feat(bearing): 일체 block as one stepped block per pair, with its rebar (승인 2026-10-26)

- integrated-block.ts: per pair (전열 k · 후열 k) one block centred on the
  pair midpoint, 2500 across the 교축 and 1200 along the 교각축, with a
  stepped top (each half to its own bearing row top). Only when 일체 is chosen
  and every pair is within 100 mm; otherwise 분리 is kept (B02).
- Rebar: S2 19 bars at 125 across the 2500 (10 front half, 9 back half), each
  leg from its half's top; S1 8 bars across the 1200, 3800 long, depth from
  the lower top. Totals per pier: S1 40, S2 95 (분리: 80 / 80).
- Scene and 3D rebar draw the stepped blocks instead of the per-bearing blocks.
- The per-bearing blocks stay for the solplate, the pads, and the body.

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

src/core/geometry.ts

@@ -1,4 +1,5 @@
 import { buildAxis, copingSpan, fromAxis, kinkArc, nearKink, toAxis } from './axis';
+import { buildIntegratedBlocks, type IntegratedBlock } from './integrated-block';
 import { layoutText, resolveRowCounts, rowLayout, type PileGeometry } from './piles';
 import type { PierInput, Row } from './types';
 import { type CopingGeom, P1_COPING_GEOM } from './coping-geom';
@@ -170,6 +171,8 @@ export interface PierModel {
   columnDiameterMm: number;
   bearings: BearingLocal[];
   blocks: BlockModel[];
+  /** 일체 블록 (승인 2026-10-26): empty unless 일체 is chosen and allowed. The per-bearing blocks stay for the solplate and pads. */
+  integratedBlocks: IntegratedBlock[];
   columns: ColumnModel[];
   footings: FootingModel[];
   blindings: BlindingModel[];
@@ -456,6 +459,7 @@ export function buildPier(input: PierInput): PierModel {
     columnDiameterMm: colD * 1000,
     bearings: [...frontPlaced, ...backPlaced].map((b) => ({ no: b.no, row: b.row, k: b.k, s: b.s, g: b.g, n: b.n, z: b.z })),
     blocks,
+    integratedBlocks: buildIntegratedBlocks(blocks, input.bearingLayout === '일체'),
     columns,
     footings,
     blindings,

src/core/integrated-block.ts

@@ -0,0 +1,47 @@
+import type { BlockModel } from './geometry';
+import { integratedCheck, pairEccentricities } from './bearing-layout';
+
+/**
+ * 일체 블록 (승인 2026-10-26): one block per front–back pair, centred on the pair's midpoint.
+ * Length 2500 across the 교축 (n) covers the pair (C1 600 + C2 1298 + C1 600), width 1200 along the 교각축 (s).
+ * The top is stepped: the front half follows the front block top, the back half the back block top (단이 있는 블록).
+ * Only built when every pair is within the eccentricity limit; otherwise the model keeps 분리 (see integratedCheck).
+ */
+export const INTEGRATED_BLOCK = { length: 2500, depth: 1200 } as const;
+
+export interface IntegratedBlock {
+  frontNo: number;
+  backNo: number;
+  /** Centre along the coping length (s, m) — the mean of the pair. */
+  s: number;
+  /** Centre across the 교축 (n, m) — the midpoint of the pair; the step line is here. */
+  n: number;
+  /** Bottom EL (m): the lower of the two bottoms. */
+  bottom: number;
+  /** Top EL of the front half (전열 side, m). */
+  topFront: number;
+  /** Top EL of the back half (후열 side, m). */
+  topBack: number;
+  /** Mean row skew (deg) of the pair. */
+  rowSkewDeg: number;
+}
+
+/** Integrated blocks of a pier: empty unless 일체 is chosen and every pair is within the limit. */
+export function buildIntegratedBlocks(blocks: BlockModel[], chosen: boolean): IntegratedBlock[] {
+  if (!chosen || !integratedCheck(blocks).allowed) return [];
+  const pick = (no: number, row: BlockModel['row']) => blocks.find((b) => b.no === no && b.row === row)!;
+  return pairEccentricities(blocks).map((p) => {
+    const f = pick(p.frontNo, '전열');
+    const b = pick(p.backNo, '후열');
+    return {
+      frontNo: p.frontNo,
+      backNo: p.backNo,
+      s: (f.s + b.s) / 2,
+      n: (f.n + b.n) / 2,
+      bottom: Math.min(f.bottom, b.bottom),
+      topFront: f.top,
+      topBack: b.top,
+      rowSkewDeg: (f.rowSkewDeg + b.rowSkewDeg) / 2,
+    };
+  });
+}

src/core/rebar/bearing-block.ts

@@ -1,4 +1,5 @@
 import type { PierModel } from '../geometry';
+import { INTEGRATED_BLOCK, type IntegratedBlock } from '../integrated-block';
 
 /**
  * 받침블럭 철근 (spec §6.3 · plan C2), 배치 분리: one block per bearing, 1200 × 1200.
@@ -64,6 +65,10 @@ export interface BlockRebar {
  * since the bar depths are measured from the block top. h1 / h2 include the 50 pad and would count it twice.
  */
 export function bearingBlockRebar(model: PierModel): BlockRebar[] {
+  // 일체 (승인 2026-10-26): one block per pair replaces the two per-bearing blocks.
+  if (model.integratedBlocks.length > 0) {
+    return model.integratedBlocks.map((ib) => ({ no: ib.frontNo, row: '전열', bars: integratedBlockBars(ib) }));
+  }
   return model.blocks.map((b) => ({
     no: b.no,
     row: b.row,
@@ -71,6 +76,30 @@ export function bearingBlockRebar(model: PierModel): BlockRebar[] {
   }));
 }
 
+/**
+ * Rebar of one 일체 block (승인 2026-10-26, 받침블럭철근.md "일체 a 2500").
+ * S2 runs along the 교각축 (1200), so its bars are spaced across the 2500 length: 19 bars at 125. Its legs are measured
+ * from the top of the half it sits in; the bar at the step line (centre) counts with the front half.
+ * S1 runs along the 2500 length, 8 bars across the 1200 depth, its depth taken from the lower top (cover on the higher half is larger).
+ */
+export function integratedBlockBars(ib: IntegratedBlock): BarRow[] {
+  const half = INTEGRATED_BLOCK.length / 2;
+  const s2 = barsAcross(INTEGRATED_BLOCK.length);
+  const frontCount = Array.from({ length: s2.count }, (_, k) => s2.firstEnd + k * s2.spacing).filter((x) => x <= half + 1e-9).length;
+  const backCount = s2.count - frontCount;
+  const hFront = (ib.topFront - ib.bottom) * 1000;
+  const hBack = (ib.topBack - ib.bottom) * 1000;
+  const legS2 = (h: number) => BLOCK_REBAR.legLength - (h - BLOCK_REBAR.depthS2);
+  const s1 = barsAcross(INTEGRATED_BLOCK.depth);
+  const hLow = Math.min(hFront, hBack);
+  const rows: BarRow[] = [
+    { name: 'S2', count: frontCount, spacing: s2.spacing, firstEnd: s2.firstEnd, length: barLength(INTEGRATED_BLOCK.depth), embedment: legS2(hFront) },
+  ];
+  if (backCount > 0) rows.push({ name: 'S2', count: backCount, spacing: s2.spacing, firstEnd: s2.firstEnd, length: barLength(INTEGRATED_BLOCK.depth), embedment: legS2(hBack) });
+  rows.push({ name: 'S1', count: s1.count, spacing: s1.spacing, firstEnd: s1.firstEnd, length: barLength(INTEGRATED_BLOCK.length), embedment: BLOCK_REBAR.legLength - (hLow - BLOCK_REBAR.depthS1) });
+  return rows;
+}
+
 /** Total bars of one pier: bars per block × blocks, for S1 and S2 separately. */
 export function totals(rebar: BlockRebar[]): { S1: number; S2: number } {
   return rebar.reduce(

src/core/validate.ts

@@ -94,14 +94,14 @@ export function validatePier(input: PierInput, model: PierModel, issues: Issue[]
   validateGround(input, issues);
   validatePileEmbedment(input, model, issues);
   validateStrataNValues(input, issues);
-  // 일체 (승인 2026-10-26): the block shape of 일체 is not modelled yet, so the model keeps 분리 and says so.
+  // 일체 (승인 2026-10-26): the model builds one stepped block per pair when allowed; otherwise it keeps 분리.
   if (input.bearingLayout === '일체') {
     const check = integratedCheck(model.blocks);
     if (!check.allowed) {
       const worst = check.overLimit.map((p) => `전열 ${p.frontNo}·후열 ${p.backNo} ${p.eccentricityMm.toFixed(0)} mm`).join(', ');
       issues.push({ code: 'B02', level: 'W', pier: input.name, message: `일체를 골랐지만 편심이 100 mm를 넘는 쌍이 있어 분리로 계산합니다 (${worst || '쌍 없음'}).` });
     } else {
-      issues.push({ code: 'B01', level: 'I', pier: input.name, message: '일체 배치: 블록 형상은 아직 분리 기준으로 계산합니다 (일체 블록 모델은 다음 단계).' });
+      issues.push({ code: 'B01', level: 'I', pier: input.name, message: '일체 배치: 전열·후열 쌍마다 단이 있는 블록 (2500 × 1200)으로 계산합니다.' });
     }
   }
 }