import { useEffect, useRef, useState } from 'react'
import { useRecoilValue } from 'recoil'
import { ANGLE_TYPE, canvasState, currentAngleTypeSelector, pitchTextSelector } from '@/store/canvasAtom'
import { useMessage } from '@/hooks/useMessage'
import { useEvent } from '@/hooks/useEvent'
import { LINE_TYPE, POLYGON_TYPE } from '@/common/common'
import { useLine } from '@/hooks/useLine'
import { useMode } from '@/hooks/useMode'
import { outerLineFixState } from '@/store/outerLineAtom'
import { useSwal } from '@/hooks/useSwal'
import { usePopup } from '@/hooks/usePopup'
import { getChonByDegree } from '@/util/canvas-util'
import { settingModalFirstOptionsState } from '@/store/settingAtom'
import { fabric } from 'fabric'
import { QLine } from '@/components/fabric/QLine'
import { reattachDebugLabels } from '@/components/fabric/QPolygon'
import { calcLinePlaneSize } from '@/util/qpolygon-utils'
import { findInteriorPoint } from '@/util/skeleton-utils'
import { logger } from '@/util/logger'
import { debugCapture } from '@/util/debugCapture'
import { applyKerabOffsetSurgical } from '@/util/kerab-offset-surgical'

// [2240 KERAB-OFFSET-SURGICAL 2026-05-27] 케라바 토글 시 出幅 변경분 surgical 반영 기능 토글.
// false 로 두면 이번 세션 변경 전 동작 (apply/revert 시 출폭 입력값 무시) 으로 즉시 회귀.
const ENABLE_KERAB_OFFSET_SURGICAL = true

// [KERAB-TYPE-EAVES 2026-06-11] TYPE(A/B 박공) 출신 케라바→처마 전용 변환 토글.
// false 면 기존 applyKerabRevertPattern 폴백(토글 이력 기반) 으로 회귀.
const ENABLE_TYPE_GABLE_TO_EAVES = true

// 처마.케라바 변경
export function useEavesGableEdit(id) {
  const canvas = useRecoilValue(canvasState)
  const { getMessage } = useMessage()
  const { addCanvasMouseEventListener, initEvent } = useEvent()
  // const { addCanvasMouseEventListener, initEvent } = useContext(EventContext)
  const { closePopup } = usePopup()
  const TYPES = {
    EAVES: 'eaves',
    GABLE: 'gable',
    WALL_MERGE: 'wall.merge',
    SHED: 'shed',
  }
  const [type, setType] = useState(TYPES.EAVES)
  const typeRef = useRef(TYPES.EAVES)
  const { removeLine, addPitchTextsByOuterLines } = useLine()
  const { swalFire } = useSwal()

  const { drawRoofPolygon } = useMode()
  const currentAngleType = useRecoilValue(currentAngleTypeSelector)
  const pitchText = useRecoilValue(pitchTextSelector)

  const pitchRef = useRef(null)
  const offsetRef = useRef(null)
  const widthRef = useRef(null)
  const radioTypeRef = useRef('1') // 각 페이지에서 사용하는 radio type
  const outerLineFix = useRecoilValue(outerLineFixState)

  const buttonMenu = [
    { id: 1, name: getMessage('eaves'), type: TYPES.EAVES },
    { id: 2, name: getMessage('gable'), type: TYPES.GABLE },
    { id: 3, name: getMessage('wall.merge'), type: TYPES.WALL_MERGE },
    { id: 4, name: getMessage('shed'), type: TYPES.SHED },
  ]

  const settingModalFirstOptions = useRecoilValue(settingModalFirstOptionsState)

  useEffect(() => {
    const outerLines = canvas.getObjects().filter((obj) => obj.name === 'outerLine')
    if (outerLines.length === 0) {
      swalFire({ text: getMessage('wall.line.not.found') })
      closePopup(id)
    }
  }, [])

  useEffect(() => {
    const wallLines = canvas.getObjects().filter((obj) => obj.name === POLYGON_TYPE.WALL)
    const outerLines = canvas.getObjects().filter((obj) => obj.name === 'outerLine')
    wallLines.forEach((wallLine) => {
      wallLine.lines = outerLines.filter((line) => line.attributes?.wallId === wallLine.id).sort((a, b) => a.idx - b.idx)
    })
    wallLines.forEach((wallLine) => {
      convertPolygonToLines(wallLine)
    })

    addCanvasMouseEventListener('mouse:over', mouseOverEvent)
    addCanvasMouseEventListener('mouse:down', mouseDownEvent)

    return () => {
      canvas.discardActiveObject()
      wallLines.forEach((wallLine) => {
        convertLinesToPolygon(wallLine)
      })
      initEvent()

      const outerLines = canvas.getObjects().filter((obj) => obj.name === 'outerLine')

      outerLines.forEach((line) => {
        let stroke, strokeWidth
        if (line.attributes) {
          if (line.attributes.type === LINE_TYPE.WALLLINE.EAVES || line.attributes.type === LINE_TYPE.WALLLINE.HIPANDGABLE) {
            stroke = '#45CD7D'
            strokeWidth = 4
          } else if (line.attributes.type === LINE_TYPE.WALLLINE.GABLE || line.attributes.type === LINE_TYPE.WALLLINE.JERKINHEAD) {
            stroke = '#3FBAE6'
            strokeWidth = 4
          } else {
            stroke = '#000000'
            strokeWidth = 4
          }

          line.set({
            visible: true,
            stroke,
            strokeWidth,
            selectable: false,
          })

          line.bringToFront()
        }
      })
      const roofs = canvas.getObjects().filter((obj) => obj.name === POLYGON_TYPE.ROOF)
      roofs.forEach((roof) => {
        roof.innerLines.forEach((line) => {
          line.set({ selectable: true })
          line.bringToFront()
        })
      })
      canvas.renderAll()
    }
  }, [])

  useEffect(() => {
    typeRef.current = type
    radioTypeRef.current = '1'
  }, [type])

  const mouseOverEvent = (e) => {
    if (e.target && e.target.name === 'outerLine') {
      e.target.set({
        stroke: 'red',
      })
      e.target.bringToFront()
      canvas.renderAll()
    } else {
      canvas
        ?.getObjects()
        .filter((obj) => obj.name === 'outerLine')
        .forEach((line) => {
          line.set({
            stroke: 'black',
          })
          line.bringToFront()
        })
    }
    canvas.renderAll()
  }

  // [KERAB-RULE-CHECK 2026-06-10] 케라바(처마↔게이블) 토글 종료 시 결과가 도메인 규칙에
  //   맞는지 자동 판정하는 진단 단계. forward/revert 양쪽 끝에서 호출. 로컬 전용 — 위반은
  //   logger.warn 로 위반 라인만 덤프(production 은 DCE 로 제거).
  //   규칙:
  //     R1 dangling: 모든 visible hip/ridge 끝점은 roofLine 코너에 닿거나 다른 inner line 과
  //                  공유돼야 한다(떠 있는 끝점=벽 교점/코너 이탈). 골짜기 내부 hip 은 양 끝이
  //                  다른 라인과 공유되므로 자동 통과(예외 불필요).
  //     R2 zero-length: 길이 0 으로 붕괴된 visible 라인(=라인 소실) 금지.
  //     R3 outside: 끝점이 roofLine 폴리곤 밖(경계 tol 초과)으로 이탈 금지.
  //     R4 anchor: 토글 전후로 움직이지 않은 roofLine 코너(stable corner)의 끝점 점유수 불변
  //                (코너에서 hip 이 떨어지거나 엉뚱한 코너로 횡단하면 점유수 변화).
  // [KERAB-OFFSET-HELPER 2026-06-15] 출폭함수 빌딩블록 (1/2): 케라바 hip(확장라인) 식별.
  //   reclick 검증 코드에서 무손실 추출. surgical 적용 *전*(옛 폴리곤) 에 호출해야 한다 —
  //   outer endpoint = 옛 roof.points 변 위 끝점, side = hip 직선이 지나는 wall 코너(A/B).
  const detectKerabHipMarks = (target, roof) => {
    const marks = []
    if (!roof || !Array.isArray(roof.innerLines) || !Array.isArray(roof.points)) return marks
    const wA = { x: target.x1, y: target.y1 }
    const wB = { x: target.x2, y: target.y2 }
    const pts = roof.points
    const isOnOldPolyEdge = (P) => {
      for (let i = 0; i < pts.length; i++) {
        const A = pts[i]
        const B = pts[(i + 1) % pts.length]
        const ddx = B.x - A.x
        const ddy = B.y - A.y
        const lenSq = ddx * ddx + ddy * ddy
        if (lenSq < 1e-6) continue
        const t = ((P.x - A.x) * ddx + (P.y - A.y) * ddy) / lenSq
        if (t < -0.02 || t > 1.02) continue
        const projX = A.x + t * ddx
        const projY = A.y + t * ddy
        const d = Math.hypot(P.x - projX, P.y - projY)
        if (d < 2.0) return true
      }
      return false
    }
    for (const il of roof.innerLines) {
      if (!il || (il.lineName !== 'hip' && il.lineName !== 'kerabPatternHip')) continue
      const e1 = { x: il.x1, y: il.y1 }
      const e2 = { x: il.x2, y: il.y2 }
      const e1OnEdge = isOnOldPolyEdge(e1)
      const e2OnEdge = isOnOldPolyEdge(e2)
      let which = null
      if (e1OnEdge && !e2OnEdge) which = 1
      else if (e2OnEdge && !e1OnEdge) which = 2
      if (which === null) continue
      const outerEnd = which === 1 ? e1 : e2
      const innerEnd = which === 1 ? e2 : e1
      const ddx = outerEnd.x - innerEnd.x
      const ddy = outerEnd.y - innerEnd.y
      const llen = Math.hypot(ddx, ddy) || 1
      const distPerp = (P) => Math.abs((ddx * (innerEnd.y - P.y) - ddy * (innerEnd.x - P.x)) / llen)
      const dA = distPerp(wA)
      const dB = distPerp(wB)
      if (Math.min(dA, dB) > 5.0) continue
      const side = dA <= dB ? 'A' : 'B'
      marks.push({ il, which, side })
    }
    logger.log(
      '[KERAB-OFFSET-ONLY-RECLICK-EAVES] hip marks ' +
        JSON.stringify(marks.map((m) => ({ which: m.which, side: m.side, lineName: m.il.lineName }))),
    )
    return marks
  }
  // [KERAB-OFFSET-HELPER 2026-06-15] 출폭함수 빌딩블록 (2/2): 케라바 hip 을 45° ray-cast 확장.
  //   surgical 적용 *후*(새 폴리곤) 에 호출. wall 코너에서 옛 hip 방향(45°)으로 새 roofLine 변까지.
  //   CORNER-SNAP 금지 룰의 실제 구현부 — roofLine 코너가 아니라 교점까지 뻗는다.
  //   [45-UNIFY 2026-06-15] reclick·revert 두 경로의 45° 구현을 한 벌로 통합. 가드는 opt-in:
  //   - useRevertGuards=false(reclick): 순수 45° ray-cast (기존 reclick 동작 그대로).
  //   - useRevertGuards=true(revert): outerShared(골짜기 내부 hip 제외) + outerOnVertex(게이블 코너
  //     hip 은 같은 인덱스 새 꼭짓점으로 직접 스냅) 가드 적용. oldPolyPoints = 이동 전 폴리곤 꼭짓점.
  const extendKerabHipsTo45 = (target, roof, hipMarks, options = {}) => {
    if (!roof || !Array.isArray(roof.points) || !hipMarks || !hipMarks.length) return
    const { useRevertGuards = false, oldPolyPoints = null } = options
    const wA = { x: target.x1, y: target.y1 }
    const wB = { x: target.x2, y: target.y2 }
    const rps = roof.points
    const M = rps.length
    if (!M) return
    const baseTag = useRevertGuards ? '[KERAB-REVERT-EXTEND-45]' : '[KERAB-OFFSET-ONLY-RECLICK-EAVES]'
    const okTag = useRevertGuards ? '[KERAB-REVERT-EXTEND-45] ' : '[KERAB-OFFSET-ONLY-RECLICK-EAVES] extended '
    const rayHit = (P, dir, A, B) => {
      const sx = B.x - A.x
      const sy = B.y - A.y
      const denom = dir.x * sy - dir.y * sx
      if (Math.abs(denom) < 1e-9) return Infinity
      const ax = A.x - P.x
      const ay = A.y - P.y
      const t = (ax * sy - ay * sx) / denom
      const s = (ax * dir.y - ay * dir.x) / denom
      if (t > 1e-6 && s >= -1e-6 && s <= 1 + 1e-6) return t
      return Infinity
    }
    const cast45 = (wCorner, innerEnd, outerOld, il, which, side) => {
      const dx = outerOld.x - innerEnd.x
      const dy = outerOld.y - innerEnd.y
      const dlen = Math.hypot(dx, dy)
      if (dlen < 1e-6) return null
      const ux = dx / dlen
      const uy = dy / dlen
      let bestT = Infinity
      for (let k = 0; k < M; k++) {
        const A = rps[k]
        const B = rps[(k + 1) % M]
        const t = rayHit(wCorner, { x: ux, y: uy }, A, B)
        if (t < bestT) bestT = t
      }
      if (!isFinite(bestT) || bestT < 0.5) {
        logger.log(baseTag + ' no-hit ' + JSON.stringify({ lineName: il.lineName, which, side, wCorner, dir: { ux, uy } }))
        return null
      }
      return { x: wCorner.x + ux * bestT, y: wCorner.y + uy * bestT }
    }
    for (const mark of hipMarks) {
      const { il, which, side } = mark
      const wCorner = side === 'A' ? wA : wB
      const innerEnd = which === 1 ? { x: il.x2, y: il.y2 } : { x: il.x1, y: il.y1 }
      const outerOld = which === 1 ? { x: il.x1, y: il.y1 } : { x: il.x2, y: il.y2 }
      let hit
      if (useRevertGuards) {
        // outerShared: outer 끝이 다른 내부선과 공유 → 골짜기 내부 hip → 확장 스킵.
        const SHARE_TOL = 2.0
        const outerShared = (roof.innerLines || []).some(
          (o) =>
            o &&
            o !== il &&
            o.visible !== false &&
            (Math.hypot(o.x1 - outerOld.x, o.y1 - outerOld.y) < SHARE_TOL ||
              Math.hypot(o.x2 - outerOld.x, o.y2 - outerOld.y) < SHARE_TOL),
        )
        // outerOnVertex: outer 가 (이동 전) 폴리곤 꼭짓점이면 게이블 코너 hip → 같은 인덱스 새 꼭짓점 스냅.
        const VERT_TOL = 2.0
        const opp = Array.isArray(oldPolyPoints) ? oldPolyPoints : []
        let vtxIdx = -1
        for (let vi = 0; vi < opp.length; vi++) {
          const p = opp[vi]
          if (p && Math.hypot(p.x - outerOld.x, p.y - outerOld.y) < VERT_TOL) {
            vtxIdx = vi
            break
          }
        }
        const outerOnVertex = vtxIdx >= 0
        if (outerShared && !outerOnVertex) {
          logger.log(baseTag + ' skip (interior hip — outer shared) ' + JSON.stringify({ lineName: il.lineName, which, side, outerOld }))
          continue
        }
        if (outerOnVertex && rps.length === opp.length && rps[vtxIdx]) {
          hit = { x: rps[vtxIdx].x, y: rps[vtxIdx].y }
        } else {
          hit = cast45(wCorner, innerEnd, outerOld, il, which, side)
          if (!hit) continue
        }
      } else {
        hit = cast45(wCorner, innerEnd, outerOld, il, which, side)
        if (!hit) continue
      }
      const oldLen = Math.hypot(outerOld.x - innerEnd.x, outerOld.y - innerEnd.y)
      const newLen = Math.hypot(hit.x - innerEnd.x, hit.y - innerEnd.y)
      const ratio = oldLen > 0 ? newLen / oldLen : 1
      if (which === 1) il.set({ x1: hit.x, y1: hit.y })
      else il.set({ x2: hit.x, y2: hit.y })
      if (il.attributes) {
        const oldPlane = il.attributes.planeSize ?? 0
        const oldActual = il.attributes.actualSize ?? 0
        il.attributes.planeSize = Math.round(oldPlane * ratio * 100) / 100
        il.attributes.actualSize = Math.round(oldActual * ratio * 100) / 100
        il.attributes.extended = true
      }
      il.__extended = true
      if (typeof il.setCoords === 'function') il.setCoords()
      if (typeof il.setLength === 'function') il.setLength()
      if (typeof il.addLengthText === 'function') il.addLengthText()
      logger.log(
        okTag +
          JSON.stringify({
            lineName: il.lineName,
            which,
            side,
            hit,
            ratio: Number(ratio.toFixed(3)),
            x1: il.x1,
            y1: il.y1,
            x2: il.x2,
            y2: il.y2,
          }),
      )
    }
  }
  const snapshotKerabState = (roof) => {
    if (!roof || !Array.isArray(roof.innerLines)) return null
    const lines = roof.innerLines
      .filter((l) => l && (l.name === LINE_TYPE.SUBLINE.HIP || l.name === LINE_TYPE.SUBLINE.RIDGE) && l.visible !== false)
      .map((l) => ({ x1: l.x1, y1: l.y1, x2: l.x2, y2: l.y2 }))
    const points = (Array.isArray(roof.points) ? roof.points : []).map((p) => ({ x: p.x, y: p.y }))
    return { lines, points }
  }
  const runKerabRuleCheck = (roof, phase, before) => {
    try {
      if (!roof || !Array.isArray(roof.innerLines)) return
      const TOL = 2.0
      const OUT_TOL = 3.0
      const ZERO = 1.0
      const r1 = (n) => Math.round(n * 10) / 10
      const fails = []
      const rpts = Array.isArray(roof.points) ? roof.points : []
      // 검사 대상 = visible 마루/힙. 끝점 공유(접합) 판정에는 골짜기확장(VALLEY)까지 포함 —
      //   RG-1 확장(kerabPatternExtRidge)은 vExt(VALLEY) 위에서 끝나므로 VALLEY 를 빼면 오탐.
      const visLines = roof.innerLines.filter(
        (l) => l && (l.name === LINE_TYPE.SUBLINE.HIP || l.name === LINE_TYPE.SUBLINE.RIDGE) && l.visible !== false,
      )
      const connLines = roof.innerLines.filter(
        (l) =>
          l &&
          (l.name === LINE_TYPE.SUBLINE.HIP || l.name === LINE_TYPE.SUBLINE.RIDGE || l.name === LINE_TYPE.SUBLINE.VALLEY) &&
          l.visible !== false,
      )
      const info = (l) => ({ n: l.name, ln: l.lineName || '-', x1: r1(l.x1), y1: r1(l.y1), x2: r1(l.x2), y2: r1(l.y2) })
      const onCorner = (p) => rpts.some((c) => c && Math.hypot(c.x - p.x, c.y - p.y) < TOL)
      const ends = []
      for (const l of connLines) {
        ends.push({ x: l.x1, y: l.y1, line: l })
        ends.push({ x: l.x2, y: l.y2, line: l })
      }
      const sharedWithOther = (p, self) => ends.some((e) => e.line !== self && Math.hypot(e.x - p.x, e.y - p.y) < TOL)
      // 폴리곤 내부/경계 판정 (ray-casting + edge 거리 tol)
      const pip = (pt) => {
        let inside = false
        for (let i = 0, j = rpts.length - 1; i < rpts.length; j = i++) {
          const xi = rpts[i].x
          const yi = rpts[i].y
          const xj = rpts[j].x
          const yj = rpts[j].y
          const intersect = yi > pt.y !== yj > pt.y && pt.x < ((xj - xi) * (pt.y - yi)) / (yj - yi + 1e-12) + xi
          if (intersect) inside = !inside
        }
        return inside
      }
      const distToSeg = (p, a, b) => {
        const dx = b.x - a.x
        const dy = b.y - a.y
        const l2 = dx * dx + dy * dy || 1
        let t = ((p.x - a.x) * dx + (p.y - a.y) * dy) / l2
        t = Math.max(0, Math.min(1, t))
        return Math.hypot(p.x - (a.x + t * dx), p.y - (a.y + t * dy))
      }
      const minEdgeDist = (pt) => {
        let m = Infinity
        for (let i = 0, j = rpts.length - 1; i < rpts.length; j = i++) {
          const d = distToSeg(pt, rpts[j], rpts[i])
          if (d < m) m = d
        }
        return m
      }
      for (const l of visLines) {
        const endpts = [
          { x: l.x1, y: l.y1 },
          { x: l.x2, y: l.y2 },
        ]
        // R2 zero-length
        if (Math.hypot(l.x2 - l.x1, l.y2 - l.y1) < ZERO) {
          fails.push({ rule: 'R2-zero-length', line: info(l) })
        }
        for (const p of endpts) {
          // R1 dangling: 끝점은 roofLine 경계(코너 + 변)에 닿거나 다른 내부선과 공유돼야 한다.
          //   kLine(중앙 마루)·게이블 hip 은 roofLine '코너'가 아닌 '변' 중간에 닿는 게 정상 →
          //   코너만 보면 오탐. minEdgeDist 로 변까지 포함해 경계 도달을 판정한다.
          const onBoundary = rpts.length >= 3 ? minEdgeDist(p) <= TOL : onCorner(p)
          if (!onBoundary && !sharedWithOther(p, l)) {
            fails.push({ rule: 'R1-dangling', line: info(l), at: { x: r1(p.x), y: r1(p.y) } })
          }
          // R3 outside roofLine
          if (rpts.length >= 3 && !pip(p) && minEdgeDist(p) > OUT_TOL) {
            fails.push({ rule: 'R3-outside', line: info(l), at: { x: r1(p.x), y: r1(p.y) } })
          }
        }
      }
      // R4 anchor: stable roofLine corner 점유수 불변
      if (before && Array.isArray(before.points) && Array.isArray(before.lines)) {
        const countOn = (lineArr, c) => {
          let n = 0
          for (const l of lineArr) {
            if (Math.hypot(l.x1 - c.x, l.y1 - c.y) < TOL) n++
            if (Math.hypot(l.x2 - c.x, l.y2 - c.y) < TOL) n++
          }
          return n
        }
        const afterPlain = visLines.map((l) => ({ x1: l.x1, y1: l.y1, x2: l.x2, y2: l.y2 }))
        for (const c of rpts) {
          const stable = before.points.some((b) => Math.hypot(b.x - c.x, b.y - c.y) < TOL)
          if (!stable) continue
          const bN = countOn(before.lines, c)
          const aN = countOn(afterPlain, c)
          if (bN !== aN) {
            fails.push({ rule: 'R4-anchor', at: { x: r1(c.x), y: r1(c.y) }, before: bN, after: aN })
          }
        }
      }
      if (fails.length) {
        logger.warn('[KERAB-RULE-CHECK] ' + phase + ' FAIL(' + fails.length + ') ' + JSON.stringify(fails))
      } else {
        logger.log('[KERAB-RULE-CHECK] ' + phase + ' PASS')
      }
    } catch (err) {
      logger.warn('[KERAB-RULE-CHECK] error', err)
    }
  }

  const mouseDownEvent = (e) => {
    // [KERAB-MOUSEDOWN-GUARD 2026-05-29] outerLine 아닌 target(ridge/lengthText 등) 클릭 시
    //   discardActiveObject·로그·후속 처리 모두 skip — 다른 hook 의 active 흐름 보호.
    if (!e.target || e.target.name !== 'outerLine') {
      return
    }
    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()

    const target = e.target

    let attributes = target.get('attributes')

    switch (typeRef.current) {
      case TYPES.EAVES:
        if (radioTypeRef.current === '1') {
          attributes = {
            ...attributes,
            type: LINE_TYPE.WALLLINE.EAVES,
            pitch: currentAngleType === ANGLE_TYPE.SLOPE ? pitchRef.current.value : getChonByDegree(pitchRef.current.value),
            offset: offsetRef.current.value / 10,
          }
        } else {
          attributes = {
            ...attributes,
            type: LINE_TYPE.WALLLINE.HIPANDGABLE,
            pitch: currentAngleType === ANGLE_TYPE.SLOPE ? pitchRef.current.value : getChonByDegree(pitchRef.current.value),
            offset: offsetRef.current.value / 10,
            width: widthRef.current.value / 10,
          }
        }
        break
      case TYPES.GABLE:
        if (radioTypeRef.current === '1') {
          attributes = {
            ...attributes,
            type: LINE_TYPE.WALLLINE.GABLE,
            offset: offsetRef.current.value / 10,
          }
        } else {
          attributes = {
            ...attributes,
            type: LINE_TYPE.WALLLINE.JERKINHEAD,
            pitch: currentAngleType === ANGLE_TYPE.SLOPE ? pitchRef.current.value : getChonByDegree(pitchRef.current.value),
            offset: offsetRef.current.value / 10,
            width: widthRef.current.value / 10,
          }
        }
        break
      case TYPES.WALL_MERGE:
        if (radioTypeRef.current === '1') {
          attributes = {
            ...attributes,
            type: LINE_TYPE.WALLLINE.WALL,
            offset: 0,
          }
        } else {
          attributes = {
            ...attributes,
            type: LINE_TYPE.WALLLINE.WALL,
            offset: offsetRef.current.value / 10,
          }
        }
        break
      case TYPES.SHED:
        attributes = {
          ...attributes,
          type: LINE_TYPE.WALLLINE.SHED,
          offset: offsetRef.current.value / 10,
        }
        break
    }

    // [KERAB-STATE-DUMP 2026-06-11] A/B타입(가로/세로 케라바) 토글 진입 시점 지붕 상태 진단.
    //   벽 type 지정은 있는데 내부 skLine 이 0인 "무에서 유" 케이스 파악용 — 사용자 설명 전 사실 수집.
    //   읽기 전용(좌표/visible/type 만 덤프), 동작 변경 없음. logger 게이트(local 만 출력).
    {
      const _dr = canvas
        .getObjects()
        .find((o) => o.name === POLYGON_TYPE.ROOF && !o.isFixed && o.id === target.attributes?.roofId)
      const _r1 = (v) => (typeof v === 'number' ? Math.round(v * 10) / 10 : v)
      logger.log(
        '[KERAB-STATE-DUMP] ' +
          JSON.stringify({
            uiType: typeRef.current,
            radio: radioTypeRef.current,
            target: {
              type: target.attributes?.type,
              offset: target.attributes?.offset,
              x1: _r1(target.x1),
              y1: _r1(target.y1),
              x2: _r1(target.x2),
              y2: _r1(target.y2),
            },
            willBecome: attributes?.type,
            roofId: target.attributes?.roofId,
            roofFound: !!_dr,
            points: _dr?.points?.map((p) => ({ x: _r1(p.x), y: _r1(p.y) })),
            lines: _dr?.lines?.map((l) => ({
              type: l.attributes?.type,
              offset: l.attributes?.offset,
              x1: _r1(l.x1),
              y1: _r1(l.y1),
              x2: _r1(l.x2),
              y2: _r1(l.y2),
            })),
            innerCount: (_dr?.innerLines || []).length,
            innerLines: (_dr?.innerLines || []).map((il) => ({
              lineName: il.lineName,
              type: il.attributes?.type,
              visible: il.visible !== false,
              x1: _r1(il.x1),
              y1: _r1(il.y1),
              x2: _r1(il.x2),
              y2: _r1(il.y2),
            })),
          }),
      )
    }

    // [2240 KERAB-NOOP-REKLICK 2026-05-19] 같은 type 으로의 재클릭은 무동작.
    //   - 케라바→케라바, 처마→처마 등. 기존 rebuild 흐름이 다시 돌면 패턴 상태
    //     (ridge/half-label/orphan ext 정리)를 망가뜨림.
    //   - radio 1 의 단순 변환에만 적용. JERKINHEAD/HIPANDGABLE 등 width 가 들어가는
    //     radio 2 변환은 파라미터 갱신 가능성이 있어 그대로 진행.
    if (radioTypeRef.current === '1' && target.attributes?.type === attributes?.type) {
      // [KERAB-OFFSET-ONLY-RECLICK 2026-06-01] 동일 type 재클릭이지만 出幅(offset) 만 다른 경우,
      //   surgical 갱신(corner / 인접 inner-line 끝점 snap + attributes.offset 반영) 후 종료.
      //   기존 collapse 흐름(applyKerab*Pattern, polygonPath BFS 등) 은 건너뛰어 케라바 패턴 보존.
      const oldOffset = target.attributes?.offset ?? 0
      const newOffset = attributes?.offset ?? 0
      if (Math.abs(newOffset - oldOffset) > 1e-3) {
        logger.log(
          `[KERAB-OFFSET-ONLY-RECLICK] type=${attributes.type} 동일, offset ${oldOffset}→${newOffset} surgical 적용`,
        )
        // [KERAB-OFFSET-ONLY-RECLICK-EAVES 2026-06-05] 처마 상태 출폭 변경 룰:
        //   - wallbaseLine 안의 내부라인 본체 끝점(apex) 절대 불변
        //   - hip outer endpoint 만 wL 코너에서 hip 방향(=skeleton 45°) 으로 새 rL 변까지 ray-cast 확장
        //   - surgical 의 CORNER-SHORTCUT/SHRINK-TRIM 은 룰 위반 → skipInnerLines:true
        //   (케라바 ONLY-RECLICK 은 KERAB-PATTERN-CORNER-SNAP 필요하므로 그대로 둠.)
        const isEaves = attributes?.type === LINE_TYPE.WALLLINE.EAVES
        let reclickRoof = null
        let hasKerabPattern = false
        let hipMarks = []
        if (isEaves) {
          reclickRoof = canvas
            .getObjects()
            .find((o) => o.name === POLYGON_TYPE.ROOF && !o.isFixed && o.id === target.attributes?.roofId)
          if (reclickRoof && Array.isArray(reclickRoof.innerLines) && Array.isArray(reclickRoof.points)) {
            hasKerabPattern = reclickRoof.innerLines.some(
              (il) => il && typeof il.lineName === 'string' && il.lineName.startsWith('kerabPattern'),
            )
            // surgical 적용 *전*(옛 폴리곤) 에 케라바 hip 식별 — outer endpoint 가 옛 변 위에 있어야 잡힌다.
            hipMarks = detectKerabHipMarks(target, reclickRoof)
          }
        }
        // [KERAB-OFFSET-RECLICK-UNIFY 2026-06-15] 出幅 재변경(eaves→eaves)을 skLine 과 동일 경로로 통일.
        //   출발 형상(skLine / A/B타입)에 무관하게 동일 규칙(= 출폭함수):
        //   - 케라바 hip(확장라인)은 surgical CORNER-SNAP 금지 → wall 코너에서 45° ray-cast 로 roofLine 까지.
        //   - 측면 수직선/변조각(normal line)은 surgical(recomputeNormalLine)이 새 코너로 추종.
        //   skLine: 케라바 패턴 없음 → skipInnerLines(전부 45°가 처리).
        //   A/B타입: 케라바 패턴 보유 → skipKerabHips(normal/ridge 는 surgical, hip 만 45°가 처리).
        //   출폭 증감(확장/수축) 양방향이 한 경로에서 일관 처리됨.
        const reclickBeforeSnap = isEaves && reclickRoof ? snapshotKerabState(reclickRoof) : null
        applyTargetOffsetSurgical(
          target,
          newOffset,
          isEaves ? (hasKerabPattern ? { skipKerabHips: true } : { skipInnerLines: true }) : undefined,
        )
        // surgical 적용 *후*(새 폴리곤) 에 케라바 hip 을 45° ray-cast 로 새 roofLine 변까지 확장.
        if (isEaves && reclickRoof) extendKerabHipsTo45(target, reclickRoof, hipMarks)
        // [KERAB-OFFSET-RECLICK-UNIFY 2026-06-15] A/B타입은 케라바 hip 외 inner line 좌표가
        //   surgical 내부(recomputeKerabPatternLine/recomputeNormalLine)에서 갱신됨 →
        //   길이/치수 라벨만 새 좌표 기준으로 새로고침한다(hip 은 45° 블록에서 이미 갱신).
        if (isEaves && hasKerabPattern && reclickRoof && Array.isArray(reclickRoof.innerLines)) {
          for (const il of reclickRoof.innerLines) {
            if (!il || il.lineName === 'kerabPatternHip') continue
            if (typeof il.setCoords === 'function') il.setCoords()
            if (typeof il.setLength === 'function') il.setLength()
            if (typeof il.addLengthText === 'function') il.addLengthText()
          }
          logger.log('[KERAB-OFFSET-RECLICK-UNIFY] surgical label refresh done')
        }
        // [KERAB-OFFSET-RECLICK-RULECHECK 2026-06-15] 라인변경(출폭 재적용) 후 규칙 검사 — 사용자 요구.
        if (isEaves && reclickRoof && reclickBeforeSnap) {
          runKerabRuleCheck(reclickRoof, 'reclick', reclickBeforeSnap)
        }
        target.set({ attributes })
        canvas.renderAll()
        return
      }
      logger.log(`[KERAB-NOOP] 이미 ${attributes.type} → 재변환 무시`)
      return
    }

    // [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
      }
    }

    // [KERAB-RECT-SOLVER 2026-06-15] 사각형이면 토글 이력과 무관한 결정론적 솔버로 처리.
    //   최종 4변 타입만으로 내부선 전부 재생성(Y 불변식 + apex 멈춤 구조적 보장). 미지원 형상은
    //   false → 아래 기존 forward/revert/type 경로로 폴백.
    if (radioTypeRef.current === '1' && (attributes?.type === LINE_TYPE.WALLLINE.EAVES || attributes?.type === LINE_TYPE.WALLLINE.GABLE)) {
      const rectRoof = canvas
        .getObjects()
        .find((o) => o.name === POLYGON_TYPE.ROOF && !o.isFixed && o.id === target.attributes?.roofId)
      if (rectRoof && solveRectangleKerab(rectRoof, target, attributes)) {
        logger.log('[KERAB-RECT-SOLVER] handled deterministically → maze 우회')
        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-SIMPLE] roof check ' + JSON.stringify({ roofId: target.attributes?.roofId, roofFound: !!roof }))
      // [KERAB-INNERLINES-DUMP 2026-05-27] 토글 진입/종료 시점 innerLines ridge/hip 스냅샷.
      //   - cascade hide / trim 으로 어떤 라인이 어디서 끊겼는지 추적용 임시 진단 로그.
      const dumpInnerLineSnapshot = (label) => {
        if (!roof || !Array.isArray(roof.innerLines)) return
        const rows = roof.innerLines
          .filter((l) => l && (l.name === LINE_TYPE.SUBLINE.HIP || l.name === LINE_TYPE.SUBLINE.RIDGE))
          .map((l) => ({
            lab: l.label || '?',
            n: l.name,
            ln: l.lineName || '-',
            v: l.visible !== false,
            x1: Math.round(l.x1 * 10) / 10,
            y1: Math.round(l.y1 * 10) / 10,
            x2: Math.round(l.x2 * 10) / 10,
            y2: Math.round(l.y2 * 10) / 10,
          }))
        logger.log('[KERAB-INNERLINES-' + label + '] ' + JSON.stringify(rows))
        // [KERAB-LABEL-REATTACH 2026-05-29] AFTER 시점에서 라벨 재부착 (local 모드 한정).
        //   케라바 토글로 추가/변경된 kerabPatternRidge/ExtRidge/Hip 등에도 H-/RG- 라벨 부여.
        if (label === 'AFTER') {
          try {
            reattachDebugLabels(canvas, roof.id)
          } catch (e) {
            logger.warn('[KERAB-LABEL-REATTACH] failed', e)
          }
        }
      }
      dumpInnerLineSnapshot('BEFORE')
      // [KERAB-RULE-CHECK 2026-06-10] surgical 전(원본 출폭) 상태를 R4 anchor 기준으로 캡처.
      const kerabBeforeSnap = snapshotKerabState(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]}`)
          }
        }
        const labelOf = (line) => (line ? labelByLine.get(line) || '?' : null)
        // [KERAB-WLINE-T1T2 2026-06-04] wLine 이동 후 선택된 target 은 이동 전 wallLine.
        //   이동된 실제 위치는 wall.baseLines 에 있다.
        //   wallId 매칭은 이동 후 인덱스 재정렬로 잘못된 baseLine 반환 → 기하학적 매칭으로 교체.
        //   같은 방향(수직/수평) + target 의 고정 끝점(이동 안 된 쪽) 공유 여부로 식별.
        const _wall = canvas.getObjects().find((o) => o.name === POLYGON_TYPE.WALL && o.attributes?.roofId === target.attributes?.roofId)
        const _BL_TOL = 5
        const _tIsV = Math.abs(target.x1 - target.x2) < 0.5
        const _tIsH = Math.abs(target.y1 - target.y2) < 0.5
        const _matchedBase = _wall?.baseLines?.find((bl) => {
          if (_tIsV) {
            if (Math.abs(bl.x1 - bl.x2) >= 0.5) return false  // bl 방향 불일치
            if (Math.abs(bl.x1 - target.x1) >= _BL_TOL) return false  // 다른 수직선
            return (
              Math.abs(bl.y1 - target.y1) < _BL_TOL || Math.abs(bl.y1 - target.y2) < _BL_TOL ||
              Math.abs(bl.y2 - target.y1) < _BL_TOL || Math.abs(bl.y2 - target.y2) < _BL_TOL
            )
          }
          if (_tIsH) {
            if (Math.abs(bl.y1 - bl.y2) >= 0.5) return false  // bl 방향 불일치
            if (Math.abs(bl.y1 - target.y1) >= _BL_TOL) return false  // 다른 수평선
            return (
              Math.abs(bl.x1 - target.x1) < _BL_TOL || Math.abs(bl.x1 - target.x2) < _BL_TOL ||
              Math.abs(bl.x2 - target.x1) < _BL_TOL || Math.abs(bl.x2 - target.x2) < _BL_TOL
            )
          }
          // 대각선: wallId fallback
          return bl.attributes?.wallId === target.attributes?.wallId
        })
        const t1 = _matchedBase ? { x: _matchedBase.x1, y: _matchedBase.y1 } : { x: target.x1, y: target.y1 }
        const t2 = _matchedBase ? { x: _matchedBase.x2, y: _matchedBase.y2 } : { 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] polygonPath 라인들의 valley vertex 식별 (진단).
              //   apex 유무 무관 — valley 가 polygonPath 에 존재하면 valleyExt 후보 (gate 완화 2026-05-27).
              //   surgical 출폭 변경으로 H-3·H-2 평행성이 살짝 깨져 apex 가 폴리곤 밖 멀리 잡히는 케이스(거의 평행)
              //   에서도 처마확장이 그려져야 함. 내부의 `h1FarIsValley || h2FarIsValley` 가드가 자동 skip 보장.
              if (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))
                debugCapture.log('KERAB-VALLEY-DIAG', { targetId: target.id, count: valleyInfo.length, valleys: valleyInfo })
              }
              // [KERAB-VALLEY-EXT 2026-05-27] 모델 교체: skeleton valley → 외곽 polygon concave corner.
              //   "확장" = roofLine 의 한쪽 끝점에서 self-extension (반대 끝점 → 그 끝점 방향) 으로 연장.
              //   concave corner 옆 끝점 self-extension 은 polygon 내부로 향함 → 첫 hip/ridge 와 hit.
              //   convex 측 끝점 self-extension 은 polygon 외부로 새서 hit 없음 → 자동 skip.
              //   양 끝점 둘 다 후보로 push → raycast 가 valley 측을 자동 결정.
              const valleyPlannedEndpoints = []
              if (polygonPath) {
                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) {
                  valleyPlannedEndpoints.push(
                    {
                      sx: matchingRoofLine.x1,
                      sy: matchingRoofLine.y1,
                      ox: matchingRoofLine.x2,
                      oy: matchingRoofLine.y2,
                      label: 'roofBase-s',
                      parent: matchingRoofLine,
                    },
                    {
                      sx: matchingRoofLine.x2,
                      sy: matchingRoofLine.y2,
                      ox: matchingRoofLine.x1,
                      oy: matchingRoofLine.y1,
                      label: 'roofBase-e',
                      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()
                runKerabRuleCheck(roof, 'forward', kerabBeforeSnap)
                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()
                runKerabRuleCheck(roof, 'forward', kerabBeforeSnap)
                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
              }
              // [KERAB-ROOF-MAX-INWARD 2026-05-27] roof polygon wall 정의를 wave 시작 전으로 이동 (이전 L896).
              //   사용자 규칙: "확장을 해도 roofLine 까지이다. 절대 통과 못한다."
              //   wave 의 모든 meet 후보 거리를 ext.maxInwardDist 로 제한 → roofLine 너머 meet 거부.
              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],
                  })
                }
              }
              const computeMaxInwardDist = (ext) => {
                let best = 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 d = Math.hypot(ip.x - ext.near.x, ip.y - ext.near.y)
                  if (d < 1e-3) continue
                  if (d < best) best = d
                }
                return best
              }
              const MAX_INWARD_TOL = 0.5
              for (const ext of allExtenders) {
                ext.maxInwardDist = computeMaxInwardDist(ext)
              }
              // [KERAB-VALLEY-EXT-BARRIER 2026-05-27] 골짜기확장라인 사전 계산 — hip/ridge wave 의 barrier 로 사용.
              //   사용자 규칙: "힙/마루 라인은 골짜기 확장라인 및 roofLine 까지. 절대 통과 못한다."
              //   pre-wave 상태(polygonPath 라인 미삭제) 의 roof.innerLines 로 raycast. polygonLines 는 곧 삭제될 라인이라 stopper 제외.
              //   최종 valleyExt 좌표는 L1280+ 에서 post-wave 상태로 다시 raycast → 약간의 차이 있을 수 있음 (수용).
              const valleyExtPreSegs = []
              if (valleyPlannedEndpoints.length) {
                for (const ep of valleyPlannedEndpoints) {
                  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 start = { x: ep.sx, y: ep.sy }
                  const rayEnd = { x: ep.sx + ux * FAR_RAY, y: ep.sy + uy * FAR_RAY }
                  // [KERAB-VALLEY-EXT-RIDGE-STOP 2026-05-27] 새 규칙:
                  //   1) ridge(마루) 만나면 그 점에서 정지. hip 은 통과.
                  //   2) ridge 못 만나면 맞은편 polygon-wall(roofLine 너머) 까지 끝까지 확장 (절반 아님).
                  let bestPt = null
                  let wallT = Infinity
                  let wallHit = null
                  for (const w of roofPolygonWalls) {
                    const ip = lineLineIntersection(start, rayEnd, w.a, w.b)
                    if (!ip) continue
                    if (!isPointOnSegment(ip, w.a.x, w.a.y, w.b.x, w.b.y)) continue
                    const t = (ip.x - start.x) * ux + (ip.y - start.y) * uy
                    if (t < 0.5) continue
                    if (t < wallT) {
                      wallT = t
                      wallHit = ip
                    }
                  }
                  let ridgeStop = null
                  let ridgeT = Infinity
                  // [KERAB-VALLEY-EXT-RIDGE-STOP 2026-05-29] 룰 1: 골짜기 확장라인이 "원래 있던" ridge(마루) 만나면 그 점에서 정지.
                  //   확장으로 생긴 ridge(kerabPatternRidge/kerabPatternExtRidge 등) 는 stop 대상 아님.
                  //   화이트리스트: lineName === 'ridge' 만 매칭.
                  for (const il of roof.innerLines || []) {
                    if (!il || il.visible === false) continue
                    if (il.name !== LINE_TYPE.SUBLINE.RIDGE) continue
                    if (il.lineName !== 'ridge') continue
                    const ip = lineLineIntersection(start, rayEnd, { x: il.x1, y: il.y1 }, { x: il.x2, y: il.y2 })
                    if (!ip) continue
                    if (!isPointOnSegment(ip, il.x1, il.y1, il.x2, il.y2)) continue
                    const t = (ip.x - start.x) * ux + (ip.y - start.y) * uy
                    if (t < 0.5) continue
                    if (wallT !== Infinity && t > wallT + 0.5) continue
                    if (t < ridgeT) {
                      ridgeT = t
                      ridgeStop = ip
                    }
                  }
                  if (ridgeStop) {
                    bestPt = ridgeStop
                    logger.log(
                      '[KERAB-VALLEY-EXT-RIDGE-STOP] pre label=' + ep.label +
                        ' ridgeT=' + Math.round(ridgeT * 100) / 100 +
                        ' stop={' + Math.round(bestPt.x * 100) / 100 + ',' + Math.round(bestPt.y * 100) / 100 + '}',
                    )
                  } else if (wallHit) {
                    bestPt = wallHit
                    logger.log(
                      '[KERAB-VALLEY-EXT-WALL] pre label=' + ep.label +
                        ' end={' + Math.round(bestPt.x * 100) / 100 + ',' + Math.round(bestPt.y * 100) / 100 + '}',
                    )
                  }
                  if (bestPt) {
                    valleyExtPreSegs.push({ x1: start.x, y1: start.y, x2: bestPt.x, y2: bestPt.y, label: ep.label })
                  }
                }
                logger.log(
                  '[KERAB-VALLEY-EXT-PRE] ' +
                    JSON.stringify(
                      valleyExtPreSegs.map((s) => ({
                        label: s.label,
                        from: { x: Math.round(s.x1 * 100) / 100, y: Math.round(s.y1 * 100) / 100 },
                        to: { x: Math.round(s.x2 * 100) / 100, y: Math.round(s.y2 * 100) / 100 },
                      })),
                    ),
                )
              }
              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) => {
                // [KERAB-WLINE-T1T2 2026-06-04] wLine 이동 후 hip.near 가 target 끝점에서 벗어나므로
                // 이동한 처마라인 끝점(t1/t2) 기준으로 foot 계산
                const ax = t2.x - t1.x
                const ay = t2.y - t1.y
                const aSq = ax * ax + ay * ay || 1
                const tFoot = ((apex.x - t1.x) * ax + (apex.y - t1.y) * ay) / aSq
                const foot = { x: t1.x + tFoot * ax, y: t1.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-VALLEY-EXT-BARRIER 2026-05-27] 골짜기확장라인 segment 와의 meet — hip/ridge 가 그 점에서 정지.
                //   mirror/reflection 없음 (단순 정지). 거리 가장 짧은 후보면 우선 처리되어 그 너머로 못 감.
                const valleyExtMeets = []
                for (const ext of unresolved) {
                  for (const vs of valleyExtPreSegs) {
                    const ip = lineLineIntersection(ext.near, ext.far, { x: vs.x1, y: vs.y1 }, { x: vs.x2, y: vs.y2 })
                    if (!ip) continue
                    if (!isInward(ext, ip)) continue
                    if (!isPointOnSegment(ip, vs.x1, vs.y1, vs.x2, vs.y2)) continue
                    const dist = Math.hypot(ip.x - ext.near.x, ip.y - ext.near.y)
                    if (dist < 1e-3) continue
                    valleyExtMeets.push({ ext, point: ip, dist, valleyExtSeg: vs })
                  }
                }
                if (valleyExtMeets.length > 0) {
                  logger.log(
                    '[KERAB-VALLEY-EXT-BARRIER] meets iter=' + iter + ' ' +
                      JSON.stringify(
                        valleyExtMeets.map((v) => ({
                          ext: labelOf(v.ext.line) || (v.ext.isHip ? 'H' : 'R'),
                          point: { x: Math.round(v.point.x * 100) / 100, y: Math.round(v.point.y * 100) / 100 },
                          dist: Math.round(v.dist * 100) / 100,
                        })),
                      ),
                  )
                }
                // [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 })
                }
                // [KERAB-VALLEY-EXT-BARRIER 2026-05-27] valleyExt 와 만나는 hip/ridge 는 그 점에서 정지.
                //   mirror 없음 → L859 의 (kline/ridge/drawn) 분기에 valleyExt 추가하지 않아 reflected 생성 안 됨.
                for (const vm of valleyExtMeets) {
                  candidates.push({
                    kind: 'valleyExt',
                    extenders: [vm.ext],
                    point: vm.point,
                    minDist: vm.dist,
                  })
                }
                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,
                  })
                }
                // [KERAB-ROOF-MAX-INWARD 2026-05-27] roofLine 너머 meet 후보 제거.
                //   사용자 규칙: "확장을 해도 roofLine 까지이다. 절대 통과 못한다."
                //   ext.maxInwardDist (inward 방향 roof wall 까지 최단거리) 를 초과하는 점은 폐기.
                const candidatesBeforeCap = candidates.length
                const capFilteredOut = []
                for (let ci = candidates.length - 1; ci >= 0; ci--) {
                  const c = candidates[ci]
                  let over = false
                  for (const e of c.extenders) {
                    const cap = e.maxInwardDist
                    if (cap === undefined || !Number.isFinite(cap)) continue
                    const d = Math.hypot(c.point.x - e.near.x, c.point.y - e.near.y)
                    if (d > cap + MAX_INWARD_TOL) {
                      over = true
                      capFilteredOut.push({
                        kind: c.kind,
                        ext: labelOf(e.line) || (e.isHip ? 'H' : 'R'),
                        d: Math.round(d * 100) / 100,
                        cap: Math.round(cap * 100) / 100,
                      })
                      break
                    }
                  }
                  if (over) candidates.splice(ci, 1)
                }
                if (capFilteredOut.length > 0) {
                  logger.log(
                    '[KERAB-ROOF-MAX-INWARD] iter=' + iter + ' filtered=' + capFilteredOut.length +
                      '/' + candidatesBeforeCap + ' ' + JSON.stringify(capFilteredOut),
                  )
                }
                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,
                      ))
                    const reflected = {
                      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,
                    }
                    // [KERAB-ROOF-MAX-INWARD 2026-05-27] reflected ext 도 roof wall 까지 캡 계산.
                    reflected.maxInwardDist = computeMaxInwardDist(reflected)
                    newReflected.push(reflected)
                  }
                  break
                }
                if (!processedAny && !pendingKLineCreated) break
                extenderPool.push(...newReflected)
              }
              // [KERAB-ROOF-FALLBACK-ANYWALL 2026-05-21] 미해소 extender 를 roof 폴리곤의 어떤 wall 이라도
              //   inward 방향의 가장 가까운 wall 교점까지 확장. 반사 hip 이 target wall 과 반대쪽으로
              //   향해도 다른 wall 에서 정지.
              //   (roofPolygonWalls 정의는 wave 시작 전 KERAB-ROOF-MAX-INWARD 블록으로 이동됨)
              // [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)
              // [KERAB-VALLEY-EXT-BARRIER 2026-05-27] 골짜기확장라인 — fallback 단계에서도 통과 금지.
              for (const vs of valleyExtPreSegs) barrierLines.push(vs)
              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의 "다음 행위").
              // [KERAB-VALLEY-EXT 2026-05-27] 골짜기확장 케이스에선 cuts 적용 skip.
              //   사용자 요구: "골짜기 라인은 확장만 하라" — 처마확장만 그리고
              //   다른 hip/ridge(H-2 등) 은 일체 손대지 말 것.
              //   staticMeets/cuts 는 일반 케라바 알고리즘의 ext hip pattern 정리용인데,
              //   골짜기 케이스에선 polygonPath 외부의 H-2 같은 라인까지 dir=junction 으로
              //   단축시키는 부작용이 있음.
              const isValleyExtCase = valleyPlannedEndpoints.length > 0
              if (cuts.length > 0 && isValleyExtCase) {
                logger.log('[KERAB-FIXPOINT-PHASE-A] cuts SKIPPED (valley extension case)')
              }
              if (cuts.length > 0 && !isValleyExtCase) {
                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)
                    // [KERAB-VALLEY-EXT-BARRIER 2026-05-27] re-resolve 단계에서도 골짜기확장라인 통과 금지.
                    for (const vs of valleyExtPreSegs) barriers2.push(vs)
                    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,
                  t1,
                  t2,
                  [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) {
                  // ====================================================================
                  // [KERAB-VALLEY-EXT 2026-05-28] valleyExt helper 4종 (Step B 추출).
                  //   Phase 1 = computeValleyExtensions + drawValleyExtensions
                  //   Phase 2 = trimByValleyExtensions + cascadeHideByValleyExtensions
                  //   모든 helper 는 closure 로 roof/target/canvas/roofPolygonWalls/valleyPlannedEndpoints 캡처.
                  //   revert 계약 (lineName='kerabPatternValleyExt', __targetId, target.__valleyExtTrims) 그대로 유지.
                  // ====================================================================
                  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
                  }

                  // ── Phase 1-a: valleyExt ray 계산 ──
                  // self-extension 방향만 사용 (양 끝점 둘 다 시도, concave 측만 hit).
                  // ridge meet first, 못 만나면 wallhit 끝까지. hip 통과.
                  const computeValleyExtensions = () => {
                    const exts = []
                    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 wallT = Infinity
                      let wallHit = null
                      for (const w of roofPolygonWalls) {
                        const ip = lineLineIntersection(start, rayEnd, w.a, w.b)
                        if (!ip) continue
                        if (!isOnSegV(ip, w.a.x, w.a.y, w.b.x, w.b.y)) continue
                        const t = (ip.x - start.x) * ux + (ip.y - start.y) * uy
                        if (t < 0.5) continue
                        if (t < wallT) {
                          wallT = t
                          wallHit = ip
                        }
                      }
                      // [KERAB-VALLEY-HALF 2026-06-11] A/B 타입 표준 규칙(방향 무관):
                      //   내부확장라인은 맞은편 roofLine 까지 거리의 "절반"에서 멈춘다.
                      //   기존 ridge-stop / wall-끝까지 휴리스틱은 ridge 가 우연히 중간에 있으면 절반처럼,
                      //   없으면 끝까지 가버려 방향(세로/가로)에 따라 결과가 들쭉날쭉했다 → 항상 절반으로 통일.
                      //   wallHit = 이 ray 가 만나는 맞은편 roof 외곽선(roofLine). 그 중점이 stop.
                      if (wallHit) {
                        bestStop = { x: (start.x + wallHit.x) / 2, y: (start.y + wallHit.y) / 2 }
                        logger.log(
                          '[KERAB-VALLEY-HALF] post label=' + ep.label +
                            ' wallHit={' + Math.round(wallHit.x * 100) / 100 + ',' + Math.round(wallHit.y * 100) / 100 + '}' +
                            ' halfStop={' + Math.round(bestStop.x * 100) / 100 + ',' + Math.round(bestStop.y * 100) / 100 + '}',
                        )
                      }
                      if (bestStop) {
                        const seg = {
                          x1: start.x,
                          y1: start.y,
                          x2: bestStop.x,
                          y2: bestStop.y,
                          source: ep.label,
                          parent: ep.parent || null,
                        }
                        exts.push(seg)
                        logger.log('[KERAB-VALLEY-EXT] generated ' + JSON.stringify(seg))
                      } else {
                        logger.log('[KERAB-VALLEY-EXT] no ridge/hip hit for ' + ep.label)
                      }
                    }
                    return exts
                  }

                  // ── Phase 1-b: roof + wall QLine 생성 (순수 그리기, trim/hide 없음) ──
                  const drawValleyExtensions = (valleyExtensions) => {
                    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 && vr.source.startsWith('roofBase'))
                    // [KERAB-VALLEY-EXT 2026-05-29] wallLine ID 를 attributes 에 명시 저장.
                    //   apply() 의 wallExt 재계산 RECALC 가 vExt.attributes.wallLine 으로 outerLine 매칭 — 보존 필수.
                    const baseAttrs = { roofId: roof.id, planeSize: sz, actualSize: sz, wallLine: target.id }
                    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)

                    // [KERAB-VALLEY-EXT-WALL 2026-05-28] wallBase 레벨 확장 라인 — 독립 ray.
                    //   사용자 룰: "맞은편 roofLine 까지" — wallBase 측도 자체 시작점에서 ray 쏴서 polygon-wall hit 까지.
                    //   roof 측 끝점과 공유 X (그건 만나라는 의미). roof 측과 동일 방향, ridge-stop 룰 동일.
                    //   wallBase 측은 시각만 — innerLines push X, type=EAVES X, parentLine X.
                    if (isRoofBase && vr.parent && target) {
                      const rl = vr.parent
                      const dxR = rl.x2 - rl.x1
                      const dyR = rl.y2 - rl.y1
                      const lenR = Math.hypot(dxR, dyR) || 1
                      const uxR2 = dxR / lenR
                      const uyR2 = dyR / lenR
                      const sT1 = (target.x1 - rl.x1) * uxR2 + (target.y1 - rl.y1) * uyR2
                      const sT2 = (target.x2 - rl.x1) * uxR2 + (target.y2 - rl.y1) * uyR2
                      const tStart = sT1 < sT2 ? { x: target.x1, y: target.y1 } : { x: target.x2, y: target.y2 }
                      const tEnd = sT1 < sT2 ? { x: target.x2, y: target.y2 } : { x: target.x1, y: target.y1 }
                      const wallCorner = vr.source === 'roofBase-s' ? tStart : tEnd
                      // 방향: vr 방향 그대로 (vr.x1,y1 → vr.x2,y2)
                      const vdx = vr.x2 - vr.x1
                      const vdy = vr.y2 - vr.y1
                      const vlen = Math.hypot(vdx, vdy) || 1
                      const wUx = vdx / vlen
                      const wUy = vdy / vlen
                      const wStart = { x: wallCorner.x, y: wallCorner.y }
                      const wRayEnd = { x: wStart.x + wUx * 1e5, y: wStart.y + wUy * 1e5 }
                      // polygon-wall hit
                      let wWallT = Infinity
                      let wWallHit = null
                      for (const w of roofPolygonWalls) {
                        const ip = lineLineIntersection(wStart, wRayEnd, w.a, w.b)
                        if (!ip) continue
                        if (!isOnSegV(ip, w.a.x, w.a.y, w.b.x, w.b.y)) continue
                        const t = (ip.x - wStart.x) * wUx + (ip.y - wStart.y) * wUy
                        if (t < 0.5) continue
                        if (t < wWallT) {
                          wWallT = t
                          wWallHit = ip
                        }
                      }
                      // ridge stop (roof 측과 동일 룰)
                      let wRidgeT = Infinity
                      let wRidgeStop = null
                      // [KERAB-VALLEY-EXT-RIDGE-STOP 2026-05-29] 룰 1: 원래 ridge 만 stop (wallBase 측 ray).
                      for (const il of roof.innerLines || []) {
                        if (!il || il.visible === false) continue
                        if (il.name !== LINE_TYPE.SUBLINE.RIDGE) continue
                        if (il.lineName !== 'ridge') continue
                        const ip = lineLineIntersection(wStart, wRayEnd, { x: il.x1, y: il.y1 }, { x: il.x2, y: il.y2 })
                        if (!ip) continue
                        if (!isOnSegV(ip, il.x1, il.y1, il.x2, il.y2)) continue
                        const t = (ip.x - wStart.x) * wUx + (ip.y - wStart.y) * wUy
                        if (t < 0.5) continue
                        if (wWallT !== Infinity && t > wWallT + 0.5) continue
                        if (t < wRidgeT) {
                          wRidgeT = t
                          wRidgeStop = ip
                        }
                      }
                      const wEnd = wRidgeStop || wWallHit
                      if (wEnd) {
// [KERAB-VALLEY-OVERLAP 2026-05-28] roof 1개에 split 결과 sub-roof 가 나뉜다.
                        //   라인은 roof.id 로만 생성 → split 후 직사각형 sub-roof 가 분리되어 나옴.
                        //   apply() 후처리에서 직사각형 sub-roof 를 인접 두 sub-roof 에 union 머지하여 "겹침" 표현.
                        const buildOverlapLine = (p1, p2, suffix) => {
                          const lpts = [p1.x, p1.y, p2.x, p2.y]
                          const lsz = calcLinePlaneSize({ x1: lpts[0], y1: lpts[1], x2: lpts[2], y2: lpts[3] })
                          const ln = new QLine(lpts, {
                            parentId: roof.id,
                            fontSize: roof.fontSize,
                            stroke: '#1083E3',
                            strokeWidth: 3,
                            name: LINE_TYPE.SUBLINE.VALLEY,
                            textMode: roof.textMode,
                            attributes: {
                              roofId: roof.id,
                              type: 'kerabValleyOverlapLine',
                              isStart: true,
                              pitch: roof.pitch,
                              planeSize: lsz,
                              actualSize: lsz,
                            },
                          })
                          ln.lineName = 'kerabValleyOverlapLine'
                          ln.roofId = roof.id
                          ln.__targetId = target.id
                          ln.__valleyExtSource = vr.source + suffix
                          canvas.add(ln)
                          ln.bringToFront()
                          return ln
                        }
                        // [KERAB-VALLEY-OVERLAP 2026-05-28] 평행 사각형으로 b 외곽 닫기 + (선택) 그 너머 ray 연장.
                        //   사용자 룰: "vStart 에서 wLine 까지 평행선 → 그 교점에서부터 wallExt 확장".
                        //   출발: vStart 의 wallLine(target) 위 수선의 발 = newWStart (90° 보조선). 원래 wStart(target corner) 는 사용 안 함.
                        //   도착: vEnd 의 동일 offset 평행이동 = wEndProj (90° 보조선, 이전과 동일).
                        //   사각형 4변: vStart-newWStart, newWStart-wEndProj(wallExt 본체), wEndProj-vEnd, vEnd-vStart(=vExt 이미 그려짐).
                        //   wEnd(원 ray hit) 가 wEndProj 보다 더 멀면 wEndProj→wEnd 확장 라인 추가.
                        const vStart = { x: pts[0], y: pts[1] }
                        const vEnd = { x: pts[2], y: pts[3] }
                        const dxT = target.x2 - target.x1
                        const dyT = target.y2 - target.y1
                        const lenTSq = dxT * dxT + dyT * dyT
                        const tFoot = ((vStart.x - target.x1) * dxT + (vStart.y - target.y1) * dyT) / Math.max(lenTSq, 1e-9)
                        const newWStart = { x: target.x1 + tFoot * dxT, y: target.y1 + tFoot * dyT }
                        const offX = newWStart.x - vStart.x
                        const offY = newWStart.y - vStart.y
                        const wEndProj = { x: vEnd.x + offX, y: vEnd.y + offY }
                        buildOverlapLine(newWStart, wEndProj, '-wall')
                        buildOverlapLine(vStart, newWStart, '-bridge-start')
                        buildOverlapLine(vEnd, wEndProj, '-bridge-end')
                        // [KERAB-VALLEY-HALF 2026-06-11] 절반 규칙: wLine(wallBase) 도 vEnd(절반) 까지만.
                        //   wEndProj 는 절반인 vEnd 에서 파생되므로, wEnd(원 ray full hit) 너머 확장은 금지.
                        logger.log(
                          '[KERAB-VALLEY-OVERLAP] drawn ' +
                            JSON.stringify({
                              src: vr.source,
                              stop: wRidgeStop ? 'ridge' : 'wall',
                              newWStart: { x: Math.round(newWStart.x * 100) / 100, y: Math.round(newWStart.y * 100) / 100 },
                              wEndProj: { x: Math.round(wEndProj.x * 100) / 100, y: Math.round(wEndProj.y * 100) / 100 },
                              wEnd: { x: Math.round(wEnd.x * 100) / 100, y: Math.round(wEnd.y * 100) / 100 },
                              vStart: { x: Math.round(vStart.x * 100) / 100, y: Math.round(vStart.y * 100) / 100 },
                              vEnd: { x: Math.round(vEnd.x * 100) / 100, y: Math.round(vEnd.y * 100) / 100 },
                              extended: false,
                            }),
                        )

                        // [KERAB-VALLEY-EXT-TRIM 2026-05-29] 룰 2: vExt 가 ridge 와 교차하면
                        //   wallExt(`:`) 측(=vExt 와 가까운 영역) ridge 부분 절삭.
                        //   ridge 의 V apex 는 vExt 와 먼 끝점 (Y 출발점). 살아남는 쪽 = V apex 쪽.
                        //   방향 판정: 절삭 방향 = wallExt 중점 - vExt 중점 (wallExt 측). dot 양수면 절삭 대상.
                        const veMid = { x: (vStart.x + vEnd.x) / 2, y: (vStart.y + vEnd.y) / 2 }
                        const wsMid = { x: (newWStart.x + wEndProj.x) / 2, y: (newWStart.y + wEndProj.y) / 2 }
                        const bDirX = wsMid.x - veMid.x
                        const bDirY = wsMid.y - veMid.y
                        const isBSide = (px, py) => (px - veMid.x) * bDirX + (py - veMid.y) * bDirY > 0
                        const trimCascadePts = []
                        const newTrimRecords = []
                        for (const il of roof.innerLines || []) {
                          if (!il || il.visible === false) continue
                          // [KERAB-VALLEY-EXT-TRIM 2026-05-29] trim 대상 = 원래 ridge/hip + 마루 확장(ExtRidge) + kLine(kerabPatternRidge).
                          //   stop 룰(룰 1) 은 ridge 만, trim 룰(룰 2) 은 hip 도 포함 — vExt 는 hip 통과 후 절삭.
                          //   절삭 방향은 V apex 우선 룰 (아래) 로 결정.
                          const isRidge =
                            il.name === LINE_TYPE.SUBLINE.RIDGE &&
                            (il.lineName === 'ridge' || il.lineName === 'kerabPatternRidge' || il.lineName === 'kerabPatternExtRidge')
                          const isHip =
                            il.name === LINE_TYPE.SUBLINE.HIP &&
                            (il.lineName === 'hip' || il.lineName === 'kerabPatternHip' || il.lineName === 'kerabPatternExtHip')
                          if (!isRidge && !isHip) continue
                          const ip = lineLineIntersection(vStart, vEnd, { x: il.x1, y: il.y1 }, { x: il.x2, y: il.y2 })
                          if (!ip) continue
                          if (!isOnSegV(ip, vStart.x, vStart.y, vEnd.x, vEnd.y)) continue
                          if (!isOnSegV(ip, il.x1, il.y1, il.x2, il.y2)) continue
                          // [VALLEY-EXT-TRIM-ENDPOINT-GUARD 2026-06-10] ip 가 il 끝점과 일치하면
                          //   그 라인은 vExt 를 가로지르는(cross) 게 아니라 vExt 에서 끝나는(terminate)
                          //   라인(예: RG-1 연장선, 한 끝이 이미 vExt 위). 반대 끝을 ip 로 절삭하면 양 끝이
                          //   같은 점이 되어 길이 0 붕괴 → 라인 소실. 절삭은 막되, 끝점이 vExt 내부점이면
                          //   split 은 여전히 필요(그래프 노드 공유 → 할당 dead-end 방지)하므로 split 전용
                          //   레코드만 push 한다(좌표 변경/cascade 없음). revert 는 splitOnly 를 건너뛴다.
                          if (Math.hypot(ip.x - il.x1, ip.y - il.y1) < 1.0 || Math.hypot(ip.x - il.x2, ip.y - il.y2) < 1.0) {
                            newTrimRecords.push({ line: il, splitOnly: true, newPt: { x: ip.x, y: ip.y } })
                            continue
                          }
                          // [KERAB-VALLEY-EXT-TRIM 2026-05-29] 절삭 방향 — V apex 우선 룰.
                          //   V apex = 케라바 확장 hip(kerabPatternHip/kerabPatternExtHip) 두 개의 교점.
                          //   원래 hip(lineName='hip') 모임은 V apex 아님 — Y 출발점 룰은 케라바 패턴 한정.
                          //   1) 한 끝만 V apex → 그 V apex 측 살림, 반대 끝 절삭.
                          //   2) 양 끝 모두 V apex → vExt 와 먼 끝 살림 (가까운 끝 절삭).
                          //   3) 둘 다 V apex 아님 → 기존 fallback (B 측 = wallExt 측 절삭).
                          const isVApex = (px, py) => {
                            let cnt = 0
                            for (const other of roof.innerLines || []) {
                              if (!other || other === il) continue
                              if (other.visible === false) continue
                              if (other.name !== LINE_TYPE.SUBLINE.HIP) continue
                              if (other.lineName !== 'kerabPatternHip' && other.lineName !== 'kerabPatternExtHip') continue
                              if (Math.hypot(other.x1 - px, other.y1 - py) < 1.0) cnt++
                              else if (Math.hypot(other.x2 - px, other.y2 - py) < 1.0) cnt++
                              if (cnt >= 2) return true
                            }
                            return false
                          }
                          const e1V = isVApex(il.x1, il.y1)
                          const e2V = isVApex(il.x2, il.y2)
                          const e1B = isBSide(il.x1, il.y1)
                          const e2B = isBSide(il.x2, il.y2)
                          let trimEnd = 0
                          if (e1V && !e2V) trimEnd = 2 // e1 V apex 살림, e2 절삭
                          else if (!e1V && e2V) trimEnd = 1
                          else if (e1V && e2V) {
                            // 양 끝 모두 V apex → vExt 와 가까운 끝 절삭
                            const d1 = Math.hypot(il.x1 - veMid.x, il.y1 - veMid.y)
                            const d2 = Math.hypot(il.x2 - veMid.x, il.y2 - veMid.y)
                            trimEnd = d1 < d2 ? 1 : 2
                          } else {
                            // 둘 다 V apex 아님 → 기존 B 측 fallback
                            if (e1B && !e2B) trimEnd = 1
                            else if (!e1B && e2B) trimEnd = 2
                            else continue
                          }
                          const oldPt = trimEnd === 1 ? { x: il.x1, y: il.y1 } : { x: il.x2, y: il.y2 }
                          const originalAttrs = { ...(il.attributes || {}) }
                          if (trimEnd === 1) il.set({ x1: ip.x, y1: ip.y })
                          else il.set({ x2: ip.x, y2: ip.y })
                          if (typeof il.setCoords === 'function') il.setCoords()
                          const newSz = calcLinePlaneSize({ x1: il.x1, y1: il.y1, x2: il.x2, y2: il.y2 })
                          il.attributes = { ...il.attributes, planeSize: newSz, actualSize: newSz }
                          // [KERAB-EXTRIDGE-CONNECT 2026-06-01] cascade hide 시 ExtRidge 끝점을 vExt 끝점(=ip)로 연장.
                          // ExtRidge 와 vExt 끝점이 분리돼 split graph 의 sub-roof 외곽이 안 닫히는 문제 해소.
                          trimCascadePts.push({ pt: oldPt, newPt: { x: ip.x, y: ip.y } })
                          newTrimRecords.push({
                            line: il,
                            end: trimEnd,
                            oldPt,
                            newPt: { x: ip.x, y: ip.y },
                            originalAttrs,
                          })
                          logger.log(
                            '[KERAB-VALLEY-EXT-TRIM] ridge trim ' +
                              JSON.stringify({ lineName: il.lineName, trimEnd, oldPt, ip: { x: Math.round(ip.x * 100) / 100, y: Math.round(ip.y * 100) / 100 } }),
                          )
                        }
                        // cascade — 절삭된 끝점에 붙은 ridge 확장(kerabPatternExtRidge) 만 BFS hide
                        const cascadeHidden = new Set()
                        let cascadeGuard = 0
                        while (trimCascadePts.length && cascadeGuard++ < 200) {
                          const entry = trimCascadePts.shift()
                          if (!entry) continue
                          const pt = entry.pt || entry
                          for (const il of roof.innerLines || []) {
                            if (!il || il.visible === false) continue
                            if (cascadeHidden.has(il)) continue
                            if (il.lineName !== 'kerabPatternExtRidge') continue
                            const m1 = Math.hypot(il.x1 - pt.x, il.y1 - pt.y) < 1.0
                            const m2 = Math.hypot(il.x2 - pt.x, il.y2 - pt.y) < 1.0
                            if (!m1 && !m2) continue
                            cascadeHidden.add(il)
                            const originalVisible = il.visible !== false
                            const originalAttrs = { ...(il.attributes || {}) }
                            il.visible = false
                            if (typeof il.setCoords === 'function') il.setCoords()
                            newTrimRecords.push({
                              line: il,
                              hide: true,
                              originalVisible,
                              originalAttrs,
                            })
                            logger.log(
                              '[KERAB-VALLEY-EXT-TRIM] cascade hide ' +
                                JSON.stringify({ lineName: il.lineName, x1: il.x1, y1: il.y1, x2: il.x2, y2: il.y2 }),
                            )
                            trimCascadePts.push({ pt: m1 ? { x: il.x2, y: il.y2 } : { x: il.x1, y: il.y1 } })
                          }
                        }
                        // [KERAB-VALLEY-EXT-SPLIT 2026-06-04] Option A: vExt(내부 roofLine)가 ridge/hip 와
                        //   *내부* 교점에서 만나면 그 교점에서 vExt 자체를 분할한다.
                        //   이유: getSplitRoofsPoints(usePolygon.js)는 라인 *끝점*만 그래프 노드로 만든다
                        //   (교차분할 없음). 절삭된 ridge(예: RG-2)가 vExt 의 끝점이 아닌 중간(internal)에
                        //   닿으면 공유 노드가 없어 dead-end → 지붕면 할당에서 고립 폐기되고 인접 면이 안
                        //   쪼개진다(예: F-2 비대). vExt 를 교점에서 분할해 끝점=노드를 만들어 ridge 가
                        //   할당 그래프에 연결되게 한다. 절삭 규칙/방향은 건드리지 않고 vExt 분할만 추가.
                        //   revert: 분할 세그먼트도 lineName='kerabPatternValleyExt' + __targetId 이므로
                        //   applyKerabRevertPattern 의 valleyExt 제거 스캔에서 자동 정리된다.
                        {
                          const SPLIT_TOL = 1.0
                          const interiorPts = []
                          for (const r of newTrimRecords) {
                            if (!r || r.hide || !r.newPt) continue
                            const ip = r.newPt
                            if (!isOnSegV(ip, vStart.x, vStart.y, vEnd.x, vEnd.y)) continue
                            const dS = Math.hypot(ip.x - vStart.x, ip.y - vStart.y)
                            const dE = Math.hypot(ip.x - vEnd.x, ip.y - vEnd.y)
                            if (dS < SPLIT_TOL || dE < SPLIT_TOL) continue // 끝점은 이미 노드
                            if (interiorPts.some((p) => Math.hypot(p.x - ip.x, p.y - ip.y) < SPLIT_TOL)) continue
                            interiorPts.push({ x: ip.x, y: ip.y })
                          }
                          if (interiorPts.length) {
                            const vdx2 = vEnd.x - vStart.x
                            const vdy2 = vEnd.y - vStart.y
                            const tOf = (p) => (p.x - vStart.x) * vdx2 + (p.y - vStart.y) * vdy2
                            interiorPts.sort((a, b) => tOf(a) - tOf(b))
                            const bps = [vStart, ...interiorPts, vEnd]
                            // 첫 구간은 기존 vExt 재사용(끝점 단축), 나머지는 새 QLine 세그먼트.
                            vExt.set({ x2: bps[1].x, y2: bps[1].y })
                            if (typeof vExt.setCoords === 'function') vExt.setCoords()
                            const sz0 = calcLinePlaneSize({ x1: vExt.x1, y1: vExt.y1, x2: vExt.x2, y2: vExt.y2 })
                            vExt.attributes = { ...vExt.attributes, planeSize: sz0, actualSize: sz0 }
                            const newSegs = []
                            for (let bi = 1; bi < bps.length - 1; bi++) {
                              const a = bps[bi]
                              const b = bps[bi + 1]
                              const segSz = calcLinePlaneSize({ x1: a.x, y1: a.y, x2: b.x, y2: b.y })
                              const seg = new QLine([a.x, a.y, b.x, b.y], {
                                parentId: roof.id,
                                fontSize: roof.fontSize,
                                stroke: '#1083E3',
                                strokeWidth: 3,
                                name: LINE_TYPE.SUBLINE.VALLEY,
                                textMode: roof.textMode,
                                attributes: { ...(vExt.attributes || {}), planeSize: segSz, actualSize: segSz },
                              })
                              seg.lineName = 'kerabPatternValleyExt'
                              seg.__targetId = target.id
                              seg.__valleyExtSource = vExt.__valleyExtSource
                              if (vExt.parentLine) seg.parentLine = vExt.parentLine
                              if (vExt.direction) seg.direction = vExt.direction
                              canvas.add(seg)
                              seg.bringToFront()
                              roof.innerLines.push(seg)
                              newSegs.push(seg)
                            }
                            logger.log(
                              '[KERAB-VALLEY-EXT-SPLIT] vExt split ' +
                                JSON.stringify({
                                  source: vr.source,
                                  breaks: interiorPts.map((p) => ({ x: Math.round(p.x * 100) / 100, y: Math.round(p.y * 100) / 100 })),
                                  segs: newSegs.length + 1,
                                }),
                            )
                            debugCapture.log('KERAB-VALLEY-EXT-SPLIT', {
                              source: vr.source,
                              vStart: { x: Math.round(vStart.x * 100) / 100, y: Math.round(vStart.y * 100) / 100 },
                              vEnd: { x: Math.round(vEnd.x * 100) / 100, y: Math.round(vEnd.y * 100) / 100 },
                              breaks: interiorPts.map((p) => ({ x: Math.round(p.x * 100) / 100, y: Math.round(p.y * 100) / 100 })),
                              segCount: newSegs.length + 1,
                            })
                          }
                        }
                        // [KERAB-VALLEY-EXT-TRIM 2026-05-29] revert 위해 target.__valleyExtTrims 에 누적.
                        //   기존 revert 로직(2566~) 이 hide/end/oldPt/originalAttrs 그대로 처리.
                        //   한 mousedown 에 여러 vExt 가 호출될 수 있어 concat.
                        if (newTrimRecords.length) {
                          target.__valleyExtTrims = (target.__valleyExtTrims || []).concat(newTrimRecords)
                        }
                        debugCapture.log('KERAB-VALLEY-EXT-TRIM', {
                          source: vr.source,
                          vStart: { x: Math.round(vStart.x * 100) / 100, y: Math.round(vStart.y * 100) / 100 },
                          vEnd: { x: Math.round(vEnd.x * 100) / 100, y: Math.round(vEnd.y * 100) / 100 },
                          count: newTrimRecords.length,
                          trims: newTrimRecords.map((r) => ({
                            lineName: r.line?.lineName,
                            name: r.line?.name,
                            label: typeof labelOf === 'function' ? labelOf(r.line) : undefined,
                            hide: r.hide ?? false,
                            end: r.end,
                            oldPt: r.oldPt ? { x: Math.round(r.oldPt.x * 100) / 100, y: Math.round(r.oldPt.y * 100) / 100 } : null,
                            newPt: r.newPt ? { x: Math.round(r.newPt.x * 100) / 100, y: Math.round(r.newPt.y * 100) / 100 } : null,
                            now: r.line ? { x1: Math.round(r.line.x1 * 100) / 100, y1: Math.round(r.line.y1 * 100) / 100, x2: Math.round(r.line.x2 * 100) / 100, y2: Math.round(r.line.y2 * 100) / 100 } : null,
                          })),
                        })
                      } else {
                        logger.log('[KERAB-VALLEY-EXT-WALL] no hit for ' + vr.source)
                      }
                    }
                  }
                  }

                  // ── Phase 2-a: valleyExt 경로상 교차 hip/ridge 절삭 ──
                  // trim 대상 = ridge + 케라바 토글 생성 hip(kerabPatternHip/ExtHip). 원래 지붕 hip 보존.
                  // Y 룰: hip-presence 검사 → hip 있는 쪽 보존, 없는 쪽 단축.
                  const trimByValleyExtensions = (valleyExtensions) => {
                    const trimRecords = []
                    for (const vr of valleyExtensions) {
                    if (!vr.source || !vr.source.startsWith('roofBase')) continue
                    const segA = { x: vr.x1, y: vr.y1 }
                    const segB = { x: vr.x2, y: vr.y2 }
                    const wallEnd = { x: 2 * segB.x - segA.x, y: 2 * segB.y - segA.y }
                    const dxV = wallEnd.x - segA.x
                    const dyV = wallEnd.y - segA.y
                    const lenV = Math.hypot(dxV, dyV) || 1
                    const ux = dxV / lenV
                    const uy = dyV / lenV
                    const tB = (segB.x - segA.x) * ux + (segB.y - segA.y) * uy
                    const COLLINEAR_TOL = 1.0
                    for (const il of roof.innerLines || []) {
                      if (!il) continue
                      if (il.lineName === 'kerabPatternValleyExt') continue
                      // trim 대상 = ridge(마루) + 케라바 토글 생성 hip(kerabPatternHip / kerabPatternExtHip).
                      // 원래 지붕 hip 은 보존.
                      const isTrimCandidate =
                        il.name === LINE_TYPE.SUBLINE.RIDGE ||
                        (il.name === LINE_TYPE.SUBLINE.HIP && (il.lineName === 'kerabPatternHip' || il.lineName === 'kerabPatternExtHip'))
                      if (!isTrimCandidate) continue
                      if (il.visible === false) continue
                      const a = { x: il.x1, y: il.y1 }
                      const b = { x: il.x2, y: il.y2 }
                      let ip = lineLineIntersection(segA, wallEnd, a, b)
                      if (ip) {
                        if (!isOnSegV(ip, segA.x, segA.y, wallEnd.x, wallEnd.y)) ip = null
                        else if (!isOnSegV(ip, a.x, a.y, b.x, b.y)) ip = null
                      }
                      if (!ip) {
                        const perp1 = Math.abs((il.x1 - segA.x) * uy - (il.y1 - segA.y) * ux)
                        const perp2 = Math.abs((il.x2 - segA.x) * uy - (il.y2 - segA.y) * ux)
                        if (perp1 > COLLINEAR_TOL || perp2 > COLLINEAR_TOL) continue
                        const tc1 = (il.x1 - segA.x) * ux + (il.y1 - segA.y) * uy
                        const tc2 = (il.x2 - segA.x) * ux + (il.y2 - segA.y) * uy
                        if (Math.max(tc1, tc2) <= tB + 0.5) continue
                        ip = { x: segB.x, y: segB.y }
                      }
                      // Y 룰: hip-presence 검사 → hip 있는 쪽 보존, 없는 쪽 단축.
                      // 양쪽 다 원래 hip 있음 → 통째 보존. 양쪽 다 없음 → 진행벡터 fallback (cascade pass 에서 정리).
                      const isOriginalHipEndAt = (px, py) => {
                        for (const other of roof.innerLines || []) {
                          if (!other || other === il) continue
                          if (other.lineName === 'kerabPatternValleyExt') continue
                          if (other.lineName === 'kerabPatternHip' || other.lineName === 'kerabPatternExtHip') continue
                          if (other.name !== LINE_TYPE.SUBLINE.HIP) continue
                          if (other.visible === false) continue
                          if (Math.hypot(other.x1 - px, other.y1 - py) < 1.0) return true
                          if (Math.hypot(other.x2 - px, other.y2 - py) < 1.0) return true
                        }
                        return false
                      }
                      const hip1 = isOriginalHipEndAt(il.x1, il.y1)
                      const hip2 = isOriginalHipEndAt(il.x2, il.y2)
                      let trimEnd
                      if (hip1 && hip2) {
                        logger.log('[KERAB-VALLEY-EXT-TRIM] both-hip preserve ' + JSON.stringify({ name: il.name, lineName: il.lineName }))
                        continue
                      } else if (hip1 && !hip2) {
                        trimEnd = 2
                      } else if (!hip1 && hip2) {
                        trimEnd = 1
                      } else {
                        const t1 = (il.x1 - segA.x) * ux + (il.y1 - segA.y) * uy
                        const t2 = (il.x2 - segA.x) * ux + (il.y2 - segA.y) * uy
                        trimEnd = t1 > t2 ? 1 : 2
                      }
                      const oldX = trimEnd === 1 ? il.x1 : il.x2
                      const oldY = trimEnd === 1 ? il.y1 : il.y2
                      trimRecords.push({
                        line: il,
                        end: trimEnd,
                        oldPt: { x: oldX, y: oldY },
                        newPt: { x: ip.x, y: ip.y },
                        originalAttrs: { ...(il.attributes || {}) },
                      })
                      if (trimEnd === 1) il.set({ x1: ip.x, y1: ip.y })
                      else il.set({ x2: ip.x, y2: ip.y })
                      if (typeof il.setCoords === 'function') il.setCoords()
                      const newSz = calcLinePlaneSize({ x1: il.x1, y1: il.y1, x2: il.x2, y2: il.y2 })
                      il.attributes = { ...il.attributes, planeSize: newSz, actualSize: newSz }
                      logger.log(
                        '[KERAB-VALLEY-EXT-TRIM] trim ' +
                          JSON.stringify({ name: il.name, lineName: il.lineName, trimEnd, oldPt: { x: oldX, y: oldY }, ip }),
                      )
                    }
                    }
                    return trimRecords
                  }

                  // ── Phase 2-b: cascade hide ──
                  // trim oldPt 에 끝점 일치 케라바산 라인(kerabPatternHip/ExtHip/Ridge/ExtRidge) BFS hide.
                  // 원래 지붕 ridge/hip 은 cascade 대상 외 — junction 공유 의도 외 절삭 방지.
                  const cascadeHideByValleyExtensions = (trimRecords) => {
                    const isKerabSynthetic = (line) => {
                      if (!line || !line.lineName) return false
                      return (
                        line.lineName === 'kerabPatternHip' ||
                        line.lineName === 'kerabPatternExtHip' ||
                        line.lineName === 'kerabPatternRidge' ||
                        line.lineName === 'kerabPatternExtRidge'
                      )
                    }
                    const cascadeHidden = new Set()
                    const cascadeQueue = trimRecords.map((r) => r.oldPt).filter(Boolean)
                    let cascadeGuard = 0
                    while (cascadeQueue.length && cascadeGuard++ < 200) {
                      const pt = cascadeQueue.shift()
                      if (!pt) continue
                      for (const il of roof.innerLines || []) {
                        if (!il || il.visible === false) continue
                        if (cascadeHidden.has(il)) continue
                        if (il.lineName === 'kerabPatternValleyExt') continue
                        if (!isKerabSynthetic(il)) continue
                        const m1 = Math.hypot(il.x1 - pt.x, il.y1 - pt.y) < 1.0
                        const m2 = Math.hypot(il.x2 - pt.x, il.y2 - pt.y) < 1.0
                        if (!m1 && !m2) continue
                        cascadeHidden.add(il)
                        trimRecords.push({
                          line: il,
                          hide: true,
                          originalAttrs: { ...(il.attributes || {}) },
                          originalVisible: il.visible !== false,
                        })
                        il.visible = false
                        if (typeof il.setCoords === 'function') il.setCoords()
                        logger.log(
                          '[KERAB-VALLEY-EXT-TRIM] cascade hide ' +
                            JSON.stringify({ name: il.name, lineName: il.lineName, x1: il.x1, y1: il.y1, x2: il.x2, y2: il.y2 }),
                        )
                        cascadeQueue.push(m1 ? { x: il.x2, y: il.y2 } : { x: il.x1, y: il.y1 })
                      }
                    }
                  }

                  // === Phase 1 + Phase 2 실행 ===
                  const valleyExtensions = computeValleyExtensions()
                  drawValleyExtensions(valleyExtensions)
                  if (valleyExtensions.length) {
                    logger.log('[KERAB-VALLEY-EXT] drawn ' + valleyExtensions.length)
                  }
                  // [KERAB-VALLEY-EXT 2026-05-28] 사용자 지시: 골짜기 라인이동(trim)·라인절삭(cascade) 다 비활성, 확장만.
                  // 골짜기 케라바 라인 별도 룰 후속에서 재활성 예정.
                  // const trimRecords = trimByValleyExtensions(valleyExtensions)
                  // cascadeHideByValleyExtensions(trimRecords)
                  const trimRecords = []
                  if (trimRecords.length) target.__valleyExtTrims = trimRecords
                }
                dumpInnerLineSnapshot('AFTER')
                runKerabRuleCheck(roof, 'forward', kerabBeforeSnap)
                logger.log('[KERAB-SIMPLE] applied (sequential, drawKLine=' + drawKLine + ', extraApexes=' + extraApexes.length + ')')
                return
              }
              dumpInnerLineSnapshot('AFTER')
              logger.log('[KERAB-SIMPLE] no resolution possible — fallback attr-only')
              target.set({ attributes })
              applyKerabAttributeOnlyPattern()
              runKerabRuleCheck(roof, 'forward', kerabBeforeSnap)
              return
            }
            // condition 1: 자연 만남 — ext 없이 hip 제거 + kLine
            target.set({ attributes })
            applyKerabKLinePattern(
              roof,
              target,
              apex,
              t1,
              t2,
              [h1Match.hip, h2Match.hip],
              null,
              null,
            )
            dumpInnerLineSnapshot('AFTER')
            runKerabRuleCheck(roof, 'forward', kerabBeforeSnap)
            logger.log('[KERAB-SIMPLE] applied (kLine, natural-apex)')
            return
          }
        }
        target.set({ attributes })
        applyKerabAttributeOnlyPattern()
        runKerabRuleCheck(roof, 'forward', kerabBeforeSnap)
        logger.log('[KERAB-SIMPLE] attr-only fallback')
        return
      }
    }

    // [2240 KERAB-REVERT 2026-05-19] 대전제 1 역방향: 케라바→처마 변환 시 케라바 중점→apex ridge 가 존재하면
    // ridge 1개 제거 + apex→c1, apex→c2 hip 2개 생성으로 처리하고 기존 rebuild 흐름은 건너뜀.
    // ridge-at-mid 없으면 forward 가 attribute-only 였던 케이스 → 속성만 EAVES 로 토글.
    if (typeRef.current === TYPES.EAVES && radioTypeRef.current === '1' && target.attributes?.type === LINE_TYPE.WALLLINE.GABLE) {
      const roof = canvas
        .getObjects()
        .find((o) => o.name === POLYGON_TYPE.ROOF && !o.isFixed && o.id === target.attributes?.roofId)
      if (roof && Array.isArray(roof.innerLines) && Array.isArray(roof.points)) {
        // [KERAB-RULE-CHECK 2026-06-10] revert 변환 전(게이블 출폭) 상태를 R4 anchor 기준으로 캡처.
        const kerabRevertBeforeSnap = snapshotKerabState(roof)
        const c1 = nearestRoofPoint(roof, { x: target.x1, y: target.y1 })
        const c2 = nearestRoofPoint(roof, { x: target.x2, y: target.y2 })
        if (c1 && c2) {
          // [KERAB-REVERT-EXTEND-45 2026-06-05] 룰: hip 은 wallbaseLine 의 45° (skeleton 이론 부정 X).
          //   본체 inner endpoint = snapshot 그대로 (apex 위치).
          //   본체 outer endpoint = wL 코너에서 45° 방향(snapshot 의 inner→outer 방향) 으로 ray cast → 새 rL 변 hit point.
          //   wL 코너는 라인이 지나가는 transit point 일 뿐 data endpoint 아님.
          //   skeleton-utils.js drawBaselineToRooflineHelpers (line 770~880) 와 동일 방식.
          const surgicalAfter = () => {
            // [KERAB-REVERT-EXTEND-45 2026-06-05] 룰: 출폭 변경 시 wallbaseLine 안의 내부라인 끝점 불변.
            //   surgical 의 CORNER-SHORTCUT(roofLine 코너로 스냅)·SHRINK-TRIM(__shrinkOrig 복원) 은 룰 위반 →
            //   skipInnerLines:true 로 roof.points + matchingRL/prev/nextRL + edge 객체만 갱신.
            //   증상: (1) b1 ray-cast 후 b4 출폭조정 → SHRINK-TRIM restore 가 b1 hip 을 snapshot 좌표로 리셋
            //         (2) CORNER-SHORTCUT 가 hip outer endpoint 를 새 roofLine 코너로 강제 스냅.
            //   hip 의 outer endpoint 만 아래 ray-cast 로 새 rL 변까지 45° 확장한다.
            // [KERAB-REVERT-VERTEX-EXTEND 2026-06-11] surgical 은 roof.points 를 새 출폭으로 갱신하므로,
            //   게이블 코너 hip 판정용으로 이동 전 옛 폴리곤 꼭짓점을 미리 스냅샷한다.
            const oldPolyPoints = (Array.isArray(roof.points) ? roof.points : []).map((p) => ({ x: p.x, y: p.y }))
            if (roof) applyTargetOffsetSurgical(target, attributes?.offset ?? 0, { skipInnerLines: true })
            // [45-UNIFY 2026-06-15] reclick 과 동일한 extendKerabHipsTo45 사용 (revert 가드 on):
            //   forward 가 붙여둔 __kerabRevertOuterWhich/Side 플래그로 marks 를 만든 뒤, surgical *후*
            //   새 폴리곤에 대해 outerShared/outerOnVertex 가드를 적용해 45° 확장. 플래그는 사용 후 정리.
            const marks = []
            for (const il of roof.innerLines || []) {
              if (!il || !il.__kerabRevertOuterWhich) continue
              marks.push({ il, which: il.__kerabRevertOuterWhich, side: il.__kerabRevertOuterSide })
            }
            extendKerabHipsTo45(target, roof, marks, { useRevertGuards: true, oldPolyPoints })
            for (const m of marks) {
              delete m.il.__kerabRevertOuterWhich
              delete m.il.__kerabRevertOuterSide
            }
            runKerabRuleCheck(roof, 'revert', kerabRevertBeforeSnap)
          }
          // [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 })
            // [KERAB-TYPE-EAVES-EDGEMOVE 2026-06-11] TYPE 출신 revert(케라바→처마)도 출폭이 바뀌므로 옛 변 위
            //   면경계선이 따라와야 한다(안 그러면 rLine 겹침). apex(= kLine 의 cMid 반대 끝) + edgeIdx 미리 캡처.
            const _kMid = { x: (c1.x + c2.x) / 2, y: (c1.y + c2.y) / 2 }
            const _kApex =
              Math.hypot(kLineRidge.x1 - _kMid.x, kLineRidge.y1 - _kMid.y) >= Math.hypot(kLineRidge.x2 - _kMid.x, kLineRidge.y2 - _kMid.y)
                ? { x: kLineRidge.x1, y: kLineRidge.y1 }
                : { x: kLineRidge.x2, y: kLineRidge.y2 }
            const _kTol = 0.5
            const _kNP = roof.points.length
            let _kEdgeIdx = -1
            for (let i = 0; i < _kNP; i++) {
              const p = roof.points[i]
              const q = roof.points[(i + 1) % _kNP]
              if (
                (Math.hypot(p.x - c1.x, p.y - c1.y) < _kTol && Math.hypot(q.x - c2.x, q.y - c2.y) < _kTol) ||
                (Math.hypot(p.x - c2.x, p.y - c2.y) < _kTol && Math.hypot(q.x - c1.x, q.y - c1.y) < _kTol)
              ) {
                _kEdgeIdx = i
                break
              }
            }
            const ok = applyKerabRevertPattern(roof, target, c1, c2, { ridge: kLineRidge, apex: null })
            if (ok) {
              surgicalAfter()
              moveStaleEdgeInnerLines(roof, c1, c2, _kEdgeIdx, _kApex)
              extendTypeGableHipsStraightToRoofLine(roof, target, _kApex)
            }
            logger.log('[KERAB-REVERT] applied (kLineOnly via targetId) ' + JSON.stringify({ ok, edgeIdx: _kEdgeIdx, apex: _kApex }))
            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)
          // [KERAB-TYPE-EAVES 2026-06-11] TYPE 출신(native 마루·토글 이력 없음) 은 전용 함수로 분기.
          //   기존 폴백(applyKerabRevertPattern single-ridge)은 apex=마루 far-end + 마루 전체 삭제라
          //   L/2 setback·마루 단축 규칙과 어긋남. native 마루일 때만 가로채고 나머지는 그대로.
          //   불변식 "마루는 roofLine 까지" → native 마루 끝점은 wLine 중점이 아니라 roofLine 코너(c1/c2)
          //   중점에 있다. 그래서 파인더는 c1/c2 기준 (tEnd 기준 ridgeAtMid 는 出幅>0 이면 null).
          const typeRidge = ridgeAtMid || findRidgeAtMidpoint(roof, c1, c2)
          if (ENABLE_TYPE_GABLE_TO_EAVES && typeRidge && isNativeTypeRidge(typeRidge.ridge)) {
            target.set({ attributes })
            // 변환 전 옛 roofLine 변(c1↔c2) 의 polygon 인덱스 캡처 — surgical 후 새 코너 좌표 매핑용.
            const _EDGE_TOL = 0.5
            const _NP = roof.points.length
            let _edgeIdx = -1
            for (let i = 0; i < _NP; i++) {
              const p = roof.points[i]
              const q = roof.points[(i + 1) % _NP]
              if (
                (Math.hypot(p.x - c1.x, p.y - c1.y) < _EDGE_TOL && Math.hypot(q.x - c2.x, q.y - c2.y) < _EDGE_TOL) ||
                (Math.hypot(p.x - c2.x, p.y - c2.y) < _EDGE_TOL && Math.hypot(q.x - c1.x, q.y - c1.y) < _EDGE_TOL)
              ) {
                _edgeIdx = i
                break
              }
            }
            const apexRes = applyTypeGableToEavesPattern(roof, target, typeRidge.ridge)
            if (apexRes) {
              surgicalAfter()
              // [KERAB-TYPE-EAVES-EDGEMOVE 2026-06-11] surgicalAfter 는 skipInnerLines:true 라 옛 roofLine
              //   변 위에 놓인 normal inner line(L자 면경계)이 안 따라온다 → 옛 위치에 ghost("한개 더").
              //   변은 出幅만큼 평행이동(delta)했으므로, 옛 변 위 끝점만 동일 delta 로 평행이동(= NORMAL-ABS 동치).
              //   단, cMid(변 중점)에 걸린 비-collinear 선의 끝점은 apex 로 수렴해야 한다(힙 사이 마루 금지).
              //   케라바패턴 라인(내 hip)은 surgicalAfter 의 ray-cast 가 이미 처리 → 제외.
              moveStaleEdgeInnerLines(roof, c1, c2, _edgeIdx, apexRes)
              // [KERAB-TYPE-EAVES-STRAIGHT 2026-06-12] apex 는 벽기준 고정. 힙을 벽교점 방향 45° 그대로 roofLine 까지 직선 연장.
              extendTypeGableHipsStraightToRoofLine(roof, target, apexRes)
              // [KERAB-TYPE-EAVES-HIPROOF 2026-06-12] 양쪽 박공이 모두 처마가 되어 완전 寄棟이면,
              //   세로 apex 2개·X자 교차를 버리고 힙·마루 규칙(R1/R2/R3)으로 가로 마루 + 절삭 힙 4개로 재구성.
              reconstructHipRoofRidgeIfComplete(roof)
              // [KERAB-RULE-CHECK 2026-06-12] 모든 라인변경(재구성 포함)이 끝난 최종 형상을 규칙으로 검증.
              //   surgicalAfter 내부 검사는 재구성 전 상태라, 최종 상태는 여기서 한 번 더 본다.
              runKerabRuleCheck(roof, 'type-eaves', kerabRevertBeforeSnap)
            }
            logger.log('[KERAB-TYPE-EAVES] branch ' + JSON.stringify({ ok: !!apexRes, c1, c2, edgeIdx: _edgeIdx }))
            if (apexRes) return
          }
          if (ridgeAtMid) {
            target.set({ attributes })
            const ok = applyKerabRevertPattern(roof, target, c1, c2, ridgeAtMid)
            if (ok) surgicalAfter()
            logger.log('[KERAB-REVERT] applied ' + JSON.stringify({ ok, c1, c2, apex: ridgeAtMid.apex }))
            if (ok) return
          }
          // [KERAB-VALLEY-EAVES-RULE1 2026-06-16] A/B타입 native 케라바 변(스냅샷·native마루·kLine 전부 없음)의
          //   첫 처마 변환 "씨앗". 양 코너에서 폴리곤 안쪽 45° 힙 2개를 그려 각자 첫 교차(다른 inner line 또는
          //   상대편 roofLine)까지 뻗는다. R3 절삭만 — 반사·힙 사이 마루 생성은 보류(다각형 넓이 의존, 추후 결정).
          //   出幅은 일반 라인변경과 동일하게 기존 surgical 로 처리. 게이트: 변 위에 collinear 게이블벽 inner line
          //   이 실재할 때만(= 진짜 케라바 기하). 없으면 아래 attr-only 폴백.
          {
            const EDGE_TOL = 0.5
            const NP = roof.points.length
            let edgeIdx = -1
            for (let i = 0; i < NP; i++) {
              const p = roof.points[i]
              const q = roof.points[(i + 1) % NP]
              if (
                (Math.hypot(p.x - c1.x, p.y - c1.y) < EDGE_TOL && Math.hypot(q.x - c2.x, q.y - c2.y) < EDGE_TOL) ||
                (Math.hypot(p.x - c2.x, p.y - c2.y) < EDGE_TOL && Math.hypot(q.x - c1.x, q.y - c1.y) < EDGE_TOL)
              ) {
                edgeIdx = i
                break
              }
            }
            // 변환되는 게이블 변의 "게이블벽" 전체를 제거한다(사용자 확정 2026-06-16).
            //   게이블벽 = 변 c1↔c2(roofLine쪽) 또는 옛 出幅쪽 outerLine 과 같은 무한직선 위의 HIP 세그먼트.
            //   변이 게이블일 때만 존재한 구조 → eaves 가 되면 소멸. 한 직선이 ridge 에 의해 여러 세그먼트로
            //   쪼개져 변 구간 밖(아래)까지 뻗기도 한다(예: H-9 = 변 아래 연장). 따라서 변 구간 겹침이 아니라
            //   "무한직선 동일선상(양 끝점 수직거리<1)" 전체를 게이블벽으로 본다 — i5(변 위) + i10(변 아래) 모두.
            //   이 전체 제거가 ridge(RG-2)의 anchor 를 끊어, 뒤의 dangling 정리에서 RG-2 까지 연쇄 제거된다.
            const isCollinearWith = (l, A, B) => {
              const dx = B.x - A.x
              const dy = B.y - A.y
              const lenSq = dx * dx + dy * dy || 1
              const perp = (px, py) => {
                const t = ((px - A.x) * dx + (py - A.y) * dy) / lenSq
                return Math.hypot(px - (A.x + t * dx), py - (A.y + t * dy))
              }
              return perp(l.x1, l.y1) < 1.0 && perp(l.x2, l.y2) < 1.0
            }
            // 옛 出幅쪽 수직벽 식별용 — surgical 전 target outerLine 끝점(=出幅 위치) 캡처.
            const tA = { x: target.x1, y: target.y1 }
            const tB = { x: target.x2, y: target.y2 }
            // 게이블벽(HIP)만 직접 제거. native 마루(RIDGE)는 여기서 보존하되, anchor 가 끊겨 dangling 이
            //   되는 ridge(RG-2)는 뒤의 cleanupDangling 이 연쇄 제거한다(사용자 확정 2026-06-16).
            const gableWallLines = (roof.innerLines || []).filter(
              (l) =>
                l && l.visible !== false && l.name === LINE_TYPE.SUBLINE.HIP && (isCollinearWith(l, c1, c2) || isCollinearWith(l, tA, tB)),
            )
            if (edgeIdx >= 0 && gableWallLines.length > 0) {
              target.set({ attributes })
              // 1) 옛 게이블벽 라인 제거 + 짝 확장 helper(extensionLine) 동반 제거.
              for (const gw of gableWallLines) {
                removeLine(gw)
                removeOrphanExtensionsForHip(gw)
              }
              roof.innerLines = roof.innerLines.filter((l) => !gableWallLines.includes(l))
              // 2) 出幅 반영 (일반 라인변경과 동일 — 기존 surgical, inner line 불변).
              applyTargetOffsetSurgical(target, attributes?.offset ?? 0, { skipInnerLines: true })
              // 3) 새 roofLine 코너 (인덱스는 surgical 후에도 안정).
              const pts = roof.points
              const nA = pts[edgeIdx]
              const nB = pts[(edgeIdx + 1) % NP]
              const newC1IsA = Math.hypot(nA.x - c1.x, nA.y - c1.y) <= Math.hypot(nA.x - c2.x, nA.y - c2.y)
              const idxA = newC1IsA ? edgeIdx : (edgeIdx + 1) % NP
              const idxB = newC1IsA ? (edgeIdx + 1) % NP : edgeIdx
              const newC1 = pts[idxA]
              const newC2 = pts[idxB]
              // 폴리곤 중심 (inward 판정용).
              let cenX = 0
              let cenY = 0
              for (const p of pts) {
                cenX += p.x
                cenY += p.y
              }
              cenX /= pts.length || 1
              cenY /= pts.length || 1
              // 코너의 두 이웃 변 방향 → 폴리곤 안쪽 45° 이등분선 (convex/reflex 모두 안쪽으로 보정).
              const inwardDir = (idx) => {
                const C = pts[idx]
                const prev = pts[(idx - 1 + NP) % NP]
                const next = pts[(idx + 1) % NP]
                const n1 = Math.hypot(prev.x - C.x, prev.y - C.y) || 1
                const n2 = Math.hypot(next.x - C.x, next.y - C.y) || 1
                let dx = (prev.x - C.x) / n1 + (next.x - C.x) / n2
                let dy = (prev.y - C.y) / n1 + (next.y - C.y) / n2
                const dl = Math.hypot(dx, dy)
                if (dl < 1e-6) {
                  // 일직선(180°) — 변 수직 안쪽 법선.
                  dx = -(next.y - C.y) / n2
                  dy = (next.x - C.x) / n2
                } else {
                  dx /= dl
                  dy /= dl
                }
                if (dx * (cenX - C.x) + dy * (cenY - C.y) < 0) {
                  dx = -dx
                  dy = -dy
                }
                return { x: dx, y: dy }
              }
              // corner 에서 dir 로 ray → 첫 교차(roofLine 변 + 기존 inner line), 자기 변(t≈0) 제외.
              const rayFirstHit = (P, dir) => {
                const segHit = (A, B) => {
                  const ex = B.x - A.x
                  const ey = B.y - A.y
                  const den = dir.x * ey - dir.y * ex
                  if (Math.abs(den) < 1e-9) return Infinity
                  const t = ((A.x - P.x) * ey - (A.y - P.y) * ex) / den
                  const u = ((A.x - P.x) * dir.y - (A.y - P.y) * dir.x) / den
                  if (t > 1.0 && u >= -1e-6 && u <= 1 + 1e-6) return t
                  return Infinity
                }
                let best = Infinity
                let hit = null
                let hitLine = null
                for (let i = 0; i < NP; i++) {
                  const t = segHit(pts[i], pts[(i + 1) % NP])
                  if (t < best) {
                    best = t
                    hit = { x: P.x + dir.x * t, y: P.y + dir.y * t, line: null, kind: 'roofLine' }
                    hitLine = null
                  }
                }
                for (const il of roof.innerLines || []) {
                  if (!il || il.visible === false) continue
                  if (il.name !== LINE_TYPE.SUBLINE.HIP && il.name !== LINE_TYPE.SUBLINE.RIDGE) continue
                  const t = segHit({ x: il.x1, y: il.y1 }, { x: il.x2, y: il.y2 })
                  if (t < best) {
                    best = t
                    hit = { x: P.x + dir.x * t, y: P.y + dir.y * t, line: il, kind: il.name }
                    hitLine = il
                  }
                }
                return hit
              }
              const mkValleyHip = (corner, hit) => {
                const arr = [corner.x, corner.y, hit.x, hit.y]
                const sz = calcLinePlaneSize({ x1: arr[0], y1: arr[1], x2: arr[2], y2: arr[3] })
                const hip = new QLine(arr, {
                  parentId: roof.id,
                  fontSize: roof.fontSize,
                  stroke: '#1083E3',
                  strokeWidth: 3,
                  name: LINE_TYPE.SUBLINE.HIP,
                  textMode: roof.textMode,
                  attributes: { roofId: roof.id, type: LINE_TYPE.SUBLINE.HIP, planeSize: sz, actualSize: sz },
                })
                hip.lineName = 'kerabPatternHip'
                hip.startPoint = { x: hip.x1, y: hip.y1 }
                hip.endPoint = { x: hip.x2, y: hip.y2 }
                return hip
              }
              const addHipFrom = (corner, idx) => {
                const dir = inwardDir(idx)
                const hit = rayFirstHit(corner, dir)
                if (!hit) return { dir, hit: null, hip: null, hitLine: null, hitKind: null }
                const h = mkValleyHip(corner, hit)
                canvas.add(h)
                h.bringToFront()
                roof.innerLines.push(h)
                return { dir, hit, hip: h, hitLine: hit.line, hitKind: hit.kind }
              }
              // 임의 방향 ray 로 골짜기 힙 1개 생성(반사 힙용). 첫 교차까지.
              const drawHipRay = (from, dir) => {
                const hit = rayFirstHit(from, dir)
                if (!hit) return null
                const h = mkValleyHip(from, hit)
                canvas.add(h)
                h.bringToFront()
                roof.innerLines.push(h)
                return { hip: h, hit }
              }
              // 4) 게이블 구조 잔재 정리 — anchor(게이블벽 HIP) 제거로 dangling 이 된 HIP·확장라인(H-9 등)만 제거.
              //   ★ 마루(RIDGE)는 절대 제거하지 않는다 — dangling 이어도 보존(사용자 확정 2026-06-16:
              //     "마루를 지우면 안된다"). RIDGE 는 connectivity 판정에는 포함(다른 HIP 의 접합 대상)하되
              //     dangler 후보에서는 제외. VALLEY(골짜기확장)도 vExt 위에서 끝나는 정상 케이스라 제외.
              //   새 골짜기 힙 그리기 *전에* 수행해야 raycast 가 깨끗한 기하에 닿아 SHORT-hit 를 피한다.
              const cleanupDangling = () => {
                const TOL = 2.0
                const rpts = roof.points || []
                const distToSeg = (p, a, b) => {
                  const ex = b.x - a.x
                  const ey = b.y - a.y
                  const l2 = ex * ex + ey * ey || 1
                  let t = ((p.x - a.x) * ex + (p.y - a.y) * ey) / l2
                  t = Math.max(0, Math.min(1, t))
                  return Math.hypot(p.x - (a.x + t * ex), p.y - (a.y + t * ey))
                }
                const minEdgeDist = (pt) => {
                  let m = Infinity
                  for (let i = 0, j = rpts.length - 1; i < rpts.length; j = i++) {
                    const d = distToSeg(pt, rpts[j], rpts[i])
                    if (d < m) m = d
                  }
                  return m
                }
                const removed = []
                for (let iter = 0; iter < 12; iter++) {
                  const surv = (roof.innerLines || []).filter(
                    (l) =>
                      l &&
                      l.visible !== false &&
                      (l.name === LINE_TYPE.SUBLINE.HIP || l.name === LINE_TYPE.SUBLINE.RIDGE || l.name === LINE_TYPE.SUBLINE.VALLEY),
                  )
                  const ends = []
                  for (const l of surv) {
                    ends.push({ x: l.x1, y: l.y1, line: l })
                    ends.push({ x: l.x2, y: l.y2, line: l })
                  }
                  // 마루(RIDGE)·VALLEY 는 dangling 이어도 제거 금지 — HIP 만 제거 후보.
                  const dangler = surv.find((l) => {
                    if (l.name !== LINE_TYPE.SUBLINE.HIP) return false
                    for (const p of [
                      { x: l.x1, y: l.y1 },
                      { x: l.x2, y: l.y2 },
                    ]) {
                      const onBoundary = rpts.length >= 3 && minEdgeDist(p) <= TOL
                      const shared = ends.some((e) => e.line !== l && Math.hypot(e.x - p.x, e.y - p.y) < TOL)
                      if (!onBoundary && !shared) return true
                    }
                    return false
                  })
                  if (!dangler) break
                  removeLine(dangler)
                  roof.innerLines = roof.innerLines.filter((l) => l !== dangler)
                  removeOrphanExtensionsForHip(dangler)
                  removed.push({ n: dangler.name, ln: dangler.lineName || '-', x1: Math.round(dangler.x1), y1: Math.round(dangler.y1), x2: Math.round(dangler.x2), y2: Math.round(dangler.y2) })
                }
                return removed
              }
              const cleaned = cleanupDangling()
              const resA = addHipFrom(newC1, idxA)
              const resB = addHipFrom(newC2, idxB)
              // 5b) 마루(RIDGE) 끝점 상호작용 — anchor 잃은 끝점 해소(사용자 확정 2026-06-16: "RG1(h8) 확장, RG2(b5) 절삭").
              //   규칙: 마루는 절대 삭제 안 함. anchor 잃은(=경계 미접촉 + 다른 선과 미공유) 끝점은
              //     · 새 골짜기 힙이 그 마루를 가로지르면 → 교점에서 절삭(trim, 끝점을 교점으로 당김)
              //     · 가로지르는 힙이 없으면 → 끝점 방향으로 roofLine/다음 라인까지 확장(extend)
              const resolveRidgeEndpoints = () => {
                const TOL = 2.0
                const rpts = roof.points || []
                const newHips = [resA, resB].map((r) => r && r.hip).filter(Boolean)
                const distToSeg = (p, a, b) => {
                  const ex = b.x - a.x
                  const ey = b.y - a.y
                  const l2 = ex * ex + ey * ey || 1
                  let t = ((p.x - a.x) * ex + (p.y - a.y) * ey) / l2
                  t = Math.max(0, Math.min(1, t))
                  return Math.hypot(p.x - (a.x + t * ex), p.y - (a.y + t * ey))
                }
                const minEdgeDist = (pt) => {
                  let m = Infinity
                  for (let i = 0, j = rpts.length - 1; i < rpts.length; j = i++) {
                    const d = distToSeg(pt, rpts[j], rpts[i])
                    if (d < m) m = d
                  }
                  return m
                }
                // 선분 교차(내부 교점만, 끝점 t∈(eps,1-eps))
                const segInt = (p1, p2, p3, p4) => {
                  const d1x = p2.x - p1.x
                  const d1y = p2.y - p1.y
                  const d2x = p4.x - p3.x
                  const d2y = p4.y - p3.y
                  const den = d1x * d2y - d1y * d2x
                  if (Math.abs(den) < 1e-9) return null
                  const t = ((p3.x - p1.x) * d2y - (p3.y - p1.y) * d2x) / den
                  const u = ((p3.x - p1.x) * d1y - (p3.y - p1.y) * d1x) / den
                  if (t <= 1e-6 || t >= 1 - 1e-6 || u <= 1e-6 || u >= 1 - 1e-6) return null
                  return { x: p1.x + t * d1x, y: p1.y + t * d1y }
                }
                // 절삭 전용: 마루(rp→rq)는 내부만, 힙(ha→hb)은 끝점 닿음(T자)까지 허용
                const segIntTrim = (rp, rq, ha, hb) => {
                  const d1x = rq.x - rp.x
                  const d1y = rq.y - rp.y
                  const d2x = hb.x - ha.x
                  const d2y = hb.y - ha.y
                  const den = d1x * d2y - d1y * d2x
                  if (Math.abs(den) < 1e-9) return null
                  const t = ((ha.x - rp.x) * d2y - (ha.y - rp.y) * d2x) / den
                  const u = ((ha.x - rp.x) * d1y - (ha.y - rp.y) * d1x) / den
                  if (t <= 1e-6 || t >= 1 - 1e-6) return null // 마루 내부만
                  if (u <= 1e-6 || u >= 1 + 1e-3) return null // 힙 끝점 닿음 허용
                  return { x: rp.x + t * d1x, y: rp.y + t * d1y }
                }
                // 힙의 먼 끝(코너=startPoint 반대쪽 endPoint)을 교차점으로 절삭 + 라벨 갱신
                const trimHipFarEnd = (hip, cross) => {
                  hip.set({ x2: cross.x, y2: cross.y })
                  hip.endPoint = { x: cross.x, y: cross.y }
                  const nsz = calcLinePlaneSize({ x1: hip.x1, y1: hip.y1, x2: cross.x, y2: cross.y })
                  hip.attributes = { ...hip.attributes, planeSize: nsz, actualSize: nsz }
                  hip.setLength?.()
                  hip.setCoords?.()
                  hip.addLengthText?.()
                }
                const ridges = (roof.innerLines || []).filter((l) => l && l.visible !== false && l.name === LINE_TYPE.SUBLINE.RIDGE)
                const allEnds = []
                for (const l of (roof.innerLines || []).filter(
                  (l) =>
                    l &&
                    l.visible !== false &&
                    (l.name === LINE_TYPE.SUBLINE.HIP || l.name === LINE_TYPE.SUBLINE.RIDGE || l.name === LINE_TYPE.SUBLINE.VALLEY),
                )) {
                  allEnds.push({ x: l.x1, y: l.y1, line: l })
                  allEnds.push({ x: l.x2, y: l.y2, line: l })
                }
                const touched = []
                for (const rg of ridges) {
                  const endsOf = [
                    { p: { x: rg.x1, y: rg.y1 }, q: { x: rg.x2, y: rg.y2 }, set: (pt) => rg.set({ x1: pt.x, y1: pt.y }) },
                    { p: { x: rg.x2, y: rg.y2 }, q: { x: rg.x1, y: rg.y1 }, set: (pt) => rg.set({ x2: pt.x, y2: pt.y }) },
                  ]
                  for (const { p, q, set } of endsOf) {
                    const onBoundary = rpts.length >= 3 && minEdgeDist(p) <= TOL
                    const shared = allEnds.some((e) => e.line !== rg && Math.hypot(e.x - p.x, e.y - p.y) < TOL)
                    if (onBoundary || shared) continue // anchor 있음 → 그대로
                    // (a) 가로지르는 힙 탐색 → 절삭
                    let trimPt = null
                    let trimD = Infinity
                    for (const h of newHips) {
                      const ip = segIntTrim(p, q, { x: h.x1, y: h.y1 }, { x: h.x2, y: h.y2 })
                      if (!ip) continue
                      const d = Math.hypot(ip.x - p.x, ip.y - p.y)
                      if (d < trimD) {
                        trimD = d
                        trimPt = ip
                      }
                    }
                    if (trimPt) {
                      set(trimPt)
                      touched.push({ act: 'trim', ln: rg.lineName || '-', to: { x: Math.round(trimPt.x), y: Math.round(trimPt.y) } })
                      continue
                    }
                    // (b) 확장 — q→p 방향으로 첫 교차(roofLine 변 + 다른 inner line, 자기 제외)까지
                    const dx = p.x - q.x
                    const dy = p.y - q.y
                    const mag = Math.hypot(dx, dy) || 1
                    const ux = dx / mag
                    const uy = dy / mag
                    const castHit = (A, B) => {
                      const ip = segInt({ x: q.x, y: q.y }, { x: q.x + ux * 1e5, y: q.y + uy * 1e5 }, A, B)
                      if (!ip) return Infinity
                      const t = (ip.x - p.x) * ux + (ip.y - p.y) * uy
                      return t > 1e-3 ? t : Infinity
                    }
                    let best = Infinity
                    let hit = null
                    let hitLine = null
                    for (let i = 0; i < rpts.length; i++) {
                      const A = rpts[i]
                      const B = rpts[(i + 1) % rpts.length]
                      const t = castHit(A, B)
                      if (t < best) {
                        best = t
                        hit = { x: q.x + ux * (mag + t), y: q.y + uy * (mag + t) }
                        hitLine = null // roofLine 변
                      }
                    }
                    for (const il of roof.innerLines || []) {
                      if (!il || il === rg || il.visible === false) continue
                      if (il.name !== LINE_TYPE.SUBLINE.HIP && il.name !== LINE_TYPE.SUBLINE.RIDGE) continue
                      const t = castHit({ x: il.x1, y: il.y1 }, { x: il.x2, y: il.y2 })
                      if (t < best) {
                        best = t
                        hit = { x: q.x + ux * (mag + t), y: q.y + uy * (mag + t) }
                        hitLine = il
                      }
                    }
                    if (hit) {
                      set(hit)
                      touched.push({ act: 'extend', ln: rg.lineName || '-', to: { x: Math.round(hit.x), y: Math.round(hit.y) } })
                      // 확장한 마루가 힙 몸통에 닿으면 → 그 힙의 먼 끝(코너 반대쪽)을 교차점으로 절삭(힙은 마루를 넘지 못함)
                      if (hitLine && hitLine.name === LINE_TYPE.SUBLINE.HIP) {
                        trimHipFarEnd(hitLine, hit)
                        touched.push({ act: 'trim-hip', ln: hitLine.lineName || '-', to: { x: Math.round(hit.x), y: Math.round(hit.y) } })
                      }
                    }
                  }
                }
                return touched
              }
              const ridgeOps = resolveRidgeEndpoints()
              // 5c) Y 반사 힙 — 새 힙이 *기존 마루(RIDGE)에 직접 부딪힌* 경우만(=raycast hit 가 RIDGE),
              //   그 마루를 대칭축으로 반대편 면에 반사 힙 1개 생성(R7: 마루+hip 교점 반사).
              //   ★ 마루를 *확장*해서 만난 힙(hit 가 roofLine 이던 resA)은 Y 아님 → 반사 안 함(사용자 확정 2026-06-16).
              const reflectOps = []
              for (const res of [resA, resB]) {
                if (!res || !res.hip || res.hitKind !== LINE_TYPE.SUBLINE.RIDGE || !res.hitLine) continue
                const M = { x: res.hit.x, y: res.hit.y }
                const rg = res.hitLine
                const rlen = Math.hypot(rg.x2 - rg.x1, rg.y2 - rg.y1) || 1
                const rx = (rg.x2 - rg.x1) / rlen
                const ry = (rg.y2 - rg.y1) / rlen
                // 반사 방향 = reflect(역입사) 마루축 기준. w=역입사(코너→M 반대), v_ref=2(w·r̂)r̂ - w
                const wx = -res.dir.x
                const wy = -res.dir.y
                const dot = wx * rx + wy * ry
                const refDir = { x: 2 * dot * rx - wx, y: 2 * dot * ry - wy }
                const drawn = drawHipRay(M, refDir)
                if (drawn) {
                  reflectOps.push({ from: { x: Math.round(M.x), y: Math.round(M.y) }, to: { x: Math.round(drawn.hit.x), y: Math.round(drawn.hit.y) } })
                }
              }
              removeKerabHalfLabels(target.id)
              hideOriginalLengthText(target.id, false)
              canvas.renderAll()
              runKerabRuleCheck(roof, 'valley-eaves-rule1', kerabRevertBeforeSnap)
              logger.log(
                '[KERAB-VALLEY-EAVES-RULE1] applied ' +
                  JSON.stringify({ edgeIdx, removed: gableWallLines.length, cleaned, newC1, newC2, resA, resB, ridgeOps, reflectOps }),
              )
              return
            }
          }
          // [2240 KERAB-ATTR-ONLY 2026-05-19] ridge-at-mid 없음 → forward 가 attribute-only 였음 → 동일 대칭으로 속성만 토글
          target.set({ attributes })
          applyKerabAttributeOnlyPattern()
          surgicalAfter()
          logger.log('[KERAB-ATTR-ONLY] applied (revert) ' + JSON.stringify({ c1, c2 }))
          return
        }
      }
    }

    target.set({
      attributes,
    })

    const roofBases = canvas?.getObjects().filter((obj) => obj.name === POLYGON_TYPE.ROOF && !obj.isFixed)

    // moveLine 속성 및 이동된 baseLines 좌표 보존
    const savedMoveProps = {}
    const savedBaseLineCoords = {}
    roofBases.forEach((roof) => {
      if (roof.moveFlowLine || roof.moveUpDown) {
        const wall = canvas.getObjects().find((obj) => obj.name === POLYGON_TYPE.WALL && obj.attributes?.roofId === roof.id)
        savedMoveProps[roof.id] = {
          moveFlowLine: roof.moveFlowLine,
          moveUpDown: roof.moveUpDown,
          moveDirect: roof.moveDirect,
          moveSelectLine: roof.moveSelectLine,
          movePosition: roof.movePosition,
        }
        if (wall?.baseLines) {
          savedBaseLineCoords[roof.id] = wall.baseLines.map((bl) => ({
            x1: bl.x1, y1: bl.y1, x2: bl.x2, y2: bl.y2,
            startPoint: bl.startPoint ? { ...bl.startPoint } : undefined,
            endPoint: bl.endPoint ? { ...bl.endPoint } : undefined,
          }))
        }
      }
      roof.innerLines.forEach((line) => {
        removeLine(line)
      })
      canvas.remove(roof)
    })

    const wallLines = canvas.getObjects().filter((obj) => obj.name === POLYGON_TYPE.WALL)
    const removeTargets = canvas.getObjects().filter((obj) => obj.name === 'pitchText' || obj.name === 'lengthText')
    removeTargets.forEach((obj) => {
      canvas.remove(obj)
    })
    wallLines.forEach((wallLine) => {
      addPitchTextsByOuterLines()
      const roof = drawRoofPolygon(wallLine)
      // moveLine 속성 복원
      const saved = savedMoveProps[roof.id]
      if (saved) {
        // 이동된 baseLines 좌표 복원 (drawRoofPolygon이 리셋한 것을 되돌림)
        const savedBL = savedBaseLineCoords[roof.id]
        if (savedBL && roof.wall?.baseLines) {
          roof.wall.baseLines.forEach((bl, i) => {
            if (!savedBL[i]) return
            bl.set({
              x1: savedBL[i].x1, y1: savedBL[i].y1,
              x2: savedBL[i].x2, y2: savedBL[i].y2,
              startPoint: savedBL[i].startPoint,
              endPoint: savedBL[i].endPoint,
            })
          })
        }
        // drawHelpLine 중에는 moveLine 미적용 (baseLines에 이미 반영됨)
        // drawHelpLine 후 moveLine 속성 복원
        canvas?.renderAll()
        roof.drawHelpLine(settingModalFirstOptions)
        Object.assign(roof, saved)
      } else {
        canvas?.renderAll()
        roof.drawHelpLine(settingModalFirstOptions)
      }
    })

    wallLines.forEach((wallLine) => {
      convertPolygonToLines(wallLine)
    })

    canvas.renderAll()

    addCanvasMouseEventListener('mouse:over', mouseOverEvent)
    addCanvasMouseEventListener('mouse:down', mouseDownEvent)
  }

  // polygon의 lines를 이용해 line으로 변경하기
  const convertPolygonToLines = (polygon) => {
    polygon.set({ visible: false })
    polygon.lines.forEach((line) => {
      line.set({ visible: true })
      line.set({ selectable: true })
      line.set({ strokeWidth: 5 })
      line.set({ parent: polygon })
      line.bringToFront()
    })

    // canvas objects에서 polygon.lines를 제외한 다른 line의 selectable을 false로 변경
    canvas
      .getObjects()
      .filter((obj) => obj.name !== 'outerLine' && obj.type === 'QLine')
      .forEach((obj) => {
        obj.set({ selectable: false })
      })

    canvas?.renderAll()
  }

  // 다시 다각형으로 변경하기
  const convertLinesToPolygon = (polygon) => {
    polygon.set({ visible: true })
    polygon.lines.forEach((line) => {
      line.set({ visible: false })
      // line.set({ selectable: false })
    })

    canvas?.renderAll()
  }

  // [2240 KERAB-OFFSET-SURGICAL 2026-05-27] 본체는 `@/util/kerab-offset-surgical` 로 분리.
  //   고객 회귀 확인을 위한 토글 — ENABLE_KERAB_OFFSET_SURGICAL false 면 즉시 false 반환.
  const applyTargetOffsetSurgical = (target, newOffset, options) => {
    if (!ENABLE_KERAB_OFFSET_SURGICAL) return false
    return applyKerabOffsetSurgical(canvas, target, newOffset, options)
  }


  // [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

  // outerLine 끝점(벽 좌표)을 가장 가까운 roof.points 코너(offset 적용 좌표)로 스냅
  const nearestRoofPoint = (roof, point) => {
    if (!Array.isArray(roof.points) || roof.points.length === 0) return null
    let best = roof.points[0]
    let bestD = (best.x - point.x) ** 2 + (best.y - point.y) ** 2
    for (let i = 1; i < roof.points.length; i++) {
      const p = roof.points[i]
      const d = (p.x - point.x) ** 2 + (p.y - point.y) ** 2
      if (d < bestD) {
        bestD = d
        best = p
      }
    }
    return { x: best.x, y: best.y }
  }

  const findHipsAtPoint = (roof, point) => {
    return roof.innerLines.filter((il) => {
      if (!il || il.name !== LINE_TYPE.SUBLINE.HIP) return false
      return isSamePt({ x: il.x1, y: il.y1 }, point) || isSamePt({ x: il.x2, y: il.y2 }, point)
    })
  }

  const otherEndOfHip = (hip, corner) => {
    const a = { x: hip.x1, y: hip.y1 }
    const b = { x: hip.x2, y: hip.y2 }
    return isSamePt(a, corner) ? b : a
  }

  const findHipPairWithSharedApex = (hipsAtP1, p1, hipsAtP2, p2) => {
    for (const hA of hipsAtP1) {
      const apexA = otherEndOfHip(hA, p1)
      for (const hB of hipsAtP2) {
        if (hB === hA) continue
        const apexB = otherEndOfHip(hB, p2)
        if (isSamePt(apexA, apexB)) return { hA, hB, apex: apexA }
      }
    }
    return null
  }

  // [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)
      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) {
        if (hB === hA) continue
        const oB = otherEndOfHip(hB, p2)
        const dBx = oB.x - p2.x
        const dBy = oB.y - p2.y
        const denom = dAx * dBy - dAy * dBx
        if (Math.abs(denom) < 1e-6) continue // 평행 → 영원히 못 만남
        const px = p2.x - p1.x
        const py = p2.y - p1.y
        const t = (px * dBy - py * dBx) / denom
        const s = (px * dAy - py * dAx) / denom
        // [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 }
        return { hA, hB, apex }
      }
    }
    return null
  }

  // [2240 KERAB-JUNCTION-EXTENDED 2026-05-19] H-7/H-1 의 junction 너머 inner hip(H-4/H-2) 을 무한직선으로
  // 확장한 교점이 처마 중점 수선 위에 있으면 apex 채택. H-7/H-1 직접 확장이 가운데가 아닌
  // L-노치 등 복합 형상에서 사용. apex 검증 후 outer hip 제거 + inner hip 확장 + ridge.
  const findHipPairViaJunction = (roof, c1, c2) => {
    const hipsAtC1 = findHipsAtPoint(roof, c1)
    const hipsAtC2 = findHipsAtPoint(roof, c2)
    logger.log('[JUNCTION-DIAG] c1/c2 hips', { c1, c2, c1n: hipsAtC1.length, c2n: hipsAtC2.length })
    if (hipsAtC1.length === 0 || hipsAtC2.length === 0) return null
    const mid = { x: (c1.x + c2.x) / 2, y: (c1.y + c2.y) / 2 }
    const eVx = c2.x - c1.x
    const eVy = c2.y - c1.y
    const eMag = Math.hypot(eVx, eVy) || 1
    for (const outer1 of hipsAtC1) {
      const junction1 = otherEndOfHip(outer1, c1)
      const innersAtJ1 = findHipsAtPoint(roof, junction1).filter((h) => h !== outer1)
      logger.log('[JUNCTION-DIAG] j1', { junction1, innersAtJ1n: innersAtJ1.length })
      if (innersAtJ1.length === 0) continue
      for (const outer2 of hipsAtC2) {
        if (outer2 === outer1) continue
        const junction2 = otherEndOfHip(outer2, c2)
        if (isSamePt(junction1, junction2)) {
          logger.log('[JUNCTION-DIAG] junction shared → skip (shared-apex case)')
          continue
        }
        const innersAtJ2 = findHipsAtPoint(roof, junction2).filter((h) => h !== outer2)
        logger.log('[JUNCTION-DIAG] j2', { junction2, innersAtJ2n: innersAtJ2.length })
        if (innersAtJ2.length === 0) continue
        for (const inner1 of innersAtJ1) {
          const innerFar1 = otherEndOfHip(inner1, junction1)
          const dAx = innerFar1.x - junction1.x
          const dAy = innerFar1.y - junction1.y
          for (const inner2 of innersAtJ2) {
            if (inner2 === inner1) continue
            const innerFar2 = otherEndOfHip(inner2, junction2)
            const dBx = innerFar2.x - junction2.x
            const dBy = innerFar2.y - junction2.y
            const denom = dAx * dBy - dAy * dBx
            if (Math.abs(denom) < 1e-6) {
              logger.log('[JUNCTION-DIAG] parallel inner hips')
              continue
            }
            const px = junction2.x - junction1.x
            const py = junction2.y - junction1.y
            const t = (px * dBy - py * dBx) / denom
            const apex = { x: junction1.x + t * dAx, y: junction1.y + t * dAy }
            const dotEaves = ((apex.x - mid.x) * eVx + (apex.y - mid.y) * eVy) / eMag
            logger.log('[JUNCTION-DIAG] candidate', { apex, dotEaves, threshold: KERAB_TOL })
            if (Math.abs(dotEaves) > KERAB_TOL) continue
            logger.log('[JUNCTION-DIAG] MATCH')
            return { outer1, outer2, inner1, inner2, junction1, junction2, apex, innerFar1, innerFar2 }
          }
        }
      }
    }
    return null
  }

  // 재사용 가능한 검증 헬퍼 — ridge 의 한 끝점이 주어진 line 의 중점과 만나는지
  const midpointOfLine = (line) => ({ x: (line.x1 + line.x2) / 2, y: (line.y1 + line.y2) / 2 })
  const ridgeMeetsMidpointOf = (ridge, line) => {
    const mid = midpointOfLine(line)
    return isSamePt({ x: ridge.x1, y: ridge.y1 }, mid) || isSamePt({ x: ridge.x2, y: ridge.y2 }, mid)
  }

  // [2240 KERAB-CENTRAL-RIDGE 2026-05-19] 특정 좌표 점에서 끝나는 ridge 1개 찾기.
  // 케라바 패턴 ridge(kerabPatternRidge) 는 제외.
  const findRidgeEndingAt = (roof, point) => {
    for (const il of roof.innerLines) {
      if (!il || il.name !== LINE_TYPE.SUBLINE.RIDGE) continue
      if (il.lineName === 'kerabPatternRidge') continue
      if (isSamePt({ x: il.x1, y: il.y1 }, point)) return il
      if (isSamePt({ x: il.x2, y: il.y2 }, point)) return il
    }
    return null
  }

  // [2240 KERAB-CENTRAL-RIDGE 2026-05-19] 점이 선분 위에 있는지 (tol 안 거리).
  const isPointOnSegment = (p, seg, tol = KERAB_TOL) => {
    const dx = seg.x2 - seg.x1
    const dy = seg.y2 - seg.y1
    const len2 = dx * dx + dy * dy
    if (len2 < 1e-9) return Math.hypot(p.x - seg.x1, p.y - seg.y1) <= tol
    let t = ((p.x - seg.x1) * dx + (p.y - seg.y1) * dy) / len2
    t = Math.max(0, Math.min(1, t))
    const px = seg.x1 + t * dx
    const py = seg.y1 + t * dy
    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) => {
    const a = { x: ridge.x1, y: ridge.y1 }
    const b = { x: ridge.x2, y: ridge.y2 }
    const seg1 = { x1: ext1.x1, y1: ext1.y1, x2: ext1.x2, y2: ext1.y2 }
    const seg2 = { x1: ext2.x1, y1: ext2.y1, x2: ext2.x2, y2: ext2.y2 }
    const aOn1 = isPointOnSegment(a, seg1)
    const aOn2 = isPointOnSegment(a, seg2)
    const bOn1 = isPointOnSegment(b, seg1)
    const bOn2 = isPointOnSegment(b, seg2)
    return (aOn1 && bOn2) || (aOn2 && bOn1)
  }

  // 케라바 중점→apex ridge 1개 찾기 (역방향 패턴의 전제)
  const findRidgeAtMidpoint = (roof, c1, c2) => {
    const mid = { x: (c1.x + c2.x) / 2, y: (c1.y + c2.y) / 2 }
    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 (isSamePt(a, mid)) return { ridge: il, apex: b }
      if (isSamePt(b, mid)) return { ridge: il, apex: a }
    }
    return null
  }

  // 케라바→처마 역변환 패턴: ridge 1개 제거 + hip 복원
  //   - junctionExtended: inner hip 좌표 원복 + outer hip 2개 신규 복원 (snapshot 기반)
  //   - 일반 single-ridge (__originalHips): outer hip 2개를 스냅샷 좌표 그대로 복원
  //   - 둘 다 없으면 폴백: 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 전체 스캔.
    // [KERAB-VALLEY-OVERLAP 2026-05-28] wallBase 측은 lineName='kerabValleyOverlapLine' (본체 + 90도 보조선 2개).
    //   b polygon 의 lines[] 에는 apply() 단계에서 들어가므로, 여기서는 canvas 객체와 roof.innerLines 만 정리.
    //   b 의 lines[] 에서 제거하는 책임은 apply() 다음 사이클에서 자동 (canvas 에서 사라지므로).
    const valleyExtsToRemove = (canvas.getObjects() || []).filter(
      (il) => il && (il.lineName === 'kerabPatternValleyExt' || il.lineName === 'kerabValleyOverlapLine') && 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-TRIM 2026-05-27] forward 에서 절삭/도미노로 단축한 hip/ridge 끝점을 옛 좌표로 복원.
    //   trimRecords push 순서: 원본 trim → 도미노 cascade. 복원은 역순.
    if (Array.isArray(target.__valleyExtTrims) && target.__valleyExtTrims.length) {
      for (let i = target.__valleyExtTrims.length - 1; i >= 0; i--) {
        const rec = target.__valleyExtTrims[i]
        const il = rec.line
        if (!il) continue
        // [VALLEY-EXT-TRIM-ENDPOINT-GUARD 2026-06-10] split 전용 레코드는 좌표/visible 변경이
        //   없으므로 복원할 게 없다. split 세그먼트는 valleyExt(__targetId) 제거에서 정리됨.
        if (rec.splitOnly) continue
        if (rec.hide) {
          il.visible = rec.originalVisible !== false
        } else {
          if (rec.end === 1) il.set({ x1: rec.oldPt.x, y1: rec.oldPt.y })
          else il.set({ x2: rec.oldPt.x, y2: rec.oldPt.y })
        }
        if (rec.originalAttrs) il.attributes = rec.originalAttrs
        if (typeof il.setCoords === 'function') il.setCoords()
      }
      logger.log('[KERAB-VALLEY-EXT-TRIM] revert restored ' + target.__valleyExtTrims.length + ' trim(s)')
      delete target.__valleyExtTrims
    }
    // [KERAB-REVERT-MARK 2026-06-05] 룰 (b): hip 본체는 wallLine 끝점을 지나고 outer 끝점은 새 roofLine 코너까지 확장.
    //   buildHipFromSnapshot 시점에는 roof.points 가 아직 옛 출폭 → corner 좌표를 미리 정할 수 없음.
    //   여기서는 outer 끝점이 어느 쪽(which=1/2, side=A/B)인지만 마크하고, 실제 좌표 snap 은 surgicalAfter() 안에서
    //   roof.points 가 새 출폭으로 갱신된 뒤 nearestRoofPoint 로 다시 잡는다.
    //   Corner-side 식별: hip 의 두 끝점 중 wallLine 양 끝점(wA/wB)에 더 가까운 쪽이 corner-side.
    //   apex-side 는 roof 안쪽 깊이 있어 두 wallLine 끝점에서 모두 멀다.
    const markRevertOuter = (line) => {
      if (!line) return
      const wA = { x: target.x1, y: target.y1 }
      const wB = { x: target.x2, y: target.y2 }
      const e1 = { x: line.x1, y: line.y1 }
      const e2 = { x: line.x2, y: line.y2 }
      const dE1A = Math.hypot(e1.x - wA.x, e1.y - wA.y)
      const dE1B = Math.hypot(e1.x - wB.x, e1.y - wB.y)
      const dE2A = Math.hypot(e2.x - wA.x, e2.y - wA.y)
      const dE2B = Math.hypot(e2.x - wB.x, e2.y - wB.y)
      const minE1 = Math.min(dE1A, dE1B)
      const minE2 = Math.min(dE2A, dE2B)
      const which = minE1 <= minE2 ? 1 : 2
      const side = which === 1 ? (dE1A <= dE1B ? 'A' : 'B') : dE2A <= dE2B ? 'A' : 'B'
      line.__kerabRevertOuterWhich = which
      line.__kerabRevertOuterSide = side
      logger.log(
        '[KERAB-REVERT-MARK] ' +
          JSON.stringify({ lineName: line.lineName, which, side, minE1, minE2 }),
      )
    }
    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] })
      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
      markRevertOuter(hip)
      return hip
    }
    const buildHipToApex = (cornerPt) => {
      const pts = [cornerPt.x, cornerPt.y, apex.x, apex.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: 3,
        name: LINE_TYPE.SUBLINE.HIP,
        textMode: roof.textMode,
        attributes: { roofId: roof.id, planeSize: sz, actualSize: sz },
      })
      hip.lineName = 'kerabPatternHip'
      return hip
    }
    const restoreInnerHipFromSnapshot = (hip, snap) => {
      hip.set({ x1: snap.x1, y1: snap.y1, x2: snap.x2, y2: snap.y2 })
      const ns = calcLinePlaneSize({ x1: snap.x1, y1: snap.y1, x2: snap.x2, y2: snap.y2 })
      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)
      }
      // [KERAB-EXTHIP-COORD-CLEAN 2026-06-15] __extHipsCreated 는 객체 참조라, 양쪽 박공→한 변씩 처마
      //   복원 시퀀스에서 중간 인접변 작업이 ext-hip 을 파괴·재생성하면 죽은 객체를 가리켜 위 루프가
      //   no-op 이 된다 → 재생성된 ext-hip 이 orphan 으로 잔류(apex 에서 끝나는 1881 V, "라인은 roofLine
      //   까지" 규칙 위반). 이 kLine 의 apex(=roofLine 반대쪽 안쪽 끝점) 를 공유하는 ext 라인을 좌표로
      //   한 번 더 제거해 재생성돼도 잡는다. orphan 없으면 0개 제거 → 정상 케이스 무영향.
      {
        const _r = ridgeAtMid.ridge
        const _tMid = { x: (target.x1 + target.x2) / 2, y: (target.y1 + target.y2) / 2 }
        const _apexPt =
          Math.hypot(_r.x1 - _tMid.x, _r.y1 - _tMid.y) >= Math.hypot(_r.x2 - _tMid.x, _r.y2 - _tMid.y)
            ? { x: _r.x1, y: _r.y1 }
            : { x: _r.x2, y: _r.y2 }
        const _EXT_TOL = 1.0
        const _orphans = roof.innerLines.filter(
          (il) =>
            il &&
            (il.lineName === 'kerabPatternExtHip' || il.lineName === 'kerabPatternExtRidge') &&
            (Math.hypot(il.x1 - _apexPt.x, il.y1 - _apexPt.y) < _EXT_TOL || Math.hypot(il.x2 - _apexPt.x, il.y2 - _apexPt.y) < _EXT_TOL),
        )
        for (const eh of _orphans) {
          removeLine(eh)
          roof.innerLines = roof.innerLines.filter((il) => il !== eh)
        }
        if (_orphans.length) logger.log('[KERAB-EXTHIP-COORD-CLEAN] removed ' + JSON.stringify({ apex: _apexPt, count: _orphans.length }))
      }
      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
        markRevertOuter(hip)
        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 : []
      extHips.forEach((h) => {
        if (!h) return
        removeLine(h)
        roof.innerLines = roof.innerLines.filter((il) => il !== h)
      })
      const removedRidgeSnaps = Array.isArray(ridgeAtMid.ridge.__removedRidgesSnapshot) ? ridgeAtMid.ridge.__removedRidgesSnapshot : []
      const removedHipSnaps = Array.isArray(ridgeAtMid.ridge.__removedHipsSnapshot) ? ridgeAtMid.ridge.__removedHipsSnapshot : []
      removeLine(ridgeAtMid.ridge)
      roof.innerLines = roof.innerLines.filter((il) => il !== ridgeAtMid.ridge)
      removedRidgeSnaps.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 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)
      })
      removedHipSnaps.forEach((snap) => {
        if (!snap) return
        const hip = buildHipFromSnapshot(snap)
        canvas.add(hip)
        hip.bringToFront()
        roof.innerLines.push(hip)
      })
      removeKerabHalfLabels(target.id)
      hideOriginalLengthText(target.id, false)
      canvas.renderAll()
      return true
    }

    // single-ridge / 이전 패턴: outer hip 2개 신규 생성
    const snaps = Array.isArray(ridgeAtMid.ridge.__originalHips) ? ridgeAtMid.ridge.__originalHips : null
    const hip1 = snaps ? buildHipFromSnapshot(snaps[0]) : buildHipToApex(c1)
    const hip2 = snaps ? buildHipFromSnapshot(snaps[1]) : buildHipToApex(c2)
    removeLine(ridgeAtMid.ridge)
    roof.innerLines = roof.innerLines.filter((il) => il !== ridgeAtMid.ridge)
    canvas.add(hip1)
    canvas.add(hip2)
    hip1.bringToFront()
    hip2.bringToFront()
    roof.innerLines.push(hip1, hip2)
    removeKerabHalfLabels(target.id)
    hideOriginalLengthText(target.id, false)
    canvas.renderAll()
    return true
  }

  // [KERAB-TYPE-EAVES 2026-06-11] TYPE(A/B 박공) 출신 케라바→처마 전용 변환.
  //   forward 토글 스냅샷이 없는 native 마루(RIDGE) 케이스. 마루확장라인을 hip 2개로 "펼친다".
  //   규칙(사용자 확정, 방향 무관):
  //     1) apex = 선택라인(wLine) 중점에서 마루 방향(inward) 으로 L/2. (45° 등거리 = 반으로 쪼갬)
  //     2) 마루는 케라바변에 닿은 끝점을 apex 로 단축.
  //     3) hip 2개(wA→apex, wB→apex) 생성 + outer 마크 → surgicalAfter 가 새 출폭 rLine 까지 45° ray-cast.
  //   markRevertOuter 는 applyKerabRevertPattern 내부 클로저라 여기선 which/side 를 직접 마크.
  const isNativeTypeRidge = (ridge) =>
    !!ridge &&
    ridge.name === LINE_TYPE.SUBLINE.RIDGE &&
    !ridge.__patternKind &&
    !ridge.__originalHips &&
    !ridge.__removedHipsSnapshot &&
    ridge.lineName !== 'kerabPatternRidge' &&
    ridge.lineName !== 'kerabPatternExtRidge'

  const applyTypeGableToEavesPattern = (roof, target, ridge) => {
    const wA = { x: target.x1, y: target.y1 }
    const wB = { x: target.x2, y: target.y2 }
    const L = Math.hypot(wB.x - wA.x, wB.y - wA.y)
    if (L < 1) return null
    const mid = { x: (wA.x + wB.x) / 2, y: (wA.y + wB.y) / 2 }
    // 마루의 케라바변쪽 끝점 식별 (단축 대상).
    const rA = { x: ridge.x1, y: ridge.y1 }
    const rB = { x: ridge.x2, y: ridge.y2 }
    const midIsA = Math.hypot(rA.x - mid.x, rA.y - mid.y) <= Math.hypot(rB.x - mid.x, rB.y - mid.y)
    // [KERAB-TYPE-EAVES-INWARD 2026-06-12] inward 방향을 변의 "폴리곤 안쪽 법선"으로 도출.
    //   기존: ridge stub 의 far-end - mid. 마루가 이미 짧아진 stub(2회차 리버트)이면 far-end 가
    //   처마변 위로 와서 방향이 바깥으로 뒤집힘 → apex 폴리곤 밖 폭주(R3-outside, roofLine 절삭 불변식 위반).
    //   변⟂마루인 정상 切妻에서는 안쪽 법선 = 마루방향이라 45°/L/2 모델과 동치이고, stub 퇴화에 불변.
    const cps = Array.isArray(roof.points) ? roof.points : []
    let cenX = 0
    let cenY = 0
    for (const p of cps) {
      cenX += p.x
      cenY += p.y
    }
    cenX /= cps.length || 1
    cenY /= cps.length || 1
    const ex = (wB.x - wA.x) / L
    const ey = (wB.y - wA.y) / L
    let ix = -ey
    let iy = ex
    if (ix * (cenX - mid.x) + iy * (cenY - mid.y) < 0) {
      ix = -ix
      iy = -iy
    }
    // [KERAB-TYPE-EAVES-APEX-CLAMP 2026-06-15] apex 깊이 = L/2 (45° 이등변). 단 변이 폴리곤 inward
    //   두께보다 길면(가로로 납작한 폴리곤) mid+inward*(L/2) 가 반대편 roofLine 을 넘어 폭주
    //   (R3-outside). "라인은 roofLine 까지" 규칙 → inward ray 가 반대편 변에 닿는 거리로 상한.
    //   정상 切妻(세로로 긴 폴리곤)은 oppDist > L/2 라 min=L/2, 기존과 동치 → 무영향.
    const oppRayDist = (P, dx, dy) => {
      let best = Infinity
      const M = cps.length
      for (let i = 0; i < M; i++) {
        const A = cps[i]
        const B = cps[(i + 1) % M]
        const ax = B.x - A.x
        const ay = B.y - A.y
        const den = dx * ay - dy * ax
        if (Math.abs(den) < 1e-9) continue
        const t = ((A.x - P.x) * ay - (A.y - P.y) * ax) / den
        const u = ((A.x - P.x) * dy - (A.y - P.y) * dx) / den
        if (t > 1e-6 && u >= -1e-6 && u <= 1 + 1e-6 && t < best) best = t
      }
      return best
    }
    const oppDist = oppRayDist(mid, ix, iy)
    const apexDepth = Math.min(L / 2, Number.isFinite(oppDist) ? oppDist : L / 2)
    const apex = { x: mid.x + ix * apexDepth, y: mid.y + iy * apexDepth }
    // 마루 단축: 케라바변쪽 끝점 → apex.
    if (midIsA) ridge.set({ x1: apex.x, y1: apex.y })
    else ridge.set({ x2: apex.x, y2: apex.y })
    // [KERAB-TYPE-EAVES-RIDGE-ZERO 2026-06-15] apex 가 반대편 roofLine 에 클램프되면 native 마루가
    //   거기로 단축돼 zero-length 가 될 수 있다(R2 위반). 객체는 revert 위해 보존하되 invisible 처리
    //   (R2 체크는 visible 만 검사). 마루 형상 재구성은 완전 우진각 시 reconstruct 가 담당.
    const ridgeLen = Math.hypot(ridge.x2 - ridge.x1, ridge.y2 - ridge.y1)
    if (ridgeLen < 1) ridge.visible = false
    const rsz = calcLinePlaneSize({ x1: ridge.x1, y1: ridge.y1, x2: ridge.x2, y2: ridge.y2 })
    if (ridge.attributes) {
      ridge.attributes.planeSize = rsz
      ridge.attributes.actualSize = rsz
    }
    if (typeof ridge.setCoords === 'function') ridge.setCoords()
    if (typeof ridge.setLength === 'function') ridge.setLength()
    if (typeof ridge.addLengthText === 'function') ridge.addLengthText()
    // hip 2개: wA→apex, wB→apex. pts=[corner, apex] 라 corner 끝(x1,y1)이 outer(=which 1).
    const mkHip = (corner, side) => {
      const pts = [corner.x, corner.y, apex.x, apex.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: 3,
        name: LINE_TYPE.SUBLINE.HIP,
        textMode: roof.textMode,
        // [KERAB-TYPE-EAVES-ROUNDTRIP 2026-06-11] forward(처마→케라바) findHipAtEndpoint 는
        //   attributes.type === HIP 로 매칭한다. type 누락 시 재변환에서 hip 미인식 → attr-only 폴백.
        attributes: { roofId: roof.id, type: LINE_TYPE.SUBLINE.HIP, planeSize: sz, actualSize: sz },
      })
      hip.lineName = 'kerabPatternHip'
      hip.__kerabRevertOuterWhich = 1
      hip.__kerabRevertOuterSide = side
      return hip
    }
    const hip1 = mkHip(wA, 'A')
    const hip2 = mkHip(wB, 'B')
    canvas.add(hip1)
    canvas.add(hip2)
    hip1.bringToFront()
    hip2.bringToFront()
    roof.innerLines.push(hip1, hip2)
    removeKerabHalfLabels(target.id)
    hideOriginalLengthText(target.id, false)
    canvas.renderAll()
    logger.log(
      '[KERAB-TYPE-EAVES] applied ' +
        JSON.stringify({ L: Math.round(L), mid, apex, inward: { ix: Number(ix.toFixed(3)), iy: Number(iy.toFixed(3)) } }),
    )
    return apex
  }

  // [KERAB-TYPE-EAVES-EDGEMOVE 2026-06-11] TYPE 변환 후 옛 roofLine 변 위에 남은 normal inner line 이동.
  //   surgicalAfter(skipInnerLines:true) 는 폴리곤 변·내 hip 만 갱신하고 L자 면경계선은 안 옮긴다 →
  //   옛 出幅 위치(ghost) 잔존. 변은 出幅만큼 평행이동했으므로 옛 변 위 끝점만 동일 delta 로 평행이동한다.
  //   (出幅 평행이동이라 변 위 모든 점의 변위가 동일 = recomputeNormalLine 의 NORMAL-ABS 와 동치.)
  //   케라바패턴 라인은 ray-cast 가 이미 처리하므로 제외. oldC1/oldC2 = 변환 전 roofLine 코너.
  // [KERAB-TYPE-EAVES-WEDGE 2026-06-11] apex 인자 추가. 처마 위상에서는 두 힙이 apex 에서 만나고
  //   힙 사이 쐐기에는 라인이 없어야 한다. 옛 변 중점(cMid)에 끝점이 닿아 있던 非평행 라인(=힙)은
  //   평행이동 시 쐐기를 가로지르므로, 그 끝점만 apex 로 수렴시킨다. 변과 평행한 라인(roofLine 절반)과
  //   코너 끝점은 종전처럼 出幅 delta 로 평행이동.
  const moveStaleEdgeInnerLines = (roof, oldC1, oldC2, edgeIdx, apex) => {
    if (edgeIdx < 0 || !Array.isArray(roof.points)) return null
    const N = roof.points.length
    const nP = roof.points[edgeIdx]
    const nQ = roof.points[(edgeIdx + 1) % N]
    // c1↔c2 ↔ nP↔nQ 방향 정합 (idx 끝과 가까운 쪽으로 매핑).
    const c1ToP = Math.hypot(oldC1.x - nP.x, oldC1.y - nP.y) <= Math.hypot(oldC1.x - nQ.x, oldC1.y - nQ.y)
    const newA = c1ToP ? nP : nQ
    const newB = c1ToP ? nQ : nP
    // 出幅 평행이동 delta (양 코너 동일, 안전하게 평균).
    const dxE = (newA.x - oldC1.x + (newB.x - oldC2.x)) / 2
    const dyE = (newA.y - oldC1.y + (newB.y - oldC2.y)) / 2
    if (Math.hypot(dxE, dyE) < 0.01) return null
    const segDx = oldC2.x - oldC1.x
    const segDy = oldC2.y - oldC1.y
    const segLen2 = segDx * segDx + segDy * segDy || 1
    const segLen = Math.sqrt(segLen2)
    const onOldEdge = (px, py) => {
      const t = ((px - oldC1.x) * segDx + (py - oldC1.y) * segDy) / segLen2
      if (t < -0.02 || t > 1.02) return false
      const prx = oldC1.x + t * segDx
      const pry = oldC1.y + t * segDy
      return Math.hypot(px - prx, py - pry) < 0.5
    }
    const oldMid = { x: (oldC1.x + oldC2.x) / 2, y: (oldC1.y + oldC2.y) / 2 }
    const nearMid = (px, py) => Math.hypot(px - oldMid.x, py - oldMid.y) < 2.0
    // 라인 방향이 변과 평행이면 cross 가 0 → roofLine 절반(평행이동 대상).
    const isCollinearWithEdge = (x1, y1, x2, y2) => {
      const lx = x2 - x1
      const ly = y2 - y1
      const llen = Math.hypot(lx, ly)
      if (llen < 0.01) return true
      const cross = Math.abs(lx * segDy - ly * segDx) / (llen * segLen)
      return cross < 0.05
    }
    const isKerabPattern = (ln) =>
      ln === 'kerabPatternHip' ||
      ln === 'kerabPatternRidge' ||
      ln === 'kerabPatternExtHip' ||
      ln === 'kerabPatternExtRidge' ||
      ln === 'kerabPatternValleyExt'
    let movedCnt = 0
    for (const il of roof.innerLines || []) {
      if (!il || isKerabPattern(il.lineName)) continue
      const collinear = isCollinearWithEdge(il.x1, il.y1, il.x2, il.y2)
      // 非평행 라인의 cMid 끝점은 apex 로 수렴, 그 외는 出幅 delta 로 평행이동.
      const relocate = (px, py) => {
        if (apex && !collinear && nearMid(px, py)) return { x: apex.x, y: apex.y }
        return { x: px + dxE, y: py + dyE }
      }
      let moved = false
      if (onOldEdge(il.x1, il.y1)) {
        const np1 = relocate(il.x1, il.y1)
        il.set({ x1: np1.x, y1: np1.y })
        moved = true
      }
      if (onOldEdge(il.x2, il.y2)) {
        const np2 = relocate(il.x2, il.y2)
        il.set({ x2: np2.x, y2: np2.y })
        moved = true
      }
      if (moved) {
        const ns = calcLinePlaneSize({ x1: il.x1, y1: il.y1, x2: il.x2, y2: il.y2 })
        if (il.attributes) {
          il.attributes.planeSize = ns
          il.attributes.actualSize = ns
        }
        if (typeof il.setCoords === 'function') il.setCoords()
        if (typeof il.setLength === 'function') il.setLength()
        if (typeof il.addLengthText === 'function') il.addLengthText()
        movedCnt++
      }
    }
    canvas.renderAll()
    logger.log('[KERAB-TYPE-EAVES-EDGEMOVE] ' + JSON.stringify({ edgeIdx, delta: { dxE, dyE }, movedCnt }))
    return { dxE, dyE }
  }

  // [KERAB-TYPE-EAVES-STRAIGHT 2026-06-12] 힙은 단일 직선 45°. apex 에서 벽교점(wLine 코너) 방향(=45°)
  //   그대로 roofLine 까지 직선 연장한다. 꺾지 않고, roofLine '코너/교점'을 찾아가지도 않는다 — ray 가
  //   roofLine 변에 처음 닿는 지점이 끝점(出幅60 → 코너 10mm 못미쳐 변 위에서 끝남, 사용자 모델 그대로).
  //   apex 는 벽기준 고정값이라 出幅 무관(half-rule 폐기) — "出幅에 의해 힙·마루 변질" 차단.
  //   surgicalAfter/EXTEND-45 가 코너 스냅한 힙을 ray-cast 직선으로 덮어쓴다.
  const extendTypeGableHipsStraightToRoofLine = (roof, target, apex) => {
    if (!apex || !roof || !Array.isArray(roof.innerLines)) return
    const pts = Array.isArray(roof.points) ? roof.points : []
    if (pts.length < 2) return
    const wcs = [
      { x: target.x1, y: target.y1 },
      { x: target.x2, y: target.y2 },
    ]
    // ray P+t*dir 가 선분 A→B 와 만나는 t(>0) 반환, 없으면 Infinity.
    const rayHit = (P, dir, A, B) => {
      const ex = B.x - A.x
      const ey = B.y - A.y
      const den = dir.x * ey - dir.y * ex
      if (Math.abs(den) < 1e-9) return Infinity
      const t = ((A.x - P.x) * ey - (A.y - P.y) * ex) / den
      const u = ((A.x - P.x) * dir.y - (A.y - P.y) * dir.x) / den
      if (t > 1e-6 && u >= -1e-6 && u <= 1 + 1e-6) return t
      return Infinity
    }
    const APEX_TOL = 2.0
    let extended = 0
    for (const il of [...roof.innerLines]) {
      if (!il || il.lineName !== 'kerabPatternHip') continue
      const d1 = Math.hypot(il.x1 - apex.x, il.y1 - apex.y)
      const d2 = Math.hypot(il.x2 - apex.x, il.y2 - apex.y)
      if (Math.min(d1, d2) > APEX_TOL) continue
      const apexIsE1 = d1 <= d2
      const outerEnd = apexIsE1 ? { x: il.x2, y: il.y2 } : { x: il.x1, y: il.y1 }
      // outerEnd 에 가까운 벽교점(wLine 끝점) 선택.
      const wc = Math.hypot(outerEnd.x - wcs[0].x, outerEnd.y - wcs[0].y) <= Math.hypot(outerEnd.x - wcs[1].x, outerEnd.y - wcs[1].y) ? wcs[0] : wcs[1]
      // 방향 = apex→wc (45°). 이 방향 그대로 roofLine 까지 ray.
      const dx = wc.x - apex.x
      const dy = wc.y - apex.y
      const dlen = Math.hypot(dx, dy) || 1
      const dir = { x: dx / dlen, y: dy / dlen }
      // wc 직전(살짝 안쪽)에서 ray 발사 → wc 통과 후 첫 roofLine 변 교차.
      const P = { x: wc.x - dir.x * 0.05, y: wc.y - dir.y * 0.05 }
      let best = Infinity
      let hit = null
      for (let i = 0; i < pts.length; i++) {
        const A = pts[i]
        const B = pts[(i + 1) % pts.length]
        const t = rayHit(P, dir, A, B)
        if (t < best) {
          best = t
          hit = { x: P.x + dir.x * t, y: P.y + dir.y * t }
        }
      }
      if (!hit) continue
      // 힙 = apex → hit (단일 직선 45°).
      if (apexIsE1) il.set({ x1: apex.x, y1: apex.y, x2: hit.x, y2: hit.y })
      else il.set({ x1: hit.x, y1: hit.y, x2: apex.x, y2: apex.y })
      // [KERAB-TYPE-EAVES-STARTPOINT-SYNC 2026-06-12] .set 은 'modified' 를 안 띄워 startPoint/endPoint
      //   가 옛 좌표로 남는다. 할당 graph(splitPolygonWithLines)는 startPoint/endPoint 로 면을 닫으므로
      //   동기화 누락 시 절삭된 힙이 옛 좌표로 연결돼 인접 roofLine 이 면에 포함되지 않아 미할당된다.
      il.startPoint = { x: il.x1, y: il.y1 }
      il.endPoint = { x: il.x2, y: il.y2 }
      const sz = calcLinePlaneSize({ x1: il.x1, y1: il.y1, x2: il.x2, y2: il.y2 })
      if (il.attributes) {
        il.attributes.planeSize = sz
        il.attributes.actualSize = sz
        il.attributes.extended = true
      }
      il.__extended = true
      if (typeof il.setCoords === 'function') il.setCoords()
      if (typeof il.setLength === 'function') il.setLength()
      if (typeof il.addLengthText === 'function') il.addLengthText()
      extended++
    }
    canvas.renderAll()
    logger.log('[KERAB-TYPE-EAVES-STRAIGHT] ' + JSON.stringify({ extended, apex }))
  }

  // [KERAB-TYPE-EAVES-HIPROOF 2026-06-12] 양쪽 박공이 모두 처마로 바뀌어 완전 寄棟(우진각)이 되는 순간 호출.
  //   per-edge L/2 apex 모델은 마루를 짧은 축(세로)으로 만들어 두 힙쌍이 X자로 교차하는 틀린 형상을 남긴다.
  //   힙·마루 규칙으로 재구성: R2(라인은 교점에서 멈춤)·R3(교점 초과분 절삭)·R1(중앙선=마루).
  //   각 힙이 "가장 먼저 만나는" 다른 힙과의 교점이 진짜 마루 끝점(짧은변 공유쌍). 두 끝점을 잇는 선이 마루.
  //   apex 기반 세로 마루 스텁은 제거하고 절삭된 힙 4개 + 가로 마루 1개(표준 우진각)로 교체.
  const reconstructHipRoofRidgeIfComplete = (roof) => {
    if (!roof || !Array.isArray(roof.innerLines) || !Array.isArray(roof.points)) return false
    // 완전 寄棟 = 외곽선에 박공(GABLE)이 하나도 안 남음.
    const outerLines = canvas.getObjects().filter((o) => o.name === 'outerLine' && o.attributes?.roofId === roof.id)
    if (!outerLines.length) return false
    if (outerLines.some((o) => o.attributes?.type === LINE_TYPE.WALLLINE.GABLE)) return false
    // kerabPatternHip 정확히 4개일 때만 표준 우진각으로 간주.
    const hips = roof.innerLines.filter((il) => il && il.lineName === 'kerabPatternHip' && il.visible !== false)
    if (hips.length !== 4) return false
    const pts = roof.points
    let cenX = 0
    let cenY = 0
    for (const p of pts) {
      cenX += p.x
      cenY += p.y
    }
    cenX /= pts.length || 1
    cenY /= pts.length || 1
    // 각 힙의 outer(roofLine 코너쪽) / inner 끝점 + 방향(outer→inner, 45°).
    const info = hips.map((il) => {
      const d1 = Math.hypot(il.x1 - cenX, il.y1 - cenY)
      const d2 = Math.hypot(il.x2 - cenX, il.y2 - cenY)
      const outer = d1 >= d2 ? { x: il.x1, y: il.y1 } : { x: il.x2, y: il.y2 }
      const inner = d1 >= d2 ? { x: il.x2, y: il.y2 } : { x: il.x1, y: il.y1 }
      return { il, outer, dir: { x: inner.x - outer.x, y: inner.y - outer.y } }
    })
    // 두 힙 직선 교점 (a.outer + t·a.dir).
    const intersect = (a, b) => {
      const den = a.dir.x * b.dir.y - a.dir.y * b.dir.x
      if (Math.abs(den) < 1e-9) return null
      const t = ((b.outer.x - a.outer.x) * b.dir.y - (b.outer.y - a.outer.y) * b.dir.x) / den
      const u = ((b.outer.x - a.outer.x) * a.dir.y - (b.outer.y - a.outer.y) * a.dir.x) / den
      if (t <= 1e-6 || u <= 1e-6) return null
      return { x: a.outer.x + a.dir.x * t, y: a.outer.y + a.dir.y * t, t }
    }
    // 각 힙이 "가장 먼저(최소 t)" 만나는 힙 = 마루 끝점 파트너.
    for (let i = 0; i < info.length; i++) {
      let best = null
      let bestJ = -1
      for (let j = 0; j < info.length; j++) {
        if (i === j) continue
        const ip = intersect(info[i], info[j])
        if (!ip) continue
        if (!best || ip.t < best.t) {
          best = ip
          bestJ = j
        }
      }
      info[i].stop = best
      info[i].partner = bestJ
    }
    if (info.some((h) => !h.stop)) return false
    // 마루 끝점 클러스터링 (2개 기대).
    const ridgePts = []
    for (const h of info) {
      const found = ridgePts.find((rp) => Math.hypot(rp.x - h.stop.x, rp.y - h.stop.y) < 1.0)
      if (found) found.count++
      else ridgePts.push({ x: h.stop.x, y: h.stop.y, count: 1 })
    }
    if (ridgePts.length !== 2 || ridgePts.some((rp) => rp.count !== 2)) {
      logger.log('[KERAB-TYPE-EAVES-HIPROOF] skip ' + JSON.stringify({ ridgePts: ridgePts.length, counts: ridgePts.map((r) => r.count) }))
      return false
    }
    // R2/R3: 각 힙을 outer → 마루 끝점으로 절삭.
    for (const h of info) {
      const rp = ridgePts.find((p) => Math.hypot(p.x - h.stop.x, p.y - h.stop.y) < 1.0)
      const d1 = Math.hypot(h.il.x1 - cenX, h.il.y1 - cenY)
      const d2 = Math.hypot(h.il.x2 - cenX, h.il.y2 - cenY)
      if (d1 >= d2) h.il.set({ x2: rp.x, y2: rp.y })
      else h.il.set({ x1: rp.x, y1: rp.y })
      // [KERAB-TYPE-EAVES-STARTPOINT-SYNC 2026-06-12] 절삭 후 startPoint/endPoint 동기화.
      //   누락 시 할당 graph 가 옛 inner 끝점으로 면을 닫으려다 실패 → 인접 roofLine 미할당.
      h.il.startPoint = { x: h.il.x1, y: h.il.y1 }
      h.il.endPoint = { x: h.il.x2, y: h.il.y2 }
      const sz = calcLinePlaneSize({ x1: h.il.x1, y1: h.il.y1, x2: h.il.x2, y2: h.il.y2 })
      if (h.il.attributes) {
        h.il.attributes.planeSize = sz
        h.il.attributes.actualSize = sz
      }
      if (typeof h.il.setCoords === 'function') h.il.setCoords()
      if (typeof h.il.setLength === 'function') h.il.setLength()
      if (typeof h.il.addLengthText === 'function') h.il.addLengthText()
    }
    // 기존 마루(세로 apex 스텁 등) 제거 — 완전 우진각엔 가로 마루 1개만.
    const staleRidges = roof.innerLines.filter((il) => il && il.name === LINE_TYPE.SUBLINE.RIDGE)
    for (const r of staleRidges) {
      canvas.remove(r)
      const idx = roof.innerLines.indexOf(r)
      if (idx >= 0) roof.innerLines.splice(idx, 1)
    }
    // R1: 두 마루 끝점을 잇는 가로 마루 신규 생성.
    const rp1 = ridgePts[0]
    const rp2 = ridgePts[1]
    const rpts = [rp1.x, rp1.y, rp2.x, rp2.y]
    const rsz = calcLinePlaneSize({ x1: rpts[0], y1: rpts[1], x2: rpts[2], y2: rpts[3] })
    const ridge = new QLine(rpts, {
      parentId: roof.id,
      fontSize: roof.fontSize,
      stroke: '#1083E3',
      strokeWidth: 3,
      name: LINE_TYPE.SUBLINE.RIDGE,
      textMode: roof.textMode,
      attributes: { roofId: roof.id, type: LINE_TYPE.SUBLINE.RIDGE, planeSize: rsz, actualSize: rsz },
    })
    ridge.lineName = 'ridge'
    canvas.add(ridge)
    ridge.bringToFront()
    roof.innerLines.push(ridge)
    if (typeof ridge.setCoords === 'function') ridge.setCoords()
    if (typeof ridge.setLength === 'function') ridge.setLength()
    if (typeof ridge.addLengthText === 'function') ridge.addLengthText()
    canvas.renderAll()
    logger.log(
      '[KERAB-TYPE-EAVES-HIPROOF] reconstructed ' +
        JSON.stringify({
          ridge: { x1: Math.round(rp1.x), y1: Math.round(rp1.y), x2: Math.round(rp2.x), y2: Math.round(rp2.y) },
          removedRidges: staleRidges.length,
        }),
    )
    return true
  }

  // [KERAB-HALF-LABEL 2026-05-19] 케라바 외곽선의 좌우/상하 절반 길이 라벨
  //   그림 그릴 단계에서는 외곽선은 1개로 유지하고 라벨만 2개 노출.
  //   할당 시 splitPolygonWithLines 가 자연 분할하므로 그때는 사라지고 분할 라인 라벨이 대체.
  const KERAB_HALF_LABEL_NAME = 'kerabHalfLabel'

  const removeKerabHalfLabels = (parentId) => {
    const labels = canvas
      .getObjects()
      .filter((obj) => obj.name === KERAB_HALF_LABEL_NAME && obj.parentId === parentId)
    labels.forEach((obj) => canvas.remove(obj))
  }

  const addKerabHalfLabels = (target, c1, c2) => {
    const mid = { x: (c1.x + c2.x) / 2, y: (c1.y + c2.y) / 2 }
    const fullPlane = calcLinePlaneSize({ x1: c1.x, y1: c1.y, x2: c2.x, y2: c2.y })
    const halfPlane = Math.round(fullPlane / 2)
    const text = String(halfPlane).replace(/\.0$/, '')
    const mkPos = (a, b) => {
      const cx = (a.x + b.x) / 2
      const cy = (a.y + b.y) / 2
      // 수평/수직 라인에 한해 라벨을 라인 옆으로 살짝 띄움 (QLine.addLengthText 와 동일한 룰)
      if (target.direction === 'left' || target.direction === 'right') return { left: cx, top: cy + 10 }
      if (target.direction === 'top' || target.direction === 'bottom') return { left: cx + 10, top: cy }
      return { left: cx, top: cy }
    }
    const buildLabel = (pos) =>
      new fabric.Textbox(text, {
        left: pos.left,
        top: pos.top,
        fontSize: target.fontSize,
        parentId: target.id,
        name: KERAB_HALF_LABEL_NAME,
        editable: false,
        selectable: true,
        lockRotation: true,
        lockScalingX: true,
        lockScalingY: true,
        planeSize: halfPlane,
        actualSize: halfPlane,
      })
    canvas.add(buildLabel(mkPos(c1, mid)))
    canvas.add(buildLabel(mkPos(mid, c2)))
  }

  const hideOriginalLengthText = (parentId, hide) => {
    const lbl = canvas.getObjects().find((obj) => obj.name === 'lengthText' && obj.parentId === parentId)
    if (lbl) lbl.set({ visible: !hide })
  }

  // [KERAB-RECT-SOLVER 2026-06-15] 사각형(axis-aligned 4코너) 결정론적 케라바 솔버.
  //   토글 이력과 무관하게 「최종 4변 타입」만으로 내부선(힙/마루/케라바 줄기)을 매번 처음부터
  //   재생성한다 = 출폭/변타입의 순수 함수. forward/revert/type 미로를 통째로 우회.
  //   구조적으로 보장되는 두 불변식:
  //     불변식1(Y): 줄기(마루)는 박공으로 바뀐 변(slope 없음) 방향으로만 뻗는다. \|/, /|\ 불가.
  //     불변식2: 힙은 apex(45° 교점)에서 멈춘다 → wallbase 교점 초과(폴리곤 밖) 힙 없음.
  //   지원: 박공 0개(우진각)·1개(Y, apex 내부일 때)·2개 마주보기(맞배). 그 외(인접 2박공/3·4박공/
  //   비사각형/회전사각형/radio2 타입)는 false 반환 → 기존 경로 폴백.
  const solveRectangleKerab = (roof, target, newAttributes) => {
    try {
      if (!roof || !Array.isArray(roof.points) || roof.points.length !== 4) return false
      if (!Array.isArray(roof.innerLines)) roof.innerLines = []
      const outerLines = canvas.getObjects().filter((o) => o.name === 'outerLine' && o.attributes?.roofId === roof.id)
      // [KERAB-RECT-PROBE 2026-06-15] outerLine 이 wallbase(출폭0) 좌표인지 roofLine 좌표인지
      //   실제 데이터로 확정하기 위한 진입 덤프. solver 가 좌표 불일치로 false 폴백해도 이건 먼저 찍힘.
      logger.log(
        '[KERAB-RECT-PROBE] entry ' +
          JSON.stringify({
            roofPoints: roof.points.map((p) => ({ x: Math.round(p.x * 10) / 10, y: Math.round(p.y * 10) / 10 })),
            outerLineCount: outerLines.length,
            outerLines: outerLines.map((o) => ({
              type: o.attributes?.type,
              offset: o.attributes?.offset,
              x1: Math.round(o.x1 * 10) / 10,
              y1: Math.round(o.y1 * 10) / 10,
              x2: Math.round(o.x2 * 10) / 10,
              y2: Math.round(o.y2 * 10) / 10,
            })),
            newType: newAttributes?.type,
            newOffset: newAttributes?.offset,
          }),
      )
      if (outerLines.length !== 4) return false
      const newType = newAttributes?.type
      const TOL = 0.6
      const xs = roof.points.map((p) => p.x)
      const ys = roof.points.map((p) => p.y)
      let minX = Math.min(...xs)
      let maxX = Math.max(...xs)
      let minY = Math.min(...ys)
      let maxY = Math.max(...ys)
      let W = maxX - minX
      let H = maxY - minY
      if (W < 2 || H < 2) return false
      // 네 코너가 실제 직사각형 코너와 일치해야 함 (axis-aligned).
      const corners = [
        { x: minX, y: minY },
        { x: maxX, y: minY },
        { x: maxX, y: maxY },
        { x: minX, y: maxY },
      ]
      for (const c of corners) {
        if (!roof.points.some((p) => Math.abs(p.x - c.x) < TOL && Math.abs(p.y - c.y) < TOL)) return false
      }
      // [KERAB-RECT-SIDE-FIX 2026-06-15] outerLine 은 roof.points(roofLine)에서 出幅만큼 안쪽으로
      //   들어온 wallbase 좌표라, roof.points bbox 와 직접 비교하면 出幅(예 50)만큼 어긋나 TOL 초과 →
      //   sideOf 가 null → 솔버 전체 false 폴백(증상: 토글 시 KERAB-SIMPLE 미로로 빠져 그림 깨짐).
      //   변 분류는 outerLine 자체 bbox 기준으로, 지오메트리(힙/마루)는 그대로 roof.points 기준으로 푼다.
      const oxs = outerLines.flatMap((o) => [o.x1, o.x2])
      const oys = outerLines.flatMap((o) => [o.y1, o.y2])
      const oMinX = Math.min(...oxs)
      const oMaxX = Math.max(...oxs)
      const oMinY = Math.min(...oys)
      const oMaxY = Math.max(...oys)
      // 각 외곽선 → 변(top/bottom/left/right) 분류 + 유효 타입(EAVES/GABLE) 확정.
      const sideOf = (o) => {
        const horiz = Math.abs(o.y1 - o.y2) < TOL
        const vert = Math.abs(o.x1 - o.x2) < TOL
        if (horiz && Math.abs((o.y1 + o.y2) / 2 - oMinY) < TOL) return 'top'
        if (horiz && Math.abs((o.y1 + o.y2) / 2 - oMaxY) < TOL) return 'bottom'
        if (vert && Math.abs((o.x1 + o.x2) / 2 - oMinX) < TOL) return 'left'
        if (vert && Math.abs((o.x1 + o.x2) / 2 - oMaxX) < TOL) return 'right'
        return null
      }
      const sides = {}
      for (const o of outerLines) {
        const s = sideOf(o)
        if (!s || sides[s]) return false
        const eff = o === target ? newType : o.attributes?.type
        if (eff !== LINE_TYPE.WALLLINE.EAVES && eff !== LINE_TYPE.WALLLINE.GABLE) return false
        sides[s] = { o, gable: eff === LINE_TYPE.WALLLINE.GABLE }
      }
      if (!sides.top || !sides.bottom || !sides.left || !sides.right) return false

      const gTop = sides.top.gable
      const gBottom = sides.bottom.gable
      const gLeft = sides.left.gable
      const gRight = sides.right.gable
      const nGable = [gTop, gBottom, gLeft, gRight].filter(Boolean).length

      // [KERAB-RECT-GATE 2026-06-15] 出幅을 경계에 반영하기 전에 지원 형상인지 먼저 판정한다.
      //   미지원(인접 2박공/3·4박공/얕은 Y)인데 offset 을 먼저 옮기면 폴백된 미로가 offset 을 한 번 더
      //   적용해 이중 出幅이 된다 → 반드시 무변형 상태에서 게이트하고, 미지원이면 boundary 손대지 않고 false.
      {
        let ok = false
        if (nGable === 0) ok = true
        // [KERAB-RECT-GATE-1 2026-06-15] 단일 박공은 항상 지원: depth<=span 이면 Y(apex)모델,
        //   long-edge(케라바, depth>span)면 CASE B(반대코너 45° 힙 2개 + 변 위 마루 1개). 둘 다 정의됨.
        else if (nGable === 1) ok = true
        else if (nGable === 2) {
          ok = (gTop && gBottom) || (gLeft && gRight)
        }
        if (!ok) return false
      }

      // [KERAB-RECT-OFFSET 2026-06-15] 지원 형상 확정 후, 토글되는 변의 出幅 변경분을 경계(roofLine)에
      //   먼저 반영한다(inner line 은 안 건드림). 이후 갱신된 roof.points 로 내부 지오메트리를 푼다.
      //   出幅 입력이 기존과 같으면 delta 0 → 무동작. 다르면 maze 의 offset-surgical 과 동일 경로.
      if (newAttributes && newAttributes.offset != null) {
        applyTargetOffsetSurgical(target, newAttributes.offset, { skipInnerLines: true })
        const nxs = roof.points.map((p) => p.x)
        const nys = roof.points.map((p) => p.y)
        minX = Math.min(...nxs)
        maxX = Math.max(...nxs)
        minY = Math.min(...nys)
        maxY = Math.max(...nys)
        W = maxX - minX
        H = maxY - minY
      }

      const cx = (minX + maxX) / 2
      const cy = (minY + maxY) / 2

      const out = []
      const addRidge = (x1, y1, x2, y2) => {
        if (Math.hypot(x2 - x1, y2 - y1) >= 1) out.push({ x1, y1, x2, y2, kind: 'ridge' })
      }
      const addHip = (x1, y1, x2, y2) => {
        if (Math.hypot(x2 - x1, y2 - y1) >= 1) out.push({ x1, y1, x2, y2, kind: 'hip' })
      }

      if (nGable === 0) {
        // 우진각: 마루는 긴 축, apex 는 짧은 변/2 안쪽. 힙 4개.
        if (W >= H) {
          const inset = H / 2
          const lA = { x: minX + inset, y: cy }
          const rA = { x: maxX - inset, y: cy }
          addRidge(lA.x, lA.y, rA.x, rA.y)
          addHip(minX, minY, lA.x, lA.y)
          addHip(minX, maxY, lA.x, lA.y)
          addHip(maxX, minY, rA.x, rA.y)
          addHip(maxX, maxY, rA.x, rA.y)
        } else {
          const inset = W / 2
          const tA = { x: cx, y: minY + inset }
          const bA = { x: cx, y: maxY - inset }
          addRidge(tA.x, tA.y, bA.x, bA.y)
          addHip(minX, minY, tA.x, tA.y)
          addHip(maxX, minY, tA.x, tA.y)
          addHip(minX, maxY, bA.x, bA.y)
          addHip(maxX, maxY, bA.x, bA.y)
        }
      } else if (nGable === 1) {
        // 박공변이 짧은/중간 변(맞은편 apex 가 폴리곤 안)이면 Y(apex+마루).
        // 긴 변(케라바=마루와 평행, W>2H or H>2W)이면 맞은편 두 코너에서 45° 힙이 박공변까지
        // 직진하고 박공변 위에 마루가 놓인다(CASE B). 어느 쪽이든 단일 박공은 항상 유효.
        if (gBottom || gTop) {
          const depth = W / 2 // apex 깊이 = 박공변(가로) 길이/2
          if (depth <= H - 0.5) {
            // Y: apex 가 맞은편 변 안쪽
            if (gBottom) {
              const apex = { x: cx, y: minY + depth }
              addHip(minX, minY, apex.x, apex.y)
              addHip(maxX, minY, apex.x, apex.y)
              addRidge(apex.x, apex.y, cx, maxY)
            } else {
              const apex = { x: cx, y: maxY - depth }
              addHip(minX, maxY, apex.x, apex.y)
              addHip(maxX, maxY, apex.x, apex.y)
              addRidge(apex.x, apex.y, cx, minY)
            }
          } else if (gBottom) {
            // 케라바(긴 가로 변): 위쪽 두 코너 → 박공변(아래)까지 45° 직진 + 박공변 위 마루
            addHip(minX, minY, minX + H, maxY)
            addHip(maxX, minY, maxX - H, maxY)
            addRidge(minX + H, maxY, maxX - H, maxY)
          } else {
            addHip(minX, maxY, minX + H, minY)
            addHip(maxX, maxY, maxX - H, minY)
            addRidge(minX + H, minY, maxX - H, minY)
          }
        } else {
          const depth = H / 2
          if (depth <= W - 0.5) {
            if (gLeft) {
              const apex = { x: maxX - depth, y: cy }
              addHip(maxX, minY, apex.x, apex.y)
              addHip(maxX, maxY, apex.x, apex.y)
              addRidge(apex.x, apex.y, minX, cy)
            } else {
              const apex = { x: minX + depth, y: cy }
              addHip(minX, minY, apex.x, apex.y)
              addHip(minX, maxY, apex.x, apex.y)
              addRidge(apex.x, apex.y, maxX, cy)
            }
          } else if (gLeft) {
            // 케라바(긴 세로 변): 오른쪽 두 코너 → 박공변(왼쪽)까지 45° 직진 + 박공변 위 마루
            addHip(maxX, minY, minX, minY + W)
            addHip(maxX, maxY, minX, maxY - W)
            addRidge(minX, minY + W, minX, maxY - W)
          } else {
            addHip(minX, minY, maxX, minY + W)
            addHip(minX, maxY, maxX, maxY - W)
            addRidge(maxX, minY + W, maxX, maxY - W)
          }
        }
      } else if (nGable === 2) {
        // 맞배: 마주보는 두 박공 사이를 잇는 단일 마루, 힙 없음.
        if (gTop && gBottom) {
          addRidge(cx, minY, cx, maxY)
        } else if (gLeft && gRight) {
          addRidge(minX, cy, maxX, cy)
        } else {
          return false // 인접 2박공 = 굽은 마루, 미지원 → 폴백
        }
      } else {
        return false // 3·4 박공 → 폴백
      }
      if (!out.length) return false

      const beforeSnap = snapshotKerabState(roof)
      // 기존 내부 HIP/RIDGE(네이티브 + kerabPattern) 전부 제거 후 재생성.
      for (const il of [...roof.innerLines]) {
        if (!il) continue
        if (il.name === LINE_TYPE.SUBLINE.HIP || il.name === LINE_TYPE.SUBLINE.RIDGE) {
          canvas.remove(il)
          const idx = roof.innerLines.indexOf(il)
          if (idx >= 0) roof.innerLines.splice(idx, 1)
        }
      }
      for (const o of outerLines) removeKerabHalfLabels(o.id)
      for (const ln of out) {
        const sz = calcLinePlaneSize({ x1: ln.x1, y1: ln.y1, x2: ln.x2, y2: ln.y2 })
        const isRidge = ln.kind === 'ridge'
        const q = new QLine([ln.x1, ln.y1, ln.x2, ln.y2], {
          parentId: roof.id,
          fontSize: roof.fontSize,
          stroke: '#1083E3',
          strokeWidth: isRidge ? 4 : 3,
          name: isRidge ? LINE_TYPE.SUBLINE.RIDGE : LINE_TYPE.SUBLINE.HIP,
          textMode: roof.textMode,
          attributes: {
            roofId: roof.id,
            type: isRidge ? LINE_TYPE.SUBLINE.RIDGE : LINE_TYPE.SUBLINE.HIP,
            planeSize: sz,
            actualSize: sz,
            // [KERAB-RECT-EXTENDED 2026-06-15] 솔버 hip 은 roofLine 코너(=출폭 끝점)까지 이미 닿아 있다.
            //   allocation 의 integrateExtensionLines 가 ext+hip 머지로 hip 을 wall 코너까지 단축시키면
            //   split graph 가 polygon 코너와 끊겨 1면만 잡힌다(native hip 은 extended 플래그로 머지 스킵).
            //   동일하게 extended=true 부여 → INTEGRATE 가 merge 스킵, ext 는 lines 에서만 제거.
            ...(isRidge ? {} : { extended: true }),
          },
        })
        q.lineName = ln.kind
        if (!isRidge) q.__extended = true
        // 할당 graph(splitPolygonWithLines)는 startPoint/endPoint 로 면을 닫으므로 동기화 필수.
        q.startPoint = { x: ln.x1, y: ln.y1 }
        q.endPoint = { x: ln.x2, y: ln.y2 }
        canvas.add(q)
        q.bringToFront()
        roof.innerLines.push(q)
        if (typeof q.setCoords === 'function') q.setCoords()
        if (typeof q.setLength === 'function') q.setLength()
        if (typeof q.addLengthText === 'function') q.addLengthText()
      }
      // 박공 변엔 절반 라벨 + 원본 길이 숨김, 처마 변엔 원본 길이 노출.
      for (const key of ['top', 'bottom', 'left', 'right']) {
        const s = sides[key]
        if (s.gable) {
          addKerabHalfLabels(s.o, { x: s.o.x1, y: s.o.y1 }, { x: s.o.x2, y: s.o.y2 })
          hideOriginalLengthText(s.o.id, true)
        } else {
          hideOriginalLengthText(s.o.id, false)
        }
      }
      target.set({ attributes: newAttributes })
      canvas.renderAll()
      const phase = newType === LINE_TYPE.WALLLINE.GABLE ? 'forward' : 'revert'
      runKerabRuleCheck(roof, phase, beforeSnap)
      try {
        reattachDebugLabels(canvas, roof.id)
      } catch (e) {}
      logger.log('[KERAB-RECT-SOLVER] built ' + JSON.stringify({ nGable, lines: out.length, W: Math.round(W), H: Math.round(H) }))
      return true
    } catch (err) {
      logger.warn('[KERAB-RECT-SOLVER] error → fallback', err)
      return false
    }
  }

  // [KERAB-PATTERN-EXT-CLEAN 2026-05-19] forward 시 제거되는 hip 과 짝이었던 orphan
  // extensionLine 정리. 한 끝점이 hip 의 한 끝점과 같고 다른 끝점이 hip 의 진행
  // 방향과 동일선상에 있으면 짝으로 판정. 잔류 시 allocation 의 integrateExtensionLines
  // 가 "짝없음" 으로 처리하고, ext 끝점이 외곽 polygon 을 잘못 자르는 잉여 분할 발생.
  const removeOrphanExtensionsForHip = (hip) => {
    const TOL = 1.0
    const hipP1 = { x: hip.x1, y: hip.y1 }
    const hipP2 = { x: hip.x2, y: hip.y2 }
    const hipVx = hip.x2 - hip.x1
    const hipVy = hip.y2 - hip.y1
    const hipMag = Math.hypot(hipVx, hipVy) || 1
    const same = (a, b) => Math.hypot(a.x - b.x, a.y - b.y) < TOL
    const exts = canvas.getObjects().filter(
      (o) => o?.lineName === 'extensionLine' && o.roofId === hip.parentId,
    )
    exts.forEach((ext) => {
      const eP1 = { x: ext.x1, y: ext.y1 }
      const eP2 = { x: ext.x2, y: ext.y2 }
      const sharesP1 = same(eP1, hipP1) || same(eP1, hipP2)
      const sharesP2 = same(eP2, hipP1) || same(eP2, hipP2)
      if ((sharesP1 ? 1 : 0) + (sharesP2 ? 1 : 0) !== 1) return
      const eVx = ext.x2 - ext.x1
      const eVy = ext.y2 - ext.y1
      const eMag = Math.hypot(eVx, eVy) || 1
      const cross = (hipVx * eVy - hipVy * eVx) / (hipMag * eMag)
      if (Math.abs(cross) >= 0.02) return // 동일선상 아님
      canvas.remove(ext)
    })
  }

  // [2240 KERAB-HIP-SNAPSHOT 2026-05-19] forward 시 제거되는 hip 의 원본 상태 캡처.
  // revert 시 c1↔apex 로 새 hip 만들지 않고 이 스냅샷으로 원본 좌표/속성 그대로 복원.
  const snapshotHip = (hip) => ({
    x1: hip.x1,
    y1: hip.y1,
    x2: hip.x2,
    y2: hip.y2,
    attributes: hip.attributes ? { ...hip.attributes } : {},
    lineName: hip.lineName,
    __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) => {
    // [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, {
      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 },
    })
    ridge.lineName = 'kerabPatternRidge'
    ridge.__patternKind = 'kLineOnly'
    if (!ridgeMeetsMidpointOf(ridge, { x1: target.x1, y1: target.y1, x2: target.x2, y2: target.y2 })) {
      return false
    }
    canvas.add(ridge)
    ridge.bringToFront()
    roof.innerLines.push(ridge)
    hideOriginalLengthText(target.id, true)
    removeKerabHalfLabels(target.id)
    addKerabHalfLabels(target, c1, c2)
    canvas.renderAll()
    return true
  }

  // [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) => {
    // [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, {
      parentId: roof.id,
      fontSize: roof.fontSize,
      stroke: '#1083E3',
      strokeWidth: 4,
      name: LINE_TYPE.SUBLINE.RIDGE,
      textMode: roof.textMode,
      attributes: { roofId: roof.id, planeSize: ridgeSz, actualSize: ridgeSz },
    })
    ridge.lineName = 'kerabPatternRidge'
    ridge.__patternKind = 'kLineOnly'
    if (!ridgeMeetsMidpointOf(ridge, { x1: target.x1, y1: target.y1, x2: target.x2, y2: target.y2 })) return false

    canvas.add(ridge)
    ridge.bringToFront()
    roof.innerLines.push(ridge)

    hideOriginalLengthText(target.id, true)
    removeKerabHalfLabels(target.id)
    addKerabHalfLabels(target, c1, c2)
    canvas.renderAll()
    return true
  }

  // [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 = () => {
    canvas.renderAll()
    return true
  }

  return { type, setType, buttonMenu, TYPES, pitchRef, offsetRef, widthRef, radioTypeRef, pitchText }
}