diff --git a/src/components/common/input/CalcInput.jsx b/src/components/common/input/CalcInput.jsx
index a92b86c7..6a26174d 100644
--- a/src/components/common/input/CalcInput.jsx
+++ b/src/components/common/input/CalcInput.jsx
@@ -77,7 +77,7 @@ export const CalculatorInput = forwardRef(
 
             newDisplayValue = calculator.currentOperand
             setDisplayValue(newDisplayValue)
-            onChange(newDisplayValue)
+            onChange?.(newDisplayValue)
 
             requestAnimationFrame(() => {
               if (inputRef.current) {
@@ -145,7 +145,7 @@ export const CalculatorInput = forwardRef(
           newDisplayValue = calculator.currentOperand
           setDisplayValue(newDisplayValue)
           if (!hasOperation) {
-            onChange(calculator.currentOperand)
+            onChange?.(calculator.currentOperand)
           }
         } else if (num === '.') {
           if (!calculator.currentOperand.includes('.')) {
@@ -153,7 +153,7 @@ export const CalculatorInput = forwardRef(
             newDisplayValue = calculator.currentOperand
             setDisplayValue(newDisplayValue)
             if (!hasOperation) {
-              onChange(newDisplayValue)
+              onChange?.(newDisplayValue)
             }
           }
         } else if (!shouldPreventInput(calculator.currentOperand)) {
@@ -161,7 +161,7 @@ export const CalculatorInput = forwardRef(
           newDisplayValue = calculator.currentOperand
           setDisplayValue(newDisplayValue)
           if (!hasOperation) {
-            onChange(newDisplayValue)
+            onChange?.(newDisplayValue)
           }
         }
         // else {
@@ -169,7 +169,7 @@ export const CalculatorInput = forwardRef(
         //   newDisplayValue = calculator.currentOperand
         //   setDisplayValue(newDisplayValue)
         //   if (!hasOperation) {
-        //     onChange(newDisplayValue)
+        //     onChange?.(newDisplayValue)
         //   }
         // }
       }
@@ -236,7 +236,7 @@ export const CalculatorInput = forwardRef(
       const displayValue = newValue || '0'
       setDisplayValue(displayValue)
       setHasOperation(false)
-      onChange(displayValue)
+      onChange?.(displayValue)
       // 커서를 텍스트 끝으로 이동하고 스크롤 처리
       requestAnimationFrame(() => {
         if (inputRef.current) {
@@ -260,7 +260,7 @@ export const CalculatorInput = forwardRef(
         setDisplayValue(resultStr)
         setHasOperation(false)
         // Only call onChange with the final result
-        onChange(resultStr)
+        onChange?.(resultStr)
 
         // 엔터키로 호출된 경우 포커스 설정하지 않음
         if (!fromEnterKey) {
@@ -282,7 +282,7 @@ export const CalculatorInput = forwardRef(
       const displayValue = newValue || '0'
       setDisplayValue(displayValue)
       setHasOperation(!!calculator.operation)
-      onChange(displayValue)
+      onChange?.(displayValue)
       // 커서를 텍스트 끝으로 이동하고 스크롤 처리
       requestAnimationFrame(() => {
         if (inputRef.current) {
@@ -337,10 +337,10 @@ export const CalculatorInput = forwardRef(
           calculator.currentOperand = filteredValue
           setHasOperation(false)
           // 연산자가 없는 순수 숫자일 때만 부모 컴포넌트의 onChange 호출
-          onChange(filteredValue)
+          onChange?.(filteredValue)
         }
 
-        //onChange(filteredValue)
+        //onChange?.(filteredValue)
       }
     }
 
@@ -485,7 +485,7 @@ export const CalculatorInput = forwardRef(
                 onClick={() => {
                   // const newValue = calculatorRef.current.clear()
                   // setDisplayValue(newValue || '0')
-                  // onChange(newValue || '0')
+                  // onChange?.(newValue || '0')
                   handleClear()
                   setHasOperation(false)
                 }}
@@ -497,7 +497,7 @@ export const CalculatorInput = forwardRef(
                 onClick={() => {
                   // const newValue = calculatorRef.current.deleteNumber()
                   // setDisplayValue(newValue || '0')
-                  // onChange(newValue || '0')
+                  // onChange?.(newValue || '0')
                   //setHasOperation(!!calculatorRef.current.operation)
                   handleDelete()
                 }}
@@ -532,7 +532,7 @@ export const CalculatorInput = forwardRef(
               <button
                 onClick={() => {
                   const newValue = calculatorRef.current.appendNumber('.')
-                  onChange(newValue)
+                  onChange?.(newValue)
                 }}
                 className="btn-number"
               >
diff --git a/src/hooks/roofcover/useAuxiliaryDrawing.js b/src/hooks/roofcover/useAuxiliaryDrawing.js
index c84e00a7..d47b8f47 100644
--- a/src/hooks/roofcover/useAuxiliaryDrawing.js
+++ b/src/hooks/roofcover/useAuxiliaryDrawing.js
@@ -622,10 +622,13 @@ export function useAuxiliaryDrawing(id, isUseEffect = true) {
       arrivalPoint = { ...adsorptionPoint }
     }
 
+    // [2240 MOUSELINE-EVENTED-FALSE 2026-05-20] selectable:false 만으로는 e.target 가로채기 차단 불가 — 클릭이
+    // 십자선에 잡히는 회귀 차단. mouseLine 은 시각 표시만, 좌표 계산은 filter(name==='mouseLine') 로 접근.
     const horizontalLine = new fabric.Line([-1 * canvas.width, arrivalPoint.y, 2 * canvas.width, arrivalPoint.y], {
       stroke: 'red',
       strokeWidth: 1,
       selectable: false,
+      evented: false,
       name: 'mouseLine',
     })
 
@@ -634,6 +637,7 @@ export function useAuxiliaryDrawing(id, isUseEffect = true) {
       stroke: 'red',
       strokeWidth: 1,
       selectable: false,
+      evented: false,
       name: 'mouseLine',
     })
 
diff --git a/src/hooks/roofcover/useEavesGableEdit.js b/src/hooks/roofcover/useEavesGableEdit.js
index 5304ad17..f805c5e7 100644
--- a/src/hooks/roofcover/useEavesGableEdit.js
+++ b/src/hooks/roofcover/useEavesGableEdit.js
@@ -14,7 +14,13 @@ import { settingModalFirstOptionsState } from '@/store/settingAtom'
 import { fabric } from 'fabric'
 import { QLine } from '@/components/fabric/QLine'
 import { calcLinePlaneSize } from '@/util/qpolygon-utils'
+import { findInteriorPoint } from '@/util/skeleton-utils'
 import { logger } from '@/util/logger'
+import { applyKerabOffsetSurgical } from '@/util/kerab-offset-surgical'
+
+// [2240 KERAB-OFFSET-SURGICAL 2026-05-27] 케라바 토글 시 出幅 변경분 surgical 반영 기능 토글.
+// false 로 두면 이번 세션 변경 전 동작 (apply/revert 시 출폭 입력값 무시) 으로 즉시 회귀.
+const ENABLE_KERAB_OFFSET_SURGICAL = true
 
 // 처마.케라바 변경
 export function useEavesGableEdit(id) {
@@ -145,7 +151,20 @@ export function useEavesGableEdit(id) {
   }
 
   const mouseDownEvent = (e) => {
-    logger.log('[KERAB-MOUSEDOWN] fired', { hasTarget: !!e.target, name: e.target?.name, type: typeRef.current, radio: radioTypeRef.current })
+    logger.log(
+      '[KERAB-MOUSEDOWN] fired ' +
+        JSON.stringify({
+          hasTarget: !!e.target,
+          name: e.target?.name,
+          type: typeRef.current,
+          radio: radioTypeRef.current,
+          targetType: e.target?.attributes?.type,
+          x1: e.target?.x1,
+          y1: e.target?.y1,
+          x2: e.target?.x2,
+          y2: e.target?.y2,
+        }),
+    )
     canvas.discardActiveObject()
     if (!e.target || (e.target && e.target.name !== 'outerLine')) {
       return
@@ -225,67 +244,1245 @@ export function useEavesGableEdit(id) {
       return
     }
 
-    // [2240 KERAB-SINGLE-RIDGE 2026-05-19] 대전제 1: 처마→케라바 변환 시 양 끝점에 동일 apex 의 hip 페어가 존재하면
-    // hip 2개 제거 + 처마 중점→apex ridge 1개 생성으로 처리하고 기존 rebuild 흐름은 건너뜀.
-    // 그 외 모든 케이스(hip 0/1개, 평행, 다중 변환 후 hip 소진 등)는 attribute-only 로 처리하고 rebuild 진입 차단.
+    // [2240 KERAB-NEIGHBOR-GABLE 2026-05-19] 「ケラバの隣にケラバは不可」
+    //   처마→케라바 변환 시, target 의 끝점을 공유하는 인접 외곽선 중 하나라도 이미 케라바(GABLE) 면
+    //   모든 패턴 시도 전에 조용히 무동작 (alert 없음).
+    if (typeRef.current === TYPES.GABLE && radioTypeRef.current === '1') {
+      const isSameXY = (a, b) => Math.hypot(a.x - b.x, a.y - b.y) <= 0.5
+      const tP1 = { x: target.x1, y: target.y1 }
+      const tP2 = { x: target.x2, y: target.y2 }
+      const neighbors = canvas.getObjects().filter(
+        (o) =>
+          o.name === 'outerLine' &&
+          o !== target &&
+          o.attributes?.roofId === target.attributes?.roofId,
+      )
+      const sharesEndpoint = (o, pt) => isSameXY({ x: o.x1, y: o.y1 }, pt) || isSameXY({ x: o.x2, y: o.y2 }, pt)
+      const adjGable = neighbors.find(
+        (o) => o.attributes?.type === LINE_TYPE.WALLLINE.GABLE && (sharesEndpoint(o, tP1) || sharesEndpoint(o, tP2)),
+      )
+      if (adjGable) {
+        logger.log('[KERAB-NEIGHBOR-GABLE] 인접 외곽선이 케라바 → 무동작')
+        return
+      }
+    }
+
+    // [2240 KERAB-SIMPLE 2026-05-20] 사용자 설명 정직 알고리즘:
+    //   1) target 양 끝점에 직접 끝이 닿은 hip 2개를 찾는다 (nearestRoofPoint 안 씀)
+    //   2) 두 hip 직선의 무한확장 교점 = apex
+    //   3) apex 를 통과하는 ridge(RG-1)가 존재하면 케라바 조건 충족
+    //   4) mid(target 중점) → apex 중앙선만 추가 (기존 라인 무손상)
     if (typeRef.current === TYPES.GABLE && radioTypeRef.current === '1') {
       const roof = canvas
         .getObjects()
         .find((o) => o.name === POLYGON_TYPE.ROOF && !o.isFixed && o.id === target.attributes?.roofId)
-      logger.log('[KERAB-GUARD] roof check', {
-        roofId: target.attributes?.roofId,
-        roofFound: !!roof,
-        innerLinesArray: Array.isArray(roof?.innerLines),
-        pointsArray: Array.isArray(roof?.points),
-        innerLinesLen: roof?.innerLines?.length,
-        pointsLen: roof?.points?.length,
-      })
-      if (roof && Array.isArray(roof.innerLines) && Array.isArray(roof.points)) {
-        // outerLine 끝점(벽 좌표)을 가장 가까운 roof 폴리곤 코너(offset 적용 좌표)로 스냅
-        const c1 = nearestRoofPoint(roof, { x: target.x1, y: target.y1 })
-        const c2 = nearestRoofPoint(roof, { x: target.x2, y: target.y2 })
-        logger.log('[KERAB-GUARD] c1/c2', { targetXY: { x1: target.x1, y1: target.y1, x2: target.x2, y2: target.y2 }, c1, c2 })
-        if (c1 && c2) {
-          const hipsAtC1 = findHipsAtPoint(roof, c1)
-          const hipsAtC2 = findHipsAtPoint(roof, c2)
-          logger.log('[KERAB-GUARD] hips at corners', { c1n: hipsAtC1.length, c2n: hipsAtC2.length })
-          const pair =
-            hipsAtC1.length > 0 && hipsAtC2.length > 0 ? findHipPairWithSharedApex(hipsAtC1, c1, hipsAtC2, c2) : null
-          logger.log('[KERAB-GUARD] shared-apex pair', { found: !!pair })
-          if (pair) {
-            target.set({ attributes })
-            const ok = applyKerabSingleRidgePattern(roof, target, c1, c2, pair)
-            logger.log('[KERAB-PATTERN] applied', { ok, c1, c2, apex: pair.apex })
-            if (ok) return
+      logger.log('[KERAB-SIMPLE] roof check ' + JSON.stringify({ roofId: target.attributes?.roofId, roofFound: !!roof }))
+      // [KERAB-OFFSET-SURGICAL 2026-05-27] 케라바 토글 직전 target.attributes.offset 을 roofLine 에 surgical 반영.
+      // SK 재실행 없이 외곽 corner / inner-line endpoint 만 이동 → kLine 등 layered custom 라인 보존.
+      if (roof) applyTargetOffsetSurgical(target, attributes?.offset ?? 0)
+      if (roof && Array.isArray(roof.innerLines)) {
+        // [KERAB-LABEL-LOOKUP 2026-05-21] QPolygon.__attachDebugLabels 와 동일 분류·카운팅 순서로
+        //   캔버스 객체에 라벨(H-1, RG-2, B-3 등) 매핑. 로그에 라벨을 함께 찍기 위함.
+        const labelByLine = new Map()
+        {
+          const counters = {}
+          const objs = canvas.getObjects().filter((o) => o.parentId === roof.id && o.name !== '__debugLabel')
+          for (const obj of objs) {
+            let prefix = null
+            const nm = obj.name
+            const ln = obj.lineName
+            const tp = obj.attributes?.type
+            if (nm === 'baseLine') prefix = 'B'
+            else if (nm === 'outerLine' || nm === 'eaves' || ln === 'roofLine') prefix = 'R'
+            else if (nm === LINE_TYPE.SUBLINE.HIP || ln === LINE_TYPE.SUBLINE.HIP) prefix = 'H'
+            else if (nm === LINE_TYPE.SUBLINE.RIDGE || ln === LINE_TYPE.SUBLINE.RIDGE) prefix = 'RG'
+            else if (nm === LINE_TYPE.SUBLINE.VALLEY || ln === LINE_TYPE.SUBLINE.VALLEY) prefix = 'V'
+            else if (nm === LINE_TYPE.SUBLINE.GABLE || ln === LINE_TYPE.SUBLINE.GABLE) prefix = 'G'
+            else if (nm === LINE_TYPE.SUBLINE.VERGE || ln === LINE_TYPE.SUBLINE.VERGE) prefix = 'VG'
+            else if (
+              tp === LINE_TYPE.WALLLINE.EAVE_HELP_LINE ||
+              ln === LINE_TYPE.WALLLINE.EAVE_HELP_LINE ||
+              nm === LINE_TYPE.WALLLINE.EAVE_HELP_LINE
+            )
+              prefix = 'E'
+            else if (
+              typeof obj.x1 === 'number' &&
+              typeof obj.y1 === 'number' &&
+              typeof obj.x2 === 'number' &&
+              typeof obj.y2 === 'number'
+            )
+              prefix = 'SK'
+            if (!prefix) continue
+            counters[prefix] = (counters[prefix] || 0) + 1
+            labelByLine.set(obj, `${prefix}-${counters[prefix]}`)
           }
-          // [2240 KERAB-JUNCTION-EXTENDED 2026-05-19] shared-apex 가 없으면 H-7/H-1 의 junction 너머
-          // H-4/H-2(inner hip) 를 무한확장한 교점을 apex 로. 채택 시 outer(H-7,H-1) 제거 +
-          // inner(H-4,H-2) 끝을 apex 로 늘림 + mid→apex ridge. H-7/H-1 직접 확장보다 안쪽까지 중앙선이 연장됨.
-          const jp = findHipPairViaJunction(roof, c1, c2)
-          logger.log('[KERAB-GUARD] junction-extended pair', { found: !!jp, apex: jp?.apex })
-          if (jp) {
-            target.set({ attributes })
-            const ok = applyKerabJunctionExtendedPattern(roof, target, c1, c2, jp)
-            logger.log('[KERAB-PATTERN] applied (junction-extended)', { ok })
-            if (ok) return
-          }
-          // [2240 KERAB-EXTENDED-APEX 2026-05-19] junction-extended 도 안 되면 H-7/H-1 직접 무한확장한 교점을 apex 로.
-          // apex 가 처마 중점 수선 위(가운데) 일 때만 채택. 채택 시 단일-ridge 패턴과 동일 처리.
-          const pairExt =
-            hipsAtC1.length > 0 && hipsAtC2.length > 0 ? findHipPairWithExtendedApex(hipsAtC1, c1, hipsAtC2, c2) : null
-          logger.log('[KERAB-GUARD] extended-apex pair', { found: !!pairExt, apex: pairExt?.apex })
-          if (pairExt) {
-            target.set({ attributes })
-            const ok = applyKerabSingleRidgePattern(roof, target, c1, c2, pairExt)
-            logger.log('[KERAB-PATTERN] applied (extended)', { ok })
-            if (ok) return
-          }
-          // [2240 KERAB-ATTR-ONLY 2026-05-19] hip 페어 없음(0/1개·평행·다중변환 소진·apex 가 중앙 아님 등) → 속성만 GABLE 로 변경
-          target.set({ attributes })
-          applyKerabAttributeOnlyPattern()
-          logger.log('[KERAB-ATTR-ONLY] applied (forward)', { c1, c2, hipsC1: hipsAtC1.length, hipsC2: hipsAtC2.length })
-          return
         }
+        const labelOf = (line) => (line ? labelByLine.get(line) || '?' : null)
+        const t1 = { x: target.x1, y: target.y1 }
+        const t2 = { x: target.x2, y: target.y2 }
+        const h1Match = findHipAtEndpoint(roof, t1)
+        const h2Match = findHipAtEndpoint(roof, t2)
+        logger.log(
+          '[KERAB-SIMPLE] hip lookup ' +
+            JSON.stringify({
+              target: labelOf(target),
+              t1,
+              t2,
+              h1: h1Match
+                ? { label: labelOf(h1Match.hip), near: h1Match.near, far: h1Match.far, dist: Math.round(h1Match.dist * 100) / 100 }
+                : null,
+              h2: h2Match
+                ? { label: labelOf(h2Match.hip), near: h2Match.near, far: h2Match.far, dist: Math.round(h2Match.dist * 100) / 100 }
+                : null,
+            }),
+        )
+        if (h1Match && h2Match) {
+          // [KERAB-APEX-FAR-AS-PARALLEL 2026-05-21] lineLineIntersection 은 완전 평행(det≈0) 만 null 반환.
+          //   거의 평행한 두 hip 은 천문학적 좌표의 가짜 apex 를 만들어 markerApex 오염. 좌표 크기로 평행 강제 판정.
+          let apex = lineLineIntersection(h1Match.near, h1Match.far, h2Match.near, h2Match.far)
+          if (apex) {
+            const APEX_FAR_LIMIT = 1e5
+            if (Math.abs(apex.x) > APEX_FAR_LIMIT || Math.abs(apex.y) > APEX_FAR_LIMIT) {
+              apex = null
+            }
+          }
+          logger.log(
+            '[KERAB-SIMPLE] apex ' +
+              JSON.stringify({
+                apex: apex ? { x: Math.round(apex.x * 100) / 100, y: Math.round(apex.y * 100) / 100 } : null,
+                parallel: !apex,
+              }),
+          )
+// [KERAB-PARALLEL-FULLALGO 2026-05-21] 평행(apex=null) 도 풀 알고리즘으로 처리.
+          //   폴리곤 경로 + extender 확장 + 반사/meet/apex/kLine — h1·h2 만나지 않더라도
+          //   내부 라인(path hips/ridges) 은 삭제, 접점 extender 는 인쪽 확장.
+          //   자연 만남(condition 1) 만 단축: apex 존재 + h*.far ≈ apex.
+          {
+            const EXT_TOL = 1.0
+            const isNatural =
+              !!apex &&
+              Math.hypot(h1Match.far.x - apex.x, h1Match.far.y - apex.y) <= EXT_TOL &&
+              Math.hypot(h2Match.far.x - apex.x, h2Match.far.y - apex.y) <= EXT_TOL
+            if (!isNatural) {
+              // [KERAB-POLYGON-BFS 2026-05-21] 사용자 전제 2: 내부 다각형 경계 = BFS 로 추적한
+              //   h1.far → h2.far 경로 + h1 + h2. 경로상 모든 hip/ridge 를 삭제 대상으로 모음.
+              //   직접 연결(RG-1) 뿐 아니라 비대칭(Ridge→junction→otherHip 체인) 도 한 번에 처리.
+              const polygonPath = traceInnerPolygonPath(roof, h1Match.far, h2Match.far, [h1Match.hip, h2Match.hip])
+              logger.log(
+                '[KERAB-SIMPLE] polygonPath ' +
+                  JSON.stringify({
+                    found: polygonPath !== null,
+                    length: polygonPath ? polygonPath.length : 0,
+                    lines: polygonPath
+                      ? polygonPath.map((p) => ({
+                          label: labelOf(p.line),
+                          name: p.line.name,
+                          lineName: p.line.lineName,
+                          x1: p.line.x1, y1: p.line.y1, x2: p.line.x2, y2: p.line.y2,
+                        }))
+                      : null,
+                  }),
+              )
+              // [KERAB-VALLEY-DIAG 2026-05-27] 평행(apex=null) 케라바: polygonPath 라인들의 valley vertex 식별.
+              //   사용자 전제: 평행 케라바 조건 = polygonPath 내부에 valley 가 2개 존재. 그 중 한쪽이 변환 대상.
+              //   진단 단계 — 실제 데이터에서 valley 가 어떤 vertex 로 잡히는지 확인.
+              if (!apex && polygonPath) {
+                const valleyPool = [h1Match.hip, h2Match.hip, target, ...polygonPath.map((p) => p.line)]
+                const valleyInfo = []
+                for (const line of [h1Match.hip, h2Match.hip, ...polygonPath.map((p) => p.line)]) {
+                  if (!line) continue
+                  const info = findInteriorPoint(line, valleyPool)
+                  valleyInfo.push({
+                    label: labelOf(line),
+                    name: line.name,
+                    lineName: line.lineName,
+                    x1: Math.round(line.x1 * 100) / 100,
+                    y1: Math.round(line.y1 * 100) / 100,
+                    x2: Math.round(line.x2 * 100) / 100,
+                    y2: Math.round(line.y2 * 100) / 100,
+                    startValley: info.start,
+                    endValley: info.end,
+                  })
+                }
+                logger.log('[KERAB-VALLEY-DIAG] ' + JSON.stringify(valleyInfo))
+              }
+              // [KERAB-VALLEY-EXT 2026-05-27] valley vertex 검출 + target/roofLine 의 valley 측 endpoint 만 미리 결정.
+              //   실제 raycast 는 applyKerabKLinePattern 호출 후 (extLines, 새 kLine 이 roof.innerLines 에 추가된 뒤)
+              //   에 수행해야 hip 자체+확장, ridge 자체+확장이 모두 정지 대상으로 잡힌다.
+              const valleyPlannedEndpoints = []
+              if (!apex && polygonPath) {
+                const valleyPool = [h1Match.hip, h2Match.hip, target, ...polygonPath.map((p) => p.line)]
+                const h1Info = findInteriorPoint(h1Match.hip, valleyPool)
+                const h2Info = findInteriorPoint(h2Match.hip, valleyPool)
+                const h1FarIsEnd =
+                  Math.hypot(h1Match.far.x - h1Match.hip.x2, h1Match.far.y - h1Match.hip.y2) < 1
+                const h2FarIsEnd =
+                  Math.hypot(h2Match.far.x - h2Match.hip.x2, h2Match.far.y - h2Match.hip.y2) < 1
+                const h1FarIsValley = h1FarIsEnd ? h1Info.end : h1Info.start
+                const h2FarIsValley = h2FarIsEnd ? h2Info.end : h2Info.start
+                logger.log(
+                  '[KERAB-VALLEY-EXT] gate ' +
+                    JSON.stringify({ h1FarIsValley, h2FarIsValley }),
+                )
+                if (h1FarIsValley || h2FarIsValley) {
+                  // target 의 valley 측 endpoint = SK valley vertex (h1/h2.far 중 valley 인 쪽) 와 더 가까운 쪽.
+                  const skValley = h1FarIsValley ? h1Match.far : h2Match.far
+                  const dTo1 = Math.hypot(target.x1 - skValley.x, target.y1 - skValley.y)
+                  const dTo2 = Math.hypot(target.x2 - skValley.x, target.y2 - skValley.y)
+                  const valleyAtStart = dTo1 < dTo2
+                  const tSX = valleyAtStart ? target.x1 : target.x2
+                  const tSY = valleyAtStart ? target.y1 : target.y2
+                  const tOX = valleyAtStart ? target.x2 : target.x1
+                  const tOY = valleyAtStart ? target.y2 : target.y1
+                  logger.log(
+                    '[KERAB-VALLEY-EXT] valleyEndpoint ' +
+                      JSON.stringify({ skValley, dTo1, dTo2, valleyAtStart, sx: tSX, sy: tSY }),
+                  )
+                  valleyPlannedEndpoints.push({ sx: tSX, sy: tSY, ox: tOX, oy: tOY, label: 'wallBase', parent: target })
+                  // roofLine 짝 = roof.lines 중 attributes.wallLine === target.id 인 것 (drawRoofPolygon CCW 동순서).
+                  const matchingRoofLine = Array.isArray(roof.lines)
+                    ? roof.lines.find((rl) => rl && rl.attributes?.wallLine === target.id)
+                    : null
+                  logger.log(
+                    '[KERAB-VALLEY-EXT] roofLine-match ' +
+                      JSON.stringify({
+                        targetId: target.id,
+                        targetIdx: target.idx,
+                        found: !!matchingRoofLine,
+                        rl: matchingRoofLine
+                          ? { x1: matchingRoofLine.x1, y1: matchingRoofLine.y1, x2: matchingRoofLine.x2, y2: matchingRoofLine.y2 }
+                          : null,
+                      }),
+                  )
+                  if (matchingRoofLine) {
+                    const rSX = valleyAtStart ? matchingRoofLine.x1 : matchingRoofLine.x2
+                    const rSY = valleyAtStart ? matchingRoofLine.y1 : matchingRoofLine.y2
+                    const rOX = valleyAtStart ? matchingRoofLine.x2 : matchingRoofLine.x1
+                    const rOY = valleyAtStart ? matchingRoofLine.y2 : matchingRoofLine.y1
+                    valleyPlannedEndpoints.push({ sx: rSX, sy: rSY, ox: rOX, oy: rOY, label: 'roofBase', parent: matchingRoofLine })
+                  } else {
+                    logger.log('[KERAB-VALLEY-EXT] no matching roof.lines for target.id=' + target.id)
+                  }
+                }
+              }
+              if (polygonPath === null) {
+                logger.log('[KERAB-SIMPLE] no polygon path → attr-only fallback')
+                target.set({ attributes })
+                applyKerabAttributeOnlyPattern()
+                return
+              }
+              const polygonLines = [h1Match.hip, h2Match.hip, ...polygonPath.map((p) => p.line)]
+              // [KERAB-EXTENDER 2026-05-21] 사용자 전제 3: 접점(h1.far, h2.far, 중간 junction) 에서 polygon path 가 아닌
+              //   inner line(hip OR ridge) 을 extender 로 식별. 경로상 라인은 제외.
+              const ext1 = findExtenderAtPoint(roof, h1Match.far, polygonLines)
+              const ext2 = findExtenderAtPoint(roof, h2Match.far, polygonLines)
+              // [KERAB-JUNCTION-EXT 2026-05-21] 중간 touch point(junction) 의 extender 도 식별 — 모든
+              //   사용 가능한 extender 를 수집해 가장 가까운 meet 부터 순차 해소(H-7↔RG-2 → H-1↔roofLine 등).
+              const intermediatePoints = []
+              for (let i = 0; i < polygonPath.length - 1; i++) {
+                intermediatePoints.push(polygonPath[i].to)
+              }
+              const junctionExtenders = intermediatePoints.map((jp) => {
+                const allAtJ = []
+                for (const il of roof.innerLines || []) {
+                  if (!il || polygonLines.includes(il)) continue
+                  if (il.name !== LINE_TYPE.SUBLINE.HIP && il.name !== LINE_TYPE.SUBLINE.RIDGE) continue
+                  const a = { x: il.x1, y: il.y1 }
+                  const b = { x: il.x2, y: il.y2 }
+                  const dA = Math.hypot(a.x - jp.x, a.y - jp.y)
+                  const dB = Math.hypot(b.x - jp.x, b.y - jp.y)
+                  if (dA <= 1.0) allAtJ.push({ line: il, near: a, far: b, isHip: il.name === LINE_TYPE.SUBLINE.HIP })
+                  else if (dB <= 1.0) allAtJ.push({ line: il, near: b, far: a, isHip: il.name === LINE_TYPE.SUBLINE.HIP })
+                }
+                return { jp, exts: allAtJ }
+              })
+              logger.log(
+                '[KERAB-SIMPLE] extenders ' +
+                  JSON.stringify({
+                    h1Far: h1Match.far,
+                    h2Far: h2Match.far,
+                    e1: ext1 ? { label: labelOf(ext1.line), near: ext1.near, far: ext1.far, isHip: ext1.isHip } : null,
+                    e2: ext2 ? { label: labelOf(ext2.line), near: ext2.near, far: ext2.far, isHip: ext2.isHip } : null,
+                    junctions: junctionExtenders.map((j) => ({
+                      jp: j.jp,
+                      exts: j.exts.map((e) => ({
+                        label: labelOf(e.line),
+                        near: e.near,
+                        far: e.far,
+                        isHip: e.isHip,
+                        lineName: e.line.lineName,
+                      })),
+                    })),
+                  }),
+              )
+              // [KERAB-SEQ-RESOLVE 2026-05-21] 사용자 모델: 모든 접점의 extender 를 모아 인쪽 확장.
+              //   가장 가까운 meet 부터 순차 해소(hip-hip → apex+kLine, hip-ridge → 그 자리 stop).
+              //   짝 잃은 extender 는 roofLine 까지 확장. parallel 도 자동 처리.
+              // [KERAB-POLYGON-INSIDE-REVERT 2026-05-21] sub-polygon 내부 필터(goesIntoPolygon) 제거.
+              //   해당 필터가 평행 케이스의 정상 extender 까지 거름 → 회귀. RG-1 류는 no-pierce(barrier) 로 처리.
+              const allExtenders = []
+              if (ext1) allExtenders.push({ ...ext1, sourcePoint: h1Match.far })
+              if (ext2) allExtenders.push({ ...ext2, sourcePoint: h2Match.far })
+              for (const j of junctionExtenders) {
+                for (const e of j.exts) {
+                  allExtenders.push({ ...e, sourcePoint: j.jp })
+                }
+              }
+              logger.log(
+                '[KERAB-SIMPLE] extenders-filtered ' +
+                  JSON.stringify({
+                    accepted: allExtenders.map((e) => ({
+                      label: labelOf(e.line),
+                      near: { x: Math.round(e.near.x * 100) / 100, y: Math.round(e.near.y * 100) / 100 },
+                      far: { x: Math.round(e.far.x * 100) / 100, y: Math.round(e.far.y * 100) / 100 },
+                      isHip: e.isHip,
+                    })),
+                  }),
+              )
+              if (allExtenders.length === 0) {
+                logger.log('[KERAB-SIMPLE] no extenders — fallback attr-only')
+                target.set({ attributes })
+                applyKerabAttributeOnlyPattern()
+                return
+              }
+              // 인쪽 방향 검증: extender 자연 방향(near→far)의 반대(near→inward) 와 일치해야 함.
+              const isInward = (ext, pt) => {
+                const ix = ext.near.x - ext.far.x
+                const iy = ext.near.y - ext.far.y
+                const px = pt.x - ext.near.x
+                const py = pt.y - ext.near.y
+                return ix * px + iy * py > 1e-3
+              }
+              // [KERAB-ITER-REFLECT 2026-05-21] 반사 hip 을 1급 extender 로 풀에 추가하고 wave 반복.
+              //   wave: 미해소 extender 들의 meet 계산 → 가장 가까운 meet 부터 해소 →
+              //         hip+(ridge/kLine) → 반사 hip 생성하여 풀에 추가 →
+              //         hip+hip → apex + 새 kLine 도 다음 wave 의 barrier (현재는 첫 apex 하나만 추적).
+              //   미해소는 roofLine fallback.
+              const existingKLines = (roof.innerLines || []).filter(
+                (il) =>
+                  il &&
+                  il.lineName === 'kerabPatternRidge' &&
+                  !il.__noKLine &&
+                  il.__targetId !== target.id &&
+                  il.visible !== false,
+              )
+              const isPointOnSegment = (pt, ax, ay, bx, by, tol = 0.5) => {
+                const dx = bx - ax
+                const dy = by - ay
+                const lenSq = dx * dx + dy * dy
+                if (lenSq < 1e-6) return Math.hypot(pt.x - ax, pt.y - ay) <= tol
+                const t = ((pt.x - ax) * dx + (pt.y - ay) * dy) / lenSq
+                const margin = tol / Math.sqrt(lenSq)
+                if (t < -margin || t > 1 + margin) return false
+                const px = ax + t * dx
+                const py = ay + t * dy
+                return Math.hypot(px - pt.x, py - pt.y) <= tol
+              }
+              const extenderPool = [...allExtenders]
+              const resolved = new Map()
+              // [KERAB-MULTI-APEX 2026-05-22] hip+hip 이 90° 로 만나는 모든 apex 수집 → 각 apex 마다 kLine 1개.
+              //   첫 apex 는 primary(applyKerabKLinePattern), 이후 apex 는 보조 ridge.
+              const apexList = []
+              const pendingKLines = []
+              const PERP_EPS = 0.05
+              const isPerpendicular = (vax, vay, vbx, vby) => {
+                const ma = Math.hypot(vax, vay) || 1
+                const mb = Math.hypot(vbx, vby) || 1
+                return Math.abs((vax * vbx + vay * vby) / (ma * mb)) < PERP_EPS
+              }
+              const computePendingKLine = (apex) => {
+                const ax = h2Match.near.x - h1Match.near.x
+                const ay = h2Match.near.y - h1Match.near.y
+                const aSq = ax * ax + ay * ay || 1
+                const tFoot = ((apex.x - h1Match.near.x) * ax + (apex.y - h1Match.near.y) * ay) / aSq
+                const foot = { x: h1Match.near.x + tFoot * ax, y: h1Match.near.y + tFoot * ay }
+                return { x1: apex.x, y1: apex.y, x2: foot.x, y2: foot.y }
+              }
+              const pushApexIfNew = (point, callerTag = '?') => {
+                const dup = apexList.some((ap) => Math.hypot(ap.point.x - point.x, ap.point.y - point.y) < 0.5)
+                if (dup) {
+                  logger.log('[KERAB-APEX-PUSH-DUP]', callerTag, { x: point.x?.toFixed?.(2), y: point.y?.toFixed?.(2) })
+                  return false
+                }
+                apexList.push({ point: { x: point.x, y: point.y } })
+                const pk = computePendingKLine(point)
+                pendingKLines.push(pk)
+                logger.log('[KERAB-APEX-PUSH]', callerTag, {
+                  apex: { x: point.x?.toFixed?.(2), y: point.y?.toFixed?.(2) },
+                  kLine: { x1: pk.x1?.toFixed?.(2), y1: pk.y1?.toFixed?.(2), x2: pk.x2?.toFixed?.(2), y2: pk.y2?.toFixed?.(2) },
+                  apexCount: apexList.length,
+                })
+                return true
+              }
+              // [KERAB-FIXPOINT-PHASE-A 2026-05-22] 정적 inner line 만남 시 절삭 정보 누적.
+              //   wave 종료 후 apply 직전에 fabric line 좌표를 갱신해 그 점 너머 부분을 제거한다.
+              const cuts = []
+              const MAX_ITER = 10
+              for (let iter = 0; iter < MAX_ITER; iter++) {
+                const unresolved = extenderPool.filter((e) => !resolved.has(e))
+                if (unresolved.length === 0) break
+                const meets = []
+                // [KERAB-MEETS-FAR-GUARD 2026-05-21] 거의 평행한 두 extender(H-2 vs H-3 등) 의 교점은
+                //   천문학적 좌표(예: ±6e5) 로 돌아오고 isInward 도 통과 → 가짜 meet 후보 등록.
+                //   line 291 APEX_FAR_LIMIT 와 동일 임계 1e5 로 거부, 짝 잃은 ext 는 fallback 경로(roof wall)로.
+                const MEETS_FAR_LIMIT = 1e5
+                for (let i = 0; i < unresolved.length; i++) {
+                  for (let k = i + 1; k < unresolved.length; k++) {
+                    const ea = unresolved[i]
+                    const eb = unresolved[k]
+                    const ip = lineLineIntersection(ea.near, ea.far, eb.near, eb.far)
+                    if (!ip) continue
+                    if (Math.abs(ip.x) > MEETS_FAR_LIMIT || Math.abs(ip.y) > MEETS_FAR_LIMIT) continue
+                    if (!isInward(ea, ip) || !isInward(eb, ip)) continue
+                    const dA = Math.hypot(ip.x - ea.near.x, ip.y - ea.near.y)
+                    const dB = Math.hypot(ip.x - eb.near.x, ip.y - eb.near.y)
+                    meets.push({
+                      a: ea, b: eb, point: ip,
+                      minDist: Math.min(dA, dB),
+                      bothHips: ea.isHip && eb.isHip,
+                    })
+                  }
+                }
+                const kLineMeets = []
+                const kLineCandidates = [...existingKLines, ...pendingKLines]
+                for (const ext of unresolved) {
+                  for (const kl of kLineCandidates) {
+                    const ip = lineLineIntersection(ext.near, ext.far, { x: kl.x1, y: kl.y1 }, { x: kl.x2, y: kl.y2 })
+                    if (!ip) continue
+                    if (!isInward(ext, ip)) continue
+                    if (!isPointOnSegment(ip, kl.x1, kl.y1, kl.x2, kl.y2)) continue
+                    const dist = Math.hypot(ip.x - ext.near.x, ip.y - ext.near.y)
+                    if (dist < 1e-3) continue
+                    kLineMeets.push({ ext, point: ip, dist, kLine: kl })
+                  }
+                }
+                // [KERAB-STATIC-RIDGE 2026-05-21] 정적 ridge(RG-1 등, 폴리곤 삭제대상 제외) 도 hip extender 의 거울.
+                const staticRidges = (roof.innerLines || []).filter(
+                  (il) =>
+                    il &&
+                    il.name === LINE_TYPE.SUBLINE.RIDGE &&
+                    il.lineName !== 'kerabPatternRidge' &&
+                    !polygonLines.includes(il),
+                )
+                const ridgeMeets = []
+                for (const ext of unresolved) {
+                  if (!ext.isHip) continue
+                  for (const r of staticRidges) {
+                    const ip = lineLineIntersection(ext.near, ext.far, { x: r.x1, y: r.y1 }, { x: r.x2, y: r.y2 })
+                    if (!ip) continue
+                    if (!isInward(ext, ip)) continue
+                    if (!isPointOnSegment(ip, r.x1, r.y1, r.x2, r.y2)) continue
+                    const dist = Math.hypot(ip.x - ext.near.x, ip.y - ext.near.y)
+                    ridgeMeets.push({ ext, point: ip, dist, ridge: r })
+                  }
+                }
+                // [KERAB-FIXPOINT-PHASE-A 2026-05-22] 정적 inner hip 만남 — 무너진 sub-polygon 의 경계.
+                //   unresolved ext (hip 또는 ridge) 가 정적 hip segment 와 만나면 그 점에서 멈춤 + 절삭정보 누적.
+                //   polygon path 라인은 제외(이 polygon 의 처리 대상). 자기 라인은 검사 루프에서 개별 제외.
+                const staticInnerHips = (roof.innerLines || []).filter(
+                  (il) =>
+                    il &&
+                    il.name === LINE_TYPE.SUBLINE.HIP &&
+                    !polygonLines.includes(il) &&
+                    il.visible !== false,
+                )
+                const staticMeets = []
+                for (const ext of unresolved) {
+                  for (const il of staticInnerHips) {
+                    if (ext.line === il) continue
+                    const a = { x: il.x1, y: il.y1 }
+                    const b = { x: il.x2, y: il.y2 }
+                    const ip = lineLineIntersection(ext.near, ext.far, a, b)
+                    if (!ip) continue
+                    if (Math.abs(ip.x) > 1e5 || Math.abs(ip.y) > 1e5) continue
+                    if (!isInward(ext, ip)) continue
+                    if (!isPointOnSegment(ip, a.x, a.y, b.x, b.y)) continue
+                    const dist = Math.hypot(ip.x - ext.near.x, ip.y - ext.near.y)
+                    if (dist < 1e-3) continue
+                    staticMeets.push({ ext, point: ip, dist, staticLine: il })
+                  }
+                }
+                if (staticMeets.length > 0) {
+                  logger.log(
+                    '[KERAB-FIXPOINT-PHASE-A] staticMeets iter=' + iter + ' ' +
+                      JSON.stringify(
+                        staticMeets.map((s) => ({
+                          ext: labelOf(s.ext.line) || (s.ext.isHip ? 'H' : 'R'),
+                          staticLine: labelOf(s.staticLine) || 'H?',
+                          point: { x: Math.round(s.point.x * 100) / 100, y: Math.round(s.point.y * 100) / 100 },
+                          dist: Math.round(s.dist * 100) / 100,
+                        })),
+                      ),
+                  )
+                }
+                // [KERAB-FIXPOINT-STEP2 2026-05-21] 이미 그려질 segment(resolved) 도 후보의 거울.
+                //   뒤늦게 도달한 extender 가 기존 segment 와 만나면 그 점에서 반사 hip 을 만든다.
+                //   (drawn segment 자체의 절단은 Step 3 에서 처리)
+                //   segment 양끝은 그리기 좌표(sourcePoint→stop) 와 일치시킨다.
+                const drawnMeets = []
+                for (const ext of unresolved) {
+                  if (!ext.isHip) continue
+                  for (const [drawnExt, stopPt] of resolved) {
+                    if (!drawnExt || !stopPt) continue
+                    if (drawnExt === ext) continue
+                    const segA = drawnExt.sourcePoint || drawnExt.near
+                    const segB = stopPt
+                    const ip = lineLineIntersection(ext.near, ext.far, segA, segB)
+                    if (!ip) continue
+                    if (Math.abs(ip.x) > 1e5 || Math.abs(ip.y) > 1e5) continue
+                    if (!isInward(ext, ip)) continue
+                    if (!isPointOnSegment(ip, segA.x, segA.y, segB.x, segB.y)) continue
+                    const dist = Math.hypot(ip.x - ext.near.x, ip.y - ext.near.y)
+                    if (dist < 1e-3) continue
+                    drawnMeets.push({ ext, point: ip, dist, drawnExt, mirrorLine: { x1: segA.x, y1: segA.y, x2: segB.x, y2: segB.y } })
+                  }
+                }
+                if (drawnMeets.length > 0) {
+                  logger.log(
+                    '[KERAB-FIXPOINT-STEP2] drawnMeets iter=' + iter + ' ' +
+                      JSON.stringify(
+                        drawnMeets.map((d) => ({
+                          ext: d.ext.line?.attributes?.label || (d.ext.isHip ? 'H' : 'R'),
+                          point: { x: Math.round(d.point.x * 100) / 100, y: Math.round(d.point.y * 100) / 100 },
+                          dist: Math.round(d.dist * 100) / 100,
+                        })),
+                      ),
+                  )
+                }
+                const candidates = []
+                for (const m of meets) {
+                  candidates.push({ kind: 'pair', extenders: [m.a, m.b], point: m.point, minDist: m.minDist, bothHips: m.bothHips })
+                }
+                for (const km of kLineMeets) {
+                  candidates.push({ kind: 'kline', extenders: [km.ext], point: km.point, minDist: km.dist, mirrorLine: km.kLine })
+                }
+                for (const rm of ridgeMeets) {
+                  candidates.push({
+                    kind: 'ridge',
+                    extenders: [rm.ext],
+                    point: rm.point,
+                    minDist: rm.dist,
+                    mirrorLine: { x1: rm.ridge.x1, y1: rm.ridge.y1, x2: rm.ridge.x2, y2: rm.ridge.y2 },
+                  })
+                }
+                for (const dm of drawnMeets) {
+                  candidates.push({
+                    kind: 'drawn',
+                    extenders: [dm.ext],
+                    point: dm.point,
+                    minDist: dm.dist,
+                    mirrorLine: dm.mirrorLine,
+                    drawnExt: dm.drawnExt,
+                  })
+                }
+                for (const sm of staticMeets) {
+                  candidates.push({
+                    kind: 'static',
+                    extenders: [sm.ext],
+                    point: sm.point,
+                    minDist: sm.dist,
+                    staticLine: sm.staticLine,
+                  })
+                }
+                candidates.sort((a, b) => a.minDist - b.minDist)
+                const newReflected = []
+                let pendingKLineCreated = false
+                let processedAny = false
+                // [KERAB-FIXPOINT-STEP1 2026-05-21] 동시성 모델: 한 iter 에 가장 가까운 후보 1개만 처리.
+                //   이후 외곽 for(iter) 루프가 meets/kLineMeets/ridgeMeets 를 새 상태로 재계산한다.
+                //   이렇게 해야 뒤늦은 교점이 이미 그려질 라인을 잘라낼 수 있다 (Step 2~3 에서 확장 예정).
+                for (const c of candidates) {
+                  if (c.extenders.some((e) => resolved.has(e))) continue
+                  for (const e of c.extenders) resolved.set(e, c.point)
+                  processedAny = true
+                  // [KERAB-FIXPOINT-STEP3 2026-05-21] drawn segment 절단:
+                  //   뒤늦은 교점이 잡힌 기존 segment 의 stop 을 교점으로 갱신.
+                  //   절단 후 길이 < 0.5 이면 resolved 에서 제거하여 라인 자체 제거.
+                  if (c.kind === 'drawn' && c.drawnExt) {
+                    const drawnNear = c.drawnExt.sourcePoint || c.drawnExt.near
+                    const remain = Math.hypot(c.point.x - drawnNear.x, c.point.y - drawnNear.y)
+                    if (remain < 0.5) {
+                      resolved.delete(c.drawnExt)
+                    } else {
+                      resolved.set(c.drawnExt, c.point)
+                    }
+                    // [KERAB-MULTI-APEX 2026-05-22] 규칙 5 Case B: drawn-meet 두 hip 90° → kLine 신규 생성.
+                    //   ray-ray 가 drift(t<0) 로 pair 후보 미생성이어도 drawn segment 교점에서 사실상 만나는 케이스.
+                    //   H-5/H-6 같이 RG-2 양끝 발산 hip → drawn meet 으로 동일점 stop.
+                    const ea = c.extenders[0]
+                    const eb = c.drawnExt
+                    if (ea?.isHip && eb?.isHip && remain >= 0.5) {
+                      const vax = ea.far.x - ea.near.x
+                      const vay = ea.far.y - ea.near.y
+                      const vbx = eb.far.x - eb.near.x
+                      const vby = eb.far.y - eb.near.y
+                      if (isPerpendicular(vax, vay, vbx, vby)) {
+                        const eaTag = `${labelOf(ea.line) || 'H'}${ea.__reflected ? '*' : ''}${ea.__reflectedFromPending ? '!' : ''}`
+                        const ebTag = `${labelOf(eb.line) || 'H'}${eb.__reflected ? '*' : ''}${eb.__reflectedFromPending ? '!' : ''}`
+                        if (ea.__reflectedFromPending || eb.__reflectedFromPending) {
+                          logger.log('[KERAB-APEX-SKIP-PHANTOM]', `iter${iter}/drawn-meet[${eaTag}+${ebTag}]`, {
+                            x: c.point.x?.toFixed?.(2), y: c.point.y?.toFixed?.(2),
+                          })
+                        } else if (pushApexIfNew(c.point, `iter${iter}/drawn-meet[${eaTag}+${ebTag}]`)) {
+                          pendingKLineCreated = true
+                        }
+                      }
+                    }
+                  }
+                  // [KERAB-FIXPOINT-PHASE-A 2026-05-22] static 만남: ext 멈춤 + 정적 라인 절삭 정보 누적.
+                  if (c.kind === 'static' && c.staticLine) {
+                    cuts.push({ line: c.staticLine, point: c.point })
+                  }
+                  if (c.kind === 'pair' && c.bothHips) {
+                    const [ea, eb] = c.extenders
+                    const vax = ea.far.x - ea.near.x
+                    const vay = ea.far.y - ea.near.y
+                    const vbx = eb.far.x - eb.near.x
+                    const vby = eb.far.y - eb.near.y
+                    if (isPerpendicular(vax, vay, vbx, vby)) {
+                      const eaTag = `${labelOf(ea.line) || (ea.isHip ? 'H' : 'R')}${ea.__reflected ? '*' : ''}${ea.__reflectedFromPending ? '!' : ''}`
+                      const ebTag = `${labelOf(eb.line) || (eb.isHip ? 'H' : 'R')}${eb.__reflected ? '*' : ''}${eb.__reflectedFromPending ? '!' : ''}`
+                      // [KERAB-MULTI-APEX 2026-05-22] pendingKLine 반사 자식이 끼인 pair-meet 은 phantom 이라 skip.
+                      //   primary(H-3+H-4*: H-4는 RG-2 ridge 반사로 fromPending 아님) 는 통과,
+                      //   phantom(H-16+H-2!: H-2 가 primary kLine 반사) 은 차단.
+                      //   정적 hip 와의 90° 만남 apex 는 re-resolve 단계에서 따로 push.
+                      if (ea.__reflectedFromPending || eb.__reflectedFromPending) {
+                        logger.log('[KERAB-APEX-SKIP-PHANTOM]', `iter${iter}/pair-meet[${eaTag}+${ebTag}]`, {
+                          x: c.point.x?.toFixed?.(2), y: c.point.y?.toFixed?.(2),
+                        })
+                      } else if (pushApexIfNew(c.point, `iter${iter}/pair-meet[${eaTag}+${ebTag}]`)) {
+                        pendingKLineCreated = true
+                      }
+                    }
+                  }
+                  let hipExt = null
+                  let mirrorLine = null
+                  if ((c.kind === 'kline' || c.kind === 'ridge' || c.kind === 'drawn') && c.extenders[0].isHip) {
+                    hipExt = c.extenders[0]
+                    mirrorLine = c.mirrorLine
+                  } else if (c.kind === 'pair') {
+                    const [ea, eb] = c.extenders
+                    if (ea.isHip && !eb.isHip) {
+                      hipExt = ea
+                      mirrorLine = { x1: eb.near.x, y1: eb.near.y, x2: eb.far.x, y2: eb.far.y }
+                    } else if (!ea.isHip && eb.isHip) {
+                      hipExt = eb
+                      mirrorLine = { x1: ea.near.x, y1: ea.near.y, x2: ea.far.x, y2: ea.far.y }
+                    }
+                  }
+                  if (hipExt && mirrorLine) {
+                    const hdx = hipExt.near.x - hipExt.far.x
+                    const hdy = hipExt.near.y - hipExt.far.y
+                    const kdx = mirrorLine.x2 - mirrorLine.x1
+                    const kdy = mirrorLine.y2 - mirrorLine.y1
+                    const klen = Math.hypot(kdx, kdy) || 1
+                    const nx = -kdy / klen
+                    const ny = kdx / klen
+                    const dot = hdx * nx + hdy * ny
+                    const rdx = hdx - 2 * dot * nx
+                    const rdy = hdy - 2 * dot * ny
+                    // [KERAB-MULTI-APEX 2026-05-22] 같은 operation 의 pendingKLine 에 반사된 자식은
+                    //   __reflectedFromPending 태그. 이 자식의 pair-meet 으로 추가 apex 생성 차단(phantom 방지).
+                    //   부모(hipExt) 가 이미 pending 에서 반사된 경우도 상속.
+                    const fromPending =
+                      hipExt.__reflectedFromPending ||
+                      (c.kind === 'kline' && pendingKLines.some(
+                        (pk) => pk.x1 === mirrorLine.x1 && pk.y1 === mirrorLine.y1 && pk.x2 === mirrorLine.x2 && pk.y2 === mirrorLine.y2,
+                      ))
+                    newReflected.push({
+                      line: hipExt.line,
+                      near: { x: c.point.x, y: c.point.y },
+                      far: { x: c.point.x - rdx, y: c.point.y - rdy },
+                      isHip: true,
+                      sourcePoint: { x: c.point.x, y: c.point.y },
+                      __reflected: true,
+                      __reflectedFromPending: fromPending,
+                    })
+                  }
+                  break
+                }
+                if (!processedAny && !pendingKLineCreated) break
+                extenderPool.push(...newReflected)
+              }
+              // [KERAB-ROOF-FALLBACK-ANYWALL 2026-05-21] 미해소 extender 를 roof 폴리곤의 어떤 wall 이라도
+              //   inward 방향의 가장 가까운 wall 교점까지 확장. 반사 hip 이 target wall 과 반대쪽으로
+              //   향해도 다른 wall 에서 정지.
+              const roofPolygonWalls = []
+              if (Array.isArray(roof.points) && roof.points.length >= 2) {
+                for (let i = 0; i < roof.points.length; i++) {
+                  roofPolygonWalls.push({
+                    a: roof.points[i],
+                    b: roof.points[(i + 1) % roof.points.length],
+                  })
+                }
+              }
+              // [KERAB-NO-PIERCE 2026-05-21] fallback 직진 중에도 정적 inner line(이 polygon 의 처리대상 제외)
+              //   + 이번 wave 에 이미 그려질 ext 라인을 barrier 로 검사. 가장 가까운 hit 에서 정지하여
+              //   다른 라인을 관통해 내부로 침입하는 케이스를 차단.
+              const barrierLines = []
+              for (const il of roof.innerLines || []) {
+                if (!il) continue
+                if (polygonLines.includes(il)) continue
+                if (il.name !== LINE_TYPE.SUBLINE.HIP && il.name !== LINE_TYPE.SUBLINE.RIDGE) continue
+                if (il.visible === false) continue
+                barrierLines.push({ x1: il.x1, y1: il.y1, x2: il.x2, y2: il.y2 })
+              }
+              for (const [otherExt, otherStop] of resolved) {
+                barrierLines.push({
+                  x1: otherExt.sourcePoint.x,
+                  y1: otherExt.sourcePoint.y,
+                  x2: otherStop.x,
+                  y2: otherStop.y,
+                })
+              }
+              for (const pk of pendingKLines) barrierLines.push(pk)
+              for (const ext of extenderPool) {
+                if (resolved.has(ext)) continue
+                let bestPt = null
+                let bestDist = Infinity
+                let bestSrc = null
+                for (const wall of roofPolygonWalls) {
+                  const ip = lineLineIntersection(ext.near, ext.far, wall.a, wall.b)
+                  if (!ip) continue
+                  if (!isInward(ext, ip)) continue
+                  if (!isPointOnSegment(ip, wall.a.x, wall.a.y, wall.b.x, wall.b.y)) continue
+                  const dist = Math.hypot(ip.x - ext.near.x, ip.y - ext.near.y)
+                  if (dist < bestDist) {
+                    bestDist = dist
+                    bestPt = ip
+                    bestSrc = { kind: 'wall', a: wall.a, b: wall.b }
+                  }
+                }
+                for (const bl of barrierLines) {
+                  const ip = lineLineIntersection(ext.near, ext.far, { x: bl.x1, y: bl.y1 }, { x: bl.x2, y: bl.y2 })
+                  if (!ip) continue
+                  if (!isInward(ext, ip)) continue
+                  if (!isPointOnSegment(ip, bl.x1, bl.y1, bl.x2, bl.y2)) continue
+                  const dist = Math.hypot(ip.x - ext.near.x, ip.y - ext.near.y)
+                  if (dist < 1e-3) continue
+                  if (dist < bestDist) {
+                    bestDist = dist
+                    bestPt = ip
+                    bestSrc = { kind: 'barrier', a: { x: bl.x1, y: bl.y1 }, b: { x: bl.x2, y: bl.y2 } }
+                  }
+                }
+                logger.log(
+                  '[KERAB-FALLBACK] ext=' + (labelOf(ext.line) || (ext.isHip ? 'H' : 'R')) +
+                    ' near=' + JSON.stringify({ x: Math.round(ext.near.x * 100) / 100, y: Math.round(ext.near.y * 100) / 100 }) +
+                    ' stop=' + (bestPt ? JSON.stringify({ x: Math.round(bestPt.x * 100) / 100, y: Math.round(bestPt.y * 100) / 100 }) : 'null') +
+                    ' src=' + (bestSrc
+                      ? bestSrc.kind +
+                        '[' +
+                        Math.round(bestSrc.a.x * 100) / 100 + ',' + Math.round(bestSrc.a.y * 100) / 100 +
+                        '→' +
+                        Math.round(bestSrc.b.x * 100) / 100 + ',' + Math.round(bestSrc.b.y * 100) / 100 +
+                        ']'
+                      : 'none'),
+                )
+                if (bestPt) resolved.set(ext, bestPt)
+              }
+              // [KERAB-FIXPOINT-PHASE-A 2026-05-22] cuts 적용 — 사용자 멘탈모델:
+              //   절삭 방향 = static line 이 "확장되는 방향" (= inward extension 의 anchor 쪽).
+              //   거리 기반(만남점에 가까운 쪽) 가 아니다 — junction-extended outer hip 의 경우
+              //   우연히 일치할 뿐. extension source 끝점 = 확장 anchor = junction stub = 제거.
+              //   반대편 = dead-end = 유지.
+              //   (a) static cut: 확장 방향 끝점을 만남점까지 잘라낸다.
+              //   (b) 확장 자체 purge: 같은 line 의 wave drawn(inward 확장) 제거.
+              //   (c) cascade: 제거된 끝점을 source/stop 으로 쓰던 다른 drawn segment 도 정리.
+              //   (d) re-resolve: stop 점이 죽은 segment(잘려나간 stub 또는 purge 된 확장)
+              //       위에 있던 다른 resolved entry 는 unresolved 로 되돌리고, 새 상태로
+              //       wall + barrier 까지 재확장한다 (Phase A의 "다음 행위").
+              if (cuts.length > 0) {
+                logger.log(
+                  '[KERAB-FIXPOINT-PHASE-A] applying cuts(initial) ' +
+                    JSON.stringify(
+                      cuts.map((c) => ({
+                        line: labelOf(c.line) || 'H?',
+                        point: { x: Math.round(c.point.x * 100) / 100, y: Math.round(c.point.y * 100) / 100 },
+                      })),
+                    ),
+                )
+                // [KERAB-FIXPOINT-PHASE-A 2026-05-22] cuts 를 while/index 로 처리해 re-resolve
+                //   결과로 새로 잡힌 static meet 이 cuts 에 추가되면 같은 루프에서 처리.
+                let cutIdx = 0
+                while (cutIdx < cuts.length) {
+                  const cut = cuts[cutIdx++]
+                  const line = cut.line
+                  if (!line) continue
+                  const a = { x: line.x1, y: line.y1 }
+                  const b = { x: line.x2, y: line.y2 }
+                  const dA = Math.hypot(a.x - cut.point.x, a.y - cut.point.y)
+                  const dB = Math.hypot(b.x - cut.point.x, b.y - cut.point.y)
+                  // 확장 방향 = 이 line 을 source 로 하는 inward extension 의 sourcePoint 쪽.
+                  // 그 끝점 = junction = 제거 대상. 반대편(dead-end) = 유지.
+                  let extensionAnchor = null
+                  for (const ext of resolved.keys()) {
+                    if (ext.line === line && ext.sourcePoint) {
+                      extensionAnchor = ext.sourcePoint
+                      break
+                    }
+                  }
+                  let keepA
+                  let dirSource
+                  if (extensionAnchor) {
+                    const dAanc = Math.hypot(a.x - extensionAnchor.x, a.y - extensionAnchor.y)
+                    const dBanc = Math.hypot(b.x - extensionAnchor.x, b.y - extensionAnchor.y)
+                    keepA = dAanc > dBanc // anchor 와 먼 쪽(dead-end) 유지
+                    dirSource = 'extension'
+                  } else {
+                    // priority 2: junction-vs-dead-end. 끝점에 다른 inner line 끝점이 모이면
+                    //   junction(3점 교점 등) → 그 쪽 유지. dead-end(연결없음) 쪽 절삭.
+                    //   둘 다 같으면 다음 priority.
+                    const countJunction = (p) => {
+                      let count = 0
+                      for (const il of roof.innerLines || []) {
+                        if (!il || il === line) continue
+                        if (il.visible === false) continue
+                        if (il.name !== LINE_TYPE.SUBLINE.HIP && il.name !== LINE_TYPE.SUBLINE.RIDGE) continue
+                        if (Math.hypot(il.x1 - p.x, il.y1 - p.y) < 0.5) count += 1
+                        if (Math.hypot(il.x2 - p.x, il.y2 - p.y) < 0.5) count += 1
+                      }
+                      return count
+                    }
+                    const jA = countJunction(a)
+                    const jB = countJunction(b)
+                    if (jA !== jB) {
+                      keepA = jA > jB // junction count 많은 쪽 유지, dead-end 쪽 절삭
+                      dirSource = 'junction'
+                    } else {
+                      // priority 3: 교점에 가까운 쪽 절삭 (먼 쪽 유지).
+                      const TIE_EPS = 1.0
+                      if (Math.abs(dA - dB) > TIE_EPS) {
+                        keepA = dA >= dB
+                        dirSource = 'distance'
+                      } else {
+                        // priority 4: roofLine 에 가까운 끝점을 가진 쪽 절삭.
+                        const pointToSegDist = (p, sa, sb) => {
+                          const vx = sb.x - sa.x
+                          const vy = sb.y - sa.y
+                          const lenSq = vx * vx + vy * vy
+                          if (lenSq < 1e-6) return Math.hypot(p.x - sa.x, p.y - sa.y)
+                          let t = ((p.x - sa.x) * vx + (p.y - sa.y) * vy) / lenSq
+                          if (t < 0) t = 0
+                          else if (t > 1) t = 1
+                          return Math.hypot(p.x - (sa.x + t * vx), p.y - (sa.y + t * vy))
+                        }
+                        const minDistToRoof = (p) => {
+                          let best = Infinity
+                          for (const w of roofPolygonWalls) {
+                            const d = pointToSegDist(p, w.a, w.b)
+                            if (d < best) best = d
+                          }
+                          return best
+                        }
+                        const rA = minDistToRoof(a)
+                        const rB = minDistToRoof(b)
+                        keepA = rA > rB
+                        dirSource = 'roofLine'
+                      }
+                    }
+                  }
+                  const removedEnd = keepA ? b : a
+                  const remain = Math.hypot((keepA ? a : b).x - cut.point.x, (keepA ? a : b).y - cut.point.y)
+                  if (remain < 0.5) {
+                    if (typeof line.set === 'function') line.set({ visible: false })
+                    else line.visible = false
+                  } else if (keepA) {
+                    if (typeof line.set === 'function') line.set({ x2: cut.point.x, y2: cut.point.y })
+                    else { line.x2 = cut.point.x; line.y2 = cut.point.y }
+                  } else {
+                    if (typeof line.set === 'function') line.set({ x1: cut.point.x, y1: cut.point.y })
+                    else { line.x1 = cut.point.x; line.y1 = cut.point.y }
+                  }
+                  // purge ext.line === cut.line BEFORE deletion: capture drawn segments.
+                  const purgedSegments = []
+                  let purgedLine = 0
+                  for (const ext of Array.from(resolved.keys())) {
+                    if (ext.line === line) {
+                      const stop = resolved.get(ext)
+                      if (ext.sourcePoint && stop) {
+                        purgedSegments.push({
+                          a: { x: ext.sourcePoint.x, y: ext.sourcePoint.y },
+                          b: { x: stop.x, y: stop.y },
+                        })
+                      }
+                      resolved.delete(ext)
+                      purgedLine += 1
+                    }
+                  }
+                  // cascade: removedEnd(잘려나간 stub 끝점) 에 src/stop 이 직접 붙은 drawn
+                  // segment 만 단일 pass purge. resolved 의 stop 점은 apex/reflection 일 수도
+                  // 있고 inner polygon junction 일 수도 있으므로 deadPts 로 전파하지 않는다.
+                  // junction 은 살아있는 anchor → 다른 extension(예: H-2) 을 휩쓸어선 안 됨.
+                  let purgedCascade = 0
+                  for (const [ext, stop] of Array.from(resolved.entries())) {
+                    const src = ext.sourcePoint
+                    if (!src || !stop) continue
+                    const srcAtRemoved = Math.hypot(src.x - removedEnd.x, src.y - removedEnd.y) < 0.5
+                    const stopAtRemoved = Math.hypot(stop.x - removedEnd.x, stop.y - removedEnd.y) < 0.5
+                    if (srcAtRemoved || stopAtRemoved) {
+                      resolved.delete(ext)
+                      purgedCascade += 1
+                    }
+                  }
+                  // (d) re-resolve: 죽은 segment 들 위에 stop 이 있던 resolved entry → 재확장.
+                  //   killed = static line 의 잘린 stub (cut.point → removedEnd) +
+                  //            방금 purge 한 drawn segment 들(source → stop).
+                  const killedSegments = [
+                    { a: { x: cut.point.x, y: cut.point.y }, b: { x: removedEnd.x, y: removedEnd.y } },
+                    ...purgedSegments,
+                  ]
+                  const staleExts = []
+                  for (const [ext, stop] of Array.from(resolved.entries())) {
+                    const onKilled = killedSegments.some((seg) =>
+                      isPointOnSegment(stop, seg.a.x, seg.a.y, seg.b.x, seg.b.y, 0.5),
+                    )
+                    if (onKilled) {
+                      resolved.delete(ext)
+                      staleExts.push(ext)
+                    }
+                  }
+                  // 재resolve: 현재 resolved + roof.innerLines 로 barrier 재구축 후 fallback 처럼
+                  //   가장 가까운 wall/barrier 까지 확장. killed segment 는 barrier 에서 제외됨
+                  //   (resolved 에서 빠졌고 fabric line 좌표가 cut 으로 갱신됨).
+                  let reResolved = 0
+                  if (staleExts.length > 0) {
+                    const barriers2 = []
+                    for (const il of roof.innerLines || []) {
+                      if (!il) continue
+                      if (polygonLines.includes(il)) continue
+                      if (il.name !== LINE_TYPE.SUBLINE.HIP && il.name !== LINE_TYPE.SUBLINE.RIDGE) continue
+                      if (il.visible === false) continue
+                      barriers2.push({ x1: il.x1, y1: il.y1, x2: il.x2, y2: il.y2 })
+                    }
+                    for (const [otherExt, otherStop] of resolved) {
+                      barriers2.push({
+                        x1: otherExt.sourcePoint.x,
+                        y1: otherExt.sourcePoint.y,
+                        x2: otherStop.x,
+                        y2: otherStop.y,
+                      })
+                    }
+                    for (const pk of pendingKLines) barriers2.push(pk)
+                    for (const ext of staleExts) {
+                      let bestPt = null
+                      let bestDist = Infinity
+                      for (const wall of roofPolygonWalls) {
+                        const ip = lineLineIntersection(ext.near, ext.far, wall.a, wall.b)
+                        if (!ip) continue
+                        if (!isInward(ext, ip)) continue
+                        if (!isPointOnSegment(ip, wall.a.x, wall.a.y, wall.b.x, wall.b.y)) continue
+                        const dist = Math.hypot(ip.x - ext.near.x, ip.y - ext.near.y)
+                        if (dist < 1e-3) continue
+                        if (dist < bestDist) { bestDist = dist; bestPt = ip }
+                      }
+                      for (const bl of barriers2) {
+                        const ip = lineLineIntersection(ext.near, ext.far, { x: bl.x1, y: bl.y1 }, { x: bl.x2, y: bl.y2 })
+                        if (!ip) continue
+                        if (!isInward(ext, ip)) continue
+                        if (!isPointOnSegment(ip, bl.x1, bl.y1, bl.x2, bl.y2)) continue
+                        const dist = Math.hypot(ip.x - ext.near.x, ip.y - ext.near.y)
+                        if (dist < 1e-3) continue
+                        if (dist < bestDist) { bestDist = dist; bestPt = ip }
+                      }
+                      if (bestPt) {
+                        resolved.set(ext, bestPt)
+                        reResolved += 1
+                      }
+                      logger.log(
+                        '[KERAB-FIXPOINT-PHASE-A] re-resolve ext=' + (labelOf(ext.line) || (ext.isHip ? 'H' : 'R')) +
+                          ' near={' + Math.round(ext.near.x * 100) / 100 + ',' + Math.round(ext.near.y * 100) / 100 + '}' +
+                          ' newStop=' + (bestPt ? '{' + Math.round(bestPt.x * 100) / 100 + ',' + Math.round(bestPt.y * 100) / 100 + '}' : 'null'),
+                      )
+                    }
+                  }
+                  // [KERAB-FIXPOINT-PHASE-A 2026-05-22] re-resolve 후 새 stop 이 정적 inner hip
+                  //   위면 hip+hip 만남(또는 hip+static-hip) 으로 간주 → cuts 추가 + apex/kLine.
+                  //   같은 cuts 루프에서 다음 pass 처리(while/index).
+                  let newCuts = 0
+                  for (const ext of staleExts) {
+                    const newStop = resolved.get(ext)
+                    if (!newStop) continue
+                    for (const il of roof.innerLines || []) {
+                      if (!il) continue
+                      if (polygonLines.includes(il)) continue
+                      if (il.name !== LINE_TYPE.SUBLINE.HIP) continue
+                      if (il.visible === false) continue
+                      const already = cuts.some(
+                        (c) => c.line === il && Math.hypot(c.point.x - newStop.x, c.point.y - newStop.y) < 0.5,
+                      )
+                      if (already) continue
+                      if (!isPointOnSegment(newStop, il.x1, il.y1, il.x2, il.y2, 0.5)) continue
+                      cuts.push({ line: il, point: { x: newStop.x, y: newStop.y } })
+                      newCuts += 1
+                      // [KERAB-MULTI-APEX 2026-05-22] re-resolve 의 정적 hip 만남(H-2반사 + H-14)이 90° 면 kLine 추가.
+                      if (ext.isHip) {
+                        const vax = ext.far.x - ext.near.x
+                        const vay = ext.far.y - ext.near.y
+                        const vbx = il.x2 - il.x1
+                        const vby = il.y2 - il.y1
+                        if (isPerpendicular(vax, vay, vbx, vby)) {
+                          pushApexIfNew(newStop, `reresolve/ext=${labelOf(ext) || '?'}/il=${labelOf(il) || '?'}`)
+                        }
+                      }
+                      break
+                    }
+                  }
+                  logger.log(
+                    '[KERAB-FIXPOINT-PHASE-A] cut applied line=' + (labelOf(line) || 'H?') +
+                      ' dir=' + dirSource +
+                      ' purgedLine=' + purgedLine + ' purgedCascade=' + purgedCascade +
+                      ' stale=' + staleExts.length + ' reResolved=' + reResolved +
+                      ' newCuts=' + newCuts +
+                      ' removedEnd={' + Math.round(removedEnd.x * 100) / 100 + ',' + Math.round(removedEnd.y * 100) / 100 + '}',
+                  )
+                }
+              }
+              const extLines = []
+              for (const [ext, stop] of resolved) {
+                const fromPt = ext.sourcePoint
+                if (Math.hypot(stop.x - fromPt.x, stop.y - fromPt.y) < 0.5) continue
+                extLines.push({ from: fromPt, to: stop, isHip: ext.isHip })
+              }
+              const drawKLine = apexList.length > 0
+              const markerApex = apexList.length > 0 ? apexList[0].point : (extLines.length > 0 ? extLines[0].to : null)
+              const extraApexes = apexList.slice(1).map((ap) => ap.point)
+              logger.log(
+                '[KERAB-SIMPLE] sequential resolve ' +
+                  JSON.stringify({
+                    extLines: extLines.map((e) => ({
+                      from: { x: Math.round(e.from.x * 100) / 100, y: Math.round(e.from.y * 100) / 100 },
+                      to: { x: Math.round(e.to.x * 100) / 100, y: Math.round(e.to.y * 100) / 100 },
+                      isHip: e.isHip,
+                    })),
+                    drawKLine,
+                    markerApex: markerApex
+                      ? { x: Math.round(markerApex.x * 100) / 100, y: Math.round(markerApex.y * 100) / 100 }
+                      : null,
+                    apexList: apexList.map((ap) => ({
+                      x: Math.round(ap.point.x * 100) / 100,
+                      y: Math.round(ap.point.y * 100) / 100,
+                    })),
+                  }),
+              )
+              if (markerApex) {
+                const pathHips = polygonPath.filter((p) => p.line.name === LINE_TYPE.SUBLINE.HIP).map((p) => p.line)
+                const pathRidges = polygonPath.filter((p) => p.line.name === LINE_TYPE.SUBLINE.RIDGE).map((p) => p.line)
+                target.set({ attributes })
+                applyKerabKLinePattern(
+                  roof,
+                  target,
+                  markerApex,
+                  h1Match.near,
+                  h2Match.near,
+                  [h1Match.hip, h2Match.hip, ...pathHips],
+                  pathRidges,
+                  extLines,
+                  drawKLine,
+                  extraApexes,
+                )
+                // [KERAB-VALLEY-EXT 2026-05-27] valley 처마확장 raycast + drawing — applyKerabKLinePattern 후 실행.
+                //   raycast 대상 = 현재 roof.innerLines 중 HIP/RIDGE (= 살아남은 hip·ridge + 새 extLines·kLine 모두 포함).
+                //   사라진 polygonPath hip/ridge 는 이미 제거되어 자동 제외. valleyExt 자신은 push 후이므로 1mm 필터로 보호.
+                if (valleyPlannedEndpoints.length) {
+                  const isOnSegV = (pt, ax, ay, bx, by, tol = 0.5) => {
+                    const sdx = bx - ax
+                    const sdy = by - ay
+                    const lenSq = sdx * sdx + sdy * sdy
+                    if (lenSq < 1e-6) return Math.hypot(pt.x - ax, pt.y - ay) <= tol
+                    const tt = ((pt.x - ax) * sdx + (pt.y - ay) * sdy) / lenSq
+                    const margin = tol / Math.sqrt(lenSq)
+                    if (tt < -margin || tt > 1 + margin) return false
+                    const px = ax + tt * sdx
+                    const py = ay + tt * sdy
+                    return Math.hypot(px - pt.x, py - pt.y) <= tol
+                  }
+                  const valleyExtensions = []
+                  for (const ep of valleyPlannedEndpoints) {
+                    const start = { x: ep.sx, y: ep.sy }
+                    const dx = ep.sx - ep.ox
+                    const dy = ep.sy - ep.oy
+                    const len = Math.hypot(dx, dy) || 1
+                    const ux = dx / len
+                    const uy = dy / len
+                    const FAR_RAY = 1e5
+                    const rayEnd = { x: start.x + ux * FAR_RAY, y: start.y + uy * FAR_RAY }
+                    let bestStop = null
+                    let bestT = Infinity
+                    let bestHit = null
+                    for (const il of roof.innerLines || []) {
+                      if (!il) continue
+                      // [KERAB-VALLEY-EXT 2026-05-27] 처마확장은 자기(kerabPatternValleyExt) 외 모든 inner line 에서 정지.
+                      //   "처마확장은 자기와 다른 속성의 라인을 만나면 멈춘다" — cascade/cut 없이 그리기만.
+                      if (il.lineName === 'kerabPatternValleyExt') continue
+                      if (il.visible === false) continue
+                      const a = { x: il.x1, y: il.y1 }
+                      const b = { x: il.x2, y: il.y2 }
+                      const ip = lineLineIntersection(start, rayEnd, a, b)
+                      if (!ip) continue
+                      if (!isOnSegV(ip, a.x, a.y, b.x, b.y)) continue
+                      const t = (ip.x - start.x) * ux + (ip.y - start.y) * uy
+                      if (t < 1.0) continue
+                      if (t < bestT) {
+                        bestT = t
+                        bestStop = ip
+                        bestHit = il
+                      }
+                    }
+                    if (bestStop) {
+                      const seg = {
+                        x1: start.x,
+                        y1: start.y,
+                        x2: bestStop.x,
+                        y2: bestStop.y,
+                        source: ep.label,
+                        parent: ep.parent || null,
+                        hitLine: bestHit,
+                        hitPoint: { x: bestStop.x, y: bestStop.y },
+                        hitLineName: bestHit && bestHit.lineName,
+                        hitName: bestHit && bestHit.name,
+                      }
+                      valleyExtensions.push(seg)
+                      logger.log('[KERAB-VALLEY-EXT] generated ' + JSON.stringify(seg))
+                    } else {
+                      logger.log('[KERAB-VALLEY-EXT] no ridge/hip hit for ' + ep.label)
+                    }
+                  }
+                  // [KERAB-VALLEY-EXT-SPLIT 2026-05-27] hit innerLine 을 hitPoint 에서 분할.
+                  //   splitPolygonWithLines 의 graph 가 line 양 endpoint 만 노드로 잡으므로,
+                  //   ext 끝점이 기존 innerLine 중간에 있으면 T-junction 이 graph 에 안 잡혀 face 할당이 끊긴다.
+                  //   revert 시 복원 위해 target.__valleyExtSplits 에 (halves, original snapshot) 보관.
+                  //   wallBase 확장은 wall layer 라 roof face 할당에 참여하면 안 되므로 split 대상에서 제외.
+                  const splitRecords = []
+                  // 같은 hit line 을 여러 ext 가 공유할 수 있으므로 endpoint set 으로 누적 후 분할.
+                  const splitMap = new Map() // hitLine -> [hitPoints...]
+                  for (const vr of valleyExtensions) {
+                    if (vr.source !== 'roofBase') continue
+                    if (!vr.hitLine || !vr.hitPoint) continue
+                    if (!splitMap.has(vr.hitLine)) splitMap.set(vr.hitLine, [])
+                    splitMap.get(vr.hitLine).push(vr.hitPoint)
+                  }
+                  for (const [hitLine, hitPoints] of splitMap.entries()) {
+                    const origPts = [hitLine.x1, hitLine.y1, hitLine.x2, hitLine.y2]
+                    const origAttrs = { ...(hitLine.attributes || {}) }
+                    const origName = hitLine.name
+                    const origLineName = hitLine.lineName
+                    const origStroke = hitLine.stroke
+                    const origStrokeWidth = hitLine.strokeWidth
+                    // start 에서 거리 순 정렬.
+                    const sx = hitLine.x1
+                    const sy = hitLine.y1
+                    hitPoints.sort((a, b) => Math.hypot(a.x - sx, a.y - sy) - Math.hypot(b.x - sx, b.y - sy))
+                    const splitSegs = []
+                    let cur = { x: hitLine.x1, y: hitLine.y1 }
+                    for (const hp of hitPoints) {
+                      splitSegs.push([cur.x, cur.y, hp.x, hp.y])
+                      cur = hp
+                    }
+                    splitSegs.push([cur.x, cur.y, hitLine.x2, hitLine.y2])
+                    const halves = []
+                    for (const segPts of splitSegs) {
+                      const segSz = calcLinePlaneSize({ x1: segPts[0], y1: segPts[1], x2: segPts[2], y2: segPts[3] })
+                      const half = new QLine(segPts, {
+                        parentId: hitLine.parentId,
+                        fontSize: hitLine.fontSize,
+                        stroke: origStroke,
+                        strokeWidth: origStrokeWidth,
+                        name: origName,
+                        textMode: hitLine.textMode,
+                        attributes: { ...origAttrs, planeSize: segSz, actualSize: segSz },
+                      })
+                      if (origLineName) half.lineName = origLineName
+                      half.__valleyExtSplitHalf = true
+                      half.__valleyExtSplitTargetId = target.id
+                      canvas.add(half)
+                      half.bringToFront()
+                      roof.innerLines.push(half)
+                      halves.push(half)
+                    }
+                    // 원본 제거.
+                    removeLine(hitLine)
+                    roof.innerLines = roof.innerLines.filter((il) => il !== hitLine)
+                    splitRecords.push({
+                      halves,
+                      originalPts: origPts,
+                      originalAttrs: origAttrs,
+                      originalName: origName,
+                      originalLineName: origLineName,
+                      originalStroke: origStroke,
+                      originalStrokeWidth: origStrokeWidth,
+                    })
+                  }
+                  if (splitRecords.length) target.__valleyExtSplits = splitRecords
+
+                  for (const vr of valleyExtensions) {
+                    const pts = [vr.x1, vr.y1, vr.x2, vr.y2]
+                    const sz = calcLinePlaneSize({ x1: pts[0], y1: pts[1], x2: pts[2], y2: pts[3] })
+                    // [KERAB-VALLEY-EXT 2026-05-27] 지붕면 할당 통합 (option a):
+                    //   roofBase 확장은 처마의 연장 → attributes.type=EAVES + parentLine + innerLines push (split 참여).
+                    //   wallBase 확장은 wall layer (roof 폴리곤 밖) → 시각만, innerLines 비추가, type/parent 부여 안 함.
+                    const isRoofBase = vr.source === 'roofBase'
+                    const baseAttrs = { roofId: roof.id, planeSize: sz, actualSize: sz }
+                    if (isRoofBase) {
+                      // [KERAB-VALLEY-EXT 2026-05-27] splitPolygonWithLines 의 innerLineMapping 은
+                      //   EAVES polygonLine 을 skip 하므로(usePolygon.js:822) 처마확장은 자동 매핑이 안 된다.
+                      //   처마 라인 매핑과 동일하게 type/isStart 를 직접 부여.
+                      baseAttrs.type = LINE_TYPE.WALLLINE.EAVES
+                      baseAttrs.isStart = true
+                    }
+                    const vExt = new QLine(pts, {
+                      parentId: roof.id,
+                      fontSize: roof.fontSize,
+                      stroke: '#1083E3',
+                      strokeWidth: 3,
+                      name: LINE_TYPE.SUBLINE.VALLEY,
+                      textMode: roof.textMode,
+                      attributes: baseAttrs,
+                    })
+                    vExt.lineName = 'kerabPatternValleyExt'
+                    vExt.__targetId = target.id
+                    vExt.__valleyExtSource = vr.source
+                    if (isRoofBase && vr.parent) {
+                      vExt.parentLine = vr.parent
+                      // [KERAB-VALLEY-EXT 2026-05-27] direction 도 부모 roofLine 에서 상속 — flow/pitch 방향 일관.
+                      if (vr.parent.direction) vExt.direction = vr.parent.direction
+                    }
+                    canvas.add(vExt)
+                    vExt.bringToFront()
+                    if (isRoofBase) roof.innerLines.push(vExt)
+                  }
+                  if (valleyExtensions.length) {
+                    logger.log('[KERAB-VALLEY-EXT] drawn ' + valleyExtensions.length)
+                  }
+                }
+                logger.log('[KERAB-SIMPLE] applied (sequential, drawKLine=' + drawKLine + ', extraApexes=' + extraApexes.length + ')')
+                return
+              }
+              logger.log('[KERAB-SIMPLE] no resolution possible — fallback attr-only')
+              target.set({ attributes })
+              applyKerabAttributeOnlyPattern()
+              return
+            }
+            // condition 1: 자연 만남 — ext 없이 hip 제거 + kLine
+            target.set({ attributes })
+            applyKerabKLinePattern(
+              roof,
+              target,
+              apex,
+              h1Match.near,
+              h2Match.near,
+              [h1Match.hip, h2Match.hip],
+              null,
+              null,
+            )
+            logger.log('[KERAB-SIMPLE] applied (kLine, natural-apex)')
+            return
+          }
+        }
+        target.set({ attributes })
+        applyKerabAttributeOnlyPattern()
+        logger.log('[KERAB-SIMPLE] attr-only fallback')
+        return
       }
     }
 
@@ -300,17 +1497,47 @@ export function useEavesGableEdit(id) {
         const c1 = nearestRoofPoint(roof, { x: target.x1, y: target.y1 })
         const c2 = nearestRoofPoint(roof, { x: target.x2, y: target.y2 })
         if (c1 && c2) {
-          const ridgeAtMid = findRidgeAtMidpoint(roof, c1, c2)
+          // [KERAB-OFFSET-SURGICAL 2026-05-27] revert 경로에서는 hip snapshot 좌표가 옛 corner 기준이라
+          //   surgical 을 pattern 호출 **후**로 미룬다. pattern 이 옛 corner 로 hip 복원 후, surgical 의
+          //   inner-line corner snap 이 hip 끝점도 새 corner 로 함께 이동시킨다.
+          const surgicalAfter = () => {
+            if (roof) applyTargetOffsetSurgical(target, attributes?.offset ?? 0)
+          }
+          // [2240 KERAB-PARALLEL-HIPS 2026-05-19] forward 가 parallel-hips 였으면 target 에 스냅샷이 붙어있음 → hip 2개 복원
+          if (Array.isArray(target.__kerabParallelHipsSnapshot)) {
+            target.set({ attributes })
+            revertKerabParallelHipsPattern(roof, target)
+            surgicalAfter()
+            logger.log('[KERAB-REVERT] applied (parallel-hips) ' + JSON.stringify({ c1, c2 }))
+            return
+          }
+          // [KERAB-SIMPLE-REVERT 2026-05-20] kLineOnly 패턴: ridge.__targetId 로 직접 매칭 (nearestRoofPoint drift 회피)
+          const kLineRidge = roof.innerLines.find(
+            (il) => il && il.__patternKind === 'kLineOnly' && il.__targetId === target.id,
+          )
+          if (kLineRidge) {
+            target.set({ attributes })
+            const ok = applyKerabRevertPattern(roof, target, c1, c2, { ridge: kLineRidge, apex: null })
+            if (ok) surgicalAfter()
+            logger.log('[KERAB-REVERT] applied (kLineOnly via targetId) ' + JSON.stringify({ ok }))
+            if (ok) return
+          }
+          // [2240 KERAB-MID-FROM-TARGET 2026-05-20] revert 도 target 중점 기준 ridge 검색 (forward 와 일관)
+          const tEnd1 = { x: target.x1, y: target.y1 }
+          const tEnd2 = { x: target.x2, y: target.y2 }
+          const ridgeAtMid = findRidgeAtMidpoint(roof, tEnd1, tEnd2)
           if (ridgeAtMid) {
             target.set({ attributes })
             const ok = applyKerabRevertPattern(roof, target, c1, c2, ridgeAtMid)
-            logger.log('[KERAB-REVERT] applied', { ok, c1, c2, apex: ridgeAtMid.apex })
+            if (ok) surgicalAfter()
+            logger.log('[KERAB-REVERT] applied ' + JSON.stringify({ ok, c1, c2, apex: ridgeAtMid.apex }))
             if (ok) return
           }
           // [2240 KERAB-ATTR-ONLY 2026-05-19] ridge-at-mid 없음 → forward 가 attribute-only 였음 → 동일 대칭으로 속성만 토글
           target.set({ attributes })
           applyKerabAttributeOnlyPattern()
-          logger.log('[KERAB-ATTR-ONLY] applied (revert)', { c1, c2 })
+          surgicalAfter()
+          logger.log('[KERAB-ATTR-ONLY] applied (revert) ' + JSON.stringify({ c1, c2 }))
           return
         }
       }
@@ -427,6 +1654,14 @@ export function useEavesGableEdit(id) {
     canvas?.renderAll()
   }
 
+  // [2240 KERAB-OFFSET-SURGICAL 2026-05-27] 본체는 `@/util/kerab-offset-surgical` 로 분리.
+  //   고객 회귀 확인을 위한 토글 — ENABLE_KERAB_OFFSET_SURGICAL false 면 즉시 false 반환.
+  const applyTargetOffsetSurgical = (target, newOffset) => {
+    if (!ENABLE_KERAB_OFFSET_SURGICAL) return false
+    return applyKerabOffsetSurgical(canvas, target, newOffset)
+  }
+
+
   // [2240 KERAB-SINGLE-RIDGE 2026-05-19] 헬퍼 — 양 끝점 hip 페어 식별 및 ridge 단일화 적용
   const KERAB_TOL = 0.5
   const isSamePt = (a, b) => Math.abs(a.x - b.x) < KERAB_TOL && Math.abs(a.y - b.y) < KERAB_TOL
@@ -472,17 +1707,36 @@ export function useEavesGableEdit(id) {
     return null
   }
 
-  // [2240 KERAB-EXTENDED-APEX 2026-05-19] B-5 끝점 hip(H-7, H-1) 을 무한 확장한 교점이
-  // 처마 중점 수선 위에 있으면 apex 채택. 채택 시 단일-ridge 패턴과 동일하게 hip 2개 제거 + mid→apex ridge.
-  const findHipPairWithExtendedApex = (hipsAtP1, p1, hipsAtP2, p2) => {
-    const mid = { x: (p1.x + p2.x) / 2, y: (p1.y + p2.y) / 2 }
-    const eVx = p2.x - p1.x
-    const eVy = p2.y - p1.y
-    const eMag = Math.hypot(eVx, eVy) || 1
+  // [2240 KERAB-PARALLEL-HIPS 2026-05-19] 양 끝점 hip 페어가 평행한지 검사.
+  // 두 hip 방향벡터의 정규화 cross product 절대값 < 0.01 이면 평행 → 무한확장해도 교점 없음 → apex 없음.
+  // 이 케이스는 hip 만 제거하고 중앙선(kLine) 은 생성하지 않는다.
+  const findParallelHipPair = (hipsAtP1, p1, hipsAtP2, p2) => {
     for (const hA of hipsAtP1) {
       const oA = otherEndOfHip(hA, p1)
-      // hA 의 진행방향: p1 → oA 의 반대로(oA 너머 확장) 이 아닌, hip 자체를 무한 직선으로 본 교점 계산.
-      // 직선 파라미터: p1 + t*(oA - p1). t>1 이면 oA 너머(폴리곤 내부 방향).
+      const dAx = oA.x - p1.x
+      const dAy = oA.y - p1.y
+      const magA = Math.hypot(dAx, dAy) || 1
+      for (const hB of hipsAtP2) {
+        if (hB === hA) continue
+        const oB = otherEndOfHip(hB, p2)
+        const dBx = oB.x - p2.x
+        const dBy = oB.y - p2.y
+        const magB = Math.hypot(dBx, dBy) || 1
+        const cross = (dAx * dBy - dAy * dBx) / (magA * magB)
+        if (Math.abs(cross) < 0.01) return { hA, hB }
+      }
+    }
+    return null
+  }
+
+  // [2240 KERAB-EXTENDED-APEX 2026-05-20] c1·c2 의 outer hip(H1, H2) 을 무한 확장한 교점을 apex 로 채택.
+  //   사용자 모델: H1, H2 가 (연장하면) 만나는 점이 apex. 처마 중점 수선 위에 있지 않아도 채택.
+  //   (dotEaves 제약 제거 — 2026-05-20)
+  //   채택 조건: ① 두 hip 이 평행이 아님 ② 교점이 두 hip 끝점 너머(t,s>1) 에 위치
+  const findHipPairWithExtendedApex = (hipsAtP1, p1, hipsAtP2, p2) => {
+    for (const hA of hipsAtP1) {
+      const oA = otherEndOfHip(hA, p1)
+      // hip 자체를 무한 직선으로 본 교점 계산. 직선 파라미터: p1 + t*(oA - p1). t>1 이면 oA 너머(폴리곤 내부 방향).
       const dAx = oA.x - p1.x
       const dAy = oA.y - p1.y
       for (const hB of hipsAtP2) {
@@ -496,12 +1750,11 @@ export function useEavesGableEdit(id) {
         const py = p2.y - p1.y
         const t = (px * dBy - py * dBx) / denom
         const s = (px * dAy - py * dAx) / denom
-        // hip 의 진행방향(끝점 너머) 으로 만나야 함. t,s > 1 (oA, oB 너머 확장)
-        if (t <= 1 + 1e-3 || s <= 1 + 1e-3) continue
+        // [KERAB-EXTENDED-APEX-TS 2026-05-20] apex 가 hip 의 진행방향(양수 쪽) 에 있을 것만 요구.
+        //   t,s > 1 (양쪽 모두 끝점 너머) 까지 강제하지 않음 — 한 쪽 hip 가 충분히 길어 apex 가
+        //   자기 segment 안쪽에 있는 케이스도 「H1, H2 가 만났다」로 인정 (사용자 모델, 2026-05-20).
+        if (t <= 1e-3 || s <= 1e-3) continue
         const apex = { x: p1.x + t * dAx, y: p1.y + t * dAy }
-        // 가운데 검증: (apex - mid) 이 처마 방향과 수직(내적 ≈ 0)
-        const dotEaves = ((apex.x - mid.x) * eVx + (apex.y - mid.y) * eVy) / eMag
-        if (Math.abs(dotEaves) > KERAB_TOL) continue
         return { hA, hB, apex }
       }
     }
@@ -597,6 +1850,158 @@ export function useEavesGableEdit(id) {
     return Math.hypot(p.x - px, p.y - py) <= tol
   }
 
+  // [2240 KERAB-SIMPLE 2026-05-20] target 끝점에서 가장 가까운 끝점을 가진 hip 검색.
+  //   처마 끝점(벽 좌표) vs hip 끝점(offset 좌표) 의 좌표계 차이(최대 ~50 단위) 는 거리 비교로 흡수.
+  //   nearestRoofPoint 안 거침 — 처마가 짧을 때(<500mm) 인접 코너로 잘못 스냅되는 문제 회피.
+  //   동일 위치 겹치는 hip 도 좌표가 미세하게 달라 거리 최소값으로 구분 가능.
+  // [KERAB-SIMPLE 2026-05-20] target 끝점 pt 에 대응되는 hip 의 "near" 끝점은
+  // 코너의 대각선 offset 위치 (dx, dy 둘 다 0 이 아님). 축정렬(dx=0 또는 dy=0) 후보는
+  // 인접 L-노치 코너의 offset 일 가능성이 높아 제외. 대각 후보 없으면 폴백으로 최근접.
+  const AXIS_EPS = 1.0
+  const findHipAtEndpoint = (roof, pt) => {
+    let bestDiag = null
+    let bestDiagD = Infinity
+    let bestAny = null
+    let bestAnyD = Infinity
+    for (const il of roof.innerLines || []) {
+      if (!il || il.attributes?.type !== LINE_TYPE.SUBLINE.HIP) continue
+      const a = { x: il.x1, y: il.y1 }
+      const b = { x: il.x2, y: il.y2 }
+      const dA = Math.hypot(a.x - pt.x, a.y - pt.y)
+      const dB = Math.hypot(b.x - pt.x, b.y - pt.y)
+      const aDiag = Math.abs(a.x - pt.x) > AXIS_EPS && Math.abs(a.y - pt.y) > AXIS_EPS
+      const bDiag = Math.abs(b.x - pt.x) > AXIS_EPS && Math.abs(b.y - pt.y) > AXIS_EPS
+      if (dA < bestAnyD) { bestAnyD = dA; bestAny = { hip: il, near: a, far: b, dist: dA } }
+      if (dB < bestAnyD) { bestAnyD = dB; bestAny = { hip: il, near: b, far: a, dist: dB } }
+      if (aDiag && dA < bestDiagD) { bestDiagD = dA; bestDiag = { hip: il, near: a, far: b, dist: dA } }
+      if (bDiag && dB < bestDiagD) { bestDiagD = dB; bestDiag = { hip: il, near: b, far: a, dist: dB } }
+    }
+    return bestDiag || bestAny
+  }
+
+  // 두 직선(p1-p2, p3-p4)의 무한확장 교점. 평행이면 null.
+  const lineLineIntersection = (p1, p2, p3, p4) => {
+    const d = (p1.x - p2.x) * (p3.y - p4.y) - (p1.y - p2.y) * (p3.x - p4.x)
+    if (Math.abs(d) < 1e-6) return null
+    const t = ((p1.x - p3.x) * (p3.y - p4.y) - (p1.y - p3.y) * (p3.x - p4.x)) / d
+    return { x: p1.x + t * (p2.x - p1.x), y: p1.y + t * (p2.y - p1.y) }
+  }
+
+  // [KERAB-SIMPLE-OTHERHIP 2026-05-20] pt 위치에서 excludeHip 을 제외한 또 다른 hip 검색.
+  //   RG-1 너머에서 같은 분기점(h*.far) 에 붙어있는 hip — 확장 방향을 정의함.
+  const findOtherHipAtPoint = (roof, pt, excludeHip, tol = 1.0) => {
+    let best = null
+    let bestD = Infinity
+    for (const il of roof.innerLines || []) {
+      if (!il || il === excludeHip) continue
+      if (il.attributes?.type !== LINE_TYPE.SUBLINE.HIP) continue
+      const a = { x: il.x1, y: il.y1 }
+      const b = { x: il.x2, y: il.y2 }
+      const dA = Math.hypot(a.x - pt.x, a.y - pt.y)
+      const dB = Math.hypot(b.x - pt.x, b.y - pt.y)
+      if (dA <= tol && dA < bestD) {
+        bestD = dA
+        best = { hip: il, near: a, far: b }
+      }
+      if (dB <= tol && dB < bestD) {
+        bestD = dB
+        best = { hip: il, near: b, far: a }
+      }
+    }
+    return best
+  }
+
+  // [KERAB-EXTENDER 2026-05-21] 사용자 전제 3: pt(접점) 에서 polygon 경계 라인을 제외한
+  //   inner line(hip 또는 ridge) 을 extender 로 검색. extender 의 방향(near→far)이 확장 방향.
+  //   반환: { line, near, far, isHip } 또는 null.
+  const findExtenderAtPoint = (roof, pt, excludedLines = [], tol = 1.0) => {
+    const excludeSet = new Set(excludedLines)
+    let best = null
+    let bestD = Infinity
+    for (const il of roof.innerLines || []) {
+      if (!il || excludeSet.has(il)) continue
+      if (il.name !== LINE_TYPE.SUBLINE.HIP && il.name !== LINE_TYPE.SUBLINE.RIDGE) continue
+      const a = { x: il.x1, y: il.y1 }
+      const b = { x: il.x2, y: il.y2 }
+      const dA = Math.hypot(a.x - pt.x, a.y - pt.y)
+      const dB = Math.hypot(b.x - pt.x, b.y - pt.y)
+      const isHip = il.name === LINE_TYPE.SUBLINE.HIP
+      if (dA <= tol && dA < bestD) {
+        bestD = dA
+        best = { line: il, near: a, far: b, isHip }
+      }
+      if (dB <= tol && dB < bestD) {
+        bestD = dB
+        best = { line: il, near: b, far: a, isHip }
+      }
+    }
+    return best
+  }
+
+  // [KERAB-SIMPLE-MIDRIDGE 2026-05-20] 두 hip 의 far 끝점 p1·p2 를 잇는 ridge 검색.
+  //   확장 apex 케이스에서 hip 사이를 잇던 RG-1 같은 마루를 제거 대상으로 식별.
+  const findRidgeBetweenHipFars = (roof, p1, p2, tol = KERAB_TOL) => {
+    for (const il of roof.innerLines || []) {
+      if (!il || il.name !== LINE_TYPE.SUBLINE.RIDGE) continue
+      const a = { x: il.x1, y: il.y1 }
+      const b = { x: il.x2, y: il.y2 }
+      const aP1 = Math.hypot(a.x - p1.x, a.y - p1.y) <= tol
+      const aP2 = Math.hypot(a.x - p2.x, a.y - p2.y) <= tol
+      const bP1 = Math.hypot(b.x - p1.x, b.y - p1.y) <= tol
+      const bP2 = Math.hypot(b.x - p2.x, b.y - p2.y) <= tol
+      if ((aP1 && bP2) || (aP2 && bP1)) return il
+    }
+    return null
+  }
+
+  // [KERAB-POLYGON-BFS 2026-05-21] 사용자 전제 2: 선택한 외곽선이 속한 내부 다각형의
+  //   inner line 경계를 BFS 로 추적. p1=h1.far → p2=h2.far 사이의 hip/ridge 체인을 모두 반환.
+  //   excludeLines=[h1, h2] 로 시작점 hip 자체를 통과하지 않게 하고,
+  //   중간 junction 이 있는 비대칭 케이스(Ridge→junction→otherHip 등)도 한 번에 식별.
+  //   반환: [{ line, from, to }, ...] 또는 path 가 없으면 null.
+  const traceInnerPolygonPath = (roof, p1, p2, excludeLines = [], tol = KERAB_TOL) => {
+    const same = (a, b) => Math.hypot(a.x - b.x, a.y - b.y) <= tol
+    if (same(p1, p2)) return []
+    const excludeSet = new Set(excludeLines)
+    const ptKey = (p) => `${Math.round(p.x * 10) / 10}_${Math.round(p.y * 10) / 10}`
+    const visited = new Set([ptKey(p1)])
+    const queue = [{ point: p1, path: [] }]
+    while (queue.length > 0) {
+      const { point, path } = queue.shift()
+      for (const il of roof.innerLines || []) {
+        if (!il || excludeSet.has(il)) continue
+        if (il.name !== LINE_TYPE.SUBLINE.HIP && il.name !== LINE_TYPE.SUBLINE.RIDGE) continue
+        const a = { x: il.x1, y: il.y1 }
+        const b = { x: il.x2, y: il.y2 }
+        let nextPoint = null
+        if (same(a, point)) nextPoint = b
+        else if (same(b, point)) nextPoint = a
+        if (!nextPoint) continue
+        if (same(nextPoint, p2)) {
+          return [...path, { line: il, from: point, to: nextPoint }]
+        }
+        const key = ptKey(nextPoint)
+        if (visited.has(key)) continue
+        visited.add(key)
+        queue.push({ point: nextPoint, path: [...path, { line: il, from: point, to: nextPoint }] })
+      }
+    }
+    return null
+  }
+
+  // apex 좌표를 끝점 또는 segment 위로 통과하는 ridge 검색 (RG-1 검증). tol 은 좌표 drift 흡수용.
+  const findRidgePassingThrough = (roof, pt, tol = KERAB_TOL) => {
+    for (const il of roof.innerLines || []) {
+      if (!il || il.name !== LINE_TYPE.SUBLINE.RIDGE) continue
+      const a = { x: il.x1, y: il.y1 }
+      const b = { x: il.x2, y: il.y2 }
+      if (Math.hypot(a.x - pt.x, a.y - pt.y) <= tol) return il
+      if (Math.hypot(b.x - pt.x, b.y - pt.y) <= tol) return il
+      if (isPointOnSegment(pt, { x1: a.x, y1: a.y, x2: b.x, y2: b.y }, tol)) return il
+    }
+    return null
+  }
+
   // [2240 KERAB-CENTRAL-RIDGE 2026-05-19] ridge 의 양 끝점이 ext1·ext2 각각의 segment 위에 있는지.
   // RG-1 은 H-4/H-2 확장선 사이에 놓인 ridge — 두 확장선이 RG-1 의 양 끝점을 각각 통과한다.
   const ridgeEndpointsOnBothExtensions = (ridge, ext1, ext2) => {
@@ -630,6 +2035,50 @@ export function useEavesGableEdit(id) {
   //   - 둘 다 없으면 폴백: c1↔apex, c2↔apex 신규 hip (이전 패턴 호환)
   const applyKerabRevertPattern = (roof, target, c1, c2, ridgeAtMid) => {
     const apex = ridgeAtMid.apex
+    // [KERAB-VALLEY-EXT 2026-05-27] forward 에서 추가됐던 처마확장(kerabPatternValleyExt) 제거.
+    //   __targetId === target.id 매칭으로 해당 target 의 처마확장만 정확히 정리. 모든 패턴 분기 공통.
+    //   roofBase 확장은 roof.innerLines 에 있고 wallBase 확장은 canvas 에만 있으므로 canvas 전체 스캔.
+    const valleyExtsToRemove = (canvas.getObjects() || []).filter(
+      (il) => il && il.lineName === 'kerabPatternValleyExt' && il.__targetId === target.id,
+    )
+    for (const v of valleyExtsToRemove) {
+      removeLine(v)
+      roof.innerLines = roof.innerLines.filter((il) => il !== v)
+    }
+    if (valleyExtsToRemove.length) {
+      logger.log('[KERAB-VALLEY-EXT] revert removed ' + valleyExtsToRemove.length)
+    }
+    // [KERAB-VALLEY-EXT-SPLIT 2026-05-27] forward 에서 분할했던 hit innerLine 복원.
+    //   halves 제거 + 원본 snapshot 으로 1개 재생성.
+    if (Array.isArray(target.__valleyExtSplits) && target.__valleyExtSplits.length) {
+      for (const rec of target.__valleyExtSplits) {
+        for (const half of rec.halves || []) {
+          removeLine(half)
+          roof.innerLines = roof.innerLines.filter((il) => il !== half)
+        }
+        const sz = calcLinePlaneSize({
+          x1: rec.originalPts[0],
+          y1: rec.originalPts[1],
+          x2: rec.originalPts[2],
+          y2: rec.originalPts[3],
+        })
+        const restored = new QLine(rec.originalPts, {
+          parentId: roof.id,
+          fontSize: roof.fontSize,
+          stroke: rec.originalStroke,
+          strokeWidth: rec.originalStrokeWidth,
+          name: rec.originalName,
+          textMode: roof.textMode,
+          attributes: { ...rec.originalAttrs, planeSize: rec.originalAttrs?.planeSize ?? sz, actualSize: rec.originalAttrs?.actualSize ?? sz },
+        })
+        if (rec.originalLineName) restored.lineName = rec.originalLineName
+        canvas.add(restored)
+        restored.bringToFront()
+        roof.innerLines.push(restored)
+      }
+      logger.log('[KERAB-VALLEY-EXT-SPLIT] revert restored ' + target.__valleyExtSplits.length + ' hit-line(s)')
+      delete target.__valleyExtSplits
+    }
     const buildHipFromSnapshot = (snap) => {
       const pts = [snap.x1, snap.y1, snap.x2, snap.y2]
       const sz = calcLinePlaneSize({ x1: pts[0], y1: pts[1], x2: pts[2], y2: pts[3] })
@@ -653,7 +2102,7 @@ export function useEavesGableEdit(id) {
         parentId: roof.id,
         fontSize: roof.fontSize,
         stroke: '#1083E3',
-        strokeWidth: 4,
+        strokeWidth: 3,
         name: LINE_TYPE.SUBLINE.HIP,
         textMode: roof.textMode,
         attributes: { roofId: roof.id, planeSize: sz, actualSize: sz },
@@ -667,6 +2116,62 @@ export function useEavesGableEdit(id) {
       hip.attributes = { ...hip.attributes, ...snap.attributes, planeSize: ns, actualSize: ns }
     }
 
+    // [2240 KERAB-KLINE-ONLY 2026-05-20] kLine 만 그렸던 패턴: ridge 1개 제거 + 제거됐던 hip 복원.
+    //   forward 가 ridge add + hip 2개 remove 했으므로 revert 도 동일하게 되돌림.
+    if (ridgeAtMid.ridge.__patternKind === 'kLineOnly') {
+      const removedHips = Array.isArray(ridgeAtMid.ridge.__removedHipsSnapshot) ? ridgeAtMid.ridge.__removedHipsSnapshot : []
+      const removedRidges = Array.isArray(ridgeAtMid.ridge.__removedRidgesSnapshot) ? ridgeAtMid.ridge.__removedRidgesSnapshot : []
+      const extHipsCreated = Array.isArray(ridgeAtMid.ridge.__extHipsCreated) ? ridgeAtMid.ridge.__extHipsCreated : []
+      // [KERAB-SIMPLE-EXTHIP 2026-05-20] forward 에서 추가됐던 ext hip 제거.
+      for (const eh of extHipsCreated) {
+        if (!eh) continue
+        removeLine(eh)
+        roof.innerLines = roof.innerLines.filter((il) => il !== eh)
+      }
+      removeLine(ridgeAtMid.ridge)
+      roof.innerLines = roof.innerLines.filter((il) => il !== ridgeAtMid.ridge)
+      for (const snap of removedHips) {
+        const sz = calcLinePlaneSize({ x1: snap.x1, y1: snap.y1, x2: snap.x2, y2: snap.y2 })
+        const hip = new QLine([snap.x1, snap.y1, snap.x2, snap.y2], {
+          parentId: roof.id,
+          fontSize: roof.fontSize,
+          stroke: '#1083E3',
+          strokeWidth: 3,
+          name: LINE_TYPE.SUBLINE.HIP,
+          textMode: roof.textMode,
+          attributes: { roofId: roof.id, planeSize: sz, actualSize: sz, ...(snap.attributes || {}) },
+        })
+        if (snap.lineName) hip.lineName = snap.lineName
+        if (snap.__extended) hip.__extended = snap.__extended
+        canvas.add(hip)
+        hip.bringToFront()
+        roof.innerLines.push(hip)
+      }
+      // [KERAB-SIMPLE-MIDRIDGE 2026-05-20] forward 시 제거됐던 hip-사이 ridge 복원.
+      for (const snap of removedRidges) {
+        if (!snap) continue
+        const pts = [snap.x1, snap.y1, snap.x2, snap.y2]
+        const sz = calcLinePlaneSize({ x1: pts[0], y1: pts[1], x2: pts[2], y2: pts[3] })
+        const restored = new QLine(pts, {
+          parentId: roof.id,
+          fontSize: roof.fontSize,
+          stroke: '#1083E3',
+          strokeWidth: 3,
+          name: LINE_TYPE.SUBLINE.RIDGE,
+          textMode: roof.textMode,
+          attributes: { roofId: roof.id, planeSize: sz, actualSize: sz, ...(snap.attributes || {}) },
+        })
+        if (snap.lineName) restored.lineName = snap.lineName
+        canvas.add(restored)
+        restored.bringToFront()
+        roof.innerLines.push(restored)
+      }
+      removeKerabHalfLabels(target.id)
+      hideOriginalLengthText(target.id, false)
+      canvas.renderAll()
+      return true
+    }
+
     // junctionExtended: ext hip 2개 + ridge 1개 제거 + 제거됐던 RG-1 + outer/inner hip 4개 복원
     if (ridgeAtMid.ridge.__patternKind === 'junctionExtended') {
       const extHips = Array.isArray(ridgeAtMid.ridge.__patternExtHips) ? ridgeAtMid.ridge.__patternExtHips : []
@@ -687,7 +2192,7 @@ export function useEavesGableEdit(id) {
           parentId: roof.id,
           fontSize: roof.fontSize,
           stroke: '#1083E3',
-          strokeWidth: 4,
+          strokeWidth: 3,
           name: LINE_TYPE.SUBLINE.RIDGE,
           textMode: roof.textMode,
           attributes: { roofId: roof.id, planeSize: sz, actualSize: sz, ...snap.attributes },
@@ -818,9 +2323,315 @@ export function useEavesGableEdit(id) {
     __extended: hip.__extended,
   })
 
+  // [2240 KERAB-SIMPLE 2026-05-20] 단순 알고리즘 전용 그리기 함수.
+  //   mid(roof corner c1·c2 중점) → apex 중앙선 추가 + 양쪽 hip(h1·h2) 제거.
+  //   c1, c2 가 hip.near (대각 offset roof corner) 이므로 그 중점이 roofLine 위 중점이 됨.
+  //   revert 는 __patternKind='kLineOnly' 분기 + hipSnapshot 으로 ridge 제거 + hip 2개 복원.
+  const applyKerabKLinePattern = (roof, target, apex, c1, c2, hipsToRemove, ridgesToRemove, extLines, drawKLine = true, extraApexes = []) => {
+    // [KERAB-SIMPLE-KLINE-PERP 2026-05-20] kLine = apex 에서 roofLine(c1·c2 무한확장) 으로
+    //   내린 수선의 발 → apex. 시작점이 hip 교점이므로 이 직선 자체가 "hip 라인의 중앙선".
+    //   roofLine 중앙과는 무관 (비대칭이면 빗겨 떨어진다).
+    // [KERAB-EXTENDER-MIXED 2026-05-21] drawKLine=false (hip+ridge mixed extender) 케이스:
+    //   사용자 전제 3 "hip과 마루가 만나면 그 자리에서 멈춘다" — kLine 없이 apex 까지의 ext line 만.
+    //   revert 식별을 위해 apex 위치 zero-length invisible 마커 ridge 추가.
+    let ridge
+    if (drawKLine) {
+      const dx = c2.x - c1.x
+      const dy = c2.y - c1.y
+      const lenSq = dx * dx + dy * dy || 1
+      const t = ((apex.x - c1.x) * dx + (apex.y - c1.y) * dy) / lenSq
+      const naiveFoot = { x: c1.x + t * dx, y: c1.y + t * dy }
+      let foot = naiveFoot
+      // [KERAB-KLINE-TO-WALL 2026-05-21] kLine 도 roofLine 까지 확장 — apex 에서 naiveFoot 방향으로
+      //   ray cast 해서 roof 폴리곤의 어떤 wall 이라도 가장 가까운 교점까지 연장.
+      //   비대칭 폴리곤에서 c1-c2 무한확장선이 폴리곤 밖으로 빠지는 케이스 흡수.
+      if (Array.isArray(roof.points) && roof.points.length >= 2) {
+        const fdx = naiveFoot.x - apex.x
+        const fdy = naiveFoot.y - apex.y
+        const flen2 = fdx * fdx + fdy * fdy
+        if (flen2 > 1e-6) {
+          const rayEnd = { x: apex.x + fdx, y: apex.y + fdy }
+          let bestPt = null
+          let bestDist = Infinity
+          for (let i = 0; i < roof.points.length; i++) {
+            const a = roof.points[i]
+            const b = roof.points[(i + 1) % roof.points.length]
+            const ip = lineLineIntersection(apex, rayEnd, a, b)
+            if (!ip) continue
+            const fwd = (ip.x - apex.x) * fdx + (ip.y - apex.y) * fdy
+            if (fwd <= 1e-3) continue
+            if (!isPointOnSegment(ip, { x1: a.x, y1: a.y, x2: b.x, y2: b.y })) continue
+            const dist = Math.hypot(ip.x - apex.x, ip.y - apex.y)
+            if (dist < bestDist) {
+              bestDist = dist
+              bestPt = ip
+            }
+          }
+          if (bestPt) foot = bestPt
+        }
+      }
+      // [KERAB-KLINE-STOP 2026-05-21] 새 kLine(apex→foot) 이 기존 kLine 가로지르면 가장 가까운 교점까지 클립.
+      const existingKLines = (roof.innerLines || []).filter(
+        (il) => il && il.lineName === 'kerabPatternRidge' && !il.__noKLine && il.__targetId !== target.id && il.visible !== false,
+      )
+      if (existingKLines.length) {
+        const segOnLine = (pt, ax, ay, bx, by, tol = 0.5) => {
+          const ddx = bx - ax
+          const ddy = by - ay
+          const sq = ddx * ddx + ddy * ddy
+          if (sq < 1e-6) return Math.hypot(pt.x - ax, pt.y - ay) <= tol
+          const tt = ((pt.x - ax) * ddx + (pt.y - ay) * ddy) / sq
+          const margin = tol / Math.sqrt(sq)
+          if (tt < -margin || tt > 1 + margin) return false
+          const px = ax + tt * ddx
+          const py = ay + tt * ddy
+          return Math.hypot(px - pt.x, py - pt.y) <= tol
+        }
+        let bestT = 1
+        let bestPt = null
+        const adx = foot.x - apex.x
+        const ady = foot.y - apex.y
+        for (const kl of existingKLines) {
+          const ip = lineLineIntersection(apex, foot, { x: kl.x1, y: kl.y1 }, { x: kl.x2, y: kl.y2 })
+          if (!ip) continue
+          if (!segOnLine(ip, kl.x1, kl.y1, kl.x2, kl.y2)) continue
+          const tt = (adx * (ip.x - apex.x) + ady * (ip.y - apex.y)) / (adx * adx + ady * ady || 1)
+          if (tt <= 1e-3 || tt > 1 + 1e-3) continue
+          if (tt < bestT) {
+            bestT = tt
+            bestPt = ip
+          }
+        }
+        if (bestPt) foot = bestPt
+      }
+      // [KERAB-NO-PIERCE 2026-05-21] kLine 도 정적 hip/ridge + 이번 ext line 가로지르면 거기서 정지.
+      //   hipsToRemove/ridgesToRemove 는 곧 사라질 라인이므로 barrier 에서 제외.
+      {
+        const segOnLine = (pt, ax, ay, bx, by, tol = 0.5) => {
+          const ddx = bx - ax
+          const ddy = by - ay
+          const sq = ddx * ddx + ddy * ddy
+          if (sq < 1e-6) return Math.hypot(pt.x - ax, pt.y - ay) <= tol
+          const tt = ((pt.x - ax) * ddx + (pt.y - ay) * ddy) / sq
+          const margin = tol / Math.sqrt(sq)
+          if (tt < -margin || tt > 1 + margin) return false
+          const px = ax + tt * ddx
+          const py = ay + tt * ddy
+          return Math.hypot(px - pt.x, py - pt.y) <= tol
+        }
+        const removingHips = new Set(Array.isArray(hipsToRemove) ? hipsToRemove : [])
+        const removingRidges = new Set(Array.isArray(ridgesToRemove) ? ridgesToRemove : [])
+        const kBarriers = []
+        for (const il of roof.innerLines || []) {
+          if (!il) continue
+          if (removingHips.has(il) || removingRidges.has(il)) continue
+          if (il.lineName === 'kerabPatternRidge') continue
+          if (il.name !== LINE_TYPE.SUBLINE.HIP && il.name !== LINE_TYPE.SUBLINE.RIDGE) continue
+          if (il.visible === false) continue
+          kBarriers.push({ x1: il.x1, y1: il.y1, x2: il.x2, y2: il.y2 })
+        }
+        if (Array.isArray(extLines)) {
+          for (const seg of extLines) {
+            if (!seg) continue
+            kBarriers.push({ x1: seg.from.x, y1: seg.from.y, x2: seg.to.x, y2: seg.to.y })
+          }
+        }
+        let bestT = 1
+        let bestPt = null
+        const adx = foot.x - apex.x
+        const ady = foot.y - apex.y
+        const aSq = adx * adx + ady * ady || 1
+        for (const bl of kBarriers) {
+          const ip = lineLineIntersection(apex, foot, { x: bl.x1, y: bl.y1 }, { x: bl.x2, y: bl.y2 })
+          if (!ip) continue
+          if (!segOnLine(ip, bl.x1, bl.y1, bl.x2, bl.y2)) continue
+          const tt = (adx * (ip.x - apex.x) + ady * (ip.y - apex.y)) / aSq
+          if (tt <= 1e-3 || tt > 1 + 1e-3) continue
+          if (tt < bestT) {
+            bestT = tt
+            bestPt = ip
+          }
+        }
+        if (bestPt) foot = bestPt
+      }
+      const points = [foot.x, foot.y, apex.x, apex.y]
+      const sz = calcLinePlaneSize({ x1: points[0], y1: points[1], x2: points[2], y2: points[3] })
+      ridge = new QLine(points, {
+        parentId: roof.id,
+        fontSize: roof.fontSize,
+        stroke: '#1083E3',
+        strokeWidth: 4,
+        name: LINE_TYPE.SUBLINE.RIDGE,
+        textMode: roof.textMode,
+        attributes: { roofId: roof.id, planeSize: sz, actualSize: sz },
+      })
+    } else {
+      ridge = new QLine([apex.x, apex.y, apex.x, apex.y], {
+        parentId: roof.id,
+        fontSize: roof.fontSize,
+        stroke: 'rgba(0,0,0,0)',
+        strokeWidth: 0,
+        name: LINE_TYPE.SUBLINE.RIDGE,
+        textMode: roof.textMode,
+        visible: false,
+        selectable: false,
+        attributes: { roofId: roof.id, planeSize: 0, actualSize: 0 },
+      })
+    }
+    ridge.lineName = 'kerabPatternRidge'
+    ridge.__patternKind = 'kLineOnly'
+    ridge.__targetId = target.id
+    ridge.__noKLine = !drawKLine
+    canvas.add(ridge)
+    ridge.bringToFront()
+    roof.innerLines.push(ridge)
+
+    // [KERAB-MULTI-APEX 2026-05-22] 추가 apex 각각 별도 kLine ridge — primary 의 apex→foot 방향을 reference 로 ray cast.
+    //   c1·c2 line 에 수직 projection 으로 foot 을 잡으면 추가 apex 가 c1·c2 line 의 반대편이라 ray 방향이 뒤집힘.
+    //   primary 의 unit direction 으로 강제 → primary 와 같은 방향(roofLine 쪽) 으로 kLine 연장.
+    const auxRidges = []
+    if (drawKLine && Array.isArray(extraApexes) && extraApexes.length) {
+      // primary 의 unit direction (apex→foot, roofLine 쪽).
+      const primDx = c2.x - c1.x
+      const primDy = c2.y - c1.y
+      const primLenSq = primDx * primDx + primDy * primDy || 1
+      const primT = ((apex.x - c1.x) * primDx + (apex.y - c1.y) * primDy) / primLenSq
+      const primNaiveFoot = { x: c1.x + primT * primDx, y: c1.y + primT * primDy }
+      const refFdx = primNaiveFoot.x - apex.x
+      const refFdy = primNaiveFoot.y - apex.y
+      const refFlen = Math.hypot(refFdx, refFdy) || 1
+      const refUx = refFdx / refFlen
+      const refUy = refFdy / refFlen
+      for (const exApex of extraApexes) {
+        let foot = { x: exApex.x + refUx, y: exApex.y + refUy }
+        if (Array.isArray(roof.points) && roof.points.length >= 2) {
+          const rayEnd = { x: exApex.x + refUx, y: exApex.y + refUy }
+          let bestPt = null
+          let bestDist = Infinity
+          for (let i = 0; i < roof.points.length; i++) {
+            const a = roof.points[i]
+            const b = roof.points[(i + 1) % roof.points.length]
+            const ip = lineLineIntersection(exApex, rayEnd, a, b)
+            if (!ip) continue
+            const fwd = (ip.x - exApex.x) * refUx + (ip.y - exApex.y) * refUy
+            if (fwd <= 1e-3) continue
+            if (!isPointOnSegment(ip, { x1: a.x, y1: a.y, x2: b.x, y2: b.y })) continue
+            const dist = Math.hypot(ip.x - exApex.x, ip.y - exApex.y)
+            if (dist < bestDist) {
+              bestDist = dist
+              bestPt = ip
+            }
+          }
+          if (bestPt) foot = bestPt
+        }
+        const pts = [foot.x, foot.y, exApex.x, exApex.y]
+        const sz = calcLinePlaneSize({ x1: pts[0], y1: pts[1], x2: pts[2], y2: pts[3] })
+        const auxRidge = new QLine(pts, {
+          parentId: roof.id,
+          fontSize: roof.fontSize,
+          stroke: '#1083E3',
+          strokeWidth: 4,
+          name: LINE_TYPE.SUBLINE.RIDGE,
+          textMode: roof.textMode,
+          attributes: { roofId: roof.id, planeSize: sz, actualSize: sz },
+        })
+        auxRidge.lineName = 'kerabPatternRidge'
+        auxRidge.__patternKind = 'kLineOnly'
+        auxRidge.__targetId = target.id
+        auxRidge.__auxApex = true
+        canvas.add(auxRidge)
+        auxRidge.bringToFront()
+        roof.innerLines.push(auxRidge)
+        auxRidges.push(auxRidge)
+      }
+      ridge.__auxApexRidges = auxRidges
+    }
+
+    // [KERAB-SIMPLE-EXTHIP 2026-05-20] 확장 hip/ridge 추가 — 접점에서 newApex 까지의 연장선.
+    //   원본 hip + RG-1 제거 전에 먼저 그려두어야 시각적으로 끊김 없이 전환됨.
+    //   revert 시 ridge.__extHipsCreated 참조로 제거.
+    // [KERAB-EXTENDER-MIXED 2026-05-21] seg.isHip 으로 hip/ridge 구분 (mixed extender 케이스).
+    if (Array.isArray(extLines) && extLines.length) {
+      const created = []
+      for (const seg of extLines) {
+        if (!seg) continue
+        const pts = [seg.from.x, seg.from.y, seg.to.x, seg.to.y]
+        const sz = calcLinePlaneSize({ x1: pts[0], y1: pts[1], x2: pts[2], y2: pts[3] })
+        const segIsHip = seg.isHip !== false
+        const extLine = new QLine(pts, {
+          parentId: roof.id,
+          fontSize: roof.fontSize,
+          stroke: '#1083E3',
+          strokeWidth: 3,
+          name: segIsHip ? LINE_TYPE.SUBLINE.HIP : LINE_TYPE.SUBLINE.RIDGE,
+          textMode: roof.textMode,
+          attributes: { roofId: roof.id, planeSize: sz, actualSize: sz },
+        })
+        extLine.lineName = segIsHip ? 'kerabPatternExtHip' : 'kerabPatternExtRidge'
+        extLine.__extended = true
+        canvas.add(extLine)
+        extLine.bringToFront()
+        roof.innerLines.push(extLine)
+        created.push(extLine)
+      }
+      ridge.__extHipsCreated = created
+    }
+
+    // [KERAB-SIMPLE-HIP-REMOVE 2026-05-20] 양쪽 hip 제거 + revert 스냅샷 저장
+    // [KERAB-POLYGON-BFS 2026-05-21] 폴리곤 경로상 path hip 도 함께 들어옴. lineName/__extended
+    //   까지 스냅샷에 보존해 revert 시 SK extended flag 등 메타 정보 복원.
+    if (Array.isArray(hipsToRemove) && hipsToRemove.length) {
+      const snapshot = []
+      for (const hip of hipsToRemove) {
+        if (!hip) continue
+        snapshot.push({
+          x1: hip.x1, y1: hip.y1, x2: hip.x2, y2: hip.y2,
+          attributes: hip.attributes ? { ...hip.attributes } : null,
+          lineName: hip.lineName,
+          __extended: hip.__extended,
+        })
+        removeLine(hip)
+        roof.innerLines = roof.innerLines.filter((il) => il !== hip)
+      }
+      ridge.__removedHipsSnapshot = snapshot
+    }
+
+    // [KERAB-SIMPLE-MIDRIDGE 2026-05-20] 확장 apex 케이스에서 hip 사이를 잇던 ridge 제거 + revert 스냅샷.
+    if (Array.isArray(ridgesToRemove) && ridgesToRemove.length) {
+      const ridgeSnapshot = []
+      for (const r of ridgesToRemove) {
+        if (!r) continue
+        ridgeSnapshot.push({
+          x1: r.x1,
+          y1: r.y1,
+          x2: r.x2,
+          y2: r.y2,
+          attributes: r.attributes ? { ...r.attributes } : null,
+          lineName: r.lineName,
+        })
+        removeLine(r)
+        roof.innerLines = roof.innerLines.filter((il) => il !== r)
+      }
+      ridge.__removedRidgesSnapshot = ridgeSnapshot
+    }
+
+    hideOriginalLengthText(target.id, true)
+    removeKerabHalfLabels(target.id)
+    addKerabHalfLabels(target, { x: target.x1, y: target.y1 }, { x: target.x2, y: target.y2 })
+    // [KERAB-SIMPLE-ROOFLABEL 2026-05-20] roofLine 위에도 half 라벨 추가 (c1·c2 기준)
+    addKerabHalfLabels(target, c1, c2)
+    canvas.renderAll()
+    return true
+  }
+
   const applyKerabSingleRidgePattern = (roof, target, c1, c2, pair) => {
-    // 케라바 외곽선 중점은 roof 폴리곤 코너 c1↔c2 의 중점
-    const mid = { x: (c1.x + c2.x) / 2, y: (c1.y + c2.y) / 2 }
+    // [2240 KERAB-KLINE-ONLY 2026-05-20] 사용자 결정: 라인 삭제·생성 없이 중앙선(kLine)만 추가.
+    //   - mid(케라바 외곽선 중점) → apex 으로 ridge 1개만 add
+    //   - hip 페어/orphan ext/RG-1 등 기존 라인은 모두 그대로 보존
+    //   - revert 는 __patternKind='kLineOnly' 분기로 ridge 만 제거
+    // [2240 KERAB-MID-FROM-TARGET 2026-05-20] mid 를 c1·c2(roof corner) 가 아닌 target 외곽선 실제 끝점으로 계산.
+    //   roof.points 와 outerLine 좌표가 50 단위 drift 되어 있어도 외곽선 중점에서 정확히 출발.
+    const mid = { x: (target.x1 + target.x2) / 2, y: (target.y1 + target.y2) / 2 }
     const points = [mid.x, mid.y, pair.apex.x, pair.apex.y]
     const sz = calcLinePlaneSize({ x1: points[0], y1: points[1], x2: points[2], y2: points[3] })
     const ridge = new QLine(points, {
@@ -832,24 +2643,14 @@ export function useEavesGableEdit(id) {
       textMode: roof.textMode,
       attributes: { roofId: roof.id, planeSize: sz, actualSize: sz },
     })
-    // [KERAB-PATTERN-MARKER 2026-05-19] 할당 등 후속 흐름이 패턴 생성 라인을 식별할 수 있도록
     ridge.lineName = 'kerabPatternRidge'
-    // [2240 KERAB-HIP-SNAPSHOT 2026-05-19] 원본 hip 스냅샷 ridge 에 첨부 (revert 시 원본 그대로 복원)
-    ridge.__originalHips = [snapshotHip(pair.hA), snapshotHip(pair.hB)]
-    // 불변식: ridge 한 끝점이 케라바 중점과 일치
-    if (!ridgeMeetsMidpointOf(ridge, { x1: c1.x, y1: c1.y, x2: c2.x, y2: c2.y })) {
+    ridge.__patternKind = 'kLineOnly'
+    if (!ridgeMeetsMidpointOf(ridge, { x1: target.x1, y1: target.y1, x2: target.x2, y2: target.y2 })) {
       return false
     }
-    // 패턴이 직접 hip 페어 제거 + 짝 ext 동반 정리 (rebuild 흐름에 의존하지 않음)
-    removeOrphanExtensionsForHip(pair.hA)
-    removeOrphanExtensionsForHip(pair.hB)
-    removeLine(pair.hA)
-    removeLine(pair.hB)
-    roof.innerLines = roof.innerLines.filter((il) => il !== pair.hA && il !== pair.hB)
     canvas.add(ridge)
     ridge.bringToFront()
     roof.innerLines.push(ridge)
-    // 외곽선 라벨: 원본 1개 숨김 + 좌우/상하 절반 라벨 2개 추가
     hideOriginalLengthText(target.id, true)
     removeKerabHalfLabels(target.id)
     addKerabHalfLabels(target, c1, c2)
@@ -857,13 +2658,11 @@ export function useEavesGableEdit(id) {
     return true
   }
 
-  // [2240 KERAB-JUNCTION-EXTENDED 2026-05-19] H-4/H-2 확장 패턴 (추가만, 기존 라인 무손상).
-  //   1) H-4 확장선(junction1 → apex) hip 추가
-  //   2) H-2 확장선(junction2 → apex) hip 추가
-  //   3) mid(B-5) → apex ridge 추가
-  //   기존 outer(H-7/H-1)·inner(H-4/H-2)·RG-2 모두 그대로 유지. revert 시 추가된 3개만 제거.
+  // [2240 KERAB-KLINE-ONLY 2026-05-20] junction-extended 도 동일: 중앙선만 그리고 기존 라인 무손상.
+  //   mid → jp.apex ridge 1개만 add. ext hip 생성·RG-1 제거·outer hip 제거 전부 skip.
   const applyKerabJunctionExtendedPattern = (roof, target, c1, c2, jp) => {
-    const mid = { x: (c1.x + c2.x) / 2, y: (c1.y + c2.y) / 2 }
+    // [2240 KERAB-MID-FROM-TARGET 2026-05-20] mid = target 외곽선 실제 중점 (roof corner drift 제거).
+    const mid = { x: (target.x1 + target.x2) / 2, y: (target.y1 + target.y2) / 2 }
     const ridgePoints = [mid.x, mid.y, jp.apex.x, jp.apex.y]
     const ridgeSz = calcLinePlaneSize({ x1: ridgePoints[0], y1: ridgePoints[1], x2: ridgePoints[2], y2: ridgePoints[3] })
     const ridge = new QLine(ridgePoints, {
@@ -876,76 +2675,12 @@ export function useEavesGableEdit(id) {
       attributes: { roofId: roof.id, planeSize: ridgeSz, actualSize: ridgeSz },
     })
     ridge.lineName = 'kerabPatternRidge'
-    ridge.__patternKind = 'junctionExtended'
-    if (!ridgeMeetsMidpointOf(ridge, { x1: c1.x, y1: c1.y, x2: c2.x, y2: c2.y })) return false
+    ridge.__patternKind = 'kLineOnly'
+    if (!ridgeMeetsMidpointOf(ridge, { x1: target.x1, y1: target.y1, x2: target.x2, y2: target.y2 })) return false
 
-    const buildExtensionHip = (from, to) => {
-      const pts = [from.x, from.y, to.x, to.y]
-      const sz = calcLinePlaneSize({ x1: pts[0], y1: pts[1], x2: pts[2], y2: pts[3] })
-      const hip = new QLine(pts, {
-        parentId: roof.id,
-        fontSize: roof.fontSize,
-        stroke: '#1083E3',
-        strokeWidth: 4,
-        name: LINE_TYPE.SUBLINE.HIP,
-        textMode: roof.textMode,
-        attributes: { roofId: roof.id, planeSize: sz, actualSize: sz },
-      })
-      hip.lineName = 'kerabPatternHip'
-      hip.__patternKind = 'junctionExtended'
-      return hip
-    }
-    const ext1 = buildExtensionHip(jp.junction1, jp.apex)
-    const ext2 = buildExtensionHip(jp.junction2, jp.apex)
-    ridge.__patternExtHips = [ext1, ext2]
-
-    // [2240 KERAB-CENTRAL-RIDGE 2026-05-19] RG-1(주 마루) 제거.
-    //   양 끝점이 ext1·ext2 segment 위에 각각 놓인 ridge 가 RG-1.
-    //   (H-4/H-2 확장선이 RG-1 끝점을 통과 → RG-2 등 다른 ridge 는 두 확장선과 무관)
-    const ridgesToRemove = roof.innerLines.filter(
-      (il) =>
-        il &&
-        il.name === LINE_TYPE.SUBLINE.RIDGE &&
-        il.lineName !== 'kerabPatternRidge' &&
-        il !== ridge &&
-        ridgeEndpointsOnBothExtensions(il, ext1, ext2),
-    )
-    logger.log('[KERAB-CENTRAL-RIDGE] lookup', {
-      ext1: `(${Math.round(ext1.x1)},${Math.round(ext1.y1)})→(${Math.round(ext1.x2)},${Math.round(ext1.y2)})`,
-      ext2: `(${Math.round(ext2.x1)},${Math.round(ext2.y1)})→(${Math.round(ext2.x2)},${Math.round(ext2.y2)})`,
-      removeCount: ridgesToRemove.length,
-      removeList: ridgesToRemove.map(
-        (il) => `(${Math.round(il.x1)},${Math.round(il.y1)})→(${Math.round(il.x2)},${Math.round(il.y2)})`,
-      ),
-    })
-    if (ridgesToRemove.length > 0) {
-      ridge.__removedRidgesSnapshot = ridgesToRemove.map(snapshotHip)
-      for (const il of ridgesToRemove) removeLine(il)
-      roof.innerLines = roof.innerLines.filter((il) => !ridgesToRemove.includes(il))
-    }
-
-    // [2240 KERAB-HIP-REMOVE 2026-05-19] 대전제: 케라바 외곽선 양 끝점(c1·c2) 에 붙은 hip 만 제거.
-    //   outer1 (c1↔junction1), outer2 (c2↔junction2) — 사용자 선택 처마 양 끝점에서 만나는 hip
-    //   inner (junction 너머) 는 보존. orphan extension 동반 정리, 스냅샷 첨부.
-    const hipsToRemove = [jp.outer1, jp.outer2]
-    ridge.__removedHipsSnapshot = hipsToRemove.map(snapshotHip)
-    for (const hip of hipsToRemove) {
-      removeOrphanExtensionsForHip(hip)
-      removeLine(hip)
-    }
-    roof.innerLines = roof.innerLines.filter((il) => !hipsToRemove.includes(il))
-    logger.log('[KERAB-HIP-REMOVE] outer only', {
-      outer1: `(${Math.round(jp.outer1.x1)},${Math.round(jp.outer1.y1)})→(${Math.round(jp.outer1.x2)},${Math.round(jp.outer1.y2)})`,
-      outer2: `(${Math.round(jp.outer2.x1)},${Math.round(jp.outer2.y1)})→(${Math.round(jp.outer2.x2)},${Math.round(jp.outer2.y2)})`,
-    })
-
-    canvas.add(ext1)
-    canvas.add(ext2)
     canvas.add(ridge)
-    ext1.bringToFront()
-    ext2.bringToFront()
     ridge.bringToFront()
-    roof.innerLines.push(ext1, ext2, ridge)
+    roof.innerLines.push(ridge)
 
     hideOriginalLengthText(target.id, true)
     removeKerabHalfLabels(target.id)
@@ -954,8 +2689,42 @@ export function useEavesGableEdit(id) {
     return true
   }
 
-  // [2240 KERAB-ATTR-ONLY 2026-05-19] 평행 hip 케이스: 외곽선 attributes.type 만 토글.
-  //   - hip 라인/ridge/라벨 등 SK 산출물 전부 무변경
+  // [2240 KERAB-KLINE-ONLY 2026-05-20] 양 끝 hip 평행 케이스: apex 가 없어 중앙선조차 그릴 수 없음.
+  //   "라인 삭제 금지 + 중앙선만 그리기" 정책상 hip 제거도 skip → attr-only 와 동일하게 동작.
+  const applyKerabParallelHipsPattern = () => {
+    canvas.renderAll()
+    return true
+  }
+
+  // [2240 KERAB-PARALLEL-HIPS 2026-05-19] revert: target.__kerabParallelHipsSnapshot 기반으로 hip 2개 복원.
+  const revertKerabParallelHipsPattern = (roof, target) => {
+    const snaps = Array.isArray(target.__kerabParallelHipsSnapshot) ? target.__kerabParallelHipsSnapshot : []
+    snaps.forEach((snap) => {
+      if (!snap) return
+      const pts = [snap.x1, snap.y1, snap.x2, snap.y2]
+      const sz = calcLinePlaneSize({ x1: pts[0], y1: pts[1], x2: pts[2], y2: pts[3] })
+      const hip = new QLine(pts, {
+        parentId: roof.id,
+        fontSize: roof.fontSize,
+        stroke: '#1083E3',
+        strokeWidth: 4,
+        name: LINE_TYPE.SUBLINE.HIP,
+        textMode: roof.textMode,
+        attributes: { roofId: roof.id, planeSize: sz, actualSize: sz, ...snap.attributes },
+      })
+      if (snap.lineName) hip.lineName = snap.lineName
+      if (snap.__extended) hip.__extended = snap.__extended
+      canvas.add(hip)
+      hip.bringToFront()
+      roof.innerLines.push(hip)
+    })
+    delete target.__kerabParallelHipsSnapshot
+    canvas.renderAll()
+    return true
+  }
+
+  // [2240 KERAB-ATTR-ONLY 2026-05-19] fallback: hip 페어가 1·2·3·평행 어디에도 해당 안 될 때 (hip 0/1 개, apex 가 중앙 아님 등).
+  //   - 외곽선 attributes.type 만 토글, hip 라인/ridge/라벨 등 SK 산출물 전부 무변경
   //   - 호출자가 이미 target.set({ attributes }) 적용한 상태로 들어옴 → 렌더만 갱신
   //   - forward/revert 양방향 동일 처리 (대칭)
   const applyKerabAttributeOnlyPattern = () => {
diff --git a/src/hooks/useEvent.js b/src/hooks/useEvent.js
index 5a5dfac2..9bc4e434 100644
--- a/src/hooks/useEvent.js
+++ b/src/hooks/useEvent.js
@@ -385,10 +385,13 @@ export function useEvent() {
     const lineBottom = visibleBottom + padding
 
     // 가로선 (수평선)
+    // [2240 MOUSELINE-EVENTED-FALSE 2026-05-20] selectable:false 만으로는 e.target 가로채기 차단 불가 — outerLine 클릭이
+    // 십자선에 잡히는 회귀 차단. mouseLine 은 시각 표시만, 좌표 계산은 filter(name==='mouseLine') 로 접근.
     const horizontalLine = new fabric.Line([lineLeft, pointer.y, lineRight, pointer.y], {
       stroke: 'red',
       strokeWidth: 1,
       selectable: false,
+      evented: false,
       direction: 'horizontal',
       name: 'mouseLine',
     })
@@ -398,6 +401,7 @@ export function useEvent() {
       stroke: 'red',
       strokeWidth: 1,
       selectable: false,
+      evented: false,
       direction: 'vertical',
       name: 'mouseLine',
     })
diff --git a/src/hooks/useMode.js b/src/hooks/useMode.js
index af134ece..df61fbe1 100644
--- a/src/hooks/useMode.js
+++ b/src/hooks/useMode.js
@@ -284,10 +284,13 @@ export function useMode() {
     }
 
     // 가로선을 그립니다.
+    // [2240 MOUSELINE-EVENTED-FALSE 2026-05-20] selectable:false 만으로는 e.target 가로채기 차단 불가 — 클릭이
+    // 십자선에 잡히는 회귀 차단. mouseLine 은 시각 표시만, 좌표 계산은 filter(name==='mouseLine') 로 접근.
     const horizontalLine = new fabric.Line([0, newY, 2 * canvas.width, newY], {
       stroke: 'red',
       strokeWidth: 1,
       selectable: false,
+      evented: false,
       name: 'mouseLine',
     })
 
@@ -296,6 +299,7 @@ export function useMode() {
       stroke: 'red',
       strokeWidth: 1,
       selectable: false,
+      evented: false,
       name: 'mouseLine',
     })
 
diff --git a/src/util/kerab-offset-surgical.js b/src/util/kerab-offset-surgical.js
new file mode 100644
index 00000000..480e11be
--- /dev/null
+++ b/src/util/kerab-offset-surgical.js
@@ -0,0 +1,157 @@
+// [2240 KERAB-OFFSET-SURGICAL 2026-05-27] 케라바 forward/revert 시 出幅(offset) 변경분만
+//   target 의 matchingRoofLine + 인접 2 corner roof.points + corner 에 닿은 inner line 끝점
+//   + lengthText 라벨을 surgical 갱신. SK 재실행 없이 다른 벽의 케라바 패턴 보존.
+//
+//   고객 회귀 검증을 위해 본 로직 전체를 useEavesGableEdit.js 에서 분리.
+//   호출 ON/OFF 는 useEavesGableEdit.js 상단 `ENABLE_KERAB_OFFSET_SURGICAL` 상수로 토글한다.
+
+import { POLYGON_TYPE } from '@/common/common'
+import { calcLinePlaneSize } from '@/util/qpolygon-utils'
+import { logger } from '@/util/logger'
+
+const lineLineIntersection = (p1, p2, p3, p4) => {
+  const d = (p1.x - p2.x) * (p3.y - p4.y) - (p1.y - p2.y) * (p3.x - p4.x)
+  if (Math.abs(d) < 1e-6) return null
+  const t = ((p1.x - p3.x) * (p3.y - p4.y) - (p1.y - p3.y) * (p3.x - p4.x)) / d
+  return { x: p1.x + t * (p2.x - p1.x), y: p1.y + t * (p2.y - p1.y) }
+}
+
+/**
+ * @param canvas    fabric canvas
+ * @param target    outerLine fabric 객체 (target.attributes 는 OLD 상태로 호출되어야 함)
+ * @param newOffset 새 출폭 (canvas 단위)
+ * @returns true=적용됨 / false=조건 미달 또는 변경 없음
+ */
+export const applyKerabOffsetSurgical = (canvas, target, newOffset) => {
+  const roof = canvas
+    .getObjects()
+    .find((o) => o.name === POLYGON_TYPE.ROOF && !o.isFixed && o.id === target.attributes?.roofId)
+  if (!roof || !Array.isArray(roof.lines) || !Array.isArray(roof.points)) return false
+  const idx = roof.lines.findIndex((rl) => rl && rl.attributes?.wallLine === target.id)
+  if (idx < 0) return false
+  const matchingRL = roof.lines[idx]
+  const oldOffset = matchingRL.attributes?.offset ?? 0
+  if (Math.abs(newOffset - oldOffset) < 1e-3) return false
+
+  const N = roof.lines.length
+  const prevRL = roof.lines[(idx - 1 + N) % N]
+  const nextRL = roof.lines[(idx + 1) % N]
+
+  // target wall edge 의 outward unit normal — matchingRL 현재 위치로 sign 추정 (oldOffset=0 시 centroid 폴백).
+  const tdx = target.x2 - target.x1
+  const tdy = target.y2 - target.y1
+  const tL = Math.hypot(tdx, tdy) || 1
+  let nx = -tdy / tL
+  let ny = tdx / tL
+  const tMid = { x: (target.x1 + target.x2) / 2, y: (target.y1 + target.y2) / 2 }
+  if (Math.abs(oldOffset) > 1e-6) {
+    const mMid = { x: (matchingRL.x1 + matchingRL.x2) / 2, y: (matchingRL.y1 + matchingRL.y2) / 2 }
+    if ((mMid.x - tMid.x) * nx + (mMid.y - tMid.y) * ny < 0) {
+      nx = -nx
+      ny = -ny
+    }
+  } else {
+    let cx = 0
+    let cy = 0
+    for (const p of roof.points) {
+      cx += p.x
+      cy += p.y
+    }
+    cx /= roof.points.length
+    cy /= roof.points.length
+    if ((tMid.x - cx) * nx + (tMid.y - cy) * ny < 0) {
+      nx = -nx
+      ny = -ny
+    }
+  }
+
+  // 새 matchingRL axis 와 prev/nextRL 무한확장 교점.
+  const newAxisP1 = { x: target.x1 + nx * newOffset, y: target.y1 + ny * newOffset }
+  const newAxisP2 = { x: target.x2 + nx * newOffset, y: target.y2 + ny * newOffset }
+  const newCorner1 = lineLineIntersection(
+    { x: prevRL.x1, y: prevRL.y1 },
+    { x: prevRL.x2, y: prevRL.y2 },
+    newAxisP1,
+    newAxisP2,
+  )
+  const newCorner2 = lineLineIntersection(
+    newAxisP1,
+    newAxisP2,
+    { x: nextRL.x1, y: nextRL.y1 },
+    { x: nextRL.x2, y: nextRL.y2 },
+  )
+  if (!newCorner1 || !newCorner2) {
+    logger.log('[KERAB-OFFSET-SURGICAL] intersect failed — skip surgical update')
+    return false
+  }
+
+  const oldCorner1 = { x: roof.points[idx].x, y: roof.points[idx].y }
+  const oldCorner2 = { x: roof.points[(idx + 1) % N].x, y: roof.points[(idx + 1) % N].y }
+
+  matchingRL.set({ x1: newCorner1.x, y1: newCorner1.y, x2: newCorner2.x, y2: newCorner2.y })
+  prevRL.set({ x2: newCorner1.x, y2: newCorner1.y })
+  nextRL.set({ x1: newCorner2.x, y1: newCorner2.y })
+
+  const newSize = calcLinePlaneSize({ x1: newCorner1.x, y1: newCorner1.y, x2: newCorner2.x, y2: newCorner2.y })
+  matchingRL.attributes = {
+    ...matchingRL.attributes,
+    offset: newOffset,
+    planeSize: newSize,
+    actualSize: newSize,
+  }
+  const prevSize = calcLinePlaneSize({ x1: prevRL.x1, y1: prevRL.y1, x2: prevRL.x2, y2: prevRL.y2 })
+  prevRL.attributes = { ...prevRL.attributes, planeSize: prevSize, actualSize: prevSize }
+  const nextSize = calcLinePlaneSize({ x1: nextRL.x1, y1: nextRL.y1, x2: nextRL.x2, y2: nextRL.y2 })
+  nextRL.attributes = { ...nextRL.attributes, planeSize: nextSize, actualSize: nextSize }
+
+  // 옛 corner 좌표에 닿아있던 inner line(hip/ridge/valley/케라바 ext) 끝점을 새 corner 로 snap.
+  const CORNER_SNAP_TOL = 0.5
+  for (const il of roof.innerLines || []) {
+    if (!il) continue
+    if (Math.hypot(il.x1 - oldCorner1.x, il.y1 - oldCorner1.y) <= CORNER_SNAP_TOL) {
+      il.set({ x1: newCorner1.x, y1: newCorner1.y })
+    }
+    if (Math.hypot(il.x2 - oldCorner1.x, il.y2 - oldCorner1.y) <= CORNER_SNAP_TOL) {
+      il.set({ x2: newCorner1.x, y2: newCorner1.y })
+    }
+    if (Math.hypot(il.x1 - oldCorner2.x, il.y1 - oldCorner2.y) <= CORNER_SNAP_TOL) {
+      il.set({ x1: newCorner2.x, y1: newCorner2.y })
+    }
+    if (Math.hypot(il.x2 - oldCorner2.x, il.y2 - oldCorner2.y) <= CORNER_SNAP_TOL) {
+      il.set({ x2: newCorner2.x, y2: newCorner2.y })
+    }
+  }
+
+  // points 는 새 배열로 set 해야 fabric 의 dirty 감지가 동작.
+  const newPoints = roof.points.map((p, i) => {
+    if (i === idx) return { x: newCorner1.x, y: newCorner1.y }
+    if (i === (idx + 1) % N) return { x: newCorner2.x, y: newCorner2.y }
+    return { x: p.x, y: p.y }
+  })
+  roof.points = newPoints
+  roof.set({ points: newPoints, dirty: true })
+  if (typeof roof.setCoords === 'function') roof.setCoords()
+
+  // canvas 에 add 된 동일 wallLine 매칭의 eaves(외곽 roofLine) fabric 객체도 같이 갱신.
+  const canvasEdgeObjs = canvas
+    .getObjects()
+    .filter(
+      (o) =>
+        o.parentId === roof.id &&
+        (o.name === 'eaves' || o.lineName === 'roofLine' || o.name === 'outerLine') &&
+        o.attributes?.wallLine === target.id,
+    )
+  for (const eo of canvasEdgeObjs) {
+    eo.set({ x1: newCorner1.x, y1: newCorner1.y, x2: newCorner2.x, y2: newCorner2.y, dirty: true })
+    eo.attributes = { ...eo.attributes, offset: newOffset, planeSize: newSize, actualSize: newSize }
+    if (typeof eo.setCoords === 'function') eo.setCoords()
+  }
+  if (typeof roof.addLengthText === 'function') roof.addLengthText()
+
+  canvas.renderAll()
+  logger.log(
+    '[KERAB-OFFSET-SURGICAL] applied ' +
+      JSON.stringify({ idx, oldOffset, newOffset, oldCorner1, newCorner1, oldCorner2, newCorner2 }),
+  )
+  return true
+}
diff --git a/src/util/skeleton-utils.js b/src/util/skeleton-utils.js
index fd63b2af..eb0a0306 100644
--- a/src/util/skeleton-utils.js
+++ b/src/util/skeleton-utils.js
@@ -5155,7 +5155,7 @@ function getTurnDirection(p1, p2, p3) {
 /**
  * 현재 점(point)을 기준으로 연결된 이전 라인과 다음 라인을 찾아 골짜기 여부 판단
  */
-function isValleyVertex(targetPoint, connectedLine, allLines, isStartVertex) {
+export function isValleyVertex(targetPoint, connectedLine, allLines, isStartVertex) {
   const tolerance = 0.1;
 
   const connectedLineData = {
@@ -5250,7 +5250,7 @@ function isValleyVertex(targetPoint, connectedLine, allLines, isStartVertex) {
   return crossProduct > 0;
 }
 
-function findInteriorPoint(line, polygonLines) {
+export function findInteriorPoint(line, polygonLines) {
   const x1 = line.x1 ?? line.get?.('x1');
   const y1 = line.y1 ?? line.get?.('y1');
   const x2 = line.x2 ?? line.get?.('x2');