feat(view): 확대기초·말뚝 inputs on ② (입력만): footing L, W, h1, blinding margin and thickness, steel and PHC pile lists

The footing card takes L, W, h1 (default 2000), the blinding margin on each side (100) and thickness (100). The pile is picked
from the 강관 or PHC list by outer diameter and wall; the inner diameter, area and weight are read from the list. Defaults are
the 1단계 constants, so P1 is unchanged. The model reads them (footing width, height, blinding, pile diameter; the footing
length for grouping). 복합 말뚝 and the rule-pending items stay disabled; the footing rebar is not yet tied to these
inputs (1·2단계 후).

Co-Authored-By: Claude Haiku 5.5 <noreply@anthropic.com>

src/core/changes.ts

@@ -8,6 +8,13 @@ export const EDITABLE_FIELDS = [
   { key: 'copingWidthMm', label: '코핑 폭 B', unit: 'mm' },
   { key: 'copingLengthMm', label: '코핑 길이 L', unit: 'mm' },
   { key: 'columnDiameterMm', label: '기둥 직경 D', unit: 'mm' },
+  { key: 'footingLengthMm', label: '확대기초 길이 L', unit: 'mm' },
+  { key: 'footingWidthMm', label: '확대기초 폭 W', unit: 'mm' },
+  { key: 'footingHeightMm', label: '확대기초 높이 h1', unit: 'mm' },
+  { key: 'blindingMarginMm', label: '비림 여유 (한쪽)', unit: 'mm' },
+  { key: 'blindingThicknessMm', label: '비림 두께', unit: 'mm' },
+  { key: 'pileOuterMm', label: '말뚝 외경 D', unit: 'mm' },
+  { key: 'pileThicknessMm', label: '말뚝 두께 t', unit: 'mm' },
   { key: 'copingH1Mm', label: '끝단 높이 h1', unit: 'mm' },
   { key: 'copingH2Mm', label: '테이퍼 높이 h2', unit: 'mm' },
   { key: 'levelWidthMm', label: 'Level 폭', unit: 'mm' },
@@ -23,6 +30,13 @@ export const FIELD_LABELS: Record<EditableKey, string> = {
   copingWidthMm: '코핑 폭 B',
   copingLengthMm: '코핑 길이 L',
   columnDiameterMm: '기둥 직경 D',
+  footingLengthMm: '확대기초 길이 L',
+  footingWidthMm: '확대기초 폭 W',
+  footingHeightMm: '확대기초 높이 h1',
+  blindingMarginMm: '비림 여유 (한쪽)',
+  blindingThicknessMm: '비림 두께',
+  pileOuterMm: '말뚝 외경 D',
+  pileThicknessMm: '말뚝 두께 t',
   copingH1Mm: '끝단 높이 h1',
   copingH2Mm: '테이퍼 높이 h2',
   levelWidthMm: 'Level 폭',

src/core/geometry.ts

@@ -357,15 +357,16 @@ export function buildPier(input: PierInput): PierModel {
     }
   }
 
+  const fd = footingDims(input);
   // Footings are grouped per stretch so that a 일체기초 never crosses the kink; each group is aligned with its stretch.
   const footingSets: { s: number; k: number; length: number }[] = [];
   for (let k = 0; k < stretchCount; k++) {
-    for (const g of footingGroups(colG.filter((_, i) => colK[i] === k))) {
+    for (const g of footingGroups(colG.filter((_, i) => colK[i] === k), fd.L)) {
       footingSets.push({ s: g.s - base[k], k, length: g.length });
     }
   }
 
-  const footingTop = input.foundationType === '현장타설말뚝' ? input.footingBottomEl : input.footingBottomEl + DIM.footingH;
+  const footingTop = input.foundationType === '현장타설말뚝' ? input.footingBottomEl : input.footingBottomEl + fd.H;
   const columns: ColumnModel[] = colG.map((g, i) => ({
     s: g - base[colK[i]],
     k: colK[i],
@@ -386,19 +387,19 @@ export function buildPier(input: PierInput): PierModel {
     });
   } else {
     for (const f of footingSets) {
-      footings.push({ s: f.s, k: f.k, top: footingTop, bottom: input.footingBottomEl, length: f.length, width: DIM.footingW });
+      footings.push({ s: f.s, k: f.k, top: footingTop, bottom: input.footingBottomEl, length: f.length, width: fd.W });
       blindings.push({
         s: f.s,
         k: f.k,
         top: input.footingBottomEl,
-        length: f.length + DIM.blindingMargin,
-        width: DIM.footingW + DIM.blindingMargin,
-        thickness: DIM.blindingT,
+        length: f.length + fd.blM,
+        width: fd.W + fd.blM,
+        thickness: fd.blT,
       });
       if (input.foundationType === '말뚝기초') {
-        const g = pileGeometry(f.length);
+        const g = pileGeometry(f.length, fd.W);
         const counts = resolveRowCounts(input.pileRows, g);
-        piles.push(...pilesFor(f.s, input.footingBottomEl, pileLength, g, counts).map((p) => ({ ...p, k: f.k })));
+        piles.push(...pilesFor(f.s, input.footingBottomEl, pileLength, g, counts, fd.pileD).map((p) => ({ ...p, k: f.k })));
       }
     }
   }
@@ -464,7 +465,7 @@ export function buildPier(input: PierInput): PierModel {
       columnHeight: levelBottom - columns[0].bottom,
       soilCover: input.groundEl - (input.foundationType === '현장타설말뚝' ? input.footingBottomEl : footingTop),
       pileCount: piles.length,
-      pileLayout: input.foundationType === '말뚝기초' ? layoutText(resolveRowCounts(input.pileRows, pileGeometry(footings[0].length)), pileGeometry(footings[0].length)) : null,
+      pileLayout: input.foundationType === '말뚝기초' ? layoutText(resolveRowCounts(input.pileRows, pileGeometry(footings[0].length, fd.W)), pileGeometry(footings[0].length, fd.W)) : null,
       pileTipEl: piles.length ? pileTip : null,
       blockHeightFront,
       blockHeightBack,
@@ -488,16 +489,16 @@ function segmentTop(segments: Segment[], s: number): number {
  * Footings (spec §4.6). Adjacent columns closer than one footing length share a 일체기초 whose length is
  * the distance between its outer columns + DIM.footingL, centred between them. Other columns get their own footing.
  */
-export function footingGroups(colS: number[]): { s: number; length: number }[] {
+export function footingGroups(colS: number[], footL: number = DIM.footingL): { s: number; length: number }[] {
   const groups: number[][] = [];
   for (const s of [...colS].sort((a, b) => a - b)) {
     const last = groups[groups.length - 1];
-    if (last && s - last[last.length - 1] < DIM.footingL) last.push(s);
+    if (last && s - last[last.length - 1] < footL) last.push(s);
     else groups.push([s]);
   }
   return groups.map((g) => ({
     s: (g[0] + g[g.length - 1]) / 2,
-    length: g[g.length - 1] - g[0] + DIM.footingL,
+    length: g[g.length - 1] - g[0] + footL,
   }));
 }
 
@@ -506,15 +507,28 @@ export function footingGroups(colS: number[]): { s: number; length: number }[] {
  * both with an end distance of 0.7 m and an even spacing that never exceeds 2.25 m.
  */
 /** Pile geometry of one footing, from the 1단계 constants (spec §4.6). */
-export function pileGeometry(footingLength: number): PileGeometry {
-  return { footingLength, footingWidth: DIM.footingW, end: DIM.pileEnd, minSpacing: DIM.pileSpacing };
+export function pileGeometry(footingLength: number, footingWidth: number = DIM.footingW): PileGeometry {
+  return { footingLength, footingWidth, end: DIM.pileEnd, minSpacing: DIM.pileSpacing };
+}
+
+/** Footing and pile dimensions in m: the input when given, else the 1단계 constants (승인 2026-10-23). */
+export function footingDims(input: PierInput): { L: number; W: number; H: number; blM: number; blT: number; pileD: number } {
+  return {
+    L: (input.footingLengthMm ?? DIM.footingL * 1000) / 1000,
+    W: (input.footingWidthMm ?? DIM.footingW * 1000) / 1000,
+    H: (input.footingHeightMm ?? DIM.footingH * 1000) / 1000,
+    // 비림 여유 is the margin on each side (삽도 한쪽 100); the blinding grows by twice that on each length and width.
+    blM: (2 * (input.blindingMarginMm ?? DIM.blindingMargin * 500)) / 1000,
+    blT: (input.blindingThicknessMm ?? DIM.blindingT * 1000) / 1000,
+    pileD: (input.pileOuterMm ?? DIM.pileDiameter * 1000) / 1000,
+  };
 }
 
 /**
  * Piles under one footing (spec §4.6): one 열 per row across the width, each with its own count along the length.
  * counts holds the 본수 of each 열 (see core/piles.ts).
  */
-export function pilesFor(s: number, topEl: number, length: number, g: PileGeometry, counts: number[]): PileModel[] {
+export function pilesFor(s: number, topEl: number, length: number, g: PileGeometry, counts: number[], diameter: number = DIM.pileDiameter): PileModel[] {
   const rows = rowLayout(counts, g);
   const spacingN = (g.footingWidth - 2 * g.end) / (counts.length - 1);
   const out: PileModel[] = [];
@@ -526,7 +540,7 @@ export function pilesFor(s: number, topEl: number, length: number, g: PileGeomet
         n: (j - (counts.length - 1) / 2) * spacingN,
         top: topEl,
         bottom: topEl - length,
-        diameter: DIM.pileDiameter,
+        diameter,
       });
     }
   });

src/core/pile-spec.ts

@@ -0,0 +1,41 @@
+/**
+ * 말뚝 규격 목록 (승인 2026-10-23): the outer diameter D and wall t are chosen from the list; the inner diameter, area and
+ * unit weight are read from it. 강관 and PHC are separate lists; 복합 말뚝 is entered as 강관 + PHC later (1·2단계 후).
+ */
+export interface PileSpec {
+  kind: '강관' | 'PHC';
+  /** 외경 D (mm). */
+  D: number;
+  /** 두께 t (mm). */
+  t: number;
+  /** 내경 (mm). */
+  inner: number;
+  /** 단면적 (cm²). */
+  area: number;
+  /** 단위중량 (kg/m for 강관, kN/m for PHC as in the sheet). */
+  unitWeight: number;
+}
+
+export const STEEL_PILES: PileSpec[] = [
+  { kind: '강관', D: 406.4, t: 9, inner: 388.4, area: 112, unitWeight: 88.2 },
+  { kind: '강관', D: 406.4, t: 12, inner: 382.4, area: 149, unitWeight: 116.7 },
+  { kind: '강관', D: 508.0, t: 9, inner: 490.0, area: 141, unitWeight: 110.7 },
+  { kind: '강관', D: 508.0, t: 12, inner: 484.0, area: 187, unitWeight: 146.8 },
+  { kind: '강관', D: 508.0, t: 14, inner: 480.0, area: 217, unitWeight: 170.5 },
+  { kind: '강관', D: 609.6, t: 9, inner: 591.6, area: 170, unitWeight: 133.3 },
+  { kind: '강관', D: 609.6, t: 12, inner: 585.6, area: 225, unitWeight: 176.8 },
+  { kind: '강관', D: 609.6, t: 14, inner: 581.6, area: 262, unitWeight: 205.6 },
+  { kind: '강관', D: 609.6, t: 16, inner: 577.6, area: 298, unitWeight: 234.2 },
+];
+
+export const PHC_PILES: PileSpec[] = [
+  { kind: 'PHC', D: 400, t: 65, inner: 270, area: 684, unitWeight: 1.74 },
+  { kind: 'PHC', D: 450, t: 70, inner: 310, area: 836, unitWeight: 2.13 },
+  { kind: 'PHC', D: 500, t: 80, inner: 340, area: 1056, unitWeight: 2.69 },
+  { kind: 'PHC', D: 600, t: 90, inner: 420, area: 1442, unitWeight: 3.67 },
+];
+
+/** The spec of an outer diameter and wall from the list of its kind, or undefined when the pair is not in the list. */
+export function findPileSpec(kind: '강관' | 'PHC', D: number, t: number): PileSpec | undefined {
+  return (kind === '강관' ? STEEL_PILES : PHC_PILES).find((p) => p.D === D && p.t === t);
+}

src/core/types.ts

@@ -44,6 +44,16 @@ export interface PierInput {
   bearings: Bearing[];
   /** 솔플레이트 plan per bearing (승인 2026-10-23): A, B (mm) and the slope S (%). Absent = no solplate. */
   bearingPlans?: { no: number; A: number; B: number; S: number }[];
+  /** 확대기초 L (축 방향), W, 높이 h1 (mm); 비림 여유 and 비림 두께 (mm); 말뚝 외경 D and 두께 t (mm). Absent = the 1단계 constants. */
+  footingLengthMm?: number;
+  footingWidthMm?: number;
+  footingHeightMm?: number;
+  blindingMarginMm?: number;
+  blindingThicknessMm?: number;
+  pileOuterMm?: number;
+  pileThicknessMm?: number;
+  /** 말뚝 종류 (규격 목록): 강관 (default) or PHC. */
+  pileKind?: '강관' | 'PHC';
   /** 공통 규칙 for the solplate: centre thickness T, 솔플 여유 margin (mm), bearing height h3 (mm). */
   solplate?: { T: number; margin: number; h3: number };
 }

src/main.ts

@@ -18,6 +18,7 @@ import { buildQuantity, quantityRows, type Quantity, type QuantityLine } from '.
 import { parseDrawingRows } from './core/drawing-import';
 import { parseBearingElevationTable, parseSolplateTable, readDxfTexts } from './core/dxf-table';
 import { columnDiameterIssues } from './core/column-check';
+import { findPileSpec, PHC_PILES, STEEL_PILES } from './core/pile-spec';
 import { P1_COPING_GEOM } from './core/coping-geom';
 import { applyBearingRules, BEARING_ELEVATION_REF, BEARING_RULES_DEFAULT, type BearingBasis, type BearingRules, type DrawingBearing, DRAWING_TOL_MM, drawingCopingCheck, SOLPLATE_REF, SOLPLATE_T_RULE, solplateTs, withDrawingBasis } from './core/bearing-ref';
 
@@ -71,7 +72,7 @@ const MEMBERS: { id: MemberId; label: string; keys: EditableKey[]; note: string
   { id: 'bearing', label: '교량받침·받침블럭·솔플레이트', keys: [], note: '받침 상세(C3)는 Q16 결정 후 추가합니다. 지금은 표시만 합니다.' },
   { id: 'coping', label: '코핑', keys: ['copingWidthMm', 'copingLengthMm', 'copingH1Mm', 'copingH2Mm', 'levelWidthMm'], note: '폭, 길이, 끝단 높이 h1, 테이퍼 높이 h2, Level 폭을 입력합니다. 계단 위치·단차선 입력은 다음 단계에서 추가합니다.' },
   { id: 'column', label: '기둥', keys: ['columnDiameterMm'], note: '기둥 직경 D를 입력합니다 (1200–3000 mm, 50 mm 단위). 높이와 위치는 계산값입니다.' },
-  { id: 'footing', label: '확대기초 · 말뚝', keys: ['pileLengthMm'], note: '말뚝 길이를 입력합니다. 열별 본수는 다음 단계에서 추가합니다.' },
+  { id: 'footing', label: '확대기초 · 말뚝', keys: ['footingLengthMm', 'footingWidthMm', 'footingHeightMm', 'blindingMarginMm', 'blindingThicknessMm', 'pileLengthMm'], note: '확대기초 치수, 비림, 말뚝 길이와 규격을 입력합니다. 규칙 미정 항목(모따기, 경사, 복합 말뚝)은 다음 단계에서 추가합니다.' },
   { id: 'ground', label: '지반·지층', keys: [], note: '지반고는 입력값을 표시만 합니다. 지층 입력은 다음 단계에서 추가합니다.' },
 ];
 
@@ -198,6 +199,14 @@ function withCopingDefaults(input: PierInput): PierInput {
   return {
     ...input,
     columnDiameterMm: input.columnDiameterMm ?? 2000,
+    footingLengthMm: input.footingLengthMm ?? 10400,
+    footingWidthMm: input.footingWidthMm ?? 8150,
+    footingHeightMm: input.footingHeightMm ?? 2000,
+    blindingMarginMm: input.blindingMarginMm ?? 100,
+    blindingThicknessMm: input.blindingThicknessMm ?? 100,
+    pileKind: input.pileKind ?? '강관',
+    pileOuterMm: input.pileOuterMm ?? 609.6,
+    pileThicknessMm: input.pileThicknessMm ?? 12,
     copingH1Mm: input.copingH1Mm ?? P1_COPING_GEOM.h1,
     copingH2Mm: input.copingH2Mm ?? P1_COPING_GEOM.h2,
     levelWidthMm: input.levelWidthMm ?? P1_COPING_GEOM.levelWidth,
@@ -707,6 +716,52 @@ function footingLengthOf(p: Pier): number | undefined {
   return p.model?.footings[0]?.length;
 }
 
+/** 말뚝 규격 (승인 2026-10-23): 강관 and PHC from their lists by outer diameter and wall; the inner diameter, area and weight are read. */
+function renderPileSpec(box: HTMLDivElement, pier: Pier): void {
+  const kind = pier.draft.pileKind ?? '강관';
+  const list = kind === '강관' ? STEEL_PILES : PHC_PILES;
+  const cur = findPileSpec(kind, pier.draft.pileOuterMm ?? 609.6, pier.draft.pileThicknessMm ?? 12);
+  const wrap = el('div', undefined, 'pile-spec');
+  const kindSel = el('select');
+  kindSel.id = 'pile-kind';
+  for (const k of ['강관', 'PHC'] as const) {
+    const o = el('option', k === '강관' ? '강관 말뚝' : 'PHC 말뚝');
+    o.value = k;
+    kindSel.appendChild(o);
+  }
+  kindSel.value = kind;
+  kindSel.addEventListener('change', () => {
+    const first = (kindSel.value === '강관' ? STEEL_PILES : PHC_PILES)[0];
+    setPileSpec(pier.input.name, kindSel.value as '강관' | 'PHC', first.D, first.t);
+  });
+  const sizeSel = el('select');
+  sizeSel.id = 'pile-size';
+  for (const p of list) {
+    const o = el('option', `${p.D} × ${p.t}`);
+    o.value = `${p.D}|${p.t}`;
+    sizeSel.appendChild(o);
+  }
+  if (cur) sizeSel.value = `${cur.D}|${cur.t}`;
+  sizeSel.addEventListener('change', () => {
+    const [D, t] = sizeSel.value.split('|').map(Number);
+    setPileSpec(pier.input.name, kind, D, t);
+  });
+  const info = cur
+    ? `내경 ${cur.inner} mm · 단면적 ${cur.area} cm² · 단위중량 ${cur.unitWeight} ${kind === '강관' ? 'kg/m' : 'kN/m'}`
+    : '목록에 없는 규격입니다.';
+  wrap.append(el('label', '말뚝 종류 '), kindSel, el('label', ' 외경 × 두께 '), sizeSel, el('p', info, 'muted small'));
+  box.appendChild(wrap);
+}
+
+function setPileSpec(name: string, kind: '강관' | 'PHC', D: number, t: number): void {
+  const p = state.piers.find((q) => q.input.name === name);
+  if (!p) return;
+  p.draft = { ...p.draft, pileKind: kind, pileOuterMm: D, pileThicknessMm: t };
+  state.piers = state.piers.map((q) => (q === p ? regenerateEntry(q) : q));
+  setupScene();
+  renderAll();
+}
+
 /** 열별 본수 −/+ per 열 (spec §5.4). Shows the spacing, the total, and a warning below the minimum spacing. */
 function renderPileRows(box: HTMLDivElement, pier: Pier): void {
   const footingLength = footingLengthOf(pier);
@@ -1587,7 +1642,10 @@ function renderPlan(): void {
     regen.disabled = true;
   } else {
     fieldRows(fields, pier, member.keys);
-    if (member.id === 'footing') renderPileRows(fields, pier);
+    if (member.id === 'footing') {
+      renderPileSpec(fields, pier);
+      renderPileRows(fields, pier);
+    }
     if (member.id === 'coping') renderCopingInfo(fields, pier);
     if (member.id === 'bearing') renderBearingRef(fields, pier);
     if (FCK_MEMBERS.includes(member.id as FckMember)) renderMemberFck(fields, member.id as FckMember);