merge(dev): origin/main_desktop_1 합침 — tools/est-test · stmate-test 는 dev(CODEX · 안티그래비티 워크트리 판) 채택 · 데스크탑 메인 폴더 사본 버림(두 번째)

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>

.env

@@ -89,5 +89,7 @@ AUTH_OTP_DISABLED=True
 # 대시보드 지식 챗봇(B01_Dashboard_Knowledge_Chat) NVIDIA 키
 NVIDIA_API_KEY=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
 # 노선분석 산사태위험지도(행안부 생활안전지도 WMS IF_0046 · D03_PlanAnalysis_Landslide) 키 — 비우면 겹 꺼짐
-SAFEMAP_API_KEY=
+SAFEMAP_API_KEY=MFO8CY4O-MFO8-MFO8-MFO8-MFO8CY4O6X
 DATA_GO_KR_API_KEY=0j5WZHeNxSkdPVSLXUsx9kVikXEN%2BDc%2Byv68jz8IpKFffjbZkRiQrJO78y6rxPCTqhiSOW4lDxpid0twkSVQ9g%3D%3D
+# 지오빅데이터(KIGAM) 오픈API 키 · 요구 597
+GEOBIGDATA_API_KEY=FVLh4UQc9x4bvYhXJWRITxF4v3y2ns

.gitignore

@@ -81,3 +81,5 @@ config/e03_walls_node/
 
 # graphify 결과(폐기 도구) — 추적 안 함
 graphify-out/
+# 큰 자료 시놀로지 전달용 임시 폴더(git 밖)
+/_sync_data_forest/

A00_Common/app_shell.ts

@@ -133,7 +133,7 @@ function buildBrand(): HTMLButtonElement {
  * 서랍을 열 때 서랍으로 옮기고 닫을 때 제자리(진행 판)로 — 그리기 · 누름 코드는 한 벌. */
 let drawerSteps: { node: HTMLElement; home: HTMLElement | null } | null = null;
 
-/** 집(진행 판) 없는 요소 = 서랍이 늘 가짐 · 닫을 때 안 옮김(B01 · M01 · M02 바로가기) */
+/** 집(진행 판) 없는 요소 = 서랍이 늘 가짐 · 닫을 때 안 옮김(M01 · M02 바로가기 · 기본 목록) */
 export function setDrawerSteps(node: HTMLElement | null): void {
   drawerSteps = node ? { node, home: node.parentElement } : null;
 }
@@ -178,11 +178,20 @@ function buildDrawer(header: HTMLElement): HTMLElement[] {
   const setOpen = (open: boolean): void => {
     header.classList.toggle("is-drawer-open", open);
     burger.setAttribute("aria-expanded", String(open));
+    if (open && !drawerSteps) void fillDefaultSteps();
     if (!drawerSteps) return;
-    if (open) steps.append(drawerSteps.node);
+    if (open)
+      steps.replaceChildren(drawerSteps.node); // 앞서 맡은 기본 목록이 있으면 갈아 끼움
     else if (drawerSteps.home && steps.contains(drawerSteps.node))
       drawerSteps.home.append(drawerSteps.node);
   };
+  // 진행 판 · 바로가기를 안 맡긴 쪽(772-1) = 기본 목록(🏠 대시보드 + 권한별 M01 · M02) · 늦게 온 쪽 목록이 이김
+  const fillDefaultSteps = async (): Promise<void> => {
+    const bar = await import("./m_settings_nav").then((m) => m.defaultSettingsBar());
+    if (!bar || drawerSteps || !steps.isConnected) return;
+    setDrawerSteps(bar);
+    if (header.classList.contains("is-drawer-open")) steps.replaceChildren(bar);
+  };
   burger.addEventListener("click", () => setOpen(!header.classList.contains("is-drawer-open")));
   scrim.addEventListener("click", () => setOpen(false));
   header.addEventListener("keydown", (e) => e.key === "Escape" && setOpen(false)); // ☰ 에 포커스가 있어도 닫힘
@@ -485,7 +494,7 @@ html:is([data-burger="on"], .is-bm-route) .app-burger { display: inline-flex; }
 .app-drawer__steps .ui-workflow-layout__steps.is-vertical .ui-workflow-layout__step { min-height: var(--spacing-40); margin-inline: 8px; width: auto; padding-left: 7px; }
 .app-drawer :is(.ui-btn__label, .ui-workflow-layout__step-label) { min-width: 0; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
 .app-drawer__steps .ui-workflow-layout__step--home { margin-bottom: 0; }
-html[data-touch="on"] :is(.app-drawer__nav > *, .app-drawer__site > summary, .app-drawer__steps .ui-workflow-layout__step, .app-drawer__row > *) { min-height: 44px; }
+html[data-touch="on"] :is(.app-drawer__nav > *, .app-drawer__site > summary, .app-drawer__steps .ui-workflow-layout__steps.is-vertical .ui-workflow-layout__step, .app-drawer__row > *) { min-height: 44px; }
 .app-drawer__row {
   display: flex;
   flex-wrap: wrap;

A00_Common/b_page_state.ts

@@ -186,6 +186,8 @@ export const STATE_REGISTRY = {
   "b08-milestone": { bucket: "draft", scope: "project" },
   /** D03 예정노선 노선분석 `{version: 2, network: 그은 선 · 갈래 · 조각}` — [저장] 때 plan/network 로(563-1). */
   "d03-plan": { bucket: "draft", scope: "project" },
+  /** D03 예정노선 분석 지형 원천 `"sheet" | "lidar"`(624-4 · 지형 칩) — 화면 캐시만 · 서버로 안 감. */
+  "d03-terrain": { bucket: "draft", scope: "project" },
   /** B09 원가 사용자 값 `{materials, estimate}`(고친 칸만) — [저장] 때 프로젝트 B09 폴더로(144). */
   "b09-estimation": { bucket: "draft", scope: "project" },
   /** 미저장 계획고 편집(▲▼ · 곡선반경) — 설계 가게 `alignmentDraft` 의 칸(계획서 24-2c).

A00_Common/calc_sheet.css

@@ -0,0 +1,66 @@
+/* 공용 단가산출 계산서(714-2) — 장비 · 하위 로직 한 줄 = 누르면 펼침 */
+[data-sheet-equip] {
+  cursor: pointer;
+  border-radius: var(--radius-sm);
+}
+
+[data-sheet-equip]:hover,
+[data-sheet-equip]:focus-visible {
+  background: var(--color-hover);
+}
+
+[data-sheet-part] .ui-calc-row__label {
+  padding-left: var(--spacing-16);
+}
+
+p[data-sheet-part] {
+  margin: 0;
+  padding-left: var(--spacing-16);
+}
+
+/* 737-1 옵션 칸 격자 — 상자 폭 따라 1 → 2 → 3 → 4 → 6 열(300 · 450 · 600 · 900) · 칸마다 이름 위 · 고르기 아래 */
+.calc-sheet__opts {
+  container-type: inline-size;
+}
+
+.calc-sheet__opts-grid {
+  display: grid;
+  grid-template-columns: minmax(0, 1fr);
+  gap: var(--spacing-8);
+}
+
+@container (min-width: 300px) {
+  .calc-sheet__opts-grid {
+    grid-template-columns: repeat(2, minmax(0, 1fr));
+  }
+}
+
+@container (min-width: 450px) {
+  .calc-sheet__opts-grid {
+    grid-template-columns: repeat(3, minmax(0, 1fr));
+  }
+}
+
+@container (min-width: 600px) {
+  .calc-sheet__opts-grid {
+    grid-template-columns: repeat(4, minmax(0, 1fr));
+  }
+}
+
+@container (min-width: 900px) {
+  .calc-sheet__opts-grid {
+    grid-template-columns: repeat(6, minmax(0, 1fr));
+  }
+}
+
+.calc-sheet__opts-grid > .ui-calc-row {
+  grid-template-columns: minmax(0, 1fr);
+  align-items: stretch;
+  gap: var(--spacing-4);
+}
+
+.calc-sheet__opts-grid > .ui-calc-row > :is(.ui-calc-row__select, .ui-calc-row__in, .ui-field) {
+  grid-column: 1;
+  justify-self: stretch;
+  width: 100%;
+}

A00_Common/calc_sheet.ts

@@ -0,0 +1,302 @@
+/* =============================================================================
+ * calc_sheet.ts
+ * 공용 「단가산출 계산서」(PLAN 714-2 · 요구서 내역12 4장 5 · 6) — 704-2 M02 계산서 보기를 올린 것.
+ *   쓰는 곳 = M01 「인력·재료·경비」 보기 · M02 기준 목록 계산서 보기(704-2) · (뒤에) 일위대가 모달 · B09 단가산출근거
+ *   꼴 둘 —
+ *     비목(기본 · 704-2) = 비목 묶음마다 식 줄(이름 | 단가 × 품 | 금액) · 소계 · 맨 아래 계
+ *     묶음(`bundle`) = 인력 · 재료 · 경비(장비) · 하위 — 줄의 `묶음`(714-1 서버 덧칸) 으로 다시 묶음 ·
+ *       장비 · 하위 로직 = 한 줄(노 · 재 · 경 칸 · 합) + 누르면 펼침(그 줄의 노 · 재 · 경 식) ·
+ *       묶음 머리 = 이름 · 기준단위 · 환산 근거 · 그 묶음이 쓰는 입력 칸(`쓰는입력`) · 맨 아래 비목 소계 셋 + 계
+ *   값 = 서버 셈 그대로(묶음 소계만 서버 줄 금액의 합) · 변수 칸 바꾸면 `onInput(이름, 값)` — 부르는 쪽이 다시 셈
+ *   부품 = `ui_template_calc_row`(값 줄 · 식 줄) · 입력 · 고르기 · 글 — 날 단추 · 표 · 페이지 CSS 없음
+ * ========================================================================== */
+
+import { createCalcFormula, createCalcFormulaRow, createCalcRow } from "@ui/ui_template_calc_row";
+import { el } from "@ui/ui_template_elements";
+import { createInputField, createSelectField } from "@ui/ui_template_input";
+import { currentLanguageIndex } from "@ui/ui_template_locale";
+import { createText } from "@ui/ui_template_text";
+import { formatLineMoney, formatMoney } from "../common_util/common_util_money";
+import "./calc_sheet.css";
+
+export interface SheetLine {
+  이름: string;
+  /** 서버 값 식 「단가 * 품 = 금액」 — 「= 금액」 은 떼고 「*」 → 「×」 */
+  글: string;
+  금액: number | null;
+  /** 714-1 서버 덧칸 — 그 줄 값이 쓰는 로직 입력 · 묶음 · 장비 · 찾는 표 기준 · 환산 근거 */
+  쓰는입력?: string[];
+  묶음?: string | null;
+  장비?: boolean | null;
+  기준단위?: string | null;
+  환산근거?: string;
+  /** (753-1) 옵션으로 빠진 줄 — 그리지 않음(소계 · 쓰는 입력 칸은 그대로) */
+  옵션꺼짐?: boolean;
+  /** 714-1b 장비 줄 펼침 — 부른 기계경비 로직의 시간당 줄(조종원 · 주연료 · 잡재료비 · 기계손료) */
+  펼침?: SheetUnfold | null;
+}
+export interface SheetUnfold {
+  키: string;
+  이름: string;
+  단위: string;
+  줄: { 비목: string; 이름: string; 글: string; 금액: number | null }[];
+  계: number | null;
+}
+export interface SheetGroup {
+  비목: string;
+  소계: number | null;
+  끝수?: string;
+  줄: SheetLine[];
+}
+export interface SheetInput {
+  이름: string;
+  단위?: string;
+  고르기?: (string | number)[];
+}
+export interface SheetOptions {
+  묶음: SheetGroup[];
+  계: number | null;
+  /** 맨 아래 계 줄 이름(「계 (원/㎡)」) */
+  sumLabel: string;
+  /** 인력 · 재료 · 경비(장비) 묶음으로 다시 묶음(없으면 서버 비목 묶음 그대로 · 704-2) */
+  bundle?: boolean;
+  /** 변수 칸 — 입력 꼴 · 지금 값 · 바꾼 뒤 할 일(없으면 변수 칸 없음) · 칸 = 묶음 줄들의 `쓰는입력` */
+  inputs?: SheetInput[];
+  values?: Record<string, string>;
+  onInput?: (name: string, value: string) => void;
+}
+
+/* ── 순수 셈 ── */
+/** 값 식 → 식 칸 글 — 「268,908 * 0.12 = 32,269」 → 「268,908 × 0.12」 */
+export const sheetFormula = (text: string): string =>
+  text.replace(/ = [^=]*$/, "").replaceAll(" * ", " × ");
+
+/** 장비 · 하위 로직 한 줄 — 비목마다 몫 줄(서버 줄 그대로) · 합 */
+export interface SheetMerged {
+  이름: string;
+  몫: { 비목: string; 줄: SheetLine }[];
+  금액: number | null;
+}
+export interface SheetBundle {
+  묶음: string;
+  줄: (SheetLine | SheetMerged)[];
+  소계: number;
+  쓰는입력: string[];
+  기준단위: string[];
+  환산근거: string[];
+}
+
+const ORDER = ["인력", "재료", "경비", "하위"];
+const OF_COST: Record<string, string> = { 노무비: "인력", 재료비: "재료", 경비: "경비" };
+const add = (a: number | null, b: number | null): number | null =>
+  a === null && b === null ? null : (a ?? 0) + (b ?? 0);
+const merges = (l: SheetLine): boolean => !!l.장비 || l.묶음 === "하위";
+
+/** 비목 묶음 → 인력 · 재료 · 경비 · 하위 묶음 — 장비 · 하위 줄은 비목마다 갈린 몫을 한 줄로
+ * (같은 이름 k 번째끼리 짝 — 서버 줄 차례 = 호표 차례 · 비목마다 같은 차례) */
+export function bundleLines(groups: SheetGroup[]): SheetBundle[] {
+  const bundles = new Map<string, SheetBundle>();
+  const merged = new Map<string, SheetMerged>();
+  const take = (name: string): SheetBundle => {
+    let b = bundles.get(name);
+    if (!b) {
+      b = { 묶음: name, 줄: [], 소계: 0, 쓰는입력: [], 기준단위: [], 환산근거: [] };
+      bundles.set(name, b);
+    }
+    return b;
+  };
+  for (const g of groups) {
+    const seen = new Map<string, number>();
+    for (const line of g.줄) {
+      const b = take(line.묶음 || OF_COST[g.비목] || g.비목);
+      b.소계 += line.금액 ?? 0;
+      for (const n of line.쓰는입력 ?? []) if (!b.쓰는입력.includes(n)) b.쓰는입력.push(n);
+      if (line.기준단위 && !b.기준단위.includes(line.기준단위)) b.기준단위.push(line.기준단위);
+      if (line.환산근거 && !b.환산근거.includes(line.환산근거)) b.환산근거.push(line.환산근거);
+      if (!merges(line)) {
+        b.줄.push(line);
+        continue;
+      }
+      const k = seen.get(line.이름) ?? 0;
+      seen.set(line.이름, k + 1);
+      const id = `${b.묶음}\n${line.이름}\n${k}`;
+      let m = merged.get(id);
+      if (!m) {
+        m = { 이름: line.이름, 몫: [], 금액: null };
+        merged.set(id, m);
+        b.줄.push(m);
+      }
+      m.몫.push({ 비목: g.비목, 줄: line });
+      m.금액 = add(m.금액, line.금액);
+    }
+  }
+  const rank = (x: string): number => (ORDER.includes(x) ? ORDER.indexOf(x) : ORDER.length);
+  return [...bundles.values()].sort((a, b) => rank(a.묶음) - rank(b.묶음));
+}
+/* ── 순수 셈 끝 ── */
+
+const TEXT = {
+  인력: ["인력", "Labor"],
+  재료: ["재료", "Material"],
+  경비: ["경비(장비)", "Expense (equipment)"],
+  하위: ["하위 로직", "Sub logic"],
+  Basis: ["기준", "Basis"],
+  Short: ["노 {a} · 재 {b} · 경 {c}", "L {a} · M {b} · E {c}"],
+  Fold: ["누르면 펼침", "Click to expand"],
+  Per: ["{n} — {v} 원/{u}", "{n} — {v} KRW/{u}"],
+} as const satisfies Record<string, readonly [string, string]>;
+const t = (k: keyof typeof TEXT): string => TEXT[k][currentLanguageIndex as 0 | 1] ?? TEXT[k][0];
+const bundleName = (b: string): string => (b in TEXT ? t(b as keyof typeof TEXT) : b);
+
+const won = (v: number | null, digits = 0): string =>
+  v === null ? "-" : digits ? formatLineMoney(v) : formatMoney(v);
+
+const out = (v: number | null, key = false, digits = 0): HTMLElement =>
+  el("span", { className: `ui-calc-row__out${key ? " is-key" : ""}`, text: won(v, digits) });
+
+const lineRow = (line: SheetLine, label = line.이름): HTMLElement =>
+  createCalcFormulaRow(label, createCalcFormula(sheetFormula(line.글)), out(line.금액, false, 1));
+
+/** 변수 칸 하나 — 고르기 있으면 고르기(값 없으면 빈 첫 칸) · 아니면 글 칸(Enter · 떠남 때 넘김) ·
+ *  722-1 공용 단가산출 상세 박스 옵션도 씀 */
+export function varRow(spec: SheetInput, value: string, onInput: (v: string) => void): HTMLElement {
+  let control: HTMLElement;
+  if (spec.고르기?.length) {
+    control = createSelectField({
+      options: [...(value ? [] : [""]), ...spec.고르기.map(String)].map((o) => ({
+        value: o,
+        text: o,
+      })),
+      value,
+      compact: true,
+      ariaLabel: spec.이름,
+      onChange: onInput,
+    }).root;
+  } else {
+    const box = createInputField({ value, compact: true });
+    box.input.setAttribute("aria-label", spec.이름);
+    box.input.addEventListener("change", () => {
+      if (box.input.value.trim() && box.input.value !== value) onInput(box.input.value.trim());
+    });
+    control = box.root;
+  }
+  const row = createCalcRow(spec.단위 ? `${spec.이름} (${spec.단위})` : spec.이름, control);
+  row.dataset.sheetVar = spec.이름;
+  return row;
+}
+
+/** 옵션 칸들 한 덩이(737-1) — 상자 폭 따라 6 → 4 → 3 → 2 → 1 열 격자(`calc_sheet.css`) · 없으면 빈 목록 */
+export const optionGrid = (rows: HTMLElement[]): HTMLElement[] =>
+  rows.length
+    ? [
+        el("div", {
+          className: "calc-sheet__opts",
+          children: [el("div", { className: "calc-sheet__opts-grid", children: rows })],
+        }),
+      ]
+    : [];
+
+/** 장비 · 하위 한 줄 — 노 · 재 · 경 칸 + 합 · 누르면(Enter · Space) 몫 식 줄 펼침 */
+function mergedRows(m: SheetMerged): HTMLElement[] {
+  const share = (cost: string): number | null =>
+    m.몫.filter((x) => x.비목 === cost).reduce<number | null>((s, x) => add(s, x.줄.금액), null);
+  const short = t("Short")
+    .replace("{a}", won(share("노무비"), 1))
+    .replace("{b}", won(share("재료비"), 1))
+    .replace("{c}", won(share("경비"), 1));
+  const head = createCalcFormulaRow(`▸ ${m.이름}`, createCalcFormula(short), out(m.금액, false, 1));
+  // 펼침 = 부른 기계경비 로직 시간당 줄(손료 · 주연료 · 잡품 · 운전사 · 714-1b) → 이 줄 노 · 재 · 경 몫 식
+  const unfold = m.몫.find((x) => x.줄.펼침)?.줄.펼침;
+  const parts = [
+    ...(unfold
+      ? [
+          createText(
+            t("Per")
+              .replace("{n}", unfold.이름)
+              .replace("{v}", won(unfold.계, 1))
+              .replace("{u}", unfold.단위 || "-"),
+            "hint",
+          ),
+          ...unfold.줄.map((x) => lineRow(x, `${x.이름} (${x.비목})`)),
+        ]
+      : []),
+    ...m.몫.map((x) => lineRow(x.줄, `${x.비목}`)),
+  ];
+  for (const p of parts) {
+    p.hidden = true;
+    p.dataset.sheetPart = m.이름;
+  }
+  head.dataset.sheetEquip = m.이름;
+  head.title = t("Fold");
+  head.tabIndex = 0;
+  head.setAttribute("role", "button");
+  head.setAttribute("aria-expanded", "false");
+  const label = head.firstElementChild as HTMLElement;
+  const toggle = (): void => {
+    const open = head.getAttribute("aria-expanded") !== "true";
+    head.setAttribute("aria-expanded", String(open));
+    label.textContent = `${open ? "▾" : "▸"} ${m.이름}`;
+    parts.forEach((p) => (p.hidden = !open));
+  };
+  head.addEventListener("click", toggle);
+  head.addEventListener("keydown", (ev) => {
+    if (ev.key !== "Enter" && ev.key !== " ") return;
+    ev.preventDefault();
+    toggle();
+  });
+  return [head, ...parts];
+}
+
+/** 묶음 머리 — 이름 · 기준 · 환산 근거 · 쓰는 입력 칸 */
+function headRows(
+  name: string,
+  uses: string[],
+  o: SheetOptions,
+  specs: Map<string, SheetInput>,
+  basis: string[] = [],
+  notes: string[] = [],
+): HTMLElement[] {
+  const vars = o.onInput ? uses.filter((n) => specs.has(n)) : [];
+  if (!vars.length && !o.bundle) return [];
+  const title = [name, basis.length ? `${t("Basis")} ${basis.join(" · ")}` : ""].filter(Boolean);
+  const head = createText(title.join(" — "), "muted", 14);
+  head.dataset.sheetHead = name;
+  const rows: HTMLElement[] = [head];
+  if (notes.length) rows.push(createText(notes.join(" · "), "hint"));
+  const onInput = o.onInput;
+  if (onInput)
+    for (const n of vars)
+      rows.push(varRow(specs.get(n)!, o.values?.[n] ?? "", (v) => onInput(n, v)));
+  return rows;
+}
+
+const subtotal = (g: SheetGroup): HTMLElement =>
+  createCalcFormulaRow(`${g.비목}${g.끝수 ? ` (${g.끝수})` : ""}`, null, out(g.소계, true));
+
+/** 옵션으로 빠진 줄(753-1)은 안 그림 — 장비 · 하위 몫 줄은 몫이 다 빠졌을 때만 */
+const shown = (l: SheetLine | SheetMerged): boolean =>
+  "몫" in l ? l.몫.some((x) => !x.줄.옵션꺼짐) : !l.옵션꺼짐;
+
+/** 계산서 줄들 — 부르는 쪽 세로 칸(flex column)에 그대로 붙임 */
+export function calcSheetRows(o: SheetOptions): HTMLElement[] {
+  const rows: HTMLElement[] = [];
+  const specs = new Map((o.inputs ?? []).map((s) => [s.이름, s]));
+  if (o.bundle) {
+    for (const b of bundleLines(o.묶음)) {
+      const name = bundleName(b.묶음);
+      rows.push(...headRows(name, b.쓰는입력, o, specs, b.기준단위, b.환산근거));
+      for (const line of b.줄.filter(shown))
+        rows.push(...("몫" in line ? mergedRows(line) : [lineRow(line)]));
+      rows.push(createCalcFormulaRow(name, null, out(b.소계, true, 1)));
+    }
+    rows.push(...o.묶음.map(subtotal)); // 맨 아래 비목 소계(서버 끝수 그대로) — 장비 노무는 여기서 인력 노무와 더해짐
+  } else {
+    for (const g of o.묶음) {
+      const uses = [...new Set(g.줄.flatMap((l) => l.쓰는입력 ?? []))];
+      rows.push(...headRows(g.비목, uses, o, specs));
+      rows.push(...g.줄.filter(shown).map((line) => lineRow(line)), subtotal(g));
+    }
+  }
+  rows.push(createCalcFormulaRow(o.sumLabel, null, out(o.계, true)));
+  return rows;
+}

A00_Common/design/design_save.ts

@@ -52,6 +52,22 @@ import { designSignature, markDesignClean } from "./design_leave";
 import { routeGradeTouch } from "./design_pipeline_page";
 import type { GradeTouch } from "../../B05_Profile/logic/B05_Profile_Pipeline_Grade";
 
+/** [저장] · [확정] 막음(755-3) — 글을 돌려주면 알림하고 안 냄 · `root` 가 화면에서 빠지면 풂. */
+const saveHolds: Array<{ root: HTMLElement; hold: () => string | null }> = [];
+export function holdDesignSave(root: HTMLElement, hold: () => string | null): void {
+  saveHolds.push({ root, hold });
+}
+function heldSave(): string | null {
+  for (let index = saveHolds.length - 1; index >= 0; index -= 1) {
+    if (!saveHolds[index].root.isConnected) saveHolds.splice(index, 1);
+  }
+  for (const { hold } of saveHolds) {
+    const why = hold();
+    if (why) return why;
+  }
+  return null;
+}
+
 export interface DesignSaveContext {
   projectId: string;
   routeId: () => number | null;
@@ -249,6 +265,8 @@ export async function saveDesign(
   const confirm = options.confirm ?? false;
   const routeId = ctx.routeId();
   if (routeId === null) return false;
+  const held = heldSave();
+  if (held) return (showToast(held, "warning"), false);
   saving.add(ctx.projectId);
   let locked = confirm;
   if (locked) showLoadingOverlay();

A00_Common/design/design_view_profile.ts

@@ -546,7 +546,6 @@ export async function mountProfileView(
       contourIntervalM: latestResponse.surface_params.contour_interval_m,
       smooth: latestResponse.surface_params.smooth,
       tools: [view3d.modal.button],
-      recommend: panel.recommend,
       // 계산 묶음(346-1) — 페이지가 세운 다리(365-1) · 노선을 고칠 때마다 종단이 따라옴(미리보기 · [저장]이 정본).
       draft: routeDraftBridge(activeProjectId, profilePanel),
     });

A00_Common/design/design_view_profile_3d_modal.ts

@@ -74,10 +74,7 @@ export function createViewer3dModal(deps: Viewer3dModalDeps) {
   }
 
   // 평면 도구줄 아이콘 단추(568-2) — 클래스는 가이드 촬영이 잡음.
-  const button = mapToolButton("view3d", {
-    title: "3D 화면을 큰 창으로 엽니다 — 닫으면 그리기를 멈춥니다",
-    onClick: open,
-  });
+  const button = mapToolButton("view3d", { onClick: open }); // 마우스 글 = 공용 표(634-2)
   button.classList.add("b05-route__3d-open");
 
   return {

A00_Common/design/logic/design_pipeline_types.ts

@@ -76,6 +76,8 @@ export interface RouteDraft {
   stationSnapStep?: number | null;
   /** 분석 지형(`las` · `sheet` · null = 확정 지표면) — ground 단계가 고를 격자. */
   terrain: string | null;
+  /** 고친 예정노선(626-3 · B05 평면 그리기) — 없음 · null = 그대로 · [] = 지움 · 점 묶음 = [저장] 때 `expected_route_edit.csv`. */
+  expected?: Vertex[] | null;
 }
 
 /** 묶음이 받는 입력 다섯. 없으면 null(= 저장분 그대로). cross · pipes · structures 모양은 주인 몫. */

A00_Common/formula_doc_copy.ts

@@ -0,0 +1,89 @@
+/* =============================================================================
+ * formula_doc_copy.ts
+ * 수식 문서 사본 몫(PLAN 802-4b-2 · 요구 655-2 · 656 · 659-3) — M02 단가산출(SK) 수식 탭 머리
+ *   「M01 새 판 있음」 배지(값 줄 · 부름 문서가 지금 M01 과 다름) · [단가 갱신](자원 단가만 · 식 그대로) ·
+ *   [재생성](지금 M01 문서로 다시 찍음 · 버리는 것 알림) — 누를 때만(자동 갱신 없음)
+ *   흐름 = 미리 셈(`{길}/preview` {할일}) → 확인 창(계 전 → 후 · 바뀐 자원 · 버리는 것) → 저장(`{길}/save` {할일, 판})
+ *   층 쓰기 권한 없으면 「읽기만」 배지
+ * ========================================================================== */
+
+import { createBadge } from "@ui/ui_template_badge";
+import { createButton } from "@ui/ui_template_button";
+import { eqText } from "@ui/ui_template_equation";
+import { showConfirmDialog } from "@ui/ui_template_elements";
+import { ft } from "./formula_doc_text";
+
+export type CopyJob = "단가갱신" | "재생성";
+
+/** 사본 표지(서버 `M02_Doc_Copy.state` + 시점 · 따로) */
+export interface CopyMark {
+  M01새판?: boolean;
+  지운키?: string[];
+  단가새값?: boolean;
+  문서새판?: string[];
+  따로?: boolean;
+}
+
+export interface CopyOptions {
+  /** SK 키 · 꼬리(`""` · `/preview` · `/table?key=…`) → 길(`/m02/layers/{층}/sangeun/{키}/doc…` · 주인 물음) */
+  route: (key: string, path: string) => string;
+  /** 저장 뒤 그 SK 새 판(페이지 [저장] 409 막음) */
+  onSaved?: (version: string) => void;
+}
+
+type Money = Record<string, number | null> | null;
+
+export interface JobReply {
+  전?: Money;
+  후?: Money;
+  바뀐자원?: unknown[];
+  버림?: { 문서고침?: boolean; 끊음?: string[] };
+}
+
+/** 「M01 새 판 있음」 — 값 줄 · 단가 · 부름 문서 어느 하나라도 지금 M01 과 다름 */
+export function isStale(m: CopyMark | undefined): boolean {
+  return !!m && (!!m.M01새판 || !!m.단가새값 || !!m.지운키?.length || !!m.문서새판?.length);
+}
+
+export function copyBadges(m: CopyMark | undefined, edit: boolean): HTMLElement[] {
+  const out: HTMLElement[] = [];
+  if (isStale(m)) {
+    const b = createBadge(ft("New_M01"), "danger");
+    b.dataset.copyStale = "";
+    out.push(b);
+  }
+  if (!edit) out.push(createBadge(ft("Read_Only"), "neutral"));
+  return out;
+}
+
+export function copyTools(edit: boolean, run: (job: CopyJob) => void): HTMLElement[] {
+  if (!edit) return [];
+  return (["단가갱신", "재생성"] as const).map((job) => {
+    const b = createButton({
+      label: job === "단가갱신" ? ft("Price") : ft("Regen"),
+      variant: "ghost",
+      size: 28,
+      onClick: () => run(job),
+    });
+    b.dataset.copyJob = job;
+    return b;
+  });
+}
+
+const sum = (m: Money | undefined): string =>
+  typeof m?.계 === "number" ? `${eqText(m.계)} 원` : "—";
+
+/** 할일 알림 — 계 전 → 후 · 바뀐 자원 수 · 재생성이 버리는 것(이름) → 확인이면 true */
+export function askJob(job: CopyJob, got: JobReply, names: Map<string, string>): Promise<boolean> {
+  const bits = [
+    job === "단가갱신" ? ft("Price_Ask") : ft("Regen_Ask"),
+    `${ft("Before_After")} ${sum(got.전)} → ${sum(got.후)}`,
+  ];
+  if (job === "단가갱신") bits.push(`${ft("Changed")} ${got.바뀐자원?.length ?? 0}`);
+  const lost = [
+    ...(got.버림?.문서고침 ? [ft("Regen_Edit")] : []),
+    ...(got.버림?.끊음 ?? []).map((k) => `${ft("Cut")} ${names.get(k) || k}`),
+  ];
+  if (job === "재생성" && lost.length) bits.push(`${ft("Regen_Lost")} — ${lost.join(" · ")}`);
+  return showConfirmDialog(bits.join(" · "), job === "단가갱신" ? ft("Price") : ft("Regen"));
+}

A00_Common/formula_doc_foot.ts

@@ -0,0 +1,20 @@
+/* =============================================================================
+ * formula_doc_foot.ts
+ * 수식 탭 맨 아래 합계 상자(PLAN 803-2a · 요구 667-2) — 단가산출 상세 탭과 같은 부품(`buildFoot` · 노무비 · 재료비 · 경비 · 계)
+ *   값 = 계산기 셈 그대로(여기서 다시 셈 안 함) · 셈 못 함 = 「—」
+ * ========================================================================== */
+
+import type { DocAnswer } from "../common_util/common_util_formula_doc_calc";
+import { buildFoot } from "../M01_MasterData/M01_MasterData_UI_LogicLab_Foot";
+import "../M01_MasterData/M01_MasterData_UI_LogicLab_Style.css";
+
+const num = (v: unknown): number => (typeof v === "number" && Number.isFinite(v) ? v : 0);
+
+export function docFoot(a: DocAnswer): HTMLElement {
+  const done = !!a.셈됨 && typeof a.계 === "number";
+  return buildFoot(
+    { labor: num(a.노무비), material: num(a.재료비), cost: num(a.경비) },
+    done,
+    num(a.계),
+  );
+}

A00_Common/formula_doc_options.ts

@@ -0,0 +1,55 @@
+/* =============================================================================
+ * formula_doc_options.ts
+ * 수식 문서 옵션 가로(PLAN 802-3 · 802-4b-2 · 요구 655 「옵션 선택은 상단에 수평」) — 선택 · 입력 기호마다 칸 하나
+ *   값 = 화면 값(`given`) › 문서 값 · 고침은 부른 쪽 `set`(M01 = 화면 값만 · M02 사본 = 문서 값) · `lock` = 읽기만
+ * ========================================================================== */
+
+import { createInputField, createSelectField } from "@ui/ui_template_input";
+import { varId, type DocVar, type FormulaDoc } from "../common_util/common_util_formula_doc";
+
+export function buildOptions(
+  doc: FormulaDoc | null,
+  given: Record<string, unknown>,
+  lock: boolean,
+  set: (key: string, v: DocVar, value: unknown) => void,
+): HTMLElement[] {
+  const out: HTMLElement[] = [];
+  for (const v of doc?.변수 ?? []) {
+    const kind = v.연결?.갈래;
+    const k = v.열쇠;
+    if (!k || (kind !== "선택" && kind !== "입력")) continue;
+    const label = v.이름 || varId(v);
+    const now = k in given ? given[k] : v.연결?.값;
+    if (kind === "선택") {
+      const list = (v.연결?.목록 ?? []).map(String);
+      const f = createSelectField({
+        label,
+        options: list.map((x) => ({ value: x, text: x })),
+        value: String(now ?? ""),
+        compact: true,
+        size: 28,
+        disabled: lock,
+        onChange: (x) => set(k, v, x),
+      });
+      f.root.dataset.option = k;
+      out.push(f.root);
+    } else {
+      const f = createInputField({
+        label,
+        value: now === undefined || now === null ? "" : String(now),
+        compact: true,
+        size: 28,
+        unit: v.단위 || undefined,
+      });
+      f.input.disabled = lock;
+      f.input.addEventListener("change", () => {
+        const t = f.input.value.trim();
+        const n = Number(t.replace(/,/g, ""));
+        set(k, v, t !== "" && Number.isFinite(n) ? n : t);
+      });
+      f.root.dataset.option = k;
+      out.push(f.root);
+    }
+  }
+  return out;
+}

A00_Common/formula_doc_render.ts

@@ -0,0 +1,82 @@
+/* =============================================================================
+ * formula_doc_render.ts
+ * 수식 문서 닿는 기호(PLAN 802-3 · 804-6) — 줄 쌓기 산출근거(`line_stack_out.ts`)가 씀
+ *   reach = 지금 탄 갈래로 닿는 기호(만약 안 탄 갈래 · 숨김 자리 인자 빼고)
+ *   옛 수식 문서 탭의 조판 그림(renderNode · 값 식 · 수 바꿈)은 804-6 에 걷음
+ * ========================================================================== */
+
+import {
+  linkNames,
+  varId,
+  type FormulaDoc,
+  type Node,
+} from "../common_util/common_util_formula_doc";
+import {
+  offLine,
+  takenOf,
+  tryParse,
+  type Values,
+} from "../common_util/common_util_formula_doc_view";
+
+/** 탄 갈래로 부르는 이름(만약 안 탄 갈래 · 숨김 자리 인자 빼고) */
+function namesTaken(n: Node, vals: Values, out: string[] = []): string[] {
+  const add = (x: string): void => {
+    if (!out.includes(x)) out.push(x);
+  };
+  switch (n[0]) {
+    case "var":
+      add(n[1]);
+      break;
+    case "bin":
+      namesTaken(n[2], vals, out);
+      namesTaken(n[3], vals, out);
+      break;
+    case "neg":
+    case "pct":
+    case "field":
+      namesTaken(n[1], vals, out);
+      break;
+    case "call": {
+      const pick = takenOf(n, vals);
+      const items = pick ? [n[2][0], n[2][pick]] : n[2];
+      items.forEach((x) => namesTaken(x, vals, out));
+      break;
+    }
+  }
+  return out;
+}
+
+const RESERVED_MONEY = new Set(["노무비", "재료비", "경비", "번지", "단계"]);
+
+/** 정의 영역에 보일 기호 — 식 줄 · 금액 줄 · 결과에서 지금 탄 갈래로 닿는 것(보이는 차례) */
+export function reach(doc: FormulaDoc, vals: Values, showOff = false): string[] {
+  const vars = new Map((doc.변수 ?? []).map((v) => [varId(v), v]));
+  const lines = new Map((doc.식 ?? []).map((l) => [String(l.기호 ?? ""), l.식]));
+  const money = new Set((doc.금액 ?? []).map((l) => String(l.기호 ?? "")).filter(Boolean));
+  const out: string[] = [];
+  const visit = (name: string): void => {
+    if (!name || out.includes(name) || RESERVED_MONEY.has(name) || money.has(name)) return;
+    out.push(name);
+    if (lines.has(name)) {
+      const n = tryParse(lines.get(name));
+      if (n) namesTaken(n, vals).forEach(visit);
+    }
+    const v = vars.get(name);
+    if (v?.연결 && v.연결.갈래 !== "식") linkNames(v.연결).forEach(visit);
+  };
+  const from = (text: unknown): void => {
+    const n = tryParse(text);
+    if (n) namesTaken(n, vals).forEach(visit);
+  };
+  for (const l of doc.식 ?? []) {
+    visit(String(l.기호 ?? ""));
+    from(l.식);
+  }
+  for (const l of doc.금액 ?? []) {
+    if (!showOff && offLine(l, vals, lines)) continue;
+    from(l.수량);
+    from(l.단가);
+  }
+  if (doc.결과) visit(String(doc.결과));
+  return out;
+}

A00_Common/formula_doc_text.ts

@@ -0,0 +1,96 @@
+/* =============================================================================
+ * formula_doc_text.ts
+ * 수식 문서 화면 글(PLAN 802-3 · 803-2a) — [국문, 영문]
+ * ========================================================================== */
+
+import { currentLanguageIndex } from "@ui/ui_template_locale";
+
+const TEXT = {
+  Sym_Head: ["기호 식", "Symbol equation"],
+  Val_Head: ["값 식", "Value equation"],
+  Defs_Head: ["기호 정의", "Symbols"],
+  New_Group: ["새 묶음", "New group"],
+  Unnamed: ["이름 없음", "Unnamed"],
+  Subtotal: ["소계", "Subtotal"],
+  Sum: ["계", "Sum"],
+  Total: ["합계", "Total"],
+  Need: ["정의 필요", "Needs definition"],
+  Unused: ["쓰지 않는 기호", "Unused symbols"],
+  Show_Off: ["꺼진 줄 보기", "Show off lines"],
+  Hide_Off: ["꺼진 줄 숨김", "Hide off lines"],
+  Save: ["수식 저장", "Save equation"],
+  Discard: ["고침 버림", "Discard"],
+  Saved: ["수식 저장됨", "Equation saved"],
+  Save_Failed: ["저장 못 함", "Save failed"],
+  Load_Failed: ["수식 문서를 못 읽음", "Failed to load"],
+  Leave: ["저장 안 한 수식 고침이 있음 — 버리고 나갈까요?", "Discard unsaved edits?"],
+  Leave_Ok: ["버리고 나감", "Discard"],
+  Result: ["결과", "Result"],
+  Result_Sym: ["결과 기호", "Result symbol"],
+  Dirty: ["저장 안 한 고침", "Unsaved edits"],
+  Sign: ["기호", "Symbol"],
+  Low: ["아래첨자", "Subscript"],
+  Up: ["위첨자", "Superscript"],
+  Name: ["국문 이름", "Name"],
+  Unit: ["단위", "Unit"],
+  Link: ["연결", "Link"],
+  Drop_Var: ["정의 지움", "Delete definition"],
+  Value: ["값", "Value"],
+  List: ["목록(· 로 나눔)", "Options (· separated)"],
+  Default: ["기본", "Default"],
+  Low_Bound: ["아래 끝", "Min"],
+  High_Bound: ["위 끝", "Max"],
+  Find: ["찾기", "Search"],
+  Column: ["칸", "Column"],
+  Cond: ["조건", "Condition"],
+  Inputs: ["넘길 입력", "Inputs"],
+  Region: ["지역 기호", "Region symbol"],
+  Make_Line: ["식 줄 만들기", "Add line"],
+  By_Line: ["식 줄로 정의", "Defined by a line"],
+  Pick_First: ["찾아 고름", "Search and pick"],
+  Material: ["재료 고르기", "Material pick"],
+  None: ["없음", "None"],
+  Open_Sub: ["식 펼침", "Show equation"],
+  Bad_Sign: ["기호 꼴 아님 · 같은 기호 있음", "Bad or duplicate symbol"],
+  More: ["더 있음 — 찾는 말을 더 넣으세요", "More — refine search"],
+  Nothing: ["찾은 것 없음", "Nothing found"],
+  Linked: ["연결", "Linked"],
+  Cut: ["끊음", "Unlinked"],
+  Unlink: ["연결 끊기", "Unlink"],
+  Relink: ["다시 잇기", "Relink"],
+  Ask_Relink: [
+    "이 기초에서 고친 것을 버리고 부르던 문서로 돌아감",
+    "Discard edits to this basis and follow the copy again",
+  ],
+  New_M01: ["M01 새 판 있음", "New M01 version"],
+  Price: ["단가 갱신", "Refresh prices"],
+  Regen: ["재생성", "Regenerate"],
+  Price_Ask: ["자원 단가만 지금 M01 값으로 — 식 · 연결 그대로", "Prices only — equation unchanged"],
+  Regen_Ask: ["지금 M01 수식 문서로 다시 찍음", "Re-copy from the current M01 equation"],
+  Regen_Lost: ["버리는 것", "Discarded"],
+  Regen_Edit: ["수식 고침", "Equation edits"],
+  Changed: ["바뀐 자원", "Changed resources"],
+  Before_After: ["계", "Sum"],
+  Job_Done: ["적용함", "Applied"],
+  Dirty_First: [
+    "저장 안 한 고침이 있음 — [저장] 또는 [되돌림] 먼저",
+    "Save or discard edits first",
+  ],
+  No_Key: [
+    "저장한 단가산출만 수식 문서를 엶 — [단가산출 상세] 탭",
+    "Saved items only — use the detail tab",
+  ],
+  Read_Only: ["읽기만", "Read only"],
+  Tools: ["수식 도구", "Equation tools"],
+  Tool_Frac: ["분수", "Fraction"],
+  Tool_Sub: ["아래첨자", "Subscript"],
+  Tool_Sup: ["위첨자", "Superscript"],
+  Tool_Paren: ["( )", "( )"],
+  Tool_If: ["만약", "If"],
+  Tool_Round: ["반올림", "Round"],
+  Tool_Group: ["묶음", "Group"],
+} as const;
+
+export type TextKey = keyof typeof TEXT;
+
+export const ft = (key: TextKey): string => TEXT[key][currentLanguageIndex === 1 ? 1 : 0];

A00_Common/key_registry.ts

@@ -138,6 +138,8 @@ export const KEY_ACTIONS: readonly KeyAction[] = [
   A("plan.redo", "plan", ["Ctrl+Shift+Z", "Ctrl+Y"], ["다시", "Redo"]),
   A("plan.drawFinish", "plan", ["Enter"], ["그리기 끝", "Finish drawing"]),
   A("plan.drawBack", "plan", ["Backspace"], ["그리기 마지막 점 빼기", "Drawing: remove last point"]),
+  A("plan.drawKind", "plan", ["Tab"], ["긋는 중 방식 자유지정 ↔ 길이·기울기 고정", "Drawing: free ↔ length + slope"]),
+  A("plan.drawBetween", "plan", ["Shift 누른 채"], ["길이·기울기 고정 긋는 중 부채꼴 사이 기울기 자리(길이 그대로)", "Drawing: pick between-slope on fan (length kept)"], F),
   A("plan.delete", "plan", ["Delete"], ["고른 노드 · 선 · 구역 · 전체 · 마커 지움", "Delete picked node · segment · region · all · marker"]),
   A("plan.escape", "plan", ["Escape"], ["그리기 취소 · 고름 풀기 · 재기 끝", "Cancel drawing · clear selection · end measure"], F),
   A("plan.zoom", "plan", ["휠"], ["커서 자리 확대 · 축소", "Zoom at cursor"], F),

A00_Common/line_stack.css

@@ -0,0 +1,397 @@
+/* 줄 쌓기 탭(804-2) — 위 옵션 · 가운데 왼쪽 편집 | 오른쪽 산출근거 · 맨 아래 합계 상자 · 색은 공통 값만 */
+.lstk {
+  display: flex;
+  flex-direction: column;
+  gap: var(--spacing-12);
+  min-width: 0;
+  container-type: inline-size;
+}
+
+.lstk__head {
+  display: flex;
+  flex-direction: column;
+  gap: var(--spacing-8);
+}
+
+.lstk__bar,
+.lstk__badges,
+.lstk__tools {
+  display: flex;
+  flex-wrap: wrap;
+  align-items: center;
+  justify-content: space-between;
+  gap: var(--spacing-8);
+}
+
+.lstk__areas {
+  display: grid;
+  grid-template-columns: minmax(0, 5fr) minmax(0, 6fr);
+  gap: var(--spacing-12);
+  align-items: start;
+}
+
+.lstk:not([data-edit="1"]) .lstk__areas {
+  grid-template-columns: minmax(0, 1fr);
+}
+
+.lstk:not([data-edit="1"]) .lstk__left {
+  display: none;
+}
+
+/* 합계 상자(요구 687-3) — 스크롤해도 화면 아래 고정 */
+.lstk__foot {
+  position: sticky;
+  inset-block-end: 0;
+  z-index: 2;
+  padding-block: var(--spacing-8);
+  background: var(--color-surface);
+  border-block-start: 1px solid var(--color-border);
+}
+
+.lstk__foot:empty {
+  display: none;
+}
+
+/* 산출근거(요구 683) — 왼쪽을 내려도 화면에 고정 · 길면 자기 스크롤(높이 = 스크롤 영역 − 합계 상자 · fit()) */
+.lstk[data-edit="1"] .lstk__right {
+  position: sticky;
+  inset-block-start: 0;
+  max-height: var(--lstk-view, 100vh);
+  overflow: auto;
+}
+
+/* 탭 폭이 좁으면(1366 화면 등) 편집 위 · 산출근거 아래(고정 없음) */
+@container (max-width: 1040px) {
+  .lstk__areas {
+    grid-template-columns: minmax(0, 1fr);
+  }
+
+  .lstk[data-edit="1"] .lstk__right {
+    position: static;
+    max-height: none;
+    overflow: visible;
+  }
+}
+
+/* ── 왼쪽 편집 ── */
+.lstk-edit {
+  display: flex;
+  flex-direction: column;
+  gap: var(--spacing-16);
+}
+
+/* 항목(804-5) — 머리 띠(바탕 · 왼쪽 굵은 띠 · 번호) · 줄 = 들여쓰기 + 왼쪽 세로 선 · 가나다 = 한 단 더 들여씀 */
+.lstk-item {
+  display: flex;
+  flex-direction: column;
+  gap: var(--spacing-8);
+}
+
+.lstk-item.is-sub {
+  margin-inline-start: var(--spacing-24);
+}
+
+.lstk-item + .lstk-item.is-sub {
+  margin-block-start: calc(-1 * var(--spacing-8));
+}
+
+/* 그룹 머리 한 줄(요구 687-6 · 688) — 이름 칸이 늘고 줄어 [+] · X 는 늘 오른쪽 끝(접어도 그대로) */
+.lstk-ihead {
+  flex-wrap: nowrap;
+  align-items: center;
+  padding: var(--spacing-4) var(--spacing-8);
+  border-inline-start: 4px solid var(--color-accent);
+  border-radius: var(--radius-sm);
+  background: var(--color-surface-sunken);
+}
+
+.lstk-item.is-sub > .lstk-ihead {
+  border-inline-start-color: var(--color-border-strong);
+}
+
+.lstk-ihead > .lstk-f-l {
+  flex: 1 1 auto;
+  min-width: 4em;
+}
+
+.lstk-count {
+  flex: none;
+  white-space: nowrap;
+}
+
+.lstk-no {
+  flex: none;
+  min-width: 1.5em;
+  font-weight: var(--font-weight-bold);
+  color: var(--color-text);
+}
+
+.lstk-lines {
+  display: flex;
+  flex-direction: column;
+  gap: var(--spacing-4);
+  margin-inline-start: var(--spacing-12);
+  padding-inline-start: var(--spacing-12);
+  border-inline-start: 2px solid var(--color-border-strong);
+}
+
+.lstk-ihead,
+.lstk-fhead,
+.lstk-frow,
+.lstk-find {
+  display: flex;
+  flex-wrap: wrap;
+  align-items: center;
+  gap: var(--spacing-4) var(--spacing-8);
+  min-width: 0;
+}
+
+.lstk-frow {
+  align-items: center;
+}
+
+/* 줄 카드 — 금액 · 글 = 한 줄(요구 687-7 · [손잡이][종류][이름][수량][단위][비목][X] · 좁으면 접힘) · 공식 = 머리 줄 + 식 줄 */
+.lstk-line {
+  display: flex;
+  flex-wrap: wrap;
+  align-items: center;
+  gap: var(--spacing-4) var(--spacing-8);
+  padding: var(--spacing-4) var(--spacing-8);
+  border: 1px solid var(--color-border);
+  border-radius: var(--radius-sm);
+  background: var(--color-surface-raised);
+}
+
+.lstk-line.k-공식 {
+  flex-direction: column;
+  flex-wrap: nowrap;
+  align-items: stretch;
+  position: relative;
+  padding-inline-start: var(--spacing-24);
+}
+
+.lstk-line > .lstk-x,
+.lstk-fhead > .lstk-x {
+  margin-inline-start: auto;
+}
+
+.lstk-line > .lstk-f-l,
+.lstk-line > .lstk-qty {
+  flex: 1 1 8em;
+  min-width: 6em;
+}
+
+.lstk-line > .lstk-f-m {
+  flex: 1 1 7em;
+  min-width: 6em;
+  width: auto;
+}
+
+.lstk-line .lstk-kind {
+  flex: none;
+  min-width: 2.5em;
+}
+
+.lstk-wide {
+  flex-basis: 100%;
+}
+
+.lstk-qty.ui-btn {
+  justify-content: flex-start;
+  max-width: 100%;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+
+.lstk-upick {
+  flex: none;
+}
+
+/* 보이는 글을 눌러 고침(요구 687-14) */
+.lstk-tap {
+  cursor: text;
+  border-radius: var(--radius-sm);
+}
+
+.lstk-tap:hover,
+.lstk-tap:focus-visible {
+  background: var(--color-surface-sunken);
+  text-decoration: underline dotted;
+}
+
+/* 끌기(804-5) — 손잡이 · 끄는 것 반투명 · 놓을 자리 = 위 · 아래 선 · 빈 항목 = 점선 */
+.lstk-grip {
+  touch-action: none;
+}
+
+.lstk-line > .lstk-grip {
+  flex: none;
+}
+
+.lstk-line.k-공식 > .lstk-grip {
+  position: absolute;
+  inset-block-start: var(--spacing-8);
+  inset-inline-start: var(--spacing-4);
+}
+
+.lstk-edit[data-dragging] {
+  cursor: grabbing;
+  user-select: none;
+}
+
+.is-dragging {
+  opacity: 0.45;
+}
+
+.lstk-line[data-drop="before"],
+.lstk-item[data-drop="before"] {
+  box-shadow: 0 -3px 0 0 var(--color-accent);
+}
+
+.lstk-line[data-drop="after"],
+.lstk-item[data-drop="after"] {
+  box-shadow: 0 3px 0 0 var(--color-accent);
+}
+
+.lstk-item[data-drop="in"] .lstk-empty {
+  outline: 2px dashed var(--color-accent);
+  outline-offset: 2px;
+}
+
+.lstk-res {
+  flex: 0 1 auto;
+  min-width: 0;
+  max-width: 100%;
+}
+
+.lstk-kind {
+  font-size: var(--text-caption);
+  font-weight: var(--font-weight-medium);
+  color: var(--color-text-secondary);
+}
+
+.lstk-fhead[data-tpl="changed"] .lstk-kind {
+  color: var(--color-accent);
+}
+
+.lstk-f-s {
+  width: 6em;
+}
+
+.lstk-f-m {
+  width: 9em;
+}
+
+.lstk-f-l {
+  flex: 1 1 12em;
+  min-width: 10em;
+}
+
+.lstk-sym {
+  font-weight: var(--font-weight-medium);
+}
+
+.lstk-val,
+.lstk-unit,
+.lstk-tag,
+.lstk-hint {
+  font-size: var(--text-body-sm);
+  color: var(--color-text-secondary);
+}
+
+.lstk-tag {
+  padding: 0 var(--spacing-4);
+  border: 1px solid var(--color-border);
+  border-radius: var(--radius-sm);
+}
+
+.lstk-empty {
+  font-size: var(--text-body-sm);
+  color: var(--color-text-muted);
+}
+
+.lstk-miss,
+.lstk-tex .lstk-miss {
+  color: var(--color-danger);
+}
+
+/* ── 오른쪽 산출근거 ── */
+.lstk-out .lstk-h {
+  display: flex;
+  flex-wrap: wrap;
+  align-items: center;
+  gap: 0 var(--spacing-4);
+  padding-inline-start: calc(var(--lstk-depth, 0) * var(--spacing-16));
+  white-space: normal;
+}
+
+.lstk-out tr.head,
+.lstk-out tr.item,
+.lstk-out tr.total {
+  font-weight: var(--font-weight-medium);
+}
+
+.lstk-out tr.subsum,
+.lstk-out tr.total {
+  background: var(--color-surface-sunken);
+}
+
+.lstk-out tr.is-sub .lstk-h {
+  color: var(--color-text-secondary);
+}
+
+/* 펼친 문서 제목 = 보통 글(링크 꼴 없음 · 요구 687-11) */
+.lstk-out tr.subhead .lstk-h {
+  font-weight: var(--font-weight-medium);
+  color: var(--color-text);
+}
+
+.lstk-ftitle {
+  cursor: pointer;
+}
+
+.lstk-gap {
+  display: inline-block;
+  width: var(--spacing-24);
+}
+
+.lstk-pack {
+  display: inline-flex;
+  align-items: center;
+  gap: var(--spacing-4);
+}
+
+.lstk-tex .katex {
+  font-size: 1.05em;
+}
+
+/* 짝 강조(679 · 684) — 왼쪽 카드 · 그룹 머리 · 오른쪽 줄 = 같은 바탕 채우기 */
+.lstk-line.is-pair,
+.lstk-item.is-pair > .lstk-ihead,
+.lstk-out tr.is-pair > td {
+  background: var(--color-accent-soft);
+}
+
+.lstk-out tr[data-loc] {
+  cursor: pointer;
+}
+
+.lstk-tpick {
+  display: flex;
+  flex-direction: column;
+  gap: var(--spacing-8);
+}
+
+/* 옵션 가로(옛 수식 문서 CSS 에서 옮김 · 804-6) */
+.fdoc__options {
+  display: flex;
+  flex-wrap: wrap;
+  gap: var(--spacing-8) var(--spacing-12);
+  align-items: flex-end;
+}
+
+.fdoc__options > * {
+  width: auto;
+  min-width: 8em;
+}

A00_Common/line_stack_drag.ts

@@ -0,0 +1,80 @@
+/* =============================================================================
+ * line_stack_drag.ts
+ * 줄 쌓기 왼쪽 끌어 옮기기(PLAN 804-5 · 요구 682-4) — 손잡이(⋮⋮)를 누르고 끌면 놓을 자리에 선 표시 · 놓으면 `drop`
+ *   줄 = 항목 안 · 항목 사이 어디든(빈 항목 = 그 안) → `k.p`(항목 k 의 p 자리) · 항목 = 항목 사이 → `p`
+ *   포인터 끌기(마우스 · 터치 같음) · Esc = 그만 · 자리 표시 = 클래스(`data-drop`)만 — 끄는 동안 배치 안 바뀜
+ * ========================================================================== */
+
+export interface DragOpts {
+  /** 끄는 것 — 줄 카드 · 항목 상자 */
+  what: "line" | "item";
+  /** 끌기 영역(`.lstk-edit`) */
+  root: HTMLElement;
+  /** 끄는 요소(반투명) */
+  self: HTMLElement;
+  /** 놓음 — line `k.p` · item `p` */
+  drop: (to: string) => void;
+}
+
+const mid = (r: DOMRect): number => r.top + r.height / 2;
+
+/** 포인터 y 의 놓을 자리 + 표시할 요소 · 꼴 */
+function spotOf(o: DragOpts, y: number): { to: string; at: HTMLElement; side: string } | null {
+  const boxes = [...o.root.querySelectorAll<HTMLElement>(":scope > .lstk-item")];
+  if (!boxes.length) return null;
+  if (o.what === "item") {
+    const k = boxes.findIndex((b) => y < mid(b.getBoundingClientRect()));
+    return k < 0
+      ? { to: String(boxes.length), at: boxes[boxes.length - 1], side: "after" }
+      : { to: String(k), at: boxes[k], side: "before" };
+  }
+  // 줄 — 포인터가 든 항목(위 · 아래 밖 = 처음 · 끝 항목)
+  let k = boxes.findIndex((b) => y < b.getBoundingClientRect().bottom);
+  if (k < 0) k = boxes.length - 1;
+  const cards = [...boxes[k].querySelectorAll<HTMLElement>(":scope .lstk-lines > .lstk-line")];
+  if (!cards.length) return { to: `${k}.0`, at: boxes[k], side: "in" };
+  const p = cards.findIndex((c) => y < mid(c.getBoundingClientRect()));
+  return p < 0
+    ? { to: `${k}.${cards.length}`, at: cards[cards.length - 1], side: "after" }
+    : { to: `${k}.${p}`, at: cards[p], side: "before" };
+}
+
+/** 손잡이에 끌기를 붙임 */
+export function attachDrag(grip: HTMLElement, o: DragOpts): void {
+  grip.addEventListener("pointerdown", (e) => {
+    if (e.button !== 0) return;
+    e.preventDefault();
+    e.stopPropagation();
+    grip.setPointerCapture(e.pointerId);
+    let spot: ReturnType<typeof spotOf> = null;
+    const clear = (): void => {
+      for (const x of o.root.querySelectorAll("[data-drop]")) x.removeAttribute("data-drop");
+    };
+    o.self.classList.add("is-dragging");
+    o.root.dataset.dragging = o.what;
+    const move = (ev: PointerEvent): void => {
+      clear();
+      spot = spotOf(o, ev.clientY);
+      if (spot) spot.at.dataset.drop = spot.side;
+    };
+    const end = (ok: boolean): void => {
+      grip.removeEventListener("pointermove", move);
+      grip.removeEventListener("pointerup", up);
+      grip.removeEventListener("pointercancel", cancel);
+      window.removeEventListener("keydown", esc);
+      clear();
+      o.self.classList.remove("is-dragging");
+      delete o.root.dataset.dragging;
+      if (ok && spot) o.drop(spot.to);
+    };
+    const up = (): void => end(true);
+    const cancel = (): void => end(false);
+    const esc = (ev: KeyboardEvent): void => {
+      if (ev.key === "Escape") end(false);
+    };
+    grip.addEventListener("pointermove", move);
+    grip.addEventListener("pointerup", up);
+    grip.addEventListener("pointercancel", cancel);
+    window.addEventListener("keydown", esc);
+  });
+}

A00_Common/line_stack_edit.ts

@@ -0,0 +1,464 @@
+/* =============================================================================
+ * line_stack_edit.ts
+ * 줄 쌓기 왼쪽 편집(PLAN 804-2 · 요구 670~677) — 항목(띠 · 번호 · 제목 · 가나다 · [+ 줄] · 접기 · X) 안 줄 카드(⋮⋮ · X)
+ *   차림(804-5 · 요구 682) = 항목 머리 띠 · 줄 = 들여쓰기 + 왼쪽 세로 선 · 순서 = 손잡이 끌기(`line_stack_drag.ts`) ·
+ *     X = 확인 없이 지우고 알림 눌러 되돌리기 한 번 · 자원 이름 = 단추(누르면 찾아 넣기 창 → 바꿈)
+ *   줄 = 인력 · 재료 · 기계 · 다른 단가산출 · 율 · 식(금액 줄 — 이름 · 단위 · 비목 · 수량 식 · 단가 고르기 또는 식)
+ *       · 공식 묶음(`line_stack_rows.ts`) · 글 줄
+ *   고침 = 부른 쪽 `change(fn)` — fn 이 문서 · 차림을 고치면 부른 쪽이 `docOf` 로 굳히고 미리 셈 · 다시 그림(입력은 change 때)
+ *   자원 고르기(804-3) = 찾아 넣기 창(`line_stack_pick.ts` — M02 [항목 추가] 창 그대로) · [+ 줄] 인력 · 재료 · 기계 · 다른 단가산출 =
+ *     고르면 줄이 생김(닫으면 안 생김) · 있는 줄 = 자원 이름 단추
+ * ========================================================================== */
+
+import { createButton, createIconButton } from "@ui/ui_template_button";
+import { createRowMenu } from "@ui/ui_template_context_menu";
+import { eqText } from "@ui/ui_template_equation";
+import { el, showToast } from "@ui/ui_template_elements";
+import { createInputField, createSelectField } from "@ui/ui_template_input";
+import { varId, type FormulaDoc, type MoneyLine } from "../common_util/common_util_formula_doc";
+import { isNum, type DocAnswer } from "../common_util/common_util_formula_doc_calc";
+import { lineMap, offLine, type Values } from "../common_util/common_util_formula_doc_view";
+import type { DocTable } from "../common_util/common_util_formula_doc_table";
+import {
+  dropSyms,
+  docOf,
+  freshId,
+  kindOf,
+  moveItem,
+  moveLine,
+  newVar,
+  ownedOf,
+  stackOf,
+  type MoneyKind,
+  type StackDoc,
+  type StackItem,
+} from "../common_util/common_util_line_stack";
+import { placeNames } from "../common_util/common_util_line_stack_copy";
+import {
+  addPicked,
+  aliasText,
+  repick,
+  shownUnit,
+  tableAlias,
+} from "../common_util/common_util_line_stack_pick";
+import { createUnitPick, NO_UNIT } from "../M02_MasterTemplete/DataFlow/M02_DF_UnitPick";
+import { reach } from "./formula_doc_render";
+import { attachDrag } from "./line_stack_drag";
+import { openStackPick, type StackTake } from "./line_stack_pick";
+import { buildBlock } from "./line_stack_rows";
+import { lt, type LsKey } from "./line_stack_text";
+
+export interface EditHooks {
+  doc: StackDoc;
+  answer: DocAnswer;
+  items: StackItem[];
+  change: (fn: (d: StackDoc, items: StackItem[]) => void) => void;
+  /** 품셈 표 하나(표 고르기 창) */
+  table: (key: string) => Promise<DocTable | null>;
+  subDoc: (key: string) => FormulaDoc | null;
+  name: (key: string) => string;
+  /** 공식 묶음 펼친 자리(`항목.줄`) — 화면 상태만 */
+  open: Set<string>;
+  /** 줄 · 항목 누름 — 오른쪽 짝 강조(679) */
+  pair: (loc: string) => void;
+  /** M02 단가산출(804-4) — 다른 단가산출 · 일위대가 = 복사해 펼침 · M01 = 없음(M01 전체만) */
+  take?: StackTake;
+}
+
+const field = (
+  label: string,
+  value: unknown,
+  set: (t: string) => void,
+  size: "s" | "m" | "l" = "m",
+): HTMLElement => {
+  const f = createInputField({
+    placeholder: label,
+    value: value === undefined || value === null ? "" : String(value),
+    compact: true,
+    size: 24,
+  });
+  f.root.classList.add(`lstk-f-${size}`);
+  f.input.setAttribute("aria-label", label);
+  f.input.title = label;
+  f.input.addEventListener("change", () => set(f.input.value));
+  return f.root;
+};
+const btn = (label: string, onClick: () => void) =>
+  createButton({ label, variant: "ghost", size: 24, onClick });
+
+const KIND_KEY: Record<MoneyKind, LsKey> = {
+  인력: "K_인력",
+  재료: "K_재료",
+  기계: "K_기계",
+  단가산출: "K_단가산출",
+  율: "K_율",
+};
+
+/** 금액 줄 몸 — 한 줄(804-7 · 요구 687-7): [종류][이름 단추 | 이름 칸 · 단가 식][수량][단위][비목] · 좁으면 접힘 */
+function moneyBody(h: EditHooks, i: number): HTMLElement[] {
+  const d = h.doc;
+  const line = (d.금액 ?? [])[i];
+  const kind = kindOf(d, i, h.subDoc);
+  const own = ownedOf(d).get(i);
+  const v = own ? d.변수?.find((x) => varId(x) === own) : undefined;
+  const put = (fn: (l: MoneyLine & { 규격?: string }) => void): void =>
+    h.change((doc) => fn(doc.금액![i]));
+  // 표 값 기호 = 화면 이름(요구 683) — 칸 글은 화면 이름 ↔ 기호로 오감
+  const alias = tableAlias(d);
+  const shown = (t: unknown): string => aliasText(String(t ?? ""), alias);
+  const real = (t: string): string => aliasText(t.trim(), alias, true);
+  const head: HTMLElement[] = [];
+  if (own && v) {
+    // 이름 단추(요구 687-9) — 누르면 찾아 넣기 창이 그 이름을 찾은 채 열림 · 고르면 바꿈
+    const link = v.연결 ?? {};
+    const mat = link.재료 as Record<string, unknown> | undefined;
+    const size = (line as { 규격?: string }).규격;
+    const name = String(line.이름 ?? "") || String(mat?.검색어 ?? mat?.이름 ?? "");
+    const res = link.키
+      ? link.갈래 === "단가산출"
+        ? (h.subDoc(link.키)?.이름 ?? h.name(link.키))
+        : h.name(link.키)
+      : "";
+    const pick = createButton({
+      label: (size && !name.includes(size) ? `${name} ${size}` : name) || "—",
+      variant: "ghost",
+      tone: "link",
+      size: 24,
+      iconStart: "search",
+      onClick: () =>
+        openStackPick(
+          kind,
+          (p) => h.change((doc) => repick(doc, i, own, kind, p)),
+          undefined,
+          String(mat?.검색어 ?? line.이름 ?? ""),
+        ),
+    });
+    pick.classList.add("lstk-res");
+    pick.title = `${lt("Repick")}${res ? ` — ${res}` : ""}`;
+    pick.dataset.repick = String(i);
+    head.push(pick);
+  } else
+    head.push(
+      field(lt("Name"), line.이름, (t) => put((l) => (l.이름 = t)), "m"),
+      field(lt("Price"), shown(line.단가), (t) => put((l) => (l.단가 = real(t))), "l"),
+    );
+  const why = (h.answer.줄?.[i] as { 까닭?: string } | undefined)?.까닭;
+  // 율 밑 번지(복사해 온 조각) — 칸 아래 읽는 이름(804-5)
+  const places = /번지\./.test(`${line.단가} ${line.수량 ?? ""}`) ? placeNames(d, h.items) : null;
+  const read = (t: unknown): string =>
+    shown(t).replace(/번지\.([^.\s()]+)\./g, (all, p: string) =>
+      places?.[p] ? `${places[p]} ` : all,
+    );
+  const unit = el("span", { className: "lstk-upick" });
+  const drawUnit = (): void =>
+    unit.replaceChildren(
+      createUnitPick({
+        value: String(line.단위 ?? "") || NO_UNIT,
+        size: 24,
+        free: true,
+        ariaLabel: lt("Unit"),
+        extra: [...new Set((d.금액 ?? []).map((m) => String(m.단위 ?? "")).filter(Boolean))],
+        onPick: (u) => put((l) => (u === NO_UNIT ? delete l.단위 : (l.단위 = u))),
+      }),
+    );
+  drawUnit();
+  return [
+    el("span", { className: "lstk-kind", text: lt(KIND_KEY[kind]) }),
+    ...head,
+    // 율 · 식 줄(자원 없음)에 수량이 없으면 칸 안 보임(한 줄 유지)
+    ...(own || String(line.수량 ?? "") ? [qtyBox(h, i, shown, real)] : []),
+    unit,
+    ...(line.비목 === "묶음"
+      ? []
+      : [
+          createSelectField({
+            options: ["노무비", "재료비", "경비"].map((x) => ({ value: x, text: x })),
+            value: line.비목 ?? "노무비",
+            compact: true,
+            size: 24,
+            ariaLabel: lt("Cost"),
+            onChange: (x) => put((l) => (l.비목 = x)),
+          }).root,
+        ]),
+    ...(places
+      ? [
+          el("div", {
+            className: "lstk-hint lstk-wide",
+            text: `= ${[line.수량, line.단가].filter(Boolean).map(read).join(" × ")}`,
+          }),
+        ]
+      : []),
+    ...(why ? [el("div", { className: "lstk-miss lstk-wide", text: why })] : []),
+  ];
+}
+
+/** 수량 — 기호 하나면 값 + 출처 꼬리표(「0.39 ← 표 · 잡석 수량」 · 요구 687-12 · 기호는 마우스 글) · 누르면 그 자리에서 식 고침 */
+function qtyBox(
+  h: EditHooks,
+  i: number,
+  shown: (t: unknown) => string,
+  real: (t: string) => string,
+): HTMLElement {
+  const line = (h.doc.금액 ?? [])[i];
+  const text = String(line.수량 ?? "");
+  const v = h.doc.변수?.find((x) => varId(x) === text);
+  const at = `qty:${i}`;
+  const edit = (): HTMLElement => {
+    const f = field(lt("Qty"), shown(text), (t) =>
+      h.change((doc) => {
+        h.open.delete(at);
+        const l = doc.금액![i];
+        if (t.trim()) l.수량 = real(t);
+        else delete l.수량;
+      }),
+    );
+    f.classList.add("lstk-qty");
+    f.dataset.qty = String(i);
+    return f;
+  };
+  if (!v || h.open.has(at)) return edit();
+  const val = (h.answer.값 ?? {})[text];
+  const link = v.연결 ?? {};
+  const kind = link.갈래 ?? "식";
+  const from =
+    v.이름 || (link.키 || link.표 ? h.name(String(link.키 ?? link.표)) : "") || shown(text);
+  const b = createButton({
+    label: `${isNum(val) ? eqText(val) : "—"}${v.단위 && shownUnit(v.단위) ? ` ${shownUnit(v.단위)}` : ""} ← ${kind} · ${from}`,
+    variant: "ghost",
+    size: 24,
+    onClick: () => {
+      h.open.add(at);
+      h.change(() => undefined);
+      requestAnimationFrame(() =>
+        document.querySelector<HTMLInputElement>(`[data-qty="${i}"] input`)?.focus(),
+      );
+    },
+  });
+  b.classList.add("lstk-qty");
+  b.title = `${lt("Qty")} = ${shown(text)}`;
+  b.dataset.qty = String(i);
+  return b;
+}
+
+/** [+ 줄] 고르개 값 → 새 줄 */
+function addLine(h: EditHooks, at: number, kind: string): void {
+  if (["인력", "재료", "기계", "단가산출"].includes(kind))
+    return openStackPick(
+      kind as MoneyKind,
+      (p) => h.change((d, items) => void addPicked(d, items[at], kind as MoneyKind, p)),
+      h.take,
+    );
+  h.change((d, items) => {
+    const it = items[at];
+    const n = (d.금액 ??= []).length;
+    const money = (line: MoneyLine): void => {
+      d.금액!.push(line);
+      it.줄.push({ 꼴: "금액", i: n });
+    };
+    if (kind === "율")
+      money({ 이름: "공구손료 및 경장비", 단위: "식", 비목: "경비", 단가: "노무비 × 3 %" });
+    else if (kind === "공식") {
+      const id = freshId(d, "x");
+      (d.변수 ??= []).push(newVar(id, { 갈래: "숫자", 값: 0 }));
+      it.줄.push({ 꼴: "공식", 기호: [id] });
+      h.open.add(`${at}.${it.줄.length - 1}`);
+    } else if (kind === "글") it.줄.push({ 꼴: "글", 글: "" });
+  });
+}
+
+/** 줄 지움 — 금액 줄은 그 줄이 가진 연결 기호까지 · 공식 묶음은 기호까지 */
+function dropLine(d: StackDoc, items: StackItem[], i: number, j: number): void {
+  const line = items[i].줄[j];
+  if (line.꼴 === "금액") {
+    const own = ownedOf(d).get(line.i);
+    if (own) dropSyms(d, [own]);
+  } else if (line.꼴 === "공식") dropSyms(d, line.기호);
+  items[i].줄.splice(j, 1);
+}
+
+export function buildEdit(h: EditHooks): HTMLElement {
+  // [+] 줄 더함 메뉴(요구 687-13 · 18) — 인력 · 재료 · 기계 · 단가산출 · 율 · 식 · 근거 글
+  const add = (at: number): HTMLElement => {
+    const kinds: [string, LsKey][] = [
+      ["인력", "K_인력"],
+      ["재료", "K_재료"],
+      ["기계", "K_기계"],
+      ["단가산출", h.take ? "K_복사" : "K_단가산출"],
+      ["율", "Add_율"],
+      ["공식", "Add_식"],
+      ["글", "K_글"],
+    ];
+    const menu = createRowMenu(
+      kinds.map(([k, label]) => ({ label: lt(label), onClick: () => addLine(h, at, k) })),
+      { icon: "plus", title: lt("Add_Line"), size: 24 },
+    );
+    menu.classList.add("lstk-add");
+    return menu;
+  };
+  // X 지움 — 확인 없이 · 알림 누르면 되돌림(그 뒤 다른 고침이 없을 때만)
+  const drop = (what: string, fn: (d: StackDoc, items: StackItem[]) => void): void => {
+    const snap = JSON.stringify(h.doc);
+    let after = "";
+    h.change((d, items) => {
+      fn(d, items);
+      after = JSON.stringify(docOf(d, items));
+    });
+    showToast(`${what || lt("K_줄")} ${lt("Dropped")}`, "info", 6000, () =>
+      h.change((d, items) => {
+        if (JSON.stringify(docOf(d, items)) !== after)
+          return void showToast(lt("Undo_Late"), "warning");
+        const back = JSON.parse(snap) as StackDoc;
+        for (const k of Object.keys(d)) delete (d as Record<string, unknown>)[k];
+        Object.assign(d, back);
+        items.splice(0, items.length, ...stackOf(back));
+      }),
+    );
+  };
+  const x = (title: string, onClick: () => void): HTMLElement => {
+    const b = createIconButton({ icon: "x", title, size: 24, onClick });
+    b.classList.add("lstk-x");
+    return b;
+  };
+  const grip = (): HTMLElement =>
+    el("span", { className: "ui-list-row__grip lstk-grip", attrs: { title: lt("Drag") } });
+  const root = el("div", { className: "lstk-edit" });
+  /** 항목 접힘 표시(화면 상태)를 항목 차례 바뀜에 맞춤 */
+  const refold = (fn: (flags: boolean[]) => void): void => {
+    const flags = h.items.map((_, k) => h.open.has(`fold:${k}`));
+    fn(flags);
+    h.items.forEach((_, k) => h.open.delete(`fold:${k}`));
+    flags.forEach((f, k) => f && h.open.add(`fold:${k}`));
+  };
+  // 항목 번호 — 산출근거와 같은 셈(제목 있는 항목 1. 2. · 옛 가나다 항목 = 가. 나. · 체크 걷음 요구 687-5)
+  let n = 0;
+  let sub = 0;
+  const nos = h.items.map((it) => {
+    if (!it.제목.trim()) return "";
+    const no = it.가나다 ? `${"가나다라마바사아자차카타파하"[sub++] ?? "?"}.` : `${++n}.`;
+    if (!it.가나다) sub = 0;
+    return no;
+  });
+  // 만약(IF) 안 탄 갈래(요구 687-10) — 갈래를 다 열면 닿고 지금 값으로는 안 닿는 기호 · 꺼진 금액 줄 = 숨김(산출근거와 같음)
+  const vals = (h.answer.값 ?? {}) as Values;
+  const taken = new Set(reach(h.doc, vals));
+  const every = new Set(reach(h.doc, {}, true));
+  const steps = lineMap(h.doc);
+  const off = (line: StackItem["줄"][number]): boolean =>
+    line.꼴 === "금액"
+      ? offLine((h.doc.금액 ?? [])[line.i] ?? {}, vals, steps)
+      : line.꼴 === "공식" &&
+        line.기호.length > 0 &&
+        line.기호.every((id) => every.has(id) && !taken.has(id));
+  const items = h.items.map((it, i) => {
+    const folded = h.open.has(`fold:${i}`);
+    const itemGrip = grip();
+    // 그룹 머리 한 줄(요구 687-6 · 688) — 손잡이 · 접기 · 번호 · 이름 · [+] · X · 접어도 자리 그대로
+    const head = el("div", {
+      className: "lstk-ihead",
+      children: [
+        itemGrip,
+        createIconButton({
+          icon: folded ? "chevronRight" : "chevronDown",
+          title: folded ? lt("Unfold_Item") : lt("Fold_Item"),
+          size: 24,
+          onClick: () => {
+            if (folded) h.open.delete(`fold:${i}`);
+            else h.open.add(`fold:${i}`);
+            h.change(() => undefined);
+          },
+        }),
+        el("b", { className: "lstk-no", text: nos[i] }),
+        field(lt("Title"), it.제목, (t) => h.change((_, items) => (items[i].제목 = t.trim())), "l"),
+        el("span", {
+          className: "lstk-hint lstk-count",
+          text: folded ? `${lt("K_줄")} ${it.줄.length}` : "",
+        }),
+        add(i),
+        x(lt("Del_Item"), () =>
+          drop(it.제목.trim() || lt("Item"), (d, items) => {
+            refold((f) => f.splice(i, 1));
+            for (let j = items[i].줄.length - 1; j >= 0; j--) dropLine(d, items, i, j);
+            items.splice(i, 1);
+          }),
+        ),
+      ],
+    });
+    const lines = it.줄.flatMap((line, j) => {
+      if (off(line)) return [];
+      const lineGrip = grip();
+      const del = x(lt("Del"), () =>
+        drop(line.꼴 === "금액" ? String(h.doc.금액?.[line.i]?.이름 ?? "") : "", (d, items) =>
+          dropLine(d, items, i, j),
+        ),
+      );
+      const body =
+        line.꼴 === "금액"
+          ? moneyBody(h, line.i)
+          : line.꼴 === "글"
+            ? [
+                el("span", { className: "lstk-kind", text: lt("K_글") }),
+                field(
+                  lt("Text_Ph"),
+                  line.글,
+                  (t) => h.change((_, items) => ((items[i].줄[j] as { 글: string }).글 = t)),
+                  "l",
+                ),
+              ]
+            : buildBlock(h, i, j, line, (id) => every.has(id) && !taken.has(id));
+      // 금액 · 글 = 한 줄(X 끝) · 공식 묶음 = 머리 줄 끝에 X
+      const card = el("div", {
+        className: `lstk-line k-${line.꼴}`,
+        children:
+          line.꼴 === "공식"
+            ? [lineGrip, ...body.slice(0, 1).map((hd) => (hd.append(del), hd)), ...body.slice(1)]
+            : [lineGrip, ...body, del],
+      });
+      card.dataset.loc = `${i}.${j}`;
+      card.addEventListener("pointerdown", () => h.pair(`${i}.${j}`));
+      attachDrag(lineGrip, {
+        what: "line",
+        root,
+        self: card,
+        drop: (to) => {
+          const [k, p] = to.split(".").map(Number);
+          h.change((_, items) => moveLine(items, i, j, k, p));
+        },
+      });
+      return [card];
+    });
+    const box = el("div", {
+      className: `lstk-item${it.가나다 ? " is-sub" : ""}${folded ? " is-folded" : ""}`,
+      attrs: { "data-loc": String(i) },
+      children: [
+        head,
+        ...(folded
+          ? []
+          : [
+              el("div", {
+                className: "lstk-lines",
+                children: lines.length
+                  ? lines
+                  : [el("div", { className: "lstk-empty", text: lt("Empty_Item") })],
+              }),
+            ]),
+      ],
+    });
+    head.addEventListener("pointerdown", () => h.pair(String(i)));
+    attachDrag(itemGrip, {
+      what: "item",
+      root,
+      self: box,
+      drop: (to) => {
+        const p = Number(to);
+        refold((f) => moveItem(f, i, p));
+        h.change((_, items) => moveItem(items, i, p));
+      },
+    });
+    return box;
+  });
+  root.append(
+    ...items,
+    btn(lt("Add_Item"), () => h.change((_, items) => items.push({ 제목: "", 줄: [] }))),
+  );
+  return root;
+}

A00_Common/line_stack_out.ts

@@ -0,0 +1,424 @@
+/* =============================================================================
+ * line_stack_out.ts
+ * 줄 쌓기 산출근거 출력(PLAN 804-2 · 요구 670-1 · 677) — 경쟁사 「단가산출」 시트 꼴 표(산출근거 · 합계 · 노무비 · 재료비 · 경비)
+ *   공식 줄 = 「기호 = 기호식 = 값식 = 결과 단위」(값만인 줄은 넷까지 한 줄) · 금액 줄 = 「이름 : 단가 × 수량 단위 = 금액」
+ *   기계 · 단가산출 줄 = 비목마다 「노무비 : 59,020 × … = 금액」 — 제목 줄(「굴착기 0.6㎥」) 누름 = 그 문서(기계 시간당 경비 등)를
+ *     같은 계산기로 셈해 같은 꼴로 펼침(손료 식 · 연료 · 운전사 · 노 · 재 · 경 · 계) · 비목 수는 글(링크 꼴 없음 · 요구 687-11) ·
+ *     공식 줄 단가산출 결과 = 수 누름(▸) · 접으면 한 줄 · 출력엔 펼친 것만
+ *   값 = 계산기 셈 답 그대로(`calcDoc` · 줄 `answer.줄` · 합 `노무비` …) — 여기서 다시 셈 안 함 · 조판 = KaTeX(`line_stack_tex.ts`)
+ * ========================================================================== */
+
+import { createButton, createIconButton } from "@ui/ui_template_button";
+import { eqText } from "@ui/ui_template_equation";
+import { el } from "@ui/ui_template_elements";
+import { tableRow, tableShell, type Column } from "@ui/ui_template_table";
+import { COSTS, varId, type FormulaDoc } from "../common_util/common_util_formula_doc";
+import { calcDoc, isNum, type DocAnswer } from "../common_util/common_util_formula_doc_calc";
+import type { DocCache } from "../common_util/common_util_formula_doc_cache";
+import {
+  lineMap,
+  moneyScope,
+  offLine,
+  type Values,
+} from "../common_util/common_util_formula_doc_view";
+import { reach } from "./formula_doc_render";
+import {
+  kindOf,
+  nodeOf,
+  priceSym,
+  stackOf,
+  subInputs,
+  type StackDoc,
+} from "../common_util/common_util_line_stack";
+import { placeNames } from "../common_util/common_util_line_stack_copy";
+import { shownUnit, stackLevels, tableAlias } from "../common_util/common_util_line_stack_pick";
+import { katexNode, symTex, tex, valTex, type TexCtx } from "./line_stack_tex";
+import { lt } from "./line_stack_text";
+
+type Cols = Partial<Record<"sum" | (typeof COSTS)[number], number>>;
+interface Row {
+  h: (string | HTMLElement)[];
+  cols?: Cols;
+  cls?: string;
+  won?: boolean;
+  depth: number;
+  /** 들여쓰기 수준(804-3) — 머리 0 · 항목 1 · 가나다 2 · 줄 = 항목 + 1 · 펼친 블록 = 그 줄 + 1 */
+  lv: number;
+  /** 왼쪽 짝 자리(679) — 항목 `k` · 줄 `k.j`(펼친 블록 = 그 줄) */
+  loc?: string;
+}
+export interface OutHooks {
+  /** 줄 누름 — 왼쪽 짝 자리(679) */
+  pair?: (loc: string) => void;
+  cache: DocCache;
+  /** 펼친 자리(`부모/기호`) */
+  open: Set<string>;
+  toggle: (at: string) => void;
+  /** 캐시에 없는 연결 — 뒤에서 서버에 물음 */
+  miss: () => void;
+}
+
+const COST_SHOW: Record<string, string> = { 노무비: "노무비", 재료비: "재료비", 경비: "경 비" };
+const won = (n: number): string => eqText(Math.round(n));
+const one = (n: number): string =>
+  n.toLocaleString("en-US", { minimumFractionDigits: 1, maximumFractionDigits: 1 });
+const MAX_DEPTH = 3;
+const LONG_SUM = 4; // 합계 덧셈 항이 이보다 많으면 항목 소계끼리(경쟁사 「노무비 : 2,523.3 + 919.5 = 3,442」)
+
+/** 식 글 → 조판(못 풀면 글) */
+function exprNode(
+  text: unknown,
+  side: "sym" | "val",
+  vals: Values,
+  inline = false,
+  cost?: string,
+  more: Partial<TexCtx> = {},
+) {
+  const n = nodeOf(text);
+  return n
+    ? katexNode(tex(n, { side, vals, inline, cost, ...more }))
+    : el("span", { text: String(text ?? "") });
+}
+const hasVar = (text: unknown): boolean => {
+  const n = nodeOf(text);
+  return !!n && JSON.stringify(n).includes('["var"');
+};
+
+function rows(
+  doc: StackDoc,
+  a: DocAnswer,
+  h: OutHooks,
+  depth: number,
+  at: string,
+  base = 0,
+): Row[] {
+  const out: Row[] = [];
+  let lv = base + 1; // 지금 쌓는 줄 수준
+  let loc: string | undefined; // 지금 쌓는 왼쪽 자리(맨 위 문서만)
+  const vals = (a.값 ?? {}) as Values;
+  const vars = new Map((doc.변수 ?? []).map((v) => [varId(v), v]));
+  const lines = new Map((doc.식 ?? []).map((l) => [String(l.기호 ?? ""), l.식]));
+  // 펼친 문서 줄 = 금액 칸 없이(부른 쪽 칸과 섞이지 않게)
+  const push = (r: Omit<Row, "depth" | "lv">): void =>
+    void out.push({ ...r, depth, lv, loc, ...(depth ? { cols: undefined } : {}) });
+  const shown = new Set(reach(doc, vals)); // 지금 탄 갈래로 닿는 기호만
+  const steps = lineMap(doc);
+  const place = placeNames(doc, stackOf(doc)); // 번지 읽는 이름(804-5)
+  const unit = (id: string): string => shownUnit(vars.get(id)?.단위);
+  const alias = tableAlias(doc); // 표 값 기호 화면 이름(요구 683)
+  const subOf = (id: string): FormulaDoc | null => {
+    const k = vars.get(id)?.연결;
+    if (k?.갈래 !== "단가산출" || !k.키 || k.키.includes("{")) return null;
+    try {
+      return h.cache.links.doc(k.키) ?? null;
+    } catch {
+      if (h.cache.takeMissing()) h.miss();
+      return null;
+    }
+  };
+  /** ▸ 단추 — 펼친 자리면 그 문서 줄을 뒤에 끼움 */
+  const opener = (id: string, label: string): HTMLElement => {
+    const path = `${at}/${id}`;
+    const b = createButton({
+      label: `${label} ${h.open.has(path) ? "▾" : "▸"}`,
+      variant: "link",
+      size: 20,
+      onClick: () => h.toggle(path),
+    });
+    b.dataset.expand = path;
+    return b;
+  };
+  /** 기계 · 단가산출 제목 줄 — 접기 단추 + 제목(누르면 펼침 · 요구 687-11) */
+  const fold = (id: string, title: string): HTMLElement[] => {
+    const path = `${at}/${id}`;
+    const on = h.open.has(path);
+    const b = createIconButton({
+      icon: on ? "chevronDown" : "chevronRight",
+      title: lt(on ? "Fold_Sub" : "Unfold_Sub"),
+      size: 20,
+      onClick: (e) => (e.stopPropagation(), h.toggle(path)),
+    });
+    b.dataset.expand = path;
+    const t = el("span", { className: "lstk-ftitle", text: title });
+    t.addEventListener("click", (e) => (e.stopPropagation(), h.toggle(path)));
+    return [b, t];
+  };
+  const expand = (id: string): void => {
+    const path = `${at}/${id}`;
+    const sub = subOf(id);
+    if (!h.open.has(path) || !sub || depth >= MAX_DEPTH) return;
+    const got = calcDoc(sub, h.cache.links, subInputs(vars.get(id)?.연결, vals));
+    if (h.cache.takeMissing()) h.miss();
+    out.push({
+      depth: depth + 1,
+      lv: lv + 1,
+      loc,
+      h: [`${sub.이름 ?? ""}${sub.결과단위 ? ` [${sub.결과단위}]` : ""}`],
+      cls: "subhead",
+    });
+    out.push(...rows(sub, got, h, depth + 1, path, lv + 1).map((r) => ({ ...r, loc })));
+  };
+
+  /** 공식 묶음 — 값만인 줄은 넷까지 한 줄 */
+  const block = (ids: string[]): void => {
+    let pack: HTMLElement[] = [];
+    const flush = (): void => {
+      if (pack.length)
+        push({ h: pack.flatMap((x, k) => (k ? [el("span", { className: "lstk-gap" }), x] : [x])) });
+      pack = [];
+    };
+    for (const id of ids.filter((x) => shown.has(x))) {
+      const v = vals[id];
+      const t = lines.get(id);
+      const head = katexNode(symTex(alias[id] ?? id));
+      if (t !== undefined && hasVar(t)) {
+        flush();
+        const res = isNum(v)
+          ? katexNode(`${valTex(v)}\\ ${unit(id) ? `\\text{${unit(id)}}` : ""}`)
+          : missing(a, id);
+        // 기호식 = 값식 = 결과 — 같은 꼴이 이어지면 한 번만(만약이 수 하나를 탄 줄)
+        const n = nodeOf(t)!;
+        const sym = tex(n, { side: "sym", vals, alias });
+        const val = tex(n, { side: "val", vals, alias });
+        const same = isNum(v) && val === valTex(v);
+        push({
+          h: [
+            head,
+            ...(sym === val ? [] : [" = ", katexNode(sym)]),
+            ...(same ? [] : [" = ", katexNode(val)]),
+            " = ",
+            res,
+          ],
+        });
+        continue;
+      }
+      const sub = subOf(id);
+      if (sub || (v && typeof v === "object")) {
+        flush();
+        const label =
+          v && typeof v === "object"
+            ? COSTS.map((c) => `${COST_SHOW[c]} ${eqText((v as Values)[c])}`).join(" · ")
+            : isNum(v)
+              ? `${eqText(v)} ${unit(id) || sub?.결과단위 || ""}`
+              : "—";
+        push({
+          h: [head, " = ", sub ? opener(id, label) : label, sub ? ` ${sub.이름 ?? ""}` : ""],
+        });
+        expand(id);
+        continue;
+      }
+      const expr =
+        t !== undefined && !isNum(Number(t))
+          ? [" = ", exprNode(t, "sym", vals, false, undefined, { alias })]
+          : [];
+      const cell = el("span", {
+        className: "lstk-pack",
+        children: [
+          head,
+          ...expr,
+          " = ",
+          isNum(v) ? `${eqText(v)} ${unit(id)}` : typeof v === "string" ? v : missing(a, id),
+        ],
+      });
+      pack.push(cell);
+      if (pack.length >= 4) flush();
+    }
+    flush();
+  };
+
+  const money = doc.금액 ?? [];
+  const lineRows = (i: number): { sub: boolean; cols: Cols } => {
+    const line = money[i];
+    const r = (a.줄?.[i] ?? {}) as {
+      비목?: Record<string, number>;
+      금액?: number | null;
+      까닭?: string;
+      단가?: unknown;
+    };
+    const scope: Values = { ...vals, ...moneyScope(a.줄, i) };
+    const at: Record<string, Values> = {}; // 앞 줄 번지 합(계산기와 같음 — 번지 값을 값 식에 · 804-5)
+    money.slice(0, i).forEach((m, k) => {
+      const got = a.줄?.[k] as { 금액?: unknown; 비목?: Values } | undefined;
+      if (m.기호) scope[m.기호] = got?.금액; // 앞 금액 줄 기호 = 그 줄 금액
+      if (m.번지)
+        for (const c of COSTS) {
+          const box = (at[String(m.번지)] ??= { 노무비: 0, 재료비: 0, 경비: 0 });
+          if (isNum(got?.비목?.[c]))
+            box[c] = Math.round(((box[c] as number) + (got!.비목![c] as number)) * 1e6) / 1e6;
+        }
+    });
+    if (Object.keys(at).length) scope.번지 = at;
+    const name = [line.이름, (line as { 규격?: string }).규격].filter(Boolean).join(" ");
+    const qty =
+      line.수량 !== undefined && line.수량 !== null && line.수량 !== "" ? line.수량 : null;
+    const qtyNode = (cost?: string): (string | HTMLElement)[] =>
+      qty === null
+        ? []
+        : [
+            " × ",
+            exprNode(qty, "val", scope, true, cost, { alias }),
+            line.단위 ? ` ${line.단위}` : "",
+          ];
+    if (r.까닭 && r.금액 === null) {
+      push({ h: [`${name} : — `, el("span", { className: "lstk-miss", text: r.까닭 })] });
+      return { sub: false, cols: {} };
+    }
+    if (line.비목 === "묶음") {
+      const s = priceSym(line);
+      const bundle = (r.단가 ?? {}) as Values;
+      const cols: Cols = {};
+      const title = name || (s ? (subOf(s)?.이름 ?? s) : "");
+      push({ h: s && subOf(s) ? fold(s, title) : [title], cls: "lname" });
+      for (const c of COSTS) {
+        const part = r.비목?.[c];
+        if (!isNum(part) || (!part && !bundle[c])) continue;
+        cols[c] = part;
+        push({
+          h: [`${COST_SHOW[c]} : `, eqText(bundle[c]), ...qtyNode(c), ` = ${one(part)}`],
+        });
+      }
+      if (s) expand(s);
+      return { sub: true, cols };
+    }
+    const amt = r.금액 ?? 0;
+    const price =
+      hasVar(line.단가) && kindOf(doc, i) === "율"
+        ? [
+            exprNode(line.단가, "sym", scope, true, undefined, { place, alias }),
+            " = ",
+            exprNode(line.단가, "val", scope, true, undefined, { alias }),
+          ]
+        : [exprNode(line.단가, "val", scope, true, undefined, { alias })];
+    const c = String(line.비목);
+    push({
+      h: [`${name} : `, ...price, ...qtyNode(), ` = ${one(amt)}`],
+      cols: { sum: amt, [c]: amt },
+    });
+    return { sub: false, cols: { [c]: amt } };
+  };
+
+  const items = stackOf(doc);
+  const terms: Record<string, number[]> = { 노무비: [], 재료비: [], 경비: [] };
+  const perItem: Record<string, number[]> = { 노무비: [], 재료비: [], 경비: [] }; // 덧셈이 길면 항목 소계끼리(804-5)
+  let n = 0;
+  let sub = 0;
+  const levels = stackLevels(items);
+  for (const [k, it] of items.entries()) {
+    lv = base + levels[k].item;
+    loc = depth ? undefined : String(k);
+    if (it.제목.trim()) {
+      const label = it.가나다 ? `${"가나다라마바사아자차카타파하"[sub++] ?? "?"} . ` : `${++n}. `;
+      if (!it.가나다) sub = 0;
+      push({ h: [label + it.제목], cls: it.가나다 ? "item sub" : "item" });
+    }
+    const sum: Record<string, number> = { 노무비: 0, 재료비: 0, 경비: 0 };
+    const own: Record<string, number[]> = { 노무비: [], 재료비: [], 경비: [] };
+    let hasSub = false;
+    lv = base + levels[k].line;
+    for (const [j, l] of it.줄.entries()) {
+      loc = depth ? undefined : `${k}.${j}`;
+      if (l.꼴 === "글") push({ h: [l.글] });
+      else if (l.꼴 === "공식") block(l.기호);
+      else {
+        if (offLine(money[l.i], vals, steps)) continue; // 선택으로 꺼진 줄(수식 탭과 같음)
+        const got = lineRows(l.i);
+        hasSub ||= got.sub;
+        if ((a.줄?.[l.i] as { 합밖?: boolean } | undefined)?.합밖) continue;
+        for (const [c, v] of Object.entries(got.cols)) {
+          sum[c] = Math.round((sum[c] + (v ?? 0)) * 10) / 10;
+          if (v) own[c].push(v);
+        }
+      }
+    }
+    loc = depth ? undefined : String(k);
+    if (hasSub && COSTS.some((c) => sum[c])) {
+      const s = Math.round((sum.노무비 + sum.재료비 + sum.경비) * 10) / 10;
+      push({ h: [`${lt("Sub_Sum")} : ${one(s)}`], cols: { sum: s, ...sum }, cls: "subsum" });
+    }
+    for (const c of COSTS) {
+      terms[c].push(...(hasSub ? (sum[c] ? [sum[c]] : []) : own[c]));
+      if (sum[c]) perItem[c].push(sum[c]);
+    }
+  }
+  lv = base + 1;
+  loc = undefined;
+  if (doc.결과) {
+    const r = a.결과;
+    push({
+      h: [
+        katexNode(symTex(doc.결과)),
+        ` = ${isNum(r) ? `${eqText(r)} ${doc.결과단위 ?? ""}` : "—"}`,
+      ],
+      cls: "total",
+    });
+    return out;
+  }
+  if (!money.length) return out;
+  push({ h: [`${++n}. ${lt("Total")}`], cls: "item" });
+  lv = base + 2;
+  for (const c of COSTS) {
+    const t = terms[c].length > LONG_SUM ? perItem[c] : terms[c];
+    const v = a[c];
+    const body = !isNum(v)
+      ? "—"
+      : t.length > 1
+        ? `${t.map(one).join(" + ")} = ${won(v)}`
+        : t.length
+          ? won(v)
+          : "";
+    push({ h: [`${COST_SHOW[c]} : ${body}`] });
+  }
+  push({
+    h: [`${lt("Sum")} : ${isNum(a.계) ? won(a.계) : "—"}`],
+    cols: isNum(a.계)
+      ? { sum: a.계, 노무비: a.노무비 ?? 0, 재료비: a.재료비 ?? 0, 경비: a.경비 ?? 0 }
+      : {},
+    cls: "total",
+    won: true,
+  });
+  return out;
+}
+
+const missing = (a: DocAnswer, id: string): HTMLElement =>
+  el("span", { className: "lstk-miss", text: `— ${a.빈값?.[id] ?? ""}`.trim() });
+
+/** 산출근거 표 */
+export function buildOut(doc: StackDoc, a: DocAnswer, h: OutHooks): HTMLElement {
+  const columns: Column[] = [
+    { label: lt("Basis") },
+    { label: lt("Total"), width: "92px", align: "end" },
+    { label: COST_SHOW.노무비, width: "84px", align: "end" },
+    { label: COST_SHOW.재료비, width: "84px", align: "end" },
+    { label: COST_SHOW.경비, width: "84px", align: "end" },
+  ];
+  const { root, tbody } = tableShell(columns, { density: "data" });
+  const head: Row = {
+    h: [`${doc.이름 ?? ""}${doc.결과단위 ? ` [${doc.결과단위}]` : ""}`],
+    cols: isNum(a.계)
+      ? { sum: a.계, 노무비: a.노무비 ?? 0, 재료비: a.재료비 ?? 0, 경비: a.경비 ?? 0 }
+      : {},
+    cls: "head",
+    won: true,
+    depth: 0,
+    lv: 0,
+  };
+  for (const r of [head, ...rows(doc, a, h, 0, "")]) {
+    const cell = (k: "sum" | (typeof COSTS)[number]): string => {
+      const v = r.cols?.[k];
+      if (v === undefined || (r.won && !v && k !== "sum")) return "";
+      return r.won ? won(v) : one(v);
+    };
+    const first = el("div", { className: "lstk-h", children: r.h });
+    first.style.setProperty("--lstk-depth", String(r.lv));
+    first.dataset.lv = String(r.lv);
+    const tr = tableRow(columns, [first, cell("sum"), ...COSTS.map(cell)]);
+    tr.className = `lstk-orow ${r.cls ?? ""} ${r.depth ? "is-sub" : ""}`;
+    if (r.loc !== undefined) {
+      tr.dataset.loc = r.loc;
+      tr.addEventListener("click", () => h.pair?.(r.loc!));
+    }
+    tbody.append(tr);
+  }
+  root.classList.add("lstk-out");
+  return root;
+}

A00_Common/line_stack_pick.ts

@@ -0,0 +1,157 @@
+/* =============================================================================
+ * line_stack_pick.ts
+ * 줄 쌓기 고르기 창(PLAN 804-3 · 804-4 · 요구 678-1 · 678-3 · 680-1 · 681)
+ *   찾아 넣기 = M02 [항목 추가] 창 그대로(`openFindPicker` · 탭 M01 전체 · 찾기 칸 · 표) — 줄 갈래마다 그 종류만
+ *     인력(노임 LB) · 재료(자재 MT) · 기계(EQ → 시간당 경비 로직 + 기계='원문번호') · 다른 단가산출(M01 단가산출 로직)
+ *   M01 단가산출 기초 줄 쌓기 = 「M01 전체」 탭만 — M01 은 원천 기준값이라 M02 단가산출 · 일위대가를 부르지 않음(요구 680-1)
+ *   M02 단가산출 줄 쌓기(`take` 있음) · 다른 단가산출 = 탭 [M01 전체 | M02 단가산출 | 일위대가](위 층 · 자기 SK 뺌) —
+ *     고름 = 복사해 펼침(`take(src)` · src = M01 키 | `참조|층|주인|키`) · 참조 줄 없음(요구 681)
+ *   표 고르기 = 품셈 표(조건 칸 + 값 칸) · 값 칸 누름 = 그 줄 · 칸 · 지금 닿는 칸 강조 ·
+ *     옵션에 매인 조건 = 그 줄만 고를 수 있음(다른 줄은 막힘 + 「위 옵션에서 고름」 안내)
+ * ========================================================================== */
+
+import { createButton } from "@ui/ui_template_button";
+import { eqText } from "@ui/ui_template_equation";
+import { el } from "@ui/ui_template_elements";
+import { openModal } from "@ui/ui_template_modal";
+import { tableRow, tableShell, type Column } from "@ui/ui_template_table";
+import { createText } from "@ui/ui_template_text";
+import type { DocTable } from "../common_util/common_util_formula_doc_table";
+import type { MoneyKind } from "../common_util/common_util_line_stack";
+import type { Picked } from "../common_util/common_util_line_stack_pick";
+import { showToast } from "@ui/ui_template_elements";
+import type { Layer } from "../M02_MasterTemplete/M02_MasterTemplete_Api_Fetch";
+import { openFindPicker, type FindKind } from "../M02_MasterTemplete/M02_MasterTemplete_Find_Pick";
+import { lt } from "./line_stack_text";
+
+const KINDS: Partial<Record<MoneyKind, FindKind>> = {
+  인력: "labor",
+  재료: "material",
+  기계: "machine",
+  단가산출: "logic",
+};
+
+/** M02 단가산출 복사 길(804-4) — 그 SK 층 · 키 · 복사해 넣기 */
+export interface StackTake {
+  layer: Layer;
+  owner: string | null;
+  me: string;
+  take: (src: string) => void;
+}
+
+/** 찾아 넣기 — 고르면 `done(고른 것)` · 닫으면 아무것도 안 함 · `m02` 있고 다른 단가산출 = 복사해 펼침 ·
+ *  `query` = 찾기 칸에 넣고 연 결과(이름 단추 · 요구 687-9) */
+export function openStackPick(
+  kind: MoneyKind,
+  done: (p: Picked) => void,
+  m02?: StackTake,
+  query = "",
+): void {
+  const want = KINDS[kind];
+  if (!want) return;
+  const spec = (e: { 규격: string }) => (e.규격 ? { 규격: e.규격 } : {});
+  const copy = kind === "단가산출" && m02 ? m02 : null;
+  openFindPicker({
+    layer: copy?.layer ?? "system",
+    owner: copy?.owner ?? null,
+    title: `${lt("Find_Title")} — ${lt(copy ? "K_복사" : (`K_${kind}` as never))}`,
+    kinds: copy ? ["logic", "sk", "pre"] : [want], // M01 = M01 전체만(680-1)
+    query: query.trim() || undefined,
+    ref: copy
+      ? (r) =>
+          r.키 === copy.me && r.층 === copy.layer && (!copy.owner || r.주인 === copy.owner)
+            ? showToast(lt("Self_Take"), "warning")
+            : copy.take(`참조|${r.층}|${r.주인 ?? ""}|${r.키}`)
+      : undefined,
+    logic: (x) =>
+      copy
+        ? copy.take(x.키)
+        : done({ 키: x.키, 이름: x.이름, 단위: x.결과단위.replace(/^원\/?/, "") }),
+    element: (e) => done({ 키: e.코드, 이름: e.이름, 단위: e.단위, ...spec(e) }),
+    machine: (e) =>
+      e.로직 && e.원문번호
+        ? done({ 키: e.로직, 이름: e.이름, 입력: { 기계: `'${e.원문번호}'` }, ...spec(e) })
+        : undefined,
+  });
+}
+
+const isNum = (v: unknown): boolean =>
+  typeof v === "number" || (typeof v === "string" && v.trim() !== "" && Number.isFinite(Number(v)));
+
+const cellText = (v: unknown): string =>
+  Array.isArray(v)
+    ? `${v[0] ?? ""} ~ ${v[1] ?? ""}`
+    : isNum(v)
+      ? eqText(Number(v))
+      : String(v ?? "");
+
+export interface TablePick {
+  table: DocTable;
+  /** 지금 닿는 줄(-1 = 없음) · 칸 */
+  now: number;
+  col: string;
+  /** 옵션에 매인 조건 — {조건 칸: 옵션 열쇠들} */
+  bound: Record<string, string[]>;
+  done: (row: Record<string, unknown>, col: string) => void;
+}
+
+/** 표 고르기 창 — 값 칸 누름 = 고름 */
+export function openTablePick(o: TablePick): void {
+  const t = o.table;
+  const conds = Object.keys(t.조건 ?? {});
+  const valueCols = [
+    ...new Set([...Object.keys(t.값칸 ?? {}), ...t.줄.flatMap((r) => Object.keys(r))]),
+  ].filter((k) => !conds.includes(k));
+  const locked = Object.keys(o.bound).length > 0;
+  const columns: Column[] = [
+    ...conds.map((c) => ({ label: c })),
+    ...valueCols.map((c) => {
+      const unit = (t.값칸 ?? {})[c];
+      return { label: unit ? `${c} (${String(unit)})` : c, align: "end" as const };
+    }),
+  ];
+  openModal({
+    title: [t.원문번호, (t as { 이름?: string }).이름].filter(Boolean).join(" "),
+    closeLabel: lt("Close"),
+    width: "960px",
+    mount: (body, close) => {
+      const { root, tbody } = tableShell(columns, { density: "data" });
+      t.줄.forEach((row, k) => {
+        const off = locked && k !== o.now;
+        const tr = tableRow(columns, [
+          ...conds.map((c) => cellText(row[c])),
+          ...valueCols.map((c) =>
+            isNum(row[c]) // 수만 고름(글 칸 = 단위 등은 보기만 · M02 길은 수를 글로 줌)
+              ? createButton({
+                  label: cellText(row[c]),
+                  variant: k === o.now && c === o.col ? "filled" : "ghost",
+                  size: 24,
+                  disabled: off,
+                  onClick: () => {
+                    close();
+                    o.done(row, c);
+                  },
+                })
+              : cellText(row[c]),
+          ),
+        ]);
+        tr.dataset.row = String(k);
+        tbody.append(tr);
+      });
+      const note = locked
+        ? [
+            createText(
+              `${lt("Tbl_Bound")} — ${[...new Set(Object.values(o.bound).flat())].join(" · ")}`,
+            ),
+          ]
+        : [];
+      body.append(
+        el("div", {
+          className: "lstk-tpick",
+          attrs: { "data-table-pick": t.키 ?? "" },
+          children: [...note, createText(lt("Tbl_Hint")), root],
+        }),
+      );
+    },
+  });
+}

A00_Common/line_stack_rows.ts

@@ -0,0 +1,327 @@
+/* =============================================================================
+ * line_stack_rows.ts
+ * 줄 쌓기 공식 묶음(PLAN 804-2 · 요구 675) — 「이름 = 값」 · 「이름 = 식」 줄 묶음 · 틀 이름표 · [식으로 풀기] · [틀로 저장]
+ *   보임 = 값 줄은 값 칸(연결 값을 고쳐 적으면 숫자 = 고정값 · 요구 664) · 식 줄은 「이름 = 식 = 값」 글 · 단가산출 결과 기호 = [식으로 풀기]
+ *   고침(804-7 · 요구 687-14) = [식 고치기] 걷음 — 이름 · 식 글을 누르면 그 줄만 그 자리에서 이름 · 식 · 단위 칸 + 지움 ·
+ *     바꾸면 닫힘 · 머리 [+] = 식 줄 더함 — 이름 바꿈 = 문서 전부(`rename`) · 식 = 식 줄 · 수 = 숫자 연결
+ *   만약 안 탄 갈래 기호(`hide` · 요구 687-10) = 안 보임(식 글은 그대로)
+ *   틀 = 단가산출 결과 문서(굴착기 Q 등)를 이 문서 식으로 옮김(`unfold`) — 꼴이 바뀌면 「내 틀 (틀 이름 에서 변경)」 ·
+ *     빈 틀 = [찾아 넣기](M01 단가산출 결과 — 작업량 등) · [틀로 저장] · 내 틀 목록 걷음(요구 685) · 표 값만 = 머리 「표 값」
+ *   표 값(804-3) = [표 · 칸] 단추 → 표 고르기 창(`line_stack_pick.ts`) · 값 칸 누름 = 그 줄 · 칸(`pickCell`)
+ * ========================================================================== */
+
+import { createButton, createIconButton } from "@ui/ui_template_button";
+import { eqText } from "@ui/ui_template_equation";
+import { el, showToast } from "@ui/ui_template_elements";
+import { createInputField } from "@ui/ui_template_input";
+import {
+  DocError,
+  rename,
+  splitId,
+  varId,
+  type FormulaDoc,
+} from "../common_util/common_util_formula_doc";
+import { isNum } from "../common_util/common_util_formula_doc_calc";
+import {
+  dropSyms,
+  freshId,
+  newVar,
+  setRow,
+  shapeOf,
+  unfold,
+  type StackItem,
+  type StackLine,
+} from "../common_util/common_util_line_stack";
+import {
+  aliasText,
+  boundConds,
+  currentRow,
+  pickCell,
+  shownUnit,
+  tableAlias,
+} from "../common_util/common_util_line_stack_pick";
+import { openFindPicker } from "../M02_MasterTemplete/M02_MasterTemplete_Find_Pick";
+import type { EditHooks } from "./line_stack_edit";
+import { openTablePick } from "./line_stack_pick";
+import { lt } from "./line_stack_text";
+
+const clone = <T>(v: T): T => JSON.parse(JSON.stringify(v)) as T;
+type Block = Extract<StackLine, { 꼴: "공식" }>;
+
+const LINK_TAG: Record<string, string> = {
+  표: "표",
+  요소: "요소",
+  단가산출: "단가산출",
+  선택: "선택",
+  입력: "입력",
+};
+
+const input = (
+  value: string,
+  placeholder: string,
+  cls: string,
+  set: (t: string) => void,
+): HTMLElement => {
+  const f = createInputField({ value, placeholder, compact: true, size: 24 });
+  f.root.classList.add(cls);
+  f.input.addEventListener("change", () => set(f.input.value));
+  return f.root;
+};
+
+export function buildBlock(
+  h: EditHooks,
+  i: number,
+  j: number,
+  line: Block,
+  hide: (id: string) => boolean = () => false,
+): HTMLElement[] {
+  const d = h.doc;
+  const at = `${i}.${j}`;
+  const editing = (id: string): boolean => h.open.has(`${at}:${id}`);
+  /** 그 줄 고침 켬 · 끔(화면 상태) */
+  const flip = (id: string, on: boolean): void => {
+    if (on) h.open.add(`${at}:${id}`);
+    else h.open.delete(`${at}:${id}`);
+  };
+  const vals = (h.answer.값 ?? {}) as Record<string, unknown>;
+  const vars = new Map((d.변수 ?? []).map((v) => [varId(v), v]));
+  const lines = new Map((d.식 ?? []).map((l) => [String(l.기호 ?? ""), String(l.식 ?? "")]));
+  const blockOf = (items: StackItem[]): Block => items[i].줄[j] as Block;
+  // 표 값 기호 = 화면 이름(요구 683 · 문서 기호 그대로) — 칸 글은 화면 이름 ↔ 기호로 오감
+  const alias = tableAlias(d);
+  const show = (id: string): string => alias[id] ?? id;
+  const shownText = (t: string): string => aliasText(t, alias);
+  const realText = (t: string): string => aliasText(t, alias, true);
+  const valText = (id: string): string => {
+    const v = vals[id];
+    if (isNum(v) || typeof v === "string")
+      return `${eqText(v)} ${shownUnit(vars.get(id)?.단위)}`.trim();
+    if (v && typeof v === "object")
+      return ["노무비", "재료비", "경비"]
+        .map((c) => `${c} ${eqText((v as Record<string, unknown>)[c])}`)
+        .join(" · ");
+    return `— ${h.answer.빈값?.[id] ?? ""}`.trim();
+  };
+
+  // ── 이름표 ──
+  const tplName = (k: string): string =>
+    k.startsWith("my:") ? lt("My_Tpl") : (h.subDoc(k)?.이름 ?? (h.name(k) || k)); // my: = 옛 내 틀(걷음 · 요구 685)
+  const changed = !!line.틀 && !!line.틀꼴 && shapeOf(d, line.기호) !== line.틀꼴;
+  const tableOnly = line.기호.every((id) => vars.get(id)?.연결?.갈래 === "표" && !lines.has(id));
+  const label = !line.틀
+    ? lt(tableOnly && line.기호.length ? "K_표값" : "K_공식")
+    : changed
+      ? `${lt("My_Tpl")} (${tplName(line.틀)} ${lt("Changed_From")})`
+      : tplName(line.틀);
+  const head = el("div", {
+    className: "lstk-fhead",
+    children: [
+      el("span", { className: "lstk-kind", text: label }),
+      createIconButton({
+        icon: "plus",
+        title: lt("Add_Row"),
+        size: 24,
+        onClick: () =>
+          h.change((doc, items) => {
+            const id = freshId(doc, "x");
+            (doc.변수 ??= []).push(newVar(id, { 갈래: "숫자", 값: 0 }));
+            blockOf(items).기호.push(id);
+            flip(id, true);
+          }),
+      }),
+    ],
+  });
+  head.dataset.tpl = changed ? "changed" : line.틀 ? "tpl" : "";
+
+  // ── 표 값 — [표 · 칸] → 표 고르기 ──
+  const tableBtn = (id: string, link: NonNullable<FormulaDoc["변수"]>[number]["연결"] & object) => {
+    const b = createButton({
+      label:
+        [
+          lt("Tbl"),
+          ...Object.values(link.조건 ?? {}).flatMap((t) =>
+            /^'.*'$/.test(String(t)) ? [String(t).slice(1, -1)] : [],
+          ),
+          link.칸,
+        ]
+          .filter(Boolean)
+          .join(" · ") + " ▾", // 고른 줄(글 조건) · 칸
+      variant: "ghost",
+      size: 24,
+      onClick: () =>
+        void h.table(String(link.표 ?? "")).then((t) => {
+          if (!t) return void showToast(lt("Tbl_Missing"), "warning");
+          openTablePick({
+            table: t,
+            now: currentRow(t, link, vals),
+            col: String(link.칸 ?? ""),
+            bound: boundConds(d, link),
+            done: (row, col) => h.change((doc) => pickCell(doc, id, t, row, col)),
+          });
+        }),
+    });
+    b.dataset.tablePick = id;
+    b.title = h.name(String(link.표 ?? "")) || String(link.표 ?? "");
+    return b;
+  };
+
+  // ── 줄 ──
+  const renameRow = (old: string, now: string): void => {
+    const t = now.trim();
+    if (!t || t === old) return;
+    try {
+      const copy = clone(d);
+      const [s, lo, up] = splitId(t);
+      rename(copy, old, s, lo, up);
+    } catch (e) {
+      if (e instanceof DocError) return void showToast(lt("Bad_Name"), "warning");
+      throw e;
+    }
+    h.change((doc, items) => {
+      const [s, lo, up] = splitId(t);
+      rename(doc, old, s, lo, up);
+      for (const it of items)
+        for (const l of it.줄) if (l.꼴 === "공식") l.기호 = l.기호.map((x) => (x === old ? t : x));
+    });
+  };
+  const unfoldRow = (id: string, sub: FormulaDoc, key: string): void =>
+    h.change((doc, items) => {
+      const moved = unfold(doc, sub, id);
+      const blk = blockOf(items);
+      blk.기호 = blk.기호.filter((x) => x !== id);
+      items[i].줄.splice(j + 1, 0, { 꼴: "공식", 기호: moved, 틀: key, 틀꼴: shapeOf(doc, moved) });
+      if (!blk.기호.length) items[i].줄.splice(j, 1);
+    });
+  /** 누르면 그 줄 고침(보이는 글을 고침) */
+  const tap = (node: HTMLElement, id: string): HTMLElement => {
+    node.classList.add("lstk-tap");
+    node.tabIndex = 0;
+    node.setAttribute("role", "button");
+    node.title = lt("Edit_Hint");
+    const go = (): void => {
+      flip(id, true);
+      h.change(() => undefined);
+    };
+    node.addEventListener("click", go);
+    node.addEventListener("keydown", (e) => e.key === "Enter" && go());
+    return node;
+  };
+  /** 고친 뒤 닫음 */
+  const done = (id: string, fn: () => void): void => {
+    flip(id, false);
+    fn();
+  };
+  const rows = line.기호
+    .filter((id) => !hide(id))
+    .map((id) => {
+      const v = vars.get(id);
+      const link = v?.연결;
+      const expr = lines.get(id);
+      const sub = link?.갈래 === "단가산출" && link.키 ? h.subDoc(link.키) : null;
+      const tag =
+        link?.갈래 === "표" && !expr
+          ? tableBtn(id, link)
+          : link && LINK_TAG[link.갈래 ?? ""] && !expr
+            ? el("span", {
+                className: "lstk-tag",
+                text: `${LINK_TAG[link.갈래!]}${link.키 && !link.키.includes("{") ? ` · ${sub?.이름 ?? h.name(link.키) ?? ""}` : ""}`,
+              })
+            : null;
+      const tools: HTMLElement[] = [];
+      if (sub?.결과 && link?.키)
+        tools.push(
+          createButton({
+            label: lt("Unfold"),
+            variant: "ghost",
+            size: 24,
+            onClick: () => unfoldRow(id, sub, link.키!),
+          }),
+        );
+      if (link?.갈래 === "단가산출" && !link.키)
+        tools.push(
+          createButton({
+            label: lt("Find_Title"),
+            variant: "ghost",
+            size: 24,
+            onClick: () =>
+              openFindPicker({
+                layer: "system",
+                owner: null,
+                title: lt("K_단가산출"),
+                kinds: ["logic"],
+                results: true,
+                logic: (x) =>
+                  h.change((doc) => {
+                    const y = doc.변수?.find((z) => varId(z) === id);
+                    if (y) y.연결 = { 갈래: "단가산출", 키: x.키, 입력: {} };
+                  }),
+              }),
+          }),
+        );
+      const name = tap(el("b", { className: "lstk-sym", text: show(id) }), id);
+      const valueOf =
+        expr ??
+        (link?.갈래 === "숫자" ? String(link.값 ?? "") : isNum(vals[id]) ? String(vals[id]) : "");
+      let body: (HTMLElement | string)[];
+      const open = editing(id);
+      if (open)
+        body = [
+          input(show(id), lt("Row_Name"), "lstk-f-s", (t) =>
+            done(id, () => renameRow(id, t.trim() === show(id) ? id : t)),
+          ),
+          "=",
+          input(shownText(valueOf), lt("Row_Expr"), "lstk-f-l", (t) =>
+            done(id, () => h.change((doc) => setRow(doc, id, realText(t)))),
+          ),
+          input(v?.단위 ?? "", lt("Unit"), "lstk-f-s", (t) =>
+            done(id, () =>
+              h.change((doc) => {
+                let x = doc.변수?.find((y) => varId(y) === id);
+                if (!x) (doc.변수 ??= []).push((x = newVar(id, { 갈래: "식" })));
+                x.단위 = t.trim();
+              }),
+            ),
+          ),
+          el("span", { className: "lstk-val", text: `= ${valText(id)}` }),
+          createButton({
+            label: "×",
+            variant: "danger-ghost",
+            size: 24,
+            onClick: () => done(id, () => h.change((doc) => dropSyms(doc, [id]))),
+          }),
+          createIconButton({
+            icon: "check",
+            title: lt("Close"),
+            size: 24,
+            onClick: () => done(id, () => h.change(() => undefined)),
+          }),
+        ];
+      else if (expr !== undefined || sub || link?.갈래 === "단가산출")
+        body = [
+          name,
+          "=",
+          ...(expr
+            ? [tap(el("span", { className: "lstk-expr", text: shownText(expr) }), id), "="]
+            : []),
+          el("span", { className: "lstk-val", text: valText(id) }),
+        ];
+      else
+        body = [
+          name,
+          "=",
+          input(shownText(valueOf), valText(id), "lstk-f-m", (t) =>
+            h.change((doc) => setRow(doc, id, realText(t))),
+          ),
+          ...(shownUnit(v?.단위)
+            ? [el("span", { className: "lstk-unit", text: shownUnit(v?.단위) })]
+            : []),
+        ];
+      const row = el("div", {
+        className: `lstk-frow ${open ? "is-open" : ""}`,
+        children: [...body, ...(tag ? [tag] : []), ...tools],
+      });
+      row.dataset.sym = id;
+      return row;
+    });
+  return [head, ...rows];
+}

A00_Common/line_stack_screen.ts

@@ -0,0 +1,496 @@
+/* =============================================================================
+ * line_stack_screen.ts
+ * 단가산출 「줄 쌓기」 탭(PLAN 804-2 · 요구 670~677) — 공용(M01 단가산출 기초 · M02 단가산출 = 길 앞머리만 바꿈)
+ *   위 = 옵션 가로(`formula_doc_options.ts`) · M02 사본 [단가 갱신] · [재생성] · 「M01 새 판」 배지(층 쓰기)
+ *     `page` 있음(M01 804-7 · M02 804-8) = 저장 · 되돌림 단추 없음 — 페이지 [저장] · [되돌림]이 `save` · `discard` 를 부름 ·
+ *     고침이 바뀌면 `page()` · `page` 없음(일위대가 줄 모달 등) = 위에 [고침 버림] · [수식 저장]
+ *   가운데 = 왼쪽 줄 쌓기 편집(`line_stack_edit.ts`) | 오른쪽 산출근거 출력(`line_stack_out.ts` · 기계 시간당 경비 펼침)
+ *   아래 = 합계 상자(노무비 · 재료비 · 경비 · 계 · 화면 아래 고정 · 요구 687-3)
+ *   정본 = 수식 문서(탭을 바꾸면 다시 읽음) · 줄 쌓기 차림 = 문서 칸 `쌓기` · 804-6 옛 수식 문서 탭 걷음 = 이 화면이 「수식」 탭
+ *   셈 = 브라우저 계산기(`calcDoc`) 즉시 · 캐시에 없는 연결만 뒤에서 `POST {길}/preview`(옛 요청 끊음)
+ *   고침 = 캐시(sessionStorage)에 쌓고 [저장] 한 번에 `POST {길}/save`(서버가 정본으로 다시 셈) · 자동저장 없음
+ *   M02 사본(`copy`) — 저장 몸 {문서, 끊음(받은 그대로), 판} · 판 바뀜(409)은 문서가 그대로면 새 판으로 한 번 더
+ *     [단가 갱신] · [재생성] = 미리 셈 → 알림 → 저장(`formula_doc_copy.ts` · 고친 것 먼저 저장)
+ * ========================================================================== */
+
+import { API_BASE_URL } from "@config/config_frontend";
+import { createBadge } from "@ui/ui_template_badge";
+import { createButton } from "@ui/ui_template_button";
+import {
+  el,
+  hideLoadingOverlay,
+  showConfirmDialog,
+  showLoadingOverlay,
+  showToast,
+} from "@ui/ui_template_elements";
+import { blankDoc, type FormulaDoc } from "../common_util/common_util_formula_doc";
+import { calcDoc, type DocAnswer } from "../common_util/common_util_formula_doc_calc";
+import type { DocTable } from "../common_util/common_util_formula_doc_table";
+import { createDocCache, type DocRecord } from "../common_util/common_util_formula_doc_cache";
+import {
+  docOf,
+  stackOf,
+  type StackDoc,
+  type StackItem,
+} from "../common_util/common_util_line_stack";
+import {
+  askJob,
+  copyBadges,
+  copyTools,
+  type CopyJob,
+  type CopyMark,
+  type CopyOptions,
+  type JobReply,
+} from "./formula_doc_copy";
+import { docFoot } from "./formula_doc_foot";
+import { buildOptions } from "./formula_doc_options";
+import { ft } from "./formula_doc_text";
+import { addTaken, type Taken } from "../common_util/common_util_line_stack_copy";
+import type { Layer } from "../M02_MasterTemplete/M02_MasterTemplete_Api_Fetch";
+import { buildEdit } from "./line_stack_edit";
+import { buildOut } from "./line_stack_out";
+import { lt } from "./line_stack_text";
+import "./line_stack.css";
+
+export interface StackScreenOptions {
+  /** 길 앞머리(`/m01/logic/doc`) — GET ?key · POST /preview · /save · /links */
+  base: string;
+  admin: boolean;
+  /** sessionStorage 열쇠 */
+  cache: string;
+  copy?: CopyOptions;
+  /** M02 SK 층(804-4) — 줄 쌓기 다른 단가산출 · 일위대가 복사 길 · 없으면(M01) 복사 없음 */
+  scope?: { layer: Layer; owner: string | null };
+  /** 페이지가 저장 · 되돌림을 맡음(M01 804-7 · M02 804-8) — 고침 있음이 바뀔 때 부름 · 화면 위 [고침 버림] · [수식 저장] 없음 */
+  page?: () => void;
+}
+
+type Docs = Record<string, FormulaDoc>;
+interface Loaded {
+  문서: StackDoc;
+  셈: DocAnswer;
+  연결: DocRecord;
+  새?: boolean;
+  끊음?: Docs;
+  사본?: CopyMark;
+  판?: string;
+}
+
+const clone = <T>(v: T): T => JSON.parse(JSON.stringify(v)) as T;
+
+export function createStackScreen(opt: StackScreenOptions) {
+  const head = el("div", { className: "lstk__head" });
+  const left = el("div", { className: "lstk__left" });
+  const right = el("div", { className: "lstk__right" });
+  const foot = el("div", { className: "lstk__foot" });
+  const root = el("div", {
+    className: "lstk",
+    attrs: { "data-line-stack": "" },
+    children: [head, el("div", { className: "lstk__areas", children: [left, right] }), foot],
+  });
+  // 산출근거 고정 높이(요구 683) — 스크롤 조상(없으면 창) 높이 · 넓을 때만 고정(line_stack.css)
+  const fit = (): void => {
+    let p = root.parentElement;
+    while (p && !/(auto|scroll)/.test(getComputedStyle(p).overflowY)) p = p.parentElement;
+    const view = (p?.clientHeight ?? innerHeight) - foot.offsetHeight;
+    root.style.setProperty("--lstk-view", `${Math.max(240, view)}px`);
+  };
+  window.addEventListener("resize", fit);
+  const cp = opt.copy;
+  let key = "";
+  let shown: string | null = null; // 연 키(같은 키 다시 그림 = 안 읽음 · 탭 바꿈 = force)
+  let saved = "";
+  let doc: StackDoc | null = null;
+  let answer: DocAnswer | null = null;
+  let cache = createDocCache();
+  let given: Record<string, unknown> = {};
+  let cut: Docs = {};
+  let mark: CopyMark | undefined;
+  let version = "";
+  let seq = 0;
+  let asked = "";
+  let ctl: AbortController | null = null;
+  const tables = new Map<string, Promise<DocTable | null>>(); // 표 고르기(문서 열 때 비움)
+  const opened = new Set<string>(); // 산출근거 펼친 자리
+  let paired = ""; // 짝 강조 자리(679 — 항목 `k` · 줄 `k.j`)
+  const blocks = new Set<string>(); // 풀린 공식 묶음
+
+  const call = async <T>(path: string, body?: unknown, signal?: AbortSignal): Promise<T> => {
+    const r = await fetch(`${API_BASE_URL}${cp ? cp.route(key, path) : opt.base + path}`, {
+      method: body === undefined ? "GET" : "POST",
+      credentials: "include",
+      headers: { "Content-Type": "application/json" },
+      ...(body === undefined ? {} : { body: JSON.stringify(body) }),
+      signal,
+    });
+    const data = (await r.json().catch(() => ({}))) as T & { detail?: unknown };
+    if (!r.ok) {
+      const why = data.detail;
+      throw Object.assign(new Error(typeof why === "string" ? why : r.statusText), {
+        status: r.status,
+      });
+    }
+    return data;
+  };
+
+  // ── 캐시 ──
+  const drafts = (): Record<string, FormulaDoc> => {
+    try {
+      return JSON.parse(sessionStorage.getItem(opt.cache) ?? "{}") as Record<string, FormulaDoc>;
+    } catch {
+      return {};
+    }
+  };
+  const dirty = (): boolean => !!doc && JSON.stringify(doc) !== saved;
+  const keep = (): void => {
+    const all = drafts();
+    if (dirty()) all[key] = doc!;
+    else delete all[key];
+    try {
+      sessionStorage.setItem(opt.cache, JSON.stringify(all));
+    } catch {
+      /* 캐시가 막혀도 화면 안 고침은 남음 */
+    }
+    opt.page?.();
+  };
+
+  // ── 셈 ──
+  const usable = (): Record<string, unknown> => {
+    const out: Record<string, unknown> = {};
+    for (const v of doc?.변수 ?? []) {
+      const k = v.열쇠;
+      if (!k || !(k in given)) continue;
+      const kind = v.연결?.갈래;
+      if (kind === "입력") out[k] = given[k];
+      if (kind === "선택" && (v.연결?.목록 ?? []).some((x) => String(x) === String(given[k])))
+        out[k] = (v.연결!.목록 ?? []).find((x) => String(x) === String(given[k]));
+    }
+    return out;
+  };
+  const recalc = (): void => {
+    if (!doc) return;
+    answer = calcDoc(doc, cache.links, usable());
+    if (cache.takeMissing()) ask();
+  };
+  /** 캐시에 없는 연결 — 뒤에서 서버 기록을 받아 더함 */
+  const ask = (): void => {
+    const snap = JSON.stringify([doc, usable()]);
+    if (snap === asked) return;
+    asked = snap;
+    ctl?.abort();
+    ctl = new AbortController();
+    const mine = ++seq;
+    void call<{ 연결: DocRecord }>(
+      "/preview",
+      cp ? { 문서: doc, 끊음: cut } : { 문서: key ? doc : { ...doc, 키: "_새" }, 입력: usable() },
+      ctl.signal,
+    )
+      .then((got) => {
+        if (mine !== seq) return;
+        cache.merge(got.연결);
+        cache.merge({ 문서: cut });
+        recalc();
+        draw();
+      })
+      .catch(() => undefined);
+  };
+  const subDoc = (k: string): FormulaDoc | null => {
+    try {
+      return cache.links.doc(k) ?? null;
+    } catch {
+      if (cache.takeMissing()) ask();
+      return null;
+    }
+  };
+
+  /** 표 하나(`/table`) — 받은 표는 계산기 캐시에도 */
+  const tableOf = (k: string): Promise<DocTable | null> => {
+    if (!tables.has(k))
+      tables.set(
+        k,
+        call<DocTable & { 끊김?: string }>(`/table?key=${encodeURIComponent(k)}`)
+          .then((t) => {
+            if (t.끊김) return null;
+            cache.putTable(k, t);
+            return t;
+          })
+          .catch(() => null),
+      );
+    return tables.get(k)!;
+  };
+
+  /** 고침 — 문서 · 차림을 고친 뒤 문서로 굳힘 */
+  const change = (fn: (d: StackDoc, items: StackItem[]) => void): void => {
+    if (!doc) return;
+    const items = stackOf(doc);
+    fn(doc, items);
+    doc = docOf(doc, items);
+    keep();
+    recalc();
+    draw();
+  };
+
+  /** 짝 강조 — 왼쪽 카드 · 오른쪽 줄(같은 자리) · from = 누른 쪽(반대쪽을 보이는 자리로) */
+  const pair = (loc: string, from?: "left" | "right"): void => {
+    paired = loc;
+    for (const x of root.querySelectorAll(".is-pair")) x.classList.remove("is-pair");
+    if (!loc) return;
+    const sel = `[data-loc="${CSS.escape(loc)}"]`;
+    const l = left.querySelector<HTMLElement>(sel);
+    const r = [...right.querySelectorAll<HTMLElement>(sel)];
+    l?.classList.add("is-pair");
+    r.forEach((x) => x.classList.add("is-pair"));
+    if (from === "right") l?.scrollIntoView({ block: "nearest", behavior: "smooth" });
+    if (from === "left") r[0]?.scrollIntoView({ block: "nearest", behavior: "smooth" });
+  };
+
+  /** 복사해 펼침(804-4) — 서버 조각 → 새 항목(고침 = 캐시 · [저장] 때 서버가 다시 셈) */
+  const takeIn = async (src: string): Promise<void> => {
+    try {
+      const got = await call<Taken>(`/take?src=${encodeURIComponent(src)}`);
+      change((d, items) => addTaken(d, items, got));
+    } catch (e) {
+      showToast(`${lt("Take_Failed")} — ${e instanceof Error ? e.message : ""}`, "error");
+    }
+  };
+  const takeCtx = () =>
+    cp && opt.scope && key
+      ? { ...opt.scope, me: key, take: (src: string) => void takeIn(src) }
+      : undefined;
+
+  // ── 그림 ──
+  const edit = (): boolean => opt.admin && (!!key || !cp);
+  const draw = (): void => {
+    if (!doc || !answer) {
+      [head, left, right, foot].forEach((x) => x.replaceChildren());
+      return;
+    }
+    const options = buildOptions(doc, given, !!cp && !opt.admin, (k, v, x) => {
+      const at = doc?.변수?.indexOf(v) ?? -1;
+      if (cp) return change((d) => at >= 0 && (d.변수![at].연결 = { ...v.연결!, 값: x }));
+      given[k] = x;
+      recalc();
+      draw();
+    });
+    const busy = dirty();
+    const tools = [
+      ...(cp && edit() && key ? copyTools(true, (job) => void runJob(job)) : []),
+      ...(edit() && key && !opt.page
+        ? [
+            createButton({
+              label: ft("Discard"),
+              variant: "ghost",
+              size: 28,
+              disabled: !busy,
+              onClick: () => void discard(),
+            }),
+            createButton({
+              label: ft("Save"),
+              variant: "filled",
+              size: 28,
+              disabled: !busy,
+              onClick: () => void save(),
+            }),
+          ]
+        : []),
+    ];
+    head.replaceChildren(
+      ...(options.length ? [el("div", { className: "fdoc__options", children: options })] : []),
+      el("div", {
+        className: "lstk__bar",
+        children: [
+          el("div", {
+            className: "lstk__badges",
+            children: [
+              ...(busy ? [createBadge(ft("Dirty"), "warning")] : []),
+              ...(cp ? copyBadges(mark, opt.admin) : []),
+            ],
+          }),
+          el("div", { className: "lstk__tools", children: tools }),
+        ],
+      }),
+    );
+    const items = stackOf(doc);
+    root.dataset.edit = edit() ? "1" : "";
+    left.replaceChildren(
+      ...(edit()
+        ? [
+            buildEdit({
+              doc,
+              answer,
+              items,
+              change,
+              table: tableOf,
+              subDoc,
+              name: (k) => cache.names.get(k) ?? "",
+              open: blocks,
+              pair: (loc) => pair(loc, "left"),
+              take: takeCtx(),
+            }),
+          ]
+        : []),
+    );
+    right.replaceChildren(
+      items.length || doc.결과
+        ? buildOut(doc, answer, {
+            cache,
+            open: opened,
+            toggle: (at) => {
+              if (opened.has(at)) opened.delete(at);
+              else opened.add(at);
+              draw();
+            },
+            miss: ask,
+            pair: (loc) => pair(loc, "right"),
+          })
+        : el("p", { className: "ui-text ui-text--muted", text: lt("Empty") }),
+    );
+    foot.replaceChildren(...(doc.결과 ? [] : [docFoot(answer)]));
+    pair(paired);
+    fit();
+  };
+
+  const take = (got: Loaded): void => {
+    cache.merge(got.연결);
+    saved = JSON.stringify(got.문서);
+    doc = clone(got.문서);
+    cut = clone(got.끊음 ?? {});
+    mark = got.사본;
+    version = got.판 ?? "";
+  };
+
+  /** 사본 [단가 갱신] · [재생성] — 미리 셈 → 알림 → 저장(고친 것 먼저 저장 · 버림) */
+  const runJob = async (job: CopyJob): Promise<void> => {
+    if (!doc || !cp) return;
+    if (dirty()) return void showToast(ft("Dirty_First"), "warning");
+    showLoadingOverlay();
+    let got: JobReply;
+    try {
+      got = await call<JobReply>("/preview", { 할일: job });
+    } catch (e) {
+      hideLoadingOverlay();
+      return void showToast(
+        `${ft("Save_Failed")} — ${e instanceof Error ? e.message : ""}`,
+        "error",
+      );
+    }
+    hideLoadingOverlay();
+    if (await askJob(job, got, cache.names)) await save({ 할일: job, 판: version }, ft("Job_Done"));
+  };
+
+  let loading: Promise<void> = Promise.resolve();
+  const save = async (job?: Record<string, unknown>, done = ft("Saved")): Promise<boolean> => {
+    await loading; // 새 로직 저장 뒤 여는 중이면 다 읽고(캐시 이어 받음)
+    if (!doc || (!job && !dirty())) return true;
+    const send = job ?? (cp ? { 문서: doc, 끊음: cut, 판: version } : { 문서: doc });
+    const was = saved;
+    showLoadingOverlay();
+    try {
+      const got = await call<Loaded>("/save", send).catch(async (e: { status?: number }) => {
+        // 사본 판 바뀜(페이지 [저장] 등) — 문서가 받은 그대로면 새 판으로 한 번 더
+        if (!cp || e.status !== 409) throw e;
+        const now = await call<Loaded>("");
+        if (JSON.stringify(now.문서) !== was) throw e;
+        return call<Loaded>("/save", { ...send, 판: (version = now.판 ?? "") });
+      });
+      take(got);
+      keep();
+      recalc();
+      draw();
+      if (cp && got.판) cp.onSaved?.(got.판);
+      if (done) showToast(done, "success");
+      return true;
+    } catch (e) {
+      showToast(`${ft("Save_Failed")} — ${e instanceof Error ? e.message : ""}`, "error");
+      return false;
+    } finally {
+      hideLoadingOverlay();
+    }
+  };
+
+  const discard = async (): Promise<void> => {
+    if (!doc || !dirty()) return void draw();
+    doc = JSON.parse(saved) as StackDoc;
+    keep();
+    recalc();
+    draw();
+  };
+
+  /** 문서 열기 — 서버 · 캐시에서 다시 읽음(수식 탭 고침 · 저장을 이어 받음) */
+  const open = async (next: string): Promise<void> => {
+    const was = key;
+    shown = next;
+    if (next !== key) {
+      paired = "";
+      opened.clear();
+      blocks.clear();
+      given = {};
+    }
+    key = next;
+    doc = answer = null;
+    asked = "";
+    cache = createDocCache();
+    tables.clear();
+    [cut, mark, version] = [{}, undefined, ""];
+    draw();
+    if (!next) {
+      if (cp)
+        return void right.replaceChildren(
+          el("p", { className: "ui-text ui-text--muted", text: lt("Unsaved_New") }),
+        );
+      doc = (drafts()[""] as StackDoc | undefined) ?? blankDoc();
+      saved = JSON.stringify(blankDoc());
+      recalc();
+      return draw();
+    }
+    const mine = ++seq;
+    try {
+      const got = await call<Loaded>(cp ? "" : `?key=${encodeURIComponent(next)}`);
+      if (mine !== seq || key !== next) return;
+      take(got);
+      const all = drafts();
+      if (!was && got.새 && all[""] && !all[next]) {
+        all[next] = { ...all[""], 키: next, 이름: got.문서.이름, 결과단위: got.문서.결과단위 };
+        delete all[""];
+        sessionStorage.setItem(opt.cache, JSON.stringify(all));
+      }
+      if (all[next]) doc = clone(all[next] as StackDoc);
+      recalc();
+      draw();
+      opt.page?.(); // 캐시에서 이어 받은 고침 — 페이지 [저장] · [되돌림] 켬
+    } catch (e) {
+      if (mine === seq)
+        head.replaceChildren(
+          el("p", {
+            className: "ui-text ui-text--muted",
+            text: `${ft("Load_Failed")} — ${e instanceof Error ? e.message : ""}`,
+          }),
+        );
+    }
+  };
+
+  const canLeave = async (): Promise<boolean> => {
+    if (!dirty()) return true;
+    if (!(key in drafts())) return true; // 다른 화면에서 이미 버림
+    if (!(await showConfirmDialog(ft("Leave"), ft("Leave_Ok")))) return false;
+    doc = JSON.parse(saved) as StackDoc;
+    keep();
+    return true;
+  };
+
+  return {
+    root,
+    /** 로직 · SK 키로 그림(빈 키 = 저장 전 새 것) — 같은 키는 그대로 · `force` = 다시 읽음(탭 바꿈) */
+    draw: (next: string, force = false): void => {
+      if (force || next !== shown) loading = open(next);
+    },
+    canLeave,
+    dirty,
+    /** 페이지 [저장](804-7) — 고침 있으면 서버 정본 저장 · 알림은 페이지가(`done` 빈 글) · 실패 = false */
+    save: (): Promise<boolean> => save(undefined, ""),
+    /** 페이지 [되돌림] — 저장 뒤 상태로(캐시 지움) */
+    discard: (): Promise<void> => discard(),
+    /** 시험 · 확인용 */
+    state: () => ({ doc, answer, dirty: dirty(), items: doc ? stackOf(doc) : [] }),
+  };
+}

A00_Common/line_stack_tex.ts

@@ -0,0 +1,152 @@
+/* =============================================================================
+ * line_stack_tex.ts
+ * 줄 쌓기 산출근거 수식 조판(PLAN 804-2 · 요구 677) — 식 나무 → TeX → KaTeX(MIT) · 분수 · 첨자 · 괄호
+ *   기호 식(side "sym") = 기호(첨자) · 값 식(side "val") = 값(모르면 기호 빨강) · 만약 = 탄 갈래만 · 반올림 · 올림 · 버림 감싸개 숨김
+ *   금액 줄 꼴(`inline`) = ÷ 한 줄(경쟁사 「노무비 : 59,020 ÷ Q」) · 공식 줄 = 분수
+ *   규칙은 수식 탭 그림(`formula_doc_render.ts` renderNode)과 같음 — 셈 정본은 계산기
+ * ========================================================================== */
+
+import katex from "katex";
+import "../config/node_modules/katex/dist/katex.min.css";
+import { eqText } from "@ui/ui_template_equation";
+import { splitId, type Node } from "../common_util/common_util_formula_doc";
+import { isNum } from "../common_util/common_util_formula_doc_calc";
+import { leafNum, takenOf, type Values } from "../common_util/common_util_formula_doc_view";
+
+export interface TexCtx {
+  side: "sym" | "val";
+  vals: Values;
+  inline?: boolean;
+  /** 묶음 값의 비목(기계 · 단가산출 줄 노 · 재 · 경) */
+  cost?: string;
+  /** 번지 읽는 이름(804-5) — 「번지.복사N.노무비」 → 「항목 이름 노무비」 */
+  place?: Record<string, string>;
+  /** 표 값 기호 화면 이름(요구 683 — 「Q_수량2^표」 → 「Q_작업반장」) */
+  alias?: Record<string, string>;
+}
+
+const HIDE = new Set(["반올림", "올림", "버림"]);
+const OPS: Record<string, string> = {
+  "+": "+",
+  "-": "-",
+  "*": "\\times",
+  "/": "\\div",
+  "<": "<",
+  "<=": "\\le",
+  ">": ">",
+  ">=": "\\ge",
+  "==": "=",
+  "!=": "\\ne",
+  그리고: "\\;\\text{그리고}\\;",
+  또는: "\\;\\text{또는}\\;",
+};
+const PREC: Record<string, number> = {
+  또는: 1,
+  그리고: 2,
+  "<": 3,
+  "<=": 3,
+  ">": 3,
+  ">=": 3,
+  "==": 3,
+  "!=": 3,
+  "+": 4,
+  "-": 4,
+  "*": 5,
+  "/": 5,
+};
+const prec = (n: Node): number => (n[0] === "bin" ? PREC[n[1]] : n[0] === "neg" ? 6 : 9);
+
+/** TeX 글 안전 — \text{} 안 */
+const txt = (s: string): string => `\\text{${s.replace(/[\\{}$&#^_%~]/g, (c) => `\\${c}`)}}`;
+const word = (s: string): string =>
+  /^[A-Za-z]$/.test(s) ? s : /^[A-Za-z]+$/.test(s) ? `\\mathit{${s}}` : txt(s);
+
+/** 기호 글(`Q_작업^표`) → TeX(첨자) */
+export function symTex(id: string): string {
+  const [s, lo, up] = splitId(id);
+  return `${word(s)}${lo ? `_{${word(lo)}}` : ""}${up ? `^{${word(up)}}` : ""}`;
+}
+
+/** 값 → TeX(천 자리 쉼표) */
+export const valTex = (v: unknown): string => {
+  const t = eqText(v);
+  return isNum(v) ? t.replace(/,/g, "{,}") : txt(t);
+};
+
+/** 칸 값 — `번지.복사1.노무비` 처럼 겹친 칸까지 */
+const look = (n: Node, vals: Values): unknown => {
+  if (n[0] === "var") return vals[n[1]];
+  if (n[0] !== "field") return undefined;
+  const v = look(n[1], vals);
+  return v && typeof v === "object" ? (v as Values)[n[2]] : undefined;
+};
+
+const paren = (t: string): string => `\\left(${t}\\right)`;
+const miss = (t: string): string => `\\htmlClass{lstk-miss}{${t}}`;
+
+export function tex(n: Node, c: TexCtx): string {
+  const go = (x: Node): string => tex(x, c);
+  switch (n[0]) {
+    case "num":
+      return valTex(n[1]);
+    case "str":
+      return txt(`'${n[1]}'`);
+    case "var": {
+      const id = c.alias?.[n[1]] ?? n[1];
+      if (c.side === "sym") return symTex(id);
+      let v = c.vals[n[1]];
+      if (v && typeof v === "object" && c.cost) v = (v as Values)[c.cost];
+      return v === null || v === undefined || typeof v === "object" ? miss(symTex(id)) : valTex(v);
+    }
+    case "field": {
+      const [, of, key] = n;
+      if (c.side === "val") {
+        const got = look(n, c.vals);
+        if (isNum(got)) return valTex(got);
+      }
+      if (of[0] === "field" && of[1][0] === "var" && of[1][1] === "번지" && c.place?.[of[2]])
+        return txt(`${c.place[of[2]]} ${key}`);
+      return `${n[1][0] === "var" ? symTex(n[1][1]) : go(n[1])}.${txt(n[2])}`;
+    }
+    case "neg":
+      return `-${n[1][0] === "bin" ? paren(go(n[1])) : go(n[1])}`;
+    case "pct":
+      return `${prec(n[1]) < 9 ? paren(go(n[1])) : go(n[1])}\\,\\%`;
+    case "call": {
+      const [, name, items] = n;
+      if (name === "만약") {
+        const pick = takenOf(n, c.vals);
+        if (pick) return go(items[pick]);
+      }
+      if (HIDE.has(name) && items.length >= 1 && items.length <= 2) return go(items[0]);
+      const fn = name === "최소" ? "\\min" : name === "최대" ? "\\max" : txt(name);
+      return `${fn}${paren(items.map(go).join(",\\,"))}`;
+    }
+    case "bin": {
+      const [, o, a, b] = n;
+      const na = leafNum(a, c.vals);
+      const nb = leafNum(b, c.vals);
+      if ((o === "+" || o === "-") && nb === 0) return go(a);
+      if ((o === "*" || o === "/") && nb === 1) return go(a);
+      if ((o === "+" && na === 0) || (o === "*" && na === 1)) return go(b);
+      if (o === "/" && !c.inline) return `\\dfrac{${go(a)}}{${go(b)}}`;
+      const mine = PREC[o];
+      const left = prec(a) < mine || (mine === 3 && prec(a) === 3) ? paren(go(a)) : go(a);
+      const right = prec(b) <= mine ? paren(go(b)) : go(b);
+      return `${left} ${OPS[o] ?? txt(o)} ${right}`;
+    }
+  }
+}
+
+/** TeX → 조판 요소(못 그리면 글 그대로) */
+export function katexNode(t: string): HTMLElement {
+  const box = document.createElement("span");
+  box.className = "lstk-tex";
+  katex.render(t, box, {
+    throwOnError: false,
+    strict: "ignore",
+    trust: (x) => x.command === "\\htmlClass",
+    output: "html",
+  });
+  return box;
+}

A00_Common/line_stack_text.ts

@@ -0,0 +1,78 @@
+/* =============================================================================
+ * line_stack_text.ts
+ * 줄 쌓기 화면 글(PLAN 804-2) — [국문, 영문] · 수식 탭과 같은 글은 `formula_doc_text.ts`
+ * ========================================================================== */
+
+import { currentLanguageIndex } from "@ui/ui_template_locale";
+
+const TEXT = {
+  Tab: ["줄 쌓기", "Line stack"],
+  Basis: ["산 출 근 거", "Basis"],
+  Total: ["합 계", "Total"],
+  Sum: ["계", "Sum"],
+  Sub_Sum: ["소 계", "Subtotal"],
+  Add_Item: ["+ 그룹", "+ Group"],
+  Add_Line: ["줄 더함", "Add line"],
+  Add_율: ["율 — 그룹 소계의 %", "Rate — % of subtotal"],
+  Add_식: ["식 — 공식 틀", "Formula"],
+  Del_Item: ["그룹 지움", "Delete group"],
+  Del: ["지움", "Delete"],
+  Item: ["그룹", "Group"],
+  K_줄: ["줄", "Line"],
+  Drag: ["끌어 옮기기", "Drag to move"],
+  Fold_Item: ["그룹 접기", "Collapse group"],
+  Unfold_Item: ["그룹 펼치기", "Expand group"],
+  Unfold_Sub: ["시간당 경비 · 산출 펼치기", "Show breakdown"],
+  Fold_Sub: ["접기", "Hide breakdown"],
+  Dropped: ["지움 — 눌러 되돌리기", "deleted — click to undo"],
+  Undo_Late: ["그 뒤 고친 것이 있어 못 되돌림", "Changed since — cannot undo"],
+  Title: ["그룹 이름", "Group title"],
+  K_인력: ["인력", "Labor"],
+  K_재료: ["재료", "Material"],
+  K_기계: ["기계", "Machine"],
+  K_단가산출: ["단가산출", "Unit price"],
+  K_복사: ["단가산출 · 일위대가 복사", "Copy unit price · combo"],
+  Self_Take: ["지금 단가산출 자신은 못 가져옴", "Cannot copy itself"],
+  Take_Failed: ["복사 못 함", "Copy failed"],
+  K_율: ["율", "Rate"],
+  K_공식: ["공식", "Formula"],
+  K_표값: ["표 값", "Table values"],
+  K_글: ["근거 글", "Basis note"],
+  Name: ["이름", "Name"],
+  Unit: ["단위", "Unit"],
+  Cost: ["비목", "Cost"],
+  Qty: ["수량", "Qty"],
+  Price: ["단가", "Price"],
+  Machine: ["기계", "Machine"],
+  Find: ["찾기", "Find"],
+  Pick: ["고름 ▾", "Pick ▾"],
+  None_Found: ["찾은 것 없음", "Nothing found"],
+  Unfold: ["식으로 풀기", "Unfold"],
+  Edit_Hint: ["눌러 고침", "Click to edit"],
+  Add_Row: ["식 줄 더함", "Add row"],
+  New_Formula: ["새 공식", "New formula"],
+  My_Formula: ["내 공식", "My formula"],
+  My_Tpl: ["내 틀", "My template"],
+  Changed_From: ["에서 변경", "changed"],
+  Row_Name: ["이름", "Name"],
+  Row_Expr: ["값 또는 식", "Value or expr"],
+  Bad_Name: ["못 쓰는 이름 · 같은 이름 있음", "Bad or duplicate name"],
+  Empty_Item: ["줄 없음 — [+]", "No lines — [+]"],
+  Empty: ["빈 단가산출 — [+ 그룹] 으로 시작", "Empty — start with [+ Group]"],
+  Text_Ph: ["< 품셈 근거 > · ※ 메모 · 별산", "Note"],
+  Unsaved_New: ["저장한 단가산출만 — 페이지 [저장] 뒤", "Saved unit prices only"],
+  Find_Title: ["찾아 넣기", "Find and add"],
+  Repick: ["찾아 바꾸기", "Find and change"],
+  Close: ["닫기", "Close"],
+  Tbl: ["표", "Table"],
+  Tbl_Missing: ["표를 못 읽음", "Table not found"],
+  Tbl_Hint: ["값 칸을 누르면 그 값이 들어감", "Click a value cell to use it"],
+  Tbl_Bound: [
+    "이 값의 줄은 위 옵션이 고름(다른 줄은 옵션에서 바꿈 · 여기선 칸만)",
+    "Row follows the option above (change it there; pick a column here)",
+  ],
+} as const;
+
+export type LsKey = keyof typeof TEXT;
+
+export const lt = (key: LsKey): string => TEXT[key][currentLanguageIndex === 1 ? 1 : 0];

A00_Common/m_settings_nav.ts

@@ -1,7 +1,8 @@
 /* =============================================================================
  * m_settings_nav.ts
- * 시스템 설정 바로가기(334 · 요구 225-2) — 대시보드 「시스템 설정」 카드 · M01 · M02 ☰ 가 같이 쓰는
- * 역할 규칙 한 벌(`settingLinks`) · ☰ 진행 단계 자리에 🏠 대시보드 + 카드(`mountSettingsDrawer`).
+ * 시스템 설정 바로가기(334 · 요구 225-2 · 716-2) — 대시보드 설계 기본값 줄(`settingLinks` · 칸마다 한 줄 ·
+ * `?open=`) / M01 · M02 ☰ 메뉴(`pageLinks` · 페이지 둘 · `mountSettingsDrawer`) /
+ * 진행 판 없는 쪽 ☰ 기본 목록(`defaultSettingsBar` · 772-1).
  * ========================================================================== */
 
 import { ROUTES, type RoutePath } from "@config/config_frontend";
@@ -16,52 +17,65 @@ interface SettingUser {
   company_id?: number | null;
 }
 
-/** key = M01 은 「m01」 · 계산 자리 창은 「calcSites」(대시보드 카드만 · 504-2) · M02 는 진입 인자 `open` */
+/** key = 페이지 열쇠(☰ · 「m01」 「m02」) 또는 칸 열쇠(대시보드 줄 · 계산 자리 「calcSites」 = 창 504-2) ·
+ * group = 대시보드 설계 기본값 묶음 제목 */
 export interface SettingLink {
   key: string;
   title: string;
   desc: string;
   route: RoutePath;
   query?: Record<string, string>;
+  group?: string;
 }
 
 function L(key: keyof typeof ui_locales): string {
   return ui_locales[key][currentLanguageIndex];
 }
 
-const ICONS: Record<string, string> = { m01: "🗄️", 구조물조합: "🧱", 옵션: "🎛️", 도면: "📑" };
+const ICONS: Record<string, string> = { m01: "🗄️", m02: "🧱" };
 
-/** 시스템 설정 — 역할로 카드 숨김 · M02 카드는 `?open=&root=` 로 진입(27-1d) */
+/** 설계 기본값 줄(대시보드) — 칸마다 한 줄 · 역할로 숨김 · M01 줄 `?open=`(칸 고름) · M02 줄 `?open=&root=`(27-1d).
+ * 칸을 더할 때는 아래 표에 한 줄(m01 / m02 호출)만 더함. */
 export function settingLinks(user: SettingUser, companyId: number | string | null): SettingLink[] {
   // 시스템 관리자는 고른 회사를 해시에 실음(29-1)
   const company: Record<string, string> =
     user.role === "SYSTEM_ADMIN" && companyId ? { company: String(companyId) } : {};
+  const m01 = (key: string, title: string, desc: string, open?: string): SettingLink => ({
+    key,
+    title,
+    desc,
+    route: ROUTES.M01_MASTER_DATA,
+    query: open ? { open } : undefined,
+    group: "마스터 데이터",
+  });
   const m02 = (title: string, open: string, root: string, desc: string): SettingLink => ({
     key: open,
     title,
     desc,
     route: ROUTES.M02_MASTER_TEMPLATE,
     query: { open, root, ...company },
+    group: "마스터 템플릿",
   });
   // 구조물 조합 기본 층 = 개인(123-1 · 누구든) · 개인 층 없음(회사 없음) = 아래 역할 규칙
   const comboRoot = (fallback: string): string => (user.company_id ? "personal" : fallback);
   if (user.role === "SYSTEM_ADMIN") {
     const desc = L("B01_Dashboard_PermMasterWrite");
+    const read = L("B01_Dashboard_PermSourceRead");
     return [
-      {
-        key: "m01",
-        title: L("B01_Dashboard_MasterElements"),
-        desc: L("B01_Dashboard_PermSourceRead"),
-        route: ROUTES.M01_MASTER_DATA,
-      },
+      m01("m01", L("M01_Title"), read),
+      m01("로직", L("B01_Dashboard_CardLogic"), read, "로직"),
+      m01("옵션", L("B01_Dashboard_CardStructOptionDef"), desc, "옵션"),
+      m01("별칭", L("B01_Dashboard_CardAliasLedger"), desc, "별칭"),
+      m02(L("B01_Dashboard_CardSangeun"), "단가산출", comboRoot("master"), desc),
+      m02(L("B01_Dashboard_CardPrecombo"), "일위대가조합", comboRoot("master"), desc),
       m02(L("B01_Dashboard_CardStructCombo"), "구조물조합", comboRoot("master"), desc),
-      m02(L("B01_Dashboard_CardStructOption"), "옵션", "master", desc),
       m02(L("B01_Dashboard_CardDrawing"), "도면", "master", desc),
       {
         key: "calcSites",
         title: L("B01_CalcSites_Title"),
         desc: L("B01_CalcSites_Desc"),
         route: ROUTES.B01_ACCOUNT,
+        group: "계산",
       },
     ];
   }
@@ -76,15 +90,47 @@ export function settingLinks(user: SettingUser, companyId: number | string | nul
   return [m02(L("B01_Dashboard_CardStructCombo"), "구조물조합", comboRoot(root), desc)];
 }
 
-/** ☰ 진행 단계 자리 — 🏠 대시보드 + 카드 · 지금 칸 강조 · 같은 길(M02 → M02)은 머리 가드가 안 물어 여기서 먼저 */
+/** ☰ 메뉴 — 페이지 둘만(M01 = 시스템 관리자 · M02 = 누구나) · 열쇠 「m01」 「m02」 */
+export function pageLinks(user: SettingUser, companyId: number | string | null): SettingLink[] {
+  const combo = settingLinks(user, companyId).find((link) => link.key === "구조물조합");
+  const links: SettingLink[] = [];
+  if (user.role === "SYSTEM_ADMIN")
+    links.push({
+      key: "m01",
+      title: L("B01_Dashboard_MasterElements"),
+      desc: "",
+      route: ROUTES.M01_MASTER_DATA,
+    });
+  if (combo)
+    links.push({ ...combo, key: "m02", title: L("M02_Title"), desc: "", group: undefined });
+  return links;
+}
+
+/** ☰ 진행 단계 자리 — 🏠 대시보드 + 페이지 둘 · 지금 페이지 강조(`activeKey` = 「m01」 「m02」) ·
+ * 같은 길(M02 → M02)은 머리 가드가 안 물어 여기서 먼저 */
 export function mountSettingsDrawer(
   user: SettingUser,
   activeKey: string,
   companyId: number | string | null,
 ): void {
-  // 계산 자리 = 대시보드 창(504-2) — 페이지가 아니라 ☰ 에 안 둠
-  const links = settingLinks(user, companyId).filter((link) => link.key !== "calcSites");
-  const bar = createStepBar(
+  setDrawerSteps(settingsBar(user, activeKey, companyId));
+}
+
+/** ☰ 기본 목록(772-1) — 진행 판 · 바로가기를 안 세운 로그인 뒤 쪽(B02 · D01 · E01 등) = 🏠 대시보드 + 권한별 페이지 둘 ·
+ * 로그인 전 = 없음 */
+export async function defaultSettingsBar(): Promise<HTMLElement | null> {
+  const { fetchSessionUser } = await import("../A06_Login/A06_Login_Api_Fetch");
+  const user = await fetchSessionUser().catch(() => null);
+  return user ? settingsBar(user, "", null) : null;
+}
+
+function settingsBar(
+  user: SettingUser,
+  activeKey: string,
+  companyId: number | string | null,
+): HTMLElement {
+  const links = pageLinks(user, companyId);
+  return createStepBar(
     links.map((link) => link.title),
     links.findIndex((link) => link.key === activeKey),
     {
@@ -95,7 +141,6 @@ export function mountSettingsDrawer(
       onStepClick: (index) => void go(links[index]),
     },
   );
-  setDrawerSteps(bar);
 }
 
 async function go(link: SettingLink): Promise<void> {

A00_Common/map/logic/map_guide_route.ts

@@ -0,0 +1,434 @@
+/* =============================================================================
+ * map_guide_route.ts(logic)
+ * 예정노선 가이드 추천선 셈(PLAN 636-1 · 요구 546) — 기준지점을 차례로 거치는 참고용 선.
+ *   화면 가이드 전용 · 파이썬 짝 없음 · 저장 안 함(설계 값 아님 · 선례 `D03_PlanAnalysis_Fan.ts:8`).
+ *   2 m 격자 A*: 걸음 = 반지름 걸음/칸 ± 0.5 격자점(20 m = 56 방향) · |Δz| > 상한 × 걸음 길이 막음 ·
+ *   비용 = 길이 × (1 + 급경사 × 급경사 표본 비율 + 기울기 × (g/상한)²) + 꺾임 × 걸음 × (꺾임각/π)² ·
+ *   어림 = 직선 거리 × 가중(가중 A*) · 구간마다 상자 = 두 점 + 여유(못 닿으면 두 배 한 번) · 펼침 상한.
+ *   첫 걸음 = 정확한 시작점에서 · 끝 걸음도 기울기 검사 · 꼭짓점 그대로(20 m 다시 나누기 금지).
+ *   1 m 격자 = 2 칸 솎아 2 m · 급경사 = 격자 높이에서 바로 셈 · 못 닿음 = 가장 가까이 간 데까지.
+ *   근거 = `docs/raw/요구_1101/_분석_546-C_추천노선_라이다.md` C1 · DOM · fetch · three 없음.
+ * ========================================================================== */
+
+import {
+  heightAt as gridHeightAt,
+  type DtmGrid,
+} from "../../../common_util/common_util_surface_sampler";
+
+export type Point2 = [number, number];
+export type Point3 = [number, number, number];
+
+/** 높이 원천 — heightAt(NaN = 밖 · 빈칸) · 원천 격자 칸(m) · 격자 원점(칸 꼭짓점 맞춤). */
+export interface GuideTerrain {
+  heightAt: (x: number, y: number) => number;
+  /** 원천 격자 칸 m(기본 2) — 2 m 보다 잘면 솎아 2 m 안팎으로. */
+  cell?: number;
+  origin?: Point2;
+}
+
+export interface GuideWeights {
+  /** 급경사 표본 비율 벌점(기본 3) */
+  steep: number;
+  /** (g/상한)² 벌점(기본 0.3) */
+  grade: number;
+  /** 꺾임 벌점(기본 1) */
+  turn: number;
+  /** 어림 가중(기본 3 · 1 = 정확 A*) */
+  heuristic: number;
+}
+
+export interface GuideOptions {
+  /** 걸음 m(기본 20 · 그리기 「길이·기울기 고정」 칸) */
+  step?: number;
+  /** 기울기 상한 비율(기본 0.14) */
+  maxGrade?: number;
+  /** 급경사 문턱 %(기본 70 = 35° · 급경사 겹 둘째 경계) */
+  steepPct?: number;
+  weights?: Partial<GuideWeights>;
+  /** 구간마다 펼침 상한(기본 30 만 ≈ 0.4 s · 못 닿음 ≤ 0.5 s) */
+  maxExpand?: number;
+  /** 구간마다 시간 상한 ms(기본 450 · 못 닿음 ≤ 0.5 s · 느린 기계 막음) */
+  maxMs?: number;
+}
+
+export interface GuideSegment {
+  /** 꼭짓점 [x, y, z] — 닿음이면 끝 = 다음 지점 · 아니면 가장 가까이 간 데까지 */
+  vertices: Point3[];
+  reached: boolean;
+  /** 평면 길이 m */
+  length: number;
+  /** 걸음 가운데 가장 큰 |기울기| 비율 */
+  maxGrade: number;
+  /** 급경사(문턱 이상) 지나는 길이 비율 0~1 */
+  steepRatio: number;
+  expanded: number;
+}
+
+export interface GuideResult {
+  segments: GuideSegment[];
+  ms: number;
+}
+
+export const GUIDE_DEFAULTS = {
+  step: 20,
+  maxGrade: 0.14,
+  steepPct: 70,
+  weights: { steep: 3, grade: 0.3, turn: 1, heuristic: 3 } as GuideWeights,
+  maxExpand: 300_000,
+  maxMs: 450,
+};
+
+const MARGIN_MIN = 200;
+const MARGIN_MAX = 800;
+const STEEP_SAMPLES = [0.25, 0.5, 0.75, 1];
+
+/** 서버 지형 격자(`parseDtmGrid`) → 가이드 높이 원천(원천 칸 · 원점 그대로). */
+export function guideTerrainFromGrid(grid: DtmGrid): GuideTerrain {
+  const n = grid.x.length;
+  const cell = n > 1 ? (grid.x[n - 1] - grid.x[0]) / (n - 1) : 2;
+  return {
+    heightAt: (x, y) => gridHeightAt(grid, x, y),
+    cell,
+    origin: [grid.x[0], grid.y[0]],
+  };
+}
+
+/** 지점 차례로 잇는 가이드 선 — 지점 사이 구간마다 A*. */
+export function guideRoute(
+  points: Point2[],
+  terrain: GuideTerrain,
+  options: GuideOptions = {},
+): GuideResult {
+  const started = performance.now();
+  const segments: GuideSegment[] = [];
+  for (let index = 0; index + 1 < points.length; index++) {
+    segments.push(guideSegment(points[index], points[index + 1], terrain, options));
+  }
+  return { segments, ms: performance.now() - started };
+}
+
+/** 두 점 사이 가이드 선 하나. */
+export function guideSegment(
+  start: Point2,
+  goal: Point2,
+  terrain: GuideTerrain,
+  options: GuideOptions = {},
+): GuideSegment {
+  const step = options.step ?? GUIDE_DEFAULTS.step;
+  const gmax = options.maxGrade ?? GUIDE_DEFAULTS.maxGrade;
+  const weights = { ...GUIDE_DEFAULTS.weights, ...options.weights };
+  const steepGrade = (options.steepPct ?? GUIDE_DEFAULTS.steepPct) / 100;
+  const source = terrain.cell ?? 2;
+  const cell = source * Math.max(1, Math.round(2 / source));
+  const origin = terrain.origin ?? [0, 0];
+  const za = terrain.heightAt(start[0], start[1]);
+  const zb = terrain.heightAt(goal[0], goal[1]);
+  if (!Number.isFinite(za) || !Number.isFinite(zb)) {
+    return measure([[start[0], start[1], za]], false, 0, null);
+  }
+  const span = Math.hypot(goal[0] - start[0], goal[1] - start[1]);
+  const margin = Math.min(MARGIN_MAX, Math.max(MARGIN_MIN, span / 2));
+  const limit = options.maxExpand ?? GUIDE_DEFAULTS.maxExpand;
+  let spent = 0; // 두 상자 합친 펼침 수
+  let late = false;
+  const deadline = performance.now() + (options.maxMs ?? GUIDE_DEFAULTS.maxMs);
+  let edge = false; // 상자 끝에 닿음 = 넓히면 길이 있을 수 있음
+  let found = search(margin);
+  if (!found.reached && edge && spent < limit && !late) found = search(margin * 2);
+  found.expanded = spent;
+  return found;
+
+  function search(pad: number): GuideSegment {
+    const i0 = Math.floor((Math.min(start[0], goal[0]) - pad - origin[0]) / cell);
+    const j0 = Math.floor((Math.min(start[1], goal[1]) - pad - origin[1]) / cell);
+    const w = Math.ceil((Math.max(start[0], goal[0]) + pad - origin[0]) / cell) - i0 + 1;
+    const h = Math.ceil((Math.max(start[1], goal[1]) + pad - origin[1]) / cell) - j0 + 1;
+    const n = w * h;
+    const START = n;
+    const GOAL = n + 1;
+    const zs = new Float32Array(n).fill(Infinity); // Infinity = 아직 안 읽음 · NaN = 밖
+    const steepState = new Uint8Array(n); // 0 모름 · 1 급경사 · 2 아님
+    const g = new Float64Array(n + 2).fill(Infinity);
+    const parent = new Int32Array(n + 2).fill(-1);
+    const dir = new Float32Array(n + 2).fill(NaN);
+    const closed = new Uint8Array(n + 2);
+    const heap = new MinHeap();
+    const nx = (id: number) => origin[0] + (i0 + (id % w)) * cell;
+    const ny = (id: number) => origin[1] + (j0 + Math.floor(id / w)) * cell;
+    const zAt = (id: number): number => {
+      let value = zs[id];
+      if (value === Infinity) {
+        value = terrain.heightAt(nx(id), ny(id));
+        zs[id] = Number.isFinite(value) ? value : NaN;
+      }
+      return value;
+    };
+    const steepSq = (2 * cell * steepGrade) ** 2;
+    const steepAt = (id: number): boolean => {
+      if (steepState[id] === 0) {
+        const i = id % w;
+        const j = (id - i) / w;
+        if (i < 1 || j < 1 || i >= w - 1 || j >= h - 1) steepState[id] = 2;
+        else {
+          const gx = zAt(id + 1) - zAt(id - 1);
+          const gy = zAt(id + w) - zAt(id - w);
+          steepState[id] = gx * gx + gy * gy >= steepSq ? 1 : 2; // NaN = 아님
+        }
+      }
+      return steepState[id] === 1;
+    };
+    const radius = step / cell;
+    // 걸음 표 — 격자 차 · 길이 · 방위 · 급경사 표본 차(1/4 · 1/2 · 3/4 · 끝)
+    const offI: number[] = [];
+    const offJ: number[] = [];
+    const offLen: number[] = [];
+    const offDir: number[] = [];
+    const sampleD: number[] = []; // 칸 번호 차
+    const reach = Math.ceil(radius + 0.5);
+    for (let dj = -reach; dj <= reach; dj++) {
+      for (let di = -reach; di <= reach; di++) {
+        if (Math.abs(Math.hypot(di, dj) - radius) > 0.5) continue;
+        offI.push(di);
+        offJ.push(dj);
+        offLen.push(Math.hypot(di, dj) * cell);
+        offDir.push(Math.atan2(dj, di));
+        for (const t of STEEP_SAMPLES) {
+          sampleD.push(Math.round(dj * t) * w + Math.round(di * t));
+        }
+      }
+    }
+    const steepShare = weights.steep / STEEP_SAMPLES.length;
+    const turnWeight = (weights.turn * step) / (Math.PI * Math.PI);
+    // 걸음 비용 — 막히면 Infinity
+    const cost = (
+      ax: number,
+      ay: number,
+      az: number,
+      bx: number,
+      by: number,
+      bz: number,
+      inDir: number,
+    ): number => {
+      const len = Math.hypot(bx - ax, by - ay);
+      const dz = Math.abs(bz - az);
+      if (!(dz <= gmax * len)) return Infinity;
+      let hits = 0;
+      for (const t of STEEP_SAMPLES) {
+        const si = Math.round((ax + (bx - ax) * t - origin[0]) / cell) - i0;
+        const sj = Math.round((ay + (by - ay) * t - origin[1]) / cell) - j0;
+        if (si >= 0 && sj >= 0 && si < w && sj < h && steepAt(sj * w + si)) hits++;
+      }
+      const grade = len > 0 ? dz / len / gmax : 0;
+      let value = len * (1 + steepShare * hits + weights.grade * grade * grade);
+      if (Number.isFinite(inDir) && len > 0) {
+        let turn = Math.abs(Math.atan2(by - ay, bx - ax) - inDir);
+        if (turn > Math.PI) turn = 2 * Math.PI - turn;
+        value += turnWeight * turn * turn;
+      }
+      return value;
+    };
+    const relax = (
+      from: number,
+      to: number,
+      c: number,
+      ax: number,
+      ay: number,
+      bx: number,
+      by: number,
+    ) => {
+      if (!Number.isFinite(c) || g[from] + c >= g[to]) return;
+      g[to] = g[from] + c;
+      parent[to] = from;
+      dir[to] = Math.atan2(by - ay, bx - ax);
+      heap.push(g[to] + weights.heuristic * Math.hypot(goal[0] - bx, goal[1] - by), to);
+    };
+    // 끝 걸음 — 한 걸음 안이면 정확한 끝점으로(기울기 검사)
+    const tryGoal = (from: number, ax: number, ay: number, az: number) => {
+      if (Math.hypot(goal[0] - ax, goal[1] - ay) <= step + 0.5 * cell) {
+        relax(
+          from,
+          GOAL,
+          cost(ax, ay, az, goal[0], goal[1], zb, dir[from]),
+          ax,
+          ay,
+          goal[0],
+          goal[1],
+        );
+      }
+    };
+    g[START] = 0;
+    tryGoal(START, start[0], start[1], za);
+    // 첫 걸음 — 정확한 시작점에서 반지름 걸음 고리
+    const ci = Math.round((start[0] - origin[0]) / cell) - i0;
+    const cj = Math.round((start[1] - origin[1]) / cell) - j0;
+    for (let j = cj - reach - 1; j <= cj + reach + 1; j++) {
+      for (let i = ci - reach - 1; i <= ci + reach + 1; i++) {
+        if (i < 0 || j < 0 || i >= w || j >= h) continue;
+        const id = j * w + i;
+        const bx = nx(id);
+        const by = ny(id);
+        if (Math.abs(Math.hypot(bx - start[0], by - start[1]) - step) > 0.5 * cell) continue;
+        const bz = zAt(id);
+        if (Number.isNaN(bz)) continue;
+        relax(START, id, cost(start[0], start[1], za, bx, by, bz, NaN), start[0], start[1], bx, by);
+      }
+    }
+    let best = START;
+    let bestDist = span;
+    while (heap.size > 0 && spent < limit && !late) {
+      const u = heap.pop();
+      if (closed[u]) continue;
+      closed[u] = 1;
+      if (u === GOAL) return finish(GOAL, true);
+      spent++;
+      if ((spent & 1023) === 0 && performance.now() > deadline) late = true;
+      const ui = u % w;
+      const uj = Math.floor(u / w);
+      const ux = nx(u);
+      const uy = ny(u);
+      const uz = zs[u];
+      const left = Math.hypot(goal[0] - ux, goal[1] - uy);
+      if (left < bestDist) {
+        bestDist = left;
+        best = u;
+      }
+      tryGoal(u, ux, uy, uz);
+      const gu = g[u];
+      const du = dir[u];
+      for (let k = 0; k < offI.length; k++) {
+        const vi = ui + offI[k];
+        const vj = uj + offJ[k];
+        if (vi < 0 || vj < 0 || vi >= w || vj >= h) {
+          edge = true;
+          continue;
+        }
+        const v = vj * w + vi;
+        if (closed[v]) continue;
+        let vz = zs[v];
+        if (vz === Infinity) vz = zAt(v);
+        if (vz !== vz) continue; // NaN = 밖
+        const len = offLen[k];
+        const dz = Math.abs(vz - uz);
+        if (dz > gmax * len) continue;
+        let hits = 0;
+        for (let s = 4 * k; s < 4 * k + 4; s++) {
+          const at = u + sampleD[s];
+          const state = steepState[at];
+          if (state === 1 || (state === 0 && steepAt(at))) hits++;
+        }
+        const grade = dz / len / gmax;
+        let c = len * (1 + steepShare * hits + weights.grade * grade * grade);
+        if (du === du) {
+          let turn = Math.abs(offDir[k] - du);
+          if (turn > Math.PI) turn = 2 * Math.PI - turn;
+          c += turnWeight * turn * turn;
+        }
+        const next = gu + c;
+        if (next >= g[v]) continue;
+        g[v] = next;
+        parent[v] = u;
+        dir[v] = offDir[k];
+        const ex = goal[0] - (ux + offI[k] * cell);
+        const ey = goal[1] - (uy + offJ[k] * cell);
+        heap.push(next + weights.heuristic * Math.sqrt(ex * ex + ey * ey), v);
+      }
+    }
+    return finish(best, false);
+
+    function finish(last: number, reached: boolean): GuideSegment {
+      const chain: Point3[] = [];
+      for (let id = last; id !== -1; id = parent[id]) {
+        if (id === START) chain.push([start[0], start[1], za]);
+        else if (id === GOAL) chain.push([goal[0], goal[1], zb]);
+        else chain.push([nx(id), ny(id), zs[id]]);
+      }
+      chain.reverse();
+      return measure(chain, reached, 0, (x, y) => {
+        const si = Math.round((x - origin[0]) / cell) - i0;
+        const sj = Math.round((y - origin[1]) / cell) - j0;
+        return si >= 0 && sj >= 0 && si < w && sj < h && steepAt(sj * w + si);
+      });
+    }
+  }
+
+  // 길이 · 최대 기울기 · 급경사 지남 비율(걸음마다 칸 간격 표본)
+  function measure(
+    vertices: Point3[],
+    reached: boolean,
+    expanded: number,
+    steepAt: ((x: number, y: number) => boolean) | null,
+  ): GuideSegment {
+    let length = 0;
+    let maxGrade = 0;
+    let steepLength = 0;
+    for (let k = 1; k < vertices.length; k++) {
+      const [ax, ay, az] = vertices[k - 1];
+      const [bx, by, bz] = vertices[k];
+      const len = Math.hypot(bx - ax, by - ay);
+      if (len <= 0) continue;
+      length += len;
+      maxGrade = Math.max(maxGrade, Math.abs(bz - az) / len);
+      if (!steepAt) continue;
+      const parts = Math.max(1, Math.ceil(len / cell));
+      for (let p = 0; p < parts; p++) {
+        const t = (p + 0.5) / parts;
+        if (steepAt(ax + (bx - ax) * t, ay + (by - ay) * t)) steepLength += len / parts;
+      }
+    }
+    return {
+      vertices,
+      reached,
+      length,
+      maxGrade,
+      steepRatio: length > 0 ? steepLength / length : 0,
+      expanded,
+    };
+  }
+}
+
+/** 이진 힙(값 작은 것 먼저) — 타입 배열 · 늘어남. */
+class MinHeap {
+  private keys = new Float64Array(1024);
+  private ids = new Int32Array(1024);
+  size = 0;
+
+  push(key: number, id: number): void {
+    if (this.size === this.keys.length) {
+      const keys = new Float64Array(this.size * 2);
+      keys.set(this.keys);
+      const ids = new Int32Array(this.size * 2);
+      ids.set(this.ids);
+      this.keys = keys;
+      this.ids = ids;
+    }
+    let at = this.size++;
+    while (at > 0) {
+      const up = (at - 1) >> 1;
+      if (this.keys[up] <= key) break;
+      this.keys[at] = this.keys[up];
+      this.ids[at] = this.ids[up];
+      at = up;
+    }
+    this.keys[at] = key;
+    this.ids[at] = id;
+  }
+
+  pop(): number {
+    const top = this.ids[0];
+    const key = this.keys[--this.size];
+    const id = this.ids[this.size];
+    let at = 0;
+    for (;;) {
+      let child = 2 * at + 1;
+      if (child >= this.size) break;
+      if (child + 1 < this.size && this.keys[child + 1] < this.keys[child]) child++;
+      if (this.keys[child] >= key) break;
+      this.keys[at] = this.keys[child];
+      this.ids[at] = this.ids[child];
+      at = child;
+    }
+    this.keys[at] = key;
+    this.ids[at] = id;
+    return top;
+  }
+}

A00_Common/map/logic/map_slope_bands.ts

@@ -1,10 +1,11 @@
 /* =============================================================================
- * D03_PlanAnalysis_SlopeBands.ts
- * D03 급경사 범위(PLAN 603 · 요구 466 · 467 · 468) — 기울기 % 범위 · 색 · 비율 셈(화면 · 서버 없이).
+ * map_slope_bands.ts(logic)
+ * 공용 지도 급경사 범위(624-3 공용으로 옮김)(PLAN 603 · 요구 466 · 467 · 468) — 기울기 % 범위 · 색 · 비율 셈(화면 · 서버 없이).
  *   서버 값 그림 칸 = 기울기 % 내림(0~250 · 250 = 250 % 이상 · `D03_PlanAnalysis_Layers.slope_values_png`) ·
  *   칸 v 는 가운데(v + 0.5)가 [아래, 위) 안이면 그 범위(위 = 250 이면 250 % 이상도) · 앞 범위 먼저.
  *   기본 = 지식DB 15 · 35 · 40° 의 % — `임도망_편성.md:20` · `타당성평가.md:59` · `노선_배치.md:29`.
- *   부르는 곳 = `D03_PlanAnalysis_UI_SlopeBands.ts` · `D03_PlanAnalysis_UI_LayerLegend.ts`.
+ *   수평 바(631) = 경계 한 줄 ↔ 범위 · 칸 나눔 · 합침 · 경계 검사.
+ *   부르는 곳 = `map_slope_bands.ts` · `map_legend.ts` · D03 `UI_LayerLegend`.
  * ========================================================================== */
 
 export interface SlopeBand {
@@ -96,3 +97,74 @@ export function bandRatios(counts: number[], bands: SlopeBand[]): number[] {
   });
   return out.map((n) => n / total);
 }
+
+/** 수평 바 꼴(631 · 요구 537) — 경계 = [0, …, 250] 한 줄 · 칸 i = [경계 i, 경계 i+1) · 색 빈 글 = 칠 안 함. */
+export interface SlopeBar {
+  edges: number[];
+  colors: string[];
+}
+
+/** 범위 → 바(사이 빈 곳 = 칠 안 함 칸). */
+export function bandsToBar(bands: SlopeBand[]): SlopeBar {
+  const edges = [0];
+  const colors: string[] = [];
+  for (const band of [...bands].sort((a, b) => a.low - b.low)) {
+    if (band.low > edges.at(-1)!) {
+      edges.push(band.low);
+      colors.push("");
+    }
+    edges.push(band.high);
+    colors.push(band.color);
+  }
+  if (edges.at(-1)! < SLOPE_MAX_PCT) {
+    edges.push(SLOPE_MAX_PCT);
+    colors.push("");
+  }
+  return { edges, colors };
+}
+
+/** 바 → 범위(칠 안 함 칸은 뺌). */
+export const barToBands = (bar: SlopeBar): SlopeBand[] =>
+  bar.colors.flatMap((color, i) =>
+    color ? [{ low: bar.edges[i], high: bar.edges[i + 1], color }] : [],
+  );
+
+/** 경계 고칠 거리 — 없으면 null(빈 값 · 0 < 값 < 250 밖 · 같은 값 · 거꾸로). */
+export function checkEdges(edges: number[]): string | null {
+  for (let i = 1; i < edges.length - 1; i++) {
+    const at = `${i}번째 경계`;
+    if (!Number.isFinite(edges[i])) return `${at} — 값이 비었습니다`;
+    if (edges[i] <= 0 || edges[i] >= SLOPE_MAX_PCT)
+      return `${at} — 0 보다 크고 ${SLOPE_MAX_PCT} % 보다 작게`;
+    if (edges[i] === edges[i - 1]) return `${at} — 옆 경계와 같은 값입니다`;
+    if (edges[i] < edges[i - 1]) return `${at} — 왼쪽 경계보다 커야 합니다`;
+  }
+  return null;
+}
+
+const colored = (bar: SlopeBar): number => bar.colors.filter(Boolean).length;
+
+/** 칸 i 를 반으로(위 반 = 새 색) — 못 나누면 null(색 칸 SLOPE_MAX_BANDS · 너무 좁음 · 경계 틀림). */
+export function splitBar(bar: SlopeBar, i: number): SlopeBar | null {
+  if (colored(bar) >= SLOPE_MAX_BANDS || checkEdges(bar.edges)) return null;
+  const [low, high] = [bar.edges[i], bar.edges[i + 1]];
+  const mid = Math.round((low + high) * 5) / 10;
+  if (!(mid > low && mid < high)) return null;
+  const color =
+    SLOPE_COLORS.find((c) => !bar.colors.includes(c.color))?.color ??
+    SLOPE_COLORS[colored(bar) % SLOPE_COLORS.length].color;
+  return {
+    edges: [...bar.edges.slice(0, i + 1), mid, ...bar.edges.slice(i + 1)],
+    colors: [...bar.colors.slice(0, i + 1), color, ...bar.colors.slice(i + 1)],
+  };
+}
+
+/** 칸 i 를 이웃과 합침(왼쪽 · 첫 칸은 오른쪽 · 이웃 색 남음) — 칸 하나면 null. */
+export function mergeBar(bar: SlopeBar, i: number): SlopeBar | null {
+  if (bar.colors.length <= 1) return null;
+  const cut = i > 0 ? i : 1;
+  return {
+    edges: bar.edges.filter((_, k) => k !== cut),
+    colors: bar.colors.filter((_, k) => k !== i),
+  };
+}

A00_Common/map/map_draw_kind.css

@@ -0,0 +1,28 @@
+/* 공용 긋기 방식 칸(626-3 · `map_draw_kind.ts`) — 고름 아래 길이 · 기울기 두 열 */
+.map-draw-kind {
+  display: flex;
+  flex-direction: column;
+  gap: 6px;
+}
+
+.map-draw-kind__fields {
+  display: grid;
+  grid-template-columns: repeat(2, minmax(0, 1fr));
+  gap: var(--spacing-8);
+  align-items: start;
+}
+
+.map-draw-kind__fields[hidden] {
+  display: none;
+}
+
+.map-draw-kind__fields .ui-field {
+  margin: 0;
+  min-width: 0;
+}
+
+.map-draw-kind__fields .ui-input-unit,
+.map-draw-kind__fields .ui-input {
+  width: 100%;
+  min-width: 0;
+}

A00_Common/map/map_draw_kind.ts

@@ -0,0 +1,161 @@
+/* =============================================================================
+ * map_draw_kind.ts
+ * 공용 긋기 방식 칸(PLAN 626-3 · 599-1 · 625-1) — 예정노선(D03) 그리기 칸 · 노드 판 · B05 평면 예정노선 그리기가 같이 씀.
+ *   꼴 = 마디 고름 2 × 2(자유지정 · 길이·기울기 고정 / 길이 고정 · 기울기 고정) + 길이 · 기울기 두 열(기울기 아래 ≈ °) ·
+ *     방식에 안 쓰는 칸은 숨김(막힘 = 권한 없음만) · 설명 글 없음(요구 463-6).
+ *   쓰는 법 = `createDrawKindFields({ value, onChange })` → { root, get, set, setDisabled, setActive }.
+ *   켬끔 꼴(589-9) = `onActive` 를 주면 고른 방식을 다시 누르면 풀림 · 방식을 고르면 켜짐 — 켬 = 긋기 시작 · 끔 = 긋기 끝
+ *     (지금 켬인지는 `setActive` 로 맞춤 · 노드 판처럼 `onActive` 없는 곳은 늘 하나 고름).
+ * ========================================================================== */
+
+import type { UiSize } from "@ui/ui_template_button";
+import { createInputField } from "@ui/ui_template_input";
+import { createSegment } from "@ui/ui_template_segment";
+import { createText } from "@ui/ui_template_text";
+import "./map_draw_kind.css";
+
+/** 기울기 % → 각(°) 한 자리 글. */
+const slopeDegText1 = (pct: number): string => ((Math.atan(pct / 100) * 180) / Math.PI).toFixed(1);
+
+/** 제약 칸 처음 값 — 길이 = 측점 간격(지식DB 설계제원_총괄) · 기울기 = 간선 20 km/h 일반지형 상한(종단선형). */
+export const DRAW_DEFAULT_LENGTH_M = 20;
+export const DRAW_DEFAULT_SLOPE_PCT = 9;
+
+export type DrawConstraint = "free" | "length" | "slope" | "both";
+
+export interface DrawKindValue {
+  kind: DrawConstraint;
+  lengthM: number;
+  slopePct: number;
+}
+
+export const DRAW_KIND_LABELS: Record<DrawConstraint, string> = {
+  free: "자유지정",
+  both: "길이·기울기 고정",
+  length: "길이 고정",
+  slope: "기울기 고정",
+};
+
+export interface DrawKindFields {
+  root: HTMLElement;
+  get: () => DrawKindValue;
+  /** 값을 바꿈(onChange 는 안 부름). */
+  set: (value: Partial<DrawKindValue>) => void;
+  setDisabled: (disabled: boolean) => void;
+  /** 켬끔 꼴에서 지금 켬인지 맞춤(onActive 는 안 부름 · 끔 = 모두 풀린 모양). */
+  setActive: (on: boolean) => void;
+}
+
+/** 긋기 방식 칸 — 고름 · 길이 · 기울기가 바뀔 때마다 `onChange(지금 값)`(빈 · 틀린 수는 칸 오류만). */
+export function createDrawKindFields(opts: {
+  value: DrawKindValue;
+  onChange: (value: DrawKindValue) => void;
+  /** 켬끔 꼴 — 방식 고름 = true · 고른 방식 다시 누름 = false. */
+  onActive?: (on: boolean) => void;
+  size?: UiSize;
+}): DrawKindFields {
+  const size = opts.size ?? 24;
+  let value = { ...opts.value };
+  let disabled = false;
+  let active = !opts.onActive;
+  const changed = (): void => opts.onChange({ ...value });
+  const segment = createSegment({
+    options: (Object.keys(DRAW_KIND_LABELS) as DrawConstraint[]).map((kind) => ({
+      value: kind,
+      label: DRAW_KIND_LABELS[kind],
+    })),
+    value: active ? value.kind : "",
+    size,
+    columns: 2,
+    clearable: !!opts.onActive,
+    ariaLabel: "긋기 방식",
+    onChange: (next) => {
+      if (next === "") return void ((active = false), opts.onActive?.(false));
+      value.kind = next as DrawConstraint;
+      fieldsState();
+      changed();
+      if (opts.onActive && !active) ((active = true), opts.onActive(true));
+    },
+  });
+  segment.root.dataset.role = "draw-constraint";
+  const lengthField = createInputField({
+    label: "길이",
+    type: "number",
+    value: String(value.lengthM),
+    min: 1,
+    unit: "m",
+    size,
+    onInput: (text) => {
+      const next = Number(text);
+      lengthField.setError(next > 0 ? undefined : "0 보다 큰 수");
+      if (!(next > 0)) return;
+      value.lengthM = next;
+      changed();
+    },
+  });
+  lengthField.input.dataset.role = "draw-length";
+  const slopeField = createInputField({
+    label: "기울기",
+    type: "number",
+    value: String(value.slopePct),
+    unit: "%",
+    size,
+    onInput: (text) => {
+      const next = Number(text);
+      const ok = text.trim() !== "" && Number.isFinite(next);
+      slopeField.setError(ok ? undefined : "숫자");
+      if (!ok) return;
+      value.slopePct = next;
+      degText();
+      changed();
+    },
+  });
+  slopeField.input.dataset.role = "draw-slope";
+  const slopeDegText = createText("", "muted");
+  slopeDegText.dataset.role = "draw-slope-deg";
+  const degText = (): void => {
+    slopeDegText.textContent = `≈ ${slopeDegText1(Math.abs(value.slopePct))}°`;
+  };
+  const slopeColumn = document.createElement("div");
+  slopeColumn.append(slopeField.root, slopeDegText);
+  const fields = document.createElement("div");
+  fields.className = "map-draw-kind__fields";
+  fields.append(lengthField.root, slopeColumn);
+  const root = document.createElement("div");
+  root.className = "map-draw-kind";
+  root.append(segment.root, fields);
+
+  function fieldsState(): void {
+    for (const button of segment.root.querySelectorAll("button")) button.disabled = disabled;
+    lengthField.input.disabled = slopeField.input.disabled = disabled;
+    fields.hidden = value.kind === "free";
+    lengthField.root.hidden = value.kind === "slope";
+    slopeColumn.hidden = value.kind === "length";
+  }
+  degText();
+  fieldsState();
+
+  return {
+    root,
+    get: () => ({ ...value }),
+    set(next) {
+      value = { ...value, ...next };
+      segment.set(active ? value.kind : "");
+      lengthField.input.value = String(value.lengthM);
+      slopeField.input.value = String(value.slopePct);
+      lengthField.setError(undefined);
+      slopeField.setError(undefined);
+      degText();
+      fieldsState();
+    },
+    setDisabled(next) {
+      disabled = next;
+      fieldsState();
+    },
+    setActive(on) {
+      if (!opts.onActive) return;
+      active = on;
+      segment.set(active ? value.kind : "");
+    },
+  };
+}

A00_Common/map/map_forest_layers.ts

@@ -0,0 +1,235 @@
+/* =============================================================================
+ * map_forest_layers.ts
+ * 공용 지도 — 받은 산림 · 환경 자료 겹(PLAN 622-2 · 624-2 · 요구 529 · 530) — 서버 줌별 조각(622-1)을 GL 고정 소스로(위성 · 등고선 615 꼴).
+ *   벡터 = 임도망도(forest_road · 전국 국가임도 · 간선 · 작업 · 산불 색 · 줌 따라 굵기 · 줌 14 부터 연도 · 종류 글) · 산림입지도(forest_soil · 토양 무리 색 ·
+ *     반투명 · z10 아래 숨김) · 경제림(eco_forest · 국유 · 사유 테두리) /
+ *   그림 = 생태자연도(ecology) · 산사태위험지도(landslide · 옛 캔버스는 받은 범위 한 장 그대로) · 암상 지질도(geology_map · 760-1 · 도형 = `map_geology`).
+ *   조각만 쓰는 겹(`TILE_ONLY`) = 받기 없음 · 옛 캔버스(그래픽 카드 끔)엔 안 보임.
+ *   토양 무리 색(`soilColor`) = 조각(`code` = SLTP_CD 두 자리) · 브이월드 요약(기호 「B₁」) 같은 색 — 범례 · 옛 캔버스도 이것.
+ *   부르는 곳 = `map_layer_specs`(꼴) · D03 `UI_MapGl`(소스) · `UI_Layers`(받기 거름) · `map_legend`(범례).
+ * ========================================================================== */
+
+import type { ExpressionSpecification, SourceSpecification } from "maplibre-gl";
+import type { LegendItem } from "@ui/ui_template_flow_legend";
+import { GL_FONT, tileSource, type GlSpec } from "@ui/ui_template_gl_map";
+import { themeColor } from "@ui/ui_template_palette";
+import type { MapLayerKey } from "./map_layer_list";
+
+/** 조각만 쓰는 겹 — 받을 자료 없음(위성 포함). */
+const TILE_ONLY = ["satellite", "nationalRoad", "ecoForest", "ecology"] as const;
+export type TileOnlyKey = (typeof TILE_ONLY)[number];
+export const tileOnly = (key: MapLayerKey): key is TileOnlyKey =>
+  (TILE_ONLY as readonly string[]).includes(key);
+
+/** 받는 동안 서클에 세는 조각 소스(등고선 포함). */
+export const TRACKED_SOURCES = [
+  "contour",
+  "forest_road",
+  "forest_soil",
+  "eco_forest",
+  "ecology",
+  "landslide",
+  "geology_map",
+];
+
+/** 고정 소스 — 벡터 z8~15(서버 줌별 단순화) · 그림 z6~19. */
+export function forestSources(projectId: string): Record<string, SourceSpecification> {
+  const vt = (name: string) => tileSource(projectId, `vt/${name}`, "pbf", 8, 15);
+  const wmt = (name: string) => tileSource(projectId, `wmt/${name}`, "png", 6, 19);
+  return {
+    forest_road: vt("forest_road"),
+    forest_soil: vt("forest_soil"),
+    eco_forest: vt("eco_forest"),
+    ecology: wmt("ecology"),
+    landslide: wmt("landslide"),
+    geology_map: wmt("geology"),
+  };
+}
+
+/** 토양형 코드(산림입지토양도 SLTP_CD) → 기호. 무리 = 갈색 · 적황색 · 암적색 · 회갈색 · 화산회 · 침식 · 미숙 · 그 밖(비산림). */
+const SOIL_SYMBOLS: Record<string, string> = {
+  "01": "B1", "02": "B2", "03": "B3", "04": "B4",
+  "05": "rB1", "06": "rB2", "07": "R1", "08": "R2", "09": "Y",
+  "10": "DR1", "11": "DR2", "12": "DR3", "13": "DRb1", "14": "DRb2",
+  "15": "GrB1", "16": "GrB2", "17": "Va1", "18": "Va2", "19": "Va3", "20": "Va4",
+  "21": "Va-R1", "22": "Va-R2", "23": "Va-gr",
+  "24": "Er1", "25": "Er2", "26": "Er-c", "27": "Im", "28": "Li", "29": "Bs",
+}; // prettier-ignore
+/** 무리 첫 코드(차례 = `--draw-map-soil-1..6`). */
+const SOIL_GROUP_START = [1, 5, 10, 15, 24, 30];
+const soilToken = (group: number): string => `--draw-map-soil-${group + 1}`;
+const SUB = /[₀-₉]/g;
+
+/** 토양형(조각 두 자리 코드 · 브이월드 기호 「B₁」) → 무리 색 값 · 모름 = 「그 밖」. */
+export function soilColor(code: string): string {
+  const plain = code.trim().replace(SUB, (c) => String(c.charCodeAt(0) - 0x2080));
+  const found = /^\d+$/.test(plain)
+    ? Number(plain)
+    : Number(Object.keys(SOIL_SYMBOLS).find((key) => SOIL_SYMBOLS[key] === plain) ?? 99);
+  return soilToken(Math.max(SOIL_GROUP_START.filter((start) => found >= start).length - 1, 0));
+}
+
+/** 임도 사업 구분(`kind` 1 간선 · 2 작업 · 3 산불) 색 값. */
+const ROAD_KINDS = [
+  { kind: 1, label: "간선", color: "--draw-map-national-road-main" },
+  { kind: 2, label: "작업", color: "--draw-map-national-road-work" },
+  { kind: 3, label: "산불", color: "--draw-map-national-road-fire" },
+];
+const ECO_KINDS = [
+  { own: "국유", color: "--draw-map-eco-national" },
+  { own: "사유", color: "--draw-map-eco-private" },
+];
+/** 생태자연도 범례 = 환경부 WMS 그림 색(3등급 = 칠 없음). */
+const ECOLOGY_LEGEND = [
+  { label: "1등급", color: "--draw-map-ecology-1" },
+  { label: "2등급", color: "--draw-map-ecology-2" },
+  { label: "별도관리지역", color: "--draw-map-ecology-x" },
+];
+
+const HALO = "rgba(0, 0, 0, 0.55)";
+const ROUND = { "line-join": "round", "line-cap": "round" } as const;
+const zoomWidth = (z8: number, z12: number, z15: number): ExpressionSpecification =>
+  ["interpolate", ["linear"], ["zoom"], 8, z8, 12, z12, 15, z15] as ExpressionSpecification;
+
+type Spec = GlSpec<MapLayerKey>;
+const raster = (
+  key: "landslide" | "ecology" | "geology",
+  opacity: number,
+  source: string = key,
+): Spec =>
+  ({
+    key,
+    id: source === key ? key : source,
+    type: "raster",
+    source,
+    paint: { "raster-opacity": opacity, "raster-fade-duration": 0 },
+  }) as Spec;
+
+/** 그림 겹(암상 지질도 · 산사태위험 · 생태자연도) — 아래 차례(급경사 위). */
+export const forestRasterSpecs = (): Spec[] => [
+  raster("geology", 0.5, "geology_map"),
+  raster("landslide", 0.6),
+  raster("ecology", 0.55),
+];
+
+/** 면 겹(산림입지도 · 경제림) — 보호구역 아래. */
+export function forestAreaSpecs(): Spec[] {
+  const soilAt = (group: number): string => themeColor(soilToken(group), "#e879f9");
+  const soil = [
+    "step",
+    ["to-number", ["get", "code"], 99],
+    soilAt(0),
+    ...SOIL_GROUP_START.slice(1).flatMap((start, i) => [start, soilAt(i + 1)]),
+  ] as ExpressionSpecification;
+  const eco = [
+    "match",
+    ["get", "own"],
+    ...ECO_KINDS.flatMap(({ own, color }) => [own, themeColor(color, "#34d399")]),
+    themeColor(ECO_KINDS[1].color, "#a78bfa"),
+  ] as unknown as ExpressionSpecification;
+  const vector = (source: string) => ({ source, "source-layer": source });
+  return [
+    {
+      key: "soils",
+      id: "soils",
+      type: "fill",
+      ...vector("forest_soil"),
+      minzoom: 10,
+      paint: { "fill-color": soil, "fill-opacity": 0.35 },
+    } as Spec,
+    {
+      key: "soils",
+      id: "soils-edge",
+      type: "line",
+      ...vector("forest_soil"),
+      minzoom: 10,
+      layout: ROUND,
+      paint: { "line-color": soil, "line-width": 0.8, "line-opacity": 0.9 },
+    } as Spec,
+    {
+      key: "ecoForest",
+      id: "ecoForest",
+      type: "line",
+      ...vector("eco_forest"),
+      layout: ROUND,
+      paint: { "line-color": eco, "line-width": zoomWidth(1, 1.8, 2.4) },
+    } as Spec,
+  ];
+}
+
+/** 임도망도(전국 국가임도) 선 — 검은 테 + 사업 구분 색(도로 위 · 임도(업로드) 아래). */
+export function forestRoadSpecs(): Spec[] {
+  const color = [
+    "match",
+    ["get", "kind"],
+    ...ROAD_KINDS.flatMap(({ kind, color }) => [kind, themeColor(color, "#ff6b00")]),
+    themeColor(ROAD_KINDS[0].color, "#ff6b00"),
+  ] as unknown as ExpressionSpecification;
+  const line = (id: string, paint: Record<string, unknown>): Spec =>
+    ({
+      key: "nationalRoad",
+      id,
+      type: "line",
+      source: "forest_road",
+      "source-layer": "forest_road",
+      layout: ROUND,
+      paint,
+    }) as Spec;
+  return [
+    line("nationalRoad-halo", { "line-color": HALO, "line-width": zoomWidth(2.2, 3.6, 5.6) }),
+    line("nationalRoad", { "line-color": color, "line-width": zoomWidth(1, 2, 3.6) }),
+  ];
+}
+
+/** 임도망도 글(요구 534) — 줌 14 부터 선 따라 「개설 연도 · 종류」(연도 0 = 종류만) · 겹치면 뺌 · 꼴 = 지명 글. */
+export function forestRoadLabelSpec(): Spec {
+  const kind = [
+    "match",
+    ["get", "kind"],
+    ...ROAD_KINDS.flatMap(({ kind, label }) => [kind, label]),
+    "",
+  ] as unknown as ExpressionSpecification;
+  return {
+    key: "nationalRoad",
+    id: "nationalRoad-label",
+    type: "symbol",
+    source: "forest_road",
+    "source-layer": "forest_road",
+    minzoom: 14,
+    layout: {
+      "symbol-placement": "line",
+      "symbol-spacing": 300,
+      "text-field": [
+        "concat",
+        ["case", [">", ["get", "year"], 0], ["concat", ["to-string", ["get", "year"]], " · "], ""],
+        kind,
+      ],
+      "text-font": [GL_FONT],
+      "text-size": 11,
+      "text-max-angle": 30,
+      "text-padding": 2,
+    },
+    paint: {
+      "text-color": themeColor("--draw-map-place", "#f8fafc"),
+      "text-halo-color": "rgba(0, 0, 0, 0.7)",
+      "text-halo-width": 1.5,
+    },
+  } as unknown as Spec;
+}
+
+/** 범례 — 켠 조각 겹(산사태위험 = 범례 자리 `LANDSLIDE_LEGEND` 따로). */
+export function forestLegendRows(on: Record<MapLayerKey, boolean>): LegendItem[][] {
+  const item = (label: string, color: string, kind?: LegendItem["kind"]): LegendItem => ({
+    label,
+    color: `var(${color})`,
+    ...(kind ? { kind } : {}),
+  });
+  const rows: LegendItem[][] = [];
+  if (on.nationalRoad)
+    rows.push(ROAD_KINDS.map(({ label, color }) => item(`임도망도 ${label}`, color, "line")));
+  if (on.ecoForest)
+    rows.push(ECO_KINDS.map(({ own, color }) => item(`경제림 ${own}`, color, "line")));
+  if (on.ecology)
+    rows.push(ECOLOGY_LEGEND.map(({ label, color }) => item(`생태자연도 ${label}`, color)));
+  return rows;
+}

A00_Common/map/map_geology.ts

@@ -0,0 +1,161 @@
+/* =============================================================================
+ * map_geology.ts
+ * 공용 지도 암상 지질도 겹(PLAN 760-1 · 요구 597-3 · 598-3) — D03 예정노선 · B05 평면이 같이 씀.
+ *   그림 = KIGAM 5만 WMS 조각(`map_forest_layers` 「geology_map」) · 도형 = 서버 `/plan/layers/geology`
+ *     (기호별 요약 · 경위도 면 · 노선마다 암상 구간 · 키는 서버만).
+ *   색 = 바위 갈래(서버 `ROCK_GROUPS` 차례) → `--draw-map-geology-1..6` · 면 위 글 = 「기호 · 첫 암상 낱말」.
+ *   범례 줄(`geologyRow`) · 노선 구간 표(`geologyTail` · 참고 — 토사 · 암 판정 아님) = 범례 칸.
+ * ========================================================================== */
+
+import type { LegendItem } from "@ui/ui_template_flow_legend";
+import { GL_FONT, type GlSpec } from "@ui/ui_template_gl_map";
+import { themeColor } from "@ui/ui_template_palette";
+import { createTable } from "@ui/ui_template_table";
+import { el } from "@ui/ui_template_elements_base";
+import { stationLabel } from "@util/common_util_station";
+import { request, type GeoJsonCollection } from "./map_layer_api";
+import { hectare } from "./map_layer_data";
+import type { MapLayerKey } from "./map_layer_list";
+
+/** 기호 하나(받은 범위 안). */
+export interface GeologyUnit {
+  symnum: string;
+  symbol: string;
+  litho: string;
+  strata: string;
+  age: string;
+  sheet: string;
+  group: number;
+  count: number;
+  area_m2: number;
+}
+
+/** 노선 구간 — `i` = 요약 차례 · -1 = 자료 없음. */
+export interface GeologySegment {
+  from_m: number;
+  to_m: number;
+  i: number;
+}
+
+export interface PlanGeology extends GeoJsonCollection {
+  source: string;
+  summary: GeologyUnit[];
+  groups: string[];
+  routes: Array<{ name: string; segments: GeologySegment[] }>;
+}
+
+const GROUP_FALLBACK = ["#f472b6", "#fb923c", "#fde047", "#818cf8", "#e5e7eb", "#5eead4"];
+const groupToken = (group: number): string => `--draw-map-geology-${Math.min(group, 5) + 1}`;
+const firstWord = (text: string): string => text.split(/\s+/)[0] ?? "";
+/** 긴 암상 글 줄임(범례 · 표 폭). */
+const short = (text: string, max = 22): string =>
+  text.length > max ? `${text.slice(0, max)}…` : text;
+
+/** 받기 — 면 위 글 꼴을 먼저 읽어 둠(한글 글자). */
+export async function fetchPlanGeology(projectId: string): Promise<PlanGeology> {
+  const got = await request<PlanGeology>(`/projects/${projectId}/plan/layers/geology`);
+  const text = got.summary.map((unit) => unit.symbol + unit.litho).join("") || "가";
+  await document.fonts.load(`600 24px "${GL_FONT}"`, text).catch(() => null);
+  return got;
+}
+
+/** GL 자료 — 지물마다 색(`_color`) · 글(`_label`). */
+export function geologyCollection(info: PlanGeology): GeoJsonCollection {
+  return {
+    features: (info.features ?? []).map((feature) => {
+      const unit = info.summary[Number(feature.properties?.["i"])];
+      const group = unit?.group ?? 5;
+      return {
+        ...feature,
+        properties: {
+          ...feature.properties,
+          _color: themeColor(groupToken(group), GROUP_FALLBACK[group] ?? GROUP_FALLBACK[5]),
+          _label: unit ? `${unit.symbol} · ${firstWord(unit.litho)}` : "",
+        },
+      };
+    }),
+  };
+}
+
+/** GL 꼴 — 연한 채움 · 갈래 색 테두리 · 면 위 글(겹치면 뺌). */
+export function geologySpecs(): GlSpec<MapLayerKey>[] {
+  const color = ["get", "_color"];
+  return [
+    {
+      key: "geology",
+      id: "geology",
+      type: "fill",
+      source: "geology",
+      paint: { "fill-color": color, "fill-opacity": 0.2 },
+    },
+    {
+      key: "geology",
+      id: "geology-edge",
+      type: "line",
+      source: "geology",
+      layout: { "line-join": "round" },
+      paint: { "line-color": color, "line-width": 1.6, "line-opacity": 0.95 },
+    },
+    {
+      key: "geology",
+      id: "geology-label",
+      type: "symbol",
+      source: "geology",
+      layout: {
+        "text-field": ["get", "_label"],
+        "text-font": [GL_FONT],
+        "text-size": 12,
+        "text-padding": 4,
+      },
+      paint: {
+        "text-color": color,
+        "text-halo-color": "rgba(0, 0, 0, 0.75)",
+        "text-halo-width": 1.5,
+      },
+    },
+  ] as unknown as GlSpec<MapLayerKey>[];
+}
+
+const unitColor = (unit: GeologyUnit | undefined): string =>
+  unit ? `var(${groupToken(unit.group)})` : "transparent";
+
+/** 범례 줄 — 기호마다 「기호 대표암상 넓이」(갈래 색) · 없으면 한 줄. */
+export function geologyRow(info: PlanGeology): LegendItem[] {
+  if (!info.summary.length)
+    return [{ label: "암상 지질도 없음(받은 범위 안)", color: "transparent", off: true }];
+  return info.summary.map((unit) => ({
+    label: `${unit.symbol} ${short(unit.litho || unit.strata)} ${hectare(unit.area_m2)}`,
+    color: unitColor(unit),
+  }));
+}
+
+/** 노선 따라 바위 종류 구간 표(노선마다) + 참고 글 — 켬 · 받음 · 노선 있을 때만. */
+export function geologyTail(on: Record<MapLayerKey, boolean>, info?: PlanGeology): HTMLElement[] {
+  if (!on.geology || !info?.routes.length) return [];
+  const columns = [
+    { label: "측점" },
+    { label: "길이", align: "end" as const },
+    { label: "기호" },
+    { label: "대표암상" },
+  ];
+  const tables = info.routes.map((route) => {
+    const rows = route.segments.map((seg) => {
+      const unit = info.summary[seg.i];
+      return [
+        `${stationLabel(seg.from_m, 20)} ~ ${stationLabel(seg.to_m, 20)}`,
+        `${(seg.to_m - seg.from_m).toFixed(0)} m`,
+        unit?.symbol ?? "—",
+        unit ? short(unit.litho || unit.strata, 30) : "자료 없음",
+      ];
+    });
+    return el("div", {
+      className: "ui-legend ui-legend--vertical",
+      children: [`암상 구간 — ${route.name}`, createTable(columns, rows, { density: "data" })],
+    });
+  });
+  const note = el("div", {
+    className: "ui-legend",
+    children: ["참고 — 토사 · 암 판정 아님(1:50,000 바위 종류 · 경계 수십 m 어긋날 수 있음)"],
+  });
+  return [...tables, note];
+}

A00_Common/map/map_layer_api.ts

@@ -0,0 +1,234 @@
+/* =============================================================================
+ * map_layer_api.ts
+ * 공용 지도 겹 받기(PLAN 569 · 581 · 584 · 603 · 605 · 606 · 624-3 · 624-4 · 요구 530) — D03 예정노선 · B05 평면이 같이 씀(D03_Api 에서 옮김).
+ *   서버 길 = `/api/projects/{id}/plan/…`(624-1 · 임도 프로젝트도 · 띠 · 올린 임도망도 = 예정노선만).
+ *   급경사 · 음영 · 0차곡 = 지형 원천 인자 `terrain`(지형 칩 값 · 624-4).
+ *   지적도 · 도엽 겹 GeoJSON 경위도 · 도엽 조각 · 그림 겹(급경사 · 음영기복 · 산사태위험) · 보호구역 · 산림입지도 ·
+ *   선 겹(단층 · 지질구조선) · 0차곡 · 띠 · 올린 임도망도(올리기 · 지움) · 산사태취약지역.
+ *   D03 = `D03_PlanAnalysis_Api` 가 다시 내놓음(부르는 곳 그대로).
+ * ========================================================================== */
+
+import { API_BASE_URL } from "@config/config_frontend";
+import type { TerrainSource } from "./map_terrain_chip";
+
+/** 경위도 GeoJSON 묶음 — B04 `GeoJsonCollection` 과 같은 꼴(공용 폴더는 페이지 파일을 안 부름). */
+export type GeoJsonCollection = {
+  features?: Array<{
+    geometry?: { type: string; coordinates: unknown } | null;
+    properties?: Record<string, unknown> | null;
+  }>;
+};
+
+export async function request<T>(path: string): Promise<T> {
+  const response = await fetch(`${API_BASE_URL}${path}`, {
+    credentials: "include",
+    headers: { "Content-Type": "application/json" },
+  });
+  const body = (await response.json().catch(() => ({}))) as T & { detail?: unknown };
+  if (!response.ok) {
+    const detail = typeof body.detail === "string" ? body.detail : `HTTP ${response.status}`;
+    throw new Error(detail);
+  }
+  return body;
+}
+
+const base = (projectId: string): string => `/projects/${projectId}/plan`;
+
+/** 지도 겹 그림(569-1) — 작업 좌표계 m 상자(칸 가장자리) · data URL(위 = 북). */
+export interface PlanRaster {
+  box_m: [number, number, number, number];
+  /** 경위도 네 귀퉁이(왼쪽 아래 · 오른쪽 아래 · 오른쪽 위 · 왼쪽 위) — GL 바탕(586-1). */
+  box?: Array<[number, number]>;
+  image: string;
+  /** 급경사만(603) — `counts[v]` = 기울기 % 내림 v(0~250) 칸 수 · 그림 = 회색 칸 값(255 = 빈 칸). */
+  counts?: number[];
+  /** 쓴 지형 원천(624-1 · 급경사 · 음영). */
+  source?: string;
+}
+
+/** 지형 원천 인자(624-1) — 안 넘김 = 서버 기본(D = 수치지형도 · B = 설계 지형). */
+const terrainQuery = (terrain?: TerrainSource): string => (terrain ? `&terrain=${terrain}` : "");
+
+export const fetchPlanCadastral = (projectId: string): Promise<GeoJsonCollection> =>
+  request(`${base(projectId)}/layers/cadastral`);
+
+/** 도엽 겹(`도로중심선` 등) — 없으면 서버가 받은 도엽에서 풀어 냄. */
+export const fetchPlanSheetLayer = (projectId: string, key: string): Promise<GeoJsonCollection> =>
+  request(`${base(projectId)}/layers/sheet?key=${encodeURIComponent(key)}`);
+
+/** 보이는 도엽(606-2) — 지도 보기 경위도 상자 → 수 · 번호(가운데부터 · 30 장 넘음 = 빈 목록). */
+export const fetchPlanSheetTiles = (
+  projectId: string,
+  bbox: [number, number, number, number],
+): Promise<{ count: number; sheets: string[] }> =>
+  request(`${base(projectId)}/sheet-tiles?bbox=${bbox.map((v) => v.toFixed(5)).join(",")}`);
+
+/** 도엽 조각 하나(606-1) — 공용 창고 · 없으면 서버가 만듦. */
+export const fetchPlanSheetTile = (
+  projectId: string,
+  sheet: string,
+  name: string,
+): Promise<GeoJsonCollection> =>
+  request(`${base(projectId)}/sheet-tiles/${sheet}/${encodeURIComponent(name)}`);
+
+/** 그림 겹 — 급경사 = PNG 바이트 + 머리 `X-Plan-Raster`(616-4 · `image` = blob 주소 · 다 읽으면
+ *  `slopeValues` 가 놓음) · 그 밖 = JSON(base64 그림). */
+export const fetchPlanRaster = async (
+  projectId: string,
+  kind: "slope" | "hillshade" | "landslide",
+  terrain?: TerrainSource,
+): Promise<PlanRaster> => {
+  const path = `${base(projectId)}/layers/raster?kind=${kind}${terrainQuery(terrain)}`;
+  if (kind !== "slope") return request(path);
+  const response = await fetch(`${API_BASE_URL}${path}`, { credentials: "include" });
+  if (!response.ok) {
+    const body = (await response.json().catch(() => ({}))) as { detail?: unknown };
+    throw new Error(typeof body.detail === "string" ? body.detail : `HTTP ${response.status}`);
+  }
+  const meta = JSON.parse(response.headers.get("X-Plan-Raster") ?? "{}") as PlanRaster;
+  return { ...meta, image: URL.createObjectURL(await response.blob()) };
+};
+
+/** 보호 · 규제 구역(581-1) — 지물 `kind` · `name` · `area_m2` + 종류별 개수 · 넓이(실패 = `failed`). */
+export interface PlanZones extends GeoJsonCollection {
+  summary: Record<string, { label: string; count: number; area_m2: number; failed?: boolean }>;
+}
+
+export const fetchPlanZones = (projectId: string): Promise<PlanZones> =>
+  request(`${base(projectId)}/layers/zones`);
+
+/** 산림입지도(581-2) — 지물 `code` · `name` · `area_m2` + 토양형별 개수 · 넓이(코드 차례). */
+export interface PlanSoils extends GeoJsonCollection {
+  summary: Array<{ code: string; name: string; count: number; area_m2: number }>;
+}
+
+export const fetchPlanSoils = (projectId: string): Promise<PlanSoils> =>
+  request(`${base(projectId)}/layers/soils`);
+
+/** 계류 100 m · 도로 300 m 띠(581-1) — 받은 범위 안 넓이 · 비율. */
+export interface PlanBand {
+  dist_m: number;
+  lines: number;
+  area_m2: number;
+  ratio: number;
+  collection: GeoJsonCollection;
+}
+
+/** 선 겹(584-1) — 받은 범위 안 선 + 가닥 · 길이 m. */
+export interface PlanLines extends GeoJsonCollection {
+  summary: { count: number; length_m: number };
+}
+
+/** 단층 · 지질구조선(브이월드 WFS · 서버 `LINE_KINDS` 열쇠). */
+export const fetchPlanLines = (projectId: string, kind: string): Promise<PlanLines> =>
+  request(`${base(projectId)}/layers/lines?kind=${encodeURIComponent(kind)}`);
+
+/** 0차곡(584-1 · 지형 추정) — 위 집수 넓이 [min_m2, max_m2) 선 + 가닥 · 길이 m. */
+export interface PlanZeroOrder {
+  min_m2: number;
+  max_m2: number;
+  cell_m: number;
+  count: number;
+  length_m: number;
+  collection: GeoJsonCollection;
+  /** 쓴 지형 원천(624-1). */
+  source?: string;
+}
+
+export const fetchPlanZeroOrder = (
+  projectId: string,
+  terrain?: TerrainSource,
+): Promise<PlanZeroOrder> =>
+  request(`${base(projectId)}/layers/zero-order?${terrainQuery(terrain).slice(1)}`);
+
+export const fetchPlanBands = (projectId: string): Promise<{ stream: PlanBand; road: PlanBand }> =>
+  request(`${base(projectId)}/layers/bands`);
+
+/** 올린 묶음 한 줄(605-1) — 올릴 때마다 하나 · 자른 가닥 · 길이 m · 원본 선 수 · 잘린 상자 · 기준점 거리. */
+export interface PlanRoadBundle {
+  id: string;
+  name: string;
+  files: string[];
+  bytes: number | null;
+  uploaded_at: string | null;
+  count: number;
+  length_m: number;
+  total: number;
+  bounds: [number, number, number, number] | null;
+  distance_m: number | null;
+}
+
+/** 올린 임도망도(584-3 · 595-4 · 605-1) — 묶음 모두를 합친 값: 기준점 ±5 km ∪ 받은 지형으로 자른 선
+ *  (선마다 `__bundle` 묶음 번호 · `__line` 묶음 안 차례) + 가닥 · 길이 m · 원본 선 수 · 좌표계 ·
+ *  잘린 상자([서, 남, 동, 북] 경위도) · 기준점 ~ 가장 가까운 임도 m · 마지막 올린 파일 · 묶음 줄. */
+export interface PlanForestRoads {
+  bundles: PlanRoadBundle[];
+  count: number;
+  length_m: number;
+  total: number;
+  crs: string[];
+  bounds: [number, number, number, number] | null;
+  distance_m: number | null;
+  source: { files: string[]; bytes: number; uploaded_at: string } | null;
+  collection: GeoJsonCollection;
+}
+
+/** 올린 적 없으면 오류(404 글 그대로). */
+export const fetchPlanForestRoads = (projectId: string): Promise<PlanForestRoads> =>
+  request(`${base(projectId)}/layers/forest-roads`);
+
+/** 묶음 하나 지움(605-1) — 남은 묶음 합친 값 · 하나도 안 남으면 null. */
+export async function deletePlanForestRoad(
+  projectId: string,
+  bundle: string,
+): Promise<PlanForestRoads | null> {
+  const response = await fetch(
+    `${API_BASE_URL}${base(projectId)}/layers/forest-roads/${encodeURIComponent(bundle)}`,
+    { method: "DELETE", credentials: "include" },
+  );
+  const body = (await response.json().catch(() => ({}))) as PlanForestRoads & {
+    detail?: unknown;
+  };
+  if (!response.ok)
+    throw new Error(typeof body.detail === "string" ? body.detail : `HTTP ${response.status}`);
+  return body.bundles.length ? body : null;
+}
+
+/** 임도망도 SHP 올리기(zip 하나 · shp · shx · dbf · prj 묶음) — 못 읽으면 서버 글 그대로 오류. */
+export async function uploadPlanForestRoads(
+  projectId: string,
+  files: File[],
+): Promise<PlanForestRoads> {
+  const form = new FormData();
+  for (const file of files) form.append("files", file);
+  const response = await fetch(`${API_BASE_URL}${base(projectId)}/layers/forest-roads`, {
+    method: "POST",
+    credentials: "include",
+    body: form,
+  });
+  const body = (await response.json().catch(() => ({}))) as PlanForestRoads & {
+    detail?: unknown;
+  };
+  if (!response.ok)
+    throw new Error(typeof body.detail === "string" ? body.detail : `HTTP ${response.status}`);
+  return body;
+}
+
+/** 산사태취약지역(584-3) — 받은 범위 안 점 · 지번 맞는 필지 테두리 · 시도별 표 · 표 없는 시도. */
+export interface PlanLandslideZones {
+  points: Array<{
+    lon: number;
+    lat: number;
+    kind: string | null;
+    area_m2: number | null;
+    place: string;
+  }>;
+  parcels: GeoJsonCollection;
+  sidos: Array<{ code: string; name: string; rows: number; located: number; basis?: string }>;
+  missing: string[];
+  /** 지적도를 받았나(못 받으면 점만). */
+  cadastral: boolean;
+}
+
+export const fetchPlanLandslideZones = (projectId: string): Promise<PlanLandslideZones> =>
+  request(`${base(projectId)}/layers/landslide-zones`);

A00_Common/map/map_layer_bar.ts

@@ -0,0 +1,133 @@
+/* =============================================================================
+ * map_layer_bar.ts
+ * 공용 지도 겹 줄(PLAN 569-2 · 586-2 · 624-2 · 634-2 · 요구 530 · 546) — 겹 단추 한 줄(공용 지도 도구줄 `createMapTools`):
+ *   단독 단추(표 묶음 없음) | 묶음 단추(여럿 고르기 메뉴 · 하나라도 켜면 눌림 · 골라도 안 닫힘) | 그래픽 카드 단추(GL ↔ 옛 캔버스).
+ *   보일 겹 · 묶음 · 호버제목 · 처음 켬 · 취향 열쇠 = 표(`map_layer_list`) · 누르면 켬끔 뒤집고 취향에 적고 `onToggle`.
+ *   막힘 = 지형을 아직 안 받음(`ready: false`) · 조각만 쓰는 겹은 옛 캔버스에서 · 페이지 까닭(`why`) — 「제목 — 까닭」.
+ *   받기 · 그리기 · 범례는 페이지 몫 — 켬끔 값(`on`)은 같은 객체를 같이 씀.
+ *   쓰는 법 = `createMapLayerBar({ page: "d03", glOn, onToggle, onGl })` → `{ root, bar, on, toggle, save, sync }`.
+ * ========================================================================== */
+
+import { createIconButton } from "@ui/ui_template_button";
+import { createPickMenu, type PickMenu } from "@ui/ui_template_context_menu";
+import { createMapTools, mapToolTip } from "@ui/ui_template_map_tools";
+import { writeByKey } from "../b_page_state";
+import { tileOnly } from "./map_forest_layers";
+import {
+  LAYER_GROUPS,
+  MAP_LAYER_PAGES,
+  pageLayers,
+  readLayerPref,
+  type LayerGroup,
+  type MapLayerKey,
+  type MapPage,
+} from "./map_layer_list";
+
+/** 그래픽 카드 단추 호버(표 밖 · 그룹1 끝 단독). */
+const GL_TITLE = "그래픽 카드";
+
+export interface MapLayerBar {
+  /** 도구줄 감싼 것(자리는 페이지 CSS · 한 행 = `createMapToolRow`). */
+  root: HTMLElement;
+  /** 도구줄 자체(폭 재기). */
+  bar: HTMLElement;
+  /** 켬끔 — 페이지가 바꾸면 `save` · 받기 실패로 끄는 것은 안 적음. */
+  on: Record<MapLayerKey, boolean>;
+  /** 뒤집고 적고 `onToggle`. */
+  toggle: (key: MapLayerKey) => void;
+  save: () => void;
+  /** 단추 · 메뉴 줄의 눌림 · 막힘 · 글을 켬끔 값에 맞춤 · `why` = 페이지 막힘 까닭(겹마다). */
+  sync: (state: {
+    ready: boolean;
+    glOn: boolean;
+    why?: Partial<Record<MapLayerKey, string>>;
+  }) => void;
+}
+
+export function createMapLayerBar(opts: {
+  page: MapPage;
+  glOn: boolean;
+  onToggle: (key: MapLayerKey) => void;
+  /** 그래픽 카드 단추 누름. */
+  onGl: () => void;
+}): MapLayerBar {
+  const { page } = opts;
+  const on = readLayerPref(page);
+  const save = (): void => writeByKey(MAP_LAYER_PAGES[page].pref, JSON.stringify(on));
+  const toggle = (key: MapLayerKey): void => {
+    on[key] = !on[key];
+    save();
+    opts.onToggle(key);
+  };
+  const defs = pageLayers(page);
+  const buttons = new Map<MapLayerKey, HTMLButtonElement>();
+  const menus = new Map<LayerGroup, PickMenu>();
+  const singles: HTMLElement[] = [];
+  for (const def of defs) {
+    if (!def.group) {
+      const button = createIconButton({
+        icon: def.icon,
+        title: def.title,
+        size: 32,
+        pressed: on[def.key],
+        onClick: () => toggle(def.key),
+      });
+      button.dataset.layer = def.key;
+      button.dataset.tip = def.title;
+      buttons.set(def.key, button);
+      singles.push(button);
+      continue;
+    }
+    if (menus.has(def.group)) continue;
+    const group = def.group;
+    const menu = createPickMenu({
+      multi: true,
+      icon: LAYER_GROUPS[group].icon,
+      title: LAYER_GROUPS[group].name,
+      items: defs
+        .filter((one) => one.group === group)
+        .map((one) => ({ value: one.key, label: one.title, icon: one.icon })),
+      onPick: (key) => key && toggle(key as MapLayerKey),
+    });
+    menu.root.dataset.layerGroup = group;
+    menus.set(group, menu);
+  }
+  for (const def of defs)
+    if (def.group) menus.get(def.group)!.setItem(def.key, { checked: on[def.key] });
+  const glButton = createIconButton({
+    icon: "gauge",
+    title: GL_TITLE,
+    size: 32,
+    pressed: opts.glOn,
+    onClick: opts.onGl,
+  });
+  glButton.dataset.layer = "gl";
+  const tools = createMapTools({
+    label: "지도 겹",
+    groups: [singles, [...menus.values()].map((menu) => menu.root), [glButton]],
+  });
+
+  function sync({ ready, glOn, why = {} }: Parameters<MapLayerBar["sync"]>[0]): void {
+    for (const def of defs) {
+      const reason = !ready
+        ? "지형 받기 뒤 보임"
+        : (why[def.key] ??
+          (tileOnly(def.key) && !glOn ? "옛 그림(그래픽 카드 끔)엔 안 보임" : null));
+      const button = buttons.get(def.key);
+      if (button) {
+        button.setAttribute("aria-pressed", String(on[def.key]));
+        button.disabled = !!reason;
+        mapToolTip(button, reason);
+        continue;
+      }
+      menus.get(def.group!)!.setItem(def.key, {
+        checked: on[def.key],
+        disabled: !!reason,
+        title: reason ? `${def.title} — ${reason}` : def.title,
+      });
+    }
+    glButton.setAttribute("aria-pressed", String(glOn));
+  }
+
+  return { root: tools.root, bar: tools.bar, on, toggle, save, sync };
+}

A00_Common/map/map_layer_data.ts

@@ -0,0 +1,76 @@
+/* =============================================================================
+ * map_layer_data.ts
+ * 공용 지도 겹 자료 도움(PLAN 569-2 · 581 · 586-2 · 624-3) — D03 예정노선 · B05 평면이 같이 씀(D03 `UI_LayerDefs` 에서 옮김).
+ *   도로 소로 · 미분류 구분 · 물 면 도엽 이름 · 넓이 글 · 그림 읽기 · GL 자료(지물 색 붙이기 · 그림 귀퉁이 · 음영 그늘 그림).
+ * ========================================================================== */
+
+import type { GlImage } from "@ui/ui_template_gl_map";
+import { themeColor } from "@ui/ui_template_palette";
+import type { GeoJsonCollection, PlanBand, PlanRaster } from "./map_layer_api";
+
+/** 도로 중 소로 · 미분류 구분(옛 임도 짐작 · 겹 걷음 · 페이지 자료 셈만 씀). */
+export const FOREST_ROAD_KINDS = new Set(["소로", "미분류"]);
+/** 물 면 = 도엽 수계(E) 면 셋. */
+export const WATER_KEYS = ["실폭하천", "수계면E003", "수계면E005"];
+
+export const hectare = (m2: number): string => `${(m2 / 10000).toFixed(1)} ha`;
+
+export const loadImage = (src: string): Promise<HTMLImageElement> =>
+  new Promise((done, fail) => {
+    const image = new Image();
+    image.onload = () => done(image);
+    image.onerror = () => fail(new Error("그림을 읽지 못했습니다"));
+    image.src = src;
+  });
+
+/** GL 자료 — 지물마다 그릴 색(`_color`) · 덧 속성을 붙인 사본. */
+export function glTagged(
+  collection: GeoJsonCollection,
+  color: (props: Record<string, unknown>) => string,
+  extra: Record<string, unknown> = {},
+): GeoJsonCollection {
+  return {
+    ...collection,
+    features: (collection.features ?? []).map((feature) => ({
+      ...feature,
+      properties: { ...feature.properties, ...extra, _color: color(feature.properties ?? {}) },
+    })),
+  };
+}
+
+/** 띠 GL 자료(581-1 · 634-2) — 도로 300 m 먼저 · 계류 100 m 위 · `_band` = 겹 가름(계류 = `bands` · 도로 = `roadBands`). */
+export function bandCollection(info: { stream: PlanBand; road: PlanBand }): GeoJsonCollection {
+  const band = (name: "stream" | "road", fallback: string): GeoJsonCollection =>
+    glTagged(info[name].collection, () => themeColor(`--draw-map-band-${name}`, fallback), {
+      _band: name,
+    });
+  return {
+    features: [
+      ...(band("road", "#facc15").features ?? []),
+      ...(band("stream", "#22d3ee").features ?? []),
+    ],
+  };
+}
+
+/** GL 그림 자리 — 서버 경위도 귀퉁이(왼쪽 아래부터 돎) → 왼쪽 위부터 · 없으면 null. */
+export function glImage(raster: PlanRaster, url = raster.image): GlImage | null {
+  const box = raster.box;
+  return box?.length === 4 ? { url, corners: [box[3], box[2], box[1], box[0]] } : null;
+}
+
+/** 음영 그늘 그림 — 위성 위 「곱하기 0.75」와 같은 검은 반투명(밝기 g → 투명도 0.75 · (1 − g)). */
+export function shadeImage(image: HTMLImageElement): string {
+  const canvas = document.createElement("canvas");
+  canvas.width = image.naturalWidth;
+  canvas.height = image.naturalHeight;
+  const context = canvas.getContext("2d")!;
+  context.drawImage(image, 0, 0);
+  const pixels = context.getImageData(0, 0, canvas.width, canvas.height);
+  const px = pixels.data;
+  for (let i = 0; i < px.length; i += 4) {
+    px[i + 3] = Math.round(0.75 * (255 - px[i]) * (px[i + 3] / 255));
+    px[i] = px[i + 1] = px[i + 2] = 0;
+  }
+  context.putImageData(pixels, 0, 0);
+  return canvas.toDataURL("image/png");
+}

A00_Common/map/map_layer_list.ts

@@ -0,0 +1,169 @@
+/* =============================================================================
+ * map_layer_list.ts
+ * 공용 지도 겹 목록(PLAN 624-2 · 요구 530 · 결정 A② · A⑧ · A⑨) — 예정노선(D03) · B05 평면이 같이 씀.
+ *   겹 = 요구 546 그룹1 표 한 줄 — 열쇠 · 아이콘 · 호버제목 · 아이콘 묶음(`LAYER_GROUPS` · 없음 = 단독) · 보일 페이지 · 처음 값(`on` = 예정노선).
+ *   페이지 표(`MAP_LAYER_PAGES`) = 처음 켬(없으면 겹의 `on`) · 켬끔 취향 열쇠.
+ *   선 겹 꼴 · 보호구역 색 · 산사태위험 범례 = GL 꼴(`map_layer_specs`) · 범례(`map_legend`) · 옛 캔버스가 같이 읽음.
+ *   쓰는 법 = 겹 줄 `createMapLayerBar({ page })`(`map_layer_bar`) · 새 겹 = `LAYERS` 한 줄 + 꼴 한 벌.
+ * ========================================================================== */
+
+import type { IconName } from "@ui/ui_template_icons";
+import type { LegendItem } from "@ui/ui_template_flow_legend";
+import { readByKey } from "../b_page_state";
+
+export type MapLayerKey =
+  | "satellite"
+  | "hillshade"
+  | "contour"
+  | "slope"
+  | "stream"
+  | "water"
+  | "road"
+  | "forestRoad" // 걷은 겹(임도 짐작 · 요구 532) — 목록 · 꼴 없음 · 페이지 자료 셈 이음만 남음
+  | "forestRoadFile"
+  | "nationalRoad"
+  | "ecoForest"
+  | "ecology"
+  | "cadastral"
+  | "zones"
+  | "soils"
+  | "landslide"
+  | "landslideZones"
+  | "geology" // 암상 지질도(760-1 · KIGAM 5만 · 그림 조각 + 도형)
+  | "faults"
+  | "lineaments"
+  | "zeroOrder"
+  | "bands" // 계류 100 m 띠(자료 = 띠 둘 한 벌 · `_band` 로 가름)
+  | "roadBands" // 도로 300 m 띠(같은 자료 · 「도로」 묶음)
+  | "building"
+  | "place";
+
+/** 임도(업로드) 고름(605-2) — 묶음 하나 또는 그 안의 선 하나(지도 강조). */
+export interface RoadPick {
+  bundle: string;
+  line?: number;
+}
+
+/** 지도가 있는 페이지. */
+export type MapPage = "d03" | "b05";
+
+/** 아이콘 묶음(요구 546 표 「아이콘 그룹명」) — 묶음 단추 = 아이콘 + ▾ + 켠 수 · 여럿 고르기 메뉴. */
+export type LayerGroup = "water" | "road" | "land" | "limit";
+export const LAYER_GROUPS: Record<LayerGroup, { name: string; icon: IconName }> = {
+  water: { name: "수계망도", icon: "streams" },
+  road: { name: "도로", icon: "signpost" },
+  land: { name: "토지·건물", icon: "parcelHouse" },
+  limit: { name: "제한·재해", icon: "ban" },
+};
+
+export interface LayerDef {
+  key: MapLayerKey;
+  icon: IconName;
+  /** 호버제목(요구 546 표) — 마우스 글 · 메뉴 줄 글. */
+  title: string;
+  /** 아이콘 묶음 — null = 단독 단추. */
+  group: LayerGroup | null;
+  /** 보일 페이지(표 「사용」). */
+  pages: readonly MapPage[];
+  /** 예정노선 처음 값 — 다른 페이지는 `MAP_LAYER_PAGES[page].on`. */
+  on: boolean;
+}
+
+const BOTH: readonly MapPage[] = ["d03", "b05"];
+const row = (
+  key: MapLayerKey,
+  icon: IconName,
+  title: string,
+  group: LayerGroup | null,
+  on = false,
+): LayerDef => ({ key, icon, title, group, pages: BOTH, on });
+
+/** 그룹1 표(요구 546 · 차례 = 단추 차례) — 도로 300 m 띠는 표 밖 한 줄(「도로」 묶음 · 기능 남김). */
+export const LAYERS: readonly LayerDef[] = [
+  row("satellite", "satellite", "위성사진", null, true),
+  row("hillshade", "sun", "음영기복도", null),
+  row("contour", "mountain", "등고선", null, true),
+  row("slope", "angle", "급경사", null),
+  row("stream", "droplet", "세류", "water", true),
+  row("water", "ripple", "하천", "water"),
+  row("zeroOrder", "arrowsJoin", "0차곡", "water"),
+  row("bands", "borderOuter", "계류100m", "water"),
+  row("road", "road", "도로", "road"),
+  row("nationalRoad", "route", "임도망도", "road"),
+  row("forestRoadFile", "map", "임도(업로드)", "road"),
+  row("roadBands", "roadBand", "도로300m", "road"),
+  row("cadastral", "borderAll", "지적도", "land"),
+  row("building", "building", "건물", "land"),
+  row("place", "mapPin", "지명", "land"),
+  row("zones", "shield", "보호규제구역", "limit"),
+  row("soils", "leaf", "산림입지도", "limit"),
+  row("ecoForest", "trees", "국유림·사유림", "limit"),
+  row("ecology", "plant", "생태자연도", "limit"),
+  row("landslide", "alert", "산사태위험지도", "limit"),
+  row("landslideZones", "alertOctagon", "산사태취약지역", "limit"),
+  row("geology", "strata", "암상 지질도", "limit"),
+  row("faults", "bolt", "단층", "limit"),
+  row("lineaments", "lineament", "지질구조선", "limit"),
+];
+
+/** 페이지 표 — 처음 켬(없음 = 겹의 `on`) · 켬끔 취향 열쇠. */
+export const MAP_LAYER_PAGES: Record<MapPage, { on?: readonly MapLayerKey[]; pref: string }> = {
+  d03: { pref: "aislo:pref:d03.layers" },
+  // A② 처음 = 지금 그대로(등고선 · 하천)
+  b05: { on: ["contour", "stream"], pref: "aislo:pref:b05.layers" },
+};
+
+/** 그 페이지에 보일 겹(표 차례). */
+export const pageLayers = (page: MapPage): LayerDef[] =>
+  LAYERS.filter((def) => def.pages.includes(page));
+
+/** 켬끔 취향 — 없거나 깨지면 페이지 처음 값 · 안 보일 겹 = 끔. */
+export function readLayerPref(page: MapPage): Record<MapLayerKey, boolean> {
+  const { on: first, pref } = MAP_LAYER_PAGES[page];
+  const on = Object.fromEntries(
+    LAYERS.map((def) => [def.key, first ? first.includes(def.key) : def.on]),
+  ) as Record<MapLayerKey, boolean>;
+  try {
+    const saved = JSON.parse(readByKey(pref) ?? "{}") as Partial<Record<MapLayerKey, unknown>>;
+    for (const def of LAYERS)
+      if (typeof saved[def.key] === "boolean") on[def.key] = saved[def.key] as boolean;
+  } catch {
+    // 깨진 값 = 처음 값
+  }
+  for (const def of LAYERS) if (!def.pages.includes(page)) on[def.key] = false;
+  return on;
+}
+
+/** 보호구역 종류 → 그림 색 값(서버 `ZONE_KINDS` 열쇠). */
+export const ZONE_COLORS: Record<string, string> = {
+  forest: "--draw-map-zone-forest",
+  baekdu: "--draw-map-zone-baekdu",
+  water: "--draw-map-zone-water",
+  park: "--draw-map-zone-park",
+  heritage: "--draw-map-zone-heritage",
+  wetland: "--draw-map-zone-wetland",
+  wildlife: "--draw-map-zone-wildlife",
+  greenbelt: "--draw-map-zone-greenbelt",
+};
+/** 산사태위험지도 범례(1 등급 = 가장 위험 · 색 = WMS 그림 색). */
+export const LANDSLIDE_LEGEND: LegendItem[] = [1, 2, 3, 4, 5].map((grade) => ({
+  label: `산사태 ${grade}등급`,
+  color: `var(--draw-map-landslide-grade-${grade})`,
+}));
+/** 선 겹 — 이름 · 그림 꼴(서버 `LINE_KINDS` 열쇠 = `kind` · 없으면 0차곡). 새 선 겹 = 여기 한 줄. */
+export type LineLayerKey = "faults" | "lineaments" | "zeroOrder";
+export const LINE_LAYERS: Record<
+  LineLayerKey,
+  { label: string; kind?: string; color: string; width: number; dash: number[] }
+> = {
+  faults: { label: "단층", kind: "faults", color: "--draw-map-fault", width: 2.4, dash: [] },
+  lineaments: {
+    label: "지질구조선",
+    kind: "lineaments",
+    color: "--draw-map-lineament",
+    width: 1.8,
+    dash: [8, 4],
+  },
+  zeroOrder: { label: "0차곡", color: "--draw-map-zero-order", width: 1.8, dash: [4, 3] },
+};
+export const LINE_KEYS = Object.keys(LINE_LAYERS) as LineLayerKey[];

A00_Common/map/map_layer_source.ts

@@ -0,0 +1,31 @@
+/* =============================================================================
+ * map_layer_source.ts
+ * 공용 지도 밖 겹 출처(PLAN 760-1 · 요구 598-4 「받아온 곳의 정보를 표기」) — 켠 겹의 받아온 곳을 범례 맨 아래 한 줄씩.
+ *   받아온 곳 = 서버가 부르는 곳 그대로(브이월드 WFS · 위성 · 산림청 원자료 · 생활안전지도 WMS · 지오빅데이터 …) ·
+ *   자체 셈 겹(음영 · 급경사 · 0차곡 · 띠) · 사용자 올림(임도(업로드)) · 자기 지형(등고선 · 세류)은 안 적음.
+ * ========================================================================== */
+
+import type { LegendItem } from "@ui/ui_template_flow_legend";
+import { LAYERS, type MapLayerKey } from "./map_layer_list";
+
+/** 받아온 곳 → 겹(차례 = 범례 차례). */
+export const LAYER_SOURCES: ReadonlyArray<[string, readonly MapLayerKey[]]> = [
+  ["브이월드", ["satellite", "cadastral", "zones", "faults", "lineaments"]],
+  ["국토지리정보원 수치지형도", ["water", "road", "building", "place"]],
+  ["산림청", ["nationalRoad", "ecoForest", "soils"]],
+  ["시도 산사태취약지역 현황(공공데이터포털)", ["landslideZones"]],
+  ["환경부 생태자연도(공공데이터포털)", ["ecology"]],
+  ["행정안전부 생활안전지도(공공누리 제4유형)", ["landslide"]],
+  ["한국지질자원연구원 수치지질도 1:50,000(CC BY-NC)", ["geology"]],
+];
+
+/** 켠 밖 겹의 출처 줄 — 「출처: 곳 — 겹 · 겹」 · 없으면 빈 것. */
+export function sourceRow(on: Record<MapLayerKey, boolean>): LegendItem[] {
+  const title = (key: MapLayerKey): string => LAYERS.find((def) => def.key === key)?.title ?? key;
+  return LAYER_SOURCES.flatMap(([where, keys]) => {
+    const shown = keys.filter((key) => on[key]);
+    return shown.length
+      ? [{ label: `출처: ${where} — ${shown.map(title).join(" · ")}`, color: "transparent" }]
+      : [];
+  });
+}

A00_Common/map/map_layer_specs.ts

@@ -0,0 +1,317 @@
+/* =============================================================================
+ * map_layer_specs.ts
+ * 공용 지도 GL 겹 꼴(PLAN 586-2 · 624-2 · 요구 530) — 바탕 겹 스물의 MapLibre 꼴 · 차례(아래 → 위):
+ *   위성 · 그림 겹(음영 · 급경사 · 산사태위험 · 생태자연도) · 면 겹(산림입지 · 경제림 · 보호구역 · 띠 · 물 면 · 건물) ·
+ *   선 겹(지적 · 등고선 · 도로 · 임도망도 · 임도(업로드) · 세류 · 단층 · 지질구조선 · 0차곡 · 산사태취약 필지) ·
+ *   점 · 글(산사태취약 · 임도망도 연도 · 종류 · 지명 · 등고 수치).
+ *   자료 = 받는 쪽이 지물에 붙인 `_color` · 고정 소스(위성 · 등고 · 산림 조각) 이름 = `map_forest_layers` · `ui_template_gl_map`.
+ *   카메라 · 지도 세우기는 페이지 몫(D03 `UI_MapGl.createGlBase` · B05 `createTmGl`) — 여기는 꼴만.
+ * ========================================================================== */
+
+import type { ExpressionSpecification, FilterSpecification } from "maplibre-gl";
+import { GL_FONT, type GlSpec as GlMapSpec } from "@ui/ui_template_gl_map";
+import { themeColor } from "@ui/ui_template_palette";
+import {
+  forestAreaSpecs,
+  forestRasterSpecs,
+  forestRoadLabelSpec,
+  forestRoadSpecs,
+} from "./map_forest_layers";
+import { geologySpecs } from "./map_geology";
+import {
+  LINE_KEYS,
+  LINE_LAYERS,
+  type LineLayerKey,
+  type MapLayerKey,
+  type RoadPick,
+} from "./map_layer_list";
+
+/** 자료 소스(위성 = 조각 · 걷은 임도 짐작 = 소스 없음). */
+export type GlSource = Exclude<MapLayerKey, "satellite" | "forestRoad">;
+
+const GL_FONT_BOLD = [`${GL_FONT} SemiBold`, GL_FONT];
+
+type GlSpec = GlMapSpec<MapLayerKey>;
+
+const HALO = "rgba(0, 0, 0, 0.55)";
+const ROUND = { "line-join": "round", "line-cap": "round" } as const;
+const COLOR: ExpressionSpecification = ["get", "_color"];
+/** 등고 조각 굵은 선(서버가 줌마다 정함) — 가는 선은 모두라 굵은 선은 두 번 겹쳐 짙음(캔버스처럼). */
+const BOLD = ["==", ["get", "k"], 1] as unknown as FilterSpecification;
+/** 캔버스 점선(px) → MapLibre 점선(선 굵기 배수). */
+const dash = (px: number[], width: number): number[] => px.map((v) => v / width);
+
+/** 선 겹 — 검은 테두리 + 선(점선이면 둘 다 같은 px 무늬). */
+function haloLine(
+  key: MapLayerKey,
+  source: GlSource,
+  color: string,
+  width: number,
+  pattern: number[] = [],
+  halo = { color: HALO, width: width + 1.6 },
+  filter?: FilterSpecification,
+): GlSpec[] {
+  const line = (id: string, paint: Record<string, unknown>, w: number): GlSpec =>
+    ({
+      key,
+      id,
+      type: "line",
+      source,
+      ...(filter ? { filter } : {}),
+      layout: ROUND,
+      paint: {
+        ...paint,
+        "line-width": w,
+        ...(pattern.length ? { "line-dasharray": dash(pattern, w) } : {}),
+      },
+    }) as GlSpec;
+  return [
+    line(`${key}-halo`, { "line-color": halo.color }, halo.width),
+    line(key, { "line-color": color }, width),
+  ];
+}
+
+/** 면 겹 — 채움 + 테두리(캔버스 `fillLayer` 처럼 테두리 투명도 0.9). */
+/** 띠 테두리 — 계류 · 도로 같은 꼴. */
+const BAND_EDGE = { color: COLOR, width: 1.2, dash: [6, 4] };
+
+function fillEdge(
+  key: MapLayerKey,
+  source: GlSource,
+  fill: string | ExpressionSpecification,
+  opacity: number | ExpressionSpecification,
+  edge: { color: string | ExpressionSpecification; width: number; dash?: number[] },
+  filter?: ExpressionSpecification,
+): GlSpec[] {
+  const only = filter ? { filter } : {};
+  return [
+    {
+      key,
+      id: key,
+      type: "fill",
+      source,
+      ...only,
+      paint: { "fill-color": fill, "fill-opacity": opacity },
+    } as GlSpec,
+    {
+      key,
+      id: `${key}-edge`,
+      type: "line",
+      source,
+      ...only,
+      layout: ROUND,
+      paint: {
+        "line-color": edge.color,
+        "line-width": edge.width,
+        "line-opacity": 0.9,
+        ...(edge.dash ? { "line-dasharray": dash(edge.dash, edge.width) } : {}),
+      },
+    } as GlSpec,
+  ];
+}
+
+/** 겹 차례(아래 → 위)와 꼴 — 옛 캔버스(D03 `UI_LayerPaint`)의 색 · 굵기 · 투명도 · 차례 그대로 · `light` = 위성 밝기 상한. */
+export function mapLayerSpecs(light: number, pick: RoadPick | null): GlSpec[] {
+  const contour = themeColor("--draw-map-contour", "#ffd68c");
+  const place = themeColor("--draw-map-place", "#f8fafc");
+  const landslideZone = themeColor("--draw-map-landslide-zone", "#e11d48");
+  const raster = (
+    key: "satellite" | "hillshade" | "slope",
+    opacity: number,
+    extra: Record<string, number> = {},
+  ): GlSpec =>
+    ({
+      key,
+      id: key,
+      type: "raster",
+      source: key,
+      paint: { "raster-opacity": opacity, "raster-fade-duration": 0, ...extra },
+    }) as GlSpec;
+  const lineKind = (key: LineLayerKey): GlSpec[] => {
+    const { color, width, dash } = LINE_LAYERS[key];
+    return haloLine(key, key, themeColor(color, "#f43f5e"), width, dash);
+  };
+  return [
+    // 위성 = 조금 어둡고 연하게(요구 475 · 노선 선 대비) — 밝기 상한은 사용자 조절
+    raster("satellite", 1, { "raster-brightness-max": light, "raster-saturation": SAT_SATURATION }),
+    raster("hillshade", 1), // 위성 위 = 「곱하기」와 같은 검은 그늘 그림(받는 쪽이 바꿈)
+    raster("slope", 0.55),
+    ...forestRasterSpecs(), // 산사태위험 · 생태자연도 = 조각 그림(622-2)
+    ...forestAreaSpecs(), // 산림입지도 · 경제림 = 벡터 조각
+    ...geologySpecs(), // 암상 지질도 면 · 글(760-1)
+    ...fillEdge("zones", "zones", COLOR, 0.22, { color: COLOR, width: 1.6 }),
+    // 띠 = 한 자료(`_band`) · 겹 둘(634-2 · 도로 300 m 아래 · 계류 100 m 위 — 옛 한 겹 차례 그대로)
+    ...fillEdge("roadBands", "bands", COLOR, 0.16, BAND_EDGE, ["==", ["get", "_band"], "road"]),
+    ...fillEdge("bands", "bands", COLOR, 0.18, BAND_EDGE, ["==", ["get", "_band"], "stream"]),
+    {
+      key: "cadastral",
+      id: "cadastral",
+      type: "line",
+      source: "cadastral",
+      layout: ROUND,
+      paint: {
+        "line-color": themeColor("--draw-map-parcel", "#f0abfc"),
+        "line-width": 0.8,
+        "line-opacity": 0.8,
+      },
+    } as GlSpec,
+    ...((): GlSpec[] => {
+      const water = themeColor("--draw-map-water", "#0ea5e9");
+      return fillEdge("water", "water", water, 0.45, { color: water, width: 1 });
+    })(),
+    ...fillEdge("building", "building", themeColor("--draw-map-building", "#fb7185"), 0.7, {
+      color: HALO,
+      width: 0.6,
+    }),
+    {
+      key: "contour",
+      id: "contour-minor",
+      type: "line",
+      source: "contour",
+      "source-layer": "contour",
+      layout: ROUND,
+      paint: { "line-color": contour, "line-width": 0.8, "line-opacity": 0.7 },
+    } as GlSpec,
+    {
+      key: "contour",
+      id: "contour-index",
+      type: "line",
+      source: "contour",
+      "source-layer": "contour",
+      filter: BOLD,
+      layout: ROUND,
+      paint: { "line-color": contour, "line-width": 1.6, "line-opacity": 0.7 },
+    } as GlSpec,
+    {
+      key: "contour",
+      id: "contour-label",
+      type: "symbol",
+      source: "contour",
+      "source-layer": "contour",
+      filter: BOLD,
+      layout: {
+        "symbol-placement": "line",
+        "symbol-spacing": 320,
+        "text-field": ["to-string", ["get", "h"]],
+        "text-font": [GL_FONT],
+        "text-size": 10,
+        "text-max-angle": 30,
+        "text-padding": 2,
+      },
+      paint: {
+        "text-color": contour,
+        "text-halo-color": "rgba(0, 0, 0, 0.6)",
+        "text-halo-width": 1.5,
+      },
+    } as GlSpec,
+    ...haloLine("road", "road", themeColor("--draw-map-road", "#f8fafc"), 1.6, [], {
+      color: HALO,
+      width: 3.2,
+    }),
+    ...forestRoadSpecs(), // 임도망도(전국 국가임도) = 벡터 조각 · 임도(업로드) 아래
+    ...haloLine(
+      "forestRoadFile",
+      "forestRoadFile",
+      themeColor("--draw-map-forest-road-file", "#ff2fd0"),
+      2.4,
+      [],
+      { color: HALO, width: 4 },
+    ),
+    // 고른 묶음 · 선 강조(605-2) — 같은 자료에서 걸러 한 겹 더 굵게
+    ...["-pick-halo", "-pick"].map(
+      (tail, i) =>
+        ({
+          key: "forestRoadFile",
+          id: `forestRoadFile${tail}`,
+          type: "line",
+          source: "forestRoadFile",
+          filter: pickFilter(pick),
+          layout: ROUND,
+          paint: {
+            "line-color": i ? themeColor("--draw-map-sketch", "#ffe94d") : HALO,
+            "line-width": i ? 4.2 : 7.4,
+          },
+        }) as GlSpec,
+    ),
+    {
+      key: "stream",
+      id: "stream",
+      type: "line",
+      source: "stream",
+      layout: ROUND,
+      paint: {
+        "line-color": themeColor("--draw-map-stream", "#38bdf8"),
+        "line-width": ["case", ["==", ["get", "구분"], "세류"], 1, 2.4],
+      },
+    } as GlSpec,
+    ...LINE_KEYS.flatMap(lineKind),
+    // 산사태취약 — 필지 = 「이 필지 안 어딘가」 테두리만 · 점 = 지정 자리
+    ...haloLine(
+      "landslideZones",
+      "landslideZones",
+      landslideZone,
+      1.8,
+      [6, 3],
+      { color: "rgba(255, 255, 255, 0.7)", width: 3.2 },
+      ["!=", ["geometry-type"], "Point"] as unknown as FilterSpecification,
+    ),
+    {
+      key: "landslideZones",
+      id: "landslideZones-point",
+      type: "circle",
+      source: "landslideZones",
+      filter: ["==", ["geometry-type"], "Point"],
+      paint: {
+        "circle-radius": 5,
+        "circle-color": landslideZone,
+        "circle-stroke-color": "#ffffff",
+        "circle-stroke-width": 1.5,
+      },
+    } as GlSpec,
+    forestRoadLabelSpec(), // 임도망도 글 — 지명 아래(겹치면 지명이 앞섬)
+    {
+      key: "place",
+      id: "place-dot",
+      type: "circle",
+      source: "place",
+      paint: { "circle-radius": 2.5, "circle-color": place },
+    } as GlSpec,
+    {
+      key: "place",
+      id: "place",
+      type: "symbol",
+      source: "place",
+      layout: {
+        "text-field": ["get", "name"],
+        "text-font": GL_FONT_BOLD,
+        "text-size": 11,
+        "text-anchor": "bottom",
+        "text-offset": [0, -0.36],
+        "text-padding": 2,
+      },
+      paint: {
+        "text-color": place,
+        "text-halo-color": "rgba(0, 0, 0, 0.7)",
+        "text-halo-width": 1.5,
+      },
+    } as GlSpec,
+  ];
+}
+
+/** 고른 묶음 · 선만 거름(고름 없음 = 아무것도 안 맞는 거름). */
+export function pickFilter(pick: RoadPick | null): FilterSpecification {
+  const all: unknown[] = ["all", ["==", ["get", "__bundle"], pick?.bundle ?? ""]];
+  if (pick?.line !== undefined) all.push(["==", ["get", "__line"], pick.line]);
+  return all as unknown as FilterSpecification;
+}
+
+/** 겹 색 지문 — 밝음 · 어두움이 바뀌면 색을 다시. */
+export const MAP_THEME_NAMES = [
+  "--draw-map-contour",
+  "--draw-map-road",
+  "--draw-map-stream",
+  "--draw-map-parcel",
+] as const;
+
+/** 위성 채도(−1~1) — 조금 연하게. */
+const SAT_SATURATION = -0.3;

A00_Common/map/map_legend.ts

@@ -0,0 +1,215 @@
+/* =============================================================================
+ * map_legend.ts
+ * 공용 지도 범례(PLAN 569-2 · 622-2 · 624-2 · 요구 530) — 켠 겹 범례 칸 하나(줄마다 `createLegend`) + 페이지가 붙이는 덧 줄.
+ *   조각 겹 범례(산사태위험 · 임도망도 · 경제림 · 생태자연도) = 받을 자료 없음 → 켬끔만 보고 여기서 만듦(`tileLegendRows`).
+ *   받은 자료 범례 줄(수 · 넓이 · 급경사 범위 · 624-3 D03 에서 옮김) = `legendRows(on, data)` — 받은 자료 꼴은 `LegendData`
+ *     (D03 옛 캔버스 자료 · B05 GL 자료 둘 다 맞음 · 받는 일은 페이지 몫).
+ *   암상 지질도 줄 · 노선 구간 표 = `map_geology`(760-1) · 켠 밖 겹 출처 줄 = 맨 아래(`map_layer_source` · 598-4).
+ *   쓰는 법 = `const legend = createMapLegend("d03-plan__legend")` → `legend.show(rows, [덧 줄])` · 줄 · 덧 없으면 숨김.
+ * ========================================================================== */
+
+import { createLegend, type LegendItem } from "@ui/ui_template_flow_legend";
+import { forestLegendRows } from "./map_forest_layers";
+import { geologyRow, type PlanGeology } from "./map_geology";
+import type {
+  PlanBand,
+  PlanForestRoads,
+  PlanLandslideZones,
+  PlanRaster,
+  PlanSoils,
+  PlanZones,
+} from "./map_layer_api";
+import { hectare } from "./map_layer_data";
+import { sourceRow } from "./map_layer_source";
+import {
+  LANDSLIDE_LEGEND,
+  LINE_KEYS,
+  LINE_LAYERS,
+  ZONE_COLORS,
+  type MapLayerKey,
+} from "./map_layer_list";
+import { SLOPE_MAX_PCT, bandRatios, pctToDeg, type SlopeBand } from "./logic/map_slope_bands";
+
+/** 지물 수만 보는 겹(옛 캔버스 자료 · GeoJSON 둘 다). */
+interface Counted {
+  features?: ArrayLike<unknown>;
+}
+
+/** 범례가 읽는 받은 자료 — 받은 겹만. */
+export interface LegendData {
+  slope: { raster: PlanRaster; bands: SlopeBand[] };
+  landslideZones: { info: PlanLandslideZones };
+  zones: { summary: PlanZones["summary"] };
+  /** 토양형(코드 차례) 색 값 · 요약. */
+  soils: { kinds: Array<{ color: string }>; summary: PlanSoils["summary"] };
+  bands: { info: { stream: PlanBand; road: PlanBand } };
+  water: Counted;
+  building: Counted;
+  road: { small: Counted };
+  forestRoadFile: { info: PlanForestRoads };
+  faults: { count: number; length_m: number };
+  lineaments: { count: number; length_m: number };
+  zeroOrder: { count: number; length_m: number };
+  geology: PlanGeology;
+}
+
+export interface MapLegend {
+  root: HTMLElement;
+  show: (rows: LegendItem[][], tail?: HTMLElement[]) => void;
+}
+
+/** 켠 조각 겹 범례 — 산사태위험 다음 산림 셋. */
+export const tileLegendRows = (on: Record<MapLayerKey, boolean>): LegendItem[][] => [
+  ...(on.landslide ? [LANDSLIDE_LEGEND] : []),
+  ...forestLegendRows(on),
+];
+
+/** `className` = 자리 · 꼴(페이지 CSS). */
+export function createMapLegend(className: string): MapLegend {
+  const root = document.createElement("div");
+  root.className = className;
+  root.title = "켠 겹 범례 — 받은 지형 범위 안 수 · 넓이";
+  return {
+    root,
+    show(rows, tail = []) {
+      root.replaceChildren(...rows.map((row) => createLegend(row)), ...tail);
+      root.hidden = !rows.length && !tail.length;
+    },
+  };
+}
+
+const km = (m: number): string => `${(m / 1000).toFixed(2)} km`;
+
+/** 급경사 범례 — 범위마다 「아래~위 %(°) · 비율」(위 = 끝 = 「↑」). */
+function slopeRow({ raster, bands }: LegendData["slope"]): LegendItem[] {
+  const ratios = bandRatios(raster.counts ?? [], bands);
+  const deg = (pct: number): string => pctToDeg(pct).toFixed(0);
+  return bands.map((band, i) => {
+    const open = band.high >= SLOPE_MAX_PCT;
+    const range = open
+      ? `${band.low} %↑(${deg(band.low)}°↑)`
+      : `${band.low}~${band.high} %(${deg(band.low)}~${deg(band.high)}°)`;
+    return { label: `${range} · ${(ratios[i] * 100).toFixed(1)} %`, color: `var(${band.color})` };
+  });
+}
+
+/** 산사태취약지역 범례 — 점 · 필지 · 위치 없는 시도 · 표 없는 시도 · 지적 못 받음. */
+function landslideZoneRow({ info }: LegendData["landslideZones"]): LegendItem[] {
+  const color = "var(--draw-map-landslide-zone)";
+  const items: LegendItem[] = [
+    {
+      label: `산사태취약지역 점 ${info.points.length}곳`,
+      color,
+      kind: "dot",
+      off: !info.points.length,
+    },
+    {
+      label: `지번 맞는 필지 ${info.parcels.features?.length ?? 0}곳(테두리)`,
+      color,
+      kind: "dash",
+      off: !info.parcels.features?.length,
+    },
+  ];
+  for (const sido of info.sidos)
+    if (!sido.located) items.push({ label: `${sido.name} 위치 없음 — 필지만`, color, off: true });
+  for (const name of info.missing)
+    items.push({ label: `${name} — 이 시도 자료 없음`, color: "transparent", off: true });
+  if (!info.cadastral)
+    items.push({ label: "지적도 못 받음 — 필지 테두리 없음", color: "transparent", off: true });
+  return items;
+}
+
+/** 켠 겹의 받은 자료 범례 줄(급경사 · 조각 겹 · 산사태취약 · 보호구역 · 토양 · 띠 · 선 겹 · 물 면 · 건물 · 임도). */
+export function legendRows(
+  on: Record<MapLayerKey, boolean>,
+  data: Partial<LegendData>,
+): LegendItem[][] {
+  const rows: LegendItem[][] = [];
+  if (on.slope && data.slope) rows.push(slopeRow(data.slope));
+  rows.push(...tileLegendRows(on)); // 조각 겹 = 받기 없음(622-2 · 공용 범례)
+  if (on.landslideZones && data.landslideZones) rows.push(landslideZoneRow(data.landslideZones));
+  if (on.zones && data.zones) {
+    const items = Object.entries(data.zones.summary)
+      .filter(([, kind]) => kind.count || kind.failed)
+      .map(([key, kind]) => ({
+        label: kind.failed
+          ? `${kind.label} 받지 못함`
+          : `${kind.label} ${kind.count}곳 ${hectare(kind.area_m2)}`,
+        color: `var(${ZONE_COLORS[key]})`,
+        off: !!kind.failed,
+      }));
+    rows.push(
+      items.length
+        ? items
+        : [{ label: "보호 · 규제 구역 없음(받은 범위 안)", color: "transparent", off: true }],
+    );
+  }
+  if (on.soils && data.soils) {
+    const { kinds, summary } = data.soils;
+    rows.push(
+      summary.length
+        ? summary.map((soil, i) => ({
+            label: `${soil.name} ${hectare(soil.area_m2)}`,
+            color: `var(${kinds[i].color})`,
+          }))
+        : [{ label: "산림입지도 없음(받은 범위 안)", color: "transparent", off: true }],
+    );
+  }
+  // 계류 100 m 띠 · 도로 300 m 띠 = 겹 둘(634-2 · 자료 한 벌)
+  if ((on.bands || on.roadBands) && data.bands) {
+    const { stream, road } = data.bands.info;
+    rows.push([
+      ...(on.bands
+        ? [
+            {
+              label: `계류 ${stream.dist_m} m 띠 ${hectare(stream.area_m2)} (${(stream.ratio * 100).toFixed(1)} %)`,
+              color: "var(--draw-map-band-stream)",
+            },
+          ]
+        : []),
+      ...(on.roadBands
+        ? [
+            {
+              label: `도로 ${road.dist_m} m 띠 ${hectare(road.area_m2)} (${(road.ratio * 100).toFixed(1)} %)`,
+              color: "var(--draw-map-band-road)",
+            },
+          ]
+        : []),
+    ]);
+  }
+  const lines = LINE_KEYS.flatMap((key) => {
+    const got = on[key] && data[key];
+    if (!got) return [];
+    const { label, color, dash } = LINE_LAYERS[key];
+    return [
+      {
+        label: `${label} ${got.count}가닥 ${km(got.length_m)}`,
+        color: `var(${color})`,
+        kind: dash.length ? ("dash" as const) : ("line" as const),
+        off: !got.count,
+      },
+    ];
+  });
+  if (lines.length) rows.push(lines);
+  if (on.geology && data.geology) rows.push(geologyRow(data.geology));
+  const tail: LegendItem[] = [];
+  if (on.water && data.water)
+    tail.push({
+      label: `물 면 ${data.water.features?.length ?? 0}곳`,
+      color: "var(--draw-map-water)",
+    });
+  if (on.building && data.building)
+    tail.push({
+      label: `건물 ${(data.building.features?.length ?? 0).toLocaleString()}동`,
+      color: "var(--draw-map-building)",
+    });
+  if (on.forestRoadFile && data.forestRoadFile)
+    tail.push({
+      label: `임도(업로드) ${data.forestRoadFile.info.count}가닥 ${km(data.forestRoadFile.info.length_m)}`,
+      color: "var(--draw-map-forest-road-file)",
+      kind: "line",
+    });
+  if (tail.length) rows.push(tail);
+  rows.push(...sourceRow(on).map((item) => [item]));
+  return rows;
+}

A00_Common/map/map_lidar_upload.ts

@@ -0,0 +1,117 @@
+/* =============================================================================
+ * map_lidar_upload.ts
+ * 공용 [LAS 올리기](PLAN 637-3 · 요구 546) — 예정노선(D03) · B05 지형 칩 옆 같은 단추 · 같은 흐름.
+ *   단추 → 파일 고름(LAS · LAZ + .prj) → `POST <path>`(multipart `files` · 못 받으면 서버 글 그대로 알림)
+ *   → 1 초마다 `poll` 로 진행(`show` = 페이지 진행 서클) → 끝(오류면 알림) → 서클 · 단추 풀고 `onDone(마지막 진행)`.
+ *   주소 · 진행 묻기 · 서클 · 끝난 뒤 일은 페이지 인자(D = `/plan/lidar` · B = `/route/lidar`).
+ *   지켜보는 동안 단추 막힘 · 페이지를 떠나면(단추가 문서 밖) 그침.
+ * ========================================================================== */
+
+import { API_BASE_URL } from "@config/config_frontend";
+import { createButton } from "@ui/ui_template_button";
+import { pickFiles } from "@ui/ui_template_drop";
+import { showToast } from "@ui/ui_template_elements";
+
+const POLL_MS = 1000;
+
+/** 서버 뒤 일 진행(`common_util_lidar_upload.start_job` 꼴). */
+export interface LidarJob {
+  running: boolean;
+  percent: number;
+  message?: string | null;
+  error?: string | null;
+  interrupted?: boolean;
+}
+
+export interface LidarUpload {
+  /** [LAS 올리기] 단추(보임은 페이지 몫). */
+  button: HTMLButtonElement;
+  /** 도는 일을 끝날 때까지 지켜봄(들어올 때 이어 보기). */
+  follow: () => Promise<void>;
+  /** 지켜보는 중. */
+  busy: () => boolean;
+}
+
+const errorText = (error: unknown): string =>
+  error instanceof Error ? error.message : String(error);
+
+/** LAS 묶음 올리기 — 못 받으면 서버 `detail` 글 그대로 오류. */
+async function postFiles(path: string, files: File[]): Promise<void> {
+  const form = new FormData();
+  for (const file of files) form.append("files", file);
+  const response = await fetch(`${API_BASE_URL}${path}`, {
+    method: "POST",
+    credentials: "include",
+    body: form,
+  });
+  if (response.ok) return;
+  const body = (await response.json().catch(() => ({}))) as { detail?: unknown };
+  throw new Error(typeof body.detail === "string" ? body.detail : `HTTP ${response.status}`);
+}
+
+export function createLidarUpload<J extends LidarJob>(opts: {
+  /** 올리기 주소(`API_BASE_URL` 뒤). */
+  path: string;
+  /** 진행 한 번 묻기. */
+  poll: () => Promise<J>;
+  /** 진행 보임(0~1 · 글) · null = 끝. */
+  show: (state: { ratio: number; text: string } | null) => void;
+  /** 지켜보기를 감쌈(예: 서클 일 셈). */
+  track?: (job: Promise<void>) => Promise<void>;
+  /** 지켜보기 시작 · 끝. */
+  onBusy?: (busy: boolean) => void;
+  /** 짓기가 끝난 뒤(오류 알림 뒤 · 단추 풀린 뒤 · 마지막 진행). */
+  onDone: (job: J) => Promise<void> | void;
+}): LidarUpload {
+  let busy = false;
+  const button = createButton({
+    label: "LAS 올리기",
+    variant: "ghost",
+    size: 32,
+    iconStart: "upload",
+    onClick: () =>
+      pickFiles({ accept: ".las,.laz,.prj", multiple: true }, (files) => void send(files)),
+  });
+
+  const setBusy = (on: boolean): void => {
+    busy = on;
+    button.disabled = on;
+    opts.onBusy?.(on);
+  };
+
+  async function send(files: File[]): Promise<void> {
+    try {
+      await postFiles(opts.path, files);
+    } catch (error) {
+      return showToast(`LAS 올리지 못함 — ${errorText(error)}`, "error");
+    }
+    await follow();
+  }
+
+  async function watch(): Promise<void> {
+    let last: J | null = null;
+    setBusy(true);
+    opts.show({ ratio: 0, text: "" });
+    try {
+      while (button.isConnected) {
+        const job = await opts.poll();
+        opts.show({ ratio: job.percent / 100, text: job.message ?? "" });
+        if (!job.running) {
+          if (job.error) showToast(`라이다 지형 못 지음 — ${job.error}`, "error");
+          last = job;
+          break;
+        }
+        await new Promise((done) => setTimeout(done, POLL_MS));
+      }
+    } catch (error) {
+      showToast(`라이다 진행을 읽지 못했습니다 — ${errorText(error)}`, "error");
+    } finally {
+      opts.show(null);
+      setBusy(false);
+    }
+    if (last) await opts.onDone(last);
+  }
+
+  const follow = (): Promise<void> => (opts.track ? opts.track(watch()) : watch());
+  return { button, follow, busy: () => busy };
+}

A00_Common/map/map_route_preview.ts

@@ -0,0 +1,57 @@
+/* =============================================================================
+ * map_route_preview.ts
+ * 공용 「추천노선」 미리보기(PLAN 626-1 → 636-2 공용 · 요구 530 · 546) — B05 평면 · 예정노선(D03)이 같이 씀.
+ *   메뉴 = 도구줄 아이콘 하나(compass · 호버 「추천노선」) + 아래 판(여럿 고르기 · 줄마다 색 점 · 「끔」 줄 없음 ·
+ *     다 끄면 꺼짐 · 부품 `createPickMenu({ multi })` · 589-12).
+ *   그리기 = 지도 위 선(노랑 `--draw-map-sketch` · 검은 테 · 기본 점선) — 위성 · 어두운 바탕 모두 보임.
+ *   항목 · 선 셈은 페이지 몫: B05 = 노선 추천 저장본 넷(`B05_Profile_UI_RouteEdit_RecPreview`) ·
+ *     예정노선 = 가이드 선(`D03_PlanAnalysis_UI_Guide`).
+ * ========================================================================== */
+
+import { createPickMenu, type PickMenu, type PickMenuItem } from "@ui/ui_template_context_menu";
+import { themeColor } from "@ui/ui_template_palette";
+
+type Vertex = [number, number] | [number, number, number];
+
+/** 「추천노선」 메뉴 — 줄 누름 = `onPick(값)`(켬끔 바뀜 · 지금 켠 줄은 `menu.values()`). */
+export function createRoutePreviewMenu(opts: {
+  items: PickMenuItem[];
+  onPick: (value: string) => void;
+}): PickMenu {
+  const menu = createPickMenu({
+    multi: true,
+    icon: "compass",
+    title: "추천노선", // 마우스 글 = 공용 표 호버제목(634-2 · `mapToolGroups` 가 맞춤)
+    items: opts.items,
+    onPick: (value) => value && opts.onPick(value),
+  });
+  menu.root.dataset.act = "recommend";
+  return menu;
+}
+
+/** 미리보기 선 하나 — 검은 테(5 px) 위 색 선(3 px) · 기본 노랑 점선. */
+export function paintRoutePreview(
+  context: CanvasRenderingContext2D,
+  line: readonly Vertex[],
+  toScreen: (vertex: [number, number]) => [number, number],
+  style: { dash?: number[]; color?: string } = {},
+): void {
+  if (line.length < 2) return;
+  context.save();
+  context.setLineDash(style.dash ?? [10, 6]);
+  context.lineJoin = "round";
+  context.beginPath();
+  line.forEach((vertex, index) => {
+    const [x, y] = toScreen([vertex[0], vertex[1]]);
+    if (index) context.lineTo(x, y);
+    else context.moveTo(x, y);
+  });
+  // 지도 위 그림 색(테마 안 따름) + 검은 테 — 위성 · 어두운 바탕 모두 보임
+  context.strokeStyle = "rgba(0, 0, 0, 0.6)";
+  context.lineWidth = 5;
+  context.stroke();
+  context.strokeStyle = style.color ?? themeColor("--draw-map-sketch", "#ffe94d");
+  context.lineWidth = 3;
+  context.stroke();
+  context.restore();
+}

A00_Common/map/map_sat_light.ts

@@ -1,11 +1,11 @@
 /* =============================================================================
- * D03_PlanAnalysis_UI_SatLight.ts
- * D03 위성 바탕 밝기(요구 475) — 노선 선 대비를 위해 위성을 조금 어둡게 · 사용자가 범례에서 조절.
- *   값 = 밝기 상한(0.4~1) · 계정 화면 취향으로 기억. 칠하기 = `D03_PlanAnalysis_UI_MapGl` `setSatelliteLight`.
+ * map_sat_light.ts
+ * 공용 지도 위성 바탕 밝기(D03 · B05 · 624-3 공용으로 옮김)(요구 475) — 노선 선 대비를 위해 위성을 조금 어둡게 · 사용자가 범례에서 조절.
+ *   값 = 밝기 상한(0.4~1) · 계정 화면 취향으로 기억. 칠하기 = D03 `UI_MapGl` `setSatelliteLight` · B05 `UI_RouteEdit_Layers`.
  * ========================================================================== */
 
 import { createSlider } from "@ui/ui_template_input";
-import { readByKey, writeByKey } from "../A00_Common/b_page_state";
+import { readByKey, writeByKey } from "../b_page_state";
 
 const PREF_KEY = "aislo:pref:d03.satellite-light";
 export const SAT_LIGHT_MIN = 0.4;

A00_Common/map/map_slope_bands.ts

@@ -0,0 +1,201 @@
+/* =============================================================================
+ * map_slope_bands.ts
+ * 공용 지도 급경사 범위 옵션(D03 · B05 · 624-3 공용으로 옮김)(PLAN 603 · 요구 466 · 467 · 468) — 범례 급경사 줄 ⚙ → 모달
+ *   (631 · 요구 537 = 수평 바 `ui_template_range_bar` — 칸 사이 경계값 한 번 · 아래 ° 환산 · 칸 눌러 색 · 칠 안 함 칸 ·
+ *    [단계 추가] = 고른 칸 반으로 · [단계 지움] = 이웃과 합침 · [기본값] · [적용] · 빈 값 · 같은 값 · 거꾸로 막음).
+ *   기억 = 화면 취향(`aislo:pref:d03.slope-bands` · 계정에 붙음 · 프로젝트 무관).
+ *   칠하기 = 서버 값 그림(회색 · 칸 = 기울기 % 내림) → 범위 색 그림(서버 왕복 없음 · CLAUDE.md 5장).
+ *   범위 · 비율 셈 = `logic/map_slope_bands.ts` · 부르는 곳 = D03 `UI_Layers` · B05 `UI_RouteEdit_Layers`.
+ * ========================================================================== */
+
+import { createButton, createIconButton } from "@ui/ui_template_button";
+import { openModal } from "@ui/ui_template_modal";
+import { themeColor } from "@ui/ui_template_palette";
+import { createRangeBar } from "@ui/ui_template_range_bar";
+import { createText } from "@ui/ui_template_text";
+import { readByKey, writeByKey } from "../b_page_state";
+import { loadImage } from "./map_layer_data";
+import {
+  DEFAULT_SLOPE_BANDS,
+  SLOPE_COLORS,
+  SLOPE_MAX_BANDS,
+  SLOPE_MAX_PCT,
+  bandOf,
+  bandsToBar,
+  barToBands,
+  checkBands,
+  checkEdges,
+  mergeBar,
+  parseBands,
+  pctToDeg,
+  splitBar,
+  type SlopeBand,
+  type SlopeBar,
+} from "./logic/map_slope_bands";
+
+const PREF_KEY = "aislo:pref:d03.slope-bands";
+/** 칠한 칸 투명도(겹 투명도 0.55 는 따로). */
+const ALPHA = 150;
+
+export const readSlopeBands = (): SlopeBand[] => parseBands(readByKey(PREF_KEY));
+export const writeSlopeBands = (bands: SlopeBand[]): void =>
+  writeByKey(PREF_KEY, JSON.stringify(bands));
+
+/** 값 그림 → 칸 값(빨강 자리 = 회색 값) · 받은 blob 주소는 다 읽었으니 놓음(616-4). */
+export function slopeValues(image: HTMLImageElement): ImageData {
+  const canvas = document.createElement("canvas");
+  canvas.width = image.naturalWidth;
+  canvas.height = image.naturalHeight;
+  const context = canvas.getContext("2d", { willReadFrequently: true })!;
+  context.drawImage(image, 0, 0);
+  if (image.src.startsWith("blob:")) URL.revokeObjectURL(image.src);
+  return context.getImageData(0, 0, canvas.width, canvas.height);
+}
+
+/** 범위대로 칠한 그림(주소 = data URL · toBlob 의 한가 작업 기다림 최대 1 s 없앰 616-4 ·
+ *  부르는 쪽 `URL.revokeObjectURL` 은 그대로 둬도 됨). */
+export async function paintSlope(
+  values: ImageData,
+  bands: SlopeBand[],
+): Promise<{ url: string; image: HTMLImageElement }> {
+  const rgb = bands.map((band) => hexRgb(themeColor(band.color, "#facc15")));
+  const lut = new Uint32Array(256);
+  const view = new DataView(lut.buffer);
+  for (let v = 0; v < 256; v++) {
+    const i = bandOf(v, bands);
+    if (i >= 0) view.setUint32(v * 4, ((rgb[i] << 8) | ALPHA) >>> 0, false);
+  }
+  const out = new ImageData(values.width, values.height);
+  const src = values.data;
+  const dst = new Uint32Array(out.data.buffer);
+  for (let p = 0; p < dst.length; p++) dst[p] = lut[src[p * 4]];
+  const canvas = document.createElement("canvas");
+  canvas.width = values.width;
+  canvas.height = values.height;
+  canvas.getContext("2d")!.putImageData(out, 0, 0);
+  const url = canvas.toDataURL("image/png");
+  return { url, image: await loadImage(url) };
+}
+
+/** `#rrggbb` → 0xrrggbb(못 읽으면 노랑). */
+function hexRgb(color: string): number {
+  const hex = /^#?([0-9a-f]{6})$/i.exec(color.trim())?.[1];
+  return hex ? parseInt(hex, 16) : 0xfacc15;
+}
+
+/** 범례 급경사 줄 ⚙. */
+export const slopeGear = (onClick: () => void): HTMLButtonElement => {
+  const button = createIconButton({
+    icon: "settings",
+    title: "급경사 범위 바꾸기(기울기 %)",
+    size: 20,
+    onClick,
+  });
+  button.dataset.role = "slope-bands";
+  return button;
+};
+
+/** 옵션 모달 — 수평 바(631 · 요구 537) · [적용] = 막을 것 없으면 `onApply` 후 닫음. */
+export function openSlopeBands(current: SlopeBand[], onApply: (bands: SlopeBand[]) => void): void {
+  const error = createText("", "error");
+  error.hidden = true;
+  const bar = createRangeBar({
+    ...bandsToBar(current),
+    palette: SLOPE_COLORS.map((c) => ({ value: c.color, name: c.name, color: `var(${c.color})` })),
+    noneLabel: "칠 안 함",
+    unit: "%",
+    ends: ["0 %", `${SLOPE_MAX_PCT} % 이상`],
+    hint: (pct) => `≈ ${pctToDeg(pct).toFixed(1)}°`,
+    ariaLabel: "급경사 범위",
+    onChange: () => refresh(),
+    onSelect: () => refresh(),
+  });
+  bar.root.dataset.role = "slope-bar";
+
+  /** 고칠 거리 — 경계 먼저 · 다음 범위(색 칸 없음 · 너무 많음). */
+  function problem(): string | null {
+    const state = bar.get();
+    return checkEdges(state.edges) ?? checkBands(barToBands(state));
+  }
+
+  function refresh(): void {
+    const state = bar.get();
+    const why = problem();
+    error.lastChild!.textContent = why ?? "";
+    error.hidden = !why;
+    const bad = checkEdges(state.edges) ? /(\d+)번째 경계/.exec(why ?? "")?.[1] : undefined;
+    bar.setError(bad ? Number(bad) : undefined);
+    addButton.disabled = !splitBar(state, bar.selected());
+    removeButton.disabled = !mergeBar(state, bar.selected());
+  }
+
+  const step =
+    (make: (state: SlopeBar, i: number) => SlopeBar | null, next: (i: number) => number) => () => {
+      const i = bar.selected();
+      const got = make(bar.get(), i);
+      if (!got) return;
+      bar.set(got, next(i));
+      refresh();
+    };
+  const addButton = createButton({
+    label: "단계 추가",
+    variant: "ghost",
+    size: 28,
+    iconStart: "plus",
+    onClick: step(splitBar, (i) => i + 1),
+  });
+  addButton.dataset.role = "slope-band-add";
+  addButton.title = "고른 칸을 반으로 나눔";
+  const removeButton = createButton({
+    label: "단계 지움",
+    variant: "ghost",
+    size: 28,
+    iconStart: "trash",
+    onClick: step(mergeBar, (i) => Math.max(0, i - 1)),
+  });
+  removeButton.dataset.role = "slope-band-remove";
+  removeButton.title = "고른 칸을 이웃 칸과 합침";
+
+  openModal({
+    title: "급경사 범위(기울기 %)",
+    closeLabel: "닫기",
+    width: "960px",
+    mount: (body, close, actions) => {
+      const reset = createButton({
+        label: "기본값",
+        variant: "ghost",
+        size: 28,
+        onClick: () => {
+          bar.set(bandsToBar(DEFAULT_SLOPE_BANDS), 0);
+          refresh();
+        },
+      });
+      reset.dataset.role = "slope-band-default";
+      const apply = createButton({
+        label: "적용",
+        size: 28,
+        onClick: () => {
+          refresh();
+          if (problem()) return;
+          onApply(barToBands(bar.get()));
+          close();
+        },
+      });
+      apply.dataset.role = "slope-band-apply";
+      actions.append(apply);
+      const foot = document.createElement("div");
+      foot.className = "d03-plan__row";
+      foot.append(addButton, removeButton, reset);
+      body.append(
+        createText(
+          `칸 사이 = 경계값(아래 칸 끝 = 위 칸 처음 · 아래 포함) · 칸 눌러 고르고 색 · 단계 ${SLOPE_MAX_BANDS}개까지 · 기본 = 15 · 35 · 40°(지식DB)`,
+          "hint",
+        ),
+        bar.root,
+        foot,
+        error,
+      );
+      refresh();
+    },
+  });
+}

A00_Common/map/map_terrain_chip.ts

@@ -0,0 +1,65 @@
+/* =============================================================================
+ * map_terrain_chip.ts
+ * 공용 지도 지형 칩(PLAN 624-2 · 요구 530 · 결정 A④ · A⑤ · D2) — 도구줄 끝 분할 고르기 하나: 수치지형도 · 라이다.
+ *   마우스 글 = 도구줄 표 호버제목(「수치지형도/라이다」 · 634-2) · 확인창은 B05 몫.
+ *   없는 원천 = 막힘 + 「제목 — 까닭」(D03 라이다 = D 프로젝트에 LAS 올린 뒤 · 624-4).
+ *   화면 칩만 — 바꾸는 일(서버 원천 인자 624-1 · B05 설계 지형 바꿈 626-1)은 `onChange` 로 페이지가 붙임.
+ *   쓰는 법 = `createTerrainChip({ page: "d03", value: "sheet", have: ["sheet"] })` → `{ root, set, setHave }` · root 를 도구줄 `terrain` 칸에.
+ * ========================================================================== */
+
+import { createSegment } from "@ui/ui_template_segment";
+import type { MapPage } from "./map_layer_list";
+import { mapToolTitle } from "./map_toolbar";
+
+/** 서버 겹 길 `terrain=` 값과 같음(624-1 · 빈 값 = 설계 지형). */
+export type TerrainSource = "sheet" | "lidar";
+
+export const TERRAIN_NAMES: Record<TerrainSource, string> = {
+  sheet: "수치지형도",
+  lidar: "라이다",
+};
+
+/** 막힘 까닭(마우스 글 = 「수치지형도/라이다 — 까닭」 · 요구 546). */
+const MISSING: Record<TerrainSource, string> = {
+  sheet: "이 프로젝트 범위에 도엽 지형 없음",
+  lidar: "올린 LAS 없음",
+};
+const TITLE = mapToolTitle("terrain");
+
+export interface TerrainChip {
+  root: HTMLElement;
+  /** 고름을 바꿈(onChange 는 안 부름). */
+  set: (value: TerrainSource) => void;
+  /** 고를 수 있는 원천 — 없는 것은 막힘. */
+  setHave: (have: readonly TerrainSource[]) => void;
+}
+
+export function createTerrainChip(opts: {
+  page: MapPage;
+  value: TerrainSource;
+  have: readonly TerrainSource[];
+  onChange?: (value: TerrainSource) => void;
+}): TerrainChip {
+  const sources = Object.keys(TERRAIN_NAMES) as TerrainSource[];
+  const segment = createSegment({
+    options: sources.map((value) => ({ value, label: TERRAIN_NAMES[value] })),
+    value: opts.value,
+    size: 32,
+    ariaLabel: TITLE,
+    onChange: (value) => opts.onChange?.(value as TerrainSource),
+  });
+  const root = segment.root;
+  root.dataset.act = "terrain";
+  root.title = TITLE;
+  const setHave = (have: readonly TerrainSource[]): void => {
+    for (const value of sources) {
+      const item = root.querySelector<HTMLButtonElement>(`[data-value="${value}"]`)!;
+      item.disabled = !have.includes(value);
+      // 열림 = 글 없음(칩 글 「수치지형도/라이다」 그대로) · 막힘 = 「제목 — 까닭」
+      if (item.disabled) item.title = `${TITLE} — ${TERRAIN_NAMES[value]} ${MISSING[value]}`;
+      else item.removeAttribute("title");
+    }
+  };
+  setHave(opts.have);
+  return { root, set: (value) => segment.set(value), setHave };
+}

A00_Common/map/map_toolbar.ts

@@ -0,0 +1,95 @@
+/* =============================================================================
+ * map_toolbar.ts
+ * 공용 지도 도구줄 표(PLAN 624-2 · 634-2 · 요구 530 · 546) — 예정노선(D03) · B05 평면이 같이 씀.
+ *   한 줄 = 요구 546 그룹2 표 한 줄 — 열쇠(`ui_template_map_tools` 단추 이름 · 아이콘) · 호버제목(`title`) · 할 일 · 보일 페이지.
+ *   묶음 = 나눔선 · 차례 = 도구줄 차례 · 단추 아닌 칸(간격 고르기 · 추천 노선 보기 · 지형 칩)은 페이지가 만든 요소.
+ *   마우스 글 = 이 표 `title` 하나(페이지 덮어쓰기 없음) · 막힘이면 페이지가 `mapToolTip(단추, 까닭)` → 「제목 — 까닭」.
+ *   누름 동작은 페이지 몫 — 만든 요소를 `parts` 로 넘기면 그 자리에 · 안 넘긴 단추는 기본 단추(돌리기 둘 = 공용 돌림이 `data-act` 로 찾음).
+ *   [?] 도움말 단추 = `createMapTools` 의 `hint`(맨 앞 · 글 = 이 표 첫 줄).
+ *   쓰는 법 = `createMapTools({ label, hint, groups: mapToolGroups("d03", { undo: undoButton, terrain: chip.root }) })`.
+ * ========================================================================== */
+
+import { mapToolButton, mapToolTip, type MapToolAct } from "@ui/ui_template_map_tools";
+import type { MapPage } from "./map_layer_list";
+
+export type MapToolKey = MapToolAct | "hint-toggle" | "recommend" | "terrain";
+
+export interface MapToolRow {
+  key: MapToolKey;
+  /** 호버제목(요구 546 표). */
+  title: string;
+  does: string;
+  pages: readonly MapPage[];
+}
+
+const BOTH: readonly MapPage[] = ["d03", "b05"];
+const B05: readonly MapPage[] = ["b05"];
+
+export const MAP_TOOLBAR: readonly (readonly MapToolRow[])[] = [
+  [{ key: "hint-toggle", title: "도움말", does: "조작 도움말 펼치기 · 접기(`hint`)", pages: BOTH }],
+  [
+    { key: "undo", title: "되돌리기", does: "편집 한 걸음 되돌림(Ctrl+Z)", pages: BOTH },
+    { key: "redo", title: "다시하기", does: "되돌린 걸음 다시(Ctrl+Y)", pages: BOTH },
+  ],
+  [
+    { key: "view3d", title: "3D", does: "3D 큰 창(동작 = 페이지 몫)", pages: BOTH },
+    { key: "rotate-ccw", title: "좌 회전", does: "지도 반시계로 돌림(Ctrl+휠도)", pages: BOTH },
+    { key: "rotate-cw", title: "우 회전", does: "지도 시계로 돌림", pages: BOTH },
+  ],
+  [
+    {
+      key: "contour-minor",
+      title: "등고선 1m",
+      does: "라이다 1 m 등고선 켬끔(라이다일 때만 열림)",
+      pages: B05,
+    },
+    { key: "stations", title: "측점", does: "측점 눈금 · 번호 켬끔", pages: BOTH },
+    { key: "slopes", title: "길이·기울기", does: "구간 길이 · 기울기 글 켬끔", pages: BOTH },
+    { key: "footprint", title: "절성토선", does: "도로 끝 · 비탈 끝 켬끔", pages: B05 },
+    { key: "measure", title: "길이측정", does: "거리 재기(동작 = 페이지 몫 · A⑩)", pages: BOTH },
+  ],
+  [
+    {
+      key: "station-snap",
+      title: "스냅",
+      does: "곡선 가운데(MC)를 간격 배수에 맞춤 · 고르기 메뉴 하나(측점 No. · 10 m · 끔 · 589-4)",
+      pages: B05,
+    },
+  ],
+  [
+    {
+      key: "recommend",
+      title: "추천노선",
+      does: "B05 = 노선 추천 저장본 선 여럿 고르기(색 구분) · 예정노선 = 가이드 선(지점 잇기 · 636-2)",
+      pages: BOTH,
+    },
+  ],
+  [{ key: "terrain", title: "수치지형도/라이다", does: "지형 원천 보기 · 고르기", pages: BOTH }],
+];
+
+const ROWS = MAP_TOOLBAR.flat();
+
+/** 표 호버제목 — 페이지 칸(지형 칩 막힘 글 등)이 씀. */
+export const mapToolTitle = (key: MapToolKey): string =>
+  ROWS.find((row) => row.key === key)?.title ?? key;
+
+const isAct = (key: MapToolKey): key is MapToolAct =>
+  key !== "hint-toggle" && key !== "station-snap" && key !== "recommend" && key !== "terrain";
+
+/** 그 페이지 도구줄 묶음 — 넘긴 요소 · 기본 단추(단추 열쇠만) · 마우스 글 = 표 · 빈 묶음 뺌. */
+export function mapToolGroups(
+  page: MapPage,
+  parts: Partial<Record<MapToolKey, HTMLElement>> = {},
+): HTMLElement[][] {
+  return MAP_TOOLBAR.map((group) =>
+    group
+      .filter((row) => row.pages.includes(page))
+      .flatMap((row): HTMLElement[] => {
+        const made = parts[row.key] ?? (isAct(row.key) ? mapToolButton(row.key) : null);
+        if (!made) return [];
+        made.dataset.tip = row.title;
+        mapToolTip(made);
+        return [made];
+      }),
+  ).filter((group) => group.length);
+}

A00_Common/master_unit_swap.ts

@@ -0,0 +1,133 @@
+/* =============================================================================
+ * master_unit_swap.ts
+ * SK 단위 바꿈 환산(728-1) — 짝(①): `resources/master_data/scripts/master_unit.py` `swap` · `split`.
+ * 거울 시험 `resources/tester/test_728_1_unit_swap.py`. 단위 표 · 별칭 · 분모 읽기는 그 모듈 그대로 옮김
+ * (한 벌 — 고칠 때 두 파일 함께). 화면 · fetch · 저장 없음.
+ * ========================================================================== */
+
+const ALIAS: Record<string, string> = {
+  ea: "개",
+  ton: "톤",
+  t: "톤",
+  l: "ℓ",
+  리터: "ℓ",
+  set: "조",
+  세트: "조",
+  hr: "시간",
+};
+const UNITS: Record<string, Record<string, number>> = {
+  무게: { g: 1, kg: 1000, 톤: 1000000 },
+  길이: { mm: 1, cm: 10, m: 1000, km: 1000000 },
+  넓이: { cm2: 1, m2: 10000 },
+  부피: { cm3: 1, ℓ: 1000, m3: 1000000 },
+  개수: { 개: 1, 본: 1, 매: 1, 개소: 1 },
+};
+const SCALE: Record<string, [string, number]> = {};
+for (const [kind, group] of Object.entries(UNITS)) {
+  for (const [u, n] of Object.entries(group)) SCALE[u] = [kind, n];
+}
+const WEIGHT_TABLE = "CC000337";
+const PER = /원\s*\/\s*(\d[\d,]*\.?\d*|\.\d+)?\s*([^\s·(\d,.][^\s·(]*)/;
+
+export type UnitNeed = null | "단위중량" | "사용자";
+export interface UnitSwap {
+  가: [number, string];
+  나: [number, string];
+  성격: [string | null, string | null];
+  /** have 1 개가 want 몇 개 — 1 단위 당 값은 ÷배 · 수량은 ×배 · 계수 없으면 null(셈 막음) */
+  배: number | null;
+  계수: UnitNeed;
+  근거: string;
+}
+
+export function plainUnit(unit: unknown): string {
+  const s = String(unit ?? "")
+    .normalize("NFKC")
+    .toLowerCase()
+    .replace(/\s+/g, "")
+    .replace(/ℓ/g, "l");
+  return ALIAS[s] ?? s;
+}
+
+export function unitKind(unit: unknown): string | null {
+  return SCALE[plainUnit(unit)]?.[0] ?? null;
+}
+
+function sameKind(a: unknown, b: unknown): boolean {
+  const k = unitKind(a);
+  return plainUnit(a) === plainUnit(b) || (k !== null && k === unitKind(b));
+}
+
+function weighs(a: unknown, b: unknown): boolean {
+  const ks = new Set([unitKind(a), unitKind(b)]);
+  return ks.size === 2 && ks.has("무게") && ks.has("부피");
+}
+
+/** `have` 1 단위가 `want` 몇 단위 — 부피 ↔ 무게는 단위중량(㎏/㎥) 있을 때만 · 못 하면 null */
+function factor(have: string, want: string, density?: number | null): number | null {
+  const a = plainUnit(have);
+  const b = plainUnit(want);
+  if (a === b) return 1;
+  if (sameKind(a, b)) return SCALE[a][1] / SCALE[b][1];
+  if (density && weighs(a, b)) {
+    const gramsPerCm3 = density / 1000;
+    const base = SCALE[a][1] * (unitKind(a) === "부피" ? gramsPerCm3 : 1 / gramsPerCm3);
+    return base / SCALE[b][1];
+  }
+  return null;
+}
+
+/** 열두 자리로 다듬음 — 파이썬 Decimal 셈과 같은 값(뜬수 끝 흔들림 없앰) */
+function tidy(x: number): number {
+  return Number(x.toPrecision(12));
+}
+
+function num(x: number): string {
+  return Number.isInteger(x) ? String(x) : String(x).slice(0, 10);
+}
+
+/** 기준단위 앞 수 떼기 — 「100본」 → [100, 본] · 「㎥」 → [1, ㎥] */
+export function splitUnit(unit: unknown): [number, string] {
+  const text = String(unit ?? "").trim();
+  const got = text ? PER.exec(`원/${text}`) : null;
+  if (!got) return [1, text];
+  return [got[1] ? Number(got[1].replace(/,/g, "")) : 1, got[2]];
+}
+
+/** SK 단위 `have` → `want` 환산 — 같은 성격 = 배 자동 · 부피 ↔ 무게 = 단위중량 · 그 밖 = 사용자 계수
+ *  (have 앞 수 뗀 1 단위 = want 앞 수 뗀 몇 단위 · 0 보다 커야). */
+export function swapUnit(
+  have: string,
+  want: string,
+  density?: number | null,
+  coef?: number | null,
+): UnitSwap {
+  const [na, ua] = splitUnit(have);
+  const [nb, ub] = splitUnit(want);
+  const base = { 가: [na, ua], 나: [nb, ub], 성격: [unitKind(ua), unitKind(ub)] } as Pick<
+    UnitSwap,
+    "가" | "나" | "성격"
+  >;
+  if (!ua || !ub) return { ...base, 배: 1, 계수: null, 근거: "" };
+  const need: UnitNeed = sameKind(ua, ub) ? null : weighs(ua, ub) ? "단위중량" : "사용자";
+  const f = need === "사용자" ? (coef && coef > 0 ? coef : null) : factor(ua, ub, density);
+  if (f === null) {
+    const why =
+      need === "단위중량"
+        ? `단위중량(${WEIGHT_TABLE}) 골라야 셈`
+        : "성격 다름 · 환산 계수 넣어야 셈";
+    return { ...base, 배: null, 계수: need, 근거: `${have} ↔ ${want} — ${why}` };
+  }
+  const ratio = tidy((na * f) / nb);
+  const how =
+    need === "단위중량"
+      ? ` · 단위중량 ${density}㎏/㎥`
+      : need === "사용자"
+        ? ` · 계수 1 ${ua} = ${coef} ${ub}`
+        : "";
+  let step = "";
+  if (ratio === 1) step = plainUnit(have) === plainUnit(want) ? "" : `${have} = ${want}`;
+  else
+    step = `${have} 당 → ${want} 당 ${ratio > 1 ? `÷${num(ratio)}` : `×${num(tidy(1 / ratio))}`}`;
+  return { ...base, 배: ratio, 계수: need, 근거: step + how };
+}

A00_Common/spreadsheet/spreadsheet.ts

@@ -72,6 +72,9 @@ export interface SpreadsheetOptions {
   conditions?: ConditionOptions;
   /** 그림 열쇠 → 주소(요구 347-5 · 시트 `그림`) — 없으면 이름 적힌 빈 상자 */
   figureSrc?: FigureSrc;
+  /** 칸 칠(요구 621-5) — 시트 id · 행 · 열(0 부터) → 꼴 이름 `success|warning|info|danger|muted`(흐림) + `mine`(왼쪽 띠) ·
+   * 공백으로 여럿 · 칸 `data-tone` 으로 나감 · 보이는 칸만 부름 · 안 주면 화면 그대로 */
+  칠?: (시트: string, r: number, c: number) => string | null | undefined;
 }
 
 export interface SpreadsheetHandle {
@@ -93,6 +96,8 @@ export interface SpreadsheetHandle {
   /** HTML 표를 지금 시트 고른 칸(왼위)부터 붙임(105-1 도면 → 면적) — 붙여넣기와 같은 길(병합 · 되돌리기 한 번) ·
    * `check` = 덮을 자리의 값 칸 · 알약 칸 수 · 범위 → false 면 안 붙임 · 붙인 범위 A1 · 읽기만 · 못 하면 null */
   pasteTable(html: string, check?: PasteCheck): Promise<string | null>;
+  /** 보이는 칸만 다시 그림(`칠` 결과가 바뀐 뒤) — 문서는 안 읽음 */
+  repaint(): void;
   /** 범위 고름 · 보이게 굴림(329-2 엑셀 보기 창) — `시트` = id 나 이름(없으면 지금 시트 · 다르면 그 탭으로) ·
    * 범위 여럿 = 여러 고름 · 시트가 없거나 주소가 틀리면 false(고름 그대로) */
   select(범위: string | string[], 시트?: string): boolean;
@@ -138,6 +143,7 @@ export function createSpreadsheet(
     root,
     book,
     readOnly,
+    fill: opts.칠,
     engine: createCalcEngine(book),
     history: createHistory(),
     selection: selectCell(firstSheet(book), 0, 0),
@@ -225,10 +231,10 @@ export function createSpreadsheet(
   }
 
   function dispatch(command: Command): void {
-    if (readOnly) return;
+    if (readOnly && command.종류 !== "열폭") return; // 읽기 전용도 열 폭은 바꿈(보기만 · 저장 · 되돌리기 없음)
     const eff = apply(command);
     if (!eff) return;
-    ctx.history.push(command, eff.undo);
+    if (!readOnly) ctx.history.push(command, eff.undo);
     after(command, eff);
   }
 
@@ -252,7 +258,7 @@ export function createSpreadsheet(
       else grid.render();
     }
     select(ctx.selection, false, true); // 명령이 바꾼 뒤 — 알약 점 등 문서 종속 부품도 다시(81-2)
-    opts.onChange?.(structuredClone(ctx.book));
+    if (!readOnly) opts.onChange?.(structuredClone(ctx.book));
   }
 
   /** 칸 명령이 건드린 칸(서식만 바뀐 칸도 다시 그리게) */
@@ -369,6 +375,7 @@ export function createSpreadsheet(
       return 이름;
     },
     pasteTable: (html, check) => pasteTableAt(ctx, html, check),
+    repaint: () => grid.render(),
     select(range, sheetKey) {
       const target = sheetKey
         ? ctx.book.시트.find((s) => s.id === sheetKey || s.이름 === sheetKey)

A00_Common/spreadsheet/spreadsheet_autofit.ts

@@ -13,7 +13,8 @@
  * · 확대 · 축소 — 값 자체를 저장하지 않는 화면 전용 CSS 배율(C 격자 뿌리에 transform) · 계약 밖.
  * ========================================================================== */
 
-import type { Workbook } from "./spreadsheet_types";
+import { colIndex, colName, parseRange } from "./spreadsheet_address";
+import type { Sheet, Workbook } from "./spreadsheet_types";
 import type { SpreadsheetContext } from "./spreadsheet_view_types";
 
 export type TextMeasurer = (text: string) => number;
@@ -30,13 +31,27 @@ const defaultMeasure: TextMeasurer = (text) => {
 
 const colFromKey = (key: string): number => {
   const m = /^([A-Z]+)\d+$/.exec(key);
-  if (!m) return -1;
-  let col = 0;
-  for (const ch of m[1]) col = col * 26 + (ch.charCodeAt(0) - 64);
-  return col - 1;
+  return m ? colIndex(m[1]) : -1;
 };
 
-/** 그 열에 든 칸 글자(식 칸은 식 글로 어림 — 계산값은 여기서 모름) 중 가장 넓은 것 + 여백. */
+/** 열마다 가장 넓은 칸 글자 폭(식 칸은 식 글로 어림 — 계산값은 여기서 모름) · 여러 열 병합 칸은 뺌(제목 줄). */
+function widestByColumn(sheet: Sheet, measure: TextMeasurer): Map<number, number> {
+  const wide = new Set<string>();
+  for (const text of sheet.병합 ?? []) {
+    const r = parseRange(text);
+    if (r && r.c1 > r.c0) wide.add(`${colName(r.c0)}${r.r0 + 1}`);
+  }
+  const out = new Map<number, number>();
+  for (const [key, cell] of Object.entries(sheet.칸)) {
+    const text = cell.식 !== undefined ? cell.식 : cell.값 !== undefined ? String(cell.값) : "";
+    const col = colFromKey(key);
+    if (!text || col < 0 || wide.has(key)) continue;
+    out.set(col, Math.max(out.get(col) ?? 0, measure(text)));
+  }
+  return out;
+}
+
+/** 그 열에 든 칸 글자 중 가장 넓은 것 + 여백. */
 export function estimateColumnWidth(
   book: Workbook,
   sheetId: string,
@@ -45,13 +60,19 @@ export function estimateColumnWidth(
 ): number {
   const sheet = book.시트.find((s) => s.id === sheetId);
   if (!sheet) return MIN_WIDTH;
-  let widest = 0;
-  for (const [key, cell] of Object.entries(sheet.칸)) {
-    if (colFromKey(key) !== col) continue;
-    const text = cell.식 !== undefined ? cell.식 : cell.값 !== undefined ? String(cell.값) : "";
-    if (text) widest = Math.max(widest, measure(text));
+  return Math.max(MIN_WIDTH, Math.ceil((widestByColumn(sheet, measure).get(col) ?? 0) + PADDING));
+}
+
+/** 폭 정보 없는 열(엑셀 폭을 못 읽은 파일)에 글 길이로 처음 폭을 채움 — 최소 · 최대 안(읽기 전용 보기). */
+export function fillMissingWidths(book: Workbook, min = 6, max = 60): void {
+  for (const sheet of book.시트) {
+    for (const [col, widest] of widestByColumn(sheet, defaultMeasure)) {
+      const letter = colName(col);
+      if (sheet.열?.[letter]?.폭 !== undefined) continue;
+      const 폭 = Math.min(max, Math.max(min, Math.ceil(widest + PADDING)));
+      sheet.열 = { ...sheet.열, [letter]: { ...sheet.열?.[letter], 폭 } };
+    }
   }
-  return Math.max(MIN_WIDTH, Math.ceil(widest + PADDING));
 }
 
 /** 폭을 자동 맞춤 값으로 바꿈(열넓이 명령 하나). */

A00_Common/spreadsheet/spreadsheet_grid.css

@@ -276,3 +276,40 @@ html[data-touch="on"] .aislo-grid__fill-handle {
     touch-action: pan-x pan-y;
   }
 }
+
+/* 칸 칠(옵션 `칠` · 요구 621-5) — 칸 원래 채움(인라인 background-color) 위에 겹침 · 어두움은 --color-* 가 따라감. */
+.aislo-cell[data-tone~="success"] {
+  background-image: linear-gradient(
+    color-mix(in srgb, var(--color-success) 18%, transparent),
+    color-mix(in srgb, var(--color-success) 18%, transparent)
+  );
+}
+.aislo-cell[data-tone~="warning"] {
+  background-image: linear-gradient(
+    color-mix(in srgb, var(--color-warning) 18%, transparent),
+    color-mix(in srgb, var(--color-warning) 18%, transparent)
+  );
+}
+.aislo-cell[data-tone~="info"] {
+  background-image: linear-gradient(
+    color-mix(in srgb, var(--color-info) 18%, transparent),
+    color-mix(in srgb, var(--color-info) 18%, transparent)
+  );
+}
+.aislo-cell[data-tone~="danger"] {
+  background-image: linear-gradient(
+    color-mix(in srgb, var(--color-danger) 18%, transparent),
+    color-mix(in srgb, var(--color-danger) 18%, transparent)
+  );
+}
+.aislo-cell[data-tone~="muted"] {
+  color: var(--color-text-muted) !important;
+}
+.aislo-cell[data-tone~="mine"] {
+  box-shadow: inset 3px 0 0 var(--color-accent);
+}
+
+/* 읽기만 — 시트 탭 「+」 숨김 */
+.ss--readonly .ss-tabs__add {
+  display: none;
+}

A00_Common/spreadsheet/spreadsheet_grid.ts

@@ -437,6 +437,16 @@ export function createGrid(ctx: SpreadsheetContext): GridHandle {
     };
   }
 
+  /** 굴리는 영역 밖 테두리 자르기(`overlay` 좌표) — 고정 머리 칸 · 모서리 · 스크롤바 위로 안 나가게(요구 566). */
+  function clipOf(b: CellBox, inFrozenCol: boolean, inFrozenRow: boolean): string {
+    const pad = (n: number): number => Math.max(0, Math.ceil(n));
+    const top = inFrozenRow ? 0 : pad(frozenH - b.y);
+    const left = inFrozenCol ? 0 : pad(frozenW - b.x);
+    const bottom = pad(b.y + b.h - (frozenH + paneBR.clientHeight));
+    const right = pad(b.x + b.w - (frozenW + paneBR.clientWidth));
+    return `inset(${top}px ${right}px ${bottom}px ${left}px)`;
+  }
+
   function renderSelection(): void {
     let selLayer = overlay.querySelector<HTMLElement>(".aislo-grid__sel-layer");
     if (!selLayer) {
@@ -470,6 +480,7 @@ export function createGrid(ctx: SpreadsheetContext): GridHandle {
       node.style.height = `${screen.h}px`;
       node.style.borderColor = "var(--aislo-grid-selected)";
       node.style.borderWidth = i === 0 ? "2px" : "1px";
+      node.style.clipPath = clipOf(screen, inFrozenCol, inFrozenRow);
       selLayer!.append(node);
     }
     // 활성 칸 테두리 — 칸 다시 그리기(`renderRowOfCells`) 없이 고름만 바뀌어도 옛 칸에 남지 않게.
@@ -487,6 +498,17 @@ export function createGrid(ctx: SpreadsheetContext): GridHandle {
     handle.className = "aislo-grid__fill-handle";
     handle.style.left = `${corner.x + corner.w - 4}px`;
     handle.style.top = `${corner.y + corner.h - 4}px`;
+    const hx = corner.x + corner.w;
+    const hy = corner.y + corner.h;
+    const hFC = handleAt.c < frozenCols;
+    const hFR = handleAt.r < frozenRows;
+    if (
+      (!hFC && hx < frozenW) ||
+      (!hFR && hy < frozenH) ||
+      hx > frozenW + paneBR.clientWidth ||
+      hy > frozenH + paneBR.clientHeight
+    )
+      handle.style.display = "none";
     selLayer!.append(handle);
   }
 
@@ -525,6 +547,16 @@ export function createGrid(ctx: SpreadsheetContext): GridHandle {
       node.style.width = `${merged.w}px`;
       node.style.height = `${merged.h}px`;
       node.style.borderColor = REF_COLORS[ref.색번호 % REF_COLORS.length];
+      node.style.clipPath = clipOf(
+        {
+          x: parseFloat(node.style.left),
+          y: parseFloat(node.style.top),
+          w: merged.w,
+          h: merged.h,
+        },
+        inFrozenCol,
+        inFrozenRow,
+      );
       refLayer!.append(node);
     }
   }
@@ -540,8 +572,10 @@ export function createGrid(ctx: SpreadsheetContext): GridHandle {
     const contentY =
       y < headRowH() ? -1 : y - headRowH() + (y - headRowH() > frozenH ? paneBR.scrollTop : 0);
     if (y < headRowH()) {
-      const c = colGeo.indexAt(contentX);
-      const edge = Math.abs(colGeo.offset(c + 1) - contentX) <= RESIZE_HOTZONE;
+      const at = colGeo.indexAt(contentX);
+      const after = at > 0 && contentX - colGeo.offset(at) <= RESIZE_HOTZONE; // 경계 오른쪽 반 = 앞 열 경계
+      const c = after ? at - 1 : at;
+      const edge = after || Math.abs(colGeo.offset(c + 1) - contentX) <= RESIZE_HOTZONE;
       return { kind: edge ? "colEdge" : "colHead", r: 0, c };
     }
     if (x < headColW()) {

A00_Common/spreadsheet/spreadsheet_grid_cells.ts

@@ -319,6 +319,9 @@ export function renderCells(
           if (need > w * 0.9) longs.push({ r: r0, c: c0, el: cellEl, own: w, need, align });
         }
       }
+      const tone = ctx.fill?.(sheet.id, r0, c0);
+      if (tone) cellEl.dataset.tone = tone;
+      else delete cellEl.dataset.tone; // 재사용 div — 앞 칸 꼴을 지움
       cellEl.classList.toggle("is-error", display.isError);
       cellEl.classList.toggle("has-comment", !!comment);
       cellEl.classList.toggle(

A00_Common/spreadsheet/spreadsheet_mouse.ts

@@ -233,9 +233,9 @@ export function attachMouse(
   }
 
   function onDbl(e: MouseEvent): void {
-    if (e.target === ed.ta || ctx.readOnly) return;
+    if (e.target === ed.ta) return;
     const hit = ctx.grid.hitTest(e.clientX, e.clientY);
-    if (!hit) return;
+    if (!hit || (ctx.readOnly && hit.kind !== "colEdge")) return; // 읽기 전용 = 열 경계 맞춤만
     if (hit.kind === "fillHandle") return fillDown();
     if (hit.kind === "colEdge") {
       // 고른 열 전체의 경계면 고른 열 모두(엑셀)

A00_Common/spreadsheet/spreadsheet_view_types.ts

@@ -94,6 +94,8 @@ export interface SpreadsheetContext {
   /** 지금 문서 — 명령만이 바꿈(직접 고치지 말 것) */
   book: Workbook;
   readOnly: boolean;
+  /** 칸 칠(옵션 `칠`) — 시트 id · 행 · 열 → 꼴 이름(공백으로 여럿 · 없으면 칠 없음) · 보이는 칸만 부름 */
+  fill?: (시트: string, r: number, c: number) => string | null | undefined;
   engine: CalcEngine;
   history: History;
   selection: Selection;

B01_Dashboard/B01_Dashboard_Router_Home.py

@@ -140,7 +140,8 @@ async def _company(cursor: Any, company_id: int) -> dict[str, Any]:
 
 async def _forest(cursor: Any, company_id: int) -> dict[str, Any]:
     """예정노선 수 — 분석 전 = 노선을 아직 안 그은 프로젝트 · 분석됨 · 확정 = 연도(설계 내용 파일) ·
-    업체 지정 대기 = 확정 연도 중 그 연도 조각에 업체가 하나도 없는 것."""
+    업체 지정 대기 = 확정 연도 중 그 연도 세트에 업체가 하나도 없는 것(업체 줄 = 세트 열쇠 ·
+    옛 조각 id = 든 세트)."""
     from D03_PlanAnalysis import D03_PlanAnalysis_Store as store
 
     await cursor.execute(
@@ -161,11 +162,13 @@ async def _forest(cursor: Any, company_id: int) -> dict[str, Any]:
             continue
         if not state["plan"]["lines"]:
             status["draft"] += 1
+        found = (store.find_unit(state["units"], key) for key in pieces)
+        held = {unit["id"] for unit in found if unit}
         for year, row in state["years"].items():
             key = "confirmed" if row["confirmed_at"] else "analyzed"
             status[key] += 1
-            ids = {p["id"] for p in row["route"]["pieces"]}
-            waiting += bool(row["confirmed_at"] and not ids & pieces)
+            ids = {u["id"] for u in state["units"] if u["year"] == year}
+            waiting += bool(row["confirmed_at"] and not ids & held)
     return {"plan_status": status, "assign_waiting": waiting}
 
 

B01_Dashboard/B01_Dashboard_UI_View_SysDefaults.ts

@@ -1,7 +1,8 @@
 /* =============================================================================
  * B01_Dashboard_UI_View_SysDefaults.ts
- * 시스템 관리 › 설계 기본값(549-2) — 마스터 데이터 · 구조물 조합 · 구조물 옵션 · 도면 양식 · 계산 자리.
- *   카드 규칙은 `settingLinks` 한 벌(334) — 여기는 모양만(묶음 제목 + 둥근 상자 안 줄) · 계산 자리 = 창(504-2).
+ * 시스템 관리 › 설계 기본값(549-2 · 716-2) — 마스터 데이터(마스터 요소 · 단가산출 로직 · 구조물 옵션 정의) ·
+ *   마스터 템플릿(일위대가 · 구조물 조합 · 도면 양식) · 계산 자리. 칸마다 한 줄(누르면 그 칸을 고른 채 열림 · `?open=`).
+ *   줄 · 묶음 규칙은 `settingLinks` 한 벌(334) — 여기는 모양만(묶음 제목 + 둥근 상자 안 줄) · 계산 자리 = 창(504-2).
  * ========================================================================== */
 
 import { createButton } from "@ui/ui_template_elements";
@@ -12,22 +13,13 @@ import { pageFrame, settingCard, settingRow } from "./B01_Dashboard_UI_PageKit";
 import { group } from "./B01_Dashboard_UI_View_Parts";
 import type { ViewCtx } from "./B01_Dashboard_UI_Views";
 
-/** 카드 열쇠 → 묶음 제목 — 모르는 열쇠는 「그 밖」 */
-const GROUP_OF: Record<string, string> = {
-  m01: "마스터 데이터",
-  구조물조합: "구조물 · 도면",
-  옵션: "구조물 · 도면",
-  도면: "구조물 · 도면",
-  calcSites: "계산",
-};
-
 const open = (link: SettingLink): void =>
   link.key === "calcSites" ? void openCalcSitesDialog() : navigateTo(link.route, link.query);
 
 export function mountSysDefaults(host: HTMLElement, ctx: ViewCtx): void {
   const groups = new Map<string, HTMLElement[]>();
   for (const link of settingLinks(ctx.me, ctx.companyId)) {
-    const title = GROUP_OF[link.key] ?? "그 밖";
+    const title = link.group ?? "그 밖";
     const openBtn = createButton({ label: "열기", variant: "ghost", onClick: () => open(link) });
     groups.set(title, [...(groups.get(title) ?? []), settingRow(link.title, link.desc, openBtn)]);
   }

B03_FileInput/B03_FileInput_Service_Chain.py

@@ -13,12 +13,13 @@ WF1(지표면 분석·자동 확정)이 끝나면 사용자가 화면에 없어
   사용자는 그 페이지에서 수동으로 이어서 진행할 수 있다.
 - 라우터 함수를 직접 호출한다(HTTP 재진입 없음). solve/confirm 엔드포인트는 인증
   의존성이 없는 순수 함수 시그니처라 서버 내부 호출이 가능하다.
+- **지형마다 한 벌**(765-3): 전처리 체인 = `run_preprocess_chain` — 다른 지형 벌을 먼저 지어
+  `design_sets/` 묶음으로 떠 두고 설계 지형 벌을 지음(`common_util_design_sets`).
 """
 
 import asyncio
 import logging
 import time
-from dataclasses import asdict
 from pathlib import Path
 from typing import Any
 from uuid import UUID
@@ -155,10 +156,12 @@ async def _prepare_drainage_pipes_and_reprofile(
 
 
 async def run_auto_design_chain(
-    project_id: UUID, surface_model_id: int | None = None
+    project_id: UUID, surface_model_id: int | None = None, *, inner: bool = False
 ) -> dict[str, Any] | None:
     """B05 기본 경로 계산·확정 → B06 기본 횡단 설계 확정을 기본값으로 이어 실행한다.
 
+    `inner` = 두 벌 짓기 · 지형 칩 안에서 부름(765) — 진입 막음 마커 · 추천 미리 셈은 부르는 쪽.
+
     WF1 자동 확정 직후 같은 백그라운드 태스크에서 호출된다. 어떤 단계가 실패해도
     예외를 밖으로 던지지 않는다 — 로그와 각 단계의 workflow 상태 기록으로 남긴다.
 
@@ -228,7 +231,8 @@ async def run_auto_design_chain(
         route_range = (range_row[0], range_row[1]) if range_row else None
         seeded_speed = range_row[2] if range_row else None
 
-        points = _planned_route_points_in_project_crs(project_root, defaults, route_range)
+        # 벌 예정노선 = 받은 노선을 이 벌 지형으로 자름(765-8 · 요구 612) — 벌마다 길이 · 곡선 다름
+        points = await asyncio.to_thread(_terrain_route_points, project_root, defaults, route_range)
         if not points:
             logger.warning("자동 설계 체인 중단(계획노선 없음): project_id=%s", project_id)
             mark_design_failed(project_root, "계획노선이 없어 초기 노선을 세울 수 없습니다.")
@@ -309,7 +313,8 @@ async def run_auto_design_chain(
 
         # 4.5) 배수유역 분석 → 관 지점 확정 → 배관 정착 계획선 재산출.
         #      B06 확정 전에 끝내야 확정 스냅샷에 배관 정착 계획선이 담긴다.
-        await _prepare_drainage_pipes_and_reprofile(project_id, route_id)
+        #      배수는 늘 다시 셈(765-3) — 저장분은 노선이 바뀐 줄 모름(두 벌 · 서피스 바꿈 뒤 묵음).
+        await _prepare_drainage_pipes_and_reprofile(project_id, route_id, refresh=True)
 
         # 5) B06 횡단 설계 확정 — 미지정 측점을 기본값으로 채워 저장. stage 3은
         #    IN_PROGRESS(스텝바 노란 표시)로 남겨 사용자 검토·확정을 기다린다.
@@ -347,12 +352,6 @@ async def run_auto_design_chain(
             logger.exception("초기값 스냅샷 실패: project_id=%s", project_id)
             mark_design_failed(project_root, f"초기값 스냅샷 저장 실패: {exc}")
 
-        # 노선 추천 기본 다섯 알약 미리 셈(PLAN 327-2) — 예약만 · 체인이 [초기화] 요청 안에서도
-        # 불리므로 기다리지 않는다. 같은 입력이면 저장본이 있어 셈 없이 끝난다.
-        from B05_Profile.B05_Profile_Router_RouteInitial import schedule_precompute
-
-        schedule_precompute(project_id)
-
         return {
             "route_id": route_id,
             "length_m": float(solve_result.total_length_m or 0.0),
@@ -365,21 +364,157 @@ async def run_auto_design_chain(
             mark_design_failed(project_root, f"초기 설계 처리 중 오류: {exc}")
     finally:
         # 성공·실패·중단 어느 쪽이든 문은 연다 — 마커가 남으면 영영 못 들어간다.
-        if project_root is not None:
+        if project_root is not None and not inner:
             clear_designing(project_root)
+        # 성공 · 실패 · 건너뜀 어느 쪽이든 추천 미리 셈 예약(763-3) — 추천은 지형 · 예정노선만 씀
+        if not inner:
+            from B05_Profile.B05_Profile_Router_RouteInitial import schedule_precompute
+
+            schedule_precompute(project_id)
+
+
+async def run_preprocess_chain(
+    project_id: UUID, surface_model_id: int | None = None
+) -> dict[str, Any] | None:
+    """전처리 체인 = 지형마다 설계 한 벌(765-3 · 요구 605 · 606-1) — 결과 = 설계 지형 요약.
+
+    다른 지형 먼저 자동 설계 → 묶음으로 떠 둠(B05~B09 비움) → 설계 지형 자동 설계 → 추천 미리 셈
+    한 번(실패 길에도). 다른 지형이 없으면(LAS 만 · 수치지형도 못 받음 · 수치지형도만) 한 벌 ·
+    묶음 meta.json 에 까닭. 부르는 곳 = WF1 자동 확정 · 서피스 바꿈 체인(B04 다른 서피스 [확정] ·
+    LAS 나중 올리기 뒤 전처리 다시). 묶음은 처음부터 다시(옛 벌 버림).
+    """
+    from B03_FileInput.B03_FileInput_Repository import get_project_storage_relative_path
+    from B05_Profile.B05_Profile_Router_RouteInitial import schedule_precompute
+    from common_util import common_util_design_sets as sets
+    from common_util.common_util_initial_snapshot import (
+        clear_designing,
+        mark_designing,
+        read_design_failure,
+    )
+    from common_util.common_util_storage import resolve_stored_project_path
+    from common_util.common_util_surface_confirmation import (
+        design_terrain,
+        get_surface_confirmation_params,
+    )
+    from config.config_db import get_db_pool
+
+    pool = get_db_pool()
+    root: Path | None = None
+    marks = [("시작", time.perf_counter())]
+    try:
+        async with pool.acquire() as connection:
+            stored_path = await get_project_storage_relative_path(connection, project_id)
+            params = await get_surface_confirmation_params(connection, str(project_id))
+        if not stored_path:
+            return None
+        root = Path(resolve_stored_project_path(stored_path))
+        mark_designing(root)
+        sets.discard_sets(root)
+        design = design_terrain(params)
+        other = sets.other_terrain(params, root)
+        if other is None:
+            missing = "sheet" if design == "las" else "las"
+            sets.note_unbuilt(root, missing, f"{missing} 지표면 모델 없음 — 한 벌만")
+        else:
+            # 예상노선(공유 · 추천 열쇠)은 설계 지형으로 자른 것 하나 — 벌 평면노선은 벌마다
+            # 그 지형으로 자른 벌 예정노선(`terrain_route.csv`)을 따라감(765-8 · 요구 612)
+            await _seed_expected_route(project_id, root, params)
+            try:
+                async with pool.acquire() as connection:
+                    model_id = await sets.switch_terrain(connection, project_id, other)
+                built = await run_auto_design_chain(project_id, model_id, inner=True)
+                async with pool.acquire() as connection:
+                    fingerprint = await sets.set_fingerprint(
+                        connection, str(project_id), root, other
+                    )
+                    if built and fingerprint:
+                        await sets.park_active_set(connection, root, str(project_id), fingerprint)
+                    else:
+                        await sets.clear_active_set(connection, root, str(project_id))
+                        sets.note_unbuilt(root, other, read_design_failure(root) or "짓기 실패")
+            except Exception as exc:  # noqa: BLE001 — 다른 벌 실패가 설계 지형 벌을 막지 않음
+                logger.exception("두 벌 짓기 — %s 벌 실패: project_id=%s", other, project_id)
+                async with pool.acquire() as connection:
+                    await sets.clear_active_set(connection, root, str(project_id))
+                sets.note_unbuilt(root, other, f"짓기 오류: {exc}")
+            finally:
+                async with pool.acquire() as connection:
+                    await sets.switch_terrain(connection, project_id, design)
+            marks.append((f"{other} 벌", time.perf_counter()))
+        summary = await run_auto_design_chain(project_id, surface_model_id, inner=True)
+        marks.append((f"{design} 벌", time.perf_counter()))
+        _log_steps("전처리 체인 두 벌", marks)
+        return summary
+    except Exception:
+        logger.exception("전처리 체인 실패: project_id=%s", project_id)
+        return None
+    finally:
+        if root is not None:
+            clear_designing(root)
+        schedule_precompute(project_id)  # 추천은 지형 · 예정노선만 씀 — 실패 길에도(763-3)
+
+
+def _terrain_route_points(
+    root: Path, surface: dict[str, Any], route_range: tuple[Any, Any] | None
+) -> list[dict[str, float]] | None:
+    """벌 예정노선(`terrain_route.csv` · 벌 몫) — 있으면 그것 · 없으면 받은 노선을 이 지형으로
+    잘라 적음.
+
+    받은 노선 파일이 없는 옛 프로젝트 = 정본 차례(`load_design_route`) 그대로."""
+    from common_util.common_util_route_geometry import (
+        load_design_route,
+        read_planned_route_csv,
+        terrain_route_csv_path,
+        write_route_csv,
+    )
+
+    path = terrain_route_csv_path(root)
+    stored = read_planned_route_csv(path) if path.is_file() else None
+    if stored is not None and len(stored.vertices) >= 2:
+        return [{"x": v.x, "y": v.y} for v in stored.vertices]
+    planned = load_design_route(root, surface, route_range, from_source=True)
+    points = (
+        [{"x": v.x, "y": v.y} for v in planned.vertices]
+        if planned is not None
+        else _planned_route_points_in_project_crs(root, surface, route_range)
+    )
+    if points:
+        write_route_csv(path, points)
+    return points
+
+
+async def _seed_expected_route(project_id: UUID, root: Path, surface: dict[str, Any]) -> None:
+    """예상노선 정본을 설계 지형으로 잘라 적음(없을 때만 · 자동 체인 2.5 와 같은 값)."""
+    from common_util.common_util_route_geometry import expected_route_csv_path, write_route_csv
+    from config.config_db import get_db_pool
+
+    path = expected_route_csv_path(root)
+    if path.is_file():
+        return
+    async with get_db_pool().acquire() as connection, connection.cursor() as cursor:
+        await cursor.execute(
+            "SELECT route_start_m, route_end_m FROM projects WHERE id = %s", (str(project_id),)
+        )
+        row = await cursor.fetchone()
+    points = await asyncio.to_thread(
+        _planned_route_points_in_project_crs, root, surface, (row[0], row[1]) if row else None
+    )
+    if points:
+        write_route_csv(path, points)
 
 
 async def _ensure_initial_polyline(
     project_id: UUID, project_root: Path, points: list[dict[str, float]]
 ) -> None:
     """계획노선 초기 폴리라인을 세운다 — 이미 있으면 그대로 둔다. 실패는 비치명적."""
-    import asyncio
 
+    from B05_Profile.B05_Profile_Router_FollowLand import initial_land
     from B05_Profile.B05_Profile_Router_Replan import _ensure_planned_initial, _min_plan_radius_m
 
     try:
         radius_m = await _min_plan_radius_m(project_id)
-        summary = await asyncio.to_thread(_ensure_planned_initial, project_root, radius_m)
+        land = await initial_land(project_id, project_root)
+        summary = await asyncio.to_thread(_ensure_planned_initial, project_root, radius_m, land)
         if summary:
             logger.info(
                 "초기 계획노선 폴리라인: project_id=%s 노드 %d · 곡선 %d · 위반 %d (R %.1fm)",
@@ -442,247 +577,3 @@ def redesign_solve_request(
         start_elevation_offset_m=params.get("start_elevation_offset_m"),
         end_elevation_offset_m=params.get("end_elevation_offset_m"),
     )
-
-
-async def run_redesign_chain(
-    project_id: UUID,
-    surface_model_id: int,
-    selection: dict[str, Any],
-    profile_target: tuple[list[float], list[float]] | None = None,
-) -> str | None:
-    """B04 재확정 후 — **사용자 입력을 유지한 채** 새 지표면 기준으로 B05·B06 재계산·저장.
-
-    관리자가 B04에서 다른 지표면 모델로 재확정하면(2026-08-04 사용자 확정) 그 값을
-    기준으로 다음 페이지들도 함께 갱신돼야 한다. 이때 일반 사용자가 이미 쓰던 설정은
-    버리지 않는다:
-    - B05: 저장된 stage 2 params(제어점 BP/EP/CP·회피/금지원·경사 옵션·측점 간격 등)를
-      그대로 쓰고 **지표면(filter/method/smooth/model id)만** 새 확정값으로 바꾼다.
-    - B06: 옛 경로의 측점별 설계(지반유형·단면유형·측구·암 경계)를 chainage 매칭으로
-      새 경로에 이월하고, 표준단면 설정(data.options)도 함께 넘긴다. 나머지 미지정
-      측점은 확정 시 기본값으로 채워진다.
-
-    경로가 아예 없으면 신규 자동 체인(계획노선 정본 기본값)으로 되돌아간다.
-
-    `profile_target`(누가거리 · 계획고)이 오면 1차 종단을 그 계획고로 세운다 — 노선 추천
-    「종단 반영」 켬으로 [적용]한 노선의 균형 종단(PLAN 74-4). 없으면 계획고 = 지반고.
-    """
-    from B03_FileInput.B03_FileInput_Repository import get_project_storage_relative_path
-    from B05_Profile.B05_Profile_Repository import get_latest_route
-    from B05_Profile.B05_Profile_Router import (
-        _section_options,
-        confirm_latest_route,
-        solve_route_record,
-    )
-    from B06_Section.B06_Section_Repository import (
-        get_cross_section_designs,
-        get_latest_section_options,
-        get_longitudinal_section,
-    )
-    from B06_Section.B06_Section_Repository_Bulk import merge_cross_section_designs
-    from B06_Section.B06_Section_Router import regenerate_route_sections
-    from B06_Section.B06_Section_Router_Confirm import _rowless_station_chainages, confirm_sections
-    from B06_Section.B06_Section_Router_Design import CARRY_INPUT_KEYS, compute_default_designs
-    from B06_Section.B06_Section_Schema import SectionConfirmRequest
-    from common_util.common_util_initial_snapshot import (
-        clear_designing,
-        discard_initial_snapshot,
-        mark_designing,
-    )
-    from common_util.common_util_storage import resolve_stored_project_path
-    from common_util.common_util_workflow_state import get_workflow_state
-    from config.config_db import get_db_pool
-
-    pool = get_db_pool()
-    project_root: Path | None = None
-    marks = [("시작", time.perf_counter())]
-    try:
-        async with pool.acquire() as connection:
-            latest = await get_latest_route(connection, project_id)
-            stored_path = await get_project_storage_relative_path(connection, project_id)
-        if stored_path:
-            project_root = Path(resolve_stored_project_path(stored_path))
-            mark_designing(project_root)
-            # 지표면이 바뀌면 옛 초기값은 다른 지형 기준이라 더는 기준이 아니다. 여기서
-            # 다시 뜨지는 않는다 — 이 체인은 **사용자 입력을 유지한 채** 재계산하므로 그
-            # 결과를 찍으면 편집이 섞인 가짜 초기값이 된다(2026-08-29 사용자 확정).
-            if discard_initial_snapshot(project_root):
-                logger.info("재확정 체인: 초기값 스냅샷 무효화 (project_id=%s)", project_id)
-        if not latest:
-            logger.info(
-                "재확정 체인 → 기존 경로 없음, 신규 자동 체인으로: project_id=%s", project_id
-            )
-            await run_auto_design_chain(project_id, surface_model_id=surface_model_id)
-            return
-
-        # 1) 사용자 입력 회수 — 마지막 경로 계산의 stage 2 params가 정본이다.
-        old_route_id = int(latest["id"])
-        async with pool.acquire() as connection:
-            import aiomysql
-
-            async with connection.cursor(aiomysql.DictCursor) as cursor:
-                state = await get_workflow_state(cursor, str(project_id))
-            old_longitudinal = await get_longitudinal_section(connection, project_id, old_route_id)
-            old_designs = await get_cross_section_designs(connection, old_route_id)
-            old_section_options = await get_latest_section_options(connection, project_id)
-        stage2 = next(
-            (s for s in (state or {}).get("stages", []) if int(s.get("stage_no", -1)) == 2), None
-        )
-        params = (stage2 or {}).get("params") or {}
-        points = params.get("points") or {}
-        if not points.get("bp") or not points.get("ep"):
-            logger.warning(
-                "재확정 체인 중단(stage 2 params에 제어점 없음): project_id=%s", project_id
-            )
-            return "노선 제어점(BP·EP)이 없어 재계산할 수 없습니다."
-
-        marks.append(("준비·사용자입력 회수", time.perf_counter()))
-
-        # 2) B05 재계산 — 지표면 관련 값만 새 확정 선택으로 교체, 나머지는 사용자 저장분.
-        request = redesign_solve_request(params, selection, surface_model_id)
-        # 종횡단은 관을 정한 뒤 한 번만 만든다(342-2) — 여기서 만들면 아래 4c 가 통째로 덮는 헛일.
-        solve_result: Any = await solve_route_record(project_id, request, generate_sections=False)
-        if isinstance(solve_result, JSONResponse):
-            # 사유까지 남긴다 — 상태 코드만으로는 무엇이 막았는지 못 짚는다(2026-09-06
-            # 노선 편집 [확인]이 조용히 400 으로 끊겨 종횡단만 옛 노선에 남았음).
-            try:
-                reason = bytes(solve_result.body).decode("utf-8", "replace")[:300]
-            except Exception:  # noqa: BLE001 — 로그용이라 실패해도 흐름을 막지 않는다
-                reason = "(본문 없음)"
-            logger.error(
-                "재확정 체인 중단(B05 재계산 실패): project_id=%s status=%s reason=%s",
-                project_id,
-                solve_result.status_code,
-                reason,
-            )
-            return f"노선 재계산 실패({solve_result.status_code}): {reason}"
-        new_route_id = int(solve_result.route_id)
-        marks.append(("노선 재계산(solve)", time.perf_counter()))
-        logger.info(
-            "재확정 체인 B05 재계산 완료: project_id=%s %s→%s",
-            project_id,
-            old_route_id,
-            new_route_id,
-        )
-
-        # 3) 옛 측점별 사용자 설계 이월은 **측점을 다시 만든 뒤**(아래 5) 한다.
-        #    여기서 하면 `_prepare_drainage_pipes_and_reprofile(refresh=True)` 가 측점을
-        #    새로 만들며 덮어써 값이 사라진다(2026-09-06 실측: 다단 구간값 `extra_spans` 가
-        #    노선 변경 뒤 0건이 됐음). 옛 설계는 `old_designs` 로 이미 손에 있다.
-        carried = 0
-
-        # 4) B05 확정 → B06 확정(옛 표준단면 설정 이월, 미지정 측점 기본값 채움).
-        #    재확정 후에도 stage 2·3은 IN_PROGRESS로 남겨 사용자 재검토를 받는다.
-        confirm_result = await confirm_latest_route(project_id, None, mark_stage_complete=False)
-        if isinstance(confirm_result, JSONResponse):
-            logger.error(
-                "재확정 체인 중단(B05 확정 실패): project_id=%s status=%s",
-                project_id,
-                confirm_result.status_code,
-            )
-            return f"노선 확정 실패({confirm_result.status_code})"
-        marks.append(("B05 확정", time.perf_counter()))
-        # 노선이 바뀌었으므로 배수유역·관 지점도 새 노선 기준으로 다시 만든다 — 옛 관 자리로
-        # 계획선을 앉히면 전부 어긋나고, 저장분은 노선 변경을 스스로 알지 못한다.
-        # 건너뛴 첫 생성이 남겼을 옵션(요청 → 옛 저장 → 기본) — 재생성이 그것을 읽어 결과가 같다.
-        seed = asdict(_section_options(request, old_section_options))
-        seed.pop("extra_stations", None)
-        piped = await _prepare_drainage_pipes_and_reprofile(
-            project_id, new_route_id, refresh=True, stored_options=seed
-        )
-        if not piped:
-            # 관 없이라도 종횡단은 세운다 — 새 노선엔 아직 종횡단이 없다(첫 생성을 건너뜀).
-            await regenerate_route_sections(
-                project_id, new_route_id, float(seed["cross_half_width_m"]), stored_options=seed
-            )
-
-        marks.append(("배수·관·측점 재생성", time.perf_counter()))
-
-        if profile_target is not None:
-            from B05_Profile.B05_Profile_Router_RouteInitial import apply_profile_target
-
-            await apply_profile_target(project_id, new_route_id, profile_target)
-            marks.append(("균형 종단 반영", time.perf_counter()))
-
-        old_options = ((old_longitudinal or {}).get("data") or {}).get("options") or {}
-        standard = old_options.get("standard_cross_section") or None
-
-        # 5) 이제 측점이 새 노선 기준으로 다 섰다 — 옛 사용자 **입력**만 누가거리로 얹고 전 측점을
-        #    새 계획고로 다시 셈한다(PLAN 74-3). 결과 칸(계획고 · 면적 · design_line …)을 통째
-        #    옮기면 옛 노선 단면이 새 노선에 남아 누가토량이 두 배가 됐다(74-1). 새 노선에 없는
-        #    누가거리는 행을 만들지 않는다.
-        try:
-            inputs = {
-                round(float(record["chainage_m"]), 3): {
-                    key: record["design"][key]
-                    for key in CARRY_INPUT_KEYS
-                    if record["design"].get(key) is not None
-                }
-                for record in old_designs
-                if isinstance(record.get("design"), dict)
-            }
-            async with pool.acquire() as connection:
-                new_longitudinal = await get_longitudinal_section(
-                    connection, project_id, new_route_id
-                )
-            long_path = str((new_longitudinal or {}).get("longitudinal_file_path") or "")
-            chainages = await asyncio.to_thread(
-                _rowless_station_chainages, project_root, long_path, []
-            )
-            entries = await asyncio.to_thread(
-                compute_default_designs, project_root, long_path, chainages, standard, inputs
-            )
-            async with pool.acquire() as connection:
-                await connection.begin()
-                try:
-                    carried = await merge_cross_section_designs(
-                        connection,
-                        route_id=new_route_id,
-                        entries=entries,
-                        replace=True,
-                        project_id=project_id,
-                    )
-                    await connection.commit()
-                except Exception:
-                    await connection.rollback()
-                    raise
-        except Exception:
-            logger.exception(
-                "재확정 체인 — 옛 설계 이월 실패(계속 진행): project_id=%s", project_id
-            )
-        logger.info("재확정 체인 설계 이월: project_id=%s %d건", project_id, carried)
-
-        marks.append(("설계 이월", time.perf_counter()))
-
-        section_request = (
-            SectionConfirmRequest(standard_cross_section=standard) if standard else None
-        )
-        sections_result = await confirm_sections(
-            project_id, new_route_id, section_request, mark_stage_complete=False
-        )
-        if isinstance(sections_result, JSONResponse):
-            logger.error(
-                "재확정 체인 중단(B06 확정 실패): project_id=%s status=%s",
-                project_id,
-                sections_result.status_code,
-            )
-            return f"종횡단 확정 실패({sections_result.status_code})"
-        marks.append(("B06 확정(서버 재계산 포함)", time.perf_counter()))
-        _log_steps("재확정 체인", marks)
-        # 지형이 바뀌면 추천 키도 바뀜 — 첫 누름이 저장본이게 미리 셈(351-1)
-        from B05_Profile.B05_Profile_Router_RouteInitial import schedule_precompute
-
-        schedule_precompute(project_id)
-        logger.info(
-            "재확정 체인 완료: project_id=%s route %s→%s (설계 %d건 이월)",
-            project_id,
-            old_route_id,
-            new_route_id,
-            carried,
-        )
-        return None
-    except Exception as exc:
-        logger.exception("재확정 체인 실패: project_id=%s", project_id)
-        return f"재계산 중 오류: {exc}"
-    finally:
-        if project_root is not None:
-            clear_designing(project_root)

B03_FileInput/B03_FileInput_Service_SurfaceChange.py

@@ -0,0 +1,49 @@
+"""서피스가 바뀐 뒤 전처리 체인 다시(763-3 · 요구 605) — 업로드와 같은 길 하나.
+
+부르는 곳 = B04 다른 서피스 [확정] · B05 LAS 나중 올리기 뒤 전처리 다시(765-5). B05~B09 초기화 =
+같은 지형 재업로드 길(`purge_project_outputs(keep_preprocess=True)` · 설계 벌 묶음까지 · 단계 2 이후
+처음 · 초기값 스냅샷 버림) → `run_preprocess_chain`(지형마다 한 벌 · 끝에 추천 미리 셈 ·
+실패 길에도). 전처리 결과(B04) · 확정은 그대로.
+"""
+
+import asyncio
+import logging
+from pathlib import Path
+from uuid import UUID
+
+logger = logging.getLogger(__name__)
+
+
+async def run_surface_change_chain(project_id: UUID, surface_model_id: int | None) -> None:
+    """B05~B09 를 지우고 자동 설계 체인을 새 확정 서피스로 다시 탐 — 실패는 로그만."""
+    from B03_FileInput.B03_FileInput_Repository import get_project_storage_relative_path
+    from B03_FileInput.B03_FileInput_Service_Chain import run_preprocess_chain
+    from B05_Profile.B05_Profile_Router_RouteInitial import schedule_precompute
+    from common_util.common_util_initial_snapshot import discard_initial_snapshot
+    from common_util.common_util_project_reset import purge_project_outputs
+    from common_util.common_util_storage import resolve_stored_project_path
+    from common_util.common_util_workflow_state import reset_stages_after_input_change
+    from config.config_db import get_db_pool
+
+    try:
+        async with get_db_pool().acquire() as connection:
+            stored_path = await get_project_storage_relative_path(connection, project_id)
+            if not stored_path:
+                return
+            root = Path(resolve_stored_project_path(stored_path))
+            await asyncio.to_thread(discard_initial_snapshot, root)
+            await connection.begin()
+            try:
+                await purge_project_outputs(connection, str(project_id), root, keep_preprocess=True)
+                async with connection.cursor() as cursor:
+                    await reset_stages_after_input_change(cursor, str(project_id), 2)
+                await connection.commit()
+            except Exception:
+                await connection.rollback()
+                raise
+    except Exception:  # noqa: BLE001 — 체인은 응답 뒤 · 추천은 새 서피스로 셈
+        logger.exception("서피스 바꿈 체인 — B05~B09 초기화 실패: project_id=%s", project_id)
+        schedule_precompute(project_id)
+        return
+    logger.info("서피스 바꿈 체인 — B05~B09 초기화 뒤 자동 설계: project_id=%s", project_id)
+    await run_preprocess_chain(project_id, surface_model_id)

B03_FileInput/B03_FileInput_Service_WF1.py

@@ -24,6 +24,7 @@ from config.config_system import (
     SEND_ANALYSIS_COMPLETION_EMAIL,
     SHEET_SURFACE_DEFAULT_METHOD,
     SURFACE_AUTO_METHODS,
+    SURFACE_CONFIRM_DEFAULT_METHOD,
     SURFACE_CONTOUR_INTERVAL_M,
 )
 
@@ -65,9 +66,10 @@ async def trigger_wf1_analysis_and_email(
     project_info: dict[str, Any] | None = None
     try:
         # 자동 전처리는 기본 조합만 만든다 — 필터는 엔진이 입력 LAS를 보고 정하고
-        # (분류 있으면 classification, 없으면 csf), 표현은 SURFACE_AUTO_METHODS.
+        # (분류 있으면 업체 분류, 없으면 점진 TIN · 둘 다 다듬기 판), 표현은 SURFACE_AUTO_METHODS.
         # 다른 조합은 관리자가 B04 드롭다운에서 요청할 때 만든다 (2026-09-01 사용자 확정).
-        methods = list(SURFACE_AUTO_METHODS)
+        # 확정 표현(implicit)도 함께 지음 — 엔진이 기본 필터에만 지음(요구 558).
+        methods = list(dict.fromkeys([*SURFACE_AUTO_METHODS, SURFACE_CONFIRM_DEFAULT_METHOD]))
         params = {
             "input_file_id": str(input_file_id),
             "source_filters": None,
@@ -176,10 +178,10 @@ async def trigger_wf1_analysis_and_email(
                 else:
                     # 자동 확정은 엔진이 정한 기본 필터를 그대로 따른다 — 이제 그 필터
                     # 하나만 만들어 두므로 config 기본값과 어긋나면 확정할 모델이 없다.
+                    # 표현 · 평활은 config 확정 기본값(implicit · 평활 끔 — 요구 558).
                     selection = surface_confirmation_defaults()
                     if resolved_filters:
                         selection["source_filter"] = resolved_filters[0]
-                    selection["method"] = methods[0]
                 try:
                     model_id = await find_surface_model_for_selection(
                         connection, project_id, selection
@@ -215,11 +217,10 @@ async def trigger_wf1_analysis_and_email(
         # 횡단 설계 체인을 잇는다(2026-08-04 사용자 확정). 체인은 실패를 스스로 격리한다.
         design_summary: dict[str, Any] | None = None
         if auto_confirmed and AUTO_DESIGN_CHAIN_ENABLED:
-            from B03_FileInput.B03_FileInput_Service_Chain import run_auto_design_chain
+            from B03_FileInput.B03_FileInput_Service_Chain import run_preprocess_chain
 
-            design_summary = await run_auto_design_chain(
-                project_id, surface_model_id=confirmed_model_id
-            )
+            # 지형마다 설계 한 벌(765-3) — 다른 지형 벌은 묶음 · 요약은 설계 지형 벌
+            design_summary = await run_preprocess_chain(project_id, confirmed_model_id)
 
         # 알림 메일은 여기 한 통뿐이다 — 업로드 직후와 분석 직후로 나눠 두 통을 보내던 것을
         # 초기 설계(B04~B06)까지 마친 시점의 통합 메일로 합쳤다(2026-08-08 사용자 지시).

B04_PreProcess/B04_PreProcess_Api_Fetch.ts

@@ -97,12 +97,6 @@ export interface SurfacePointCloudSampleResponse {
   rgb?: [number, number, number][];
 }
 
-export interface SurfaceGroundStatsResponse {
-  status: string;
-  project_id: string;
-  filters: Record<string, Record<string, unknown>>;
-}
-
 export interface SurfaceStatusResponse {
   project_id: string;
   status: "pending" | "in_progress" | "completed" | "failed";
@@ -298,14 +292,6 @@ export async function fetchConfirmedSurface(projectId: string): Promise<SurfaceC
   });
 }
 
-export async function fetchSurfaceGroundStats(
-  projectId: string,
-): Promise<SurfaceGroundStatsResponse> {
-  return requestJson<SurfaceGroundStatsResponse>(`/projects/${projectId}/surface/ground-stats`, {
-    method: "GET",
-  });
-}
-
 export async function fetchSurfaceStatus(projectId: string): Promise<SurfaceStatusResponse> {
   return requestJson<SurfaceStatusResponse>(`/projects/${projectId}/surface/status`, {
     method: "GET",

B04_PreProcess/B04_PreProcess_Engine.py

@@ -14,11 +14,14 @@ from typing import Any
 import numpy as np
 
 from B04_PreProcess.B04_PreProcess_Engine_Ground import (
+    available_filters,
+    base_filter,
     build_ground_masks,
     resolve_auto_source_filters,
     run_ground_filter,
     summarize_masks,
 )
+from B04_PreProcess.B04_PreProcess_Engine_ModelBuild import BUILDERS
 from B04_PreProcess.B04_PreProcess_Engine_Pipeline import build_all_terrain_models
 from B04_PreProcess.B04_PreProcess_Engine_Structurize import structurize_las
 from common_util.common_util_atomic import atomic_write_npz
@@ -197,9 +200,12 @@ def run_surface_analysis(
     methods: list[str],
     force: bool = False,
     on_progress: ProgressCallback | None = None,
+    maps: bool = True,
 ) -> dict[str, Any]:
     """구조화→필터→모델 빌드를 수행하고 산출 메타데이터를 반환한다.
 
+    `maps=False` = 지도 · GIS 받기와 도엽 서피스를 건너뜀(D 라이다 · PLAN 624-4).
+
     `las_path`는 지형 파일 한 장 또는 여러 장이다 — 여러 장이면 합친 범위로 한 벌을
     만든다(2026-09-06 사용자 확정).
 
@@ -276,27 +282,36 @@ def run_surface_analysis(
         _report(40, "ground_filter", "지면 필터 적용 중")
         # 자동 전처리는 목록을 넘기지 않는다 — 기본 필터는 입력 LAS를 보고 여기서 정한다.
         if not source_filters:
-            source_filters = resolve_auto_source_filters(data)
+            source_filters = resolve_auto_source_filters(data, processed_dir)
             logger.info("B04 자동 전처리 기본 필터: %s", ", ".join(source_filters))
         masks: dict[str, np.ndarray] = {}
-        for filter_key in source_filters:
+
+        def _mask_for(filter_key: str) -> np.ndarray:
             mask_path = processed_dir / f"mask_{filter_key}.npy"
-            mask: np.ndarray | None = None
             if not rebuild and mask_path.is_file():
                 stored_mask = np.load(mask_path)
                 if len(stored_mask) == total_points:
-                    mask = np.asarray(stored_mask, dtype=bool)
                     logger.info("B04 지면 필터 캐시 재사용: %s", mask_path.name)
-            if mask is None:
-                step_started = time.monotonic()
-                mask = np.asarray(run_ground_filter(filter_key, data), dtype=bool)
-                np.save(mask_path, mask)
-                logger.info(
-                    "B04 지면 필터 계산 완료: %s (%.1fs)",
-                    filter_key,
-                    time.monotonic() - step_started,
-                )
-            masks[filter_key] = mask
+                    return np.asarray(stored_mask, dtype=bool)
+            # 다듬기 판(762)은 바탕 필터 마스크(저장본)를 다듬음 — 점진 TIN 을 두 번 돌리지 않음
+            base = base_filter(filter_key)
+            base_mask = (masks.get(base) if base in masks else _mask_for(base)) if base else None
+            step_started = time.monotonic()
+            mask = np.asarray(run_ground_filter(filter_key, data, base_mask), dtype=bool)
+            np.save(mask_path, mask)
+            logger.info(
+                "B04 지면 필터 계산 완료: %s (%.1fs)",
+                filter_key,
+                time.monotonic() - step_started,
+            )
+            return mask
+
+        for filter_key in source_filters:
+            masks[filter_key] = _mask_for(filter_key)
+        # 다듬기 판의 바탕 마스크 — 모델 외곽용(766-2) · 지면점 저장본은 안 지음
+        outer_masks = {
+            b: _mask_for(b) for k in source_filters if (b := base_filter(k)) not in (None, *masks)
+        }
         ground_summary = summarize_masks(data, masks)
         # 지면점 비율은 필터가 조용히 실패해도 유일하게 드러나는 신호다 — 반드시 남긴다.
         for filter_key, entry in ground_summary.items():
@@ -340,7 +355,12 @@ def run_surface_analysis(
             _report(70 + int(percent * 0.2), "surface_model", detail)
 
         manifest = build_all_terrain_models(
-            data, masks, models_dir, config, force=rebuild, progress=_model_progress
+            data,
+            {**outer_masks, **masks},
+            models_dir,
+            config,
+            force=rebuild,
+            progress=_model_progress,
         )
         logger.info(
             "B04 지표면 모델 빌드 완료: status=%s (%.1fs)",
@@ -349,31 +369,38 @@ def run_surface_analysis(
         )
 
     # 3-2·3-3. VWorld 지도·국가 GIS 벡터·수치지형도 도엽 (공용 블록 — 도엽 서피스도 사용)
-    _report(90, "download_maps", "VWorld 지도 및 GIS 벡터 데이터 다운로드 중")
     las_bounds_dict = {
         "x": [float(bounds[0, 0]), float(bounds[0, 1])],
         "y": [float(bounds[1, 0]), float(bounds[1, 1])],
         "z": [float(bounds[2, 0]), float(bounds[2, 1])],
     }
-    download_geodata(
-        project_root, processed_dir, las_bounds_dict, las_paths[0].parent, rebuild, report=_report
-    )
+    if maps:
+        _report(90, "download_maps", "VWorld 지도 및 GIS 벡터 데이터 다운로드 중")
+        download_geodata(
+            project_root,
+            processed_dir,
+            las_bounds_dict,
+            las_paths[0].parent,
+            rebuild,
+            report=_report,
+        )
 
     # 3-4. 도엽등고선 3D 서피스 — LAS가 있어도 참고용으로 같이 만들어 영구저장한다
     # (2026-08-30 사용자 확정). 실패해도 분석은 계속한다.
-    _report(94, "surface_model", "도엽등고선 3D 서피스 생성 중")
     sheet_models: list[dict[str, Any]] = []
-    try:
-        from B04_PreProcess.B04_PreProcess_Engine_SheetSurface import (
-            build_sheet_surface_from_route,
-        )
+    if maps:
+        _report(94, "surface_model", "도엽등고선 3D 서피스 생성 중")
+        try:
+            from B04_PreProcess.B04_PreProcess_Engine_SheetSurface import (
+                build_sheet_surface_from_route,
+            )
 
-        # 자동 전처리는 기본 방식 하나만 만든다 — 나머지는 관리자가 화면에서 고를 때.
-        sheet_models = build_sheet_surface_from_route(
-            project_root, processed_dir, models_dir, list(SHEET_SURFACE_AUTO_METHODS)
-        )
-    except Exception as exc:
-        logger.warning("도엽등고선 서피스 생성 실패: %s", exc)
+            # 자동 전처리는 기본 방식 하나만 만든다 — 나머지는 관리자가 화면에서 고를 때.
+            sheet_models = build_sheet_surface_from_route(
+                project_root, processed_dir, models_dir, list(SHEET_SURFACE_AUTO_METHODS)
+            )
+        except Exception as exc:
+            logger.warning("도엽등고선 서피스 생성 실패: %s", exc)
 
     _report(95, "saving", "결과 저장 중")
 
@@ -583,8 +610,10 @@ def _collect_analysis_result(
     # manifest에서 저장된 모델별 정보 추출 (필터별 대표 모델)
     models: list[dict[str, Any]] = []
     for filter_key, filter_entry in manifest.get("source_filters", {}).items():
+        if filter_key not in available_filters():
+            continue  # 지운 갈래(608 · csf 등) 옛 줄은 DB 로 되살리지 않음
         for method, meta in filter_entry.get("methods", {}).items():
-            if meta.get("status") != "completed":
+            if meta.get("status") != "completed" or method not in BUILDERS:
                 continue
             model_file = meta.get("model_file")
             model_path = (models_dir / model_file) if model_file else None
@@ -593,11 +622,11 @@ def _collect_analysis_result(
                 layers.append(
                     {
                         "layer_name": f"{method}_{filter_key}_preview",
-                        "geometry_type": "MESH" if method != "meshfree" else "POINTCLOUD",
+                        "geometry_type": "MESH",
                         "file_path": _relative_to_project(
                             project_root, models_dir / meta["preview_file"]
                         ),
-                        "file_format": "glb" if method != "meshfree" else "ply",
+                        "file_format": "glb",
                     }
                 )
             models.append(

B04_PreProcess/B04_PreProcess_Engine_Contour.py

@@ -1,16 +1,13 @@
 """B04 등고선 추출 엔진.
 
-5종 표현(regular_grid/triangular_mesh/bspline_surface/local_rbf_height_field/
-meshfree_surfels)의 npz 모델에서 표고 격자를 환원하고, marching squares로
-지정 간격 등고선 라인을 추출한다. DTM valid_mask를 footprint로 사용해
-경계 누출을 차단한다.
+표현(regular_grid · local_rbf_height_field 굳힌 격자)의 표고 격자에서 marching
+squares로 지정 간격 등고선 라인을 추출한다. 격자 valid_mask가 경계 누출을 막는다.
 """
 
 from pathlib import Path
 from typing import Any
 
 import numpy as np
-from scipy.interpolate import RBFInterpolator
 from skimage import measure
 
 # 등고선 캐시 형식/추출 규칙이 바뀔 때 증가시킨다.
@@ -122,231 +119,21 @@ def extract_contours_from_grid(
     return contours_geojson_list
 
 
-def _load_footprint_mask(
-    model_npz_path: Path, x_coords: np.ndarray, y_coords: np.ndarray
-) -> np.ndarray | None:
-    """같은 source filter의 DTM valid_mask를 현재 격자에 최근접 리샘플한다."""
-    stem = Path(model_npz_path).stem
-    if stem.endswith("_smooth"):
-        stem = stem[:-7]
-    parts = stem.split("_", 1)
-    if len(parts) < 2:
-        return None
-    filter_key = parts[1]
-    dtm_path = Path(model_npz_path).parent / f"dtm_{filter_key}.npz"
-    if not dtm_path.exists():
-        return None
-    try:
-        d = np.load(dtm_path)
-        dtm_x = np.asarray(d["x"]).ravel()
-        dtm_y = np.asarray(d["y"]).ravel()
-        dtm_mask = np.asarray(d["valid_mask"], dtype=bool)
-    except Exception:
-        return None
-    if len(dtm_x) < 2 or len(dtm_y) < 2:
-        return None
+def contour_cache_is_stale(contour_path: Path, model_path: Path) -> bool:
+    """등고선 캐시가 없거나 그 면을 낳은 파일보다 옛것이면 True(754-1).
 
-    def _nearest_idx(axis: np.ndarray, coords: np.ndarray) -> np.ndarray:
-        ascending = bool(axis[0] <= axis[-1])
-        a = axis if ascending else axis[::-1]
-        idx = np.clip(np.searchsorted(a, coords), 1, len(a) - 1)
-        idx = np.where(np.abs(a[idx - 1] - coords) <= np.abs(a[idx] - coords), idx - 1, idx)
-        return idx if ascending else (len(axis) - 1 - idx)
-
-    xi = _nearest_idx(dtm_x, np.asarray(x_coords, dtype=np.float64))
-    yi = _nearest_idx(dtm_y, np.asarray(y_coords, dtype=np.float64))
-    return dtm_mask[np.ix_(yi, xi)]
-
-
-def _apply_footprint(
-    model_npz_path: Path, x_coords: np.ndarray, y_coords: np.ndarray, valid_mask: np.ndarray
-) -> np.ndarray:
-    """valid_mask에 DTM footprint를 교집합으로 적용한다 (형상 다르면 최근접 리샘플)."""
-    fp = _load_footprint_mask(model_npz_path, x_coords, y_coords)
-    if fp is not None:
-        if fp.shape == valid_mask.shape:
-            return valid_mask & fp
-        from scipy.ndimage import zoom
-
-        zoom_y = valid_mask.shape[0] / fp.shape[0]
-        zoom_x = valid_mask.shape[1] / fp.shape[1]
-        fp_resized = zoom(fp.astype(float), (zoom_y, zoom_x), order=0) > 0.5
-        if fp_resized.shape == valid_mask.shape:
-            return valid_mask & fp_resized
-    return valid_mask
-
-
-def _tin_face_coverage_mask(
-    vertices: np.ndarray, faces: np.ndarray, xx: np.ndarray, yy: np.ndarray
-) -> np.ndarray:
-    """저장된 TIN 면이 실제로 덮는 XY 영역만 True로 반환한다."""
-    vertices = np.asarray(vertices)
-    faces = np.asarray(faces, dtype=np.int64)
-    if vertices.ndim != 2 or vertices.shape[1] < 2 or not len(faces):
-        return np.zeros(xx.shape, dtype=bool)
-
-    edges = np.vstack((faces[:, [0, 1]], faces[:, [1, 2]], faces[:, [2, 0]]))
-    edges = np.sort(edges, axis=1)
-    unique_edges, counts = np.unique(edges, axis=0, return_counts=True)
-    boundary_edges = unique_edges[counts == 1]
-    if not len(boundary_edges):
-        return np.zeros(xx.shape, dtype=bool)
-
-    import affine
-    import rasterio.features
-    from shapely import get_parts, linestrings, polygonize
-
-    boundary_lines = linestrings(vertices[boundary_edges, :2])
-    polygons = list(get_parts(polygonize(boundary_lines)))
-    if not polygons:
-        return np.zeros(xx.shape, dtype=bool)
-
-    x_coords = xx[0, :]
-    y_coords = yy[:, 0]
-    dx = float(x_coords[1] - x_coords[0]) if len(x_coords) > 1 else 1.0
-    dy = float(y_coords[1] - y_coords[0]) if len(y_coords) > 1 else 1.0
-
-    transform = affine.Affine(dx, 0.0, x_coords[0] - dx / 2.0, 0.0, dy, y_coords[0] - dy / 2.0)
-
-    mask = rasterio.features.rasterize(
-        polygons, out_shape=xx.shape, transform=transform, fill=0, default_value=1, dtype="uint8"
-    )
-    return mask.astype(bool)
-
-
-def _grid_axes(x_min: float, x_max: float, y_min: float, y_max: float, target_grid_m: float):
-    cols = max(2, int(np.ceil((x_max - x_min) / target_grid_m)) + 1)
-    rows = max(2, int(np.ceil((y_max - y_min) / target_grid_m)) + 1)
-    x_coords = np.linspace(x_min, x_max, cols, dtype=np.float32)
-    y_coords = np.linspace(y_min, y_max, rows, dtype=np.float32)
-    return x_coords, y_coords
-
-
-# 후보 셀 배열이 한 번에 커지지 않도록 삼각형을 나눠 처리하는 단위.
-_RASTER_CHUNK = 200_000
-# 격자점이 변 위에 놓였을 때 양쪽 삼각형 모두에서 탈락하지 않도록 두는 여유.
-_BARYCENTRIC_EPS = 1e-9
-
-
-def rasterize_triangle_mesh(
-    vertices: np.ndarray,
-    triangles: np.ndarray,
-    x_coords: np.ndarray,
-    y_coords: np.ndarray,
-) -> np.ndarray:
-    """삼각망을 규칙격자에 직접 래스터화해 표고 격자를 만든다.
-
-    삼각형마다 자기가 덮는 격자 셀만 무게중심 선형보간으로 채우므로, 질의점별
-    위치탐색(scipy `find_simplex`)이 사라진다. 삼각망 밖 셀은 NaN으로 남아
-    기존 `griddata` 결과와 같은 유효 판정을 유지한다.
+    낳은 파일 = 모델 npz · 같은 필터 `dtm_{필터}.npz`(외곽 자르기) · implicit 굳힌 격자.
     """
-    rows, cols = len(y_coords), len(x_coords)
-    z_grid = np.full((rows, cols), np.nan, dtype=np.float64)
-    vertices = np.asarray(vertices, dtype=np.float64)
-    triangles = np.asarray(triangles, dtype=np.int64)
-    if not len(triangles) or vertices.ndim != 2 or vertices.shape[1] < 3:
-        return z_grid
-
-    axis_x = np.asarray(x_coords, dtype=np.float64)
-    axis_y = np.asarray(y_coords, dtype=np.float64)
-
-    def _index_range(axis: np.ndarray, low: np.ndarray, high: np.ndarray, size: int):
-        """축 배열을 직접 탐색해 [low, high]를 덮는 인덱스 구간을 낸다.
-
-        `(좌표 - 원점) / 간격` 식은 쓰지 않는다. `_grid_axes`가 float32 축을 만드는데
-        UTM 좌표(18만대)에서 float32 해상도가 0.015625m라 격자 간격이 0.984~1.0으로
-        흔들리고, 등간격으로 환산하면 최대 0.81셀까지 어긋난다. 삼각형이 평균 0.3m라
-        그만큼 어긋나면 격자점을 통째로 놓친다 (2026-08-17 실측).
-        """
-        ascending = size < 2 or axis[-1] >= axis[0]
-        sorted_axis = axis if ascending else axis[::-1]
-        lo = np.searchsorted(sorted_axis, low, side="left")
-        hi = np.searchsorted(sorted_axis, high, side="right") - 1
-        if ascending:
-            return lo, hi
-        return size - 1 - hi, size - 1 - lo
-
-    for begin in range(0, len(triangles), _RASTER_CHUNK):
-        chunk = triangles[begin : begin + _RASTER_CHUNK]
-        corners = vertices[chunk]
-        ax, ay, az = corners[:, 0, 0], corners[:, 0, 1], corners[:, 0, 2]
-        bx, by, bz = corners[:, 1, 0], corners[:, 1, 1], corners[:, 1, 2]
-        cx, cy, cz = corners[:, 2, 0], corners[:, 2, 1], corners[:, 2, 2]
-
-        denom = (by - cy) * (ax - cx) + (cx - bx) * (ay - cy)
-        col_lo, col_hi = _index_range(
-            axis_x, np.minimum(np.minimum(ax, bx), cx), np.maximum(np.maximum(ax, bx), cx), cols
-        )
-        row_lo, row_hi = _index_range(
-            axis_y, np.minimum(np.minimum(ay, by), cy), np.maximum(np.maximum(ay, by), cy), rows
-        )
-
-        # 클립 전에 격자 밖 삼각형을 걸러야 경계에 눌러붙지 않는다.
-        selected = (
-            np.isfinite(denom)
-            & (np.abs(denom) > 1e-12)
-            & (col_hi >= col_lo)
-            & (row_hi >= row_lo)
-            & (col_hi >= 0)
-            & (row_hi >= 0)
-            & (col_lo <= cols - 1)
-            & (row_lo <= rows - 1)
-        )
-        if not selected.any():
-            continue
-
-        col_lo = np.clip(col_lo[selected], 0, cols - 1).astype(np.int64)
-        col_hi = np.clip(col_hi[selected], 0, cols - 1).astype(np.int64)
-        row_lo = np.clip(row_lo[selected], 0, rows - 1).astype(np.int64)
-        row_hi = np.clip(row_hi[selected], 0, rows - 1).astype(np.int64)
-        width = col_hi - col_lo + 1
-        counts = width * (row_hi - row_lo + 1)
-        total = int(counts.sum())
-        if total <= 0:
-            continue
-
-        # 삼각형별 후보 셀 수가 제각각이라 반복 인덱스를 펼쳐서 한 번에 계산한다.
-        starts = np.concatenate(([0], np.cumsum(counts)[:-1]))
-        local = np.arange(total, dtype=np.int64) - np.repeat(starts, counts)
-        width_rep = np.repeat(width, counts)
-        offset_row = local // width_rep
-        cell_row = np.repeat(row_lo, counts) + offset_row
-        cell_col = np.repeat(col_lo, counts) + (local - offset_row * width_rep)
-
-        point_x = axis_x[cell_col]
-        point_y = axis_y[cell_row]
-        ax_r, ay_r, az_r = (
-            np.repeat(ax[selected], counts),
-            np.repeat(ay[selected], counts),
-            np.repeat(az[selected], counts),
-        )
-        bx_r, by_r, bz_r = (
-            np.repeat(bx[selected], counts),
-            np.repeat(by[selected], counts),
-            np.repeat(bz[selected], counts),
-        )
-        cx_r, cy_r, cz_r = (
-            np.repeat(cx[selected], counts),
-            np.repeat(cy[selected], counts),
-            np.repeat(cz[selected], counts),
-        )
-        denom_r = np.repeat(denom[selected], counts)
-
-        weight_a = ((by_r - cy_r) * (point_x - cx_r) + (cx_r - bx_r) * (point_y - cy_r)) / denom_r
-        weight_b = ((cy_r - ay_r) * (point_x - cx_r) + (ax_r - cx_r) * (point_y - cy_r)) / denom_r
-        weight_c = 1.0 - weight_a - weight_b
-        hit = (
-            (weight_a >= -_BARYCENTRIC_EPS)
-            & (weight_b >= -_BARYCENTRIC_EPS)
-            & (weight_c >= -_BARYCENTRIC_EPS)
-        )
-        if not hit.any():
-            continue
-        z_grid[cell_row[hit], cell_col[hit]] = (
-            weight_a[hit] * az_r[hit] + weight_b[hit] * bz_r[hit] + weight_c[hit] * cz_r[hit]
-        )
-
-    return z_grid
+    stem = Path(model_path).stem.removesuffix("_smooth")
+    folder = Path(model_path).parent
+    sources = [Path(model_path), folder / f"dtm_{stem.split('_', 1)[-1]}.npz"]
+    if stem.startswith("implicit_"):
+        sources.append(folder / f"{stem}_grid.npz")
+    try:
+        built = Path(contour_path).stat().st_mtime_ns
+    except OSError:
+        return True
+    return any(path.is_file() and path.stat().st_mtime_ns > built for path in sources)
 
 
 def extract_contours(
@@ -360,7 +147,21 @@ def extract_contours(
     model_npz_path = Path(model_npz_path)
     if not model_npz_path.exists():
         raise FileNotFoundError(f"모델 파일이 존재하지 않습니다: {model_npz_path}")
-    data = np.load(model_npz_path)
+    # 실패해도 모델 파일을 닫음 — 열린 채 남으면 Windows 에서 다시 짓기(교체)가 막힘(754-1)
+    with np.load(model_npz_path) as data:
+        return _extract_loaded(
+            data, model_npz_path, representation, interval, target_grid_m, scene_center
+        )
+
+
+def _extract_loaded(
+    data: Any,
+    model_npz_path: Path,
+    representation: str,
+    interval: float,
+    target_grid_m: float,
+    scene_center: tuple[float, float, float] | None,
+) -> list[dict[str, Any]]:
 
     if representation == "regular_grid":
         x_coords, y_coords, z_grid, valid_mask = (
@@ -384,88 +185,19 @@ def extract_contours(
             x_coords, y_coords, z_grid, valid_mask, interval, scene_center=scene_center
         )
 
-    if representation == "triangular_mesh":
-        vertices, faces = data["vertices"], data["faces"]
-        x_min, x_max = float(np.min(vertices[:, 0])), float(np.max(vertices[:, 0]))
-        y_min, y_max = float(np.min(vertices[:, 1])), float(np.max(vertices[:, 1]))
-        x_coords, y_coords = _grid_axes(x_min, x_max, y_min, y_max, target_grid_m)
-        xx, yy = np.meshgrid(x_coords, y_coords)
-        # 저장된 faces를 그대로 쓴다 — griddata는 정점을 다시 삼각분할하느라 긴 변
-        # 제거·외곽 클리핑이 반영되지 않은 면까지 되살렸다 (PLAN 2026-08-17).
-        z_grid = rasterize_triangle_mesh(vertices, faces, x_coords, y_coords)
-        face_mask = _tin_face_coverage_mask(vertices, faces, xx, yy)
-        valid_mask = np.isfinite(z_grid) & face_mask
-        valid_mask = _apply_footprint(model_npz_path, x_coords, y_coords, valid_mask)
-        return extract_contours_from_grid(
-            x_coords, y_coords, z_grid, valid_mask, interval, scene_center=scene_center
-        )
-
-    if representation == "bspline_surface":
-        # 모델 빌더와 같은 곡면을 다시 만든다 — 평활 계수·발산 방어를 공유한다.
-        from B04_PreProcess.B04_PreProcess_Engine_ModelContext import (
-            evaluate_nurbs_spline,
-            fit_nurbs_spline,
-        )
-
-        control_x, control_y, control_z = data["control_x"], data["control_y"], data["control_z"]
-        degree = int(data["degree"][0])
-        spline, z_range = fit_nurbs_spline(control_x, control_y, control_z, degree)
-        x_coords, y_coords = _grid_axes(
-            float(control_x[0]),
-            float(control_x[-1]),
-            float(control_y[0]),
-            float(control_y[-1]),
-            target_grid_m,
-        )
-        z_grid = evaluate_nurbs_spline(
-            spline, y_coords, x_coords, z_range, Path(model_npz_path).stem
-        ).astype(np.float32)
-        valid_mask = _apply_footprint(
-            model_npz_path, x_coords, y_coords, np.ones_like(z_grid, dtype=bool)
-        )
-        return extract_contours_from_grid(
-            x_coords, y_coords, z_grid, valid_mask, interval, scene_center=scene_center
-        )
-
     if representation == "local_rbf_height_field":
-        centers_xy, center_z = data["centers_xy"], data["center_z"]
-        smoothing = float(data["smoothing"][0])
-        interpolator = RBFInterpolator(
-            centers_xy.astype(np.float64),
-            center_z.astype(np.float64),
-            neighbors=min(64, len(centers_xy)),
-            smoothing=smoothing,
-            kernel="thin_plate_spline",
-        )
-        x_min, x_max = float(np.min(centers_xy[:, 0])), float(np.max(centers_xy[:, 0]))
-        y_min, y_max = float(np.min(centers_xy[:, 1])), float(np.max(centers_xy[:, 1]))
-        x_coords, y_coords = _grid_axes(x_min, x_max, y_min, y_max, target_grid_m)
-        xx, yy = np.meshgrid(x_coords, y_coords)
-        z_values = interpolator(np.column_stack([xx.ravel(), yy.ravel()])).astype(np.float32)
-        z_grid = z_values.reshape(len(y_coords), len(x_coords))
-        valid_mask = _apply_footprint(
-            model_npz_path, x_coords, y_coords, np.ones_like(z_grid, dtype=bool)
-        )
-        return extract_contours_from_grid(
-            x_coords, y_coords, z_grid, valid_mask, interval, scene_center=scene_center
-        )
+        # 굳힌 격자(641-1) 그대로 — 등고선 = 서버 표본 · 종횡단과 같은 면(643) · dtm 늘 먼저(754-1)
+        from common_util.common_util_surface_sampler import implicit_grid_npz
 
-    if representation == "meshfree_surfels":
-        from scipy.spatial import Delaunay
-
-        points = data["points"]
-        x_min, x_max = float(np.min(points[:, 0])), float(np.max(points[:, 0]))
-        y_min, y_max = float(np.min(points[:, 1])), float(np.max(points[:, 1]))
-        x_coords, y_coords = _grid_axes(x_min, x_max, y_min, y_max, target_grid_m)
-        # Delaunay 1회로 삼각분할과 hull 판정을 함께 해결한다. 기존에는 griddata가
-        # 내부에서 한 번, hull 판정용으로 또 한 번 만들었다 (PLAN 2026-08-17).
-        triangulation = Delaunay(np.asarray(points[:, :2], dtype=np.float64))
-        z_grid = rasterize_triangle_mesh(points, triangulation.simplices, x_coords, y_coords)
-        # hull 밖은 어느 삼각형에도 안 닿아 NaN으로 남는다 = 기존 hull_inside와 같다.
-        valid_mask = np.isfinite(z_grid)
-        valid_mask = _apply_footprint(model_npz_path, x_coords, y_coords, valid_mask)
-        return extract_contours_from_grid(
-            x_coords, y_coords, z_grid, valid_mask, interval, scene_center=scene_center
-        )
+        filter_key = model_npz_path.stem.removeprefix("implicit_")
+        with np.load(implicit_grid_npz(model_npz_path.parent, filter_key)) as grid:
+            return extract_contours_from_grid(
+                grid["x"],
+                grid["y"],
+                grid["z"],
+                grid["valid_mask"],
+                interval,
+                scene_center=scene_center,
+            )
 
     raise ValueError(f"지원하지 않는 표현 방식입니다: {representation}")

B04_PreProcess/B04_PreProcess_Engine_Filter_CSF.py

@@ -1,122 +0,0 @@
-"""B04 CSF(Cloth Simulation Filter) 지면 필터.
-
-Pure NumPy 기반 CSF. 지형을 반전시킨 뒤 가상의 천을 중력으로 낙하시켜
-원 지면(반전 최하단)에 밀착시키고, 천과의 오차가 임계값 이내인 포인트를
-지면으로 분류한다.
-"""
-
-import math
-from typing import Any
-
-import numpy as np
-
-from config.config_system import (
-    SURFACE_CSF_CLASS_THRESHOLD_M,
-    SURFACE_CSF_CLOTH_RESOLUTION_M,
-    SURFACE_CSF_ITERATIONS,
-    SURFACE_CSF_MAX_ITERATIONS,
-    SURFACE_CSF_RIGIDNESS,
-    SURFACE_CSF_SLOPE_SMOOTH,
-    SURFACE_CSF_SLOPE_SMOOTH_THRESHOLD_M,
-    SURFACE_CSF_TIME_STEP,
-)
-
-# rigidness 단계별 스프링 완화 계수 (1: 산악 밀착 ~ 3: 부드럽게 덮음)
-_RIGIDNESS_SPRING_COEFF = {1: 0.25, 2: 0.45, 3: 0.65}
-# 중력 하강 계수 (time_step에 곱해 반복당 낙하량 산출)
-_GRAVITY_BASE = 9.8 * 0.05
-
-
-def filter_csf(
-    structured_data: dict[str, Any] | np.lib.npyio.NpzFile,
-    cloth_resolution: float = SURFACE_CSF_CLOTH_RESOLUTION_M,
-    rigidness: int = SURFACE_CSF_RIGIDNESS,
-    time_step: float = SURFACE_CSF_TIME_STEP,
-    class_threshold: float = SURFACE_CSF_CLASS_THRESHOLD_M,
-    iterations: int = SURFACE_CSF_ITERATIONS,
-    slope_smooth: bool = SURFACE_CSF_SLOPE_SMOOTH,
-    slope_smooth_threshold: float = SURFACE_CSF_SLOPE_SMOOTH_THRESHOLD_M,
-    max_iterations: int = SURFACE_CSF_MAX_ITERATIONS,
-) -> np.ndarray:
-    """CSF로 지면 포인트의 불리언 마스크를 반환한다."""
-    if not math.isfinite(cloth_resolution) or cloth_resolution <= 0:
-        raise ValueError("천 해상도는 0보다 큰 유한한 값이어야 합니다.")
-    if rigidness not in _RIGIDNESS_SPRING_COEFF:
-        raise ValueError("rigidness는 1, 2, 3 중 하나여야 합니다.")
-    if not math.isfinite(time_step) or time_step <= 0:
-        raise ValueError("time_step은 0보다 큰 유한한 값이어야 합니다.")
-    if not math.isfinite(class_threshold) or class_threshold < 0:
-        raise ValueError("분류 임계값은 0 이상의 유한한 값이어야 합니다.")
-    if iterations <= 0:
-        raise ValueError("반복 횟수는 1 이상이어야 합니다.")
-    if max_iterations < iterations:
-        raise ValueError("반복 상한은 정착 여유 반복 수보다 작을 수 없습니다.")
-
-    xyz = np.asarray(structured_data["xyz"], dtype=np.float64)
-    if xyz.ndim != 2 or xyz.shape[1] != 3:
-        raise ValueError("xyz 배열은 (N, 3) 형태여야 합니다.")
-    if xyz.shape[0] == 0:
-        return np.zeros(0, dtype=bool)
-
-    xs, ys, zs = xyz[:, 0], xyz[:, 1], xyz[:, 2]
-
-    # 1. 지형 반전 — 지표면 추출을 위해 높이를 뒤집는다.
-    z_max = float(np.max(zs))
-    inverted_zs = (z_max - zs).astype(np.float32)
-
-    # 2. 2D 가상 천 격자 설정 (바운더리 밀착 매핑)
-    x_min, x_max = float(np.min(xs)), float(np.max(xs))
-    y_min, y_max = float(np.min(ys)), float(np.max(ys))
-    cols = int(np.ceil((x_max - x_min) / cloth_resolution)) + 1
-    rows = int(np.ceil((y_max - y_min) / cloth_resolution)) + 1
-
-    # 천 노드 초기 높이 — 반전 지형 최고점보다 약간 높은 곳에서 낙하 시작
-    start_height = float(np.max(inverted_zs)) + 1.0
-    cloth_z = np.full((rows, cols), start_height, dtype=np.float32)
-
-    # 3. 격자 충돌 타겟 구성 (Drape Target)
-    collision_grid = np.full((rows, cols), -np.inf, dtype=np.float32)
-    gx = np.clip(((xs - x_min) / cloth_resolution).astype(np.int32), 0, cols - 1)
-    gy = np.clip(((ys - y_min) / cloth_resolution).astype(np.int32), 0, rows - 1)
-    np.maximum.at(collision_grid, (gy, gx), inverted_zs)
-    collision_grid[collision_grid == -np.inf] = 0.0
-
-    # 4. 천 시뮬레이션 반복 루프 (물리 하강)
-    #    반복 수는 현장 기복에서 뽑는다 — 고정 횟수는 곧 고정 하강 예산이라
-    #    (0.3185m × 150회 = 47.8m) 기복이 그보다 큰 산악지에서 천이 지면에 닿지
-    #    못하고 공중에 멈춘다. 낙하 구간 + 스프링 정착 여유(iterations)로 잡는다.
-    gravity = _GRAVITY_BASE * time_step
-    spring_coeff = _RIGIDNESS_SPRING_COEFF[rigidness]
-    required_drop = start_height - float(np.min(collision_grid))
-    total_iterations = int(math.ceil(max(required_drop, 0.0) / gravity)) + iterations
-    total_iterations = min(total_iterations, max_iterations)
-    for _ in range(total_iterations):
-        cloth_z -= gravity
-        cloth_z = np.maximum(cloth_z, collision_grid)
-
-        # 노드 간 스프링 제약 완화 (가로/세로 인접 교정)
-        diff_h = cloth_z[:, 1:] - cloth_z[:, :-1]
-        correction_h = diff_h * spring_coeff * 0.5
-        cloth_z[:, :-1] += correction_h
-        cloth_z[:, 1:] -= correction_h
-
-        diff_v = cloth_z[1:, :] - cloth_z[:-1, :]
-        correction_v = diff_v * spring_coeff * 0.5
-        cloth_z[:-1, :] += correction_v
-        cloth_z[1:, :] -= correction_v
-
-        cloth_z = np.maximum(cloth_z, collision_grid)
-
-    # 5. 시뮬레이션 천 높이와 원본 대조 → 오차 이내면 지면
-    simulated_inverted_z = cloth_z[gy, gx]
-    height_diff = np.abs(inverted_zs - simulated_inverted_z)
-    mask = height_diff <= class_threshold
-
-    # 6. 수목 노이즈 2차 필터 보정 — 셀 지면 후보(반전고 최대 = 원표고 최저)보다
-    #    얼마나 위에 떠 있는지를 본다. 반전 공간에서 높이는 (지면 후보 - 자기 반전고)다.
-    #    반대로 빼면 항상 0 이하가 나와 조건이 늘 참이 된다(= 필터가 무력화).
-    if slope_smooth:
-        local_ground_z = collision_grid[gy, gx]
-        mask = mask & ((local_ground_z - inverted_zs) < slope_smooth_threshold)
-
-    return np.asarray(mask, dtype=bool)

B04_PreProcess/B04_PreProcess_Engine_Filter_Classification.py

@@ -5,11 +5,18 @@
 쓸 수 있는지는 has_classified_ground()로 먼저 판정한다.
 """
 
+import json
+from pathlib import Path
 from typing import Any
 
 import numpy as np
 
-from config.config_system import SURFACE_CLASSIFIED_GROUND_MIN_RATIO
+from common_util.common_util_json import atomic_write_json
+from config.config_system import (
+    SURFACE_CLASSIFIED_COVERAGE_CELL_M,
+    SURFACE_CLASSIFIED_COVERAGE_MIN_RATIO,
+    SURFACE_CLASSIFIED_GROUND_MIN_RATIO,
+)
 
 # ASPRS 표준 지면 클래스 코드
 GROUND_CLASS_CODE = 2
@@ -38,3 +45,51 @@ def has_classified_ground(
         return False
     ground = int(np.count_nonzero(classification == GROUND_CLASS_CODE))
     return ground / total >= minimum_ratio
+
+
+def classified_coverage(
+    structured_data: dict[str, Any] | np.lib.npyio.NpzFile,
+    cell_meters: float = SURFACE_CLASSIFIED_COVERAGE_CELL_M,
+) -> float:
+    """점 있는 칸 중 class 2 가 있는 칸의 비율 — 일부만 분류된 LAS 를 가려냄."""
+    if "classification" not in structured_data:
+        return 0.0
+    classification = np.asarray(structured_data["classification"])
+    xyz = structured_data["xyz"]
+    bounds = np.asarray(structured_data["bounds"], dtype=np.float64)
+    cell = max(float(cell_meters), 0.1)
+    cols = int((bounds[0, 1] - bounds[0, 0]) // cell) + 1
+    rows = int((bounds[1, 1] - bounds[1, 0]) // cell) + 1
+    occupied = np.zeros((rows, cols), dtype=bool)
+    ground = np.zeros((rows, cols), dtype=bool)
+    for start in range(0, len(classification), 5_000_000):
+        points = np.asarray(xyz[start : start + 5_000_000, :2], dtype=np.float64)
+        gx = np.clip(((points[:, 0] - bounds[0, 0]) // cell).astype(np.int32), 0, cols - 1)
+        gy = np.clip(((points[:, 1] - bounds[1, 0]) // cell).astype(np.int32), 0, rows - 1)
+        occupied[gy, gx] = True
+        is_ground = classification[start : start + len(points)] == GROUND_CLASS_CODE
+        ground[gy[is_ground], gx[is_ground]] = True
+    total = int(np.count_nonzero(occupied))
+    return float(np.count_nonzero(ground)) / total if total else 0.0
+
+
+def has_classified_coverage(
+    structured_data: dict[str, Any] | np.lib.npyio.NpzFile,
+    processed_dir: Path | None = None,
+    minimum_ratio: float = SURFACE_CLASSIFIED_COVERAGE_MIN_RATIO,
+) -> bool:
+    """분류 덮임 문턱 판정 — `processed_dir` 면 structured.npz 지문으로 저장본 재사용."""
+    if processed_dir is None:
+        return classified_coverage(structured_data) >= minimum_ratio
+    stat = (processed_dir / "structured.npz").stat()
+    stamp = [int(stat.st_size), int(stat.st_mtime_ns)]
+    path = processed_dir / "classification_coverage.json"
+    try:
+        stored = json.loads(path.read_text(encoding="utf-8"))
+        coverage = float(stored["coverage"]) if stored.get("structured") == stamp else None
+    except (OSError, ValueError, KeyError, TypeError, AttributeError):
+        coverage = None
+    if coverage is None:
+        coverage = classified_coverage(structured_data)
+        atomic_write_json(path, {"structured": stamp, "coverage": coverage})
+    return coverage >= minimum_ratio

B04_PreProcess/B04_PreProcess_Engine_Filter_Grid.py

@@ -1,50 +0,0 @@
-"""B04 grid minimum-Z 지면 필터."""
-
-import math
-from typing import Any
-
-import numpy as np
-
-from config.config_system import SURFACE_GRID_CELL_SIZE_M, SURFACE_GRID_HEIGHT_THRESHOLD_M
-
-
-def filter_grid_min_z(
-    structured_data: dict[str, Any] | np.lib.npyio.NpzFile,
-    cell_size: float = SURFACE_GRID_CELL_SIZE_M,
-    height_threshold: float = SURFACE_GRID_HEIGHT_THRESHOLD_M,
-) -> np.ndarray:
-    """격자 최저 표면에서 높이 임계값 이내인 포인트의 불리언 마스크를 반환한다."""
-    if not math.isfinite(cell_size) or cell_size <= 0:
-        raise ValueError("격자 크기는 0보다 큰 유한한 값이어야 합니다.")
-    if not math.isfinite(height_threshold) or height_threshold < 0:
-        raise ValueError("높이 임계값은 0 이상의 유한한 값이어야 합니다.")
-
-    xyz = np.asarray(structured_data["xyz"], dtype=np.float64)
-    bounds = np.asarray(structured_data["bounds"], dtype=np.float64)
-    if xyz.ndim != 2 or xyz.shape[1] != 3:
-        raise ValueError("xyz 배열은 (N, 3) 형태여야 합니다.")
-    if bounds.shape != (3, 2):
-        raise ValueError("bounds 배열은 (3, 2) 형태여야 합니다.")
-    if xyz.shape[0] == 0:
-        return np.zeros(0, dtype=bool)
-
-    x_min, y_min = bounds[0, 0], bounds[1, 0]
-    x_max, y_max = bounds[0, 1], bounds[1, 1]
-    grid_width = int(np.ceil((x_max - x_min) / cell_size)) + 2
-    grid_height = int(np.ceil((y_max - y_min) / cell_size)) + 2
-    # float32로 담으면 셀 최저점(가장 확실한 지면점)이 반올림 때문에 자기 기준면보다
-    # 낮아져 height_above < 0 으로 탈락한다 — 원본 좌표와 같은 float64로 둔다.
-    minimum_z = np.full((grid_height, grid_width), np.inf, dtype=np.float64)
-
-    grid_x = np.clip(((xyz[:, 0] - x_min) / cell_size).astype(np.int64), 0, grid_width - 1)
-    grid_y = np.clip(((xyz[:, 1] - y_min) / cell_size).astype(np.int64), 0, grid_height - 1)
-    np.minimum.at(minimum_z, (grid_y, grid_x), xyz[:, 2])
-
-    # 기준면은 점이 실제로 들어 있는 셀에서만 읽는다 — 3x3 최소필터로 이웃 셀 값을
-    # 끌어오면 급경사에서 기준면이 경사만큼 파고들어(중앙 1.88m > 임계 1.5m) 지면점이
-    # 통째로 탈락한다. 빈 셀은 아래 인덱싱에서 참조되지 않으므로 채울 필요가 없다.
-    height_above = xyz[:, 2] - minimum_z[grid_y, grid_x]
-    return np.asarray(
-        (height_above >= 0.0) & (height_above <= height_threshold),
-        dtype=bool,
-    )

B04_PreProcess/B04_PreProcess_Engine_Filter_PMF.py

@@ -1,91 +0,0 @@
-"""B04 PMF(Progressive Morphological Filter) 지면 필터.
-
-XY 평면을 격자로 투영해 Z-min 지형 맵을 만든 뒤, 윈도우 폭을 단계적으로
-키워가며 형태학적 열림(Opening) 연산으로 수목·구조물을 제거하고, 최종 지면
-대비 높이차가 임계값 이내인 포인트를 지면으로 분류한다. Pure NumPy 구현.
-"""
-
-import math
-from typing import Any
-
-import numpy as np
-from numpy.lib.stride_tricks import sliding_window_view
-
-from config.config_system import (
-    SURFACE_PMF_CELL_SIZE_M,
-    SURFACE_PMF_INITIAL_WINDOW_SIZE,
-    SURFACE_PMF_MAX_DISTANCE_M,
-    SURFACE_PMF_MAX_WINDOW_SIZE,
-    SURFACE_PMF_SLOPE,
-)
-
-
-def _min_max_window_filter(grid: np.ndarray, w_size: int, mode: str = "min") -> np.ndarray:
-    """순수 NumPy 2D 이동 윈도우 최솟값/최댓값 필터 (경계는 edge 패딩)."""
-    pad_val = w_size // 2
-    padded = np.pad(grid, pad_val, mode="edge")
-    windows = sliding_window_view(padded, (w_size, w_size))
-    if mode == "min":
-        return np.min(windows, axis=(2, 3))
-    return np.max(windows, axis=(2, 3))
-
-
-def filter_pmf(
-    structured_data: dict[str, Any] | np.lib.npyio.NpzFile,
-    cell_size: float = SURFACE_PMF_CELL_SIZE_M,
-    max_window_size: int = SURFACE_PMF_MAX_WINDOW_SIZE,
-    slope: float = SURFACE_PMF_SLOPE,
-    initial_window_size: int = SURFACE_PMF_INITIAL_WINDOW_SIZE,
-    max_distance: float = SURFACE_PMF_MAX_DISTANCE_M,
-) -> np.ndarray:
-    """PMF로 지면 포인트의 불리언 마스크를 반환한다."""
-    if not math.isfinite(cell_size) or cell_size <= 0:
-        raise ValueError("격자 크기는 0보다 큰 유한한 값이어야 합니다.")
-    if initial_window_size < 1 or max_window_size < initial_window_size:
-        raise ValueError("윈도우 크기는 1 이상이고 최대가 초기값 이상이어야 합니다.")
-    if not math.isfinite(max_distance) or max_distance < 0:
-        raise ValueError("최대 거리 임계값은 0 이상의 유한한 값이어야 합니다.")
-
-    xyz = np.asarray(structured_data["xyz"], dtype=np.float64)
-    bounds = np.asarray(structured_data["bounds"], dtype=np.float64)
-    if xyz.ndim != 2 or xyz.shape[1] != 3:
-        raise ValueError("xyz 배열은 (N, 3) 형태여야 합니다.")
-    if bounds.shape != (3, 2):
-        raise ValueError("bounds 배열은 (3, 2) 형태여야 합니다.")
-    if xyz.shape[0] == 0:
-        return np.zeros(0, dtype=bool)
-
-    xs, ys, zs = xyz[:, 0], xyz[:, 1], xyz[:, 2]
-    x_min, y_min, z_min = bounds[0, 0], bounds[1, 0], bounds[2, 0]
-    x_max, y_max = bounds[0, 1], bounds[1, 1]
-
-    grid_w = int(np.ceil((x_max - x_min) / cell_size)) + 2
-    grid_h = int(np.ceil((y_max - y_min) / cell_size)) + 2
-
-    z_grid = np.full((grid_h, grid_w), np.inf, dtype=np.float32)
-    gx = np.clip(((xs - x_min) / cell_size).astype(np.int32), 0, grid_w - 1)
-    gy = np.clip(((ys - y_min) / cell_size).astype(np.int32), 0, grid_h - 1)
-
-    # 1. Z-min 지형 구성
-    np.minimum.at(z_grid, (gy, gx), zs.astype(np.float32))
-    z_grid[z_grid == np.inf] = z_min
-
-    # 2. 점진적 형태학 필터 (Opening = Dilation of Erosion)
-    current_grid = z_grid.copy()
-    w_sizes = []
-    w = initial_window_size
-    while w <= max_window_size:
-        w_sizes.append(w)
-        w = w * 2 + 1
-
-    for w_size in w_sizes:
-        eroded = _min_max_window_filter(current_grid, w_size, mode="min")
-        opened = _min_max_window_filter(eroded, w_size, mode="max")
-        t_dist = min(slope * w_size * cell_size * 0.15 + 0.5, max_distance)
-        mask_elev = (current_grid - opened) > t_dist
-        current_grid[mask_elev] = opened[mask_elev]
-
-    # 3. 마스크 매핑 및 원본 비교
-    simulated_z = current_grid[gy, gx]
-    mask = (zs >= simulated_z - 0.4) & (zs <= simulated_z + max_distance)
-    return np.asarray(mask, dtype=bool)

B04_PreProcess/B04_PreProcess_Engine_Filter_PTD.py

@@ -0,0 +1,246 @@
+"""B04 점진 TIN(PTD · Axelsson 꼴) 지면 필터 — 분류 없는 LAS 의 기본 필터.
+
+1. 작은 칸(후보 칸) 최저점 = 후보 · 시작 간격 칸 최저점 = 씨앗.
+2. 씨앗 삼각망 → 후보마다 삼각면까지 연직 거리 · 세 꼭짓점 각을 보고 문턱 안이면
+   삼각형마다 가장 가까운 하나를 지면에 더함 → 더 안 들어올 때까지 되풀이.
+   삼각망 밖 후보 · 격자는 맞닿은 테두리 삼각형 평면을 늘여 봄(밖으로 차례로 넓어짐).
+   굵게 → 가늘게: 후보가 모두 면 위로 뜬 칸(면이 처짐)에 반 간격 씨앗을 더해 다시 다짐.
+   끝에 둘레보다 최대 거리 넘게 튀거나 꺼진 외딴 꼭짓점(가시 · 잡점)을 걷음.
+3. 마지막 지면 TIN 을 후보 칸 격자로 굳히고 모든 점을 면까지 연직 거리로 판정 —
+   면 아래 최대 거리 · 면 위 0.12 m(꼭짓점 = 칸 최저라 땅은 면 곁 · 위는 덤불).
+
+장면 셋(DJI Terra 꼴) = 평지 3° · 0.3 m / 완경사 6° · 0.5 m / 급경사 10° · 0.7 m
+· 기본 급경사(임도).
+큰 파일 = 점을 덩이로 나눠 칸 최저만 모음 · 후보가 상한을 넘으면 후보 칸을 키움(메모리 상한).
+"""
+
+import math
+from typing import Any
+
+import numpy as np
+from scipy import ndimage
+from scipy.spatial import Delaunay, cKDTree
+
+from config.config_system import SURFACE_PTD_SCENE, SURFACE_PTD_SEED_SPACING_M
+
+# 장면 → (최대 각 °, 최대 거리 m)
+PTD_SCENES = {"flat": (3.0, 0.3), "gentle": (6.0, 0.5), "steep": (10.0, 0.7)}
+_CHUNK_POINTS = 5_000_000
+
+
+def _cell_minima(xyz: np.ndarray, origin: tuple[float, float], cell: float, cols: int):
+    """칸마다 가장 낮은 점의 (칸 번호, 점 번호)를 덩이로 나눠 모은다."""
+    keys, picks = [], []
+    for start in range(0, len(xyz), _CHUNK_POINTS):
+        part = xyz[start : start + _CHUNK_POINTS]
+        gx = ((part[:, 0] - origin[0]) / cell).astype(np.int64)
+        gy = ((part[:, 1] - origin[1]) / cell).astype(np.int64)
+        key = gy * cols + gx
+        order = np.lexsort((part[:, 2], key))
+        first = np.r_[True, key[order][1:] != key[order][:-1]]
+        keys.append(key[order][first])
+        picks.append(order[first] + start)
+    key = np.concatenate(keys)
+    pick = np.concatenate(picks)
+    order = np.lexsort((xyz[pick, 2], key))
+    first = np.r_[True, key[order][1:] != key[order][:-1]]
+    return key[order][first], pick[order][first]
+
+
+def _lone_vertices(points: np.ndarray, gap: float, rounds: int = 10) -> np.ndarray:
+    """둘레 꼭짓점 모두보다 gap 넘게 높거나(덤불 가시) 낮은(땅 밑 잡점) 꼭짓점 번호.
+    능선 · 골은 축 따라 비슷한 이웃이 있어 안 걸림."""
+    keep = np.arange(len(points))
+    for _ in range(rounds):
+        if len(keep) < 4:
+            break
+        indptr, nb = Delaunay(points[keep, :2]).vertex_neighbor_vertices
+        z = points[keep, 2]
+        low = np.minimum.reduceat(z[nb], indptr[:-1])
+        high = np.maximum.reduceat(z[nb], indptr[:-1])
+        lone = (z > high + gap) | (z < low - gap)
+        if not lone.any():
+            break
+        keep = keep[~lone]
+    return np.setdiff1d(np.arange(len(points)), keep)
+
+
+def _lowest_per_cell(points: np.ndarray, origin: tuple[float, float], size: float):
+    """칸마다 가장 낮은 점 — (칸 열, 칸 행, 점 번호)."""
+    gx = ((points[:, 0] - origin[0]) / size).astype(np.int64)
+    gy = ((points[:, 1] - origin[1]) / size).astype(np.int64)
+    key = gy * (gx.max() + 1) + gx
+    order = np.lexsort((points[:, 2], key))
+    first = np.r_[True, key[order][1:] != key[order][:-1]]
+    pick = order[first]
+    return gx[pick], gy[pick], pick
+
+
+def _barycentric(tri: Delaunay, simplex: np.ndarray, q: np.ndarray) -> np.ndarray:
+    """세 꼭짓점 무게(차례 = simplices 차례). tri.transform 은 BLAS 스레드 다툼으로
+    이 PC 에서 1 만 삼각형에 14 초 → 직접 셈."""
+    p = tri.points[tri.simplices[simplex]]
+    v0, v1, v2 = p[:, 1] - p[:, 0], p[:, 2] - p[:, 0], q - p[:, 0]
+    den = v0[:, 0] * v1[:, 1] - v1[:, 0] * v0[:, 1]
+    den = np.where(np.abs(den) < 1e-12, 1e-12, den)
+    l1 = (v2[:, 0] * v1[:, 1] - v1[:, 0] * v2[:, 1]) / den
+    l2 = (v0[:, 0] * v2[:, 1] - v2[:, 0] * v0[:, 1]) / den
+    return np.column_stack([1.0 - l1 - l2, l1, l2])
+
+
+def _locate(tri: Delaunay, q: np.ndarray, max_steps: int = 200) -> np.ndarray:
+    """점이 든 삼각형 번호 · 삼각망 밖이면 맞닿은 테두리 삼각형(그 평면으로 늘여 봄).
+    가장 가까운 꼭짓점에서 이웃으로 걸음 — scipy find_simplex 는 점마다 0 번에서 걸어
+    백만 점에 수십 분이 걸린다."""
+    _, nearest = cKDTree(tri.points).query(q)
+    simplex = tri.vertex_to_simplex[nearest].astype(np.int64)
+    active = np.arange(len(q))
+    for _ in range(max_steps):
+        if not len(active):
+            break
+        bary = _barycentric(tri, simplex[active], q[active])
+        worst = bary.argmin(axis=1)
+        moving = bary[np.arange(len(active)), worst] < -1e-9
+        step = tri.neighbors[simplex[active], worst]
+        walk = moving & (step >= 0)
+        simplex[active[walk]] = step[walk]
+        active = active[walk]
+    return simplex
+
+
+def _plane_distance(tri: Delaunay, gz: np.ndarray, simplex: np.ndarray, q: np.ndarray):
+    """점 q 의 삼각면까지 연직 거리와 세 꼭짓점에서 본 최대 각(°).
+    연직 = 비탈에서 수직 거리보다 관목을 덜 받음(수직은 45° 비탈 0.7 m 가 연직 1 m)."""
+    vertex = tri.simplices[simplex]
+    weight = _barycentric(tri, simplex, q[:, :2])
+    distance = np.abs(q[:, 2] - (weight * gz[vertex]).sum(axis=1))
+    reach = np.linalg.norm(q[:, None, :2] - tri.points[vertex], axis=2).min(axis=1)
+    angle = np.degrees(np.arctan(distance / np.maximum(reach, 1e-9)))
+    return distance, angle
+
+
+def _tin_dz(ground: np.ndarray, q: np.ndarray) -> np.ndarray:
+    """q 높이 − 지면 TIN 높이(연직)."""
+    tri = Delaunay(ground[:, :2])
+    simplex = _locate(tri, q[:, :2])
+    weight = _barycentric(tri, simplex, q[:, :2])
+    return q[:, 2] - (weight * ground[tri.simplices[simplex], 2]).sum(axis=1)
+
+
+def _densify(
+    cand: np.ndarray, is_ground: np.ndarray, max_angle: float, max_distance: float, rounds: int
+) -> None:
+    """삼각형마다 문턱 안 가장 가까운 후보 하나를 지면에 더함 — 더 안 들어올 때까지."""
+    for _ in range(rounds):
+        ground = cand[is_ground]
+        tri = Delaunay(ground[:, :2])
+        pending = np.flatnonzero(~is_ground)
+        if not len(pending):
+            return
+        simplex = _locate(tri, cand[pending, :2])
+        distance, angle = _plane_distance(tri, ground[:, 2], simplex, cand[pending])
+        # 꼭짓점 곁 점은 각이 커지기만 함 → 최대 거리 절반 안이면 각을 안 봄
+        ok = (distance <= max_distance) & ((angle <= max_angle) | (distance <= max_distance / 2))
+        pending, simplex, distance = pending[ok], simplex[ok], distance[ok]
+        if not len(pending):
+            return
+        order = np.lexsort((distance, simplex))
+        first = np.r_[True, simplex[order][1:] != simplex[order][:-1]]
+        is_ground[pending[order[first]]] = True
+        if first.sum() < max(10, 0.001 * is_ground.sum()):
+            return
+
+
+def filter_ptd(
+    structured_data: dict[str, Any] | np.lib.npyio.NpzFile,
+    scene: str = SURFACE_PTD_SCENE,
+    seed_spacing: float = SURFACE_PTD_SEED_SPACING_M,
+    max_angle: float | None = None,
+    max_distance: float | None = None,
+    above_distance: float = 0.12,
+    candidate_cell: float = 0.5,
+    max_candidates: int = 3_000_000,
+    max_iterations: int = 60,
+    refine_min_spacing: float = 2.5,
+) -> np.ndarray:
+    """점진 TIN 으로 지면 포인트의 불리언 마스크를 반환한다."""
+    if scene not in PTD_SCENES:
+        raise ValueError(f"점진 TIN 장면은 {', '.join(PTD_SCENES)} 중 하나여야 합니다.")
+    scene_angle, scene_distance = PTD_SCENES[scene]
+    max_angle = scene_angle if max_angle is None else float(max_angle)
+    max_distance = scene_distance if max_distance is None else float(max_distance)
+    for name, value in (("시작 간격", seed_spacing), ("후보 칸", candidate_cell)):
+        if not math.isfinite(value) or value <= 0:
+            raise ValueError(f"{name}은 0보다 큰 유한한 값이어야 합니다.")
+    if not (0 < max_angle < 90) or max_distance <= 0 or above_distance < 0:
+        raise ValueError("최대 각은 0~90°, 최대 거리는 0보다 커야 합니다.")
+
+    xyz = np.asarray(structured_data["xyz"], dtype=np.float64)
+    if xyz.ndim != 2 or xyz.shape[1] != 3:
+        raise ValueError("xyz 배열은 (N, 3) 형태여야 합니다.")
+    if len(xyz) < 3:
+        return np.ones(len(xyz), dtype=bool)
+
+    x_min, y_min = float(xyz[:, 0].min()), float(xyz[:, 1].min())
+    x_max, y_max = float(xyz[:, 0].max()), float(xyz[:, 1].max())
+    width, height = max(x_max - x_min, 1e-6), max(y_max - y_min, 1e-6)
+    # ponytail: 후보 상한은 칸을 키워 지킴(공간 타일 아님) · 수 km² 넘으면 겹침 타일로
+    cell = max(candidate_cell, math.sqrt(width * height / max_candidates))
+    cols = int(width / cell) + 1
+    cand_key, cand_idx = _cell_minima(xyz, (x_min, y_min), cell, cols)
+    cand = xyz[cand_idx]
+
+    # 씨앗 = 시작 간격 칸마다 가장 낮은 후보 + 자료 가장자리는 1/4 간격 칸마다(삼각망이
+    # 가장자리까지 닿게 — 밖은 늘여 볼 테두리 삼각형이 가늘어 땅을 놓침)
+    origin = (x_min, y_min)
+    is_ground = np.zeros(len(cand), dtype=bool)
+    is_ground[_lowest_per_cell(cand, origin, seed_spacing)[2]] = True
+    gx, gy, pick = _lowest_per_cell(cand, origin, seed_spacing / 4)
+    occupied = np.zeros((gy.max() + 1, gx.max() + 1), dtype=bool)
+    occupied[gy, gx] = True
+    edge = occupied & ~ndimage.binary_erosion(occupied, iterations=1, border_value=0)
+    is_ground[pick[edge[gy, gx]]] = True
+    _densify(cand, is_ground, max_angle, max_distance, max_iterations)
+
+    # 굵게 → 가늘게: 칸 안 후보가 모두 면보다 최대 거리 넘게 위면(땅이 모든 반사점 밑일 수
+    # 없음 = 성긴 씨앗 사이에서 면이 처짐) 면에 가장 가까운 후보를 씨앗으로 더하고 다시 다짐
+    spacing = seed_spacing / 2
+    while spacing >= refine_min_spacing:
+        dz = np.zeros(len(cand))
+        pending = np.flatnonzero(~is_ground)
+        dz[pending] = _tin_dz(cand[is_ground], cand[pending])
+        gx, gy, pick = _lowest_per_cell(np.column_stack([cand[:, :2], dz]), origin, spacing)
+        sag = pick[dz[pick] > max_distance]
+        if len(sag):
+            is_ground[sag] = True
+            _densify(cand, is_ground, max_angle, max_distance, max_iterations)
+        spacing /= 2
+    ground_idx = np.flatnonzero(is_ground)
+    is_ground[ground_idx[_lone_vertices(cand[ground_idx], max_distance)]] = False
+
+    # 마지막 지면 TIN → 후보 칸 격자 → 모든 점 연직 거리 판정
+    ground = cand[is_ground]
+    tri = Delaunay(ground[:, :2])
+    rows = int(height / cell) + 2
+    mesh_x, mesh_y = np.meshgrid(x_min + np.arange(cols + 1) * cell, y_min + np.arange(rows) * cell)
+    node = np.column_stack([mesh_x.ravel(), mesh_y.ravel()])
+    simplex = _locate(tri, node)
+    weight = _barycentric(tri, simplex, node)
+    grid = (weight * ground[tri.simplices[simplex], 2]).sum(axis=1).reshape(mesh_x.shape)
+
+    mask = np.zeros(len(xyz), dtype=bool)
+    for start in range(0, len(xyz), _CHUNK_POINTS):
+        part = xyz[start : start + _CHUNK_POINTS]
+        fx = np.clip((part[:, 0] - x_min) / cell, 0, cols - 1e-6)
+        fy = np.clip((part[:, 1] - y_min) / cell, 0, rows - 1 - 1e-6)
+        ix, iy = fx.astype(np.int64), fy.astype(np.int64)
+        tx, ty = fx - ix, fy - iy
+        z_tin = (
+            grid[iy, ix] * (1 - tx) * (1 - ty)
+            + grid[iy, ix + 1] * tx * (1 - ty)
+            + grid[iy + 1, ix] * (1 - tx) * ty
+            + grid[iy + 1, ix + 1] * tx * ty
+        )
+        dz = part[:, 2] - z_tin
+        mask[start : start + len(part)] = (dz >= -max_distance) & (dz <= above_distance)
+    return mask

B04_PreProcess/B04_PreProcess_Engine_Filter_RANSAC.py

@@ -1,116 +0,0 @@
-"""B04 RANSAC 지면 필터 (Local plane fitting).
-
-공간을 로컬 격자로 분할하고, 각 격자에서 RANSAC 평면 피팅을 수행해
-평면과의 거리가 임계값 이내인 인라이어(지면)를 취합한다. Pure NumPy 구현.
-"""
-
-import math
-from collections.abc import Callable
-from typing import Any
-
-import numpy as np
-
-from config.config_system import (
-    SURFACE_RANSAC_DISTANCE_THRESHOLD_M,
-    SURFACE_RANSAC_ITERATIONS,
-    SURFACE_RANSAC_LOCAL_GRID_SIZE_M,
-    SURFACE_RANSAC_N,
-    SURFACE_RANSAC_SEED,
-)
-
-
-def fit_plane_ransac(
-    points: np.ndarray,
-    distance_threshold: float = SURFACE_RANSAC_DISTANCE_THRESHOLD_M,
-    ransac_n: int = SURFACE_RANSAC_N,
-    num_iterations: int = SURFACE_RANSAC_ITERATIONS,
-    seed: int = SURFACE_RANSAC_SEED,
-) -> np.ndarray:
-    """평면 ax+by+cz+d=0을 RANSAC으로 피팅하고 인라이어 마스크를 반환한다."""
-    n_points = len(points)
-    if n_points < ransac_n:
-        return np.ones(n_points, dtype=bool)
-
-    best_inliers = np.zeros(n_points, dtype=bool)
-    max_inlier_count = -1
-    rng = np.random.default_rng(seed)
-
-    for _ in range(num_iterations):
-        idx = rng.choice(n_points, ransac_n, replace=False)
-        p0, p1, p2 = points[idx]
-        normal = np.cross(p1 - p0, p2 - p0)
-        norm = np.linalg.norm(normal)
-        if norm < 1e-6:
-            continue  # 세 점이 일직선상 → 스킵
-        normal = normal / norm
-        d = -np.dot(normal, p0)
-        distances = np.abs(np.dot(points, normal) + d)
-        inliers = distances < distance_threshold
-        inlier_count = int(np.sum(inliers))
-        if inlier_count > max_inlier_count:
-            max_inlier_count = inlier_count
-            best_inliers = inliers
-
-    if max_inlier_count > 0:
-        return best_inliers
-    return np.ones(n_points, dtype=bool)
-
-
-def filter_ransac(
-    structured_data: dict[str, Any] | np.lib.npyio.NpzFile,
-    distance_threshold: float = SURFACE_RANSAC_DISTANCE_THRESHOLD_M,
-    ransac_n: int = SURFACE_RANSAC_N,
-    num_iterations: int = SURFACE_RANSAC_ITERATIONS,
-    local_grid_size: float = SURFACE_RANSAC_LOCAL_GRID_SIZE_M,
-    seed: int = SURFACE_RANSAC_SEED,
-    progress_callback: Callable[[int], None] | None = None,
-) -> np.ndarray:
-    """로컬 격자별 RANSAC 평면 분할로 지면 포인트 마스크를 반환한다."""
-    if not math.isfinite(local_grid_size) or local_grid_size <= 0:
-        raise ValueError("로컬 격자 크기는 0보다 큰 유한한 값이어야 합니다.")
-    if ransac_n < 3:
-        raise ValueError("RANSAC 샘플 수는 3 이상이어야 합니다.")
-
-    xyz = np.asarray(structured_data["xyz"], dtype=np.float64)
-    bounds = np.asarray(structured_data["bounds"], dtype=np.float64)
-    if xyz.ndim != 2 or xyz.shape[1] != 3:
-        raise ValueError("xyz 배열은 (N, 3) 형태여야 합니다.")
-    if bounds.shape != (3, 2):
-        raise ValueError("bounds 배열은 (3, 2) 형태여야 합니다.")
-
-    n_points = len(xyz)
-    mask = np.zeros(n_points, dtype=bool)
-    if n_points == 0:
-        return mask
-
-    x_min, y_min = bounds[0, 0], bounds[1, 0]
-    x_max, y_max = bounds[0, 1], bounds[1, 1]
-    grid_w = int(np.ceil((x_max - x_min) / local_grid_size)) + 1
-    grid_h = int(np.ceil((y_max - y_min) / local_grid_size)) + 1
-
-    xs, ys = xyz[:, 0], xyz[:, 1]
-    gx = np.clip(((xs - x_min) / local_grid_size).astype(np.int32), 0, grid_w - 1)
-    gy = np.clip(((ys - y_min) / local_grid_size).astype(np.int32), 0, grid_h - 1)
-    grid_indices = gy * grid_w + gx
-    unique_grids = np.unique(grid_indices)
-    total_grids = len(unique_grids)
-
-    for i, grid_id in enumerate(unique_grids):
-        cell_points_idx = np.where(grid_indices == grid_id)[0]
-        if len(cell_points_idx) < ransac_n:
-            mask[cell_points_idx] = True
-            continue
-        cell_inliers = fit_plane_ransac(
-            xyz[cell_points_idx],
-            distance_threshold=distance_threshold,
-            ransac_n=ransac_n,
-            num_iterations=num_iterations,
-            seed=seed,
-        )
-        mask[cell_points_idx[cell_inliers]] = True
-        if progress_callback:
-            progress_callback(int(((i + 1) / total_grids) * 100))
-
-    if progress_callback:
-        progress_callback(100)  # 모든 격자 처리 완료 보장
-    return mask

B04_PreProcess/B04_PreProcess_Engine_Filter_Refine.py

@@ -0,0 +1,116 @@
+"""B04 지면점 다듬기 — 필터가 고른 지면점에서 덤불 · 풀 혹과 낮은 잡점을 한 번 더 거름(762-1).
+
+SMRF 꼴(Pingel 2013 · PDAL filters.smrf) — 입력 = 필터 지면 마스크 · 출력 = 줄어든 마스크.
+① 1 m 칸 최저면 → 뒤집어 열림(낮은 잡점 칸)
+② 창 반지름 1 칸부터 최대까지 키우며 열림 · 문턱 = 기울기 × 칸 × 반지름(물체 칸)
+③ 걸린 칸 빼고 남은 칸으로 임시 지면 다시 그림(줄여 메우고 늘려 붓는 다층 보간)
+④ 점마다 |z − 임시 지면| ≤ 문턱 + 배수 × 그 자리 기울기 이면 지면.
+"""
+
+from typing import Any
+
+import numpy as np
+from scipy import ndimage
+
+from config.config_system import (
+    SURFACE_REFINE_CELL_M,
+    SURFACE_REFINE_LOW_SLOPE,
+    SURFACE_REFINE_SCALAR,
+    SURFACE_REFINE_SLOPE,
+    SURFACE_REFINE_THRESHOLD_M,
+    SURFACE_REFINE_WINDOW_M,
+)
+
+_RELAX_STEPS = 30
+
+
+def _fill_nearest(grid: np.ndarray, missing: np.ndarray) -> np.ndarray:
+    if not missing.any():
+        return grid
+    index = ndimage.distance_transform_edt(missing, return_distances=False, return_indices=True)
+    return grid[tuple(index)]
+
+
+def _progressive(surface: np.ndarray, cell: float, slope: float, max_radius: int) -> np.ndarray:
+    """창을 한 칸씩 키운 열림이 한 단계에 문턱(기울기 × 칸 × 반지름)보다 깎은 칸."""
+    flagged = np.zeros(surface.shape, dtype=bool)
+    last = surface
+    for radius in range(1, max_radius + 1):
+        # ponytail: 정사각 창(분리형 최소 · 최대 거름) — 원판보다 빠름 · 모서리 방향만 조금 넓음
+        # (네 방향 선분 열림은 능선을 더 지키나 덤불 판을 3 배 남겨 버림 — 762 훑기)
+        current = ndimage.grey_opening(last, size=(2 * radius + 1, 2 * radius + 1))
+        flagged |= (last - current) > slope * cell * radius
+        last = current
+    return flagged
+
+
+def _inpaint(values: np.ndarray, known: np.ndarray) -> np.ndarray:
+    """빈 칸을 아는 칸으로 메움 — 2 배씩 줄여 메운 뒤 늘려 붓고 이웃 평균으로 폄."""
+    if known.all():
+        return values
+    if not known.any():
+        return np.zeros_like(values)
+    rows, cols = values.shape
+    pad = ((0, rows % 2), (0, cols % 2))
+    weight = np.pad(known.astype(np.float64), pad)
+    total = np.pad(np.where(known, values, 0.0), pad)
+    shape = (weight.shape[0] // 2, 2, weight.shape[1] // 2, 2)
+    coarse_weight = weight.reshape(shape).sum(axis=(1, 3))
+    coarse_known = coarse_weight > 0
+    coarse = total.reshape(shape).sum(axis=(1, 3)) / np.maximum(coarse_weight, 1.0)
+    coarse = _inpaint(coarse, coarse_known)
+    up = ndimage.zoom(coarse, 2, order=1, mode="nearest", grid_mode=True)[:rows, :cols]
+    result = np.where(known, values, up)
+    missing = ~known
+    for _ in range(_RELAX_STEPS):
+        padded = np.pad(result, 1, mode="edge")
+        mean = (padded[:-2, 1:-1] + padded[2:, 1:-1] + padded[1:-1, :-2] + padded[1:-1, 2:]) / 4
+        result[missing] = mean[missing]
+    return result
+
+
+def refine_ground_mask(
+    xyz: Any,
+    mask: np.ndarray,
+    *,
+    cell: float = SURFACE_REFINE_CELL_M,
+    slope: float = SURFACE_REFINE_SLOPE,
+    window_m: float = SURFACE_REFINE_WINDOW_M,
+    threshold: float = SURFACE_REFINE_THRESHOLD_M,
+    scalar: float = SURFACE_REFINE_SCALAR,
+    low_slope: float = SURFACE_REFINE_LOW_SLOPE,
+) -> np.ndarray:
+    """필터 지면 마스크를 다듬어 돌려줌 — 지면이던 점만 지면으로 남음(늘지 않음)."""
+    mask = np.asarray(mask, dtype=bool)
+    index = np.flatnonzero(mask)
+    refined = np.zeros(mask.shape, dtype=bool)
+    if index.size < 3:
+        refined[index] = True
+        return refined
+    points = np.asarray(xyz[index], dtype=np.float64)
+    fx = (points[:, 0] - points[:, 0].min()) / cell
+    fy = (points[:, 1] - points[:, 1].min()) / cell
+    gx = fx.astype(np.int64)
+    gy = fy.astype(np.int64)
+    shape = (int(gy.max()) + 1, int(gx.max()) + 1)
+    zmin = np.full(shape, np.inf)
+    np.minimum.at(zmin, (gy, gx), points[:, 2])
+    empty = ~np.isfinite(zmin)
+    filled = _fill_nearest(np.where(empty, 0.0, zmin), empty)
+
+    # ① 낮은 잡점 — 뒤집은 면에서 한 칸 창 열림이 문턱 넘게 깎는 칸(PDAL 기본 기울기 5)
+    low = _progressive(-filled, cell, low_slope, 1) & ~empty
+    surface = _fill_nearest(filled, empty | low)
+    # ② 물체 — 창을 최대 반지름까지 키우며
+    objects = _progressive(surface, cell, slope, max(1, int(round(window_m / cell))))
+    # ③ 임시 지면 · 그 자리 기울기(rise / run)
+    provisional = _inpaint(filled, ~empty & ~low & ~objects)
+    grad_y, grad_x = np.gradient(provisional, cell)
+    gradient = np.hypot(grad_x, grad_y)
+    # ④ 점마다 판정 — 칸 가운데 기준 쌍선형
+    coords = [fy - 0.5, fx - 0.5]
+    ground_z = ndimage.map_coordinates(provisional, coords, order=1, mode="nearest")
+    local_slope = ndimage.map_coordinates(gradient, coords, order=1, mode="nearest")
+    keep = np.abs(points[:, 2] - ground_z) <= threshold + scalar * local_slope
+    refined[index[keep]] = True
+    return refined

B04_PreProcess/B04_PreProcess_Engine_Ground.py

@@ -1,35 +1,44 @@
 """B04 지면 필터 오케스트레이션.
 
-구조화된 포인트클라우드(structured.npz)에 대해 grid_min_z/csf/pmf/ransac
+구조화된 포인트클라우드(structured.npz)에 대해 ptd(점진 TIN)/classification(업체 분류)
+(+ `_refine` 다듬기 판)
 필터를 실행하여 지면 마스크 딕셔너리를 만든다. 필터 선택은 config의
 source_filters를 따른다.
 """
 
+from pathlib import Path
 from typing import Any
 
 import numpy as np
 
 from B04_PreProcess.B04_PreProcess_Engine_Filter_Classification import (
     filter_classification,
+    has_classified_coverage,
     has_classified_ground,
 )
-from B04_PreProcess.B04_PreProcess_Engine_Filter_CSF import filter_csf
-from B04_PreProcess.B04_PreProcess_Engine_Filter_Grid import filter_grid_min_z
-from B04_PreProcess.B04_PreProcess_Engine_Filter_PMF import filter_pmf
-from B04_PreProcess.B04_PreProcess_Engine_Filter_RANSAC import filter_ransac
+from B04_PreProcess.B04_PreProcess_Engine_Filter_PTD import filter_ptd
+from B04_PreProcess.B04_PreProcess_Engine_Filter_Refine import refine_ground_mask
 from config.config_system import SURFACE_AUTO_FALLBACK_FILTER
 
+# 다듬기 판(762) — `{기본 필터}_refine` = 기본 필터 지면점을 SMRF 꼴로 한 번 더 거름
+REFINE_SUFFIX = "_refine"
+_REFINABLE = ("classification", "ptd")
+
 # 필터 키 → 함수 매핑
 _FILTERS = {
-    "grid_min_z": filter_grid_min_z,
-    "csf": filter_csf,
-    "pmf": filter_pmf,
-    "ransac": filter_ransac,
+    "ptd": filter_ptd,
     "classification": filter_classification,
+    "classification_refine": lambda data: refine_ground_mask(
+        data["xyz"], filter_classification(data)
+    ),
+    "ptd_refine": lambda data: refine_ground_mask(data["xyz"], filter_ptd(data)),
 }
 
 # LAS에 지면분류가 실제로 들어 있을 때만 쓰는 필터 (미분류 LAS에서는 마스크가 빈다)
-_CONDITIONAL_FILTERS = {"classification": has_classified_ground}
+_CONDITIONAL_FILTERS = {
+    "classification": has_classified_ground,
+    "classification_refine": has_classified_ground,
+}
 
 
 def available_filters() -> tuple[str, ...]:
@@ -45,23 +54,40 @@ def usable_conditional_filters(
 
 def resolve_auto_source_filters(
     structured_data: dict[str, Any] | np.lib.npyio.NpzFile,
+    processed_dir: Path | None = None,
 ) -> list[str]:
     """자동 전처리가 만들 필터를 입력 LAS를 보고 정한다. 첫 항목이 기본 확정값이다.
 
     업체가 이미 지면을 분류해 놨으면 그것을 기본으로 쓴다 — 계산이 없고 품질도 가장
-    안정적이다. **csf는 분류가 있어도 함께 만든다** — csf 처리 결과를 눈으로 검증할 수
-    있어야 하기 때문이다 (2026-09-01 사용자 확정). 분류가 없으면 csf 하나만 남는다.
+    안정적이다. **ptd(점진 TIN)는 분류가 있어도 함께 만든다** — 내장 필터 결과를 눈으로
+    검증할 수 있어야 하기 때문이다 (2026-09-01 사용자 확정). 분류가 없으면 ptd 하나만 남는다.
+    둘 다 다듬기 판(`_refine`)으로 지음 — 업체 분류 + 다듬기 · 점진 TIN + 다듬기(요구 607).
+    「분류 있음」 = 비율 문턱 + 덮임(일부만 분류된 LAS 거름) — 자동 고름에만(요구 558).
     """
     usable = usable_conditional_filters(structured_data)
-    return [*usable[:1], SURFACE_AUTO_FALLBACK_FILTER]
+    if usable and not has_classified_coverage(structured_data, processed_dir):
+        usable = []
+    filters = [*usable[:1], SURFACE_AUTO_FALLBACK_FILTER]
+    # 다듬기 기본(요구 607) — 같은 기본 필터에 다듬기를 붙인 판을 지음(바탕 마스크도 저장)
+    return [f"{key}{REFINE_SUFFIX}" if key in _REFINABLE else key for key in filters]
+
+
+def base_filter(filter_key: str) -> str | None:
+    """다듬기 판이면 바탕 필터 이름 — 엔진이 바탕 마스크 저장본을 다시 쓰게."""
+    base = filter_key.removesuffix(REFINE_SUFFIX)
+    return base if base != filter_key and base in _REFINABLE else None
 
 
 def run_ground_filter(
-    filter_key: str, structured_data: dict[str, Any] | np.lib.npyio.NpzFile
+    filter_key: str,
+    structured_data: dict[str, Any] | np.lib.npyio.NpzFile,
+    base_mask: np.ndarray | None = None,
 ) -> np.ndarray:
-    """단일 지면 필터를 실행해 불리언 마스크를 반환한다."""
+    """단일 지면 필터를 실행해 불리언 마스크를 반환한다 — 다듬기 판은 `base_mask` 를 다듬음."""
     if filter_key not in _FILTERS:
         raise ValueError(f"알 수 없는 지면 필터입니다: {filter_key}")
+    if base_mask is not None and base_filter(filter_key):
+        return refine_ground_mask(structured_data["xyz"], base_mask)
     return np.asarray(_FILTERS[filter_key](structured_data), dtype=bool)
 
 

B04_PreProcess/B04_PreProcess_Engine_ModelBuild.py

@@ -1,15 +1,15 @@
-"""B04 지표면 5종 표현 빌더 (TIN/DTM/NURBS/implicit/meshfree).
+"""B04 지표면 표현 빌더 (DTM/implicit).
 
 TerrainContext에서 파생 격자·샘플을 받아 각 표현의 모델(npz)과 프리뷰
-(GLB/PLY)를 저장하고 메타데이터를 반환한다.
+(GLB)를 저장하고 메타데이터를 반환한다.
 """
 
+from contextlib import suppress
 from pathlib import Path
 from typing import Any
 
 import numpy as np
 from scipy.interpolate import RBFInterpolator
-from scipy.spatial import Delaunay
 
 from B04_PreProcess.B04_PreProcess_Engine_ModelContext import (
     ProgressCallback,
@@ -17,60 +17,12 @@ from B04_PreProcess.B04_PreProcess_Engine_ModelContext import (
     artifact_size,
     atomic_npz,
     clip_and_compact_mesh,
-    evaluate_nurbs_spline,
-    fit_nurbs_spline,
     grid_faces,
     grid_vertices,
     with_footprint,
-    write_binary_ply,
     write_glb,
 )
-
-
-def build_tin(
-    context: TerrainContext, output_dir: Path, stem: str, progress: ProgressCallback
-) -> dict[str, Any]:
-    progress(5)
-    points = context.sample(int(context.config["tin_max_input_points"]))
-    unique_xy, unique_indices = np.unique(points[:, :2], axis=0, return_index=True)
-    points = points[unique_indices]
-    if len(points) < 3:
-        raise ValueError("TIN 생성에 필요한 포인트가 부족합니다.")
-    progress(25)
-    faces = np.asarray(Delaunay(unique_xy).simplices, dtype=np.uint32)
-    if len(faces):
-        triangle_xy = points[faces, :2]
-        edges = np.stack(
-            [
-                np.linalg.norm(triangle_xy[:, 0] - triangle_xy[:, 1], axis=1),
-                np.linalg.norm(triangle_xy[:, 1] - triangle_xy[:, 2], axis=1),
-                np.linalg.norm(triangle_xy[:, 2] - triangle_xy[:, 0], axis=1),
-            ],
-            axis=1,
-        )
-        faces = faces[np.max(edges, axis=1) <= float(context.config["tile_size_meters"]) * 2]
-    valid_vertices = context.contains_xy(points[:, 0], points[:, 1])
-    points, faces = clip_and_compact_mesh(points, faces, valid_vertices)
-    if not len(faces):
-        raise ValueError("외곽 안쪽 기준 적용 후 TIN 면이 남지 않았습니다.")
-    progress(65)
-    model_path = output_dir / f"{stem}.npz"
-    preview_path = output_dir / f"{stem}_preview.glb"
-    atomic_npz(model_path, vertices=points, faces=faces)
-    write_glb(preview_path, points, faces, context.bounds)
-    progress(100)
-    return with_footprint(
-        context,
-        {
-            "representation": "triangular_mesh",
-            "model_file": model_path.name,
-            "preview_file": preview_path.name,
-            "preview_media_type": "model/gltf-binary",
-            "vertex_count": int(len(points)),
-            "face_count": int(len(faces)),
-            "artifact_bytes": artifact_size(model_path, preview_path),
-        },
-    )
+from common_util.common_util_surface_sampler import implicit_grid_npz
 
 
 def build_dtm(
@@ -96,6 +48,7 @@ def build_dtm(
         y=y_coords,
         z=z_grid,
         valid_mask=valid_grid,
+        filled_mask=context.filled(resolution) & valid_grid,
         resolution=np.array([resolution], np.float32),
     )
     progress(75)
@@ -118,61 +71,21 @@ def build_dtm(
     )
 
 
-def build_nurbs(
-    context: TerrainContext, output_dir: Path, stem: str, progress: ProgressCallback
-) -> dict[str, Any]:
-    degree = max(1, min(5, int(context.config["nurbs_degree"])))
-    patch_size = float(context.config["nurbs_patch_size_meters"])
-    controls = max(degree + 1, int(context.config["nurbs_control_points_per_axis"]))
-    control_resolution = max(patch_size / max(controls - 1, 1), 0.25)
-    x_control, y_control, z_control = context.grid(control_resolution)
-    progress(30)
-    spline, z_range = fit_nurbs_spline(x_control, y_control, z_control, degree)
-    x_preview, y_preview, _ = context.preview_grid(
-        float(context.config["dtm_grid_resolution_meters"])
-    )
-    z_preview = evaluate_nurbs_spline(spline, y_preview, x_preview, z_range, stem).astype(
-        np.float32
-    )
-    progress(65)
-    vertices = grid_vertices(x_preview, y_preview, z_preview)
-    faces = grid_faces(len(y_preview), len(x_preview))
-    valid_preview = context.contains_xy(vertices[:, 0], vertices[:, 1])
-    vertices, faces = clip_and_compact_mesh(vertices, faces, valid_preview)
-    model_path = output_dir / f"{stem}.npz"
-    preview_path = output_dir / f"{stem}_preview.glb"
-    atomic_npz(
-        model_path,
-        control_x=x_control,
-        control_y=y_control,
-        control_z=z_control,
-        degree=np.array([degree], np.int16),
-        patch_size_meters=np.array([patch_size], np.float32),
-    )
-    write_glb(preview_path, vertices, faces, context.bounds)
-    progress(100)
-    return with_footprint(
-        context,
-        {
-            "representation": "bspline_surface",
-            "model_file": model_path.name,
-            "preview_file": preview_path.name,
-            "preview_media_type": "model/gltf-binary",
-            "degree": degree,
-            "control_rows": int(len(y_control)),
-            "control_columns": int(len(x_control)),
-            "vertex_count": int(len(vertices)),
-            "face_count": int(len(faces)),
-            "artifact_bytes": artifact_size(model_path, preview_path),
-        },
-    )
+def implicit_point_count(ground_count: int, config: dict[str, Any]) -> int:
+    """implicit 중심점 수 = clip(지면점 × 비율, 하한, 상한) · 지면점이 하한보다 적으면 전부."""
+    minimum = int(config["implicit_min_points"])
+    if ground_count <= minimum:
+        return int(ground_count)
+    ratio = round(ground_count * float(config["implicit_point_ratio"]))
+    return int(min(max(ratio, minimum), int(config["implicit_max_points"])))
 
 
 def build_implicit(
     context: TerrainContext, output_dir: Path, stem: str, progress: ProgressCallback
 ) -> dict[str, Any]:
-    maximum = max(100, int(context.config["implicit_max_points_per_tile"]))
-    points = context.sample(maximum)
+    count = implicit_point_count(context.source_count, context.config)
+    # 구멍(766-2)은 메운 dtm 칸을 중심점으로 더해 dtm 과 같은 면으로 이음
+    points = np.concatenate([context.grid_sample(count), context.hole_guides()])
     unique_xy, unique_indices = np.unique(points[:, :2], axis=0, return_index=True)
     points = points[unique_indices]
     if len(points) < 4:
@@ -209,6 +122,8 @@ def build_implicit(
         smoothing=np.array([float(context.config["implicit_smoothing"])], np.float32),
     )
     write_glb(preview_path, vertices, faces, context.bounds)
+    with suppress(OSError, ValueError):  # 641-1 굳힌 격자 — 못 지으면 처음 읽을 때 지음
+        implicit_grid_npz(output_dir, stem.removeprefix("implicit_"))
     progress(100)
     return with_footprint(
         context,
@@ -225,57 +140,7 @@ def build_implicit(
     )
 
 
-def build_meshfree(
-    context: TerrainContext, output_dir: Path, stem: str, progress: ProgressCallback
-) -> dict[str, Any]:
-    points = context.sample(int(context.config["meshfree_max_model_points"]))
-    points = points[context.contains_xy(points[:, 0], points[:, 1])]
-    if not len(points):
-        raise ValueError("외곽 안쪽 기준 적용 후 Meshfree 포인트가 남지 않았습니다.")
-    resolution = float(context.config["dtm_grid_resolution_meters"])
-    x_grid, y_grid, z_grid = context.grid(resolution)
-    dz_dy, dz_dx = np.gradient(z_grid, resolution, resolution)
-    gx = np.clip(np.searchsorted(x_grid, points[:, 0]), 0, len(x_grid) - 1)
-    gy = np.clip(np.searchsorted(y_grid, points[:, 1]), 0, len(y_grid) - 1)
-    normals = np.column_stack([-dz_dx[gy, gx], -dz_dy[gy, gx], np.ones(len(points), np.float32)])
-    normals /= np.maximum(np.linalg.norm(normals, axis=1, keepdims=True), 1e-9)
-    progress(55)
-    preview_max = int(context.config["max_preview_vertices"])
-    if len(points) > preview_max:
-        selection = np.linspace(0, len(points) - 1, preview_max, dtype=np.int64)
-        preview_points, preview_normals = points[selection], normals[selection]
-    else:
-        preview_points, preview_normals = points, normals
-    model_path = output_dir / f"{stem}.npz"
-    preview_path = output_dir / f"{stem}_preview.ply"
-    radius = float(context.config["meshfree_point_radius_meters"])
-    atomic_npz(
-        model_path,
-        points=points,
-        normals=normals.astype(np.float32),
-        radius=np.array([radius], np.float32),
-    )
-    write_binary_ply(preview_path, preview_points, preview_normals, context.bounds)
-    progress(100)
-    return with_footprint(
-        context,
-        {
-            "representation": "meshfree_surfels",
-            "model_file": model_path.name,
-            "preview_file": preview_path.name,
-            "preview_media_type": "application/octet-stream",
-            "point_count": int(len(points)),
-            "preview_point_count": int(len(preview_points)),
-            "point_radius_meters": radius,
-            "artifact_bytes": artifact_size(model_path, preview_path),
-        },
-    )
-
-
 BUILDERS = {
-    "tin": build_tin,
     "dtm": build_dtm,
-    "nurbs": build_nurbs,
     "implicit": build_implicit,
-    "meshfree": build_meshfree,
 }

B04_PreProcess/B04_PreProcess_Engine_ModelContext.py

@@ -1,91 +1,34 @@
 """B04 지표면 모델 공통 컨텍스트 및 메시 유틸리티.
 
 지면 마스크가 적용된 포인트에서 footprint(외곽), 격자, 프리뷰 격자를 만들고,
-GLB/PLY 프리뷰 및 npz 모델을 원자적으로 저장하는 공통 기능을 제공한다.
-5개 표현(TIN/DTM/NURBS/implicit/meshfree) 빌더가 이 컨텍스트를 공유한다.
+GLB 프리뷰 및 npz 모델을 원자적으로 저장하는 공통 기능을 제공한다.
+표현(DTM/implicit) 빌더가 이 컨텍스트를 공유한다.
 """
 
 import hashlib
 import json
 import logging
 import math
-from dataclasses import dataclass, field
+from dataclasses import dataclass, field, replace
 from pathlib import Path
 from typing import Any, Callable
 
 import numpy as np
 import trimesh
 from scipy import ndimage
-from scipy.interpolate import RectBivariateSpline
+from skimage.restoration import inpaint_biharmonic
 
 from common_util.common_util_atomic import atomic_write_bytes, atomic_write_npz
 
 logger = logging.getLogger(__name__)
 
 MODEL_VERSION = 1
-MODEL_METHODS = ("tin", "dtm", "nurbs", "implicit", "meshfree")
-SOURCE_FILTER_LABELS = {"grid_min_z": "Grid Min-Z", "csf": "CSF", "pmf": "PMF"}
 ProgressCallback = Callable[[int], None]
 
 # 대용량 포인트 배치 처리 크기
 _BATCH_SIZE = 500_000
-
-# NURBS 평활 계수 — 제어점당 허용 잔차제곱(m²).
-# 0.01(RMS 0.1m)은 요구가 너무 빡빡해 FITPACK이 제어점 수(122x113)보다 많은
-# knot(126x117)을 밀어넣고 계수가 발산했다 — csf 표고 1e105, grid_min_z 1e10
-# (2026-08-17 실측). 1.0(RMS 1m)이면 knot이 17~35로 떨어지고 세 지면 필터 모두
-# 데이터 표고 범위 안에 머문다. NURBS는 평활 곡면 표현이라 이 정도 완화가 맞다.
-NURBS_RESIDUAL_PER_CONTROL_POINT = 1.0
-
-
-def fit_nurbs_spline(
-    x_control: np.ndarray, y_control: np.ndarray, z_control: np.ndarray, degree: int
-) -> tuple[RectBivariateSpline, tuple[float, float]]:
-    """제어 격자에 B-spline 곡면을 맞추고, 발산 판정용 표고 허용 범위를 함께 준다.
-
-    모델 빌더와 등고선 엔진이 같은 곡면을 각각 만들므로 여기서 한 번에 정의한다.
-    """
-    spline = RectBivariateSpline(
-        y_control,
-        x_control,
-        z_control,
-        kx=min(degree, len(y_control) - 1),
-        ky=min(degree, len(x_control) - 1),
-        s=float(len(x_control) * len(y_control)) * NURBS_RESIDUAL_PER_CONTROL_POINT,
-    )
-    z_min = float(np.min(z_control))
-    z_max = float(np.max(z_control))
-    margin = max((z_max - z_min) * 0.5, 1.0)
-    return spline, (z_min - margin, z_max + margin)
-
-
-def evaluate_nurbs_spline(
-    spline: RectBivariateSpline,
-    y_coords: np.ndarray,
-    x_coords: np.ndarray,
-    z_range: tuple[float, float],
-    label: str = "",
-) -> np.ndarray:
-    """스플라인을 평가하고 표고 허용 범위를 벗어난 값을 잘라낸다.
-
-    평활 스플라인은 제어점이 성긴 구석에서 발산할 수 있다. 그대로 두면 float32
-    캐스팅에서 inf가 되고 프리뷰 색상(nan)과 등고선 레벨 산출(`np.arange`가
-    "Maximum allowed size exceeded"로 실패)까지 번진다.
-    """
-    z_values = np.asarray(spline(y_coords, x_coords), dtype=np.float64)
-    low, high = z_range
-    outside = np.count_nonzero(~np.isfinite(z_values) | (z_values < low) | (z_values > high))
-    if outside:
-        logger.warning(
-            "NURBS 곡면이 표고 범위를 벗어나 잘라냈습니다: %s%d개 셀 (허용 %.1f~%.1fm)",
-            f"{label} " if label else "",
-            int(outside),
-            low,
-            high,
-        )
-    z_values = np.nan_to_num(z_values, nan=low, posinf=high, neginf=low)
-    return np.clip(z_values, low, high)
-
+# implicit 격자 칸 뽑기 씨앗 — 고정이라 다시 지어도 같은 중심점
+IMPLICIT_SAMPLE_SEED = 558
 
 # 서명에서 빼는 키 — 지오메트리를 만드는 방법이 아니라 "무엇을 만들지"를 고르는 값들.
 # source_filters·precompute를 넣으면 조합을 바꿀 때마다 manifest가 통째로 폐기돼
@@ -152,44 +95,6 @@ def write_glb(path: Path, vertices: np.ndarray, faces: np.ndarray, bounds: np.nd
     atomic_write_bytes(path, payload)
 
 
-def write_binary_ply(
-    path: Path, vertices: np.ndarray, normals: np.ndarray, bounds: np.ndarray
-) -> None:
-    verts = scene_vertices(vertices, bounds)
-    scene_normals = np.empty_like(normals, dtype=np.float32)
-    scene_normals[:, 0] = normals[:, 0]
-    scene_normals[:, 1] = normals[:, 2]
-    scene_normals[:, 2] = -normals[:, 1]
-    colors = height_colors(vertices)
-    dtype = np.dtype(
-        [
-            ("x", "<f4"),
-            ("y", "<f4"),
-            ("z", "<f4"),
-            ("nx", "<f4"),
-            ("ny", "<f4"),
-            ("nz", "<f4"),
-            ("red", "u1"),
-            ("green", "u1"),
-            ("blue", "u1"),
-            ("alpha", "u1"),
-        ]
-    )
-    records = np.empty(len(vertices), dtype=dtype)
-    records["x"], records["y"], records["z"] = verts.T
-    records["nx"], records["ny"], records["nz"] = scene_normals.T
-    records["red"], records["green"], records["blue"], records["alpha"] = colors.T
-    header = (
-        "ply\nformat binary_little_endian 1.0\n"
-        f"element vertex {len(vertices)}\n"
-        "property float x\nproperty float y\nproperty float z\n"
-        "property float nx\nproperty float ny\nproperty float nz\n"
-        "property uchar red\nproperty uchar green\nproperty uchar blue\nproperty uchar alpha\n"
-        "end_header\n"
-    ).encode("ascii")
-    atomic_write_bytes(path, header + records.tobytes())
-
-
 def grid_faces(rows: int, cols: int) -> np.ndarray:
     """정규 격자의 삼각형 면 인덱스를 만든다."""
     if rows < 2 or cols < 2:
@@ -219,6 +124,29 @@ def clip_and_compact_mesh(
     return vertices[used], remap[kept_faces].astype(np.uint32)
 
 
+def fill_holes_smooth(
+    z: np.ndarray, known: np.ndarray, inside: np.ndarray, min_gap_cells: float
+) -> np.ndarray:
+    """외곽 안 큰 구멍을 둘레 지면에서 매끈하게(쌍조화 · 판 굽힘) 이어 메움(766-2).
+
+    구멍 = 땅 칸에서 `min_gap_cells` 넘게 떨어진 칸 + 그 둘레 `min_gap_cells` 안 빈 칸(외곽 안) ·
+    작은 틈은 지금처럼 가까운 칸 값 · 둘레 높이 · 기울기를 이어 받음(평면 · 곡면 비탈 그대로) ·
+    외곽 밖 이웃도 같이 풀어 가까운 칸 값에 끌리지 않게 함.
+    돌려줌 = 땅 칸에서 `min_gap_cells` 넘게 먼 메운 칸(메운 넓이 지표 · implicit 길잡이).
+    """
+    gap = ~known & inside
+    far = (ndimage.distance_transform_edt(~known) > min_gap_cells) & gap
+    if not far.any():
+        return far
+    square = np.ones((3, 3), dtype=bool)
+    reach = max(1, int(math.ceil(min_gap_cells)))
+    solve = ndimage.binary_dilation(far, square, iterations=reach) & gap
+    free = solve | (ndimage.binary_dilation(solve, square, iterations=reach) & ~inside & ~known)
+    # 라플라스(막 펴기)는 홀로 남은 땅 점마다 고깔이 생겨 튐이 늘어 버림(용화 실측)
+    z[free] = inpaint_biharmonic(z.astype(np.float64), free)[free]
+    return far
+
+
 def grid_vertices(x_coords: np.ndarray, y_coords: np.ndarray, z_grid: np.ndarray) -> np.ndarray:
     xx, yy = np.meshgrid(x_coords, y_coords)
     return np.column_stack([xx.ravel(), yy.ravel(), z_grid.ravel()]).astype(np.float32)
@@ -236,10 +164,13 @@ class TerrainContext:
     mask: np.ndarray
     bounds: np.ndarray
     config: dict[str, Any]
+    # 외곽을 그릴 지면점(다듬기 판 = 바탕 필터 마스크) — 다듬기가 지운 자리는 외곽 안 구멍으로 메움
+    outer_mask: np.ndarray | None = None
     _indices: np.ndarray | None = None
     _samples: dict[int, np.ndarray] = field(default_factory=dict)
     _grids: dict[float, tuple[np.ndarray, np.ndarray, np.ndarray]] = field(default_factory=dict)
     _footprint: tuple[float, float, float, np.ndarray] | None = None
+    _filled: dict[float, np.ndarray] = field(default_factory=dict)
 
     @property
     def source_count(self) -> int:
@@ -262,6 +193,36 @@ class TerrainContext:
         self._samples[maximum] = points
         return points
 
+    def grid_sample(self, count: int, seed: int = IMPLICIT_SAMPLE_SEED) -> np.ndarray:
+        """implicit 전용 — 격자 칸(√(외곽 넓이 / 점 수))마다 하나 · 모자라면 무작위로 채움.
+
+        파일 차례 뽑기는 점 많은 트인 곳에 몰려 숲 밑 성긴 곳이 빔(요구 558). 씨앗 고정.
+        """
+        indices = self.indices()
+        if len(indices) <= count:
+            return np.asarray(self.xyz[indices], dtype=np.float32)
+        # 칸 = 이 필터 자기 외곽 넓이 기준 — 바탕 외곽(766-2)으로 넓혀도 원래 자리 중심점 그대로
+        own = (
+            self
+            if self.outer_mask is None
+            else replace(self, outer_mask=None, _footprint=None, _grids={}, _filled={})
+        )
+        _, _, resolution, footprint = own.footprint()
+        cell = max(math.sqrt(float(footprint.sum()) * resolution * resolution / count), 0.01)
+        xy = np.asarray(self.xyz[indices][:, :2], dtype=np.float64)
+        rng = np.random.default_rng(seed)
+        order = rng.permutation(len(indices))
+        gx = ((xy[order, 0] - self.bounds[0, 0]) // cell).astype(np.int64)
+        gy = ((xy[order, 1] - self.bounds[1, 0]) // cell).astype(np.int64)
+        _, first = np.unique(gy * (int(gx.max()) + 1) + gx, return_index=True)
+        chosen = order[first]
+        if len(chosen) > count:
+            chosen = rng.choice(chosen, count, replace=False)
+        elif len(chosen) < count:
+            rest = np.setdiff1d(np.arange(len(indices)), chosen, assume_unique=True)
+            chosen = np.concatenate([chosen, rng.choice(rest, count - len(chosen), replace=False)])
+        return np.asarray(self.xyz[indices[np.sort(chosen)]], dtype=np.float32)
+
     def footprint(self) -> tuple[float, float, float, np.ndarray]:
         if self._footprint is not None:
             return self._footprint
@@ -271,7 +232,7 @@ class TerrainContext:
         cols = max(2, int(math.ceil((x_max - x_min) / resolution)) + 1)
         rows = max(2, int(math.ceil((y_max - y_min) / resolution)) + 1)
         occupied = np.zeros((rows, cols), dtype=bool)
-        indices = self.indices()
+        indices = self.indices() if self.outer_mask is None else np.flatnonzero(self.outer_mask)
         for start in range(0, len(indices), _BATCH_SIZE):
             points = np.asarray(self.xyz[indices[start : start + _BATCH_SIZE]], dtype=np.float32)
             gx = np.clip(((points[:, 0] - x_min) / resolution).astype(np.int32), 0, cols - 1)
@@ -359,10 +320,32 @@ class TerrainContext:
             grid = grid[tuple(nearest)]
         x_coords = np.linspace(x_min, x_max, cols, dtype=np.float32)
         y_coords = np.linspace(y_min, y_max, rows, dtype=np.float32)
+        inside = self.contains_xy(*np.meshgrid(x_coords, y_coords)).reshape(rows, cols)
+        gap_cells = float(self.config.get("footprint_gap_close_meters", 1.0)) / resolution
+        self._filled[resolution] = fill_holes_smooth(grid, ~missing, inside, gap_cells)
         result = (x_coords, y_coords, grid)
         self._grids[resolution] = result
         return result
 
+    def filled(self, resolution: float) -> np.ndarray:
+        """`grid(resolution)` 가 막 펴기로 메운 칸(766-2)."""
+        self.grid(resolution)
+        return self._filled[max(float(resolution), 0.05)]
+
+    def hole_guides(self) -> np.ndarray:
+        """implicit 이 구멍도 같은 면으로 잇게 — 메운 dtm 칸을 틈 닫기 간격마다 하나씩 (N, 3)."""
+        resolution = float(self.config["dtm_grid_resolution_meters"])
+        x_coords, y_coords, z_grid = self.grid(resolution)
+        filled = self.filled(resolution)
+        spacing = float(self.config.get("footprint_gap_close_meters", 1.0))
+        step = max(1, int(round(spacing / resolution)))
+        lattice = np.zeros_like(filled)
+        lattice[::step, ::step] = True
+        rows, cols = np.nonzero(filled & lattice)
+        return np.column_stack([x_coords[cols], y_coords[rows], z_grid[rows, cols]]).astype(
+            np.float32
+        )
+
     def preview_grid(
         self, preferred_resolution: float
     ) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
@@ -377,6 +360,7 @@ class TerrainContext:
     def clear_caches(self) -> None:
         self._samples.clear()
         self._grids.clear()
+        self._filled.clear()
         self._indices = None
 
 

B04_PreProcess/B04_PreProcess_Engine_Pipeline.py

@@ -1,6 +1,6 @@
 """B04 지표면 모델 파이프라인 오케스트레이터.
 
-세 지면 필터(grid_min_z/csf/pmf)와 다섯 표현(TIN/DTM/NURBS/implicit/meshfree)의
+지면 필터(업체 분류 · 점진 TIN · 둘의 다듬기 판)와 표현(DTM/implicit)의
 캐시를 만들고 manifest.json을 관리한다. 캐시 유효성 검증, 스무딩/등고선 연동,
 동일 출력 폴더의 중복 실행 취소를 포함한다.
 """
@@ -16,8 +16,10 @@ import numpy as np
 
 from B04_PreProcess.B04_PreProcess_Engine_Contour import (
     CONTOUR_EXTRACTOR_VERSION,
+    contour_cache_is_stale,
     extract_contours,
 )
+from B04_PreProcess.B04_PreProcess_Engine_Ground import base_filter
 from B04_PreProcess.B04_PreProcess_Engine_ModelBuild import BUILDERS
 from B04_PreProcess.B04_PreProcess_Engine_ModelContext import (
     MODEL_VERSION,
@@ -25,6 +27,7 @@ from B04_PreProcess.B04_PreProcess_Engine_ModelContext import (
     bounds_dict,
     config_signature,
 )
+from B04_PreProcess.B04_PreProcess_Engine_Quality import quality_after_build
 from B04_PreProcess.B04_PreProcess_Engine_Smooth import (
     compute_smoothing_signature,
     run_smoothing,
@@ -85,10 +88,9 @@ def _cache_contours(
     smooth_model_path = output_dir / f"{stem}_smooth.npz"
     smooth_meta = metadata.get("smooth", {})
     if smooth_model_path.exists() and smooth_meta.get("status") == "completed":
-        smooth_rep = "regular_grid" if method == "dtm" else "triangular_mesh"
         smooth_contours = extract_contours(
             smooth_model_path,
-            representation=smooth_rep,
+            representation="regular_grid",
             interval=interval,
             target_grid_m=target_grid_m,
             scene_center=None,
@@ -140,10 +142,7 @@ def _cache_contours_safely(
 
 
 _REPRESENTATIONS = {
-    "meshfree": "meshfree_surfels",
     "dtm": "regular_grid",
-    "tin": "triangular_mesh",
-    "nurbs": "bspline_surface",
     "implicit": "local_rbf_height_field",
 }
 
@@ -151,14 +150,19 @@ _REPRESENTATIONS = {
 def _cache_is_valid(
     output_dir: Path, stem: str, method: str, entry: dict[str, Any], config: dict[str, Any]
 ) -> bool:
-    """디스크의 결과 파일과 스무딩 메타데이터가 유효한지 검사한다."""
-    ext = "ply" if method == "meshfree" else "glb"
-    files_exist = (output_dir / f"{stem}_preview.{ext}").exists() and (
+    """디스크의 결과 파일과 스무딩 메타데이터가 유효한지 검사한다.
+
+    manifest 항목이 완료여야 함 — 설정 지문이 바뀌면 manifest 가 비므로 파일만 남은
+    옛 결과(평활 없는 implicit)를 다시 짓는다(요구 558).
+    """
+    if entry.get("status") != "completed":
+        return False
+    files_exist = (output_dir / f"{stem}_preview.glb").exists() and (
         output_dir / f"{stem}.npz"
     ).exists()
     if not files_exist:
         return False
-    if method in config.get("smoothing_methods", ("dtm", "tin")):
+    if method in config.get("smoothing_methods", ("dtm",)):
         smooth_entry = entry.get("smooth", {})
         smooth_exist = (output_dir / f"{stem}_smooth.npz").exists() and (
             output_dir / f"{stem}_smooth_preview.glb"
@@ -181,15 +185,15 @@ def _build_all_terrain_models(
     force: bool = False,
     progress: ProgressReporter | None = None,
 ) -> dict[str, Any]:
-    """세 지면 필터와 다섯 표현의 캐시를 만들고 manifest를 반환한다."""
+    """지면 필터와 표현의 캐시를 만들고 manifest를 반환한다."""
     output_dir.mkdir(parents=True, exist_ok=True)
     manifest_path = output_dir / "manifest.json"
     filters = tuple(key for key in config["source_filters"] if key in ground_masks)
-    methods_list = [key for key in config["precompute"] if key in BUILDERS]
-    if "dtm" in methods_list:
-        methods_list.remove("dtm")
-        methods_list.insert(0, "dtm")
-    methods = tuple(methods_list)
+    # dtm 은 늘 맨 앞 — 같은 필터 외곽 · implicit 굳힌 격자 · 등고선 자르기의 바탕이라
+    # 어느 표현을 지어도 낡았으면(manifest 항목 없음 · 지문 다름) 같이 다시 지음(754-1).
+    methods = ("dtm", *(key for key in config["precompute"] if key in BUILDERS and key != "dtm"))
+    # 무거운 implicit 은 기본 필터(첫 필터)에만 — 둘째 필터엔 안 지음(요구 558).
+    later_methods = tuple(method for method in methods if method != "implicit")
     signature = config_signature(config)
     bounds = np.asarray(structured_data["bounds"], dtype=np.float64)
     xyz = structured_data["xyz"]
@@ -211,7 +215,7 @@ def _build_all_terrain_models(
     }
     started_at = time.monotonic()
     timeout = max(0, int(config.get("sync_timeout_seconds", 0)))
-    total_units = max(1, len(filters) * len(methods))
+    total_units = max(1, len(methods) + (len(filters) - 1) * len(later_methods))
     done_units = 0
     failures = 0
 
@@ -223,41 +227,29 @@ def _build_all_terrain_models(
         mask = np.asarray(ground_masks[filter_key], dtype=bool)
         if len(mask) != len(xyz):
             raise ValueError(f"{filter_key} 마스크 길이가 XYZ 데이터와 다릅니다.")
-        context = TerrainContext(xyz=xyz, mask=mask, bounds=bounds, config=config)
+        # 다듬기 판은 바탕 필터 지면점으로 외곽을 그림 — 다듬기가 지운 자리 = 외곽 안 구멍(766-2)
+        outer = ground_masks.get(base_filter(filter_key) or "")
+        context = TerrainContext(xyz=xyz, mask=mask, bounds=bounds, config=config, outer_mask=outer)
         filter_entry = manifest["source_filters"].setdefault(
             filter_key, {"source_point_count": context.source_count, "methods": {}}
         )
         filter_entry["source_point_count"] = context.source_count
 
-        for method in methods:
+        for method in later_methods if filter_index else methods:
             stem = f"{method}_{filter_key}"
             entry = filter_entry["methods"].get(method, {})
 
             if not force and _cache_is_valid(output_dir, stem, method, entry, config):
-                if entry.get("status") != "completed":
-                    entry.update(
-                        {
-                            "status": "completed",
-                            "representation": _REPRESENTATIONS[method],
-                            "model_file": f"{stem}.npz",
-                            "preview_file": f"{stem}_preview."
-                            + ("ply" if method == "meshfree" else "glb"),
-                            "preview_media_type": "application/octet-stream"
-                            if method == "meshfree"
-                            else "model/gltf-binary",
-                            "error": None,
-                        }
-                    )
-                    filter_entry["methods"][method] = entry
-                    _write_json_file(manifest_path, manifest)
                 interval = float(config.get("contour_interval_meters", 1.0))
                 contour_path = output_dir / f"contour_{filter_key}_{method}_{interval}m.json"
-                needs_contours = not contour_path.exists()
-                if method in config.get("smoothing_methods", ("dtm", "tin")):
+                needs_contours = contour_cache_is_stale(contour_path, output_dir / f"{stem}.npz")
+                if method in config.get("smoothing_methods", ("dtm",)):
                     smooth_contour_path = (
                         output_dir / f"contour_{filter_key}_{method}_smooth_{interval}m.json"
                     )
-                    needs_contours = needs_contours or not smooth_contour_path.exists()
+                    needs_contours = needs_contours or contour_cache_is_stale(
+                        smooth_contour_path, output_dir / f"{stem}_smooth.npz"
+                    )
                 if needs_contours:
                     _cache_contours_safely(
                         output_dir,
@@ -269,6 +261,7 @@ def _build_all_terrain_models(
                         manifest.get("bounds", {}),
                         entry,
                     )
+                quality_after_build(output_dir, filter_key, method, context, fresh=False)
                 done_units += 1
                 _report(f"{filter_key}-{method} 캐시 재사용")
                 continue
@@ -304,7 +297,7 @@ def _build_all_terrain_models(
                         "error": None,
                     }
                 )
-                if method in config.get("smoothing_methods", ("dtm", "tin")):
+                if method in config.get("smoothing_methods", ("dtm",)):
                     original_model_path = output_dir / f"{stem}.npz"
                     if original_model_path.exists():
                         try:
@@ -327,6 +320,7 @@ def _build_all_terrain_models(
                     manifest.get("bounds", {}),
                     metadata,
                 )
+                quality_after_build(output_dir, filter_key, method, context, fresh=True)
             except Exception as exc:
                 failures += 1
                 filter_entry["methods"][method] = {

B04_PreProcess/B04_PreProcess_Engine_Quality.py

@@ -0,0 +1,226 @@
+"""B04 서피스 품질 지표 넷 — 기준 없이 재는 값(762-2 · _분석_599 정의 · _분석_601-1 3-3).
+
+① 튐 넓이 % — 5 × 5 칸 중간값 대비 0.5 m 넘는 칸(8 방향 묶음 = 곳 수)
+② 1 m 등고선 꺾임 /km — 2 m 마다 다시 찍어 30° 넘게 꺾인 곳
+③ 땅 점 빈 곳 % — 2 m 안 지면점 없는 칸 · 그중 기울기 > 15° 칸
+④ 필터 차 % — 같은 표현 · 짝 필터 모델과 |차| > 0.5 m 넓이
+⑤ 메운 넓이 m² · % — 외곽 안 구멍을 막 펴기로 메운 칸(766-2 · 같은 필터 dtm `filled_mask`)
+저장 = `models/quality_{필터}_{표현}.json`(파생 저장본 — 모델 · 짝 모델 지문이 다를 때만 다시 셈).
+"""
+
+import json
+import logging
+from pathlib import Path
+from typing import Any
+
+import numpy as np
+from scipy import ndimage
+from skimage.measure import find_contours
+
+from common_util.common_util_derived_store import file_stamp
+from common_util.common_util_json import atomic_write_json
+
+logger = logging.getLogger(__name__)
+
+QUALITY_VERSION = 2
+SPIKE_M = 0.5
+SPIKE_WINDOW = 5
+CONTOUR_INTERVAL_M = 1.0
+KINK_STEP_M = 2.0
+KINK_DEG = 30.0
+GAP_M = 2.0
+GAP_STEEP_DEG = 15.0
+DIFF_M = 0.5
+GRID_METHODS = ("dtm", "implicit")
+# 필터 차 짝 — 업체 분류 ↔ 점진 TIN(다듬기 판끼리) · 없으면 다듬기 전 ↔ 뒤
+_PAIRS = {
+    "classification": ("ptd", "classification_refine"),
+    "ptd": ("classification", "ptd_refine"),
+    "classification_refine": ("ptd_refine", "classification"),
+    "ptd_refine": ("classification_refine", "ptd"),
+}
+
+
+def _grid_path(models_dir: Path, filter_key: str, method: str) -> Path:
+    suffix = "_grid" if method == "implicit" else ""
+    return models_dir / f"{method}_{filter_key}{suffix}.npz"
+
+
+def _load_grid(path: Path) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
+    with np.load(path) as data:
+        z = np.asarray(data["z"], dtype=np.float64)
+        valid = np.asarray(data["valid_mask"], dtype=bool) & np.isfinite(z)
+        cell = float(np.asarray(data["resolution"]).ravel()[0]) if "resolution" in data else 1.0
+    return np.where(valid, z, 0.0), valid, np.asarray(cell)
+
+
+def spike_stats(z: np.ndarray, valid: np.ndarray) -> dict[str, Any]:
+    residual = z - ndimage.median_filter(z, size=SPIKE_WINDOW, mode="nearest")
+    inner = ndimage.binary_erosion(valid, iterations=SPIKE_WINDOW // 2)
+    spike = (np.abs(residual) > SPIKE_M) & inner
+    _, count = ndimage.label(spike, structure=np.ones((3, 3), dtype=bool))
+    area = int(inner.sum())
+    return {
+        "spike_pct": round(100.0 * int(spike.sum()) / area, 2) if area else None,
+        "spike_count": int(count),
+    }
+
+
+def contour_kinks(z: np.ndarray, valid: np.ndarray, cell: float) -> dict[str, Any]:
+    if not valid.any():
+        return {"contour_km": 0.0, "kinks_per_km": None, "bubbles": 0}
+    low, high = float(z[valid].min()), float(z[valid].max())
+    total, kinks, bubbles = 0.0, 0, 0
+    step = KINK_STEP_M / cell
+    for level in np.arange(np.ceil(low / CONTOUR_INTERVAL_M) * CONTOUR_INTERVAL_M, high, 1.0):
+        for line in find_contours(z, level, mask=valid):
+            seg = np.hypot(*np.diff(line, axis=0).T)
+            length = float(seg.sum())
+            if length < step * 2:
+                continue
+            total += length
+            if np.allclose(line[0], line[-1]) and length * cell < 30.0:
+                bubbles += 1
+            along = np.r_[0.0, np.cumsum(seg)]
+            t = np.arange(0.0, length, step)
+            rows, cols = np.interp(t, along, line[:, 0]), np.interp(t, along, line[:, 1])
+            angle = np.arctan2(np.diff(rows), np.diff(cols))
+            turn = np.abs((np.diff(angle) + np.pi) % (2 * np.pi) - np.pi)
+            kinks += int((np.degrees(turn) > KINK_DEG).sum())
+    km = total * cell / 1000.0
+    return {
+        "contour_km": round(km, 2),
+        "kinks_per_km": round(kinks / km, 1) if km else None,
+        "bubbles": bubbles,
+    }
+
+
+def gap_stats(
+    z: np.ndarray, valid: np.ndarray, occupied: np.ndarray, cell: float
+) -> dict[str, Any]:
+    gap = (ndimage.distance_transform_edt(~occupied) * cell > GAP_M) & valid
+    grad_y, grad_x = np.gradient(z, cell)
+    steep = np.degrees(np.arctan(np.hypot(grad_x, grad_y))) > GAP_STEEP_DEG
+    area = int(valid.sum())
+    return {
+        "gap_pct": round(100.0 * int(gap.sum()) / area, 2) if area else None,
+        "gap_steep_pct": round(100.0 * int((gap & steep).sum()) / area, 2) if area else None,
+    }
+
+
+def ground_occupancy(xyz: Any, indices: np.ndarray, bounds: np.ndarray, shape: tuple) -> np.ndarray:
+    """지면점이 하나라도 든 칸 — dtm 격자와 같은 칸 나눔(`TerrainContext.grid`)."""
+    rows, cols = shape
+    cell_x = (bounds[0, 1] - bounds[0, 0]) / max(cols - 1, 1)
+    cell_y = (bounds[1, 1] - bounds[1, 0]) / max(rows - 1, 1)
+    occupied = np.zeros(shape, dtype=bool)
+    for start in range(0, len(indices), 2_000_000):
+        points = np.asarray(xyz[indices[start : start + 2_000_000]], dtype=np.float64)
+        gx = np.clip(((points[:, 0] - bounds[0, 0]) / cell_x).astype(np.int64), 0, cols - 1)
+        gy = np.clip(((points[:, 1] - bounds[1, 0]) / cell_y).astype(np.int64), 0, rows - 1)
+        occupied[gy, gx] = True
+    return occupied
+
+
+def diff_pct(z: np.ndarray, valid: np.ndarray, other_path: Path) -> float | None:
+    other_z, other_valid, _ = _load_grid(other_path)
+    if other_z.shape != z.shape:
+        return None
+    both = valid & other_valid
+    area = int(both.sum())
+    if not area:
+        return None
+    return round(100.0 * int(((np.abs(z - other_z) > DIFF_M) & both).sum()) / area, 2)
+
+
+def filled_stats(
+    models_dir: Path, filter_key: str, valid: np.ndarray, cell: float
+) -> dict[str, Any]:
+    with np.load(models_dir / f"dtm_{filter_key}.npz") as data:
+        filled = np.asarray(data["filled_mask"], dtype=bool) if "filled_mask" in data else None
+    if filled is None or filled.shape != valid.shape:
+        return {"filled_m2": None, "filled_pct": None}
+    count, area = int((filled & valid).sum()), int(valid.sum())
+    return {
+        "filled_m2": round(count * cell * cell, 1),
+        "filled_pct": round(100.0 * count / area, 2) if area else None,
+    }
+
+
+def _pair(models_dir: Path, filter_key: str, method: str) -> Path | None:
+    for other in _PAIRS.get(filter_key, ()):
+        path = _grid_path(models_dir, other, method)
+        if path.is_file():
+            return path
+    return None
+
+
+def ensure_quality(
+    models_dir: Path,
+    filter_key: str,
+    method: str,
+    occupied: np.ndarray | None = None,
+) -> dict[str, Any] | None:
+    """지표 넷을 돌려줌 — 저장본 지문이 맞으면 그대로 · ③ 은 지을 때 넘긴 지면점 칸만."""
+    if method not in GRID_METHODS:
+        return None
+    grid_path = _grid_path(models_dir, filter_key, method)
+    if not grid_path.is_file():
+        return None
+    pair = _pair(models_dir, filter_key, method)
+    key = {
+        "version": QUALITY_VERSION,
+        "model": file_stamp(grid_path),
+        "pair": [pair.name, file_stamp(pair)] if pair else None,
+    }
+    path = models_dir / f"quality_{filter_key}_{method}.json"
+    try:
+        stored = json.loads(path.read_text(encoding="utf-8"))
+    except (OSError, ValueError):
+        stored = {}
+    if stored.get("key") == key and occupied is None:
+        return stored
+    z, valid, cell = _load_grid(grid_path)
+    cell = float(cell)
+    same_model = (stored.get("key") or {}).get("model") == key["model"]
+    result: dict[str, Any] = {"key": key, "filter": filter_key, "method": method}
+    if same_model and occupied is None:
+        result.update({k: stored.get(k) for k in ("spike_pct", "spike_count", "contour_km")})
+        result.update({k: stored.get(k) for k in ("kinks_per_km", "bubbles")})
+    else:
+        result.update(spike_stats(z, valid))
+        result.update(contour_kinks(z, valid, cell))
+    if occupied is not None and occupied.shape == z.shape:
+        result.update(gap_stats(z, valid, occupied, cell))
+    elif same_model:
+        result.update({k: stored.get(k) for k in ("gap_pct", "gap_steep_pct")})
+    result["diff_against"] = pair.name if pair else None
+    result["diff_pct"] = diff_pct(z, valid, pair) if pair else None
+    result.update(filled_stats(models_dir, filter_key, valid, cell))
+    atomic_write_json(path, result)
+    return result
+
+
+def ensure_quality_safely(models_dir: Path, filter_key: str, method: str, **kwargs: Any) -> None:
+    """지을 때 부름 — 실패가 모델 짓기를 막지 않음."""
+    try:
+        ensure_quality(models_dir, filter_key, method, **kwargs)
+    except Exception as exc:  # noqa: BLE001
+        logger.warning("서피스 품질 지표 실패: %s-%s %s", filter_key, method, exc)
+
+
+def quality_after_build(
+    models_dir: Path, filter_key: str, method: str, context: Any, fresh: bool
+) -> None:
+    """파이프라인이 표현 하나를 짓거나 다시 쓴 뒤 부름 — ③ 은 지면점이 손에 있을 때만 셈."""
+    if method not in GRID_METHODS:
+        return
+    occupied = None
+    if fresh or not (models_dir / f"quality_{filter_key}_{method}.json").is_file():
+        try:
+            resolution = float(context.config.get("dtm_grid_resolution_meters", 1.0))
+            shape = context.grid(resolution)[2].shape
+            occupied = ground_occupancy(context.xyz, context.indices(), context.bounds, shape)
+        except Exception as exc:  # noqa: BLE001
+            logger.warning("서피스 품질 지면점 칸 실패: %s %s", filter_key, exc)
+    ensure_quality_safely(models_dir, filter_key, method, occupied=occupied)

B04_PreProcess/B04_PreProcess_Engine_SheetMethods.py

@@ -1,57 +1,23 @@
-"""도엽등고선 → 표고 격자 보간 방식 모음 (비교용).
+"""도엽등고선 → 표고 격자 보간 — 라플라스(거리 비례 초기값 + 이웃 평균 다듬기).
 
-문헌(Hutchinson 1988/89 ANUDEM; Chaplot 2006; Arun 2013 등)은 지형 복잡도·자료 밀도에
-따라 우열이 갈리며 단일 최적해가 없다고 본다. 그래서 방식을 하나로 고르지 않고 여기
-모아 두고 B04 화면에서 바꿔 가며 보게 한다(2026-08-30 사용자 지시).
+비교용 다섯 방식(TIN 둘 · TPS · ANUDEM형 · 다중해상도)은 걷음(608) — 확정 · 자동 = 라플라스.
 
-각 builder는 `(spec, burned, features, cell_m) -> (R, C) float32` 격자를 돌려준다.
+builder는 `(spec, burned, features, cell_m) -> (R, C) float32` 격자를 돌려준다.
 `burned`는 등고 라인이 구워진 격자(라인 셀 = 표고, 그 외 NaN)다. 폐합 링 안쪽 처리와
 프리뷰·저장은 호출측(`_SheetSurface`)이 방식과 무관하게 똑같이 해 준다.
 """
 
-import logging
-import warnings
 from typing import Any, Callable
 
 import numpy as np
 
-logger = logging.getLogger(__name__)
-
-# TIN(도엽선)이 물어 오는 격자 밖 여유 — 테두리가 삼각망 밖으로 나가지 않을 만큼만.
-SHEET_TIN_CLIP_MARGIN_M = 100.0
-
 # 화면 버튼에 쓰는 이름 — 키는 surface_models.generation_params.source_filter 접미사다.
 SHEET_METHOD_LABELS: dict[str, str] = {
-    "tin_sheet": "TIN(도엽선)",
-    "tin": "TIN 격자",
-    "biharmonic": "TPS(박판)",
-    "anudem": "ANUDEM형",
-    "multires": "다중해상도",
     "laplace": "라플라스",
 }
 
 
-def _laplacian(values: np.ndarray) -> np.ndarray:
-    padded = np.pad(values, 1, mode="edge")
-    return (
-        padded[:-2, 1:-1] + padded[2:, 1:-1] + padded[1:-1, :-2] + padded[1:-1, 2:] - 4.0 * values
-    )
-
-
-def _contour_vertices(burned: np.ndarray, spec: Any) -> tuple[np.ndarray, np.ndarray]:
-    """등고 라인 셀을 (N,2) 세계좌표와 표고로 바꾼다."""
-    rows, cols = np.nonzero(np.isfinite(burned))
-    xs = spec.cell_centers_x()[cols]
-    ys = spec.cell_centers_y()[rows]
-    return np.column_stack([xs, ys]), burned[rows, cols].astype(np.float64)
-
-
-def _grid_points(spec: Any) -> tuple[np.ndarray, np.ndarray]:
-    grid_x, grid_y = np.meshgrid(spec.cell_centers_x(), spec.cell_centers_y())
-    return grid_x, grid_y
-
-
-# ── ① 거리 비례 (버튼에서는 뺐지만 다른 방식의 초기추정으로 계속 쓴다) ───────
+# ── 거리 비례 (라플라스 초기값) ─────────────────────────────────────────────
 def build_distance(spec: Any, burned: np.ndarray, features: Any, cell_m: float) -> np.ndarray:
     """가장 가까운 서로 다른 표고 두 라인 사이를 거리 비례로 나눈다.
 
@@ -120,394 +86,17 @@ def relax_laplace(surface: np.ndarray, fixed: np.ndarray, iterations: int) -> No
             surface[colour] = neighbours[colour]
 
 
-# ── ② 라플라스(조화) ─────────────────────────────────────────────────────────
+# ── 라플라스(조화) ─────────────────────────────────────────────────────────────
 def build_laplace(spec: Any, burned: np.ndarray, features: Any, cell_m: float) -> np.ndarray:
     """등고선을 경계값으로 두고 Δz=0을 푼다.
 
-    면이 매끈해지지만 z=r(원뿔·능선)은 조화함수가 아니라 마루가 눌린다. 비교 기준으로
-    남겨 둔다 — ANUDEM이 라플라스 대신 박판 스플라인을 쓰는 이유를 눈으로 보기 위함.
+    면이 매끈해지지만 z=r(원뿔·능선)은 조화함수가 아니라 마루가 조금 눌린다.
     """
     surface = build_distance(spec, burned, features, cell_m)
     relax_laplace(surface, np.isfinite(burned), 400)
     return surface
 
 
-# ── ③ 박판 스플라인(중조화) ──────────────────────────────────────────────────
-def solve_min_curvature(constrained: np.ndarray, guess: np.ndarray) -> np.ndarray:
-    """제약 셀을 고정하고 Δ²z=0(박판 스플라인)을 최소곡률 최소제곱으로 푼다.
-
-    ANUDEM/Topo to Raster가 쓰는 박판 스플라인과 같은 연산자다. 라플라스와 달리 z=r을
-    그대로 통과시켜 능선·마루가 눌리지 않고, 경사가 등고선 너머로 자연스럽게 이어진다.
-
-    `constrained`: 값이 고정된 셀(등고 라인, 필요하면 구조선 앵커) — 그 외는 NaN.
-    `guess`: 시작값이자 감쇠 기준(보통 거리 보간 결과).
-    """
-    from scipy.sparse.linalg import LinearOperator, lsmr
-
-    guess = guess.astype(np.float64)
-    burned = constrained
-    # 제약 셀 + **격자 테두리**를 고정한다. 최외곽 등고선 바깥이 통째로 자유면
-    # 1차함수가 Δ²의 영공간에 남아 해가 하나로 정해지지 않고 켤레기울기가 발산한다
-    # (2026-08-30 실측: |Δz| 2092m). 테두리는 거리 보간값으로 묶는다.
-    fixed = np.isfinite(burned)
-    fixed[0, :] = fixed[-1, :] = True
-    fixed[:, 0] = fixed[:, -1] = True
-    free = ~fixed & np.isfinite(guess)
-    if not free.any():
-        return guess.astype(np.float32)
-    index = np.flatnonzero(free.ravel())
-    values = np.where(np.isfinite(burned), burned, guess)
-    base = np.where(fixed, np.nan_to_num(values), 0.0)
-
-    # Δ²z=0을 정규방정식(CG)으로 풀면 조건수가 격자변 4제곱이라 발산한다(실측).
-    # 대신 **최소곡률** 최소제곱으로 세운다 — 자유 셀에 대해 ‖Δz‖를 최소화하며,
-    # 그 정상해가 곧 Δ²z=0이다. 조건수가 제곱으로 줄어 LSMR이 안정적으로 푼다
-    # (Briggs 1974의 최소곡률 격자화와 같은 목적함수).
-    # 최소곡률만으로는 제약(등고선)에서 먼 영역이 정해지지 않아 해가 폭주한다.
-    # ANUDEM의 거칠기 벌점과 같은 취지로 감쇠항을 붙여 거리 보간값에 묶어 둔다:
-    #     minimize ‖Δz‖² + λ‖z − 거리보간‖²
-    # λ가 작을수록 더 매끈하고 클수록 거리 보간에 가깝다.
-    total_cells = base.size
-    free_count = len(index)
-    damping = np.float64(np.sqrt(0.02))
-    anchor = guess.ravel()[index]
-
-    def forward(vector: np.ndarray) -> np.ndarray:
-        # 반드시 **선형**이어야 한다 — 고정 셀 기여(base)를 여기서 더하면 아핀이 되어
-        # LSMR의 전제가 깨지고 해가 폭주한다. base 몫은 우변으로만 넘긴다.
-        scattered = np.zeros_like(base)
-        scattered.ravel()[index] = vector
-        return np.concatenate([_laplacian(scattered).ravel(), damping * vector])
-
-    def adjoint(vector: np.ndarray) -> np.ndarray:
-        curvature = _laplacian(vector[:total_cells].reshape(base.shape)).ravel()[index]
-        return curvature + damping * vector[total_cells:]
-
-    rhs = np.concatenate([-_laplacian(base).ravel(), damping * anchor])
-    linear = LinearOperator(
-        (total_cells + free_count, free_count),
-        matvec=forward,
-        rmatvec=adjoint,
-        dtype=np.float64,
-    )
-    result = lsmr(linear, rhs, x0=anchor, maxiter=400, atol=1e-8, btol=1e-8)
-    solution, info = result[0], result[1]
-    surface = base.copy()
-    surface.ravel()[index] = solution
-    surface[fixed] = values[fixed]
-    # 안전장치 — 발산하면 조용히 틀린 지형을 넘기지 말고 거리 보간으로 되돌린다.
-    drift = float(np.nanmax(np.abs(surface - guess)))
-    span = float(np.nanmax(guess) - np.nanmin(guess))
-    if not np.isfinite(drift) or drift > max(span, 1.0):
-        logger.warning(
-            "도엽 서피스(TPS): 해가 발산해(최대 %.1fm) 거리 보간으로 되돌립니다 (info=%s).",
-            drift,
-            info,
-        )
-        return guess.astype(np.float32)
-    logger.info("도엽 서피스(TPS): 최소제곱 info=%s, 최대 변화 %.2fm", info, drift)
-    return surface.astype(np.float32)
-
-
-def build_biharmonic(spec: Any, burned: np.ndarray, features: Any, cell_m: float) -> np.ndarray:
-    """등고선만 제약으로 둔 박판 스플라인."""
-    return solve_min_curvature(burned, build_distance(spec, burned, features, cell_m))
-
-
-# ── ④ TIN ───────────────────────────────────────────────────────────────────
-def _triangulate(
-    spec: Any, shape_: tuple[int, int], points: np.ndarray, values: np.ndarray
-) -> np.ndarray:
-    """정점 구름을 Delaunay 삼각망 선형 보간해 격자로 편다. 삼각망 밖은 NaN."""
-    from scipy.interpolate import LinearNDInterpolator
-
-    if len(points) < 3:
-        return np.full(shape_, np.nan, dtype=np.float32)
-    interpolator = LinearNDInterpolator(points, values)
-    grid_x, grid_y = _grid_points(spec)
-    surface = np.empty(shape_, dtype=np.float32)
-    chunk = max(1, int(4_000_000 // max(spec.n_cols, 1)))
-    for start in range(0, spec.n_rows, chunk):
-        stop = min(start + chunk, spec.n_rows)
-        surface[start:stop] = interpolator(grid_x[start:stop], grid_y[start:stop]).astype(
-            np.float32
-        )
-    return surface
-
-
-def build_tin(spec: Any, burned: np.ndarray, features: Any, cell_m: float) -> np.ndarray:
-    """격자에 구운 등고 라인 셀을 Delaunay 삼각망 선형 보간한다.
-
-    정점이 셀 중심에 맞춰져 있어 1m 계단이 삼각망에 그대로 실린다. 같은 표고 정점
-    3개로 이루어진 평탄 삼각형이 굴곡부·마루에 계단을 만든다. 비교 기준으로 남긴다.
-    """
-    points, values = _contour_vertices(burned, spec)
-    if len(points) > 120_000:  # 삼각망 비용은 정점 수에 비례한다
-        step = int(np.ceil(len(points) / 120_000))
-        points, values = points[::step], values[::step]
-    return _triangulate(spec, burned.shape, points, values)
-
-
-def build_tin_sheet(spec: Any, burned: np.ndarray, features: Any, cell_m: float) -> np.ndarray:
-    """**원본 5m 도엽 등고선 정점**을 그대로 이은 고전 TIN (2026-08-30 사용자 지시).
-
-    `tin`은 격자에 구운 라인 셀(=1m 계단으로 뭉개진 정점)을 쓰지만, 이쪽은 벡터
-    등고선의 정점을 좌표 그대로 쓴다 — 도면 등고선을 삼각망으로 잇는 측량 관행 그대로다.
-    격자 밖 등고선은 물지 않는다(삼각망 비용만 커지고 결과는 같다). 다만 격자 테두리가
-    삼각망 밖으로 나가지 않도록 여유를 두고 자른다.
-
-    길이 필터는 두지 않는다 — 짧은 봉우리 폐합 등고선을 버리면 마루가 통째로 평평해진다.
-    """
-    from shapely.geometry import shape as to_shape
-
-    from B04_PreProcess.B04_PreProcess_Engine_Watershed_Grid import (
-        ELEVATION_KEYS,
-        iter_linestrings,
-    )
-
-    xs, ys = spec.cell_centers_x(), spec.cell_centers_y()
-    margin = max(SHEET_TIN_CLIP_MARGIN_M, cell_m * 2.0)
-    x_lo, x_hi = xs[0] - margin, xs[-1] + margin
-    y_lo, y_hi = ys[-1] - margin, ys[0] + margin
-
-    coords: list[np.ndarray] = []
-    levels: list[np.ndarray] = []
-    for feature in features or []:
-        properties = feature.get("properties") or {}
-        elevation = next(
-            (float(properties[key]) for key in ELEVATION_KEYS if properties.get(key) is not None),
-            None,
-        )
-        geometry = feature.get("geometry")
-        if elevation is None or not geometry:
-            continue
-        try:
-            parsed = to_shape(geometry)
-        except Exception:  # noqa: BLE001 — 손상된 피처는 건너뛴다
-            continue
-        for line in iter_linestrings(parsed):
-            point = np.asarray(line.coords, dtype=np.float64)[:, :2]
-            inside = (
-                (point[:, 0] >= x_lo)
-                & (point[:, 0] <= x_hi)
-                & (point[:, 1] >= y_lo)
-                & (point[:, 1] <= y_hi)
-            )
-            if not inside.any():
-                continue
-            coords.append(point[inside])
-            levels.append(np.full(int(inside.sum()), elevation, dtype=np.float64))
-
-    if not coords:
-        logger.warning("도엽 서피스: TIN(도엽선)에 쓸 등고선 정점이 없습니다.")
-        return np.full(burned.shape, np.nan, dtype=np.float32)
-
-    points = np.vstack(coords)
-    values = np.concatenate(levels)
-    # 도엽 이음매에서 같은 정점이 겹쳐 들어온다 — Qhull 비용만 늘어 미리 접는다.
-    _, unique = np.unique(np.round(points, 3), axis=0, return_index=True)
-    points, values = points[unique], values[unique]
-    logger.info("도엽 서피스: TIN(도엽선) 정점 %d개", len(points))
-    return _triangulate(spec, burned.shape, points, values)
-
-
-# ── ⑦ ANUDEM형 (구조선 + 배수 강제) ─────────────────────────────────────────
-def _contour_corner_anchors(
-    spec: Any, burned: np.ndarray, guess: np.ndarray, cell_m: float
-) -> tuple[np.ndarray, np.ndarray] | None:
-    """등고선의 국소 최대 곡률점(코너)에서 능선·계곡 구조선 앵커를 만든다.
-
-    ANUDEM은 등고선 자체의 곡률에서 능선·계곡망을 먼저 뽑아 흐름 구조를 세운다
-    (Hutchinson 1988/89). 여기서도 같은 순서를 따른다.
-
-      ① 라인마다 정점 곡률을 재 국소 최대점(V자 꼭짓점)을 고른다
-      ② 굽은 안쪽이 더 높으면 **계곡**(등고선 V가 상류를 가리킴), 낮으면 **능선**
-      ③ 같은 종류의 코너를 이웃 표고끼리 이어 그 사이를 선형 보간해 앵커로 심는다
-
-    앵커는 박판 해의 제약으로 들어가 계곡 바닥이 이어져 내려가고 능선 마루가 선다.
-    """
-    from scipy.ndimage import label
-    from scipy.spatial import cKDTree
-
-    levels = np.unique(burned[np.isfinite(burned)])
-    if len(levels) < 2:
-        return None
-    interval = float(np.diff(levels).min())
-    xs = spec.cell_centers_x()
-    ys = spec.cell_centers_y()
-
-    corners: list[tuple[float, float, float, int]] = []  # x, y, level, +1 계곡 / -1 능선
-    span = 6  # 곡률을 재는 정점 간격(px) — 짧으면 노이즈, 길면 꼭짓점을 놓친다
-    for level in levels:
-        labelled, count = label(burned == level)
-        for component_id in range(1, count + 1):
-            line_rows, line_cols = np.nonzero(labelled == component_id)
-            if len(line_rows) < 3 * span:
-                continue
-            # 라인 셀을 한 줄로 세운다 — 좌표 정렬로 근사한다(정밀 추적은 과하다).
-            order = np.argsort(line_cols + line_rows * 1e-3)
-            path = np.column_stack([line_cols[order], line_rows[order]]).astype(np.float64)
-            before = np.roll(path, span, axis=0)
-            after = np.roll(path, -span, axis=0)
-            first = path - before
-            second = after - path
-            first_len = np.hypot(first[:, 0], first[:, 1])
-            second_len = np.hypot(second[:, 0], second[:, 1])
-            valid = (first_len > 1e-6) & (second_len > 1e-6)
-            cosine = np.ones(len(path))
-            cosine[valid] = (first[valid] * second[valid]).sum(axis=1) / (
-                first_len[valid] * second_len[valid]
-            )
-            sharp = np.flatnonzero(valid & (cosine < 0.3))  # 70도 이상 꺾인 자리
-            for i in sharp[:: max(1, span)]:
-                # 굽은 안쪽 방향 = 두 변 단위벡터 합의 반대
-                inward = -(first[i] / first_len[i] + second[i] / second_len[i])
-                norm = float(np.hypot(inward[0], inward[1]))
-                if norm < 1e-6:
-                    continue
-                probe = path[i] + inward / norm * 6.0
-                probe_col = int(round(probe[0]))
-                probe_row = int(round(probe[1]))
-                if not (0 <= probe_row < guess.shape[0] and 0 <= probe_col < guess.shape[1]):
-                    continue
-                inside = float(guess[probe_row, probe_col])
-                if not np.isfinite(inside) or abs(inside - level) < interval * 0.15:
-                    continue
-                corners.append(
-                    (
-                        float(xs[int(path[i, 0])]),
-                        float(ys[int(path[i, 1])]),
-                        float(level),
-                        1 if inside > level else -1,
-                    )
-                )
-    if len(corners) < 4:
-        logger.info("도엽 서피스(ANUDEM형): 등고선 코너가 부족해 구조선을 건너뜁니다.")
-        return None
-
-    array = np.asarray(corners, dtype=np.float64)
-    anchor_xy: list[np.ndarray] = []
-    anchor_z: list[np.ndarray] = []
-    reach = interval * 20.0  # 이보다 먼 코너는 같은 구조선으로 보지 않는다
-    for level in levels[:-1]:
-        upper = level + interval
-        lower_set = array[np.abs(array[:, 2] - level) < 1e-6]
-        upper_set = array[np.abs(array[:, 2] - upper) < 1e-6]
-        if not len(lower_set) or not len(upper_set):
-            continue
-        tree = cKDTree(upper_set[:, :2])
-        distance, index = tree.query(lower_set[:, :2], k=1)
-        for i in range(len(lower_set)):
-            j = int(index[i])
-            if distance[i] > reach or lower_set[i, 3] != upper_set[j, 3]:
-                continue
-            start = lower_set[i, :2]
-            end = upper_set[j, :2]
-            steps = max(2, int(distance[i] / max(cell_m, 1e-6) / 4))
-            fraction = np.linspace(0.0, 1.0, steps + 1)[1:-1]
-            if not len(fraction):
-                continue
-            anchor_xy.append(start + (end - start) * fraction[:, None])
-            anchor_z.append(level + interval * fraction)
-    if not anchor_xy:
-        return None
-    return np.vstack(anchor_xy), np.concatenate(anchor_z)
-
-
-def _enforce_drainage(surface: np.ndarray, epsilon: float = 0.01) -> int:
-    """가짜 웅덩이를 메운다 — ANUDEM의 배수 강제와 같은 목적.
-
-    등고선만으로 만든 면에는 흐름이 끊기는 웅덩이가 남는다. 형태학적 재구성(erosion)
-    으로 채우되 완전 평탄해지지 않게 아주 작은 값을 얹는다. 채운 셀 수를 반환한다.
-    """
-    from skimage.morphology import reconstruction
-
-    if not np.isfinite(surface).all():
-        return 0
-    seed = np.full(surface.shape, float(surface.max()), dtype=np.float64)
-    seed[0, :] = surface[0, :]
-    seed[-1, :] = surface[-1, :]
-    seed[:, 0] = surface[:, 0]
-    seed[:, -1] = surface[:, -1]
-    filled = reconstruction(seed, surface.astype(np.float64), method="erosion")
-    raised = filled > surface + 1e-6
-    if not raised.any():
-        return 0
-    # 그냥 채우면 웅덩이가 통째로 평탄해져 흐름 방향이 없어진다. 채운 영역 안쪽으로
-    # 갈수록 아주 조금 높아지게 해서 물이 가장자리(넘침점)로 빠져나가게 둔다
-    # (Garbrecht·Martz의 평탄면 해소를 간단히 옮긴 것 — 표고 변화는 cm 단위다).
-    from scipy.ndimage import distance_transform_edt
-
-    inner = distance_transform_edt(raised)
-    surface[raised] = (filled[raised] + epsilon * inner[raised]).astype(surface.dtype)
-    return int(raised.sum())
-
-
-def build_anudem(spec: Any, burned: np.ndarray, features: Any, cell_m: float) -> np.ndarray:
-    """ANUDEM형 — 등고선 곡률에서 능선·계곡 구조선을 뽑아 제약에 더하고, 박판으로 풀고,
-    가짜 웅덩이를 메운다. Topo to Raster가 밟는 세 단계를 그대로 옮긴 것이다."""
-    guess = build_distance(spec, burned, features, cell_m).astype(np.float64)
-    constrained = burned.astype(np.float64).copy()
-    anchors = _contour_corner_anchors(spec, burned, guess, cell_m)
-    if anchors is not None:
-        xy, z = anchors
-        row, col = spec.world_to_rc(xy[:, 0].copy(), xy[:, 1].copy())
-        inside = (row >= 0) & (col >= 0)
-        row, col, z = row[inside], col[inside], z[inside]
-        free = ~np.isfinite(constrained[row, col])
-        constrained[row[free], col[free]] = z[free]
-        logger.info("도엽 서피스(ANUDEM형): 구조선 앵커 %d셀", int(free.sum()))
-    surface = solve_min_curvature(constrained, guess).astype(np.float32)
-    logger.info("도엽 서피스(ANUDEM형): 가짜 웅덩이 %d셀 메움", _enforce_drainage(surface))
-    return surface
-
-
-# ── ⑧ 다중해상도 (coarse → fine) ────────────────────────────────────────────
-def build_multires(spec: Any, burned: np.ndarray, features: Any, cell_m: float) -> np.ndarray:
-    """성긴 격자에서 풀고 점차 세밀화한다 — ANUDEM의 다중해상도 전략.
-
-    전체 형상은 성긴 격자에서 싸게 잡고, 세밀한 격자에서는 등고선 근처만 다듬는다.
-    한 해상도에서만 풀 때보다 넓은 밴드가 고르게 퍼지고 값싸게 수렴한다.
-    """
-    from scipy.ndimage import zoom
-
-    surface: np.ndarray | None = None
-    for factor in (8, 4, 2, 1):
-        if factor == 1:
-            coarse = burned
-        else:
-            # 성긴 격자의 제약 — 블록 안 등고 라인의 평균 표고를 대표로 쓴다.
-            rows = burned.shape[0] // factor * factor
-            cols = burned.shape[1] // factor * factor
-            blocks = burned[:rows, :cols].reshape(rows // factor, factor, cols // factor, factor)
-            # 라인이 하나도 없는 블록은 NaN이 정상이라 경고를 삼킨다.
-            with warnings.catch_warnings():
-                warnings.simplefilter("ignore", RuntimeWarning)
-                coarse = np.nanmean(blocks, axis=(1, 3)).astype(np.float32)
-        level = build_distance(spec, coarse, features, cell_m * factor)
-        if surface is not None:
-            # 앞 단계 해를 지금 해상도로 올려 절반씩 섞는다 — 성긴 단계의 넓은 추세를
-            # 이어받되 이번 해상도의 등고선 정보를 덮지 않는다.
-            scale = (level.shape[0] / surface.shape[0], level.shape[1] / surface.shape[1])
-            upscaled = zoom(surface, scale, order=1)
-            free = ~np.isfinite(coarse)
-            level[free] = (level[free] + upscaled[free]) * 0.5
-        relax_laplace(level, np.isfinite(coarse), 8)
-        surface = level
-    assert surface is not None
-    if surface.shape != burned.shape:  # 블록 자르기로 남은 가장자리 보정
-        scale = (burned.shape[0] / surface.shape[0], burned.shape[1] / surface.shape[1])
-        surface = zoom(surface, scale, order=1)
-    line = np.isfinite(burned)
-    surface[line] = burned[line]
-    return surface.astype(np.float32)
-
-
 SHEET_METHOD_BUILDERS: dict[str, Callable[[Any, np.ndarray, Any, float], np.ndarray]] = {
-    "tin_sheet": build_tin_sheet,
-    "tin": build_tin,
-    "biharmonic": build_biharmonic,
-    "anudem": build_anudem,
-    "multires": build_multires,
     "laplace": build_laplace,
 }

B04_PreProcess/B04_PreProcess_Engine_SheetStore.py

@@ -39,8 +39,10 @@ from .B04_PreProcess_Engine_MapSheet import latlon_to_sheet5k, sheet5k_to_bounds
 
 logger = logging.getLogger(__name__)
 
-# 도곽선 레이어 코드 (수치지형도 v2.0 도엽본) — 도곽선 N3L_H0010000 이 없는 zip 은 옛 A0010000(도로 면)로 대신
+# 도곽선 레이어 코드 (수치지형도 v2.0 도엽본) — 선 N3L_H0010000 · 면 N3A_H0010000(섬 · 해안 작은 도엽)
+# · 둘 다 없는 zip 은 옛 A0010000(도로 면)로 대신
 _SHEET_FRAME_CODE = "N3L_H0010000"
+_SHEET_FRAME_AREA_CODE = "N3A_H0010000"
 _SHEET_FRAME_FALLBACK_CODE = "A0010000"
 _SHEET_NO_RE = re.compile(r"(\d{8})")
 _SHARED_DIRNAME = "_shared"  # storage/_shared 아래 = 여러 프로젝트가 같이 쓰는 창고
@@ -153,7 +155,11 @@ def download_sheet(store_dir: str | Path, sheet_no: str, version: int = 2) -> di
     rows = search_sheet_files(sheet_no, version=version)
     if not rows:
         raise LookupError(f"도엽 {sheet_no}: 브이월드 검색 결과 없음")
-    row = rows[0]
+    # Ver2.0 이 zip 아닌 NGI · NDA 뿐인 도엽(작은 섬) — 받을 zip 없음
+    row = next((r for r in rows if str(r.get("file_nm", "")).lower().endswith(".zip")), None)
+    if row is None:
+        kinds = ", ".join(sorted({str(r.get("file_extsn", "")) for r in rows}))
+        raise LookupError(f"도엽 {sheet_no}: Ver2.0 zip 없음({kinds})")
 
     cookie = _session_cookie_cache or VWORLD_SESSION_COOKIE
     payload = None
@@ -318,7 +324,7 @@ def ingest_zip(store_dir: str | Path, src_path: str | Path, sheet_no: str | None
 
 
 def _read_frame_bounds_wgs84(zip_path: Path) -> tuple[tuple[float, float, float, float], str]:
-    """zip 내 도곽선(N3L_H0010000 · 없으면 A0010000) SHP bounds를 WGS84로 반환. (bounds, 사용된 CRS).
+    """zip 내 도곽선(N3L_H0010000 · N3A_H0010000 · 없으면 A0010000) SHP bounds를 WGS84로 반환. (bounds, 사용된 CRS).
 
     선언된 PRJ가 오라벨(중부/동부원점 뒤바뀜)인 실측 사례가 있어, 파일명 도엽번호
     기준 예측 도곽과 대조해 정합한 CRS를 자동 판별한다.
@@ -328,7 +334,7 @@ def _read_frame_bounds_wgs84(zip_path: Path) -> tuple[tuple[float, float, float,
     with zipfile.ZipFile(zip_path) as zf:
         names = zf.namelist()
         shp: list[str] = []
-        for code in (_SHEET_FRAME_CODE, _SHEET_FRAME_FALLBACK_CODE):
+        for code in (_SHEET_FRAME_CODE, _SHEET_FRAME_AREA_CODE, _SHEET_FRAME_FALLBACK_CODE):
             shp = [n for n in names if n.upper().endswith(f"{code}.SHP")]
             if shp:
                 break

B04_PreProcess/B04_PreProcess_Engine_Smooth.py

@@ -1,7 +1,7 @@
-"""B04 지표면 스무딩 엔진 (DTM 가우시안+B-Spline, TIN Taubin).
+"""B04 지표면 스무딩 엔진 (DTM 가우시안+B-Spline).
 
 원본 모델(npz)을 로드해 표고 Z만 평활화한 스무딩 모델과 프리뷰(GLB)를 만든다.
-XY 위치와 삼각형 연결은 원본을 유지한다.
+XY 격자는 원본을 유지한다.
 """
 
 import hashlib
@@ -10,7 +10,6 @@ from pathlib import Path
 from typing import Any
 
 import numpy as np
-import trimesh
 from scipy import ndimage
 from scipy.interpolate import RectBivariateSpline
 
@@ -90,7 +89,7 @@ def smooth_dtm(
         y=y_coords,
         z=z_smooth,
         valid_mask=valid_grid,
-        resolution=np.array([preview_res], np.float32),
+        resolution=np.array([x_coords[1] - x_coords[0]], np.float32),  # 넓힌 실제 칸(633)
     )
     write_glb(preview_path, vertices_compact, faces_compact, context.bounds)
     return {
@@ -104,48 +103,10 @@ def smooth_dtm(
     }
 
 
-def smooth_tin(
-    context: TerrainContext, output_dir: Path, stem: str, original_model_path: Path
-) -> dict[str, Any]:
-    """TIN 삼각망에 Taubin 저수축 스무딩을 적용한다 (Z만 평활화)."""
-    data = np.load(original_model_path)
-    vertices, faces = data["vertices"], data["faces"]
-    if len(vertices) < 3 or not len(faces):
-        raise ValueError("TIN 스무딩을 수행할 삼각망 메쉬 데이터가 올바르지 않습니다.")
-
-    iterations = int(context.config.get("smoothing_tin_taubin_iterations", 10))
-    lamb = float(context.config.get("smoothing_tin_taubin_lambda", 0.5))
-    mu = float(context.config.get("smoothing_tin_taubin_mu", -0.53))
-    mesh = trimesh.Trimesh(vertices=vertices, faces=faces, process=False)
-    if iterations > 0:
-        trimesh.smoothing.filter_taubin(mesh, lamb=lamb, nu=mu, iterations=iterations)
-
-    vertices_smooth = np.asarray(mesh.vertices, dtype=np.float32)
-    # 지표면 스무딩은 리토폴로지가 아니다: XY·연결은 원본, Z만 평활화.
-    vertices_smooth[:, :2] = np.asarray(vertices[:, :2], dtype=np.float32)
-    faces_smooth = np.asarray(mesh.faces, dtype=np.uint32)
-
-    model_path = output_dir / f"{stem}_smooth.npz"
-    preview_path = output_dir / f"{stem}_smooth_preview.glb"
-    atomic_npz(model_path, vertices=vertices_smooth, faces=faces_smooth)
-    write_glb(preview_path, vertices_smooth, faces_smooth, context.bounds)
-    return {
-        "model_file": model_path.name,
-        "preview_file": preview_path.name,
-        "preview_media_type": "model/gltf-binary",
-        "vertex_count": int(len(vertices_smooth)),
-        "face_count": int(len(faces_smooth)),
-        "artifact_bytes": artifact_size(model_path, preview_path),
-        "smoothing_signature": compute_smoothing_signature(context.config),
-    }
-
-
 def run_smoothing(
     method: str, context: TerrainContext, output_dir: Path, stem: str, original_model_path: Path
 ) -> dict[str, Any]:
     """방식에 따라 적절한 스무딩 엔진을 수행한다."""
     if method == "dtm":
         return smooth_dtm(context, output_dir, stem, original_model_path)
-    if method == "tin":
-        return smooth_tin(context, output_dir, stem, original_model_path)
     raise ValueError(f"스무딩이 불가능한 지형 표현 방식입니다: {method}")

B04_PreProcess/B04_PreProcess_Engine_Structurize.py

@@ -4,7 +4,7 @@
 만들고, 뒤 단계(지면필터·모델·등고선·배수)는 받는 형식이 그대로라 손대지 않는다.
 
 점이 임계를 넘으면 **칸(기본 0.5m)마다 최저점 하나만** 남긴다(씨닝). 설계가 쓰는 격자가
-1m(지면필터 2m·CSF 천 1.5m)라 0.5m 는 설계보다 촘촘해 결과 표고가 사실상 같고, 30GB 두
+1m(다듬기 칸 1m)라 0.5m 는 설계보다 촘촘해 결과 표고가 사실상 같고, 30GB 두
 장이 메모리 29GB → 1.4GB 로 내려간다. 임계 아래면 원본 점을 그대로 쓴다 — 작은 자료의
 결과는 바뀌지 않는다.
 """
@@ -157,8 +157,8 @@ class _ThinGrid:
     버리지 않으므로 **지면 결과는 씨닝 전과 완전히 같다**(2026-09-06 용화 실측: 1m 지면
     격자 141,969칸 전부 표고 차이 0). 지면점은 원본의 2~3%뿐이라 남겨도 가볍다.
 
-    나머지(수목·구조물·잡음)는 칸마다 최저점만 남긴다 — 분류가 없는 자료에서 CSF·PMF가
-    지면을 찾을 밑그림으로 충분하다(CSF 천 간격 1.5m > 칸 0.5m).
+    나머지(수목·구조물·잡음)는 칸마다 최저점만 남긴다 — 분류가 없는 자료에서 점진 TIN이
+    지면을 찾을 밑그림으로 충분하다(씨앗 간격 10m · 다듬기 칸 1m > 칸 0.5m).
 
     한 청크 안에서 같은 칸이 여러 번 나오면 뒤에 쓴 값이 이겨 최저점이 아니게 된다.
     그래서 청크를 (칸, 표고)로 정렬해 **칸마다 첫 점**만 골라 낸 뒤 격자와 견준다.

B04_PreProcess/B04_PreProcess_Repository.py

@@ -287,19 +287,6 @@ async def list_surface_models(
     return models
 
 
-async def clear_confirmed_surface_models(connection: aiomysql.Connection, project_id: UUID) -> None:
-    """재분석 시 기존 확정을 해제하여 새 분석 결과의 재확정을 요구한다."""
-    async with connection.cursor() as cursor:
-        await cursor.execute(
-            """
-            UPDATE surface_models
-            SET status = 'COMPLETE'
-            WHERE project_id = %s AND status = 'CONFIRMED'
-            """,
-            (str(project_id),),
-        )
-
-
 async def confirm_surface_model(
     connection: aiomysql.Connection, project_id: UUID, model_id: int
 ) -> None:
@@ -384,7 +371,7 @@ async def _upsert_surface_model(
     processed_cloud_id: int | None,
     crs_epsg: int | None,
 ) -> int:
-    """파일 지문이 같은 옛 행이면 id 를 살려 고쳐 씀 — 화면 주소 · 노선 연결이 그대로.
+    """파일 지문이 같은 옛 행이면 id 를 살려 고쳐 씀 — 화면 주소 · 노선 연결 · 확정이 그대로(763-3).
 
     지문이 다르거나 없으면 옛 행을 지우고 새로 넣는다(새 지표면 = 노선 연결도 끊김).
     """
@@ -397,7 +384,8 @@ async def _upsert_surface_model(
             await cursor.execute(
                 """
                 UPDATE surface_models
-                SET source_file_id = %s, processed_cloud_id = %s, status = 'COMPLETE',
+                SET source_file_id = %s, processed_cloud_id = %s,
+                    status = IF(status = 'CONFIRMED', 'CONFIRMED', 'COMPLETE'),
                     crs_epsg = %s, resolution_m = %s, generation_params = %s,
                     completed_at = CURRENT_TIMESTAMP
                 WHERE id = %s

B04_PreProcess/B04_PreProcess_Router.py

@@ -1,7 +1,6 @@
 """B04 지표면 분석 FastAPI 라우터."""
 
 import asyncio
-import json
 import logging
 from pathlib import Path
 from typing import Any
@@ -22,9 +21,8 @@ from B04_PreProcess.B04_PreProcess_Engine_Extent import (
     project_epsg_from_prj,
 )
 from B04_PreProcess.B04_PreProcess_Engine_Ground import available_filters
-from B04_PreProcess.B04_PreProcess_Engine_PointPreview import ensure_point_preview, sample_points
+from B04_PreProcess.B04_PreProcess_Engine_PointPreview import ensure_point_preview
 from B04_PreProcess.B04_PreProcess_Repository import (
-    clear_confirmed_surface_models,
     get_input_file,
     list_project_point_cloud_inputs,
     list_project_point_cloud_paths,
@@ -55,25 +53,21 @@ from B04_PreProcess.B04_PreProcess_Schema import (
     SurfaceConfirmedResponse,
     SurfaceConfirmRequest,
     SurfaceConfirmResponse,
-    SurfaceGroundStatsResponse,
     SurfaceInputFileListResponse,
     SurfaceInputFileSummary,
     SurfaceModelListResponse,
     SurfaceModelSummary,
-    SurfacePointCloudSampleResponse,
 )
 from B04_PreProcess.B04_PreProcess_Service import confirm_surface_selection
 from common_util.common_util_auth import require_system_admin
 from common_util.common_util_http_cache import cached_file_response
 from common_util.common_util_storage import resolve_stored_project_path
 from common_util.common_util_surface_confirmation import (
+    confirmed_surface_params,
     get_surface_confirmation_params,
     surface_confirmation_defaults,
-)
-from common_util.common_util_workflow_state import (
-    fail_stage,
-    start_stage,
-    update_stage_progress,
+    terrain_changes,
+    update_contour_interval_param,
 )
 from config.config_db import get_db_pool
 
@@ -89,7 +83,10 @@ router.include_router(status_router)
 async def analyze_surface(
     project_id: UUID, request: SurfaceAnalyzeRequest
 ) -> SurfaceAnalyzeResponse | JSONResponse:
-    """LAS 구조화·지면 필터·지표면 모델 생성을 실행하고 DB에 기록한다."""
+    """LAS 구조화·지면 필터·지표면 모델 생성을 실행하고 DB에 기록한다 — 보기만(763-3 · 요구 605).
+
+    확정 · 단계 상태 · 1 단계 값(`las_selection` 포함)을 안 바꿈 · 미리 셈도 없음. 서피스를 바꾸는
+    길 = 다른 모델 [확정](전처리 체인 다시)."""
     try:
         source_filters = request.resolved_filters()
         methods = request.resolved_methods()
@@ -97,19 +94,9 @@ async def analyze_surface(
         return JSONResponse(status_code=400, content={"status": "error", "message": str(exc)})
 
     pool = get_db_pool()
+    project_root: Path | None = None
     try:
-        params = {
-            "input_file_id": request.input_file_id,
-            "source_filters": source_filters,
-            "methods": methods,
-            "force": request.force,
-        }
         async with pool.acquire() as connection:
-            async with connection.cursor() as cursor:
-                await start_stage(cursor, str(project_id), 1, params)
-                await clear_confirmed_surface_models(connection, project_id)
-                await connection.commit()
-
             stored_path = await get_project_storage_relative_path(connection, project_id)
             project_root = Path(resolve_stored_project_path(stored_path))
             input_file = await get_input_file(connection, project_id, request.input_file_id)
@@ -151,19 +138,23 @@ async def analyze_surface(
                     analysis_result=result,
                     source_filters=source_filters,
                 )
-                async with connection.cursor() as cursor:
-                    await update_stage_progress(cursor, str(project_id), 1, 100)
                 await connection.commit()
+                confirmed = await confirmed_surface_params(connection, str(project_id))
             except Exception:
                 await connection.rollback()
                 raise
 
-        write_surface_progress(
-            project_root,
-            100,
-            "awaiting_confirmation",
-            "WF1 분석이 완료되었습니다. 사용할 모델을 확정하세요.",
-        )
+        if confirmed is not None:
+            write_surface_progress(
+                project_root, 100, "completed", "조합을 지었습니다 — 확정 그대로."
+            )
+        else:
+            write_surface_progress(
+                project_root,
+                100,
+                "awaiting_confirmation",
+                "WF1 분석이 완료되었습니다. 사용할 모델을 확정하세요.",
+            )
 
         return SurfaceAnalyzeResponse(
             project_id=str(project_id),
@@ -173,16 +164,14 @@ async def analyze_surface(
         )
     except LookupError as exc:
         return JSONResponse(status_code=404, content={"status": "error", "message": str(exc)})
-    except (OSError, ValueError) as exc:
-        async with pool.acquire() as connection, connection.cursor() as cursor:
-            await fail_stage(cursor, str(project_id), 1, str(exc))
-            await connection.commit()
+    except (OSError, ValueError) as exc:  # 보기만 — 단계 상태 그대로 · 진행 파일만 끝(763-3)
+        if project_root is not None:
+            write_surface_progress(project_root, 100, "failed", str(exc))
         return JSONResponse(status_code=400, content={"status": "error", "message": str(exc)})
     except Exception as exc:
         logger.exception("B04 지표면 분석 실패: project_id=%s", project_id)
-        async with pool.acquire() as connection, connection.cursor() as cursor:
-            await fail_stage(cursor, str(project_id), 1, str(exc))
-            await connection.commit()
+        if project_root is not None:
+            write_surface_progress(project_root, 100, "failed", str(exc))
         return JSONResponse(
             status_code=500,
             content={"status": "error", "message": "지표면 분석 처리 중 오류가 발생했습니다."},
@@ -214,7 +203,10 @@ async def confirm_surface(
     request: SurfaceConfirmRequest,
     _session: dict[str, Any] = Depends(require_system_admin),
 ) -> SurfaceConfirmResponse | JSONResponse:
-    """사용자가 선택한 지표면 모델을 확정하고 WF1을 완료한다."""
+    """사용자가 선택한 지표면 모델을 확정하고 WF1을 완료한다.
+
+    같은 서피스(필터 · 표현 · 평활) 다시 [확정] = 등고선 간격만 · 체인 없음. 다른 서피스 = 업로드와
+    같은 전처리 체인(B05~B09 초기화 → 자동 설계 · 추천 미리 셈 · 763-3 · 요구 605)."""
     pool = get_db_pool()
     try:
         async with pool.acquire() as connection:
@@ -247,24 +239,32 @@ async def confirm_surface(
                         ),
                     }
                 )
-                await confirm_surface_selection(
-                    connection,
-                    project_id,
-                    request.model_id,
-                    selection,
-                )
+                current = await confirmed_surface_params(connection, str(project_id))
+                same = current is not None and not terrain_changes(current, selection)
+                if same:  # 같은 서피스 — 아무것도 안 다시 셈(등고선 간격만 · 763-3)
+                    await update_contour_interval_param(
+                        connection, str(project_id), float(selection["contour_interval_m"])
+                    )
+                else:
+                    await confirm_surface_selection(
+                        connection,
+                        project_id,
+                        request.model_id,
+                        selection,
+                    )
                 await connection.commit()
             except Exception:
                 await connection.rollback()
                 raise
-        # 재확정 체인(2026-08-04 사용자 확정) — 새 지표면 기준으로 B05·B06을 백그라운드
-        # 재계산·저장한다. 사용자 저장 입력(제어점·경사 옵션·측점별 설계)은 유지·이월된다.
+        if same:
+            return SurfaceConfirmResponse(project_id=str(project_id), model_id=request.model_id)
+        # 서피스가 바뀜 — 업로드와 같은 전처리 체인 하나(B05~B09 초기화 · 763-3 · 요구 605).
         # 응답을 막지 않도록 백그라운드로 돌리고, 체인은 실패를 스스로 격리한다.
-        from B03_FileInput.B03_FileInput_Service_Chain import run_redesign_chain
+        from B03_FileInput.B03_FileInput_Service_SurfaceChange import run_surface_change_chain
 
         redesign_task = asyncio.create_task(
-            run_redesign_chain(project_id, request.model_id, dict(selection)),
-            name=f"redesign-chain-{project_id}",
+            run_surface_change_chain(project_id, request.model_id),
+            name=f"surface-change-chain-{project_id}",
         )
         redesign_task.add_done_callback(
             lambda task: task.exception()  # 체인 내부에서 이미 로깅 — 미회수 예외 경고만 방지
@@ -353,51 +353,6 @@ async def get_surface_point_cloud_binary(
         )
 
 
-@router.get("/{project_id}/surface/point-cloud", response_model=SurfacePointCloudSampleResponse)
-async def get_surface_point_cloud(
-    project_id: UUID,
-    filter: str | None = None,
-) -> SurfacePointCloudSampleResponse | JSONResponse:
-    """원본 또는 필터링된 B04 3D 미리보기 포인트를 반환한다(JSON · 화면은 이진 길을 씀)."""
-    try:
-        source_path = await _point_cloud_source(project_id, filter)
-        if isinstance(source_path, JSONResponse):
-            return source_path
-
-        with np.load(source_path) as structured:
-            xyz = np.asarray(structured["xyz"], dtype=np.float32)
-            bounds = np.asarray(structured["bounds"], dtype=np.float64)
-            point_count = (
-                int(structured["point_count"]) if "point_count" in structured else int(len(xyz))
-            )
-            rgb = np.asarray(structured["rgb"]) if "rgb" in structured else None
-            sample, rgb_sample = sample_points(xyz, rgb)
-
-        return SurfacePointCloudSampleResponse(
-            project_id=str(project_id),
-            point_count=point_count,
-            sampled_count=int(len(sample)),
-            bounds={
-                "x_min": float(bounds[0, 0]),
-                "x_max": float(bounds[0, 1]),
-                "y_min": float(bounds[1, 0]),
-                "y_max": float(bounds[1, 1]),
-                "z_min": float(bounds[2, 0]),
-                "z_max": float(bounds[2, 1]),
-            },
-            points=sample.astype(float).tolist(),
-            rgb=rgb_sample.astype(int).tolist() if rgb_sample is not None else None,
-        )
-    except LookupError as exc:
-        return JSONResponse(status_code=404, content={"status": "error", "message": str(exc)})
-    except Exception:
-        logger.exception("B04 포인트클라우드 샘플 조회 실패: project_id=%s", project_id)
-        return JSONResponse(
-            status_code=500,
-            content={"status": "error", "message": "포인트클라우드 조회 중 오류가 발생했습니다."},
-        )
-
-
 @router.get("/{project_id}/surface/confirmed", response_model=SurfaceConfirmedResponse)
 async def get_confirmed_surface(project_id: UUID) -> SurfaceConfirmedResponse | JSONResponse:
     """확정 지표면 구성과 지형 가장자리만 반환한다(포인트 배열 없음).
@@ -493,34 +448,3 @@ async def get_confirmed_surface(project_id: UUID) -> SurfaceConfirmedResponse |
             status_code=500,
             content={"status": "error", "message": "확정 지표면 정보를 불러오지 못했습니다."},
         )
-
-
-@router.get("/{project_id}/surface/ground-stats", response_model=SurfaceGroundStatsResponse)
-async def get_surface_ground_stats(project_id: UUID) -> SurfaceGroundStatsResponse | JSONResponse:
-    """manifest에서 필터별 지면 포인트 통계를 반환한다."""
-    pool = get_db_pool()
-    try:
-        async with pool.acquire() as connection:
-            stored_path = await get_project_storage_relative_path(connection, project_id)
-        project_root = Path(resolve_stored_project_path(stored_path))
-        manifest_path = project_root / "B04_PreProcess" / "models" / "manifest.json"
-        if not manifest_path.is_file():
-            return SurfaceGroundStatsResponse(project_id=str(project_id), filters={})
-        manifest = json.loads(manifest_path.read_text(encoding="utf-8"))
-        filters = {
-            key: {
-                "source_point_count": value.get("source_point_count"),
-                "methods": value.get("methods", {}),
-            }
-            for key, value in manifest.get("source_filters", {}).items()
-            if isinstance(value, dict)
-        }
-        return SurfaceGroundStatsResponse(project_id=str(project_id), filters=filters)
-    except LookupError as exc:
-        return JSONResponse(status_code=404, content={"status": "error", "message": str(exc)})
-    except Exception:
-        logger.exception("B04 지면 통계 조회 실패: project_id=%s", project_id)
-        return JSONResponse(
-            status_code=500,
-            content={"status": "error", "message": "지면 통계 조회 중 오류가 발생했습니다."},
-        )

B04_PreProcess/B04_PreProcess_Router_Basins.py

@@ -257,21 +257,26 @@ def _apply_new_defaults(
         if definition is None:
             continue
         options = dict(point.options or {})
+        given = set(options)
         for field in definition.options:
             if field.key not in options and field.default not in (None, ""):
                 options[field.key] = field.default
-        # 집수정 모양도 실제 값으로(54-39 · 54-36 기본 L형 — 화면 짝 `DEFAULT_BASIN_SHAPE`)
-        if options.get("inlet_type") == "집수정":
+        if "pipe_diameter_mm" not in given and isinstance(options.get("pipe_diameter_mm"), str):
+            options["pipe_diameter_mm"] = int(_float(options["pipe_diameter_mm"]))  # 폼 = 수(623)
+        # 집수정 = 모양 L(54-39 · `DEFAULT_BASIN_SHAPE`) · 동물이동형 유 · 유입 흙막이 없음(623)
+        basin = options.get("inlet_type") == "집수정"
+        if basin:
             options.setdefault("inlet_structure", "L")
-        # 관 보호공 · 유입 집수정 높이 = 관경 + 0.5(139-1 · 화면 짝 `PIPE_HEIGHT_KEYS`)
+            options.setdefault("inlet_basin_animal", "true")
+            for key in [k for k in options if k.startswith("inlet_revet_") and k not in given]:
+                del options[key]
+        # 보호공 · 집수정 높이 = 관경 + 0.5(139-1 · `PIPE_HEIGHT_KEYS`) · 유입 흙막이 + 0.7(211-1)
         keys = {field.key for field in definition.options}
         diameter_m = _float(options.get("pipe_diameter_mm")) / 1000
         if diameter_m > 0:
             for key in PIPE_HEIGHT_KEYS:
-                if key in keys:
-                    side = (
-                        "inlet" if key == "inlet_revet_height_m" else ""
-                    )  # 유입 흙막이 + 0.7(211-1)
+                if key in keys and not (basin and key.startswith("inlet_revet_")):
+                    side = "inlet" if key == "inlet_revet_height_m" else ""
                     options.setdefault(key, pipe_wall_min_height_m(diameter_m, side))
         if point.facility == "ford_bridge" and "ford_height_m" not in options:
             flow = (flows or {}).get(round(point.chainage_m, 2))

B04_PreProcess/B04_PreProcess_Router_Contour.py

@@ -16,6 +16,7 @@ from fastapi.responses import JSONResponse, Response
 from B03_FileInput.B03_FileInput_Repository import get_project_storage_relative_path
 from B04_PreProcess.B04_PreProcess_Engine_Contour import (
     CONTOUR_EXTRACTOR_VERSION,
+    contour_cache_is_stale,
     extract_contours,
 )
 from common_util.common_util_atomic import atomic_write_bytes
@@ -28,19 +29,16 @@ logger = logging.getLogger(__name__)
 router = APIRouter(prefix="/api/projects", tags=["B04 Surface Contour"])
 
 MODEL_REPRESENTATIONS = {
-    "meshfree": "meshfree_surfels",
     "dtm": "regular_grid",
-    "tin": "triangular_mesh",
-    "nurbs": "bspline_surface",
     "implicit": "local_rbf_height_field",
 }
 
 
 def _is_contour_cache_current(contour_path: Path, model_path: Path) -> bool:
-    """캐시가 현재 추출기 버전이고 기반 모델 npz보다 최신인지 검사한다."""
+    """캐시가 현재 추출기 버전이고 모델 · 같은 필터 dtm · 굳힌 격자보다 최신인지 검사한다."""
+    if contour_cache_is_stale(contour_path, model_path):
+        return False
     try:
-        if contour_path.stat().st_mtime < model_path.stat().st_mtime:
-            return False
         with contour_path.open("rb") as cache_file:
             head = cache_file.read(256).decode("utf-8", errors="ignore")
     except OSError:
@@ -78,7 +76,7 @@ async def get_surface_model_contour(
                         status_code=404,
                         content={"status": "error", "message": "해당 모델을 찾을 수 없습니다."},
                     )
-                model_type, model_file_path = row[0], row[1]
+                model_file_path = row[1]
 
         project_root = Path(resolve_stored_project_path(stored_path))
         if not model_file_path:
@@ -91,21 +89,16 @@ async def get_surface_model_contour(
         models_dir = model_path.parent
         structured_path = project_root / "B04_PreProcess" / "processed" / "structured.npz"
         stem = model_path.stem
-        parts = stem.split("_")
-        if len(parts) >= 2:
-            method = parts[0]
-            filter_key = "_".join(parts[1:])
-        else:
-            method = model_type
-            filter_key = "csf"
-        if smooth and method in ("dtm", "tin"):
+        # 파일 이름 = `{표현}_{필터}` · 지운 표현(608 · tin 등)이면 404
+        method, _, filter_key = stem.partition("_")
+        if smooth and method == "dtm":
             contour_filename = f"contour_{filter_key}_{method}_smooth_{interval}m.json"
             contour_model_path = models_dir / f"{stem}_smooth.npz"
-            representation = "regular_grid" if method == "dtm" else "triangular_mesh"
+            representation = "regular_grid"
         else:
             contour_filename = f"contour_{filter_key}_{method}_{interval}m.json"
             contour_model_path = model_path
-            representation = MODEL_REPRESENTATIONS.get(method)
+            representation = MODEL_REPRESENTATIONS.get(method) if filter_key else None
         contour_path = models_dir / contour_filename
         if recalculate or not _is_contour_cache_current(contour_path, contour_model_path):
             if not math.isfinite(interval) or interval < 0.5:
@@ -189,3 +182,34 @@ async def get_surface_model_contour(
             status_code=500,
             content={"status": "error", "message": "등고선 파일 조회 중 오류가 발생했습니다."},
         )
+
+
+@router.get("/{project_id}/surface/models/{model_id}/quality")
+async def get_surface_model_quality(project_id: UUID, model_id: int) -> JSONResponse:
+    """서피스 품질 지표 넷(762-2) — 저장본 지문이 다르면 다시 셈 · 격자 표현 밖이면 null."""
+    from B04_PreProcess.B04_PreProcess_Engine_Quality import ensure_quality
+
+    pool = get_db_pool()
+    async with pool.acquire() as connection:
+        stored_path = await get_project_storage_relative_path(connection, project_id)
+        async with connection.cursor() as cursor:
+            await cursor.execute(
+                "SELECT model_file_path FROM surface_models WHERE id = %s AND project_id = %s",
+                (model_id, str(project_id)),
+            )
+            row = await cursor.fetchone()
+    if not row or not row[0]:
+        return JSONResponse(
+            status_code=404,
+            content={"status": "error", "message": "해당 모델을 찾을 수 없습니다."},
+        )
+    model_path = Path(resolve_stored_project_path(stored_path)) / row[0]
+    method, _, filter_key = model_path.stem.partition("_")
+    try:
+        quality = await asyncio.to_thread(ensure_quality, model_path.parent, filter_key, method)
+    except Exception:
+        logger.exception("서피스 품질 지표 실패: project_id=%s, model_id=%s", project_id, model_id)
+        quality = None
+    if quality:
+        quality = {key: value for key, value in quality.items() if key != "key"}
+    return JSONResponse(content={"status": "success", "quality": quality})

B04_PreProcess/B04_PreProcess_Router_Status.py

@@ -188,11 +188,10 @@ async def get_surface_model_preview(
         models_dir = model_path.parent
         stem = model_path.stem
 
-        ext = "ply" if model_type == "meshfree" else "glb"
-        if smooth and model_type in ("dtm", "tin"):
+        if smooth and model_type == "dtm":
             preview_filename = f"{stem}_smooth_preview.glb"
         else:
-            preview_filename = f"{stem}_preview.{ext}"
+            preview_filename = f"{stem}_preview.glb"
 
         preview_path = models_dir / preview_filename
         if not preview_path.is_file():
@@ -204,11 +203,7 @@ async def get_surface_model_preview(
                 },
             )
 
-        media_type = "application/octet-stream"
-        if ext == "glb":
-            media_type = "model/gltf-binary"
-        elif ext == "ply":
-            media_type = "application/ply"
+        media_type = "model/gltf-binary"
 
         # 브라우저가 이미 같은 파일을 갖고 있으면 304만 돌려준다(새로고침이 빨라진다).
         return cached_file_response(request, preview_path, media_type, preview_filename)

B04_PreProcess/B04_PreProcess_Schema.py

@@ -4,14 +4,14 @@ from typing import Any
 
 from pydantic import BaseModel, ConfigDict, Field
 
+from B04_PreProcess.B04_PreProcess_Engine_Ground import available_filters
 from config.config_system import (
     SURFACE_MODEL_PRECOMPUTE,
     SURFACE_MODEL_SOURCE_FILTERS,
 )
 
-# classification은 LAS가 지면분류를 싣고 있을 때 엔진이 자동으로 붙이지만,
-# 재계산 요청에서 이름으로 지정하는 것도 허용한다.
-_ALLOWED_FILTERS = set(SURFACE_MODEL_SOURCE_FILTERS) | {"ransac", "classification"}
+# 허용 필터 = 지면 필터 등록부 하나(Ground `_FILTERS`)
+_ALLOWED_FILTERS = set(available_filters())
 _ALLOWED_METHODS = set(SURFACE_MODEL_PRECOMPUTE)
 
 
@@ -100,18 +100,6 @@ class SurfaceInputFileListResponse(BaseModel):
     files: list[SurfaceInputFileSummary]
 
 
-class SurfacePointCloudSampleResponse(BaseModel):
-    """B04 3D 미리보기용 포인트클라우드 샘플."""
-
-    status: str = "success"
-    project_id: str
-    point_count: int
-    sampled_count: int
-    bounds: dict[str, float]
-    points: list[list[float]]
-    rgb: list[list[int]] | None = None
-
-
 class SurfaceConfirmedResponse(BaseModel):
     """확정 지표면 요약 — 화면 진입 판정·준비화면·B05가 공통으로 쓰는 단일 출처.
 
@@ -133,14 +121,6 @@ class SurfaceConfirmedResponse(BaseModel):
     route_bounds: dict[str, float] | None = None
 
 
-class SurfaceGroundStatsResponse(BaseModel):
-    """필터별 지면 포인트 통계 응답."""
-
-    status: str = "success"
-    project_id: str
-    filters: dict[str, dict[str, Any]]
-
-
 class SurfaceAnalyzeResponse(BaseModel):
     """지표면 분석 실행 결과."""
 

B04_PreProcess/B04_PreProcess_UI_Filter.ts

@@ -0,0 +1,117 @@
+/* =============================================================================
+ * B04_PreProcess_UI_Filter.ts
+ * B04 지면 필터 드롭다운(고를 갈래 · 이름) + 고른 모델의 서피스 품질 지표 넷(762-2).
+ *   지표 = GET /api/projects/{id}/surface/models/{model}/quality — 서버가 지을 때 셈해 둔 값
+ *   (튐 넓이 % · 1 m 등고선 꺾임 /km · 땅 점 빈 곳 % · 필터 차 %) · 문턱 판정은 안 함(사용자 협의).
+ * ========================================================================== */
+
+import { API_BASE_URL } from "@config/config_frontend";
+import { createSelectField } from "@ui/ui_template_elements";
+import { createKv } from "@ui/ui_template_kv";
+import type { SurfaceModelSummary } from "./B04_PreProcess_Api_Fetch";
+
+// 고를 수 있는 필터. 자동 전처리는 이 중 기본 하나만 만들고, 나머지는 관리자가
+// 드롭다운에서 고를 때 그 조합만 계산한다 (2026-09-01 사용자 확정).
+// `_refine` = 다듬기 판(762) — 바탕 필터 바로 뒤에 둠(이름 찾기는 가장 긴 것이 이김).
+export const SOURCE_FILTERS = [
+  "classification",
+  "classification_refine",
+  "ptd",
+  "ptd_refine",
+] as const;
+
+const FILTER_LABELS: Record<string, string> = {
+  ptd: "점진 TIN",
+  classification_refine: "업체 분류 + 다듬기",
+  ptd_refine: "점진 TIN + 다듬기",
+};
+
+function optionLabel(value: string): string {
+  return FILTER_LABELS[value] ?? value.replaceAll("_", " ").toUpperCase();
+}
+
+/** 라벨 한 줄 + 드롭다운. 지표면 분석 컨테이너 안의 항목 하나를 만든다. */
+export function buildSelectField(
+  label: string,
+  values: readonly string[],
+  defaultValue: string,
+): { root: HTMLElement; select: HTMLSelectElement } {
+  const { root, select } = createSelectField({
+    label,
+    options: values.map((value) => ({ value, text: optionLabel(value) })),
+    value: defaultValue,
+    size: 36,
+  });
+  root.classList.add("b04-surface__field");
+  return { root, select };
+}
+
+interface SurfaceQuality {
+  spike_pct?: number | null;
+  spike_count?: number | null;
+  kinks_per_km?: number | null;
+  gap_pct?: number | null;
+  gap_steep_pct?: number | null;
+  diff_pct?: number | null;
+  diff_against?: string | null;
+  filled_m2?: number | null;
+  filled_pct?: number | null;
+}
+
+function fmt(value: number | null | undefined, unit: string): string | null {
+  return value == null ? null : `${value.toLocaleString()} ${unit}`;
+}
+
+function rows(quality: SurfaceQuality | null): ReturnType<typeof createKv> {
+  const against = quality?.diff_against
+    ?.replace(/^(dtm|implicit)_/, "")
+    .replace(/(_grid)?\.npz$/, "");
+  const list = createKv([
+    {
+      label: "튐 넓이",
+      value:
+        quality?.spike_pct == null
+          ? null
+          : `${quality.spike_pct} % · ${quality.spike_count ?? 0} 곳`,
+    },
+    { label: "등고선 꺾임", value: fmt(quality?.kinks_per_km, "/km") },
+    { label: "땅 점 빈 곳", value: fmt(quality?.gap_pct, "%") },
+    { label: "그중 급경사", value: fmt(quality?.gap_steep_pct, "%") },
+    // 대상 이름은 길어 줄을 깨뜨림 — 값은 % 만 · 대상은 마우스 올림 글
+    { label: "필터 차", value: fmt(quality?.diff_pct, "%") },
+    // 외곽 안 구멍을 둘레 지면에서 이어 메운 자리(766-2)
+    {
+      label: "메운 넓이",
+      value:
+        quality?.filled_m2 == null
+          ? null
+          : `${fmt(quality.filled_m2, "m²")} · ${quality.filled_pct ?? 0} %`,
+    },
+  ]);
+  if (against) list.title = `필터 차 = ${optionLabel(against)} 모델과 0.5 m 넘게 다른 넓이`;
+  return list;
+}
+
+/** 고른 모델의 품질 지표(넷 + 메운 넓이) — 늦게 온 옛 응답은 버림. */
+export function createQualityPanel(): {
+  root: HTMLElement;
+  show: (projectId: string, model: SurfaceModelSummary | undefined) => void;
+} {
+  const root = document.createElement("div");
+  root.append(rows(null));
+  let ticket = 0;
+  function show(projectId: string, model: SurfaceModelSummary | undefined): void {
+    const mine = ++ticket;
+    root.replaceChildren(rows(null));
+    if (!model) return;
+    void fetch(`${API_BASE_URL}/projects/${projectId}/surface/models/${model.id}/quality`, {
+      credentials: "include",
+    })
+      .then((response) => (response.ok ? response.json() : null))
+      .then((payload: { quality?: SurfaceQuality | null } | null) => {
+        if (mine === ticket) root.replaceChildren(rows(payload?.quality ?? null));
+      })
+      .catch(() => undefined);
+  }
+  return { root, show };
+}

B04_PreProcess/B04_PreProcess_UI_Page.ts

@@ -40,6 +40,7 @@ import {
   type SurfacePointCloudSampleResponse,
   type SurfaceStatusResponse,
 } from "./B04_PreProcess_Api_Fetch";
+import { buildSelectField, createQualityPanel, SOURCE_FILTERS } from "./B04_PreProcess_UI_Filter";
 import { buildSurfaceGroup } from "./B04_PreProcess_UI_Group";
 import { createSurfaceMapViewer } from "./B04_PreProcess_UI_MapViewer";
 import { createSurfaceTerrainViewer } from "./B04_PreProcess_UI_TerrainViewer";
@@ -49,15 +50,12 @@ import "./B04_PreProcess_UI_Style.css";
 import "./B04_PreProcess_UI_Style_Map.css";
 import { currentProjectId, guardProjectLeave } from "../A00_Common/b_project_switch";
 
-// 고를 수 있는 필터. 자동 전처리는 이 중 기본 하나만 만들고, 나머지는 관리자가
-// 드롭다운에서 고를 때 그 조합만 계산한다 (2026-09-01 사용자 확정).
-const SOURCE_FILTERS = ["classification", "grid_min_z", "csf", "pmf"] as const;
-const MODEL_METHODS = ["tin", "dtm", "nurbs", "implicit", "meshfree"] as const;
-const DEFAULT_FILTER = "csf";
-const DEFAULT_METHOD = "dtm";
+const MODEL_METHODS = ["dtm", "implicit"] as const;
+const DEFAULT_FILTER = "ptd";
+const DEFAULT_METHOD = "implicit"; // 확정 기본 표현(요구 558) — 확정본이 있으면 그것이 먼저
 const ROUTE_STAGE = ROUTES.B05_PROFILE;
 // 도엽 서피스 보간 방식 버튼 순서 — 백엔드 SHEET_SURFACE_METHODS와 같은 차례로 둔다.
-const SHEET_METHOD_ORDER = ["tin_sheet", "tin", "biharmonic", "anudem", "multires", "laplace"];
+const SHEET_METHOD_ORDER = ["laplace"];
 
 function L(key: keyof typeof ui_locales): string {
   return ui_locales[key][currentLanguageIndex];
@@ -67,30 +65,11 @@ function infoRow(label: string, value: unknown): KvRow {
   return { label, value: value == null || value === "" ? "-" : String(value) };
 }
 
-/** 라벨 한 줄 + 드롭다운. 지표면 분석 컨테이너 안의 항목 하나를 만든다. */
-function buildSelectField(
-  label: string,
-  values: readonly string[],
-  defaultValue: string,
-): { root: HTMLElement; select: HTMLSelectElement } {
-  const { root, select } = createSelectField({
-    label,
-    options: values.map((value) => ({
-      value,
-      text: value.replaceAll("_", " ").toUpperCase(),
-    })),
-    value: defaultValue,
-    size: 36,
-  });
-  root.classList.add("b04-surface__field");
-  return { root, select };
-}
-
 function getModelFilter(model: SurfaceModelSummary): string {
   const configured = model.generation_params?.source_filter;
   if (typeof configured === "string") return configured.toLowerCase();
   const path = model.model_file_path?.toLowerCase() ?? "";
-  return SOURCE_FILTERS.find((filter) => path.includes(filter)) ?? "";
+  return SOURCE_FILTERS.filter((filter) => path.includes(filter)).pop() ?? "";
 }
 
 export async function renderB04Surface(root: HTMLElement): Promise<void> {
@@ -138,6 +117,7 @@ export async function renderB04Surface(root: HTMLElement): Promise<void> {
   let appliedFilter = DEFAULT_FILTER;
   let appliedMethod = DEFAULT_METHOD;
   const viewer = createSurfacePointCloudViewer();
+  const quality = createQualityPanel(); // 762-2 고른 모델의 서피스 품질 지표 넷
   const terrainViewer = createSurfaceTerrainViewer();
   const mapViewer = createSurfaceMapViewer();
   // 도엽등고 3D 서피스 — 전처리에서 함께 생성되는 참고 서피스(LAS 없는 설계의 지형 원천,
@@ -268,6 +248,7 @@ export async function renderB04Surface(root: HTMLElement): Promise<void> {
     filterGroup.root,
     methodGroup.root,
     terrainViewer.smoothingField,
+    quality.root,
   ]);
   // 표시 옵션은 3D 모델 토글과 포인트 슬라이더를 한 칸에 둔다(슬라이더가 맨 아래).
   const displayGroup = buildSurfaceGroup(L("B04_Surface_Group_Display"), [
@@ -460,6 +441,7 @@ export async function renderB04Surface(root: HTMLElement): Promise<void> {
     if (!projectId) return;
     terrainViewer.setSelection(filterGroup.select.value, methodGroup.select.value);
     terrainViewer.render(projectId, models);
+    quality.show(projectId, findSelectedModel());
     confirmButton.disabled = !findSelectedModel();
   }
 
@@ -494,7 +476,7 @@ export async function renderB04Surface(root: HTMLElement): Promise<void> {
     ]);
     models = modelResponse.models;
     // 확정본과 같은 조합에서 시작해야 B05와 같은 파일을 보고, 보관함도 한 벌만 쓴다.
-    // 확정 이력이 없을 때만 개발 기본값(csf·dtm)으로 둔다.
+    // 확정 이력이 없을 때만 개발 기본값(ptd·implicit)으로 둔다.
     if (confirmed.model_id) {
       if (confirmed.source_filter) filterGroup.select.value = confirmed.source_filter;
       if (confirmed.method) methodGroup.select.value = confirmed.method;

B04_PreProcess/B04_PreProcess_UI_TerrainViewer.ts

@@ -1,7 +1,6 @@
 import * as THREE from "three";
 import { OrbitControls } from "three/examples/jsm/controls/OrbitControls.js";
 import { GLTFLoader } from "three/examples/jsm/loaders/GLTFLoader.js";
-import { PLYLoader } from "three/examples/jsm/loaders/PLYLoader.js";
 import { API_BASE_URL } from "@config/config_frontend";
 import { fetchCachedBytes } from "../A00_Common/b_asset_cache";
 import { currentLanguageIndex, ui_locales } from "@ui/ui_template_locale";
@@ -75,7 +74,7 @@ export function createSurfaceTerrainViewer(): SurfaceTerrainViewer {
     minValSpan,
     progress,
   } = buildTerrainViewerChrome();
-  let activeFilter = "csf";
+  let activeFilter = "";
   let activeMethod = "dtm";
 
   /** 진행률(0~1, 모르면 null)과 문구를 표시한다. label이 null이면 서클을 감춘다. */
@@ -348,7 +347,7 @@ export function createSurfaceTerrainViewer(): SurfaceTerrainViewer {
   }
 
   function syncSmoothingSupport(): void {
-    const supported = activeMethod === "tin" || activeMethod === "dtm";
+    const supported = activeMethod === "dtm";
     smoothSelect.disabled = !supported;
     smoothSelect.value = supported && smoothPreferred ? "on" : "off";
     smoothLabel.classList.toggle("is-disabled", !supported);
@@ -372,8 +371,8 @@ export function createSurfaceTerrainViewer(): SurfaceTerrainViewer {
     showProgress(null, "모델 조회 중…");
 
     // 1. Find matching model in list
-    // model_type is TIN / DTM / NURBS / Implicit / Meshfree (we match activeMethod)
-    // model_file_path contains the activeFilter (e.g. csf, pmf, grid_min_z)
+    // model_type is DTM / Implicit (we match activeMethod)
+    // model_file_path contains the activeFilter (e.g. ptd_refine, classification)
     const match = currentModelsList.find((m) => {
       const typeMatches = m.model_type.toLowerCase() === activeMethod.toLowerCase();
       const configuredFilter = m.generation_params?.source_filter;
@@ -391,7 +390,7 @@ export function createSurfaceTerrainViewer(): SurfaceTerrainViewer {
     }
 
     const modelId = match.id;
-    const isSmooth = (activeMethod === "tin" || activeMethod === "dtm") && smoothingOn();
+    const isSmooth = activeMethod === "dtm" && smoothingOn();
     currentModelId = modelId;
     currentModelSmooth = isSmooth;
     const generation = ++loadGeneration;
@@ -410,52 +409,34 @@ export function createSurfaceTerrainViewer(): SurfaceTerrainViewer {
       });
       if (generation !== loadGeneration) return;
 
-      if (activeMethod === "meshfree") {
-        const geometry = new PLYLoader().parse(buffer);
-        geometry.computeBoundingSphere();
-        const material = new THREE.PointsMaterial({
-          size: 0.35,
-          vertexColors: geometry.hasAttribute("color"),
-          sizeAttenuation: true,
-        });
-        const points = new THREE.Points(geometry, material);
-        points.visible = surfCheck.checked;
-        terrainMesh = points;
-        scene.add(points);
-        fitCamera(points);
-        showProgress(1, "등고선을 그리는 중…");
-        await loadSelectedContours(modelId, isSmooth);
-        showProgress(null, null);
-      } else {
-        new GLTFLoader().parse(
-          buffer,
-          "",
-          async (gltf) => {
-            if (generation !== loadGeneration) {
-              disposeObject(gltf.scene);
-              return;
+      new GLTFLoader().parse(
+        buffer,
+        "",
+        async (gltf) => {
+          if (generation !== loadGeneration) {
+            disposeObject(gltf.scene);
+            return;
+          }
+          gltf.scene.traverse((child) => {
+            if (child instanceof THREE.Mesh) {
+              child.material.side = THREE.DoubleSide;
+              child.material.vertexColors = child.geometry.hasAttribute("color");
             }
-            gltf.scene.traverse((child) => {
-              if (child instanceof THREE.Mesh) {
-                child.material.side = THREE.DoubleSide;
-                child.material.vertexColors = child.geometry.hasAttribute("color");
-              }
-            });
-            gltf.scene.visible = surfCheck.checked;
-            terrainMesh = gltf.scene;
-            scene.add(gltf.scene);
-            fitCamera(gltf.scene);
-            showProgress(1, "등고선을 그리는 중…");
-            await loadSelectedContours(modelId, isSmooth);
-            showProgress(null, null);
-          },
-          () => {
-            if (generation !== loadGeneration) return;
-            statusSpan.textContent = "3D 메쉬 파일이 없거나 로드할 수 없습니다.";
-            showProgress(null, null);
-          },
-        );
-      }
+          });
+          gltf.scene.visible = surfCheck.checked;
+          terrainMesh = gltf.scene;
+          scene.add(gltf.scene);
+          fitCamera(gltf.scene);
+          showProgress(1, "등고선을 그리는 중…");
+          await loadSelectedContours(modelId, isSmooth);
+          showProgress(null, null);
+        },
+        () => {
+          if (generation !== loadGeneration) return;
+          statusSpan.textContent = "3D 메쉬 파일이 없거나 로드할 수 없습니다.";
+          showProgress(null, null);
+        },
+      );
     } catch (e) {
       statusSpan.textContent = "3D 파일 로드에 실패했습니다.";
       showProgress(null, null);

B05_Profile/B05_Profile_Api_Replan.ts

@@ -6,8 +6,8 @@
  *   POST /projects/{id}/route/replan       → 노선 초안 저장(346-3 · draft = 계약 RouteDraft · as_initial)
  *   GET  /projects/{id}/route/terrain-sources → 고를 수 있는 분석 지형(라이다 · 수치지형도)
  *
- * 편집 창 분석(지반고 · 횡단 미리보기)은 설계 지형 그대로 — 지형 고르기는 추천 창 안 · [적용]이
- * 그 지형을 설계 지형으로(509-5).
+ * 편집 창 분석(지반고 · 횡단 미리보기)은 설계 지형 그대로 — 설계 지형 바꿈 = 평면 도구줄 지형 칩
+ * (`/route/design-terrain` · 626-1 · `_Terrain`).
  *
  * 재계산은 배수유역부터 전 단계를 다시 도는 무거운 작업이라(용화 67측점 기준 3분대)
  * 타임아웃을 길게 잡는다 — 기본값으로 두면 중간에 끊긴다.
@@ -73,6 +73,8 @@ export interface RoutePlanResponse {
   project_id: string;
   /** 예상노선(원본) **점 묶음** [[x, y], …] — 사업지 좌표계(m). 폴리라인이 아니다. */
   expected: Array<[number, number]>;
+  /** 고친 예정노선(626-2 · [저장] 때 `expected_route_edit.csv`) — 없으면 빈 목록 · 원본 `expected` 는 그대로. */
+  expected_edited?: Array<[number, number]>;
   /** 계획노선 폴리라인(원호 포함) — 그려 보이는 선. 잡는 대상이 아니다. */
   planned: Array<[number, number]>;
   /** 잡아 옮기는 노드(꺾임점). 편집은 이것으로 한다(2026-09-06 사용자 지시). */

B05_Profile/B05_Profile_Api_RouteInitial.ts

@@ -81,6 +81,8 @@ export interface PrecomputeProgress {
   done: number;
   total: number;
   mode: RouteInitialLogic | null;
+  /** 기록은 「도는 중」인데 서버가 다시 켜져 끊김(763-4) — 추천 요청 409 가 이어 셈을 예약. */
+  interrupted?: boolean;
 }
 
 /** 미리 셈 진행 — 못 읽으면 null(진행 표시만 빠짐). */

B05_Profile/B05_Profile_Engine_InitialProfile.py

@@ -213,15 +213,10 @@ def source_fingerprint() -> str:
 
 
 def stat_marks(paths: list[Path]) -> list[str]:
-    """큰 자료(지형 npz · 도엽) 자국 — 이름 · 크기 · 수정시각."""
-    marks = []
-    for path in sorted(paths):
-        try:
-            info = path.stat()
-            marks.append(f"{path.name}:{info.st_size}:{info.st_mtime_ns}")
-        except OSError:
-            marks.append(f"{path.name}:-")
-    return marks
+    """큰 자료(지형 npz · 도엽) 자국 — 이름 · 내용 지문(763-2 · 시각만 바뀌면 같음)."""
+    from common_util.common_util_derived_store import file_digest
+
+    return [f"{path.name}:{file_digest(path) or '-'}" for path in sorted(paths)]
 
 
 def fingerprint(parts: dict[str, Any], source: str | None = None) -> str:

B05_Profile/B05_Profile_Engine_RouteInitial.py

@@ -28,7 +28,8 @@
 가파른 지형(옆경사 중앙값 67 %)에서는 제약 안의 길이 폭 10~20 m 한 띠뿐이라 갈래끼리 가까울 수
 있다 — 응답 `similar`(10 m 안인 다른 갈래) · `band_width_m`(띠 폭 어림)로 알린다(PLAN 23-4).
 
-공통 제약(follow 밖 모든 갈래 · **넘지 못함**) — 최소 곡선반지름 · 계류 이격 · 곡선 MC = 일반측점:
+공통 제약(follow 밖 모든 갈래 · **넘지 못함** · 측점 맞춤 · 합치기 없음 = 가이드 선 · 요구 611) —
+최소 곡선반지름 · 계류 이격:
   · 종단기울기 — 지반 기울기가 상한을 넘는 링크는 탐색에서 뺌(비탈 곧장 오르는 길 막이). 곡선
     맞춤 뒤 측점(20 m) 사이 **원지반 기울기는 참고만**(계획선 높이로 푸는 값 · 요구 253-1 · 419) —
     못 지킨 곳 수(`over_limit.total`)에 안 듦 · 목록엔 남음. 시종점 높이 차가 상한을 넘으면
@@ -55,29 +56,27 @@ from __future__ import annotations
 import hashlib
 import json
 import math
+from dataclasses import replace
 from pathlib import Path
 from typing import Any
 
 import numpy as np
-from shapely.geometry import LineString
 
-from B05_Profile.B05_Profile_Engine_RouteInitial_CrossEarth import (
-    cross_earthwork,
-    cross_earthwork_delta,
+from B05_Profile.B05_Profile_Engine_RouteInitial_CrossEarth import cross_earthwork
+from B05_Profile.B05_Profile_Engine_RouteInitial_Follow import (
+    FollowLand,
+    merged_follow,
 )
-from B05_Profile.B05_Profile_Engine_RouteInitial_Merge import RouteEarth
 from B05_Profile.B05_Profile_Engine_RouteInitial_Metrics import GRADE_SMOOTH_M, route_metrics
 from B05_Profile.B05_Profile_Engine_RouteInitial_Pool import (
     Pool,
     build_pool,
     choose,
     hard_limits,
-    settle,
     similar,
     weighted,
 )
 from B05_Profile.B05_Profile_Engine_RouteInitial_Profile import (
-    STATION_M,
     _reference,
     attach_profile,
     cover_shortfall,
@@ -93,9 +92,8 @@ from B05_Profile.B05_Profile_Engine_RouteInitial_Search import (
 )
 from B05_Profile.B05_Profile_Engine_RouteInitial_Station import (
     off_station_count,
-    snap_curves_to_stations,
+    with_station_misses,
 )
-from common_util.common_util_route_polyline import build_planned_polyline
 
 __all__ = ["NoRoute", "Terrain", "generate_initial_route"]
 
@@ -158,6 +156,7 @@ def load_terrain_and_streams(
         _load_or_build_cost_surface,
     )
     from common_util.common_util_crs import resolve_project_crs
+    from common_util.common_util_derived_store import file_digest
 
     filter_key = str(selection.get("source_filter"))
     method = str(selection.get("method") or "dtm")
@@ -165,11 +164,7 @@ def load_terrain_and_streams(
     models_dir = project_root / _MODELS_SUBDIR if models_dir is None else Path(models_dir)
     stream_path = project_root / "B04_PreProcess" / "processed" / STREAM_FILE
     crs = resolve_project_crs(project_root)
-    try:
-        stat = stream_path.stat()
-        stream_stamp = f"{stat.st_mtime_ns}:{stat.st_size}"
-    except OSError:
-        stream_stamp = "-"
+    stream_stamp = file_digest(stream_path) or "-"  # 내용 지문(763-2)
     signature = "|".join(
         (
             filter_key,
@@ -354,18 +349,13 @@ def generate_initial_route(
             )
         )
 
-    def fit(outline: Any, guard: Any = None) -> Any:
-        # R = 일반측점(383-1) — 갈래 후보는 직접 잼(`guard` · 406 · 거리 한도 없음) · 추적은 제약을
-        # 안 따짐(새 초기 노선 `snapped_initial` 과 같은 잣대 · 거리 한도 그대로).
-        moved = snap_curves_to_stations(outline, min_radius_m, guard=guard)
-        return outline if moved is None else moved
-
-    def follow_line() -> tuple[Any, dict[str, Any]]:
-        # 예상노선 추적 = 전처리 초기값(`planned_route_initial.csv` · 383-1 측점 맞춤)과 같은
-        # 규칙 · 같은 입력 → 같은 선. 제약은 따지지 않고 넘은 곳만 목록에 뜸.
-        outline = build_planned_polyline(expected, min_radius_m=min_radius_m)
-        route = (outline, measure(outline, bound=None, follow=True))
-        return settle(route, fit, measure, bound=None, follow=True)
+    def follow_line(grid: Any = None) -> tuple[Any, dict[str, Any]]:
+        # 예상노선 추적 = 전처리 초기값(`planned_route_initial.csv`)과 같은 함수(곡선 최적 · 측점
+        # 맞춤 · 758-1 `..._Follow.merged_follow`) · 같은 입력 → 같은 선. 넘은 곳만 목록에 뜸.
+        land = FollowLand(terrain, streams, max_grade, stream_offset, grade_smooth, goal_grade)
+        land = replace(land, standard=standard, corridor_m=corridor_m)
+        outline = merged_follow(expected, min_radius_m, land, grid)
+        return outline, with_station_misses(measure(outline, bound=None, follow=True), outline)
 
     def profiled(route: Any, exact: bool = True) -> None:
         if route is not None:
@@ -393,32 +383,6 @@ def generate_initial_route(
             design_curves=[curve.as_dict() for curve in line.curves],
         )
 
-    def route_earth(line: Any) -> float:
-        # 합치기 멈춤 잣대 = 계획고 지반고 횡단(1차 종단 규칙 · 종단 끔과 같음)
-        try:
-            found = cross(line)
-        except ValueError:
-            return math.inf
-        return found["cut"] + found["fill"]
-
-    def merge_delta(before: Any, after: Any, window: tuple[float, float]) -> float:
-        # 바뀐 자리 측점만 — 뒤 측점은 같은 선을 따라 밀린 것뿐(옛 선 끝 s1 → 새 선 s1 + 연장 차)
-        shift = LineString(after.vertices).length - LineString(before.vertices).length
-        first = math.ceil(window[0] / STATION_M) * STATION_M
-        try:
-            return cross_earthwork_delta(
-                before.vertices,
-                after.vertices,
-                np.arange(first, window[1] + shift + 1e-9, STATION_M),
-                terrain,
-                standard,
-                before_chainages=np.arange(first, window[1] + 1e-9, STATION_M),
-                design_curves_before=[curve.as_dict() for curve in before.curves],
-                design_curves_after=[curve.as_dict() for curve in after.curves],
-            )["earth"]
-        except ValueError:
-            return math.inf
-
     def cross_score(route: Any, capped: bool) -> float:
         # 후보 줄 세움(419) — 켬 = 상한 누른 계획선(`_reference`) 횡단 · 끔 = 계획고 지반고 횡단
         held = pool.scores if pool is not None else {}
@@ -466,16 +430,7 @@ def generate_initial_route(
             graph = RouteGraph(grid, expected, limit=max_grade, min_radius_m=min_radius_m)
             while len(_POOLS) >= POOL_CACHE_SIZE:
                 _POOLS.pop(next(iter(_POOLS)))
-            # 합치기 멈춤 토공 = 노선 횡단 + 바뀐 측점 횡단 차이(420 `..._CrossEarth` · 419)
-            _POOLS[key] = build_pool(
-                graph,
-                follow_line(),
-                max_grade,
-                min_radius_m,
-                measure,
-                fit,
-                cross=RouteEarth(route_earth, merge_delta),
-            )
+            _POOLS[key] = build_pool(graph, follow_line(grid), max_grade, min_radius_m, measure)
         pool = _POOLS[key]
         bound = pool.bound
         if target == "weighted":
@@ -484,8 +439,7 @@ def generate_initial_route(
             # 토공 · 공사비 = 횡단 토공으로 줄 세움 · 종단 반영 켬이면 위 후보만 균형 종단(빠른
             # 판) · 고른 하나만 아래에서 바로 셈(419)
             outline, metrics = choose(target, pool.candidates, with_profile, quick, cross_score)
-    # 후보는 이미 측점에 맞춘 선(383-1 · `..._Pool.settle` · 맞추기 전 선은 안 냄 · 419)
-    snapped = (outline, metrics)
+    # 추천 = 계산 로직 결과 그대로(합치기 · 측점 맞춤 없음 · 요구 611) · 추적만 평면계획선 길
 
     def finish(route: tuple[Any, dict[str, Any]]) -> dict[str, Any]:
         # 정밀 종단은 낼 사본에만 — 묶음 캐시 후보는 빠른 판 그대로 둬 다음 고르기가 같은 잣대끼리
@@ -506,7 +460,7 @@ def generate_initial_route(
             "metrics": values,
         }
 
-    shown = finish(snapped)
+    shown = finish((outline, metrics))
     ends = ends_grade(expected, terrain, shown["metrics"]["length_m"])
     return {
         "mode": mode,

B05_Profile/B05_Profile_Engine_RouteInitial_Fit.py

@@ -0,0 +1,196 @@
+"""평면계획선 예정노선 맞춤(775 · 요구 615 · 617 · 분석 773 갈래 M) — 곡선 수 그대로 교각점 · R.
+
+`..._Follow.merged_follow` 가 같은 쪽 합치기 뒤 부름(체인 처음 · `/route/plan` · `/route/replan` ·
+`/route/follow` · 추천 「예상노선 추적」).
+- `fit_to_expected` = 틀(곡선 수) 그대로 교각점 · R 를 예정노선 1 m 점 거리 제곱합 최소로(성긴
+  자코비안 · 이웃 곡선만) → 가까운 일반측점 고름 → 「이웃 MC 사이 = 측점 사이」 · 「R ≥ 최소 R」
+  벌점을 1 → 1000 으로 키우며 다시 맞춤 → 4 자리 · R 2 자리 반올림 → 끝 확인(MC 측점 어김 0 ·
+  R ≥ 최소 R · 곡선 수 그대로) · 못 지나면 None(부르는 쪽이 지금 측점 맞춤으로 물러남 · 스냅 절대).
+- `frame_for_count` = 수정 끝 틀 고르기 — 꺾임마다 곡선인 선에서 예정노선 거리가 가장 덜 늘어나는
+  합침(교각점 지움 · 같은 쪽 둘 → 바깥 직선 교점)을 차례로 해 곡선 수 N · 굽이가 N 보다 적으면
+  그대로.
+"""
+
+from __future__ import annotations
+
+import numpy as np
+from scipy.optimize import least_squares
+from scipy.spatial import cKDTree
+from shapely.geometry import LineString, Point
+
+from B05_Profile.B05_Profile_Engine_RouteInitial_Radius import _flat
+from B05_Profile.B05_Profile_Engine_RouteInitial_Station import (
+    STATION_M,
+    curve_mc_chainages,
+    off_station_count,
+)
+from common_util.common_util_route_polyline import PlannedPolyline, build_planned_polyline
+
+Xy = tuple[float, float]
+PENALTY_STEPS = (1.0, 10.0, 100.0, 1000.0)
+
+
+def _build(points: list[Xy], radii: list[float], min_radius_m: float) -> PlannedPolyline:
+    n = len(points)
+    return build_planned_polyline(
+        points,
+        min_radius_m=min_radius_m,
+        simplify=False,
+        curve_flags=[False] + [True] * (n - 2) + [False],
+        radii=[None, *radii, None],
+    )
+
+
+def _along(coords: np.ndarray) -> np.ndarray:
+    return np.concatenate([[0.0], np.cumsum(np.hypot(*np.diff(coords, axis=0).T))])
+
+
+def _samples(vertices, step: float) -> np.ndarray:
+    c = np.asarray(vertices, float)
+    ch = _along(c)
+    s = np.arange(0.0, ch[-1] + 1e-9, step)
+    return np.c_[np.interp(s, ch, c[:, 0]), np.interp(s, ch, c[:, 1])]
+
+
+def _plain(expected: list[Xy]) -> list[Xy]:
+    """곧은 줄 위 덧점 지움 — 조밀화한 예정노선 · 원본이 같은 맞춤(체인 · `/route/follow`)."""
+    return list(LineString(expected).simplify(1e-6).coords)
+
+
+def _frame(line: PlannedPolyline, min_radius_m: float) -> tuple[list[Xy], list[float]]:
+    points, _, radii = _flat(line)
+    return points, [r if r else min_radius_m for r in radii[1:-1]]
+
+
+def _fit(points0, radii0, expected, min_radius_m, targets=None, w_mc=0.0, r_pen=5.0, nfev=100):
+    """교각점(끝 둘 고정) · R 최소제곱 — targets 주면 이웃 MC 사이 길이 = 측점 사이 벌점."""
+    P = np.asarray(points0, float)
+    n = len(P) - 2
+    E = _samples(expected, 1.0)
+    sE = np.arange(len(E), dtype=float)
+    eline = LineString(expected)
+    s_ip = np.array([eline.project(Point(p)) for p in P])
+    m, n_t = len(E), (n if targets is not None else 0)
+    sparsity = np.zeros((m + n + n_t, 3 * n), dtype=bool)
+    for k in range(1, n + 1):
+        lo, hi = s_ip[max(0, k - 2)] - 30, s_ip[min(n + 1, k + 2)] + 30
+        rows = np.where((sE >= lo) & (sE <= hi))[0]
+        for c in (2 * (k - 1), 2 * (k - 1) + 1, 2 * n + k - 1):
+            sparsity[rows, c] = True
+            sparsity[m + max(1, k - 1) - 1 : m + min(n, k + 1), c] = True
+            if n_t:
+                sparsity[m + n + max(1, k - 2) - 1 : m + n + min(n, k + 2), c] = True
+    gaps = np.diff(np.concatenate([[0.0], targets])) if n_t else None
+
+    def unpack(x):
+        pts = [tuple(P[0]), *(tuple(p) for p in x[: 2 * n].reshape(n, 2)), tuple(P[-1])]
+        return pts, list(x[2 * n :])
+
+    def resid(x):
+        pts, radii = unpack(x)
+        line = _build(pts, radii, min_radius_m)
+        d = cKDTree(_samples(line.vertices, 0.25)).query(E)[0]
+        ok = len(line.curves) == n
+        built = np.array([c.radius_m for c in line.curves]) if ok else np.zeros(n)
+        out = [d, r_pen * np.maximum(0.0, min_radius_m + 0.01 - built)]
+        if n_t:
+            mc = np.array(curve_mc_chainages(line)) if ok else np.full(n, 1e4)
+            out.append(w_mc * (np.diff(np.concatenate([[0.0], mc])) - gaps))
+        return np.concatenate(out)
+
+    x0 = np.concatenate([P[1:-1].ravel(), np.maximum(np.asarray(radii0, float), min_radius_m)])
+    lower = np.concatenate([np.full(2 * n, -np.inf), np.full(n, min_radius_m)])
+    scale = np.concatenate([np.full(2 * n, 5.0), np.full(n, 10.0)])
+    found = least_squares(
+        resid, x0, jac_sparsity=sparsity, bounds=(lower, np.inf), x_scale=scale, max_nfev=nfev
+    )
+    return unpack(found.x)
+
+
+def _targets(line: PlannedPolyline) -> np.ndarray:
+    """MC 마다 가까운 일반측점(No.1 이상 · 앞 측점보다 뒤)."""
+    out, last = [], 0.0
+    for mc in curve_mc_chainages(line):
+        last = max(last + STATION_M, round(mc / STATION_M) * STATION_M)
+        out.append(last)
+    return np.array(out)
+
+
+def passes(line: PlannedPolyline, count: int, min_radius_m: float) -> bool:
+    """끝 확인 — 곡선 수 그대로 · MC 측점 어김 0 · R ≥ 최소 R."""
+    return (
+        len(line.curves) == count
+        and off_station_count(line) == 0
+        and all(c.radius_m >= min_radius_m - 1e-6 for c in line.curves)
+    )
+
+
+def fit_to_expected(
+    frame: PlannedPolyline, expected: list[Xy], min_radius_m: float
+) -> PlannedPolyline | None:
+    """틀 곡선 수 그대로 예정노선에 맞추고 MC 를 일반측점에 놓은 선 · 끝 확인 못 지나면 None."""
+    count = len(frame.curves)
+    if count == 0:
+        return None
+    expected = _plain(expected)
+    try:
+        points, radii = _fit(*_frame(frame, min_radius_m), expected, min_radius_m)
+        targets = _targets(_build(points, radii, min_radius_m))
+        for w in PENALTY_STEPS:
+            points, radii = _fit(
+                points, radii, expected, min_radius_m, targets, w, max(5.0, w), nfev=60
+            )
+    except (ValueError, np.linalg.LinAlgError):
+        return None
+    points = [(round(x, 4), round(y, 4)) for x, y in points]
+    line = _build(points, [round(r, 2) for r in radii], min_radius_m)
+    return line if passes(line, count, min_radius_m) else None
+
+
+def _gap(line: PlannedPolyline, tree: cKDTree) -> float:
+    return float(np.square(tree.query(_samples(line.vertices, 1.0))[0]).sum())
+
+
+def _crossing(a: Xy, b: Xy, c: Xy, d: Xy) -> Xy | None:
+    """a→b 반직선 · d→c 반직선(b · c 넘어) 교점 — 둘 다 앞쪽일 때만."""
+    u, v = np.subtract(b, a), np.subtract(c, d)
+    den = u[0] * v[1] - u[1] * v[0]
+    if abs(den) < 1e-9:
+        return None
+    w = np.subtract(d, a)
+    t, s = (w[0] * v[1] - w[1] * v[0]) / den, (w[0] * u[1] - w[1] * u[0]) / den
+    if t <= 1.0 or s <= 1.0:
+        return None
+    return (float(a[0] + u[0] * t), float(a[1] + u[1] * t))
+
+
+def frame_for_count(
+    kinked: PlannedPolyline, expected: list[Xy], min_radius_m: float, count: int
+) -> PlannedPolyline:
+    """꺾임마다 곡선인 선 → 예정노선 거리가 가장 덜 늘어나는 합침을 차례로 해 곡선 수 `count`."""
+    tree = cKDTree(_samples(_plain(expected), 1.0))
+    points, radii = _frame(kinked, min_radius_m)
+    line = _build(points, radii, min_radius_m)
+    # ponytail: 한 걸음마다 후보 전부 다시 짬(곡선 30 개 · 수 초) · 느리면 바뀐 곡선 둘레만 잼
+    while len(points) - 2 > max(count, 0):
+        best = None
+        for k in range(1, len(points) - 1):
+            trials = [(points[:k] + points[k + 1 :], radii[: k - 1] + radii[k:])]
+            if k + 1 < len(points) - 1:
+                at = _crossing(points[k - 1], points[k], points[k + 1], points[k + 2])
+                if at is not None:
+                    r = max(radii[k - 1], radii[k])
+                    trials.append(
+                        (points[:k] + [at] + points[k + 2 :], radii[: k - 1] + [r] + radii[k + 1 :])
+                    )
+            for pts, rr in trials:
+                trial = _build(pts, rr, min_radius_m)
+                if len(trial.curves) != len(pts) - 2:
+                    continue
+                cost = _gap(trial, tree)
+                if best is None or cost < best[0]:
+                    best = (cost, pts, rr, trial)
+        if best is None:
+            break
+        _, points, radii, line = best
+    return line if len(line.curves) == len(points) - 2 else kinked

B05_Profile/B05_Profile_Engine_RouteInitial_Follow.py

@@ -0,0 +1,195 @@
+"""예정노선 따라가기 곡선 최적(758-1 · 요구 598-1) — 따라간 선에 「토공 최소」와 같은 둘째 단계.
+
+`B05_Profile_Route_Polyline_Write.followed_table`(체인 처음 · `/route/follow` · 받은 노선으로) ·
+추천 「예상노선 추적」(`..._RouteInitial.generate_initial_route` `follow_line`)이 같이 부름.
+
+차례(`merged_follow`) = ① 예정노선 폴리라인(꺾임점 · 묶기 · R 맞춤 · 기본 규칙) → 큰 R
+(`..._Radius.widen`) → 꺾임만 곡선으로(`curve_every_kink`) → 같은 쪽 이웃 곡선 합치기
+(`..._Merge.merge_same_side`) → ② 예정노선 맞춤(775 · `..._Fit` — 곡선 수 그대로 교각점 · R 를
+예정노선에 맞추며 MC = 일반측점 · 끝 확인 못 지나면 지금 측점 맞춤 · 수정 끝 `keep_curves` = 수정 전
+곡선 수 틀). 큰 R · 합치기 · 측점 맞춤(물러남) 모두 직접 잼
+(`Guard` · 지형 · 계류 격자 · 토공 최소 갈래와 같은 판 — 이격도 판 `keeping_offset` 은 합치기 0 ·
+측점 맞춤이 더 벗어나 안 씀) · 합치기 멈춤 = 못 지킨 곳 수 · 노선 횡단 토공 +10 %.
+지형이 없으면(`FollowLand` None) 부르는 쪽이 옛 길(순수 기하 `snapped_initial`)을 씀.
+"""
+
+from __future__ import annotations
+
+import math
+from collections import OrderedDict
+from dataclasses import dataclass
+from typing import Any
+
+import numpy as np
+from shapely.geometry import LineString
+
+from B05_Profile.B05_Profile_Engine_RouteInitial_CrossEarth import (
+    cross_earthwork,
+    cross_earthwork_delta,
+)
+from B05_Profile.B05_Profile_Engine_RouteInitial_Fit import fit_to_expected, frame_for_count
+from B05_Profile.B05_Profile_Engine_RouteInitial_Merge import Guard, RouteEarth, merge_same_side
+from B05_Profile.B05_Profile_Engine_RouteInitial_Metrics import STATION_M, route_metrics
+from B05_Profile.B05_Profile_Engine_RouteInitial_Pool import hard_limits
+from B05_Profile.B05_Profile_Engine_RouteInitial_Radius import curve_every_kink, widen
+from B05_Profile.B05_Profile_Engine_RouteInitial_Search import (
+    CORRIDOR_M,
+    ROAD_WIDTH_M,
+    SearchGrid,
+    Terrain,
+)
+from B05_Profile.B05_Profile_Engine_RouteInitial_Station import snap_curves_to_stations
+from common_util.common_util_route_polyline import PlannedPolyline, build_planned_polyline
+
+Xy = tuple[float, float]
+# 같은 입력 다시 셈 막기(끌 때 · 체인 · 추천이 같은 선을 거듭 부름) — 최근 몇 벌만
+MEMO_SIZE = 8
+_MEMO: OrderedDict[tuple, PlannedPolyline] = OrderedDict()
+
+
+@dataclass(frozen=True)
+class FollowLand:
+    """따라가기 곡선 최적의 지형 · 제약 — 추천 엔진과 같은 풀이 값(`resolve_inputs` 뒤)."""
+
+    terrain: Terrain
+    streams: list[list[Xy]]
+    max_grade: float
+    stream_offset_m: float
+    grade_smooth_m: float
+    target_grade: float
+    standard: dict[str, Any] | None = None
+    corridor_m: float = CORRIDOR_M
+
+
+def cross_total(line: PlannedPolyline, terrain: Terrain, standard: dict[str, Any] | None) -> float:
+    """합치기 멈춤 잣대 — 계획고 지반고 횡단 토공(1차 종단 규칙 · 종단 끔과 같음) · 못 재면 inf."""
+    try:
+        found = cross_earthwork(
+            line.vertices,
+            None,
+            None,
+            terrain,
+            standard,
+            design_curves=[curve.as_dict() for curve in line.curves],
+        )
+    except ValueError:
+        return math.inf
+    return found["cut"] + found["fill"]
+
+
+def cross_delta(
+    before: PlannedPolyline,
+    after: PlannedPolyline,
+    window: tuple[float, float],
+    terrain: Terrain,
+    standard: dict[str, Any] | None,
+) -> float:
+    """바뀐 자리 측점만 횡단 토공 차 — 뒤 측점은 같은 선 따라 밀림(옛 끝 s1 → 새 s1 + 연장 차)."""
+    shift = LineString(after.vertices).length - LineString(before.vertices).length
+    first = math.ceil(window[0] / STATION_M) * STATION_M
+    try:
+        return cross_earthwork_delta(
+            before.vertices,
+            after.vertices,
+            np.arange(first, window[1] + shift + 1e-9, STATION_M),
+            terrain,
+            standard,
+            before_chainages=np.arange(first, window[1] + 1e-9, STATION_M),
+            design_curves_before=[curve.as_dict() for curve in before.curves],
+            design_curves_after=[curve.as_dict() for curve in after.curves],
+        )["earth"]
+    except ValueError:
+        return math.inf
+
+
+def merged_follow(
+    points: list[Xy],
+    min_radius_m: float,
+    land: FollowLand,
+    grid: SearchGrid | None = None,
+    keep_curves: int | None = None,
+) -> PlannedPolyline:
+    """예정노선 점 묶음 → 곡선 최적 · 측점 맞춘 폴리라인(못 맞추면 맞추기 전 선). `grid` = 이미 짠
+    탐색 격자(같은 예정노선 · 추천 묶음) · 없으면 짬. `keep_curves` = 지킬 곡선 수(수정 끝 = 수정 전
+    평면계획선 곡선 수) · 없으면 합친 뒤 곡선 수."""
+    key = (
+        tuple((float(x), float(y)) for x, y in points),
+        round(min_radius_m, 6),
+        land.terrain.signature or id(land.terrain),
+        land.max_grade,
+        land.stream_offset_m,
+        land.grade_smooth_m,
+        land.target_grade,
+        land.corridor_m,
+        repr(land.standard),
+        len(land.streams),
+        keep_curves,
+    )
+    if key in _MEMO:
+        _MEMO.move_to_end(key)
+        return _MEMO[key]
+
+    def measure(line: PlannedPolyline) -> dict[str, Any]:
+        # 추천 「예상노선 추적」 잣대(follow · 못 지킨 곳 = R · 계류 · 측점 · 원지반 기울기 참고)
+        return hard_limits(
+            route_metrics(
+                line.vertices,
+                points,
+                land.terrain,
+                land.streams,
+                line.curves,
+                max_grade=land.max_grade,
+                min_radius_m=min_radius_m,
+                stream_offset_m=land.stream_offset_m,
+                road_width_m=ROAD_WIDTH_M,
+                bound_pct=None,
+                grade_smooth_m=land.grade_smooth_m,
+                follow=True,
+                target_grade=land.target_grade,
+            )
+        )
+
+    if grid is None:
+        grid = SearchGrid(
+            points,
+            land.terrain,
+            land.streams,
+            stream_offset_m=land.stream_offset_m,
+            grade_smooth_m=land.grade_smooth_m,
+            target_grade=land.target_grade,
+            corridor_m=land.corridor_m,
+        )
+    guard = Guard(grid, land.max_grade)
+    outline = build_planned_polyline(points, min_radius_m=min_radius_m)
+    route = (outline, measure(outline))
+    larger = widen(outline, points, min_radius_m, guard=guard)
+    if larger is not outline:
+        trial = (larger, measure(larger))
+        if trial[1]["over_limit"]["total"] <= route[1]["over_limit"]["total"]:
+            route = trial
+    kinked = curve_every_kink(route[0], min_radius_m)
+    if kinked is not route[0]:
+        route = (kinked, measure(kinked))
+    route = merge_same_side(
+        route,
+        guard,
+        min_radius_m,
+        measure,
+        RouteEarth(
+            lambda line: cross_total(line, land.terrain, land.standard),
+            lambda before, after, window: cross_delta(
+                before, after, window, land.terrain, land.standard
+            ),
+        ),
+    )
+    frame = route[0]
+    if keep_curves is not None and keep_curves != len(frame.curves):
+        frame = frame_for_count(kinked, points, min_radius_m, keep_curves)
+    found = fit_to_expected(frame, points, min_radius_m)
+    if found is None:  # 끝 확인 못 지남 — 지금 측점 맞춤(스냅 절대)
+        snapped = snap_curves_to_stations(route[0], min_radius_m, guard=guard)
+        found = route[0] if snapped is None else snapped
+    _MEMO[key] = found
+    while len(_MEMO) > MEMO_SIZE:
+        _MEMO.popitem(last=False)
+    return found

B05_Profile/B05_Profile_Engine_RouteInitial_Merge.py

@@ -167,6 +167,11 @@ class Guard:
     def ok(self, local: list[Xy], reference: list[Xy]) -> bool:
         return self.judge(local, reference)[0]
 
+    def rise(self, local: list[Xy], reference: list[Xy]) -> float:
+        """원지반 기울기가 상한을 넘은 만큼의 늘어남(옛 조각 대비) — 측점 맞춤 덜 나쁜 자리 고르기만
+        씀(요구 606-2 · 그 밖 잼은 419 그대로)."""
+        return self._look(local)[0] - self._look(reference)[0]
+
     @staticmethod
     def piece(before: Xy, apex: Xy, after: Xy, radius: float) -> list[Xy] | None:
         """곡선 하나가 쓰는 조각 — 앞 직선 가운데 → 원호 → 뒤 직선 가운데(직선 절반 규칙)."""

B05_Profile/B05_Profile_Engine_RouteInitial_Pool.py

@@ -12,9 +12,9 @@
   · 못 지킨 곳 수(R · 계류 · 측점 — 원지반 기울기는 참고만 · 419 `hard_limits`)가 기준(엄격: 후보
     최소 · 풂: 센 벌점 기준 길)보다 많은 후보는 뺀다. 탐색 링크 상한(비탈 곧장 오르는 길 막이)은
     남김.
-  · R = 일반측점이 기본 제약(383-1) — 후보마다 곡선 MC 를 일반측점에 맞춘 선(`snap`)으로 재고
-    고르고 거름. 못 맞춘 곡선은 「못 지킨 구간」(station) · 고르기는 측점 밖 0 후보를 앞세움.
-    꺾임만(R 없는 교점)은 안 남김(`..._Radius.curve_every_kink` · 측점 맞춤 · 419).
+  · 추천 = 평면계획선을 긋는 가이드 선(요구 611 · 769-1) — 계산 로직 결과 그대로(경로 탐색 → 곡선
+    넣기 → 큰 R) · 같은 쪽 곡선 합치기 · 측점 맞춤은 안 함(평면계획선 길 `..._Follow.merged_follow`
+    몫). 꺾임만(R 없는 교점)은 안 남김(`..._Radius.curve_every_kink` · 419).
 
 갈래는 **비교값으로** 고른다(`pick` · `GOALS`) — 토공 최소 = 절성토 합 · 기울기 순한 = 최대(같으면
 평균) · 영선 노선 = 목표 기울기 편차 · 안전 우선 = 위험 통과 길이(옆경사 35° 이상 · 계류 버퍼 안) ·
@@ -38,7 +38,7 @@ from typing import Any
 import numpy as np
 from shapely.geometry import LineString
 
-from B05_Profile.B05_Profile_Engine_RouteInitial_Merge import Guard, RouteEarth, merge_same_side
+from B05_Profile.B05_Profile_Engine_RouteInitial_Merge import Guard
 from B05_Profile.B05_Profile_Engine_RouteInitial_Metrics import (
     COST_CROSSING,
     COST_EARTH_M3,
@@ -52,7 +52,6 @@ from B05_Profile.B05_Profile_Engine_RouteInitial_Search import (
     NoRoute,
     RouteGraph,
 )
-from B05_Profile.B05_Profile_Engine_RouteInitial_Station import with_station_misses
 from common_util.common_util_route_geometry import densify_route
 from common_util.common_util_route_polyline import build_planned_polyline
 
@@ -87,8 +86,6 @@ TRACE_DENSIFY_M = 2.0
 
 Measure = Callable[..., dict[str, Any]]
 Route = tuple[Any, dict[str, Any]]
-# (선, 직접 잼) → 곡선 MC 를 일반측점에 맞춘 선(못 맞추면 그 선 그대로)
-Snap = Callable[[Any, Any], Any]
 
 
 @dataclass
@@ -96,7 +93,6 @@ class Pool:
     """같은 입력의 후보 묶음 — 갈래 고르기 · 비중 탐색이 같이 쓴다."""
 
     graph: RouteGraph
-    snap: Snap
     candidates: list[Route] = field(default_factory=list)
     bound: float | None = None
     limit: int = 0  # 후보로 남길 못 지킨 곳 수 상한
@@ -111,10 +107,8 @@ class Pool:
     follow: Route | None = None
     # 제약 안에서 갈 수 있는 띠 폭 어림 — 후보끼리 가장 먼 거리(m)
     band_width_m: float = 0.0
-    # 큰 R · 합치기 · 측점 맞춤이 거리 한도 대신 쓰는 직접 잼(406 · `..._Merge.Guard`)
+    # 큰 R 이 거리 한도 대신 쓰는 직접 잼(406 · `..._Merge.Guard`)
     guard: Guard | None = None
-    # 합치기 멈춤 토공 = 횡단(노선 + 바뀐 측점 차이 · 420 · 없으면 띠 가늠 · `merge_same_side`)
-    cross: RouteEarth | None = None
     # 후보 줄 세움 횡단 토공 기억(잰 값 id · 종단 반영) — 갈래 사이 다시 안 셈(419)
     scores: dict[tuple[int, bool], float] = field(default_factory=dict)
 
@@ -127,15 +121,6 @@ def hard_limits(metrics: dict[str, Any]) -> dict[str, Any]:
     return {**metrics, "over_limit": {**over, "total": over["total"] - over.get("grade", 0)}}
 
 
-def settle(route: Route, snap: Snap, measure: Measure, **kw: Any) -> Route:
-    """측점에 맞춘 선 + 잰 값(측점 밖 곡선 = 못 지킨 구간 · 383-1)."""
-    outline, metrics = route
-    moved = snap(outline)
-    if moved is not outline:
-        outline, metrics = moved, measure(moved, **kw)
-    return outline, with_station_misses(metrics, outline)
-
-
 def _trace(
     pool: Pool, nodes: list[tuple[float, float]], min_radius_m: float, measure: Measure, **kw: Any
 ) -> Route:
@@ -144,9 +129,9 @@ def _trace(
     # 경로를 예정노선 규칙으로 단순화 · 묶음 · R 맞춤) 차례로, 위반(R · 계류 · 원지반 기울기 뺌)이
     # 최소 R 판(노드마다 곡선 · 옛 규칙)보다 많지 않은 첫 판. 모두 화면이 [확인] 때 같은 선으로 다시
     # 짜는 꼴. 같은 노드 · 같은 잼이면 다시 재지 않음(쓸기는 이웃 비중이 같은 길을 자주 냄).
-    # 고른 판의 꺾임만을 곡선 · 교점 지움으로(419) → 같은 쪽 이웃 곡선 합치기(406 · `..._Merge`) →
-    # 측점에 맞춤(`settle` · 383-1). 큰 R · 합치기 · 측점 맞춤 모두 거리 한도 대신 직접
-    # 잼(`pool.guard`) · 비중 계산은 예상노선 이격도(그 갈래 잣대 — 예상 몫을 줄이면 이격이 늘기만).
+    # 고른 판의 꺾임만을 곡선 · 교점 지움으로(419) — 끝. 같은 쪽 곡선 합치기 · 측점 맞춤은 안 함
+    # (추천 = 가이드 선 · 요구 611). 큰 R 은 거리 한도 대신 직접 잼(`pool.guard`) · 비중 계산은
+    # 예상노선 이격도(그 갈래 잣대 — 예상 몫을 줄이면 이격이 늘기만).
     traced = pool.traced
     guard = pool.guard
     if guard is not None and kw.get("weighted"):
@@ -176,10 +161,7 @@ def _trace(
             line = curve_every_kink(chosen[0], min_radius_m)
             if line is not chosen[0]:
                 chosen = (line, measure(line, **kw))
-            chosen = merge_same_side(
-                chosen, guard, min_radius_m, lambda line: measure(line, **kw), pool.cross
-            )
-        traced[key] = settle(chosen, lambda line: pool.snap(line, guard), measure, **kw)
+        traced[key] = chosen
     return traced[key]
 
 
@@ -252,13 +234,11 @@ def build_pool(
     max_grade: float,
     min_radius_m: float,
     measure: Measure,
-    snap: Snap,
-    cross: RouteEarth | None = None,
 ) -> Pool:
     """후보 묶음 — 제약 탐색 후보 → 끝 노선 셋으로 비중 크기 맞춤 → 토공 ↔ 기울기 쓸기를 더함.
 
     `measure` 는 원지반 기울기를 뺀 못 지킨 곳 수를 내야 함(`hard_limits`)."""
-    pool = Pool(graph, snap, follow=follow, guard=Guard(graph.grid, max_grade), cross=cross)
+    pool = Pool(graph, follow=follow, guard=Guard(graph.grid, max_grade))
     pool.candidates, pool.bound, pool.limit = _candidates(pool, max_grade, min_radius_m, measure)
     candidates, bound, limit = pool.candidates, pool.bound, pool.limit
     ends = [follow[0], pick("earthwork", candidates)[0], pick("gentle", candidates)[0]]

B05_Profile/B05_Profile_Engine_RouteInitial_Station.py

@@ -24,7 +24,9 @@ R = 일반측점이 기본 제약(383-1 · 요구 241-13) — 추천 후보마
 (`..._Merge.Guard` · 복도 · 계류 · 토공이 같은 자리 원래 조각보다 안 나빠짐 · 원지반 기울기는
 참고만 · 419)으로 거름. MC = 일반측점 필수 · 꺾임만(R 없는 교점 · 삼각) 없음(419):
   · 같은 쪽으로 가장 많이 합친 꼴부터 놓아 봄(S자는 안 합침) · 자리는 그 잣대가 가장 나은 곳부터.
-  · 잼을 지나는 놓기가 없으면 덜 나쁜 놓기(복도 안) — MC 는 늘 측점에.
+  · 잼을 지나는 놓기가 없으면 덜 나쁜 놓기(복도 안) — MC 는 늘 측점에. 덜 나쁜 놓기는 원지반
+    기울기 늘어남 · 옮긴 거리를 따져 고르고 크게 망치는 놓기는 맨 뒤(다 막힐 때 그중 가장 덜
+    망치는 것 · 요구 606-2).
   · 곡선 끔 없음 — 내각 155° 이상도 곡선 · 꺾임만으로 들어온 자리도 곡선으로 놓아 봄 · 곡선을 못
     끼우는 자리(나란함)는 교점 지움 · 이웃과 한 측점을 다투면 교점째 뺌.
   · 그래도 못 놓으면 그 곡선은 그 자리(측점 밖 · 마지막 수).
@@ -80,6 +82,10 @@ RADIUS_STEPS = 8
 BACKTRACK_LIMIT = 30
 # 한 꺾임 꼴(그대로 · 합친 꼴마다)에서 볼 놓기 수 — 막히면 R · 측점만 바꾸기보다 합치기로
 PER_VARIANT = 3
+# 덜 나쁜 놓기(직접 잼 못 지남)가 「크게 망침」 — 원지반 기울기 상한 넘은 만큼이 옛 자리보다 이만큼
+# 넘게 늘거나 원래 선에서 이만큼(m) 넘게 옮김 · 다른 놓기가 다 막힐 때만 씀(요구 606-2)
+RUIN_RISE = 0.05
+RUIN_GAP_M = STATION_M / 2
 
 
 @dataclass
@@ -316,6 +322,9 @@ class _Snapper:
         self.excess = excess
         self.guard = guard
         self.keep = False
+        # 놓기 층 — 0 잼 지남 · 1 덜 나쁨 · 2 크게 망침(2 는 없이 다 놓는 길이 없을 때만 · 606-2)
+        self.tiers: tuple[int, ...] = (0, 1) if guard is not None else (0,)
+        self.memo: dict[tuple, list[tuple]] = {}  # 놓을 자리(`_found`)
         self.merged_first = guard is not None  # 같은 쪽으로 합친 꼴부터 놓아 봄(406)
 
     def _steeper(self, local: list[Xy]) -> bool:
@@ -338,15 +347,54 @@ class _Snapper:
         end_s = state.end_s + math.dist(state.end_xy, at)
         return _State(plan, state.k + 1, at, end_s, 0.0, state.last_station, state.placed)
 
-    def _placements(self, state: _State, plan: _Plan, soft: bool = False) -> Iterator[_State]:
+    def _placements(
+        self, state: _State, plan: _Plan, tier: int = 0
+    ) -> Iterator[tuple[tuple, _State]]:
         """곡선 k 를 남은 측점에 놓은 걸음들 — 가까운 측점 · 지금 R 에 가까운 것부터.
 
-        직접 잼(406)이면 잼을 지나는 자리만 · `soft` 면 못 지나는 자리(복도 안)만 — 잣대 나은 순."""
+        직접 잼(406)이면 `tier` 층 자리만 — 0 잼 지남 · 1 못 지남(복도 안 · 덜 나쁨) · 2 그중 크게
+        망침(`RUIN_RISE` · `RUIN_GAP_M`) — 잣대 나은 순 · 1 · 2 층은 원지반 기울기 늘어남 · 옮긴
+        거리도 따짐(요구 606-2 · 419 「기울기 참고만」을 이 자리만 풂)."""
         k = state.k
+        given = 0
+        for _, rank, local, new_at, new_corner, new_mc, station in sorted(
+            (item for item in self._found(state, plan) if item[0] == tier),
+            key=lambda item: item[1],
+        ):
+            if self.guard is None and (self._far(local) or self._steeper(local)):
+                continue
+            placed = plan.copy()
+            placed.points[k], placed.radii[k] = new_at, round(new_corner.radius, 3)
+            yield (
+                rank,
+                _State(
+                    placed,
+                    k + 1,
+                    new_corner.arc[-1],
+                    new_mc + new_corner.length / 2,
+                    new_corner.tangent,
+                    station,
+                    state.placed + 1,
+                ),
+            )
+            given += 1
+            if given >= PER_VARIANT:
+                return
+
+    def _found(self, state: _State, plan: _Plan) -> list[tuple]:
+        """곡선 k 를 놓을 수 있는 자리 모두 — (층, 순위, 조각, IP, 곡선, MC, 측점) · 층 · 판(망침
+        다시 셈)마다 다시 풀지 않게 기억."""
+        k = state.k
+        memo = (k, *state.end_xy, state.end_s, state.prev_tangent, state.last_station)
+        memo += (*plan.points[k - 1 : k + 2], plan.radii[k])
+        if memo in self.memo:
+            return self.memo[memo]
+        found: list[tuple] = []
+        self.memo[memo] = found
         before, at, after = plan.points[k - 1], plan.points[k], plan.points[k + 1]
         start = _try(state, plan, k, at, plan.radii[k] or self.min_radius)
         if start is None:
-            return
+            return found
         corner, mc = start
         floor_r = min(self.min_radius, corner.radius)
         half_tan = math.tan(math.radians(180.0 - _inner_angle_deg(before, at, after)) / 2)
@@ -360,7 +408,6 @@ class _Snapper:
             max(lowest, STATION_M * math.floor(mc / STATION_M)),
             max(lowest, STATION_M * math.ceil(mc / STATION_M)),
         }
-        found: list[tuple[tuple, list[Xy], Xy, _Corner, float, float]] = []
         for station in stations:
             for radius in radii:
                 solved = _solve(state, plan, k, station, radius)
@@ -372,35 +419,25 @@ class _Snapper:
                 middle = ((new_at[0] + after[0]) / 2, (new_at[1] + after[1]) / 2)
                 local = [state.end_xy, *new_corner.arc, middle]
                 rank: tuple = (tight, abs(station - mc), abs(radius - corner.radius))
+                tier = 0
                 if self.guard is not None:
                     # 직접 잼(406) — 잣대 가장 나은 자리부터 · 복도 밖은 버림
-                    passed, (out, along, earth) = self.guard.judge(
-                        local, self.reference.window(local)
-                    )
-                    if out or passed == soft:
+                    window = self.reference.window(local)
+                    passed, (out, along, earth) = self.guard.judge(local, window)
+                    if out:
                         continue
                     rank = (along, tight, rank[1], earth, rank[2])
-                found.append((rank, local, new_at, new_corner, new_mc, station))
-        given = 0
-        for _, local, new_at, new_corner, new_mc, station in sorted(
-            found, key=lambda item: item[0]
-        ):
-            if self.guard is None and (self._far(local) or self._steeper(local)):
-                continue
-            placed = plan.copy()
-            placed.points[k], placed.radii[k] = new_at, round(new_corner.radius, 3)
-            yield _State(
-                placed,
-                k + 1,
-                new_corner.arc[-1],
-                new_mc + new_corner.length / 2,
-                new_corner.tangent,
-                station,
-                state.placed + 1,
-            )
-            given += 1
-            if given >= PER_VARIANT:
-                return
+                    if not passed:
+                        # 덜 나쁜 자리 — 기울기 늘어남 · 옮긴 거리를 순위 · 문턱에(요구 606-2)
+                        rise = self.guard.rise(local, window)
+                        gap = self.reference.gap(local)
+                        ruin = max(rise / RUIN_RISE, gap / RUIN_GAP_M)
+                        tier = 2 if ruin > 1 else 1
+                        rank = (along, round(rise, 2), tight, round(gap), earth, rank[2])
+                        if tier == 2:  # 크게 망침 — 가장 덜 망치는 것부터
+                            rank = (round(ruin, 1), *rank)
+                found.append((tier, rank, local, new_at, new_corner, new_mc, station))
+        return found
 
     def _options(self, state: _State) -> Iterator[_State]:
         """꺾임점 k 의 갈래 — 측점에 놓기 → 뒤 꺾임과 합쳐 놓기 → (완만하면) 곡선 끔."""
@@ -440,9 +477,14 @@ class _Snapper:
                 same += 1
             if self.merged_first:
                 variants = variants[:same][::-1] + variants[same:]
-        for soft in (False, True) if self.guard is not None else (False,):
-            for trial in variants:
-                yield from self._placements(state, trial, soft)
+        for tier in self.tiers:
+            if not tier:
+                for trial in variants:
+                    yield from (placed for _, placed in self._placements(state, trial))
+                continue
+            # 덜 나쁨 · 크게 망침 — 꼴(합친 꼴 먼저)을 가로질러 순위대로(606-2)
+            found = [item for trial in variants for item in self._placements(state, trial, tier)]
+            yield from (placed for _, placed in sorted(found, key=lambda item: item[0]))
         # 곡선 끔 — 법이 곡선을 안 둬도 되는 완만한 꺾임 · 원래 선에서 한도 안일 때만(추천 후보는
         # 안 함 · 155° 이상도 곡선 · 419)
         middle = ((at[0] + after[0]) / 2, (at[1] + after[1]) / 2)
@@ -507,7 +549,7 @@ class _Snapper:
             if small == k:
                 yield self._kink(state, off)
             else:
-                yield from self._placements(state, off)
+                yield from (placed for _, placed in self._placements(state, off))
                 yield from self._kept(state, off)
 
     def _kept(self, state: _State, plan: _Plan | None = None) -> Iterator[_State]:
@@ -599,7 +641,12 @@ def snap_curves_to_stations(
 
 def _snap(snapper: _Snapper, min_radius_m: float) -> PlannedPolyline | None:
     """다 놓는 길 → 부분 맞춤 차례로 맞춘 선 · 못 하면 None."""
-    state = snapper.run(keep=False) or snapper.run(keep=True)
+    state = snapper.run(keep=False)
+    if state is None and snapper.guard is not None:
+        # 크게 망치는 놓기는 그것 없이 다 놓는 길(이웃 곡선 다른 배치 포함)이 없을 때만(606-2)
+        snapper.tiers = (0, 1, 2)
+        state = snapper.run(keep=False)
+    state = state or snapper.run(keep=True)
     if state is None:
         return None
     snapped = build_planned_polyline(

B05_Profile/B05_Profile_Engine_RouteInitial_Store.py

@@ -40,8 +40,10 @@ from common_util.common_util_time import utc_now_text
 
 # 3 = 곡선 MC 일반측점(351-2) · 4 = 다투는 곡선 끔(364-5) · 5 = 후보마다 맞춤(383-1) ·
 # 6 = 같은 쪽 곡선 합치기 · 거리 한도 대신 직접 잼(406) · 7 = 측점 밖이 늘면 옛 차례 맞춤(406-4) ·
-# 8 = 횡단 토공 · 표준 횡단면 = 저장 패널값 · 엔진 소스 지문(420)
-ALGO_VERSION = 8
+# 8 = 횡단 토공 · 표준 횡단면 = 저장 패널값 · 엔진 소스 지문(420) ·
+# 9 = 측점 맞춤 덜 나쁜 자리에 원지반 기울기 늘어남 · 옮긴 거리(요구 606-2) ·
+# 10 = 추천 4 갈래 합치기 · 측점 맞춤 뺌(가이드 선 · 요구 611)
+ALGO_VERSION = 10
 # 엔진 소스 지문에 드는 파일(저장소 뿌리 기준) — 추천 결과를 낳는 코드
 SOURCE_GLOBS = (
     "B05_Profile/B05_Profile_Engine_RouteInitial*.py",

B05_Profile/B05_Profile_Engine_Sections_Node.py

@@ -7,7 +7,7 @@
 (화면 묶음 stations · ground 단계와 같은 함수). 파이썬은 머리(schema_version · source ·
 coordinate_reference · cad_exchange · options)만 붙임.
 
-DTM 지표면만(격자 이진 = `dtm_grid_file`) — DTM 아닌 지표면(tin · nurbs · implicit · meshfree) ·
+DTM · implicit(굳힌 격자 641-1) 지표면만(격자 이진 = `dtm_grid_file`) — 그 밖 ·
 Node 못 돌림 = None → 부르는 쪽이 파이썬 `generate_sections`(짝 · 로그 남김).
 측점 열쇠(`key`) = 노선 저장 이월 열쇠(`B05_Profile_Route_Save._carry_cross`).
 """

B05_Profile/B05_Profile_Engine_Solver.py

@@ -19,7 +19,12 @@ from B05_Profile.B05_Profile_Engine_Geometry import (
     resample_polyline_2d,
     single_segment_dijkstra,
 )
-from common_util.common_util_surface_sampler import check_surface_keys
+from common_util.common_util_derived_store import file_digest
+from common_util.common_util_surface_sampler import (
+    DtmGridSampler,
+    check_surface_keys,
+    implicit_grid_npz,
+)
 from config.config_system import (
     FOREST_ROAD_MAX_GRADE,
     FOREST_ROAD_MIN_CURVE_R_M,
@@ -71,14 +76,12 @@ def _sample_surface_on_grid(
     y_coords: np.ndarray,
     dtm_z: np.ndarray,
 ) -> np.ndarray:
-    """확정 지표면 모델의 표고를 DTM 격자에 샘플링한다(실패 시 DTM으로 폴백)."""
+    """확정 지표면 표고를 DTM 격자에 샘플링 — 파일 없음 · 깨짐은 까닭 그대로 던짐(763-1)."""
     check_surface_keys(filter_key, method)
     if method == "dtm":
         return dtm_z
 
     models_dir = Path(models_dir)
-    xx, yy = np.meshgrid(x_coords, y_coords)
-    query = np.column_stack([xx.ravel(), yy.ravel()])
 
     def _finalize(z_flat: np.ndarray) -> np.ndarray:
         z = np.asarray(z_flat, dtype=np.float64).reshape(len(y_coords), len(x_coords))
@@ -88,60 +91,20 @@ def _sample_surface_on_grid(
         return z
 
     try:
-        suffix = "_smooth" if smooth else ""
-        if method == "tin":
-            from scipy.interpolate import LinearNDInterpolator
-
-            path = models_dir / f"tin_{filter_key}{suffix}.npz"
-            if not path.exists():
-                path = models_dir / f"tin_{filter_key}.npz"
-            d = np.load(path)
-            verts = np.asarray(d["vertices"], dtype=np.float64)
-            interp = LinearNDInterpolator(verts[:, :2], verts[:, 2])
-            return _finalize(interp(query))
-
-        if method == "nurbs":
-            from scipy.interpolate import RectBivariateSpline
-
-            d = np.load(models_dir / f"nurbs_{filter_key}.npz")
-            cx = np.asarray(d["control_x"], dtype=np.float64)
-            cy = np.asarray(d["control_y"], dtype=np.float64)
-            cz = np.asarray(d["control_z"], dtype=np.float64)
-            degree = int(d["degree"][0]) if "degree" in d else 3
-            spline = RectBivariateSpline(
-                cy, cx, cz, kx=min(degree, len(cy) - 1), ky=min(degree, len(cx) - 1)
-            )
-            return _finalize(spline(y_coords, x_coords).ravel())
-
         if method == "implicit":
-            from scipy.interpolate import RBFInterpolator
-
-            d = np.load(models_dir / f"implicit_{filter_key}.npz")
-            centers = np.asarray(d["centers_xy"], dtype=np.float64)
-            cz = np.asarray(d["center_z"], dtype=np.float64)
-            smoothing = float(d["smoothing"][0]) if "smoothing" in d else 0.0
-            interp = RBFInterpolator(
-                centers,
-                cz,
-                neighbors=min(64, len(centers)),
-                smoothing=smoothing,
-                kernel="thin_plate_spline",
-            )
-            out = np.empty(len(query), dtype=np.float64)
-            for s in range(0, len(query), 50_000):
-                e = min(s + 50_000, len(query))
-                out[s:e] = interp(query[s:e])
-            return _finalize(out)
-
-        if method == "meshfree":
-            from scipy.interpolate import griddata
-
-            d = np.load(models_dir / f"meshfree_{filter_key}.npz")
-            pts = np.asarray(d["points"], dtype=np.float64)
-            z = griddata(pts[:, :2], pts[:, 2], query, method="linear")
-            return _finalize(z)
-    except Exception:
-        return dtm_z
+            # 굳힌 1 m 격자(641-1) 마디 그대로 — B05 종횡단 표본기와 같은 값 · RBF 다시 안 셈(763-1)
+            grid = DtmGridSampler.open_cached(implicit_grid_npz(models_dir, filter_key))
+            ix = np.abs(grid.x[None, :] - np.asarray(x_coords)[:, None]).argmin(axis=1)
+            iy = np.abs(grid.y[None, :] - np.asarray(y_coords)[:, None]).argmin(axis=1)
+            off = max(np.abs(grid.x[ix] - x_coords).max(), np.abs(grid.y[iy] - y_coords).max())
+            if off > 1e-3:
+                raise ValueError(f"굳힌 격자 축이 DTM 과 다름: implicit_{filter_key}_grid.npz")
+            return _finalize(grid.z[np.ix_(iy, ix)])
+    except FileNotFoundError as error:
+        name = Path(error.filename).name if error.filename else f"{method}_{filter_key}"
+        raise FileNotFoundError(f"지표면 모델 파일이 없습니다: {name}") from error
+    except Exception as error:  # noqa: BLE001 — 깨진 파일 = 까닭 그대로 409
+        raise ValueError(f"지표면 모델을 읽지 못함({method}_{filter_key}): {error}") from error
 
     return dtm_z
 
@@ -157,6 +120,9 @@ def _source_npz_paths(models_dir: Path, filter_key: str, method: str, smooth: bo
     if method != "dtm":
         candidates.append(models_dir / f"{method}_{filter_key}{suffix}.npz")
         candidates.append(models_dir / f"{method}_{filter_key}.npz")
+    # 비용면이 읽는 굳힌 격자 — 서명 전에 지음(763-1)
+    if method == "implicit" and candidates[-1].exists():
+        candidates.append(implicit_grid_npz(models_dir, filter_key))
     seen: set[Path] = set()
     out: list[Path] = []
     for p in candidates:
@@ -167,11 +133,10 @@ def _source_npz_paths(models_dir: Path, filter_key: str, method: str, smooth: bo
 
 
 def _cost_surface_signature(models_dir: Path, filter_key: str, method: str, smooth: bool) -> str:
-    """비용면 재빌드 필요 시 바뀌는 서명(격자해상도 + 소스파일 mtime/size)."""
+    """비용면 서명(격자해상도 + 소스파일 이름 · 내용 지문 · 763-2 — 시각만 바뀌면 같음)."""
     parts = [f"res={ROUTE_GRID_RES_M}", f"method={method}", f"smooth={smooth}"]
     for p in _source_npz_paths(models_dir, filter_key, method, smooth):
-        st = p.stat()
-        parts.append(f"{p.name}:{int(st.st_mtime)}:{st.st_size}")
+        parts.append(f"{p.name}:{file_digest(p)}")
     return "|".join(parts)
 
 

B05_Profile/B05_Profile_Route_Polyline_Write.py

@@ -146,6 +146,33 @@ def _write_planned_polyline(
     섞여 있어 다시 단순화하면 꺾임점이 조금씩 지워지고, 그것을 반복하면 [확인]을 누를
     때마다 선이 깎인다(2026-09-07 실측: 정점 136 → 134 → 119). 낳은 값을 그대로 보관한다.
     """
+    result, table = polyline_table(
+        points,
+        radius_m,
+        simplify=simplify,
+        curve_flags=curve_flags,
+        radii=radii,
+        station_snap=station_snap,
+        station_snap_step=station_snap_step,
+        locks=locks,
+        arcs=arcs,
+    )
+    return _write_table(path, result, table)
+
+
+def polyline_table(
+    points: list[tuple[float, float]],
+    radius_m: float,
+    *,
+    simplify: bool = True,
+    curve_flags: list[bool] | None = None,
+    radii: list[float | None] | None = None,
+    station_snap: bool | None = None,
+    station_snap_step: float | None = None,
+    locks: list[str | None] | None = None,
+    arcs: list[float | None] | None = None,
+) -> tuple[PlannedPolyline, dict[str, Any]]:
+    """`_write_planned_polyline` 의 셈 몫 — (폴리라인, 곡선표) · 파일 안 씀(626-2)."""
     edited = curve_flags is not None or radii is not None
     made = (
         node_polyline(points, radius_m, curve_flags, radii, locks, arcs)
@@ -163,8 +190,6 @@ def _write_planned_polyline(
             radii=radii,
         )
         edits = node_edits(points, curve_flags, radii, locks, arcs) if edited else None
-    write_route_csv(path, [{"x": x, "y": y} for x, y in result.vertices])
-    write_route_csv(_nodes_path(path), [{"x": node.x, "y": node.y} for node in result.nodes])
     table: dict[str, Any] = {
         "min_radius_m": round(radius_m, 3),
         "curves": [c.as_dict() for c in result.curves],
@@ -175,6 +200,38 @@ def _write_planned_polyline(
         table["station_snap_step"] = float(station_snap_step)
     if edits is not None:
         table["edits"] = edits
+    return result, table
+
+
+def followed_table(
+    points: list[tuple[float, float]],
+    radius_m: float,
+    land: Any = None,
+    keep_curves: int | None = None,
+) -> tuple[PlannedPolyline, dict[str, Any]]:
+    """예정노선 추적(383-1) — 점 묶음 → 곡선 MC 를 일반측점에 맞춘 폴리라인 + 곡선표(스냅 켬).
+
+    체인 초기 폴리라인(`_ensure_planned_initial`) · `/route/follow`(626-2)가 같이 씀 · 못 맞추면
+    지금 선. `land`(`..._RouteInitial_Follow.FollowLand`) 주면 곡선 최적(큰 R · 같은 쪽 합치기 ·
+    758-1 · 추천 「예상노선 추적」과 같은 함수) · 없으면 순수 기하.
+    `keep_curves` = 지킬 곡선 수(775 · 수정 끝 = 수정 전 곡선 수).
+    """
+    from B05_Profile.B05_Profile_Engine_RouteInitial_Station import snapped_initial
+
+    if land is not None:
+        from B05_Profile.B05_Profile_Engine_RouteInitial_Follow import merged_follow
+        from B05_Profile.B05_Profile_Engine_RouteInitial_Radius import _flat
+
+        fit = _flat(merged_follow(points, radius_m, land, keep_curves=keep_curves))
+    else:
+        fit = snapped_initial(points, radius_m)
+    shape = {"simplify": False, "curve_flags": fit[1], "radii": fit[2]} if fit else {}
+    return polyline_table(fit[0] if fit else points, radius_m, station_snap=True, **shape)
+
+
+def _write_table(path: Path, result: PlannedPolyline, table: dict[str, Any]) -> dict:
+    write_route_csv(path, [{"x": x, "y": y} for x, y in result.vertices])
+    write_route_csv(_nodes_path(path), [{"x": node.x, "y": node.y} for node in result.nodes])
     _curves_path(path).write_text(json.dumps(table, ensure_ascii=False), encoding="utf-8")
     return {
         "nodes": len(result.nodes),

B05_Profile/B05_Profile_Route_Save.py

@@ -75,6 +75,8 @@ class RouteDraftInput(BaseModel):
     stationSnap: bool = False  # noqa: N815
     stationSnapStep: float | None = None  # noqa: N815 — 390-5
     terrain: Literal["las", "sheet"] | None = None
+    #: 고친 예정노선(626-2) — 없음 = 그대로 · [] = 지움 · 점 묶음 = `expected_route_edit.csv`
+    expected: list[tuple[float, float]] | None = None
 
 
 class RouteSaveRequest(RouteReplanRequest):