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 { calcLinePlaneSize } from '@/util/qpolygon-utils'
import { findInteriorPoint } from '@/util/skeleton-utils'
import { logger } from '@/util/logger'
import { applyKerabOffsetSurgical } from '@/util/kerab-offset-surgical'

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

// 처마.케라바 변경
export function useEavesGableEdit(id) {
  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()
  }

  const mouseDownEvent = (e) => {
    logger.log(
      '[KERAB-MOUSEDOWN] fired ' +
        JSON.stringify({
          hasTarget: !!e.target,
          name: e.target?.name,
          type: typeRef.current,
          radio: radioTypeRef.current,
          targetType: e.target?.attributes?.type,
          x1: e.target?.x1,
          y1: e.target?.y1,
          x2: e.target?.x2,
          y2: e.target?.y2,
        }),
    )
    canvas.discardActiveObject()
    if (!e.target || (e.target && e.target.name !== 'outerLine')) {
      return
    }

    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
    }

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

    // [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-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)
        const t1 = { x: target.x1, y: target.y1 }
        const t2 = { x: target.x2, y: target.y2 }
        const h1Match = findHipAtEndpoint(roof, t1)
        const h2Match = findHipAtEndpoint(roof, t2)
        logger.log(
          '[KERAB-SIMPLE] hip lookup ' +
            JSON.stringify({
              target: labelOf(target),
              t1,
              t2,
              h1: h1Match
                ? { label: labelOf(h1Match.hip), near: h1Match.near, far: h1Match.far, dist: Math.round(h1Match.dist * 100) / 100 }
                : null,
              h2: h2Match
                ? { label: labelOf(h2Match.hip), near: h2Match.near, far: h2Match.far, dist: Math.round(h2Match.dist * 100) / 100 }
                : null,
            }),
        )
        if (h1Match && h2Match) {
          // [KERAB-APEX-FAR-AS-PARALLEL 2026-05-21] lineLineIntersection 은 완전 평행(det≈0) 만 null 반환.
          //   거의 평행한 두 hip 은 천문학적 좌표의 가짜 apex 를 만들어 markerApex 오염. 좌표 크기로 평행 강제 판정.
          let apex = lineLineIntersection(h1Match.near, h1Match.far, h2Match.near, h2Match.far)
          if (apex) {
            const APEX_FAR_LIMIT = 1e5
            if (Math.abs(apex.x) > APEX_FAR_LIMIT || Math.abs(apex.y) > APEX_FAR_LIMIT) {
              apex = null
            }
          }
          logger.log(
            '[KERAB-SIMPLE] apex ' +
              JSON.stringify({
                apex: apex ? { x: Math.round(apex.x * 100) / 100, y: Math.round(apex.y * 100) / 100 } : null,
                parallel: !apex,
              }),
          )
// [KERAB-PARALLEL-FULLALGO 2026-05-21] 평행(apex=null) 도 풀 알고리즘으로 처리.
          //   폴리곤 경로 + extender 확장 + 반사/meet/apex/kLine — h1·h2 만나지 않더라도
          //   내부 라인(path hips/ridges) 은 삭제, 접점 extender 는 인쪽 확장.
          //   자연 만남(condition 1) 만 단축: apex 존재 + h*.far ≈ apex.
          {
            const EXT_TOL = 1.0
            const isNatural =
              !!apex &&
              Math.hypot(h1Match.far.x - apex.x, h1Match.far.y - apex.y) <= EXT_TOL &&
              Math.hypot(h2Match.far.x - apex.x, h2Match.far.y - apex.y) <= EXT_TOL
            if (!isNatural) {
              // [KERAB-POLYGON-BFS 2026-05-21] 사용자 전제 2: 내부 다각형 경계 = BFS 로 추적한
              //   h1.far → h2.far 경로 + h1 + h2. 경로상 모든 hip/ridge 를 삭제 대상으로 모음.
              //   직접 연결(RG-1) 뿐 아니라 비대칭(Ridge→junction→otherHip 체인) 도 한 번에 처리.
              const polygonPath = traceInnerPolygonPath(roof, h1Match.far, h2Match.far, [h1Match.hip, h2Match.hip])
              logger.log(
                '[KERAB-SIMPLE] polygonPath ' +
                  JSON.stringify({
                    found: polygonPath !== null,
                    length: polygonPath ? polygonPath.length : 0,
                    lines: polygonPath
                      ? polygonPath.map((p) => ({
                          label: labelOf(p.line),
                          name: p.line.name,
                          lineName: p.line.lineName,
                          x1: p.line.x1, y1: p.line.y1, x2: p.line.x2, y2: p.line.y2,
                        }))
                      : null,
                  }),
              )
              // [KERAB-VALLEY-DIAG 2026-05-27] 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))
              }
              // [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()
                return
              }
              const polygonLines = [h1Match.hip, h2Match.hip, ...polygonPath.map((p) => p.line)]
              // [KERAB-EXTENDER 2026-05-21] 사용자 전제 3: 접점(h1.far, h2.far, 중간 junction) 에서 polygon path 가 아닌
              //   inner line(hip OR ridge) 을 extender 로 식별. 경로상 라인은 제외.
              const ext1 = findExtenderAtPoint(roof, h1Match.far, polygonLines)
              const ext2 = findExtenderAtPoint(roof, h2Match.far, polygonLines)
              // [KERAB-JUNCTION-EXT 2026-05-21] 중간 touch point(junction) 의 extender 도 식별 — 모든
              //   사용 가능한 extender 를 수집해 가장 가까운 meet 부터 순차 해소(H-7↔RG-2 → H-1↔roofLine 등).
              const intermediatePoints = []
              for (let i = 0; i < polygonPath.length - 1; i++) {
                intermediatePoints.push(polygonPath[i].to)
              }
              const junctionExtenders = intermediatePoints.map((jp) => {
                const allAtJ = []
                for (const il of roof.innerLines || []) {
                  if (!il || polygonLines.includes(il)) continue
                  if (il.name !== LINE_TYPE.SUBLINE.HIP && il.name !== LINE_TYPE.SUBLINE.RIDGE) continue
                  const a = { x: il.x1, y: il.y1 }
                  const b = { x: il.x2, y: il.y2 }
                  const dA = Math.hypot(a.x - jp.x, a.y - jp.y)
                  const dB = Math.hypot(b.x - jp.x, b.y - jp.y)
                  if (dA <= 1.0) allAtJ.push({ line: il, near: a, far: b, isHip: il.name === LINE_TYPE.SUBLINE.HIP })
                  else if (dB <= 1.0) allAtJ.push({ line: il, near: b, far: a, isHip: il.name === LINE_TYPE.SUBLINE.HIP })
                }
                return { jp, exts: allAtJ }
              })
              logger.log(
                '[KERAB-SIMPLE] extenders ' +
                  JSON.stringify({
                    h1Far: h1Match.far,
                    h2Far: h2Match.far,
                    e1: ext1 ? { label: labelOf(ext1.line), near: ext1.near, far: ext1.far, isHip: ext1.isHip } : null,
                    e2: ext2 ? { label: labelOf(ext2.line), near: ext2.near, far: ext2.far, isHip: ext2.isHip } : null,
                    junctions: junctionExtenders.map((j) => ({
                      jp: j.jp,
                      exts: j.exts.map((e) => ({
                        label: labelOf(e.line),
                        near: e.near,
                        far: e.far,
                        isHip: e.isHip,
                        lineName: e.line.lineName,
                      })),
                    })),
                  }),
              )
              // [KERAB-SEQ-RESOLVE 2026-05-21] 사용자 모델: 모든 접점의 extender 를 모아 인쪽 확장.
              //   가장 가까운 meet 부터 순차 해소(hip-hip → apex+kLine, hip-ridge → 그 자리 stop).
              //   짝 잃은 extender 는 roofLine 까지 확장. parallel 도 자동 처리.
              // [KERAB-POLYGON-INSIDE-REVERT 2026-05-21] sub-polygon 내부 필터(goesIntoPolygon) 제거.
              //   해당 필터가 평행 케이스의 정상 extender 까지 거름 → 회귀. RG-1 류는 no-pierce(barrier) 로 처리.
              const allExtenders = []
              if (ext1) allExtenders.push({ ...ext1, sourcePoint: h1Match.far })
              if (ext2) allExtenders.push({ ...ext2, sourcePoint: h2Match.far })
              for (const j of junctionExtenders) {
                for (const e of j.exts) {
                  allExtenders.push({ ...e, sourcePoint: j.jp })
                }
              }
              logger.log(
                '[KERAB-SIMPLE] extenders-filtered ' +
                  JSON.stringify({
                    accepted: allExtenders.map((e) => ({
                      label: labelOf(e.line),
                      near: { x: Math.round(e.near.x * 100) / 100, y: Math.round(e.near.y * 100) / 100 },
                      far: { x: Math.round(e.far.x * 100) / 100, y: Math.round(e.far.y * 100) / 100 },
                      isHip: e.isHip,
                    })),
                  }),
              )
              if (allExtenders.length === 0) {
                logger.log('[KERAB-SIMPLE] no extenders — fallback attr-only')
                target.set({ attributes })
                applyKerabAttributeOnlyPattern()
                return
              }
              // 인쪽 방향 검증: extender 자연 방향(near→far)의 반대(near→inward) 와 일치해야 함.
              const isInward = (ext, pt) => {
                const ix = ext.near.x - ext.far.x
                const iy = ext.near.y - ext.far.y
                const px = pt.x - ext.near.x
                const py = pt.y - ext.near.y
                return ix * px + iy * py > 1e-3
              }
              // [KERAB-ITER-REFLECT 2026-05-21] 반사 hip 을 1급 extender 로 풀에 추가하고 wave 반복.
              //   wave: 미해소 extender 들의 meet 계산 → 가장 가까운 meet 부터 해소 →
              //         hip+(ridge/kLine) → 반사 hip 생성하여 풀에 추가 →
              //         hip+hip → apex + 새 kLine 도 다음 wave 의 barrier (현재는 첫 apex 하나만 추적).
              //   미해소는 roofLine fallback.
              const existingKLines = (roof.innerLines || []).filter(
                (il) =>
                  il &&
                  il.lineName === 'kerabPatternRidge' &&
                  !il.__noKLine &&
                  il.__targetId !== target.id &&
                  il.visible !== false,
              )
              const isPointOnSegment = (pt, ax, ay, bx, by, tol = 0.5) => {
                const dx = bx - ax
                const dy = by - ay
                const lenSq = dx * dx + dy * dy
                if (lenSq < 1e-6) return Math.hypot(pt.x - ax, pt.y - ay) <= tol
                const t = ((pt.x - ax) * dx + (pt.y - ay) * dy) / lenSq
                const margin = tol / Math.sqrt(lenSq)
                if (t < -margin || t > 1 + margin) return false
                const px = ax + t * dx
                const py = ay + t * dy
                return Math.hypot(px - pt.x, py - pt.y) <= tol
              }
              const extenderPool = [...allExtenders]
              const resolved = new Map()
              // [KERAB-MULTI-APEX 2026-05-22] hip+hip 이 90° 로 만나는 모든 apex 수집 → 각 apex 마다 kLine 1개.
              //   첫 apex 는 primary(applyKerabKLinePattern), 이후 apex 는 보조 ridge.
              const apexList = []
              const pendingKLines = []
              const PERP_EPS = 0.05
              const isPerpendicular = (vax, vay, vbx, vby) => {
                const ma = Math.hypot(vax, vay) || 1
                const mb = Math.hypot(vbx, vby) || 1
                return Math.abs((vax * vbx + vay * vby) / (ma * mb)) < PERP_EPS
              }
              const computePendingKLine = (apex) => {
                const ax = h2Match.near.x - h1Match.near.x
                const ay = h2Match.near.y - h1Match.near.y
                const aSq = ax * ax + ay * ay || 1
                const tFoot = ((apex.x - h1Match.near.x) * ax + (apex.y - h1Match.near.y) * ay) / aSq
                const foot = { x: h1Match.near.x + tFoot * ax, y: h1Match.near.y + tFoot * ay }
                return { x1: apex.x, y1: apex.y, x2: foot.x, y2: foot.y }
              }
              const pushApexIfNew = (point, callerTag = '?') => {
                const dup = apexList.some((ap) => Math.hypot(ap.point.x - point.x, ap.point.y - point.y) < 0.5)
                if (dup) {
                  logger.log('[KERAB-APEX-PUSH-DUP]', callerTag, { x: point.x?.toFixed?.(2), y: point.y?.toFixed?.(2) })
                  return false
                }
                apexList.push({ point: { x: point.x, y: point.y } })
                const pk = computePendingKLine(point)
                pendingKLines.push(pk)
                logger.log('[KERAB-APEX-PUSH]', callerTag, {
                  apex: { x: point.x?.toFixed?.(2), y: point.y?.toFixed?.(2) },
                  kLine: { x1: pk.x1?.toFixed?.(2), y1: pk.y1?.toFixed?.(2), x2: pk.x2?.toFixed?.(2), y2: pk.y2?.toFixed?.(2) },
                  apexCount: apexList.length,
                })
                return true
              }
              // [KERAB-FIXPOINT-PHASE-A 2026-05-22] 정적 inner line 만남 시 절삭 정보 누적.
              //   wave 종료 후 apply 직전에 fabric line 좌표를 갱신해 그 점 너머 부분을 제거한다.
              const cuts = []
              const MAX_ITER = 10
              for (let iter = 0; iter < MAX_ITER; iter++) {
                const unresolved = extenderPool.filter((e) => !resolved.has(e))
                if (unresolved.length === 0) break
                const meets = []
                // [KERAB-MEETS-FAR-GUARD 2026-05-21] 거의 평행한 두 extender(H-2 vs H-3 등) 의 교점은
                //   천문학적 좌표(예: ±6e5) 로 돌아오고 isInward 도 통과 → 가짜 meet 후보 등록.
                //   line 291 APEX_FAR_LIMIT 와 동일 임계 1e5 로 거부, 짝 잃은 ext 는 fallback 경로(roof wall)로.
                const MEETS_FAR_LIMIT = 1e5
                for (let i = 0; i < unresolved.length; i++) {
                  for (let k = i + 1; k < unresolved.length; k++) {
                    const ea = unresolved[i]
                    const eb = unresolved[k]
                    const ip = lineLineIntersection(ea.near, ea.far, eb.near, eb.far)
                    if (!ip) continue
                    if (Math.abs(ip.x) > MEETS_FAR_LIMIT || Math.abs(ip.y) > MEETS_FAR_LIMIT) continue
                    if (!isInward(ea, ip) || !isInward(eb, ip)) continue
                    const dA = Math.hypot(ip.x - ea.near.x, ip.y - ea.near.y)
                    const dB = Math.hypot(ip.x - eb.near.x, ip.y - eb.near.y)
                    meets.push({
                      a: ea, b: eb, point: ip,
                      minDist: Math.min(dA, dB),
                      bothHips: ea.isHip && eb.isHip,
                    })
                  }
                }
                const kLineMeets = []
                const kLineCandidates = [...existingKLines, ...pendingKLines]
                for (const ext of unresolved) {
                  for (const kl of kLineCandidates) {
                    const ip = lineLineIntersection(ext.near, ext.far, { x: kl.x1, y: kl.y1 }, { x: kl.x2, y: kl.y2 })
                    if (!ip) continue
                    if (!isInward(ext, ip)) continue
                    if (!isPointOnSegment(ip, kl.x1, kl.y1, kl.x2, kl.y2)) continue
                    const dist = Math.hypot(ip.x - ext.near.x, ip.y - ext.near.y)
                    if (dist < 1e-3) continue
                    kLineMeets.push({ ext, point: ip, dist, kLine: kl })
                  }
                }
                // [KERAB-STATIC-RIDGE 2026-05-21] 정적 ridge(RG-1 등, 폴리곤 삭제대상 제외) 도 hip extender 의 거울.
                const staticRidges = (roof.innerLines || []).filter(
                  (il) =>
                    il &&
                    il.name === LINE_TYPE.SUBLINE.RIDGE &&
                    il.lineName !== 'kerabPatternRidge' &&
                    !polygonLines.includes(il),
                )
                const ridgeMeets = []
                for (const ext of unresolved) {
                  if (!ext.isHip) continue
                  for (const r of staticRidges) {
                    const ip = lineLineIntersection(ext.near, ext.far, { x: r.x1, y: r.y1 }, { x: r.x2, y: r.y2 })
                    if (!ip) continue
                    if (!isInward(ext, ip)) continue
                    if (!isPointOnSegment(ip, r.x1, r.y1, r.x2, r.y2)) continue
                    const dist = Math.hypot(ip.x - ext.near.x, ip.y - ext.near.y)
                    ridgeMeets.push({ ext, point: ip, dist, ridge: r })
                  }
                }
                // [KERAB-FIXPOINT-PHASE-A 2026-05-22] 정적 inner hip 만남 — 무너진 sub-polygon 의 경계.
                //   unresolved ext (hip 또는 ridge) 가 정적 hip segment 와 만나면 그 점에서 멈춤 + 절삭정보 누적.
                //   polygon path 라인은 제외(이 polygon 의 처리 대상). 자기 라인은 검사 루프에서 개별 제외.
                const staticInnerHips = (roof.innerLines || []).filter(
                  (il) =>
                    il &&
                    il.name === LINE_TYPE.SUBLINE.HIP &&
                    !polygonLines.includes(il) &&
                    il.visible !== false,
                )
                const staticMeets = []
                for (const ext of unresolved) {
                  for (const il of staticInnerHips) {
                    if (ext.line === il) continue
                    const a = { x: il.x1, y: il.y1 }
                    const b = { x: il.x2, y: il.y2 }
                    const ip = lineLineIntersection(ext.near, ext.far, a, b)
                    if (!ip) continue
                    if (Math.abs(ip.x) > 1e5 || Math.abs(ip.y) > 1e5) continue
                    if (!isInward(ext, ip)) continue
                    if (!isPointOnSegment(ip, a.x, a.y, b.x, b.y)) continue
                    const dist = Math.hypot(ip.x - ext.near.x, ip.y - ext.near.y)
                    if (dist < 1e-3) continue
                    staticMeets.push({ ext, point: ip, dist, staticLine: il })
                  }
                }
                if (staticMeets.length > 0) {
                  logger.log(
                    '[KERAB-FIXPOINT-PHASE-A] staticMeets iter=' + iter + ' ' +
                      JSON.stringify(
                        staticMeets.map((s) => ({
                          ext: labelOf(s.ext.line) || (s.ext.isHip ? 'H' : 'R'),
                          staticLine: labelOf(s.staticLine) || 'H?',
                          point: { x: Math.round(s.point.x * 100) / 100, y: Math.round(s.point.y * 100) / 100 },
                          dist: Math.round(s.dist * 100) / 100,
                        })),
                      ),
                  )
                }
                // [KERAB-FIXPOINT-STEP2 2026-05-21] 이미 그려질 segment(resolved) 도 후보의 거울.
                //   뒤늦게 도달한 extender 가 기존 segment 와 만나면 그 점에서 반사 hip 을 만든다.
                //   (drawn segment 자체의 절단은 Step 3 에서 처리)
                //   segment 양끝은 그리기 좌표(sourcePoint→stop) 와 일치시킨다.
                const drawnMeets = []
                for (const ext of unresolved) {
                  if (!ext.isHip) continue
                  for (const [drawnExt, stopPt] of resolved) {
                    if (!drawnExt || !stopPt) continue
                    if (drawnExt === ext) continue
                    const segA = drawnExt.sourcePoint || drawnExt.near
                    const segB = stopPt
                    const ip = lineLineIntersection(ext.near, ext.far, segA, segB)
                    if (!ip) continue
                    if (Math.abs(ip.x) > 1e5 || Math.abs(ip.y) > 1e5) continue
                    if (!isInward(ext, ip)) continue
                    if (!isPointOnSegment(ip, segA.x, segA.y, segB.x, segB.y)) continue
                    const dist = Math.hypot(ip.x - ext.near.x, ip.y - ext.near.y)
                    if (dist < 1e-3) continue
                    drawnMeets.push({ ext, point: ip, dist, drawnExt, mirrorLine: { x1: segA.x, y1: segA.y, x2: segB.x, y2: segB.y } })
                  }
                }
                if (drawnMeets.length > 0) {
                  logger.log(
                    '[KERAB-FIXPOINT-STEP2] drawnMeets iter=' + iter + ' ' +
                      JSON.stringify(
                        drawnMeets.map((d) => ({
                          ext: d.ext.line?.attributes?.label || (d.ext.isHip ? 'H' : 'R'),
                          point: { x: Math.round(d.point.x * 100) / 100, y: Math.round(d.point.y * 100) / 100 },
                          dist: Math.round(d.dist * 100) / 100,
                        })),
                      ),
                  )
                }
                const candidates = []
                for (const m of meets) {
                  candidates.push({ kind: 'pair', extenders: [m.a, m.b], point: m.point, minDist: m.minDist, bothHips: m.bothHips })
                }
                for (const km of kLineMeets) {
                  candidates.push({ kind: 'kline', extenders: [km.ext], point: km.point, minDist: km.dist, mirrorLine: km.kLine })
                }
                for (const rm of ridgeMeets) {
                  candidates.push({
                    kind: 'ridge',
                    extenders: [rm.ext],
                    point: rm.point,
                    minDist: rm.dist,
                    mirrorLine: { x1: rm.ridge.x1, y1: rm.ridge.y1, x2: rm.ridge.x2, y2: rm.ridge.y2 },
                  })
                }
                for (const dm of drawnMeets) {
                  candidates.push({
                    kind: 'drawn',
                    extenders: [dm.ext],
                    point: dm.point,
                    minDist: dm.dist,
                    mirrorLine: dm.mirrorLine,
                    drawnExt: dm.drawnExt,
                  })
                }
                for (const sm of staticMeets) {
                  candidates.push({
                    kind: 'static',
                    extenders: [sm.ext],
                    point: sm.point,
                    minDist: sm.dist,
                    staticLine: sm.staticLine,
                  })
                }
                candidates.sort((a, b) => a.minDist - b.minDist)
                const newReflected = []
                let pendingKLineCreated = false
                let processedAny = false
                // [KERAB-FIXPOINT-STEP1 2026-05-21] 동시성 모델: 한 iter 에 가장 가까운 후보 1개만 처리.
                //   이후 외곽 for(iter) 루프가 meets/kLineMeets/ridgeMeets 를 새 상태로 재계산한다.
                //   이렇게 해야 뒤늦은 교점이 이미 그려질 라인을 잘라낼 수 있다 (Step 2~3 에서 확장 예정).
                for (const c of candidates) {
                  if (c.extenders.some((e) => resolved.has(e))) continue
                  for (const e of c.extenders) resolved.set(e, c.point)
                  processedAny = true
                  // [KERAB-FIXPOINT-STEP3 2026-05-21] drawn segment 절단:
                  //   뒤늦은 교점이 잡힌 기존 segment 의 stop 을 교점으로 갱신.
                  //   절단 후 길이 < 0.5 이면 resolved 에서 제거하여 라인 자체 제거.
                  if (c.kind === 'drawn' && c.drawnExt) {
                    const drawnNear = c.drawnExt.sourcePoint || c.drawnExt.near
                    const remain = Math.hypot(c.point.x - drawnNear.x, c.point.y - drawnNear.y)
                    if (remain < 0.5) {
                      resolved.delete(c.drawnExt)
                    } else {
                      resolved.set(c.drawnExt, c.point)
                    }
                    // [KERAB-MULTI-APEX 2026-05-22] 규칙 5 Case B: drawn-meet 두 hip 90° → kLine 신규 생성.
                    //   ray-ray 가 drift(t<0) 로 pair 후보 미생성이어도 drawn segment 교점에서 사실상 만나는 케이스.
                    //   H-5/H-6 같이 RG-2 양끝 발산 hip → drawn meet 으로 동일점 stop.
                    const ea = c.extenders[0]
                    const eb = c.drawnExt
                    if (ea?.isHip && eb?.isHip && remain >= 0.5) {
                      const vax = ea.far.x - ea.near.x
                      const vay = ea.far.y - ea.near.y
                      const vbx = eb.far.x - eb.near.x
                      const vby = eb.far.y - eb.near.y
                      if (isPerpendicular(vax, vay, vbx, vby)) {
                        const eaTag = `${labelOf(ea.line) || 'H'}${ea.__reflected ? '*' : ''}${ea.__reflectedFromPending ? '!' : ''}`
                        const ebTag = `${labelOf(eb.line) || 'H'}${eb.__reflected ? '*' : ''}${eb.__reflectedFromPending ? '!' : ''}`
                        if (ea.__reflectedFromPending || eb.__reflectedFromPending) {
                          logger.log('[KERAB-APEX-SKIP-PHANTOM]', `iter${iter}/drawn-meet[${eaTag}+${ebTag}]`, {
                            x: c.point.x?.toFixed?.(2), y: c.point.y?.toFixed?.(2),
                          })
                        } else if (pushApexIfNew(c.point, `iter${iter}/drawn-meet[${eaTag}+${ebTag}]`)) {
                          pendingKLineCreated = true
                        }
                      }
                    }
                  }
                  // [KERAB-FIXPOINT-PHASE-A 2026-05-22] static 만남: ext 멈춤 + 정적 라인 절삭 정보 누적.
                  if (c.kind === 'static' && c.staticLine) {
                    cuts.push({ line: c.staticLine, point: c.point })
                  }
                  if (c.kind === 'pair' && c.bothHips) {
                    const [ea, eb] = c.extenders
                    const vax = ea.far.x - ea.near.x
                    const vay = ea.far.y - ea.near.y
                    const vbx = eb.far.x - eb.near.x
                    const vby = eb.far.y - eb.near.y
                    if (isPerpendicular(vax, vay, vbx, vby)) {
                      const eaTag = `${labelOf(ea.line) || (ea.isHip ? 'H' : 'R')}${ea.__reflected ? '*' : ''}${ea.__reflectedFromPending ? '!' : ''}`
                      const ebTag = `${labelOf(eb.line) || (eb.isHip ? 'H' : 'R')}${eb.__reflected ? '*' : ''}${eb.__reflectedFromPending ? '!' : ''}`
                      // [KERAB-MULTI-APEX 2026-05-22] pendingKLine 반사 자식이 끼인 pair-meet 은 phantom 이라 skip.
                      //   primary(H-3+H-4*: H-4는 RG-2 ridge 반사로 fromPending 아님) 는 통과,
                      //   phantom(H-16+H-2!: H-2 가 primary kLine 반사) 은 차단.
                      //   정적 hip 와의 90° 만남 apex 는 re-resolve 단계에서 따로 push.
                      if (ea.__reflectedFromPending || eb.__reflectedFromPending) {
                        logger.log('[KERAB-APEX-SKIP-PHANTOM]', `iter${iter}/pair-meet[${eaTag}+${ebTag}]`, {
                          x: c.point.x?.toFixed?.(2), y: c.point.y?.toFixed?.(2),
                        })
                      } else if (pushApexIfNew(c.point, `iter${iter}/pair-meet[${eaTag}+${ebTag}]`)) {
                        pendingKLineCreated = true
                      }
                    }
                  }
                  let hipExt = null
                  let mirrorLine = null
                  if ((c.kind === 'kline' || c.kind === 'ridge' || c.kind === 'drawn') && c.extenders[0].isHip) {
                    hipExt = c.extenders[0]
                    mirrorLine = c.mirrorLine
                  } else if (c.kind === 'pair') {
                    const [ea, eb] = c.extenders
                    if (ea.isHip && !eb.isHip) {
                      hipExt = ea
                      mirrorLine = { x1: eb.near.x, y1: eb.near.y, x2: eb.far.x, y2: eb.far.y }
                    } else if (!ea.isHip && eb.isHip) {
                      hipExt = eb
                      mirrorLine = { x1: ea.near.x, y1: ea.near.y, x2: ea.far.x, y2: ea.far.y }
                    }
                  }
                  if (hipExt && mirrorLine) {
                    const hdx = hipExt.near.x - hipExt.far.x
                    const hdy = hipExt.near.y - hipExt.far.y
                    const kdx = mirrorLine.x2 - mirrorLine.x1
                    const kdy = mirrorLine.y2 - mirrorLine.y1
                    const klen = Math.hypot(kdx, kdy) || 1
                    const nx = -kdy / klen
                    const ny = kdx / klen
                    const dot = hdx * nx + hdy * ny
                    const rdx = hdx - 2 * dot * nx
                    const rdy = hdy - 2 * dot * ny
                    // [KERAB-MULTI-APEX 2026-05-22] 같은 operation 의 pendingKLine 에 반사된 자식은
                    //   __reflectedFromPending 태그. 이 자식의 pair-meet 으로 추가 apex 생성 차단(phantom 방지).
                    //   부모(hipExt) 가 이미 pending 에서 반사된 경우도 상속.
                    const fromPending =
                      hipExt.__reflectedFromPending ||
                      (c.kind === 'kline' && pendingKLines.some(
                        (pk) => pk.x1 === mirrorLine.x1 && pk.y1 === mirrorLine.y1 && pk.x2 === mirrorLine.x2 && pk.y2 === mirrorLine.y2,
                      ))
                    newReflected.push({
                      line: hipExt.line,
                      near: { x: c.point.x, y: c.point.y },
                      far: { x: c.point.x - rdx, y: c.point.y - rdy },
                      isHip: true,
                      sourcePoint: { x: c.point.x, y: c.point.y },
                      __reflected: true,
                      __reflectedFromPending: fromPending,
                    })
                  }
                  break
                }
                if (!processedAny && !pendingKLineCreated) break
                extenderPool.push(...newReflected)
              }
              // [KERAB-ROOF-FALLBACK-ANYWALL 2026-05-21] 미해소 extender 를 roof 폴리곤의 어떤 wall 이라도
              //   inward 방향의 가장 가까운 wall 교점까지 확장. 반사 hip 이 target wall 과 반대쪽으로
              //   향해도 다른 wall 에서 정지.
              const roofPolygonWalls = []
              if (Array.isArray(roof.points) && roof.points.length >= 2) {
                for (let i = 0; i < roof.points.length; i++) {
                  roofPolygonWalls.push({
                    a: roof.points[i],
                    b: roof.points[(i + 1) % roof.points.length],
                  })
                }
              }
              // [KERAB-NO-PIERCE 2026-05-21] fallback 직진 중에도 정적 inner line(이 polygon 의 처리대상 제외)
              //   + 이번 wave 에 이미 그려질 ext 라인을 barrier 로 검사. 가장 가까운 hit 에서 정지하여
              //   다른 라인을 관통해 내부로 침입하는 케이스를 차단.
              const barrierLines = []
              for (const il of roof.innerLines || []) {
                if (!il) continue
                if (polygonLines.includes(il)) continue
                if (il.name !== LINE_TYPE.SUBLINE.HIP && il.name !== LINE_TYPE.SUBLINE.RIDGE) continue
                if (il.visible === false) continue
                barrierLines.push({ x1: il.x1, y1: il.y1, x2: il.x2, y2: il.y2 })
              }
              for (const [otherExt, otherStop] of resolved) {
                barrierLines.push({
                  x1: otherExt.sourcePoint.x,
                  y1: otherExt.sourcePoint.y,
                  x2: otherStop.x,
                  y2: otherStop.y,
                })
              }
              for (const pk of pendingKLines) barrierLines.push(pk)
              for (const ext of extenderPool) {
                if (resolved.has(ext)) continue
                let bestPt = null
                let bestDist = Infinity
                let bestSrc = null
                for (const wall of roofPolygonWalls) {
                  const ip = lineLineIntersection(ext.near, ext.far, wall.a, wall.b)
                  if (!ip) continue
                  if (!isInward(ext, ip)) continue
                  if (!isPointOnSegment(ip, wall.a.x, wall.a.y, wall.b.x, wall.b.y)) continue
                  const dist = Math.hypot(ip.x - ext.near.x, ip.y - ext.near.y)
                  if (dist < bestDist) {
                    bestDist = dist
                    bestPt = ip
                    bestSrc = { kind: 'wall', a: wall.a, b: wall.b }
                  }
                }
                for (const bl of barrierLines) {
                  const ip = lineLineIntersection(ext.near, ext.far, { x: bl.x1, y: bl.y1 }, { x: bl.x2, y: bl.y2 })
                  if (!ip) continue
                  if (!isInward(ext, ip)) continue
                  if (!isPointOnSegment(ip, bl.x1, bl.y1, bl.x2, bl.y2)) continue
                  const dist = Math.hypot(ip.x - ext.near.x, ip.y - ext.near.y)
                  if (dist < 1e-3) continue
                  if (dist < bestDist) {
                    bestDist = dist
                    bestPt = ip
                    bestSrc = { kind: 'barrier', a: { x: bl.x1, y: bl.y1 }, b: { x: bl.x2, y: bl.y2 } }
                  }
                }
                logger.log(
                  '[KERAB-FALLBACK] ext=' + (labelOf(ext.line) || (ext.isHip ? 'H' : 'R')) +
                    ' near=' + JSON.stringify({ x: Math.round(ext.near.x * 100) / 100, y: Math.round(ext.near.y * 100) / 100 }) +
                    ' stop=' + (bestPt ? JSON.stringify({ x: Math.round(bestPt.x * 100) / 100, y: Math.round(bestPt.y * 100) / 100 }) : 'null') +
                    ' src=' + (bestSrc
                      ? bestSrc.kind +
                        '[' +
                        Math.round(bestSrc.a.x * 100) / 100 + ',' + Math.round(bestSrc.a.y * 100) / 100 +
                        '→' +
                        Math.round(bestSrc.b.x * 100) / 100 + ',' + Math.round(bestSrc.b.y * 100) / 100 +
                        ']'
                      : 'none'),
                )
                if (bestPt) resolved.set(ext, bestPt)
              }
              // [KERAB-FIXPOINT-PHASE-A 2026-05-22] cuts 적용 — 사용자 멘탈모델:
              //   절삭 방향 = static line 이 "확장되는 방향" (= inward extension 의 anchor 쪽).
              //   거리 기반(만남점에 가까운 쪽) 가 아니다 — junction-extended outer hip 의 경우
              //   우연히 일치할 뿐. extension source 끝점 = 확장 anchor = junction stub = 제거.
              //   반대편 = dead-end = 유지.
              //   (a) static cut: 확장 방향 끝점을 만남점까지 잘라낸다.
              //   (b) 확장 자체 purge: 같은 line 의 wave drawn(inward 확장) 제거.
              //   (c) cascade: 제거된 끝점을 source/stop 으로 쓰던 다른 drawn segment 도 정리.
              //   (d) re-resolve: stop 점이 죽은 segment(잘려나간 stub 또는 purge 된 확장)
              //       위에 있던 다른 resolved entry 는 unresolved 로 되돌리고, 새 상태로
              //       wall + barrier 까지 재확장한다 (Phase A의 "다음 행위").
              // [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)
                    for (const ext of staleExts) {
                      let bestPt = null
                      let bestDist = Infinity
                      for (const wall of roofPolygonWalls) {
                        const ip = lineLineIntersection(ext.near, ext.far, wall.a, wall.b)
                        if (!ip) continue
                        if (!isInward(ext, ip)) continue
                        if (!isPointOnSegment(ip, wall.a.x, wall.a.y, wall.b.x, wall.b.y)) continue
                        const dist = Math.hypot(ip.x - ext.near.x, ip.y - ext.near.y)
                        if (dist < 1e-3) continue
                        if (dist < bestDist) { bestDist = dist; bestPt = ip }
                      }
                      for (const bl of barriers2) {
                        const ip = lineLineIntersection(ext.near, ext.far, { x: bl.x1, y: bl.y1 }, { x: bl.x2, y: bl.y2 })
                        if (!ip) continue
                        if (!isInward(ext, ip)) continue
                        if (!isPointOnSegment(ip, bl.x1, bl.y1, bl.x2, bl.y2)) continue
                        const dist = Math.hypot(ip.x - ext.near.x, ip.y - ext.near.y)
                        if (dist < 1e-3) continue
                        if (dist < bestDist) { bestDist = dist; bestPt = ip }
                      }
                      if (bestPt) {
                        resolved.set(ext, bestPt)
                        reResolved += 1
                      }
                      logger.log(
                        '[KERAB-FIXPOINT-PHASE-A] re-resolve ext=' + (labelOf(ext.line) || (ext.isHip ? 'H' : 'R')) +
                          ' near={' + Math.round(ext.near.x * 100) / 100 + ',' + Math.round(ext.near.y * 100) / 100 + '}' +
                          ' newStop=' + (bestPt ? '{' + Math.round(bestPt.x * 100) / 100 + ',' + Math.round(bestPt.y * 100) / 100 + '}' : 'null'),
                      )
                    }
                  }
                  // [KERAB-FIXPOINT-PHASE-A 2026-05-22] re-resolve 후 새 stop 이 정적 inner hip
                  //   위면 hip+hip 만남(또는 hip+static-hip) 으로 간주 → cuts 추가 + apex/kLine.
                  //   같은 cuts 루프에서 다음 pass 처리(while/index).
                  let newCuts = 0
                  for (const ext of staleExts) {
                    const newStop = resolved.get(ext)
                    if (!newStop) continue
                    for (const il of roof.innerLines || []) {
                      if (!il) continue
                      if (polygonLines.includes(il)) continue
                      if (il.name !== LINE_TYPE.SUBLINE.HIP) continue
                      if (il.visible === false) continue
                      const already = cuts.some(
                        (c) => c.line === il && Math.hypot(c.point.x - newStop.x, c.point.y - newStop.y) < 0.5,
                      )
                      if (already) continue
                      if (!isPointOnSegment(newStop, il.x1, il.y1, il.x2, il.y2, 0.5)) continue
                      cuts.push({ line: il, point: { x: newStop.x, y: newStop.y } })
                      newCuts += 1
                      // [KERAB-MULTI-APEX 2026-05-22] re-resolve 의 정적 hip 만남(H-2반사 + H-14)이 90° 면 kLine 추가.
                      if (ext.isHip) {
                        const vax = ext.far.x - ext.near.x
                        const vay = ext.far.y - ext.near.y
                        const vbx = il.x2 - il.x1
                        const vby = il.y2 - il.y1
                        if (isPerpendicular(vax, vay, vbx, vby)) {
                          pushApexIfNew(newStop, `reresolve/ext=${labelOf(ext) || '?'}/il=${labelOf(il) || '?'}`)
                        }
                      }
                      break
                    }
                  }
                  logger.log(
                    '[KERAB-FIXPOINT-PHASE-A] cut applied line=' + (labelOf(line) || 'H?') +
                      ' dir=' + dirSource +
                      ' purgedLine=' + purgedLine + ' purgedCascade=' + purgedCascade +
                      ' stale=' + staleExts.length + ' reResolved=' + reResolved +
                      ' newCuts=' + newCuts +
                      ' removedEnd={' + Math.round(removedEnd.x * 100) / 100 + ',' + Math.round(removedEnd.y * 100) / 100 + '}',
                  )
                }
              }
              const extLines = []
              for (const [ext, stop] of resolved) {
                const fromPt = ext.sourcePoint
                if (Math.hypot(stop.x - fromPt.x, stop.y - fromPt.y) < 0.5) continue
                extLines.push({ from: fromPt, to: stop, isHip: ext.isHip })
              }
              const drawKLine = apexList.length > 0
              const markerApex = apexList.length > 0 ? apexList[0].point : (extLines.length > 0 ? extLines[0].to : null)
              const extraApexes = apexList.slice(1).map((ap) => ap.point)
              logger.log(
                '[KERAB-SIMPLE] sequential resolve ' +
                  JSON.stringify({
                    extLines: extLines.map((e) => ({
                      from: { x: Math.round(e.from.x * 100) / 100, y: Math.round(e.from.y * 100) / 100 },
                      to: { x: Math.round(e.to.x * 100) / 100, y: Math.round(e.to.y * 100) / 100 },
                      isHip: e.isHip,
                    })),
                    drawKLine,
                    markerApex: markerApex
                      ? { x: Math.round(markerApex.x * 100) / 100, y: Math.round(markerApex.y * 100) / 100 }
                      : null,
                    apexList: apexList.map((ap) => ({
                      x: Math.round(ap.point.x * 100) / 100,
                      y: Math.round(ap.point.y * 100) / 100,
                    })),
                  }),
              )
              if (markerApex) {
                const pathHips = polygonPath.filter((p) => p.line.name === LINE_TYPE.SUBLINE.HIP).map((p) => p.line)
                const pathRidges = polygonPath.filter((p) => p.line.name === LINE_TYPE.SUBLINE.RIDGE).map((p) => p.line)
                target.set({ attributes })
                applyKerabKLinePattern(
                  roof,
                  target,
                  markerApex,
                  h1Match.near,
                  h2Match.near,
                  [h1Match.hip, h2Match.hip, ...pathHips],
                  pathRidges,
                  extLines,
                  drawKLine,
                  extraApexes,
                )
                // [KERAB-VALLEY-EXT 2026-05-27] valley 처마확장 raycast + drawing — applyKerabKLinePattern 후 실행.
                //   raycast 대상 = 현재 roof.innerLines 중 HIP/RIDGE (= 살아남은 hip·ridge + 새 extLines·kLine 모두 포함).
                //   사라진 polygonPath hip/ridge 는 이미 제거되어 자동 제외. valleyExt 자신은 push 후이므로 1mm 필터로 보호.
                if (valleyPlannedEndpoints.length) {
                  const isOnSegV = (pt, ax, ay, bx, by, tol = 0.5) => {
                    const sdx = bx - ax
                    const sdy = by - ay
                    const lenSq = sdx * sdx + sdy * sdy
                    if (lenSq < 1e-6) return Math.hypot(pt.x - ax, pt.y - ay) <= tol
                    const tt = ((pt.x - ax) * sdx + (pt.y - ay) * sdy) / lenSq
                    const margin = tol / Math.sqrt(lenSq)
                    if (tt < -margin || tt > 1 + margin) return false
                    const px = ax + tt * sdx
                    const py = ay + tt * sdy
                    return Math.hypot(px - pt.x, py - pt.y) <= tol
                  }
                  const valleyExtensions = []
                  for (const ep of valleyPlannedEndpoints) {
                    const start = { x: ep.sx, y: ep.sy }
                    // [KERAB-VALLEY-EXT 2026-05-27] self-extension 방향만 사용 (양 끝점 둘 다 시도).
                    //   concave corner 측 끝점 → polygon 내부로 향해 hip/ridge hit → 그려짐.
                    //   convex 측 끝점 → polygon 외부로 새서 hit 없음 → 자동 skip.
                    const dx = ep.sx - ep.ox
                    const dy = ep.sy - ep.oy
                    const len = Math.hypot(dx, dy) || 1
                    const ux = dx / len
                    const uy = dy / len
                    const FAR_RAY = 1e5
                    const rayEnd = { x: start.x + ux * FAR_RAY, y: start.y + uy * FAR_RAY }
                    let bestStop = null
                    let bestT = Infinity
                    let bestHit = null
                    for (const il of roof.innerLines || []) {
                      if (!il) continue
                      // [KERAB-VALLEY-EXT 2026-05-27] stopper = HIP / RIDGE 만.
                      if (il.lineName === 'kerabPatternValleyExt') continue
                      if (il.name !== LINE_TYPE.SUBLINE.HIP && il.name !== LINE_TYPE.SUBLINE.RIDGE) continue
                      if (il.visible === false) continue
                      const a = { x: il.x1, y: il.y1 }
                      const b = { x: il.x2, y: il.y2 }
                      const ip = lineLineIntersection(start, rayEnd, a, b)
                      if (!ip) continue
                      if (!isOnSegV(ip, a.x, a.y, b.x, b.y)) continue
                      const t = (ip.x - start.x) * ux + (ip.y - start.y) * uy
                      if (t < 1.0) continue
                      if (t < bestT) {
                        bestT = t
                        bestStop = ip
                        bestHit = il
                      }
                    }
                    if (bestStop) {
                      const seg = {
                        x1: start.x,
                        y1: start.y,
                        x2: bestStop.x,
                        y2: bestStop.y,
                        source: ep.label,
                        parent: ep.parent || null,
                        hitLine: bestHit,
                        hitPoint: { x: bestStop.x, y: bestStop.y },
                        hitLineName: bestHit && bestHit.lineName,
                        hitName: bestHit && bestHit.name,
                      }
                      valleyExtensions.push(seg)
                      logger.log('[KERAB-VALLEY-EXT] generated ' + JSON.stringify(seg))
                    } else {
                      logger.log('[KERAB-VALLEY-EXT] no ridge/hip hit for ' + ep.label)
                    }
                  }
                  // [KERAB-VALLEY-EXT-TRIM 2026-05-27] 처마확장 segment 는 1순위로 보존 (위에서 그려진 hitPoint 까지 그대로).
                  //   다음 단계: 처마확장이 만난 hitLine(hip/ridge) 의 외곽측 끝점을 hitPoint 로 단축(절삭).
                  //   도미노: 단축된 hitLine 의 옛 외곽 끝점에 닿아있던 다른 hip/ridge 의 그 끝점도 hitPoint 로 cascade 이동.
                  //   revert 시 trimRecords 역순 복원 (도미노 → 원본 trim 순).
                  //   [2026-05-27 비활성] flag=false. junction 공유 hip 까지 cascade 되는 부작용 (예: H-2 의도 외 절삭)
                  //   확인 — 절삭 모델은 다음 페이즈에서 concave-side-only 판정 추가 후 재활성.
                  const ENABLE_VALLEY_EXT_TRIM = false
                  const trimRecords = []
                  const TOL_DOMINO = 1.0
                  if (ENABLE_VALLEY_EXT_TRIM) for (const vr of valleyExtensions) {
                    if (!vr.source || !vr.source.startsWith('roofBase')) continue
                    if (!vr.hitLine || !vr.hitPoint) continue
                    const il = vr.hitLine
                    const hp = vr.hitPoint
                    const d1 = Math.hypot(il.x1 - vr.x1, il.y1 - vr.y1)
                    const d2 = Math.hypot(il.x2 - vr.x1, il.y2 - vr.y1)
                    const trimEnd = d1 < d2 ? 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: hp.x, y: hp.y },
                      originalAttrs: { ...(il.attributes || {}) },
                    })
                    if (trimEnd === 1) il.set({ x1: hp.x, y1: hp.y })
                    else il.set({ x2: hp.x, y2: hp.y })
                    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 }, hp }),
                    )
                    for (const other of roof.innerLines || []) {
                      if (!other || other === il) continue
                      if (other.lineName === 'kerabPatternValleyExt') continue
                      if (other.name !== LINE_TYPE.SUBLINE.HIP && other.name !== LINE_TYPE.SUBLINE.RIDGE) continue
                      const m1 = Math.hypot(other.x1 - oldX, other.y1 - oldY) <= TOL_DOMINO
                      const m2 = Math.hypot(other.x2 - oldX, other.y2 - oldY) <= TOL_DOMINO
                      if (!m1 && !m2) continue
                      trimRecords.push({
                        line: other,
                        end: m1 ? 1 : 2,
                        oldPt: { x: oldX, y: oldY },
                        newPt: { x: hp.x, y: hp.y },
                        originalAttrs: { ...(other.attributes || {}) },
                        domino: true,
                      })
                      if (m1) other.set({ x1: hp.x, y1: hp.y })
                      else other.set({ x2: hp.x, y2: hp.y })
                      const oSz = calcLinePlaneSize({ x1: other.x1, y1: other.y1, x2: other.x2, y2: other.y2 })
                      other.attributes = { ...other.attributes, planeSize: oSz, actualSize: oSz }
                      logger.log(
                        '[KERAB-VALLEY-EXT-TRIM] domino ' + JSON.stringify({ name: other.name, lineName: other.lineName, hp }),
                      )
                    }
                  }
                  if (trimRecords.length) target.__valleyExtTrims = trimRecords

                  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'))
                    const baseAttrs = { roofId: roof.id, planeSize: sz, actualSize: sz }
                    if (isRoofBase) {
                      // [KERAB-VALLEY-EXT 2026-05-27] splitPolygonWithLines 의 innerLineMapping 은
                      //   EAVES polygonLine 을 skip 하므로(usePolygon.js:822) 처마확장은 자동 매핑이 안 된다.
                      //   처마 라인 매핑과 동일하게 type/isStart 를 직접 부여.
                      baseAttrs.type = LINE_TYPE.WALLLINE.EAVES
                      baseAttrs.isStart = true
                    }
                    const vExt = new QLine(pts, {
                      parentId: roof.id,
                      fontSize: roof.fontSize,
                      stroke: '#1083E3',
                      strokeWidth: 3,
                      name: LINE_TYPE.SUBLINE.VALLEY,
                      textMode: roof.textMode,
                      attributes: baseAttrs,
                    })
                    vExt.lineName = 'kerabPatternValleyExt'
                    vExt.__targetId = target.id
                    vExt.__valleyExtSource = vr.source
                    if (isRoofBase && vr.parent) {
                      vExt.parentLine = vr.parent
                      // [KERAB-VALLEY-EXT 2026-05-27] direction 도 부모 roofLine 에서 상속 — flow/pitch 방향 일관.
                      if (vr.parent.direction) vExt.direction = vr.parent.direction
                    }
                    canvas.add(vExt)
                    vExt.bringToFront()
                    if (isRoofBase) roof.innerLines.push(vExt)
                  }
                  if (valleyExtensions.length) {
                    logger.log('[KERAB-VALLEY-EXT] drawn ' + valleyExtensions.length)
                  }
                }
                logger.log('[KERAB-SIMPLE] applied (sequential, drawKLine=' + drawKLine + ', extraApexes=' + extraApexes.length + ')')
                return
              }
              logger.log('[KERAB-SIMPLE] no resolution possible — fallback attr-only')
              target.set({ attributes })
              applyKerabAttributeOnlyPattern()
              return
            }
            // condition 1: 자연 만남 — ext 없이 hip 제거 + kLine
            target.set({ attributes })
            applyKerabKLinePattern(
              roof,
              target,
              apex,
              h1Match.near,
              h2Match.near,
              [h1Match.hip, h2Match.hip],
              null,
              null,
            )
            logger.log('[KERAB-SIMPLE] applied (kLine, natural-apex)')
            return
          }
        }
        target.set({ attributes })
        applyKerabAttributeOnlyPattern()
        logger.log('[KERAB-SIMPLE] attr-only fallback')
        return
      }
    }

    // [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)) {
        const c1 = nearestRoofPoint(roof, { x: target.x1, y: target.y1 })
        const c2 = nearestRoofPoint(roof, { x: target.x2, y: target.y2 })
        if (c1 && c2) {
          // [KERAB-OFFSET-SURGICAL 2026-05-27] revert 경로에서는 hip snapshot 좌표가 옛 corner 기준이라
          //   surgical 을 pattern 호출 **후**로 미룬다. pattern 이 옛 corner 로 hip 복원 후, surgical 의
          //   inner-line corner snap 이 hip 끝점도 새 corner 로 함께 이동시킨다.
          const surgicalAfter = () => {
            if (roof) applyTargetOffsetSurgical(target, attributes?.offset ?? 0)
          }
          // [2240 KERAB-PARALLEL-HIPS 2026-05-19] forward 가 parallel-hips 였으면 target 에 스냅샷이 붙어있음 → hip 2개 복원
          if (Array.isArray(target.__kerabParallelHipsSnapshot)) {
            target.set({ attributes })
            revertKerabParallelHipsPattern(roof, target)
            surgicalAfter()
            logger.log('[KERAB-REVERT] applied (parallel-hips) ' + JSON.stringify({ c1, c2 }))
            return
          }
          // [KERAB-SIMPLE-REVERT 2026-05-20] kLineOnly 패턴: ridge.__targetId 로 직접 매칭 (nearestRoofPoint drift 회피)
          const kLineRidge = roof.innerLines.find(
            (il) => il && il.__patternKind === 'kLineOnly' && il.__targetId === target.id,
          )
          if (kLineRidge) {
            target.set({ attributes })
            const ok = applyKerabRevertPattern(roof, target, c1, c2, { ridge: kLineRidge, apex: null })
            if (ok) surgicalAfter()
            logger.log('[KERAB-REVERT] applied (kLineOnly via targetId) ' + JSON.stringify({ ok }))
            if (ok) return
          }
          // [2240 KERAB-MID-FROM-TARGET 2026-05-20] revert 도 target 중점 기준 ridge 검색 (forward 와 일관)
          const tEnd1 = { x: target.x1, y: target.y1 }
          const tEnd2 = { x: target.x2, y: target.y2 }
          const ridgeAtMid = findRidgeAtMidpoint(roof, tEnd1, tEnd2)
          if (ridgeAtMid) {
            target.set({ attributes })
            const ok = applyKerabRevertPattern(roof, target, c1, c2, ridgeAtMid)
            if (ok) surgicalAfter()
            logger.log('[KERAB-REVERT] applied ' + JSON.stringify({ ok, c1, c2, apex: ridgeAtMid.apex }))
            if (ok) return
          }
          // [2240 KERAB-ATTR-ONLY 2026-05-19] ridge-at-mid 없음 → forward 가 attribute-only 였음 → 동일 대칭으로 속성만 토글
          target.set({ attributes })
          applyKerabAttributeOnlyPattern()
          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) => {
    if (!ENABLE_KERAB_OFFSET_SURGICAL) return false
    return applyKerabOffsetSurgical(canvas, target, newOffset)
  }


  // [2240 KERAB-SINGLE-RIDGE 2026-05-19] 헬퍼 — 양 끝점 hip 페어 식별 및 ridge 단일화 적용
  const KERAB_TOL = 0.5
  const isSamePt = (a, b) => Math.abs(a.x - b.x) < KERAB_TOL && Math.abs(a.y - b.y) < KERAB_TOL

  // 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 전체 스캔.
    const valleyExtsToRemove = (canvas.getObjects() || []).filter(
      (il) => il && il.lineName === 'kerabPatternValleyExt' && il.__targetId === target.id,
    )
    for (const v of valleyExtsToRemove) {
      removeLine(v)
      roof.innerLines = roof.innerLines.filter((il) => il !== v)
    }
    if (valleyExtsToRemove.length) {
      logger.log('[KERAB-VALLEY-EXT] revert removed ' + valleyExtsToRemove.length)
    }
    // [KERAB-VALLEY-EXT-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
        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
      }
      logger.log('[KERAB-VALLEY-EXT-TRIM] revert restored ' + target.__valleyExtTrims.length + ' trim(s)')
      delete target.__valleyExtTrims
    }
    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
      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)
      }
      removeLine(ridgeAtMid.ridge)
      roof.innerLines = roof.innerLines.filter((il) => il !== ridgeAtMid.ridge)
      for (const snap of removedHips) {
        const sz = calcLinePlaneSize({ x1: snap.x1, y1: snap.y1, x2: snap.x2, y2: snap.y2 })
        const hip = new QLine([snap.x1, snap.y1, snap.x2, snap.y2], {
          parentId: roof.id,
          fontSize: roof.fontSize,
          stroke: '#1083E3',
          strokeWidth: 3,
          name: LINE_TYPE.SUBLINE.HIP,
          textMode: roof.textMode,
          attributes: { roofId: roof.id, planeSize: sz, actualSize: sz, ...(snap.attributes || {}) },
        })
        if (snap.lineName) hip.lineName = snap.lineName
        if (snap.__extended) hip.__extended = snap.__extended
        canvas.add(hip)
        hip.bringToFront()
        roof.innerLines.push(hip)
      }
      // [KERAB-SIMPLE-MIDRIDGE 2026-05-20] forward 시 제거됐던 hip-사이 ridge 복원.
      for (const snap of removedRidges) {
        if (!snap) continue
        const pts = [snap.x1, snap.y1, snap.x2, snap.y2]
        const sz = calcLinePlaneSize({ x1: pts[0], y1: pts[1], x2: pts[2], y2: pts[3] })
        const restored = new QLine(pts, {
          parentId: roof.id,
          fontSize: roof.fontSize,
          stroke: '#1083E3',
          strokeWidth: 3,
          name: LINE_TYPE.SUBLINE.RIDGE,
          textMode: roof.textMode,
          attributes: { roofId: roof.id, planeSize: sz, actualSize: sz, ...(snap.attributes || {}) },
        })
        if (snap.lineName) restored.lineName = snap.lineName
        canvas.add(restored)
        restored.bringToFront()
        roof.innerLines.push(restored)
      }
      removeKerabHalfLabels(target.id)
      hideOriginalLengthText(target.id, false)
      canvas.renderAll()
      return true
    }

    // junctionExtended: ext hip 2개 + ridge 1개 제거 + 제거됐던 RG-1 + outer/inner hip 4개 복원
    if (ridgeAtMid.ridge.__patternKind === 'junctionExtended') {
      const extHips = Array.isArray(ridgeAtMid.ridge.__patternExtHips) ? ridgeAtMid.ridge.__patternExtHips : []
      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-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-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 }
}