feat(bearing): 교각 솔플레이트를 2026-11-06 결정으로 (짝 받침 S · 열 T · 거더 하면 고정)

받침방위각_솔플레이트검토.md §3과 시안(Version 110–113)을 따른다 (사용자 결정 2026-11-06: 시안 적용).
11-03 C안(받침높이 H 고정, h3 = H − T, S 입력)을 대체한다.
- S: 교량 전체(A1, P1 … Pn, A2) 거더 짝 받침의 z 차 / 수평거리. 없으면 교각 종단경사 입력 →
  다른 열 같은 순번 값(가정, WS03) → 0 %(WS03). 받침별 직접 수정(수정됨)
- 평면 L = A + 100, W = B + 100 (받침별 A × B, 기본 700 × 640 가정), h3 181
- T = 열마다 max(22, ⌈22 + L·|S|/2⌉), 열 T 직접 수정 가능(T2 < T_min → WS02).
  T1은 오르막 쪽(3D 쐐기의 두꺼운 끝도 그쪽), T2 반대쪽
- 거더 하면 고정: 블럭 상면 = z − (T − T_ref), T_ref 30
- 짝 받침은 불러오기·프로젝트 열기 때 교량 전체로 계산해 교각 생성에 넘김
- ② 카드: h3·T_ref·T_min·여유·열 T·종단경사 입력, 표에 짝 받침·S 근거·받침별 S/A/B 수정·검산 W08·검사
- P1 검증(A1과 함께): S −1.908 … −1.902 %, L 800 · W 740 · T 30 · T1 38 · T2 22, 블럭 높이 변화 없음
- 블럭·솔플레이트 테스트는 A1–P1 짝 문맥으로 실행 (짝이 없으면 S 0 · T 22 · 블럭 +8 mm)
교대(QA-15 C안)와 Pier 시트 종단경사 열 읽기는 아직 남음.

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

tests/bearing-pair.test.ts

@@ -69,3 +69,11 @@ describe('솔플레이트 열 두께 (Q-SH3·8·9, L 800)', () => {
     expect(row.ends[1]).toEqual({ T1: 38, T2: 30 });
   });
 });
+
+describe('교량 전체 짝 받침 (bridgePairs, 구조물 순서 A1 · P1 … · A2)', () => {
+  it('builds the same A1 ↔ P1 pairs from the loaded records', async () => {
+    const { bridgePairs } = await import('../src/core/bridge-pairs');
+    const pairs = bridgePairs([p1], [a1]);
+    expect(pairs.map((p) => `${p.from.structure}${p.from.no}-${p.to.structure}${p.to.no}`)).toEqual(['A11-P11', 'A12-P12', 'A13-P13', 'A14-P14', 'A15-P15']);
+  });
+});

tests/bearing-plan-svg.test.ts

@@ -1,10 +1,13 @@
 import { describe, expect, it } from 'vitest';
 import { buildPier } from '../src/core/geometry';
 import { bearingPlanSvg } from '../src/view/bearing-plan-svg';
-import { loadP1 } from './helpers';
+import { loadP1, p1Pairs } from './helpers';
 
-const separate = buildPier(loadP1());
-const integrated = buildPier({ ...loadP1(), bearingLayout: '일체' });
+// Bridge context (A1 ↔ P1 girder pairs) as in the app, so the solplate slope is computed (2026-11-06).
+const P1CTX = { pairs: p1Pairs() };
+
+const separate = buildPier(loadP1(), P1CTX);
+const integrated = buildPier({ ...loadP1(), bearingLayout: '일체' }, P1CTX);
 
 describe('교량받침 상세 평면 (승인 2026-10-26)', () => {
   it('shows C4 and C5 from the bearing to the block edges along the 교축 (600 each)', () => {
@@ -18,8 +21,8 @@ describe('교량받침 상세 평면 (승인 2026-10-26)', () => {
     expect(bearingPlanSvg(integrated, 0)).toContain('width="2500" height="1200"');
   });
 
-  it('draws the solplate of each bearing from the pier plan (L 1000 across, W 1100 along)', () => {
-    expect((bearingPlanSvg(separate, 0).match(/width="1000" height="1100"/g) ?? []).length).toBe(2);
+  it('draws the solplate of each bearing from its plan (L = A + 100 = 800, W = B + 100 = 740, 2026-11-06)', () => {
+    expect((bearingPlanSvg(separate, 0).match(/width="800" height="740"/g) ?? []).length).toBe(2);
   });
 
   it('an unknown pair index gives an empty drawing', () => {

tests/bearing-section-svg.test.ts

@@ -1,10 +1,13 @@
 import { describe, expect, it } from 'vitest';
 import { buildPier } from '../src/core/geometry';
 import { bearingSectionSvg } from '../src/view/bearing-section-svg';
-import { loadP1 } from './helpers';
+import { loadP1, p1Pairs } from './helpers';
 
-const model = buildPier(loadP1());
-const integrated = buildPier({ ...loadP1(), bearingLayout: '일체' });
+// Bridge context (A1 ↔ P1 girder pairs) as in the app, so the solplate slope is computed (2026-11-06).
+const P1CTX = { pairs: p1Pairs() };
+
+const model = buildPier(loadP1(), P1CTX);
+const integrated = buildPier({ ...loadP1(), bearingLayout: '일체' }, P1CTX);
 
 describe('교량받침 상세 단면 (승인 2026-10-26, C안 2026-11-03)', () => {
   it('labels EL.X at the mortar top and the block height h1 for each bearing', () => {

tests/bearing-table.test.ts

@@ -1,10 +1,13 @@
 import { describe, expect, it } from 'vitest';
 import { buildPier } from '../src/core/geometry';
 import { elevationRows, pairCopingSpans, solplateRows } from '../src/core/bearing-table';
-import { loadP1 } from './helpers';
+import { loadP1, p1Pairs } from './helpers';
 
-const model = buildPier(loadP1());
-const integrated = buildPier({ ...loadP1(), bearingLayout: '일체' });
+// Bridge context (A1 ↔ P1 girder pairs) as in the app, so the solplate slope is computed (2026-11-06).
+const P1CTX = { pairs: p1Pairs() };
+
+const model = buildPier(loadP1(), P1CTX);
+const integrated = buildPier({ ...loadP1(), bearingLayout: '일체' }, P1CTX);
 
 describe('교량받침 ELEVATION TABLE (모델값, 2026-11-03)', () => {
   const rows = elevationRows(model);
@@ -15,9 +18,9 @@ describe('교량받침 ELEVATION TABLE (모델값, 2026-11-03)', () => {
     expect(rows[5].elx).toBeCloseTo(43.611, 3);
   });
 
-  it('front block 100 mm, back block 150 mm; mortar 50; bearing 186; solplate 25; E = sum', () => {
-    expect(rows[0]).toMatchObject({ h1: 100, h2: 50, h3: 186, h4: 25, E: 361 });
-    expect(rows[5]).toMatchObject({ h1: 150, h2: 50, h3: 186, h4: 25, E: 411 });
+  it('front block 100 mm, back block 150 mm; mortar 50; bearing 181; solplate 30 (T = T_ref → no drop); E = sum', () => {
+    expect(rows[0]).toMatchObject({ h1: 100, h2: 50, h3: 181, h4: 30, E: 361 });
+    expect(rows[5]).toMatchObject({ h1: 150, h2: 50, h3: 181, h4: 30, E: 411 });
   });
 
   it('C1 is 600 for a 분리 bearing; C6 is the 1200 block depth; C4 and C5 are 600 each', () => {
@@ -47,12 +50,16 @@ describe('교량받침 ELEVATION TABLE (모델값, 2026-11-03)', () => {
 });
 
 describe('솔플레이트 TABLE (모델값, 2026-11-03)', () => {
-  it('10 rows with S −0.5, L 1000, W 1100, T 25, T1 27.5, T2 22.5; the check holds', () => {
+  it('10 rows: S from the A1 pair (−1.908 %), L 800, W 740, T 30, T1 38, T2 22; W08 holds within 1 mm (2026-11-06)', () => {
     const rows = solplateRows(model);
     expect(rows.length).toBe(10);
-    expect(rows[0]).toMatchObject({ S: -0.5, L: 1000, W: 1100, T: 25, T1: 27.5, T2: 22.5, ok: true });
-    expect(rows[0].checkLhs).toBeCloseTo(5, 9);
-    expect(rows[0].checkRhs).toBeCloseTo(5, 9);
+    expect(rows[0]).toMatchObject({ L: 800, W: 740, T: 30, T1: 38, T2: 22, ok: true, pair: 'A1-①', source: '계산' });
+    expect(rows[0].S).toBeCloseTo(-1.908, 3);
+    expect(rows[0].checkLhs).toBe(16);
+    expect(rows[0].checkRhs).toBeCloseTo(15.265, 2);
+    // 후열 ⑥: no pair (P2 not loaded) → the front twin ① value, 가정 + WS03.
+    expect(rows[5]).toMatchObject({ source: '가정', pair: undefined, T: 30 });
+    expect(rows[5].warnings).toContain('WS03');
   });
 });
 

tests/coping-steps.test.ts

@@ -1,8 +1,11 @@
 import { describe, expect, it } from 'vitest';
 import { buildPier } from '../src/core/geometry';
-import { loadP1 } from './helpers';
+import { loadP1, p1Pairs } from './helpers';
 
-const m = buildPier(loadP1());
+// Bridge context (A1 ↔ P1 girder pairs) as in the app, so the solplate slope is computed (2026-11-06).
+const P1CTX = { pairs: p1Pairs() };
+
+const m = buildPier(loadP1(), P1CTX);
 const front = m.blocks.filter((b) => b.row === '전열');
 const back = m.blocks.filter((b) => b.row === '후열');
 

tests/helpers.ts

@@ -3,6 +3,9 @@ import { fileURLToPath } from 'node:url';
 import * as XLSX from 'xlsx';
 import { parseWorkbook } from '../src/core/parseWorkbook';
 import type { PierInput } from '../src/core/types';
+import { parseAbutments } from '../src/core/abut/parse';
+import { type BearingPair, girderPairs } from '../src/core/bearing-pair';
+import { buildPier, type PierModel } from '../src/core/geometry';
 
 /** Spec workbook (RAG/Pier ui_xxx.xlsx, sheet intent.PR, all tables on one sheet). Used by single-sheet tests. */
 const SPEC_PATH = fileURLToPath(new URL('../public/samples/P1.xlsx', import.meta.url));
@@ -24,3 +27,22 @@ export function loadP1(): PierInput {
   if (!p1) throw new Error('P1 not found');
   return p1;
 }
+
+/**
+ * P1 with its bridge context (2026-11-06): the girder pairs A1 ①–⑤ ↔ P1 ①–⑤ from the same input workbook, so the
+ * solplate slope S is computed (−1.908 … −1.902 %, T 30) as in the app where A1 is loaded with P1.
+ */
+export function p1Pairs(): BearingPair[] {
+  const a1 = parseAbutments(loadInputWorkbook()).abutments.find((a) => a.name === 'A1');
+  if (!a1) throw new Error('A1 not found');
+  const p1 = loadP1();
+  return girderPairs([
+    { name: 'A1', bearings: a1.bearings.map((b) => ({ no: b.no, x: b.pos.e, y: b.pos.n, z: b.z, azimuthDeg: b.azimuthDeg! })) },
+    { name: p1.name, bearings: p1.bearings.map((b) => ({ no: b.no, x: b.x, y: b.y, z: b.z, azimuthDeg: b.azimuthDeg })) },
+  ]);
+}
+
+/** buildPier for P1 (with changes) in its bridge context. */
+export function buildP1(changes: Partial<PierInput> = {}): PierModel {
+  return buildPier({ ...loadP1(), ...changes }, { pairs: p1Pairs() });
+}

tests/p1-regression.test.ts

@@ -1,13 +1,16 @@
 import { describe, expect, it } from 'vitest';
 import { buildPier } from '../src/core/geometry';
-import { loadP1 } from './helpers';
+import { loadP1, p1Pairs } from './helpers';
+
+// Bridge context (A1 ↔ P1 girder pairs) as in the app, so the solplate slope is computed (2026-11-06).
+const P1CTX = { pairs: p1Pairs() };
 
 /**
  * Regression against spec.md §12 (P1, 운곡교, T형, 말뚝기초).
  * Coordinates and EL: ±1 mm (0.001 m). Angles: ±0.01°.
  */
 const TOL = 0.001;
-const model = buildPier(loadP1());
+const model = buildPier(loadP1(), P1CTX);
 
 describe('P1 regression — spec.md §12', () => {
   it('axis length and azimuth', () => {

tests/rebar-bearing.test.ts

@@ -2,7 +2,10 @@ import { describe, expect, it } from 'vitest';
 import { buildPier } from '../src/core/geometry';
 import { barsAcross, bearingBlockRebar, blockBars, totals } from '../src/core/rebar/bearing-block';
 import { rebarSummary } from '../src/core/rebar/summary';
-import { loadP1 } from './helpers';
+import { loadP1, p1Pairs } from './helpers';
+
+// Bridge context (A1 ↔ P1 girder pairs) as in the app, so the solplate slope is computed (2026-11-06).
+const P1CTX = { pairs: p1Pairs() };
 
 describe('받침블럭 철근 (spec §6.3, plan C2)', () => {
   it('a 1200 block takes 8 bars at 125 mm: 7 gaps = 875, ends 162.5 each', () => {
@@ -18,7 +21,7 @@ describe('받침블럭 철근 (spec §6.3, plan C2)', () => {
   });
 
   it('coping embedment from the model block height (block top − coping top: front 100, back 150): S2 650 / 600, S1 669.1 / 619.1', () => {
-    const m = buildPier(loadP1());
+    const m = buildPier(loadP1(), P1CTX);
     const rebar = bearingBlockRebar(m);
     const emb = (row: '전열' | '후열', name: 'S1' | 'S2') => rebar.find((b) => b.row === row)!.bars.find((r) => r.name === name)!.embedment;
     expect(emb('전열', 'S2')).toBeCloseTo(650, 6);
@@ -28,7 +31,7 @@ describe('받침블럭 철근 (spec §6.3, plan C2)', () => {
   });
 
   it('P1: 10 blocks, 80 bars each of S1 and S2 (spec table: 8 本 per block)', () => {
-    const m = buildPier(loadP1());
+    const m = buildPier(loadP1(), P1CTX);
     const rebar = bearingBlockRebar(m);
     expect(rebar).toHaveLength(10);
     expect(totals(rebar)).toEqual({ S1: 80, S2: 80 });
@@ -52,7 +55,7 @@ describe('받침블럭 도면 재현 (spec §6.3)', () => {
 
 describe('받침블럭 묻힘 검토 (spec §9 RB-S04)', () => {
   it('P1: embedments 619–669 mm are shorter than the H19 development length 882, so RB-S04 is raised and the rows show the range', () => {
-    const { rows, warnings } = rebarSummary(buildPier(loadP1()));
+    const { rows, warnings } = rebarSummary(buildPier(loadP1(), P1CTX));
     expect(warnings.some((w) => w.code === 'RB-S04')).toBe(true);
     expect(rows.find((r) => r.name === 'S1')!.note).toContain('묻힘 619–669');
     expect(rows.find((r) => r.name === 'S2')!.note).toContain('묻힘 600–650');

tests/scene.test.ts

@@ -2,9 +2,12 @@ import * as THREE from 'three';
 import { describe, expect, it } from 'vitest';
 import { buildPier } from '../src/core/geometry';
 import { buildPierScene, frameMatrix } from '../src/view/scene';
-import { loadP1 } from './helpers';
+import { loadP1, p1Pairs } from './helpers';
 
-const model = buildPier(loadP1());
+// Bridge context (A1 ↔ P1 girder pairs) as in the app, so the solplate slope is computed (2026-11-06).
+const P1CTX = { pairs: p1Pairs() };
+
+const model = buildPier(loadP1(), P1CTX);
 const M = frameMatrix(model);
 
 /** Scene coordinates of a national-grid point at EL 0 (x = E − pivot E, z = −(N − pivot N)). */
@@ -29,11 +32,11 @@ describe('3D frame (view/scene.ts)', () => {
     expect(mapped.distanceTo(expected)).toBeLessThan(1e-6);
   });
 
-  it('bounding box spans pile tip (2.208 m) to the highest solplate top (back bearing 5: pad top 43.898 m + h3 0.186 m + T1 0.0275 m)', () => {
+  it('bounding box spans pile tip (2.208 m) to the highest solplate top (back bearing 5: pad top 43.898 m + h3 0.181 m + T1 0.038 m)', () => {
     const scene = buildPierScene(model);
     const box = new THREE.Box3().setFromObject(scene.root);
     expect(box.min.y).toBeCloseTo(2.208, 2);
-    expect(box.max.y).toBeCloseTo(43.898 + 0.186 + 0.0275, 3);
+    expect(box.max.y).toBeCloseTo(43.898 + 0.181 + 0.038, 3);
   });
 
   it('builds the expected part counts for P1', () => {

tests/seat-el.test.ts

@@ -2,7 +2,10 @@ import { describe, expect, it } from 'vitest';
 import { buildPier } from '../src/core/geometry';
 import { validatePier } from '../src/core/validate';
 import type { Issue, PierInput } from '../src/core/types';
-import { loadP1 } from './helpers';
+import { loadP1, p1Pairs } from './helpers';
+
+// Bridge context (A1 ↔ P1 girder pairs) as in the app, so the solplate slope is computed (2026-11-06).
+const P1CTX = { pairs: p1Pairs() };
 
 // 교좌면 EL of the P1 sheet (받침 1–10), 2026-11-03.
 const SEAT = [43.411, 43.483, 43.555, 43.626, 43.698, 43.411, 43.483, 43.555, 43.626, 43.698];
@@ -13,8 +16,8 @@ function withSeat(input: PierInput, seats: number[]): PierInput {
 
 describe('교좌면 EL 입력 (2026-11-03)', () => {
   it('the P1 교좌면 EL values reproduce the 두부보 상면 slope: the model does not change', () => {
-    const base = buildPier(loadP1());
-    const seated = buildPier(withSeat(loadP1(), SEAT));
+    const base = buildPier(loadP1(), P1CTX);
+    const seated = buildPier(withSeat(loadP1(), SEAT), P1CTX);
     for (const b of base.blocks) {
       const s = seated.blocks.find((x) => x.no === b.no)!;
       expect(s.bottom).toBeCloseTo(b.bottom, 6);
@@ -23,20 +26,20 @@ describe('교좌면 EL 입력 (2026-11-03)', () => {
   });
 
   it('an input 교좌면 EL sets the block bottom and so h1 = (EL.X − 50 mm) − 교좌면 EL', () => {
-    const m = buildPier(withSeat(loadP1(), [43.4, ...SEAT.slice(1)]));
+    const m = buildPier(withSeat(loadP1(), [43.4, ...SEAT.slice(1)]), P1CTX);
     const b1 = m.blocks.find((x) => x.no === 1)!;
     expect(b1.bottom).toBeCloseTo(43.4, 6);
     expect((b1.top - b1.bottom) * 1000).toBeCloseTo(111, 6);
   });
 
   it('without 교좌면 EL the seatCalc is the slope value (the check reference)', () => {
-    const m = buildPier(loadP1());
+    const m = buildPier(loadP1(), P1CTX);
     expect(m.blocks.every((b) => Math.abs(b.seatCalc - b.bottom) < 1e-9)).toBe(true);
   });
 
   it('warns (W10) when the input 교좌면 EL differs from the slope by more than 5 mm, and keeps the input', () => {
     const input = withSeat(loadP1(), [43.5, ...SEAT.slice(1)]);
-    const m = buildPier(input);
+    const m = buildPier(input, P1CTX);
     const issues: Issue[] = [];
     validatePier(input, m, issues);
     const w = issues.filter((i) => i.code === 'W10');
@@ -47,7 +50,7 @@ describe('교좌면 EL 입력 (2026-11-03)', () => {
 
   it('no W10 for the P1 values', () => {
     const input = withSeat(loadP1(), SEAT);
-    const m = buildPier(input);
+    const m = buildPier(input, P1CTX);
     const issues: Issue[] = [];
     validatePier(input, m, issues);
     expect(issues.filter((i) => i.code === 'W10')).toEqual([]);

tests/solplate-scene.test.ts

@@ -3,22 +3,64 @@ import * as THREE from 'three';
 import { buildPier } from '../src/core/geometry';
 import { solplateGeometry } from '../src/core/solplate';
 import { buildPierScene } from '../src/view/scene';
-import { loadP1 } from './helpers';
+import { loadP1, p1Pairs } from './helpers';
 
-describe('솔플레이트 모델과 3D (C안, 2026-11-03)', () => {
-  it('every pier has a solplate plan from its rule; the default gives T 25 and h3 186', () => {
-    const m = buildPier(loadP1());
-    expect(m.blocks.every((b) => b.plan.T === 25 && b.plan.h3 === 186)).toBe(true);
+// Bridge context (A1 ↔ P1 girder pairs) as in the app, so the solplate slope is computed (2026-11-06).
+const P1CTX = { pairs: p1Pairs() };
+const FRONT = { 1: 3, 2: 3, 3: 3, 4: 3, 5: 3 };
+
+describe('솔플레이트 모델과 3D (결정 2026-11-06, Q-SH1–9)', () => {
+  it('every bearing: h3 181, L 800 × W 740 (A 700 × B 640 + 100), T 30, T1 38 / T2 22', () => {
+    const m = buildPier(loadP1(), P1CTX);
+    expect(m.blocks.every((b) => b.plan.h3 === 181 && b.plan.L === 800 && b.plan.W === 740 && b.plan.T === 30 && b.plan.T1 === 38 && b.plan.T2 === 22)).toBe(true);
   });
 
-  it('a pier rule changes its own plan: 받침높이 211 and slope −1 % give T 27 and h3 184', () => {
-    const m = buildPier({ ...loadP1(), solplate: { heightMm: 211, lengthMm: 1000, widthMm: 1100, slopePct: -1 } });
-    expect(m.blocks[0].plan.T).toBe(27);
-    expect(m.blocks[0].plan.h3).toBe(184);
+  it('S 3 % typed on the front row → T 34, T1 46 / T2 22, and the front blocks drop 4 mm (girder underside kept)', () => {
+    const base = buildPier(loadP1(), P1CTX);
+    const m = buildPier({ ...loadP1(), sole: { slopePct: FRONT } }, P1CTX);
+    const b1 = m.blocks.find((b) => b.no === 1)!, b0 = base.blocks.find((b) => b.no === 1)!;
+    expect(b1.plan).toMatchObject({ T: 34, T1: 46, T2: 22 });
+    expect(b1.top).toBeCloseTo(b0.top - 0.004, 9);
+    expect(b1.padTop + (b1.plan.h3 + b1.plan.T) / 1000).toBeCloseTo(b0.padTop + (b0.plan.h3 + b0.plan.T) / 1000, 9);
+    expect(m.soles.find((s) => s.no === 1)!.slopeSource).toBe('수정됨');
+    // The back row keeps its own T (30): one T per row (Q-SH9).
+    expect(m.blocks.find((b) => b.no === 6)!.plan.T).toBe(30);
+  });
+
+  it('WS02: T typed 30 at S 3 % leaves T2 18 < 22', () => {
+    const m = buildPier({ ...loadP1(), sole: { slopePct: FRONT, tByRow: { 전열: 30 } } }, P1CTX);
+    const s = m.soles.find((x) => x.no === 1)!;
+    expect(s).toMatchObject({ T: 30, tTyped: true, T2: 18 });
+    expect(s.warnings).toContain('WS02');
+  });
+
+  it('without a pair or 종단경사 the slope is 0 (WS03): T 22, the block rises 8 mm', () => {
+    const alone = buildPier(loadP1());
+    expect(alone.soles.every((s) => s.slopePct === 0 && s.warnings.includes('WS03') && s.T === 22)).toBe(true);
+    const withSlope = buildPier({ ...loadP1(), longitudinalSlope: -0.0191 });
+    expect(withSlope.soles.every((s) => s.slopeSource === '입력' && Math.abs(s.slopePct + 1.91) < 1e-9 && s.T === 30)).toBe(true);
+  });
+
+  it('T1 sits on the 오르막 쪽: the thick end of P1 ① points towards A1 (the higher girder end)', () => {
+    const m = buildPier(loadP1(), P1CTX);
+    const b = m.blocks.find((x) => x.no === 1)!;
+    const g = solplateGeometry(b, b.plan);
+    // Top corners: index (ai·2 + ci)·2 + 1; the thick end has the larger top.
+    const tops = [0, 1, 2, 3].map((q) => g.corners[q * 2 + 1]);
+    const thick = tops.filter((p) => p[1] - g.bottom > (g.T1 + g.T2) / 2), thin = tops.filter((p) => p[1] - g.bottom < (g.T1 + g.T2) / 2);
+    const mid = (ps: number[][]) => [0, 2].map((i) => ps.reduce((s, p) => s + p[i], 0) / ps.length);
+    const [ds, dn] = [mid(thick)[0] - mid(thin)[0], mid(thick)[1] - mid(thin)[1]];
+    const toThick = { e: ds * m.u.e + dn * m.nrm.e, n: ds * m.u.n + dn * m.nrm.n };
+    const p1 = loadP1().bearings[0];
+    const pair = P1CTX.pairs.find((p) => p.to.no === 1)!;
+    // A1 lies against the azimuth direction from P1 (pairs look ahead from A1 to P1).
+    const az = (p1.azimuthDeg * Math.PI) / 180;
+    expect(pair.uphill).toBe('A1');
+    expect(toThick.e * -Math.sin(az) + toThick.n * -Math.cos(az)).toBeGreaterThan(0);
   });
 
   it('the 3D scene has one solplate wedge per bearing, and its highest point is the thick end of the tallest one', () => {
-    const m = buildPier(loadP1());
+    const m = buildPier(loadP1(), P1CTX);
     const scene = buildPierScene(m);
     const wedges = scene.parts.solplates.children;
     expect(wedges.length).toBe(10);
@@ -27,13 +69,11 @@ describe('솔플레이트 모델과 3D (C안, 2026-11-03)', () => {
     expect(box.max.y).toBeCloseTo(top, 3);
   });
 
-  it('the 교량받침 본체 is one box per bearing: the plan less 100 mm on each side, height h3 (186 mm)', () => {
-    const scene = buildPierScene(buildPier(loadP1()));
+  it('the 교량받침 본체 is one box per bearing, height h3 (181 mm)', () => {
+    const scene = buildPierScene(buildPier(loadP1(), P1CTX));
     const bodies = scene.parts.bearings.children;
     expect(bodies.length).toBe(10);
     const one = new THREE.Box3().setFromObject(bodies[0]);
-    expect(one.max.y - one.min.y).toBeCloseTo(0.186, 3);
-    // Body: L − 200 = 800 across the 교각축 직각, W − 200 = 900 along the 교축; the row skew turns it a few degrees.
-    expect(Math.max(one.max.x - one.min.x, one.max.z - one.min.z)).toBeGreaterThan(0.85);
+    expect(one.max.y - one.min.y).toBeCloseTo(0.181, 3);
   });
 });