/**
 * Viewer2D — three.js renderer for DWG/DXF parseResult (orthographic 2D drawing).
 * Ported from webviewer/src/viewer/Viewer3D.js (class renamed 3D→2D) for the
 * 2D+3D merge. Renders CAD entities as LineSegments / Mesh / CanvasTexture sprites.
 * Supported: LINE, CIRCLE, ARC, LWPOLYLINE, POLYLINE, POINT, ELLIPSE, SOLID,
 *            TEXT, MTEXT, INSERT (ownerHandle block expansion), HATCH (solid+outline+bulge),
 *            DIMENSION_LINEAR/ALIGNED/RADIUS/DIAMETER/ANG_3PT/ANG_2LN/ORDINATE
 */
import * as THREE from 'three';
import { OrbitControls } from 'three/examples/jsm/controls/OrbitControls.js';
import { aciToHex } from './aciColors.js';
import { SlugTextEngine, SlugTextBatch } from './slugText';

const DEFAULT_COLOR = 0xc9d1d9;
const ARC_SEGS      = 64;
const ELLIPSE_SEGS  = 72;
const CLICK_THRESHOLD_PX = 14;

function stripMText(s) {
  if (!s) return '';
  return s
    .replace(/\\A\d+;/g, '')            // \A1; vertical alignment
    .replace(/\\p[^;]*;/g, '')          // \p...; paragraph properties (lowercase, has ;)
    .replace(/\\P/g, '\n')              // \P paragraph break → newline (capital, no ;)
    .replace(/\\[a-zA-Z][^;]*;/g, '')   // remaining inline codes \f \H \C \W \Q \T...
    .replace(/\{[^{}]*\}/g, m => stripMText(m.slice(1, -1)))
    .replace(/%%d/gi, '°').replace(/%%p/gi, '±').replace(/%%c/gi, 'Ø')
    .replace(/[{}]/g, '')
    .replace(/[ \t]{2,}/g, ' ')         // collapse runs of spaces
    .replace(/^[ \t]+|[ \t]+$/gm, '')   // trim each line's edges (keeps interior \n)
    .replace(/\n{3,}/g, '\n\n')
    .replace(/^\n+|\n+$/g, '');         // drop leading/trailing blank lines
}

export class Viewer2D {
  constructor(container) {
    this._container = container;
    this._entityMeta = [];
    this._layerByHandle = new Map();
    this._layerByName   = new Map();
    this._onSelectCb    = null;
    this._measureActive = false;
    this._measureCb     = null;
    this._measurePtA    = null;
    this._measureMarkers = [];
    this._textGen = 0; // invalidation token for the async Slug text flush
    SlugTextEngine.shared().catch(() => {}); // warm the font load; sprite fallback covers failure

    this._scene = new THREE.Scene();
    this._scene.background = new THREE.Color(0x0d1117);

    const w = container.clientWidth  || 800;
    const h = container.clientHeight || 600;
    this._camera = new THREE.OrthographicCamera(-w/2, w/2, h/2, -h/2, -10000, 10000);
    this._camera.position.set(0, 0, 100);

    this._renderer = new THREE.WebGLRenderer({ antialias: true, preserveDrawingBuffer: true });
    this._renderer.setPixelRatio(window.devicePixelRatio);
    this._renderer.setSize(w, h);
    container.appendChild(this._renderer.domElement);

    this._controls = new OrbitControls(this._camera, this._renderer.domElement);
    this._controls.enableRotate    = false;
    this._controls.screenSpacePanning = true;
    this._controls.zoomToCursor   = true;
    this._controls.mouseButtons   = { LEFT: THREE.MOUSE.PAN, MIDDLE: THREE.MOUSE.PAN, RIGHT: THREE.MOUSE.PAN };
    this._controls.touches        = { ONE: THREE.TOUCH.PAN, TWO: THREE.TOUCH.DOLLY_PAN };

    const savedSpeed = localStorage.getItem('hmw:zoom-speed');
    if (savedSpeed) {
      const speed = parseFloat(savedSpeed);
      if (!isNaN(speed)) {
        this._controls.zoomSpeed = speed;
      }
    }

    window.addEventListener('keydown', (e) => { if (e.key === 'f' || e.key === 'F') this.fit(); });

    this._group = new THREE.Group();
    this._scene.add(this._group);

    window.addEventListener('resize', () => this._onResize());
    // Prevent browser auto-scroll popup when middle-button is pressed on the WebGL canvas
    this._renderer.domElement.addEventListener('pointerdown', (e) => {
      if (e.button === 1) e.preventDefault();
    });
    this._renderer.domElement.addEventListener('mousedown', (e) => {
      this._downXY = [e.clientX, e.clientY];
      if (e.button === 1) e.preventDefault();
    });
    this._renderer.domElement.addEventListener('click', (e) => this._onClick(e));
    this._selColor = { r: 0xd8 / 255, g: 0x3a / 255, b: 0x2f / 255 };
    this._gridVisible = false;
    this._gridMesh = null;
    this._controls.addEventListener('change', () => { if (this._gridVisible) this._rebuildGrid(); });
    this._animate();
  }

  onSelect(cb) { this._onSelectCb = cb; }
  resize()     { this._onResize(); }
  setZoomSpeed(speed) { if (this._controls) this._controls.zoomSpeed = speed; }
  getZoomSpeed() { return this._controls ? this._controls.zoomSpeed : 1.0; }

  fit() {
    const box = new THREE.Box3();
    this._group.traverse(obj => { if (obj.geometry) box.expandByObject(obj); });
    if (!box.isEmpty()) this._fit(box);
  }

  load(result, opts = {}) {
    this._lastResult = result;
    this._selMeta = null;
    this._clear();
    this._entityMeta = [];
    this._buildLayerMap(result?.tables?.layers);
    this._buildLinetypeMap(result);
    // Sheet orientation: the active model-space viewport's VIEWTWIST rotates the
    // view so a drawing stored tilted in WCS (rotated survey sheets — header UCS
    // stays identity) displays with its title border upright. Applied as a
    // camera-up rotation in _fit (geometry untouched → picking stays exact).
    this._viewTwist = this._readViewTwist(result);
    // Geometric pick index — the ACTUAL rendered geometry, not a bounds proxy.
    // _pickSegs: flat [ax,ay,bx,by,…] of every line segment (lines, arcs, circles,
    // polylines, block wires, dimension leaders/arrows) with a parallel owner-meta
    // index. _pickFills: filled regions (hatch loops, SOLID quads, text quads)
    // tested by even-odd point-in-polygon. _onClick raycasts these directly.
    this._pickSegs = [];
    this._pickSegMeta = [];
    this._pickFills = [];
    this._pickCurIdx = -1;

    const entities    = result?.entities || [];
    const lineVerts   = [];
    const lineColors  = [];
    // Dashed-linetype segments go into separate buckets keyed by dash|gap size;
    // each becomes its own LineDashedMaterial LineSegments at assembly. Solid
    // (Continuous / ByLayer→Continuous) segments stay in lineVerts/lineColors.
    const dashBuckets = new Map();
    let curDash = null; // {key,dash,gap} for the entity currently being emitted
    const box         = new THREE.Box3();
    const _tmp        = new THREE.Vector3();
    const pendingTexts = [];

    // Build set of user block definition handles.
    // Block-def entities have ownerHandle = their block's handle. They're rendered
    // via INSERT (_insertEntities) and must be SKIPPED in the main loop to avoid
    // expanding the bounding box with block-local coordinates (near 0,0), which
    // would make the real drawing appear as a tiny speck on zoom-extents.
    const blockDefHandles = new Set();
    // Also track model/paper space handles to verify correctness
    const spaceHandles = new Set();
    // Block header handle (hex) → basePoint, for nested INSERT transform composition.
    const blockBaseByHex = new Map();
    const blockNameByHex = new Map();
    for (const b of (result?.tables?.blocks ?? [])) {
      const name = (b.name ?? '').toLowerCase().replace(/\*/g, '').trim();
      const h = typeof b.handle === 'object' ? b.handle?.value?.toString(16) : b.handle?.toString(16);
      if (!h) continue;
      if (b.basePoint) blockBaseByHex.set(h, b.basePoint);
      blockNameByHex.set(h, (b.name ?? '').toLowerCase());
      // System space blocks: any of these names → entity owner, render directly
      if (name === 'model_space' || name === 'paper_space' ||
          name === 'ms' || name === 'ps' ||
          name.startsWith('model') || name.startsWith('paper') ||
          name === '') {
        spaceHandles.add(h);
      } else {
        blockDefHandles.add(h);
      }
    }
    // Safety: if spaceHandles is empty we couldn't identify model space →
    // disable the filter entirely to avoid hiding everything.
    const useBlockFilter = spaceHandles.size > 0;
    this._blockCount = blockDefHandles.size;

    // Pre-group all entities by ownerHandle hex string for O(1) lookup.
    // Without this, every INSERT/DIMENSION does entities.filter() = O(n) per call = O(n²) total.
    const entsByOwner = new Map();
    for (const ent of entities) {
      const key = ent.ownerHandle?.value?.toString(16);
      if (key != null) {
        if (!entsByOwner.has(key)) entsByOwner.set(key, []);
        entsByOwner.get(key).push(ent);
      }
    }

    const expand  = (x, y, z = 0) => box.expandByPoint(_tmp.set(x, y, z));
    const pushSeg = (ax, ay, bx, by, z, color) => {
      const r = ((color >> 16) & 0xFF) / 255;
      const g = ((color >>  8) & 0xFF) / 255;
      const b = (color         & 0xFF) / 255;
      if (curDash) {
        let bk = dashBuckets.get(curDash.key);
        if (!bk) { bk = { dash: curDash.dash, gap: curDash.gap, verts: [], colors: [] }; dashBuckets.set(curDash.key, bk); }
        bk.verts.push(ax, ay, z, bx, by, z);
        bk.colors.push(r, g, b, r, g, b);
      } else {
        lineVerts.push(ax, ay, z, bx, by, z);
        lineColors.push(r, g, b, r, g, b);
      }
      if (this._pickCurIdx >= 0) { this._pickSegs.push(ax, ay, bx, by); this._pickSegMeta.push(this._pickCurIdx); }
      expand(ax, ay, z); expand(bx, by, z);
    };

    for (const e of entities) {
      // Skip block-definition entities — they live at block-local coords and are
      // rendered at correct world positions via INSERT / _insertEntities.
      // Only apply filter when we've successfully identified model/paper space handles.
      const ownerHex = e.ownerHandle?.value?.toString(16);
      if (useBlockFilter && ownerHex && blockDefHandles.has(ownerHex)) continue;
      if (this._hiddenLayers?.size) {
        const lh = e.layerHandle?.value ?? e.layerHandle;
        const lname = (lh != null && this._layerNameByHandle.get(String(lh))) ?? e.layer ?? e.layerName;
        if (lname && this._hiddenLayers.has(lname)) continue;
      }
      const d    = e.data || e;
      const type = (e.type || e.typeName || '').toUpperCase();
      const color = this._entityColor(e);
      curDash = this._resolveDash(e);
      const meta  = { entity: e, type, bounds: null, colStart: lineColors.length };
      this._entityMeta.push(meta);
      this._pickCurIdx = this._entityMeta.length - 1; // owner for pick geometry emitted below

      try {
        switch (type) {

          // ── Basic geometry ────────────────────────────────────────────────
          case 'LINE':
            if (d.start && d.end) {
              pushSeg(d.start.x, d.start.y, d.end.x, d.end.y, d.start.z || 0, color);
              meta.bounds = { type:'line', x1:d.start.x, y1:d.start.y, x2:d.end.x, y2:d.end.y };
            }
            break;

          case 'CIRCLE':
            if (d.center && d.radius != null) {
              this._arcSegs(d.center, d.radius, 0, Math.PI*2, d.center.z||0, color, pushSeg);
              meta.bounds = { type:'circle', cx:d.center.x, cy:d.center.y, r:d.radius };
            }
            break;

          case 'ARC':
            if (d.center && d.radius != null) {
              this._arcSegs(d.center, d.radius, d.startAngle??0, d.endAngle??Math.PI*2, d.center.z||0, color, pushSeg);
              meta.bounds = { type:'circle', cx:d.center.x, cy:d.center.y, r:d.radius };
            }
            break;

          case 'LWPOLYLINE':
            if (d.points?.length) {
              const hasBulge = d.bulges?.some(b => Math.abs(b) >= 1e-6);
              const closed = !!(d.closed || (d.flags & 1));
              const nSeg = closed ? d.points.length : d.points.length - 1;
              if (this._polyHasWidth(e, nSeg, 1)) {
                this._widePolyMesh(d.points, d.bulges, closed, e, color, 1, expand);
              } else if (hasBulge) {
                this._bulgePolySegs(d.points, d.bulges, closed, color, pushSeg, expand);
              } else {
                this._polylineSegs(d.points, closed, d.elevation||0, color, pushSeg);
                d.points.forEach(p => expand(p.x, p.y, d.elevation||0));
              }
              // Note: uncovered-poly fill is only applied in _insertEntities (block
              // glyphs). Model-space polylines can be huge parcels — never fill those.
              meta.bounds = { type:'point', cx:d.points[0].x, cy:d.points[0].y };
            }
            break;

          case 'POLYLINE':
            this._polylineSegs(d.vertices||d.points, d.closed||(d.flags&1), 0, color, pushSeg);
            break;

          case 'POLYLINE_2D': {
            // Old-style 2D polyline: vertices are separate VERTEX_2D entities
            // owned by this polyline (point/bulge at top level, not under .data).
            const kids = (entsByOwner.get(e.handle?.value?.toString(16)) ?? [])
              .filter(v => (v.type||'').toUpperCase().startsWith('VERTEX') && v.point);
            if (kids.length >= 2) {
              const pts    = kids.map(v => v.point);
              const bulges = kids.map(v => v.bulge || 0);
              const closed = (d.flags & 1) === 1;
              const elev   = d.elevation || 0;
              if (bulges.some(b => Math.abs(b) >= 1e-6)) {
                this._bulgePolySegs(pts, bulges, closed, color, pushSeg, expand);
              } else {
                this._polylineSegs(pts, closed, elev, color, pushSeg);
                pts.forEach(p => expand(p.x, p.y, elev));
              }
              meta.bounds = { type:'point', cx: pts[0].x, cy: pts[0].y };
            }
            break;
          }

          case 'POINT': {
            const p = d.position || d;
            if (typeof p.x === 'number') {
              const s = 1;
              pushSeg(p.x-s, p.y, p.x+s, p.y, p.z||0, color);
              pushSeg(p.x, p.y-s, p.x, p.y+s, p.z||0, color);
              meta.bounds = { type:'point', cx:p.x, cy:p.y };
            }
            break;
          }

          case 'ELLIPSE':
            if (d.center) {
              this._ellipseSegs(d, color, pushSeg);
              meta.bounds = { type:'point', cx:d.center.x, cy:d.center.y };
            }
            break;

          case 'SPLINE': {
            const cps = d.controlPoints ?? d.fitPoints;
            if (cps?.length >= 2) {
              const pts = cps.length >= 3
                ? (() => {
                    const segs = cps.length * 10;
                    const result = [];
                    for (let i = 0; i <= segs; i++) {
                      const t = i / segs;
                      result.push(this._catmullRom(cps, t));
                    }
                    return result;
                  })()
                : cps;
              this._polylineSegs(pts, false, 0, color, pushSeg);
              pts.forEach(p => expand(p.x, p.y, p.z || 0));
              meta.bounds = { type:'point', cx:pts[0].x, cy:pts[0].y };
            }
            break;
          }

          case 'ATTRIB':
          case 'ATTDEF': {
            if ((d.flags ?? 0) & 1) break; // invisible attribute
            const raw    = e.text ?? d.text ?? d.textValue ?? d.defaultValue ?? '';
            const text   = stripMText(raw);
            const height = e.textHeight ?? e.height ?? d.textHeight ?? d.height ?? 2.5;
            const rotation = e.rotationAngle ?? d.rotationAngle ?? 0;
            const alignH   = e.horizAlignment ?? d.horizAlignment ?? 0;
            const alignV   = e.vertAlignment  ?? d.vertAlignment  ?? 0;
            // When aligned (non-default H/V), the alignmentPt is the true anchor;
            // insertionPt is the "first point" and differs for centered/right text.
            const useAlignPt = alignH !== 0 || alignV !== 0;
            const pos = useAlignPt
              ? (e.alignmentPt ?? d.alignmentPt ?? e.insertionPt ?? d.insertionPt ?? d.insertionPoint ?? { x:0, y:0 })
              : (e.insertionPt ?? d.insertionPt ?? d.insertionPoint ?? { x:0, y:0 });
            if (text) {
              // Force vertical center for ATTRIB — attribute values (e.g. node tags) appear centered
              pendingTexts.push({ text, pos, height, rotation, color, alignH, alignV: 2 });
              meta.bounds = { type:'point', cx:pos.x, cy:pos.y };
              this._addTextPick(text, pos, height, alignH, 2);
              expand(pos.x, pos.y, 0);
            }
            break;
          }

          case 'XLINE':
          case 'RAY': {
            // Infinite/semi-infinite lines — render as very long line segment
            const bp  = d.basePoint ?? d.point ?? d.startPoint;
            const dir = d.direction ?? d.unitDir ?? d.vector;
            if (bp && dir) {
              const len = 1e6;
              const ex = bp.x + dir.x * len, ey = bp.y + dir.y * len;
              if (type === 'XLINE') {
                pushSeg(bp.x - dir.x * len, bp.y - dir.y * len, ex, ey, 0, color);
              } else {
                pushSeg(bp.x, bp.y, ex, ey, 0, color);
              }
              meta.bounds = { type:'point', cx:bp.x, cy:bp.y };
              expand(bp.x, bp.y);
            }
            break;
          }

          case 'SOLID': {
            const corners = [d.corner1||d.pt1||d.point1, d.corner2||d.pt2||d.point2,
                             d.corner3||d.pt3||d.point3, d.corner4||d.pt4||d.point4].filter(Boolean);
            if (corners.length >= 3) {
              this._solidMesh(corners, color);
              meta.bounds = { type:'point', cx:corners[0].x, cy:corners[0].y };
            }
            break;
          }

          // ── Text ──────────────────────────────────────────────────────────
          case 'TEXT':
          case 'MTEXT': {
            const raw    = e.text ?? d.text ?? '';
            const text   = stripMText(raw);
            const height = e.textHeight ?? e.height ?? d.textHeight ?? d.height ?? 2.5;
            let rotation = 0, alignH = 0, alignV = 0, pos;
            if (type === 'TEXT') {
              rotation = e.rotationAngle ?? d.rotationAngle ?? 0;
              alignH   = e.horizAlignment ?? d.horizAlignment ?? 0;
              alignV   = e.vertAlignment  ?? d.vertAlignment  ?? 0;
              // DXF group 72 = 4 ("Middle") centers the text both horizontally AND
              // vertically on the alignment point — group 73 (vertical) is ignored.
              // Without this, vA=0 (baseline) placed such text half a line too high
              // (titleblock labels 노선이정/설계사/… floated up).
              if (alignH === 4) alignV = 2;
              // DWG: when alignment is non-default, alignmentPt is the actual anchor
              // (insertionPt is the "first point" which may differ from anchor)
              const useAlignPt = alignH !== 0 || alignV !== 0;
              pos = useAlignPt
                ? (e.alignmentPt ?? d.alignmentPt ?? e.insertionPt ?? d.insertionPt ?? { x:0, y:0 })
                : (e.insertionPt ?? d.insertionPt ?? d.insertionPoint ?? { x:0, y:0 });
            } else {
              const xd = e.xAxisDir ?? d.xAxisDir;
              if (xd) rotation = Math.atan2(xd.y, xd.x);
              // MTEXT: attachmentPoint 1-3=top, 4-6=mid, 7-9=bottom
              // (parsers emit the field as `attachment`; keep both names)
              const ap = e.attachment ?? d.attachment ?? e.attachmentPoint ?? d.attachmentPoint ?? 5;
              alignH = ([1,4,7].includes(ap) ? 0 : [3,6,9].includes(ap) ? 2 : 1);
              alignV = ([1,2,3].includes(ap) ? 3 : [7,8,9].includes(ap) ? 1 : 2);
              pos = e.insertionPt ?? d.insertionPt ?? d.insertionPoint ?? { x:0, y:0 };
            }
            if (text) {
              const entry = { text, pos, height, rotation, color, alignH, alignV };
              if (type === 'MTEXT') {
                entry.linespacingFactor = e.linespacingFactor ?? d.linespacingFactor ?? 1;
                entry.rectWidth = e.rectWidth ?? d.rectWidth ?? 0;
                entry.rectHeight = e.rectHeight ?? d.rectHeight ?? 0;
                // Background mask (DXF 90/45/63): bit0=use fill color, bit1=window color, bit4=frame
                entry.bgFillFlags = e.bgFillFlags ?? d.bgFillFlags ?? 0;
                entry.bgScale = e.bgScale ?? d.bgScale ?? 1.5;
                entry.bgColorIndex = e.bgColorIndex ?? d.bgColorIndex;
                entry.bgColorRgb = e.bgColorRgb ?? d.bgColorRgb;
              }
              pendingTexts.push(entry);
              meta.bounds = { type:'point', cx:pos.x, cy:pos.y };
              this._addTextPick(text, pos, height, alignH, alignV);
              expand(pos.x, pos.y, 0);
            }
            break;
          }

          // ── INSERT (block reference) ──────────────────────────────────────
          case 'INSERT': {
            const ip    = e.insertionPt ?? d.insertionPt ?? d.insertionPoint;
            const sx    = d.scaleX ?? d.scale?.x ?? e.scale?.x ?? 1;
            const sy    = d.scaleY ?? d.scale?.y ?? e.scale?.y ?? 1;
            const rot   = d.rotation ?? e.rotation ?? 0;
            const bhVal = e.blockHeaderHandle?.value ?? d.blockHeaderHandle?.value;

            if (bhVal != null) {
              // Block definition entities sit in the flat entities array,
              // identified by ownerHandle.value === block header handle
              const bHandleHex = bhVal.toString(16);
              const bEnts = entsByOwner.get(bHandleHex) ?? [];
              if (bEnts.length > 0) {
                const bh = result?.tables?.blocks?.find(b => {
                  const bh2 = typeof b.handle === 'object' ? b.handle?.value : b.handle;
                  return bh2 === bhVal;
                });
                this._insertEntities(
                  bEnts,
                  { insertionPoint: ip ?? {x:0,y:0,z:0}, xScale:sx, yScale:sy, rotation:rot, basePoint: bh?.basePoint },
                  color, pushSeg, pendingTexts,
                  { entsByOwner, blockBase: blockBaseByHex }
                );
              }
            }
            if (ip) { meta.bounds = { type:'point', cx:ip.x, cy:ip.y }; expand(ip.x, ip.y, 0); }
            break;
          }

          // ── HATCH ─────────────────────────────────────────────────────────
          case 'HATCH': {
            const paths     = d.paths ?? e.paths;
            const solidFill = d.solidFill ?? e.solidFill ?? false;
            if (!paths?.length) break;

            let firstPt = null;
            for (const path of paths) {
              if (!path.points?.length || path.points.length < 2) continue;
              if (!firstPt) firstPt = path.points[0];
              const hasBulge = path.bulges?.some(b => Math.abs(b) >= 1e-6);
              if (hasBulge) {
                this._bulgePolySegs(path.points, path.bulges, true, color, pushSeg, expand);
              } else {
                this._polylineSegs(path.points, true, 0, color, pushSeg);
                path.points.forEach(p => expand(p.x, p.y, 0));
              }
            }
            if (solidFill) this._hatchFill(paths, color);
            if (firstPt) meta.bounds = { type:'point', cx:firstPt.x, cy:firstPt.y };
            break;
          }

          // ── DIMENSION (all subtypes) ───────────────────────────────────────
          case 'DIMENSION':
          case 'DIMENSION_LINEAR':
          case 'DIMENSION_ALIGNED':
          case 'DIMENSION_RADIUS':
          case 'DIMENSION_DIAMETER':
          case 'DIMENSION_ANG_3PT':
          case 'DIMENSION_ANG_2LN':
          case 'DIMENSION_ORDINATE': {
            const bhVal = e.blockHeaderHandle?.value ?? d.blockHeaderHandle?.value;
            let dimEnts = [];
            if (bhVal != null) {
              const hex = bhVal.toString(16);
              dimEnts = entsByOwner.get(hex) ?? [];
            }

            if (dimEnts.length > 0) {
              // Render pre-built dimension block geometry
              for (const child of dimEnts) {
                const ct  = (child.type || child.typeName || '').toUpperCase();
                const cd  = child.data || child;
                const cc  = this._entityColor(child) || color;
                if (ct === 'LINE' && cd.start && cd.end) {
                  pushSeg(cd.start.x, cd.start.y, cd.end.x, cd.end.y, 0, cc);
                  expand(cd.start.x, cd.start.y); expand(cd.end.x, cd.end.y);
                } else if (ct === 'SOLID') {
                  const crs = [cd.corner1||cd.pt1, cd.corner2||cd.pt2,
                               cd.corner3||cd.pt3, cd.corner4||cd.pt4].filter(Boolean);
                  if (crs.length >= 3) { this._solidMesh(crs, cc); crs.forEach(c => expand(c.x, c.y)); }
                } else if (ct === 'ARC' && cd.center && cd.radius != null) {
                  this._arcSegs(cd.center, cd.radius, cd.startAngle??0, cd.endAngle??Math.PI*2, 0, cc, pushSeg);
                } else if ((ct === 'TEXT' || ct === 'MTEXT')) {
                  const raw  = child.text ?? cd.text ?? cd.textValue ?? '';
                  const text = stripMText(raw);
                  const pos  = child.insertionPt ?? cd.insertionPt ?? cd.insertionPoint ?? {x:0,y:0};
                  const ht   = cd.textHeight ?? cd.height ?? child.textHeight ?? 2.5;
                  if (text) { pendingTexts.push({ text, pos, height:ht, rotation: cd.rotationAngle??0, color:cc, alignH:1, alignV:2 }); expand(pos.x, pos.y); }
                } else if (ct === 'INSERT') {
                  // Arrowhead block INSERT within the dimension block: render the real
                  // arrow geometry; fall back to a named default for geometry-less
                  // system blocks (_ClosedFilled / _Dot / _Oblique / _Open / …).
                  const cip  = child.insertionPt ?? cd.insertionPt ?? cd.insertionPoint ?? {x:0,y:0};
                  const crot = cd.rotation ?? child.rotation ?? 0;
                  const csx  = cd.scaleX ?? cd.scale?.x ?? child.scale?.x ?? 1;
                  const csy  = cd.scaleY ?? cd.scale?.y ?? child.scale?.y ?? csx;
                  const abh   = child.blockHeaderHandle?.value ?? cd.blockHeaderHandle?.value;
                  const aHex  = abh?.toString(16);
                  const aname = blockNameByHex.get(aHex) ?? '';
                  const arrowEnts = aHex ? (entsByOwner.get(aHex) ?? []) : [];
                  if (aname.includes('dot')) {
                    // Dot arrowhead → filled disc (radius from the block's geometry × scale)
                    this._dotMesh(cip, this._arrowDotRadius(arrowEnts) * Math.abs(csx) || Math.abs(csx) * 0.5, cc);
                  } else if (arrowEnts.length) {
                    this._insertEntities(
                      arrowEnts,
                      { insertionPoint: cip, xScale: csx, yScale: csy, rotation: crot, basePoint: blockBaseByHex.get(aHex) },
                      cc, pushSeg, pendingTexts,
                      { entsByOwner, blockBase: blockBaseByHex }
                    );
                  } else {
                    this._defaultArrow(aname, cip, crot, Math.abs(csx) || 1, cc, pushSeg);
                  }
                  expand(cip.x, cip.y);
                }
              }
              const fl = dimEnts.find(c => (c.type||c.typeName||'').toUpperCase() === 'LINE');
              const fd = fl?.data || fl;
              if (fd?.start) meta.bounds = { type:'point', cx:fd.start.x, cy:fd.start.y };
            } else {
              // Fallback: reconstruct from entity properties
              this._renderDimFallback(e, d, type, color, pushSeg, pendingTexts, expand);
              const pt10 = e.pt10 ?? d.pt10;
              if (pt10) { meta.bounds = { type:'point', cx:pt10.x, cy:pt10.y }; expand(pt10.x, pt10.y); }
            }
            break;
          }

          case 'LEADER': {
            const pts = d.points ?? e.points;
            if (pts?.length >= 2) {
              this._polylineSegs(pts, false, 0, color, pushSeg);
              pts.forEach(p => expand(p.x, p.y, p.z || 0));
              if (d.arrowheadOn ?? e.arrowheadOn ?? true) {
                const p0 = pts[0], p1 = pts[1];
                const rot = Math.atan2(p1.y - p0.y, p1.x - p0.x);
                const arrowSz = d.arrowSize ?? e.arrowSize ?? 2.5;
                this._arrowMesh(p0, rot, arrowSz, color);
              }
              meta.bounds = { type:'point', cx:pts[0].x, cy:pts[0].y };
            }
            break;
          }

          default: break;
        }
      } catch { /* skip malformed entity */ }
      meta.colEnd = lineColors.length;
    }

    // ── Render deferred text with bbox-proportional minimum size ──────────
    if (pendingTexts.length) {
      const sz       = box.isEmpty() ? new THREE.Vector3(1,1,0) : box.getSize(new THREE.Vector3());
      const diagSize = Math.hypot(Math.max(sz.x, 1), Math.max(sz.y, 1));
      const minTextH = diagSize * 0.0002;  // 0.02% of diagonal → readable at fit-view
      // Cap sprite count to avoid GPU/heap OOM on large drawings. With the
      // per-(text,color) texture cache in _textSprite, memory scales with
      // UNIQUE strings, so the cap is a sprite-object guard, not a raster one
      // (3000 previously culled half the texts on table sheets, e.g. BLOCK4).
      const MAX_TEXTS = 20000;
      const renderTexts = pendingTexts.length > MAX_TEXTS
        ? (console.warn(`텍스트 ${pendingTexts.length}개 → ${MAX_TEXTS}개로 제한`),
           pendingTexts.sort((a, b) => b.height - a.height).slice(0, MAX_TEXTS))
        : pendingTexts;
      void this._drawTexts(renderTexts, minTextH);
    }

    this._lineColorAttr = null; this._origColors = null;
    if (lineVerts.length) {
      const geom = new THREE.BufferGeometry();
      geom.setAttribute('position', new THREE.Float32BufferAttribute(lineVerts, 3));
      const colorAttr = new THREE.Float32BufferAttribute(lineColors, 3);
      geom.setAttribute('color', colorAttr);
      this._group.add(new THREE.LineSegments(geom, new THREE.LineBasicMaterial({ vertexColors: true })));
      this._lineColorAttr = colorAttr;
      this._origColors = Float32Array.from(colorAttr.array);
    }

    // Dashed linetypes (HIDDEN / CENTER / …) — one LineSegments per dash|gap
    // bucket with a LineDashedMaterial. computeLineDistances() is REQUIRED for
    // the dash pattern to appear; on LineSegments each 2-vertex pair dashes
    // independently from its own start (correct for CAD segments).
    for (const bk of dashBuckets.values()) {
      if (!bk.verts.length) continue;
      const dgeom = new THREE.BufferGeometry();
      dgeom.setAttribute('position', new THREE.Float32BufferAttribute(bk.verts, 3));
      dgeom.setAttribute('color', new THREE.Float32BufferAttribute(bk.colors, 3));
      const dline = new THREE.LineSegments(dgeom, new THREE.LineDashedMaterial({
        vertexColors: true, dashSize: bk.dash, gapSize: bk.gap,
      }));
      dline.computeLineDistances();
      this._group.add(dline);
    }

    if (!opts.keepView && !box.isEmpty()) this._fit(box);
  }

  // ── UI integration ─────────────────────────────────────────────────────────

  /** Swap canvas background for theme. dark=true → near-black, false → light. */
  setTheme(dark) {
    this._scene.background = new THREE.Color(dark ? 0x0a0b0d : 0xf7f6f3);
    if (this._gridVisible) this._rebuildGrid();
  }

  setGrid(visible) {
    this._gridVisible = visible;
    if (!visible) {
      if (this._gridMesh) { this._scene.remove(this._gridMesh); this._gridMesh.geometry.dispose(); this._gridMesh.material.dispose(); this._gridMesh = null; }
    } else {
      this._rebuildGrid();
    }
  }

  _rebuildGrid() {
    if (this._gridMesh) { this._scene.remove(this._gridMesh); this._gridMesh.geometry.dispose(); this._gridMesh.material.dispose(); this._gridMesh = null; }
    const zoom = this._camera.zoom || 1;
    const cx = this._camera.position.x;
    const cy = this._camera.position.y;
    const hw = (this._camera.right - this._camera.left) / zoom / 2;
    const hh = (this._camera.top - this._camera.bottom) / zoom / 2;
    const ext = Math.max(hw, hh) * 3;
    const spacing = this._niceSpacing(Math.max(hw, hh) * 2 / 20);
    const [minX, maxX, minY, maxY] = [cx - ext, cx + ext, cy - ext, cy + ext];
    const isDark = this._scene.background.r < 0.5;
    const color = isDark ? 0x2b2b2b : 0xbbbbbb;
    const verts = [];
    for (let x = Math.ceil(minX / spacing) * spacing; x <= maxX; x += spacing) verts.push(x, minY, -0.5, x, maxY, -0.5);
    for (let y = Math.ceil(minY / spacing) * spacing; y <= maxY; y += spacing) verts.push(minX, y, -0.5, maxX, y, -0.5);
    const geo = new THREE.BufferGeometry();
    geo.setAttribute('position', new THREE.Float32BufferAttribute(verts, 3));
    this._gridMesh = new THREE.LineSegments(geo, new THREE.LineBasicMaterial({ color }));
    this._scene.add(this._gridMesh);
  }

  _niceSpacing(raw) {
    if (raw <= 0) return 1;
    const exp = Math.pow(10, Math.floor(Math.log10(raw)));
    const norm = raw / exp;
    return (norm < 2 ? 1 : norm < 5 ? 2 : 5) * exp;
  }

  /** Zoom % relative to fit (ortho camera zoom). */
  getZoomPercent() { return Math.round((this._camera?.zoom ?? 1) * 100); }

  /** Subscribe to pan/zoom changes (for live zoom readout). */
  onViewChange(cb) { this._controls?.addEventListener('change', cb); }

  /** Hide entities on the given layer names (Set<string>); re-renders keeping the view. */
  setHiddenLayers(nameSet) {
    this._hiddenLayers = nameSet || new Set();
    if (this._lastResult) this.load(this._lastResult, { keepView: true });
  }

  /** Entity count, block definition count — for recent-files metadata. */
  getStats() {
    return { entities: this._entityMeta.length, blocks: this._blockCount ?? 0 };
  }

  /** Capture current view as a WebP Blob. Requires preserveDrawingBuffer:true (already set). */
  snapshotWebPBlob() {
    return new Promise((resolve) => {
      this._renderer.render(this._scene, this._camera);
      this._renderer.domElement.toBlob((b) => resolve(b), 'image/webp', 0.75);
    });
  }

  /** Layer list for the Layers panel: [{ name, colorHex, count, visible }]. */
  getLayerInfo() {
    const result = this._lastResult;
    if (!result) return [];
    const counts = new Map();
    for (const e of (result.entities || [])) {
      const lh = e.layerHandle?.value ?? e.layerHandle;
      const name = (lh != null && this._layerNameByHandle?.get(String(lh)))
        ?? e.layer ?? e.layerName ?? '0';
      counts.set(name, (counts.get(name) || 0) + 1);
    }
    const hidden = this._hiddenLayers || new Set();
    return (result.tables?.layers || []).map(l => {
      const name = l.name ?? l.layerName ?? '0';
      const aci  = Math.abs(l.colorIndex ?? l.color ?? l.colorNumber ?? 7);
      return {
        name,
        colorHex: '#' + ((aciToHex(aci) ?? DEFAULT_COLOR).toString(16).padStart(6, '0')),
        count: counts.get(name) || 0,
        visible: !hidden.has(name),
      };
    }).filter(l => l.count > 0 || !l.name.startsWith('*'));
  }

  // ── Private helpers ────────────────────────────────────────────────────────

  _buildLayerMap(layers) {
    this._layerByHandle.clear();
    this._layerByName.clear();
    this._layerNameByHandle = new Map();
    this._layer0Handle = null;
    if (!layers) return;
    for (const l of layers) {
      const handle = l.handle?.value ?? l.handle;
      const name   = l.name ?? l.layerName;
      const aci    = Math.abs(l.colorIndex ?? l.color ?? l.colorNumber ?? 7);
      const hex    = aciToHex(aci) ?? DEFAULT_COLOR;
      if (handle != null) this._layerByHandle.set(String(handle), hex);
      if (name)           this._layerByName.set(name, hex);
      if (handle != null && name) this._layerNameByHandle.set(String(handle), name);
      if (name === '0' && handle != null) this._layer0Handle = String(handle);
    }
  }

  // Active-viewport VIEWTWIST (radians). The sheet is un-twisted by rotating the
  // camera up by -viewTwist (verified against samples/11.dwg: title border upright).
  _readViewTwist(result) {
    const vports = result?.tables?.vports;
    if (!Array.isArray(vports) || !vports.length) return 0;
    const vp = vports.find(v => /active/i.test(v.name || '')) || vports[0];
    const tw = vp?.viewTwist;
    return (typeof tw === 'number' && isFinite(tw)) ? tw : 0;
  }

  // Build linetype lookup: pattern-by-name (signed element lengths, drawing
  // units) + layer→linetype-name maps + the global LTSCALE. Consumed by
  // _resolveDash to turn an entity's linetype into a dash/gap size.
  _buildLinetypeMap(result) {
    this._ltPatterns = new Map();
    this._layerLtByName = new Map();
    this._layerLtByHandle = new Map();
    this._globalLtscale = (result?.vars?.ltscale > 0 ? result.vars.ltscale : 1);
    for (const lt of (result?.tables?.lineTypes ?? [])) {
      if (lt?.name) this._ltPatterns.set(lt.name, Array.isArray(lt.pattern) ? lt.pattern : []);
    }
    for (const l of (result?.tables?.layers ?? [])) {
      const name = l.name ?? l.layerName;
      const handle = l.handle?.value ?? l.handle;
      const ltn = l.lineType ?? l.linetype;
      if (name && ltn) this._layerLtByName.set(name, ltn);
      if (handle != null && ltn) this._layerLtByHandle.set(String(handle), ltn);
    }
  }

  // Resolve an entity's dash pattern → { key, dash, gap } world-unit sizes, or
  // null for a solid line. BYLAYER / BYBLOCK / empty fall back to the layer's
  // linetype; dash/gap = Σ|element| × LTSCALE × entity linetypeScale (CELTSCALE).
  _resolveDash(e) {
    if (!this._ltPatterns || this._ltPatterns.size === 0) return null;
    let ltName = e.lineType ?? e.linetype;
    if (!ltName || ltName === 'ByLayer' || ltName === 'BYLAYER' ||
        ltName === 'ByBlock' || ltName === 'BYBLOCK') {
      const lh = e.layerHandle?.value ?? e.layerHandle;
      ltName = (lh != null && this._layerLtByHandle.get(String(lh)))
            || this._layerLtByName.get(e.layer ?? e.layerName) || null;
    }
    if (!ltName || ltName === 'Continuous' || ltName === 'ByLayer' || ltName === 'ByBlock') return null;
    const pattern = this._ltPatterns.get(ltName);
    if (!pattern || pattern.length === 0) return null;
    const entScale = (e.entityHeader?.linetypeScale > 0 ? e.entityHeader.linetypeScale : 1);
    const scale = this._globalLtscale * entScale;
    let dash = 0, gap = 0;
    for (const d of pattern) {
      const len = Math.abs(d) * scale;
      if (d > 1e-6) dash += len;
      else if (d < -1e-6) gap += len;
      else dash += Math.max(len, 0.01 * scale); // dot → tiny dash
    }
    if (dash < 1e-4 || gap < 1e-4) return null;
    return { key: `${dash.toFixed(3)}|${gap.toFixed(3)}`, dash, gap };
  }

  // Resolve an entity's color inside a block, given the color inherited from the
  // INSERT context. BYBLOCK and layer-0 BYLAYER entities inherit the INSERT color
  // (AutoCAD's layer-0 rule); everything else uses its own color/layer.
  _resolveBlockColor(entity, inherited) {
    const aci = entity.entityHeader?.colorIndex
             ?? entity.color ?? entity.colorIndex ?? entity.colorNumber ?? 256;
    if (aci === 0) return inherited;  // BYBLOCK
    const lh = String(entity.layerHandle?.value ?? entity.layerHandle ?? '');
    if (aci === 256 && this._layer0Handle && lh === this._layer0Handle) return inherited;
    return this._entityColor(entity);
  }

  _entityColor(entity) {
    const aci = entity.entityHeader?.colorIndex
             ?? entity.color ?? entity.colorIndex ?? entity.colorNumber ?? 256;
    if (aci != null) {
      const hex = aciToHex(aci);
      if (hex !== null) return hex;
    }
    const lh = entity.layerHandle?.value ?? entity.layerHandle;
    if (lh != null) {
      const c = this._layerByHandle.get(String(lh));
      if (c !== undefined) return c;
    }
    const ln = entity.layer ?? entity.layerName;
    if (ln) {
      const c = this._layerByName.get(ln);
      if (c !== undefined) return c;
    }
    return DEFAULT_COLOR;
  }

  // Filled triangle arrow mesh (replaces V-line arrowhead)
  _arrowMesh(pt, rotation, size, color) {
    if (!pt || size < 1e-4) return;
    const w = size * 0.166;
    const r = ((color >> 16) & 0xFF) / 255;
    const g = ((color >>  8) & 0xFF) / 255;
    const b = (color         & 0xFF) / 255;
    const geom = new THREE.BufferGeometry();
    geom.setAttribute('position', new THREE.Float32BufferAttribute([0,0,0, -size,w,0, -size,-w,0], 3));
    geom.setAttribute('color',    new THREE.Float32BufferAttribute([r,g,b,  r,g,b,  r,g,b], 3));
    const mesh = new THREE.Mesh(geom, new THREE.MeshBasicMaterial({ vertexColors: true, side: THREE.DoubleSide }));
    mesh.position.set(pt.x, pt.y, (pt.z || 0) + 0.5);
    mesh.rotation.z = rotation;
    this._group.add(mesh);
  }

  // Default geometry for AutoCAD standard arrowhead blocks that ship no geometry
  // in the file (system blocks). `name` is the lowercased block name.
  _defaultArrow(name, pt, rotation, size, color, pushSeg) {
    if (!pt || size < 1e-4) return;
    const n = (name || '').replace(/^[_*]+/, '');
    const cos = Math.cos(rotation), sin = Math.sin(rotation);
    // local→world: arrow points toward +X at the insertion point
    const P = (lx, ly) => ({ x: pt.x + lx * cos - ly * sin, y: pt.y + lx * sin + ly * cos });
    if (n === 'none' || n === 'small' || n === 'integral') return;
    if (n === 'dot' || n === 'dotsmall' || n === 'dotblank' || n === 'dotsmallblank' || n === 'origin' || n === 'origin2') {
      this._dotMesh(pt, size * (n === 'dotsmall' ? 0.12 : 0.5), color);
      return;
    }
    if (n === 'oblique' || n === 'archtick') {
      const a = P(size * 0.5, size * 0.5), b = P(-size * 0.5, -size * 0.5);
      pushSeg(a.x, a.y, b.x, b.y, (pt.z || 0) + 0.5, color);
      return;
    }
    if (n === 'open' || n === 'open30' || n === 'open90') {
      const w = n === 'open90' ? size : size * 0.42;
      const t = P(0, 0), u = P(-size, w), v = P(-size, -w);
      pushSeg(u.x, u.y, t.x, t.y, (pt.z || 0) + 0.5, color);
      pushSeg(v.x, v.y, t.x, t.y, (pt.z || 0) + 0.5, color);
      return;
    }
    // default (_ClosedFilled, "", closed, boxfilled, datumfilled, …) → filled triangle
    this._arrowMesh(pt, rotation, size, color);
  }

  // Filled disc (dot arrowhead).
  _dotMesh(center, radius, color) {
    if (!center || !(radius > 1e-5)) return;
    const r = ((color >> 16) & 0xFF) / 255, g = ((color >> 8) & 0xFF) / 255, b = (color & 0xFF) / 255;
    const segs = 20, verts = [], cols = [], z = (center.z || 0) + 0.5;
    for (let i = 0; i < segs; i++) {
      const a0 = i / segs * Math.PI * 2, a1 = (i + 1) / segs * Math.PI * 2;
      verts.push(center.x, center.y, z,
        center.x + radius * Math.cos(a0), center.y + radius * Math.sin(a0), z,
        center.x + radius * Math.cos(a1), center.y + radius * Math.sin(a1), z);
      cols.push(r, g, b, r, g, b, r, g, b);
    }
    const geom = new THREE.BufferGeometry();
    geom.setAttribute('position', new THREE.Float32BufferAttribute(verts, 3));
    geom.setAttribute('color', new THREE.Float32BufferAttribute(cols, 3));
    this._group.add(new THREE.Mesh(geom, new THREE.MeshBasicMaterial({ vertexColors: true, side: THREE.DoubleSide })));
  }

  // Dot radius (block-local) from an arrow block's geometry, measured from its centroid.
  _arrowDotRadius(ents) {
    let r = 0;
    for (const ae of (ents || [])) {
      const ad = ae.data || ae;
      if ((ae.type || '').toUpperCase() === 'CIRCLE' && ad.radius) r = Math.max(r, ad.radius);
      const pts = ad.points ?? ad.vertices;
      if (pts?.length) {
        let cx = 0, cy = 0; pts.forEach(p => { cx += p.x; cy += p.y; }); cx /= pts.length; cy /= pts.length;
        pts.forEach(p => { r = Math.max(r, Math.hypot(p.x - cx, p.y - cy)); });
      }
    }
    return r;
  }

  _arcSegs(center, r, a0, a1, z, color, pushSeg) {
    let span = a1 - a0;
    if (span <= 0) span += Math.PI * 2;
    const steps = Math.max(8, Math.ceil((span / (Math.PI * 2)) * ARC_SEGS));
    let prev = null;
    for (let i = 0; i <= steps; i++) {
      const a = a0 + (span * i) / steps;
      const x = center.x + r * Math.cos(a);
      const y = center.y + r * Math.sin(a);
      if (prev) pushSeg(prev.x, prev.y, x, y, z, color);
      prev = { x, y };
    }
  }

  // Centripetal CatmullRom interpolation for SPLINE
  _catmullRom(pts, t) {
    const n  = pts.length;
    const f  = t * (n - 1);
    const i  = Math.min(Math.floor(f), n - 2);
    const tt = f - i;
    const p0 = pts[Math.max(i - 1, 0)];
    const p1 = pts[i];
    const p2 = pts[i + 1];
    const p3 = pts[Math.min(i + 2, n - 1)];
    const t2 = tt * tt, t3 = t2 * tt;
    return {
      x: 0.5 * ((2*p1.x) + (-p0.x+p2.x)*tt + (2*p0.x-5*p1.x+4*p2.x-p3.x)*t2 + (-p0.x+3*p1.x-3*p2.x+p3.x)*t3),
      y: 0.5 * ((2*p1.y) + (-p0.y+p2.y)*tt + (2*p0.y-5*p1.y+4*p2.y-p3.y)*t2 + (-p0.y+3*p1.y-3*p2.y+p3.y)*t3),
      z: 0.5 * ((2*(p1.z||0)) + (-(p0.z||0)+(p2.z||0))*tt + (2*(p0.z||0)-5*(p1.z||0)+4*(p2.z||0)-(p3.z||0))*t2 + (-(p0.z||0)+3*(p1.z||0)-3*(p2.z||0)+(p3.z||0))*t3),
    };
  }

  _ellipseSegs(d, color, pushSeg) {
    // field names: majorAxis or smAxis; ratio or axisRatio
    const ma = d.majorAxis ?? d.smAxis ?? { x: 1, y: 0, z: 0 };
    const center = d.center;
    const ratio = d.ratio ?? d.axisRatio ?? 1;
    const startParam = d.startParam ?? 0;
    const endParam   = d.endParam   ?? Math.PI * 2;
    const mx = ma?.x ?? 1, my = ma?.y ?? 0;
    const a   = Math.sqrt(mx*mx + my*my);
    const b   = a * ratio;
    const rot = Math.atan2(my, mx);
    let span  = endParam - startParam;
    if (span <= 0) span += Math.PI * 2;
    let prev  = null;
    for (let i = 0; i <= ELLIPSE_SEGS; i++) {
      const t  = startParam + (span * i) / ELLIPSE_SEGS;
      const ex = a * Math.cos(t), ey = b * Math.sin(t);
      const x  = center.x + ex * Math.cos(rot) - ey * Math.sin(rot);
      const y  = center.y + ex * Math.sin(rot) + ey * Math.cos(rot);
      if (prev) pushSeg(prev.x, prev.y, x, y, center.z || 0, color);
      prev = { x, y };
    }
  }

  _polylineSegs(points, closed, z, color, pushSeg) {
    if (!points || points.length < 2) return;
    for (let i = 0; i < points.length - 1; i++) {
      pushSeg(points[i].x, points[i].y, points[i+1].x, points[i+1].y, z, color);
    }
    if (closed) {
      const a = points[points.length-1], b = points[0];
      pushSeg(a.x, a.y, b.x, b.y, z, color);
    }
  }

  // Resolve start/end width for segment i→i+1 (DXF 40/41, fallback 43 constant).
  _segWidths(ent, i, scale = 1) {
    const d = ent?.data || ent || {};
    const cw = (d.constantWidth ?? d.constWidth ?? 0) * scale;
    const dsw = (d.defaultStartWidth ?? 0) * scale;
    const dew = (d.defaultEndWidth ?? 0) * scale;
    const sw0 = (d.startWidths?.[i] ?? 0) * scale;
    const ew0 = (d.endWidths?.[i] ?? 0) * scale;
    const sw = Math.abs(sw0) > 1e-12 ? sw0 : (Math.abs(cw) > 1e-12 ? cw : dsw);
    const ew = Math.abs(ew0) > 1e-12 ? ew0 : (Math.abs(cw) > 1e-12 ? cw : dew);
    return { sw: Math.abs(sw), ew: Math.abs(ew) };
  }

  _polyHasWidth(ent, nSeg, scale = 1) {
    for (let i = 0; i < nSeg; i++) {
      const { sw, ew } = this._segWidths(ent, i, scale);
      if (sw > 1e-9 || ew > 1e-9) return true;
    }
    return false;
  }

  // Draw one trapezoid segment (variable start/end half-width) as two triangles.
  _pushWideSeg(verts, p1, p2, w0, w1) {
    const dx = p2.x - p1.x, dy = p2.y - p1.y;
    const len = Math.hypot(dx, dy);
    if (len < 1e-12) return;
    const nx = -dy / len, ny = dx / len;
    const h0 = w0 * 0.5, h1 = w1 * 0.5;
    const a = { x: p1.x + nx * h0, y: p1.y + ny * h0 };
    const b = { x: p1.x - nx * h0, y: p1.y - ny * h0 };
    const c = { x: p2.x - nx * h1, y: p2.y - ny * h1 };
    const d = { x: p2.x + nx * h1, y: p2.y + ny * h1 };
    // two triangles a-b-c, a-c-d
    verts.push(a.x, a.y, 0, b.x, b.y, 0, c.x, c.y, 0);
    verts.push(a.x, a.y, 0, c.x, c.y, 0, d.x, d.y, 0);
  }

  // Variable-width polyline → solid mesh (MeshBasicMaterial). Used when any
  // segment has start/end/constant width > 0 (도곽 outer frame etc.).
  _widePolyMesh(points, bulges, closed, ent, color, scale = 1, expand = null) {
    if (!points || points.length < 2) return;
    const n = points.length;
    const segs = closed ? n : n - 1;
    const verts = [];
    for (let i = 0; i < segs; i++) {
      const p1 = points[i];
      const p2 = points[(i + 1) % n];
      const { sw, ew } = this._segWidths(ent, i, scale);
      if (sw < 1e-9 && ew < 1e-9) {
        // Zero-width segment: still emit a tiny hair so it isn't dropped entirely.
        this._pushWideSeg(verts, p1, p2, 0.01 * scale, 0.01 * scale);
        if (expand) { expand(p1.x, p1.y); expand(p2.x, p2.y); }
        continue;
      }
      const bulge = bulges?.[i] || 0;
      if (Math.abs(bulge) < 1e-6) {
        this._pushWideSeg(verts, p1, p2, sw, ew);
        if (expand) { expand(p1.x, p1.y); expand(p2.x, p2.y); }
      } else {
        // Tessellate bulge arc; interpolate width along the arc.
        const dx = p2.x - p1.x, dy = p2.y - p1.y;
        const dist = Math.hypot(dx, dy);
        if (dist < 1e-9) continue;
        const inc = 4 * Math.atan(bulge);
        const half = Math.abs(inc) / 2;
        const radius = (dist / 2) / Math.sin(half);
        const apothem = radius * Math.cos(half);
        const mx2 = (p1.x + p2.x) / 2, my2 = (p1.y + p2.y) / 2;
        const nx2 = -dy / dist, ny2 = dx / dist;
        const sign = bulge > 0 ? 1 : -1;
        const cx = mx2 + sign * nx2 * apothem;
        const cy = my2 + sign * ny2 * apothem;
        const sa = Math.atan2(p1.y - cy, p1.x - cx);
        const steps = Math.max(2, Math.ceil(Math.abs(inc) / (Math.PI / 16)));
        let prev = { x: p1.x, y: p1.y };
        let prevW = sw;
        for (let k = 1; k <= steps; k++) {
          const t = k / steps;
          const a = sa + (inc * k) / steps;
          const cur = { x: cx + radius * Math.cos(a), y: cy + radius * Math.sin(a) };
          const curW = sw + (ew - sw) * t;
          this._pushWideSeg(verts, prev, cur, prevW, curW);
          prev = cur;
          prevW = curW;
        }
        if (expand) { expand(p1.x, p1.y); expand(p2.x, p2.y); }
      }
    }
    if (verts.length < 9) return;
    const geo = new THREE.BufferGeometry();
    geo.setAttribute('position', new THREE.Float32BufferAttribute(verts, 3));
    geo.computeVertexNormals();
    const mat = new THREE.MeshBasicMaterial({
      color: new THREE.Color(color),
      side: THREE.DoubleSide,
      depthWrite: false,
    });
    this._group.add(new THREE.Mesh(geo, mat));
    // Pick as edge segments only — do NOT register the poly as a fill loop.
    // A closed outer frame (도곽 cw=2) used as _pickFills would mark the whole
    // interior as "covered" and (with a weak size check) hide every inner line.
    if (this._pickCurIdx >= 0 && this._pickSegs) {
      for (let i = 0; i < segs; i++) {
        const a = points[i], b = points[(i + 1) % n];
        this._pickSegs.push(a.x, a.y, b.x, b.y);
        this._pickSegMeta.push(this._pickCurIdx);
      }
    }
  }

  // Polyline with bulge arcs (LWPOLYLINE, HATCH boundaries)
  _bulgePolySegs(points, bulges, closed, color, pushSeg, expand) {
    const n = points.length;
    const segs = closed ? n : n - 1;
    for (let i = 0; i < segs; i++) {
      const p1    = points[i];
      const p2    = points[(i + 1) % n];
      const bulge = bulges?.[i] || 0;
      if (Math.abs(bulge) < 1e-6) {
        pushSeg(p1.x, p1.y, p2.x, p2.y, 0, color);
        if (expand) { expand(p1.x, p1.y); expand(p2.x, p2.y); }
      } else {
        const dx = p2.x - p1.x, dy = p2.y - p1.y;
        const dist = Math.sqrt(dx*dx + dy*dy);
        if (dist < 1e-9) continue;
        // Sweep by the signed included angle Δ = 4·atan(bulge). Sweeping the angle
        // directly (rather than computing both endpoint angles and resolving the
        // 2π wrap) avoids drawing the major arc when |bulge| is tiny.
        const inc     = 4 * Math.atan(bulge);          // signed; >0 = CCW
        const half     = Math.abs(inc) / 2;
        const radius  = (dist / 2) / Math.sin(half);
        const apothem = radius * Math.cos(half);
        const mx2 = (p1.x + p2.x) / 2, my2 = (p1.y + p2.y) / 2;
        const nx2 = -dy / dist, ny2 = dx / dist;       // left normal of p1→p2
        const sign = bulge > 0 ? 1 : -1;
        const cx  = mx2 + sign * nx2 * apothem;
        const cy  = my2 + sign * ny2 * apothem;
        const sa  = Math.atan2(p1.y - cy, p1.x - cx);
        const steps = Math.max(2, Math.ceil(Math.abs(inc) / (Math.PI / 16)));
        let prev = p1;
        for (let k = 1; k <= steps; k++) {
          const a = sa + (inc * k) / steps;
          const x = cx + radius * Math.cos(a), y = cy + radius * Math.sin(a);
          pushSeg(prev.x, prev.y, x, y, 0, color);
          prev = { x, y };
        }
        if (expand) { expand(p1.x, p1.y); expand(p2.x, p2.y); }
      }
    }
  }

  _solidMesh(corners, color) {
    const r = ((color >> 16) & 0xFF) / 255;
    const g = ((color >>  8) & 0xFF) / 255;
    const b = (color         & 0xFF) / 255;
    const verts = [], cols = [];
    const addTri = (...pts) => {
      for (const p of pts) { verts.push(p.x, p.y, p.z || 0); cols.push(r, g, b); }
    };
    if (corners.length >= 4) {
      addTri(corners[0], corners[1], corners[3]);
      addTri(corners[0], corners[3], corners[2]);
    } else {
      addTri(corners[0], corners[1], corners[2]);
    }
    const geom = new THREE.BufferGeometry();
    geom.setAttribute('position', new THREE.Float32BufferAttribute(verts, 3));
    geom.setAttribute('color',    new THREE.Float32BufferAttribute(cols, 3));
    this._group.add(new THREE.Mesh(geom, new THREE.MeshBasicMaterial({ vertexColors: true, side: THREE.DoubleSide })));
    // Filled quad/tri → pickable region (DWG SOLID vertex order is 0,1,3,2).
    if (this._pickCurIdx >= 0 && corners.length >= 3) {
      const loop = corners.length >= 4 ? [corners[0], corners[1], corners[3], corners[2]] : corners.slice(0, 3);
      this._pickFills.push({ metaIdx: this._pickCurIdx, loops: [loop] });
    }
  }

  // Text has no line geometry — register its box as a pickable fill so a click
  // anywhere on the text selects it. Box follows the sprite's anchor rules
  // (alignH 0/3/5=left,2=right,1/4=center; alignV 3=top,0/1=bottom,2=middle).
  _addTextPick(text, pos, height, alignH = 0, alignV = 0) {
    if (this._pickCurIdx < 0 || !pos) return;
    const rows = String(text).split('\n');
    const cols = rows.reduce((m, s) => Math.max(m, s.length), 1);
    const w = cols * height * 0.62;          // ~ per-glyph advance
    const h = rows.length * height * 1.2;
    let x0 = pos.x;
    if (alignH === 2)                              x0 = pos.x - w;      // right anchor
    else if (alignH === 1 || alignH === 4)         x0 = pos.x - w / 2;  // center
    let y0 = pos.y;                                                     // bottom anchor
    if (alignV === 3)                              y0 = pos.y - h;      // top anchor
    else if (alignV === 2)                         y0 = pos.y - h / 2;  // middle
    this._pickFills.push({ metaIdx: this._pickCurIdx, loops: [[
      { x: x0, y: y0 }, { x: x0 + w, y: y0 }, { x: x0 + w, y: y0 + h }, { x: x0, y: y0 + h },
    ]] });
  }

  // Even-odd point-in-region across ALL loops of a fill (holes exclude correctly).
  _fillHit(loops, x, y) {
    let inside = false;
    for (const poly of loops) {
      for (let i = 0, j = poly.length - 1; i < poly.length; j = i++) {
        const xi = poly[i].x, yi = poly[i].y, xj = poly[j].x, yj = poly[j].y;
        if (((yi > y) !== (yj > y)) && (x < (xj - xi) * (y - yi) / (yj - yi) + xi)) inside = !inside;
      }
    }
    return inside;
  }

  // True if (x,y) lies inside ANY single loop (NOT even-odd across loops).
  // Used to detect "this point belongs to hatch geometry" including hole
  // interiors — even-odd would report holes as uncovered and let a later
  // LWPOLYLINE re-solid them (CXGLOGO ㅇ/ㅎ counters).
  _pointInAnyLoop(loops, x, y) {
    for (const poly of loops) {
      if (!poly?.length) continue;
      let c = false;
      for (let i = 0, j = poly.length - 1; i < poly.length; j = i++) {
        const a = poly[i], b = poly[j];
        if (((a.y > y) !== (b.y > y)) && (x < (b.x - a.x) * (y - a.y) / (b.y - a.y) + a.x)) c = !c;
      }
      if (c) return true;
    }
    return false;
  }

  // Signed area of a loop (for topmost = smallest-area tie-break on overlapping fills).
  _loopArea(poly) {
    let s = 0;
    for (let i = 0; i < poly.length; i++) { const a = poly[i], b = poly[(i + 1) % poly.length]; s += a.x * b.y - b.x * a.y; }
    return Math.abs(s) / 2;
  }

  // Solid-fill a polyline that is geometrically closed but not covered by any
  // existing hatch fill. Text-as-hatch logos sometimes ship glyph strokes as
  // LWPOLYLINE outlines only (e.g. ㅅ of 사 in CXGLOGO) while sibling glyphs
  // have solid HATCH — without this they render as empty outlines.
  //
  // Coverage test is ANY-loop containment (not even-odd). Logo blocks list
  // HATCH entities first, then the same glyph outlines as LWPOLYLINE. Even-odd
  // treats hole interiors as "uncovered", so the post-hatch polyline pass used
  // to re-solid ㅇ/ㅎ counters and wipe the punches. Any-loop still lets true
  // orphan outlines (ㅅ with no hatch) fill, while skipping anything that
  // already belongs to a hatch loop — fill or hole.
  _fillClosedPolyIfUncovered(points, bulges, color) {
    if (!points || points.length < 3) return;
    const a = points[0], b = points[points.length - 1];
    const gap = Math.hypot(a.x - b.x, a.y - b.y);
    // Allow tiny gaps relative to polyline size (floating-point closed loops).
    let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
    for (const p of points) {
      if (p.x < minX) minX = p.x; if (p.y < minY) minY = p.y;
      if (p.x > maxX) maxX = p.x; if (p.y > maxY) maxY = p.y;
    }
    const diag = Math.hypot(maxX - minX, maxY - minY) || 1;
    if (gap > diag * 1e-4 && gap > 1e-6) return;
    // Area gate: logo glyph strokes are small (area ~1–100 in block units).
    // Refuse huge loops even inside blocks (defensive).
    let sa = 0;
    for (let i = 0; i < points.length; i++) {
      const p0 = points[i], p1 = points[(i + 1) % points.length];
      sa += p0.x * p1.y - p1.x * p0.y;
    }
    const absA = Math.abs(sa) / 2;
    if (absA < 1e-6 || absA > 5000) return;
    let cx = 0, cy = 0;
    for (const p of points) { cx += p.x; cy += p.y; }
    cx /= points.length; cy /= points.length;
    for (const f of this._pickFills) {
      if (this._pointInAnyLoop(f.loops, cx, cy)) return;
    }
    this._hatchFill([{ points, bulges: bulges || null, closed: true }], color);
  }

  // Solid fill HATCH using THREE.ShapeGeometry
  // Tessellate one (closed) hatch boundary loop → flat {x,y}[] (resolves bulge arcs,
  // including the closing edge — a 2-point/2-bulge loop is a full circle).
  _pathPoints(path) {
    const pts = path.points;
    if (!pts?.length) return null;
    const bulges = path.bulges;
    const n = pts.length;
    if (!bulges?.some(b => Math.abs(b) >= 1e-6)) return pts.map(p => ({ x: p.x, y: p.y }));
    const out = [];
    for (let i = 0; i < n; i++) {
      const p1 = pts[i], p2 = pts[(i + 1) % n], bulge = bulges[i] || 0;
      out.push({ x: p1.x, y: p1.y });
      if (Math.abs(bulge) < 1e-6) continue;
      const dx = p2.x - p1.x, dy = p2.y - p1.y, dist = Math.hypot(dx, dy);
      if (dist < 1e-9) continue;
      const inc = 4 * Math.atan(bulge), half = Math.abs(inc) / 2;
      const radius = (dist / 2) / Math.sin(half), apo = radius * Math.cos(half);
      const mx = (p1.x + p2.x) / 2, my = (p1.y + p2.y) / 2;
      const nx = -dy / dist, ny = dx / dist, sign = bulge > 0 ? 1 : -1;
      const cx = mx + sign * nx * apo, cy = my + sign * ny * apo;
      const sa = Math.atan2(p1.y - cy, p1.x - cx);
      const segs = Math.max(6, Math.ceil(Math.abs(inc) / (Math.PI / 16)));
      for (let j = 1; j < segs; j++) {  // intermediate arc points; p2 added next iter
        const a = sa + inc * j / segs;
        out.push({ x: cx + radius * Math.cos(a), y: cy + radius * Math.sin(a) });
      }
    }
    return out;
  }

  // Solid fill with true even-odd parity across all boundary loops.
  //
  // DWG solid HATCH (style Normal / odd parity) is even-odd, not "outer +
  // nested holes". Text-as-hatch logos (CXGLOGO 한국도로공사) ship
  // self-intersecting multi-stroke loops where ShapeGeometry/earcut + geometric
  // nesting mis-classifies ㅇ/ㅎ counters. Verified against samples/11.dwg:
  // SVG fill-rule=evenodd over all non-outlier loops matches the CAD logo.
  _hatchFill(paths, color) {
    const totalPts = paths.reduce((s, p) => s + (p.points?.length ?? 0), 0);
    if (totalPts > 8000) return; // safety for pathological boundaries
    let polys = [];
    for (const p of paths) { const pp = this._pathPoints(p); if (pp && pp.length >= 3) polys.push(pp); }
    if (!polys.length) return;

    const area = (poly) => { let s = 0; for (let i = 0; i < poly.length; i++) { const a = poly[i], b = poly[(i + 1) % poly.length]; s += a.x * b.y - b.x * a.y; } return Math.abs(s) / 2; };

    // Drop spurious giant boundaries (parse-corrupt arcs expanded to huge loops).
    // Many-loop hatches (≥5) or empty-loop hatches get median×10 outlier filter.
    if ((paths.some(p => !(p.points?.length)) && polys.length >= 3) || polys.length >= 5) {
      const sorted = polys.map(area).sort((a, b) => a - b);
      const med = sorted[Math.floor(sorted.length / 2)] || 0;
      if (med > 0) polys = polys.filter(p => area(p) <= med * 10);
      if (!polys.length) return;
    }

    // Picking uses even-odd across all loops (holes exclude correctly).
    if (this._pickCurIdx >= 0 && polys.length) this._pickFills.push({ metaIdx: this._pickCurIdx, loops: polys });

    // When does this hatch need true even-odd (vs independent union of islands)?
    // - Self-intersecting loops (text-as-hatch glyph strokes)
    // - Many loops (≥5): logo words like 한국도로공사
    // - Geometric nesting: a smaller loop sits inside a larger one (island/hole)
    // Separate solid islands that only touch/overlap (EX logo 4 paths) must be
    // UNION — even-odd would punch diamond holes at the overlaps.
    const needsEvenOdd =
      polys.length >= 5 ||
      polys.some((p) => this._polySelfIntersects(p)) ||
      this._hatchHasNestedLoop(polys);

    if (needsEvenOdd) {
      this._hatchFillEvenOddCanvas(polys, color);
      return;
    }

    // Union of simple islands: one ShapeGeometry per loop (no hole punching).
    const mat = new THREE.MeshBasicMaterial({ color: new THREE.Color(color), side: THREE.DoubleSide });
    for (const poly of polys) {
      try {
        const shape = new THREE.Shape();
        shape.moveTo(poly[0].x, poly[0].y);
        for (let k = 1; k < poly.length; k++) shape.lineTo(poly[k].x, poly[k].y);
        shape.closePath();
        this._group.add(new THREE.Mesh(new THREE.ShapeGeometry(shape), mat));
      } catch { /* degenerate */ }
    }
  }

  // True if any loop is (mostly) inside a larger loop — island/hole topology.
  _hatchHasNestedLoop(polys) {
    if (polys.length < 2) return false;
    const area = (poly) => {
      let s = 0;
      for (let i = 0; i < poly.length; i++) {
        const a = poly[i], b = poly[(i + 1) % poly.length];
        s += a.x * b.y - b.x * a.y;
      }
      return Math.abs(s) / 2;
    };
    const bboxOf = (poly) => {
      let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
      for (const p of poly) {
        if (p.x < minX) minX = p.x; if (p.y < minY) minY = p.y;
        if (p.x > maxX) maxX = p.x; if (p.y > maxY) maxY = p.y;
      }
      return { minX, minY, maxX, maxY };
    };
    const inside = (poly, pt) => {
      let c = false;
      for (let i = 0, j = poly.length - 1; i < poly.length; j = i++) {
        const a = poly[i], b = poly[j];
        if (((a.y > pt.y) !== (b.y > pt.y)) && (pt.x < (b.x - a.x) * (pt.y - a.y) / (b.y - a.y) + a.x)) c = !c;
      }
      return c;
    };
    const ar = polys.map(area);
    const bbs = polys.map(bboxOf);
    for (let i = 0; i < polys.length; i++) {
      let cx = 0, cy = 0;
      for (const p of polys[i]) { cx += p.x; cy += p.y; }
      cx /= polys[i].length; cy /= polys[i].length;
      for (let j = 0; j < polys.length; j++) {
        if (i === j || ar[j] <= ar[i]) continue;
        const bb = bbs[j], bi = bbs[i];
        const bboxHit = bb.minX <= bi.minX && bb.minY <= bi.minY && bb.maxX >= bi.maxX && bb.maxY >= bi.maxY;
        if (bboxHit || inside(polys[j], { x: cx, y: cy })) return true;
      }
    }
    return false;
  }

  // Cheap self-intersection probe (adjacent edges ignored). Used only to choose
  // ShapeGeometry vs even-odd canvas; false negatives still go through canvas
  // when there are multiple loops.
  _polySelfIntersects(poly) {
    const n = poly.length;
    if (n < 4) return false;
    const cross = (u, v, w) => (v.x - u.x) * (w.y - u.y) - (v.y - u.y) * (w.x - u.x);
    const hits = (a, b, c, d) => {
      const d1 = cross(a, b, c), d2 = cross(a, b, d), d3 = cross(c, d, a), d4 = cross(c, d, b);
      return ((d1 > 0 && d2 < 0) || (d1 < 0 && d2 > 0)) && ((d3 > 0 && d4 < 0) || (d3 < 0 && d4 > 0));
    };
    // Cap checks for large loops (logo glyphs are small).
    const lim = Math.min(n, 80);
    for (let i = 0; i < lim; i++) {
      const a = poly[i], b = poly[(i + 1) % n];
      for (let j = i + 2; j < lim; j++) {
        if (i === 0 && j === n - 1) continue;
        if (j === (i + n - 1) % n) continue;
        if (hits(a, b, poly[j], poly[(j + 1) % n])) return true;
      }
    }
    return false;
  }

  // Diameter-like edge through bbox center: corrupt hatch chords (CXGLOGO ㅎ)
  // that turn even-odd into a Mercedes/pie pattern. True when shoelace area is
  // also inflated above the convex hull (self-intersecting junk).
  _isDiameterInflatedPath(pts) {
    if (!pts || pts.length < 8) return false;
    let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
    for (const p of pts) {
      if (p.x < minX) minX = p.x; if (p.y < minY) minY = p.y;
      if (p.x > maxX) maxX = p.x; if (p.y > maxY) maxY = p.y;
    }
    const w = maxX - minX, h = maxY - minY;
    const minDim = Math.min(w, h);
    if (!(minDim > 1e-9)) return false;
    const cx = (minX + maxX) / 2, cy = (minY + maxY) / 2;
    const thr = 0.55 * minDim;
    const centerR = 0.22 * minDim;
    let diamN = 0;
    for (let i = 0; i < pts.length; i++) {
      const a = pts[i], b = pts[(i + 1) % pts.length];
      const len = Math.hypot(b.x - a.x, b.y - a.y);
      if (len < thr) continue;
      const mx = (a.x + b.x) / 2, my = (a.y + b.y) / 2;
      if (Math.hypot(mx - cx, my - cy) <= centerR) diamN++;
    }
    if (!diamN) return false;
    // shoelace abs area vs convex hull — inflated ⇒ self-intersecting
    let sa = 0;
    for (let i = 0; i < pts.length; i++) {
      const a = pts[i], b = pts[(i + 1) % pts.length];
      sa += a.x * b.y - b.x * a.y;
    }
    const absA = Math.abs(sa) / 2;
    const hull = this._convexHull(pts);
    if (hull.length < 3) return false;
    let ha = 0;
    for (let i = 0; i < hull.length; i++) {
      const a = hull[i], b = hull[(i + 1) % hull.length];
      ha += a.x * b.y - b.x * a.y;
    }
    ha = Math.abs(ha) / 2;
    return ha > 1e-9 && absA > ha * 1.15;
  }

  _convexHull(pts) {
    const p = pts.map((q) => ({ x: q.x, y: q.y })).sort((a, b) => a.x - b.x || a.y - b.y);
    if (p.length <= 2) return p;
    const cross = (o, a, b) => (a.x - o.x) * (b.y - o.y) - (a.y - o.y) * (b.x - o.x);
    const lower = [];
    for (const pt of p) {
      while (lower.length >= 2 && cross(lower[lower.length - 2], lower[lower.length - 1], pt) <= 0) lower.pop();
      lower.push(pt);
    }
    const upper = [];
    for (let i = p.length - 1; i >= 0; i--) {
      const pt = p[i];
      while (upper.length >= 2 && cross(upper[upper.length - 2], upper[upper.length - 1], pt) <= 0) upper.pop();
      upper.push(pt);
    }
    lower.pop();
    upper.pop();
    return lower.concat(upper);
  }

  _polyCentroid(poly) {
    let x = 0, y = 0;
    for (const p of poly) { x += p.x; y += p.y; }
    return { x: x / poly.length, y: y / poly.length };
  }

  _pointInPoly(poly, pt) {
    let c = false;
    for (let i = 0, j = poly.length - 1; i < poly.length; j = i++) {
      const a = poly[i], b = poly[j];
      if (((a.y > pt.y) !== (b.y > pt.y)) && (pt.x < (b.x - a.x) * (pt.y - a.y) / (b.y - a.y) + a.x)) c = !c;
    }
    return c;
  }

  // Raster even-odd fill into a CanvasTexture plane. Sharp enough for logo-scale
  // glyphs (tens of units); large site hatches still use ShapeGeometry when they
  // are a single simple loop. Texture is disposed with the mesh on reload.
  //
  // Diameter-inflated loops (ㅎ of 한 in CXGLOGO): pure even-odd yields a pie/
  // Mercedes pattern from spurious center chords. Those loops are filled with
  // nonzero (solid glyph + cross), then nested sibling loops punch the counters
  // (ㅇ hole). Remaining loops use normal even-odd.
  _hatchFillEvenOddCanvas(polys, color) {
    let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
    for (const poly of polys) {
      for (const p of poly) {
        if (p.x < minX) minX = p.x; if (p.y < minY) minY = p.y;
        if (p.x > maxX) maxX = p.x; if (p.y > maxY) maxY = p.y;
      }
    }
    const worldW = maxX - minX;
    const worldH = maxY - minY;
    if (!(worldW > 1e-12) || !(worldH > 1e-12)) return;

    // Pad 1px equivalent so AA edges aren't clipped.
    const MAX = 2048;
    const pxPerUnit = Math.min(MAX / worldW, MAX / worldH, 64);
    const tw = Math.max(2, Math.ceil(worldW * pxPerUnit) + 2);
    const th = Math.max(2, Math.ceil(worldH * pxPerUnit) + 2);
    const sx = (tw - 2) / worldW;
    const sy = (th - 2) / worldH;

    const canvas = document.createElement('canvas');
    canvas.width = tw;
    canvas.height = th;
    const ctx = canvas.getContext('2d');
    if (!ctx) return;
    ctx.clearRect(0, 0, tw, th);

    const toCanvas = (p) => ({
      x: 1 + (p.x - minX) * sx,
      y: 1 + (maxY - p.y) * sy,
    });
    const addPoly = (poly) => {
      if (poly.length < 3) return;
      const p0 = toCanvas(poly[0]);
      ctx.moveTo(p0.x, p0.y);
      for (let i = 1; i < poly.length; i++) {
        const p = toCanvas(poly[i]);
        ctx.lineTo(p.x, p.y);
      }
      ctx.closePath();
    };

    const solidPolys = [];
    const evenPolys = [];
    for (const poly of polys) {
      if (this._isDiameterInflatedPath(poly)) solidPolys.push(poly);
      else evenPolys.push(poly);
    }
    // Self-intersecting solid outlines fail ordinary PIP for hole nesting — use
    // their convex hull as the containment oracle (ㅎ outer vs ㅇ counter).
    const solidHulls = solidPolys.map((p) => this._convexHull(p));

    const isHoleOfSolid = (poly) => {
      if (poly.length < 3 || !solidHulls.length) return false;
      const c = this._polyCentroid(poly);
      for (const hull of solidHulls) {
        if (hull.length >= 3 && this._pointInPoly(hull, c)) return true;
      }
      return false;
    };

    // 1) Nonzero fill for diameter-inflated glyphs (ㅎ solid + cross, no pie).
    if (solidPolys.length) {
      ctx.fillStyle = '#ffffff';
      ctx.beginPath();
      for (const poly of solidPolys) addPoly(poly);
      ctx.fill('nonzero');

      // 2) Punch counters nested inside a solid glyph.
      const holes = evenPolys.filter(isHoleOfSolid);
      if (holes.length) {
        ctx.globalCompositeOperation = 'destination-out';
        ctx.beginPath();
        for (const poly of holes) addPoly(poly);
        ctx.fill('nonzero');
        ctx.globalCompositeOperation = 'source-over';
      }
    }

    // 3) Remaining loops (not used as hole punches) → even-odd.
    const rest = evenPolys.filter((p) => !isHoleOfSolid(p));
    if (rest.length) {
      ctx.fillStyle = '#ffffff';
      ctx.beginPath();
      for (const poly of rest) addPoly(poly);
      ctx.fill('evenodd');
    }

    const tex = new THREE.CanvasTexture(canvas);
    tex.colorSpace = THREE.NoColorSpace;
    tex.magFilter = THREE.LinearFilter;
    tex.minFilter = THREE.LinearMipmapLinearFilter;
    tex.generateMipmaps = true;
    tex.needsUpdate = true;

    const mat = new THREE.MeshBasicMaterial({
      map: tex,
      color: new THREE.Color(color),
      transparent: true,
      alphaTest: 0.4,
      side: THREE.DoubleSide,
      depthWrite: false,
    });
    const geo = new THREE.PlaneGeometry(worldW, worldH);
    const mesh = new THREE.Mesh(geo, mat);
    mesh.position.set((minX + maxX) / 2, (minY + maxY) / 2, 0);
    // PlaneGeometry is XY; our 2D world is already XY. No rotation needed.
    this._group.add(mesh);
  }

  // Multi-line MTEXT: one canvas with stacked lines, aligned as a block.
  // alignH 0=left 1/4=center 2=right (per line); alignV 3=top 2=middle 0/1=bottom anchor.
  _multilineSprite(lines, pos, height, rotation, color, alignH, alignV) {
    const fontSize = 96;
    const font = `${fontSize}px 'Malgun Gothic', 'Apple SD Gothic Neo', monospace`;
    const canvas = document.createElement('canvas');
    const ctx = canvas.getContext('2d');
    ctx.font = font;
    let tw = 1, asc = fontSize * 0.70, desc = fontSize * 0.20;
    for (const ln of lines) {
      const m = ctx.measureText(ln || ' ');
      tw = Math.max(tw, Math.ceil(m.width));
      asc = Math.max(asc, m.actualBoundingBoxAscent || fontSize * 0.70);
      desc = Math.max(desc, m.actualBoundingBoxDescent || fontSize * 0.20);
    }
    const pad  = Math.ceil(fontSize * 0.15);
    const step = Math.ceil(asc + desc + fontSize * 0.35); // baseline-to-baseline
    canvas.width  = tw + pad * 2;
    canvas.height = step * lines.length + pad * 2;
    ctx.font = font; // resizing the canvas clears state

    const ri = (color >> 16) & 0xFF, gi = (color >> 8) & 0xFF, bi = color & 0xFF;
    ctx.fillStyle = `rgb(${ri},${gi},${bi})`;
    ctx.textBaseline = 'alphabetic';
    let ax = pad;
    if (alignH === 1 || alignH === 4) { ctx.textAlign = 'center'; ax = canvas.width / 2; }
    else if (alignH === 2)            { ctx.textAlign = 'right';  ax = canvas.width - pad; }
    else                              { ctx.textAlign = 'left';   ax = pad; }
    for (let i = 0; i < lines.length; i++) ctx.fillText(lines[i], ax, pad + asc + i * step);

    const texture = new THREE.CanvasTexture(canvas);
    const pxToWorld = height / asc;             // one line's cap height == DWG text height
    const vw = canvas.width  * pxToWorld;
    const vh = canvas.height * pxToWorld;

    // Anchor the text block so the requested datum lands on pos (block edges).
    let ox = 0, oy = 0;
    if (alignH === 0 || alignH === 3 || alignH === 5) ox = vw / 2;   // left edge at pos.x
    else if (alignH === 2)                            ox = -vw / 2;  // right edge at pos.x
    if (alignV === 3)                      oy = -vh / 2;  // top edge at pos.y
    else if (alignV === 0 || alignV === 1) oy = vh / 2;   // bottom edge at pos.y

    const mat = new THREE.SpriteMaterial({ map: texture, transparent: true, depthTest: false });
    if (rotation) mat.rotation = rotation;
    const sprite = new THREE.Sprite(mat);
    sprite.scale.set(vw, vh, 1);
    sprite.position.set(pos.x + ox, pos.y + oy, 1);
    this._group.add(sprite);
  }

  // MTEXT background mask (opaque fill behind text). Flags (DXF 90):
  //   0x01 = use background fill color (63)
  //   0x02 = use drawing window color
  //   0x10 = text frame only (R2018+)
  // bgScale (DXF 45, default 1.5) = border offset factor × text height.
  _drawMTextBackground(t, engine, minTextH) {
    const flags = t.bgFillFlags | 0;
    if (!flags) return;
    const useFill = !!(flags & 0x01) || !!(flags & 0x02);
    const useFrame = !!(flags & 0x10);
    if (!useFill && !useFrame) return;

    const height = Math.max(t.height || 2.5, minTextH || 0);
    const lines = String(t.text || '').split('\n');
    const ls = t.linespacingFactor > 0 ? t.linespacingFactor : 1;
    // Match slugText line step (CAD MTEXT default ~ 5/3 of height × factor)
    const lineStep = height * (5 / 3) * ls;
    let maxEm = 0;
    if (engine?.measureEm) {
      for (const line of lines) maxEm = Math.max(maxEm, engine.measureEm(line || ' '));
    } else {
      // ~0.9 em per Hangul/Latin fallback when engine unavailable
      for (const line of lines) maxEm = Math.max(maxEm, (line || ' ').length * 0.9);
    }
    let textW = Math.max(maxEm * height, height * 0.5);
    let textH = lines.length <= 1
      ? height
      : height + (lines.length - 1) * lineStep;
    if (t.rectWidth > 0) textW = Math.max(textW, t.rectWidth);
    if (t.rectHeight > 0) textH = Math.max(textH, t.rectHeight);

    const scale = t.bgScale > 0 ? t.bgScale : 1.5;
    // Scale factor expands the text bbox (1.5 → 50% larger total).
    const boxW = textW * scale;
    const boxH = textH * scale;

    // Text-center offset from insertion/attachment point (same rules as slug/sprite).
    const alignH = t.alignH ?? 1;
    const alignV = t.alignV ?? 2;
    let lx = 0, ly = 0;
    if (alignH === 0 || alignH === 3 || alignH === 5) lx = textW / 2;
    else if (alignH === 2) lx = -textW / 2;
    if (alignV === 3) ly = -textH / 2;
    else if (alignV === 0 || alignV === 1) ly = textH / 2;

    const rot = t.rotation || 0;
    const cos = Math.cos(rot), sin = Math.sin(rot);
    const cx = t.pos.x + lx * cos - ly * sin;
    const cy = t.pos.y + lx * sin + ly * cos;

    let bgColor = 0xFFFF00; // default yellow if color missing
    if (flags & 0x02) {
      // Drawing window color — follow viewer theme
      const dark = this._scene?.background?.r < 0.5;
      bgColor = dark ? 0x0a0b0d : 0xf7f6f3;
    } else if (t.bgColorRgb && (t.bgColorRgb.r != null)) {
      bgColor = ((t.bgColorRgb.r & 255) << 16) | ((t.bgColorRgb.g & 255) << 8) | (t.bgColorRgb.b & 255);
    } else if (t.bgColorIndex != null) {
      const hex = aciToHex(t.bgColorIndex);
      if (hex != null) bgColor = hex;
    }

    if (useFill) {
      const geo = new THREE.PlaneGeometry(boxW, boxH);
      const mat = new THREE.MeshBasicMaterial({
        color: new THREE.Color(bgColor),
        side: THREE.DoubleSide,
        depthWrite: false,
        transparent: false,
      });
      const mesh = new THREE.Mesh(geo, mat);
      mesh.position.set(cx, cy, 0.4); // behind text (z≈1)
      mesh.rotation.z = rot;
      this._group.add(mesh);
    }
    if (useFrame && !useFill) {
      // Outline only — four edges as hairline segs (rare path)
      const hw = boxW / 2, hh = boxH / 2;
      const corners = [[-hw, -hh], [hw, -hh], [hw, hh], [-hw, hh], [-hw, -hh]];
      const world = corners.map(([x, y]) => ({
        x: cx + x * cos - y * sin,
        y: cy + x * sin + y * cos,
      }));
      // Use a thin mesh strip ring via Line if we had a helper; simple solid edges:
      for (let i = 0; i < 4; i++) {
        const a = world[i], b = world[i + 1];
        this._widePolyMesh(
          [a, b], null, false,
          { constantWidth: Math.max(height * 0.05, 0.01) },
          bgColor, 1, null,
        );
      }
    }
  }

  // Slug vector text (GPU winding-number glyphs, see slugText.ts): one merged
  // mesh per load for ALL texts. Async because the TTF loads once on demand;
  // falls back to the legacy canvas sprites if the font can't be fetched.
  async _drawTexts(texts, minTextH) {
    const gen = this._textGen;
    try {
      const engine = await SlugTextEngine.shared();
      if (gen !== this._textGen) return; // a clear()/load() superseded this flush
      // Background masks first (under glyphs).
      for (const t of texts) {
        if ((t.bgFillFlags | 0) !== 0) this._drawMTextBackground(t, engine, minTextH);
      }
      const batch = new SlugTextBatch(engine);
      for (const t of texts) {
        batch.add(t.text, t.pos, Math.max(t.height, minTextH), t.rotation || 0, t.color, t.alignH ?? 0, t.alignV ?? 0);
      }
      const mesh = batch.build();
      if (mesh) this._group.add(mesh);
    } catch (e) {
      console.warn('[Viewer2D] Slug text unavailable, falling back to canvas sprites:', e?.message ?? e);
      if (gen !== this._textGen) return;
      for (const t of texts) {
        if ((t.bgFillFlags | 0) !== 0) this._drawMTextBackground(t, null, minTextH);
        this._textSprite(t.text, t.pos, Math.max(t.height, minTextH), t.rotation, t.color, t.alignH ?? 0, t.alignV ?? 0);
      }
    }
  }

  // alignH: 0=left, 1=center, 2=right, 4=middle-center.  alignV: 0=baseline,1=bottom,2=middle,3=top.
  _textSprite(text, pos, height, rotation, color, alignH = 0, alignV = 0) {
    // MTEXT paragraph breaks (\P → \n) produce multi-line text: render stacked.
    const lines = String(text).split('\n');
    if (lines.length > 1) {
      this._multilineSprite(lines, pos, height, rotation, color, alignH, alignV);
      return;
    }
    // Texture cache: table drawings repeat the same strings thousands of times
    // ("D25", sizes, counts). Rasterizing each occurrence separately OOMs on
    // dense sheets (e.g. 6k+ texts) — share one CanvasTexture per (text, color).
    // Alignment/rotation are per-sprite (scale/offset/material), not per-raster.
    const cacheKey = text + '' + color;
    let tex = (this._texCache ??= new Map()).get(cacheKey);
    if (!tex) {
      const fontSize = 96;
      const font     = `${fontSize}px 'Malgun Gothic', 'Apple SD Gothic Neo', monospace`;
      const canvas   = document.createElement('canvas');
      const ctx      = canvas.getContext('2d');
      ctx.font = font;
      const m   = ctx.measureText(text);
      const tw  = Math.max(1, Math.ceil(m.width));
      // Actual ink extents above/below the baseline (fallback to typical font ratios).
      const asc  = m.actualBoundingBoxAscent  || fontSize * 0.70;  // ≈ cap/glyph height
      const desc = m.actualBoundingBoxDescent || fontSize * 0.20;
      const pad  = Math.ceil(fontSize * 0.15);
      // Symmetric padding → the ink bounding box stays centered in the canvas.
      canvas.width  = tw + pad * 2;
      canvas.height = Math.ceil(asc + desc) + pad * 2;
      ctx.font = font;  // reset (resizing the canvas clears state)
      const ri = (color >> 16) & 0xFF, gi = (color >> 8) & 0xFF, bi = color & 0xFF;
      ctx.fillStyle    = `rgb(${ri},${gi},${bi})`;
      ctx.textBaseline = 'alphabetic';
      ctx.fillText(text, pad, pad + asc);
      tex = { texture: new THREE.CanvasTexture(canvas), w: canvas.width, h: canvas.height, asc, pad };
      this._texCache.set(cacheKey, tex);
    }
    const { texture, asc, pad } = tex;

    // Size so the visible ascent (≈ DWG cap height) equals the DWG text `height`.
    const vh = height * tex.h / asc;
    const vw = vh * (tex.w / tex.h);
    const pxToWorld = vh / tex.h;
    const centerPx  = tex.h / 2;

    // X: place sprite so the requested horizontal datum lands on pos.x.
    let ox = 0;
    if      (alignH === 0 || alignH === 3 || alignH === 5) ox = vw / 2;   // left edge at pos.x
    else if (alignH === 1 || alignH === 4)                 ox = 0;        // center at pos.x
    else if (alignH === 2)                                 ox = -vw / 2;  // right edge at pos.x

    // Y: map the alignment datum (in canvas px) to pos.y. Canvas y grows downward,
    // world y upward → world offset of a canvas row = (centerPx - rowPx) * pxToWorld.
    // ah=4 (DWG "middle" justification) forces both-axis centering regardless of av.
    let oy = 0;
    if (alignH !== 4) {
      if      (alignV === 0 || alignV === 1) oy = (pad + asc - centerPx) * pxToWorld;  // baseline/bottom datum
      else if (alignV === 3)                 oy = (pad       - centerPx) * pxToWorld;  // top datum
      // alignV === 2 (middle): ink already centered → oy = 0
    }

    const mat    = new THREE.SpriteMaterial({ map: texture, transparent: true, depthTest: false });
    if (rotation) mat.rotation = rotation;
    const sprite = new THREE.Sprite(mat);
    sprite.scale.set(vw, vh, 1);
    sprite.position.set(pos.x + ox, pos.y + oy, 1);
    this._group.add(sprite);
  }

  // Render block definition entities transformed by INSERT params
  _insertEntities(entities, d, color, pushSeg, pendingTexts, ctx) {
    const entsByOwner = ctx?.entsByOwner;
    const blockBase   = ctx?.blockBase;
    const parentXf    = ctx?.parentXf ?? null;
    const parentScale = ctx?.scale ?? 1;
    const parentRot   = ctx?.rot ?? 0;
    const depth       = ctx?.depth ?? 0;

    const ip   = d.insertionPoint ?? { x: 0, y: 0 };
    const base = d.basePoint;
    const sx   = d.xScale ?? 1, sy = d.yScale ?? 1;
    const rot  = d.rotation ?? 0;
    const cos  = Math.cos(rot), sin = Math.sin(rot);

    // Local transform: block-local coords → parent-local (or world if top level).
    const localXf = (px, py) => {
      const lx = base ? px - base.x : px;
      const ly = base ? py - base.y : py;
      return [
        ip.x + (lx * sx) * cos - (ly * sy) * sin,
        ip.y + (lx * sx) * sin + (ly * sy) * cos,
      ];
    };
    // Compose with parent transform for nested INSERTs.
    const xf = parentXf ? (px, py) => parentXf(...localXf(px, py)) : localXf;
    // Accumulated uniform scale (for radii) and rotation (for arc/ellipse angles).
    const scaleAcc = parentScale * Math.max(Math.abs(sx), Math.abs(sy));
    const rotAcc   = parentRot + rot;

    for (const be of entities) {
      const bd = be.data || be;
      const bt = (be.type || be.typeName || '').toUpperCase();
      if (bt === 'ATTDEF') continue; // skip attribute definitions
      const ecol = this._resolveBlockColor(be, color);
      try {
        if (bt === 'LINE' && bd.start && bd.end) {
          const [ax, ay] = xf(bd.start.x, bd.start.y);
          const [bx, by] = xf(bd.end.x,   bd.end.y);
          pushSeg(ax, ay, bx, by, 0, ecol);

        } else if ((bt === 'CIRCLE' || bt === 'ARC') && bd.center && bd.radius != null) {
          const [cx, cy] = xf(bd.center.x, bd.center.y);
          const r  = bd.radius * scaleAcc;
          const a0 = bt === 'ARC' ? (bd.startAngle ?? 0) + rotAcc      : 0;
          const a1 = bt === 'ARC' ? (bd.endAngle   ?? Math.PI*2) + rotAcc : Math.PI*2;
          this._arcSegs({ x:cx, y:cy, z:0 }, r, a0, a1, 0, ecol, pushSeg);

        } else if (bt === 'ELLIPSE' && bd.center) {
          const [cx, cy] = xf(bd.center.x, bd.center.y);
          const ma   = bd.majorAxis ?? bd.smAxis ?? { x:1, y:0 };
          const mlen = Math.hypot(ma.x ?? 0, ma.y ?? 0) * scaleAcc;
          const mang = Math.atan2(ma.y ?? 0, ma.x ?? 1) + rotAcc;
          this._ellipseSegs({
            center: { x:cx, y:cy, z:0 },
            majorAxis: { x: mlen * Math.cos(mang), y: mlen * Math.sin(mang) },
            ratio: bd.ratio ?? bd.axisRatio ?? 1,
            startParam: bd.startParam ?? 0,
            endParam: bd.endParam ?? Math.PI*2,
          }, ecol, pushSeg);

        } else if ((bt === 'LWPOLYLINE' || bt === 'POLYLINE') && (bd.points || bd.vertices)) {
          const raw = bd.points ?? bd.vertices;
          const pts = raw.map(p => { const [nx, ny] = xf(p.x, p.y); return { x:nx, y:ny }; });
          // Preserve per-vertex bulges through the transform (scalar, not position).
          const bulges = bd.bulges ?? null;
          const closed = !!(bd.closed || (bd.flags & 1));
          // Logo blocks list solid HATCH first, then the same glyph outlines as
          // LWPOLYLINE. Re-stroking those glyph outlines draws chords across ㅇ
          // holes — skip ONLY true re-outlines: same scale as the covering loop.
          // (Not "poly smaller than loop" — that also killed 도곽 안쪽 가는 선
          // whose centroid sat inside the outer frame / a large hatch.)
          let skipGlyphReoutline = false;
          if (pts.length >= 2 && this._pickFills.length) {
            let cx = 0, cy = 0, pMinX = Infinity, pMinY = Infinity, pMaxX = -Infinity, pMaxY = -Infinity;
            for (const p of pts) {
              cx += p.x; cy += p.y;
              if (p.x < pMinX) pMinX = p.x; if (p.y < pMinY) pMinY = p.y;
              if (p.x > pMaxX) pMaxX = p.x; if (p.y > pMaxY) pMaxY = p.y;
            }
            cx /= pts.length; cy /= pts.length;
            const pw = Math.max(pMaxX - pMinX, 1e-9);
            const ph = Math.max(pMaxY - pMinY, 1e-9);
            for (const f of this._pickFills) {
              if (!this._pointInAnyLoop(f.loops, cx, cy)) continue;
              for (const loop of f.loops) {
                if (!loop?.length) continue;
                let lMinX = Infinity, lMinY = Infinity, lMaxX = -Infinity, lMaxY = -Infinity;
                for (const q of loop) {
                  if (q.x < lMinX) lMinX = q.x; if (q.y < lMinY) lMinY = q.y;
                  if (q.x > lMaxX) lMaxX = q.x; if (q.y > lMaxY) lMaxY = q.y;
                }
                const lw = Math.max(lMaxX - lMinX, 1e-9);
                const lh = Math.max(lMaxY - lMinY, 1e-9);
                // Similar size both ways (re-outline of same glyph/hatch).
                const similar =
                  pw <= lw * 1.5 && ph <= lh * 1.5 &&
                  lw <= pw * 1.5 && lh <= ph * 1.5;
                if (similar) { skipGlyphReoutline = true; break; }
              }
              if (skipGlyphReoutline) break;
            }
          }
          if (!skipGlyphReoutline) {
            const nSeg = closed ? pts.length : pts.length - 1;
            // start/end/constant width (도곽 frame etc.) — mesh strip, scaled by INSERT
            if (this._polyHasWidth(be, nSeg, scaleAcc)) {
              this._widePolyMesh(pts, bulges, closed, be, ecol, scaleAcc, null);
            } else {
              if (bulges?.some(b => Math.abs(b) >= 1e-6)) this._bulgePolySegs(pts, bulges, closed, ecol, pushSeg);
              else this._polylineSegs(pts, closed, 0, ecol, pushSeg);
              this._fillClosedPolyIfUncovered(pts, bulges, ecol);
            }
          }

        } else if (bt === 'POLYLINE_2D' && entsByOwner) {
          // Old-style 2D polyline inside a block: vertices are separate VERTEX_2D
          // entities owned by the polyline (point/bulge at top level).
          const kids = (entsByOwner.get(be.handle?.value?.toString(16)) ?? [])
            .filter(v => (v.type||'').toUpperCase().startsWith('VERTEX') && v.point);
          if (kids.length >= 2) {
            const pts    = kids.map(v => { const [nx, ny] = xf(v.point.x, v.point.y); return { x:nx, y:ny }; });
            const bulges = kids.map(v => v.bulge || 0);
            const closed = (bd.flags & 1) === 1;
            if (bulges.some(b => Math.abs(b) >= 1e-6)) this._bulgePolySegs(pts, bulges, closed, ecol, pushSeg);
            else                                       this._polylineSegs(pts, closed, 0, ecol, pushSeg);
          }

        } else if (bt === 'HATCH') {
          const paths = bd.paths ?? be.paths;
          if (paths?.length) {
            const solidFill = bd.solidFill ?? be.solidFill ?? false;
            const tpaths = paths.map(p => ({
              ...p,
              points: (p.points ?? []).map(pt => { const [nx, ny] = xf(pt.x, pt.y); return { x:nx, y:ny }; }),
            }));
            // Solid fill: draw fill only (CAD does not render hatch boundaries).
            // Pattern hatch: draw boundary outline as a proxy (no pattern support).
            if (solidFill) {
              this._hatchFill(tpaths, ecol);
            } else {
              for (const tp of tpaths) {
                if ((tp.points?.length ?? 0) < 2) continue;
                if (tp.bulges?.some(b => Math.abs(b) >= 1e-6)) this._bulgePolySegs(tp.points, tp.bulges, true, ecol, pushSeg);
                else this._polylineSegs(tp.points, true, 0, ecol, pushSeg);
              }
            }
          }

        } else if (bt === 'SOLID') {
          const crs = [bd.corner1||bd.pt1, bd.corner2||bd.pt2,
                       bd.corner3||bd.pt3, bd.corner4||bd.pt4].filter(Boolean);
          if (crs.length >= 3) {
            const mapped = crs.map(p => { const [nx,ny] = xf(p.x, p.y); return {x:nx, y:ny, z:p.z||0}; });
            this._solidMesh(mapped, ecol);
          }

        } else if (bt === 'INSERT' && entsByOwner && depth < 8) {
          // Nested block reference: recurse with composed transform.
          const bhVal = be.blockHeaderHandle?.value ?? bd.blockHeaderHandle?.value;
          if (bhVal != null) {
            const hex = bhVal.toString(16);
            const childEnts = entsByOwner.get(hex) ?? [];
            if (childEnts.length) {
              const nip  = be.insertionPt ?? bd.insertionPt ?? bd.insertionPoint ?? { x:0, y:0 };
              const nsx  = bd.scaleX ?? bd.scale?.x ?? be.scale?.x ?? 1;
              const nsy  = bd.scaleY ?? bd.scale?.y ?? be.scale?.y ?? 1;
              const nrot = bd.rotation ?? be.rotation ?? 0;
              this._insertEntities(
                childEnts,
                { insertionPoint: nip, xScale: nsx, yScale: nsy, rotation: nrot, basePoint: blockBase?.get(hex) },
                ecol, pushSeg, pendingTexts,
                { entsByOwner, blockBase, parentXf: xf, scale: scaleAcc, rot: rotAcc, depth: depth + 1 }
              );
            }
          }

        } else if ((bt === 'TEXT' || bt === 'MTEXT' || bt === 'ATTRIB' || bt === 'ATTDEF') && pendingTexts) {
          if ((bt === 'ATTRIB' || bt === 'ATTDEF') && ((bd.flags ?? 0) & 1)) continue;
          const raw  = be.text ?? bd.text ?? bd.textValue ?? bd.defaultValue ?? '';
          const text = stripMText(raw);
          let ah, av, rot = (bd.rotationAngle ?? 0) + rotAcc;
          if (bt === 'MTEXT') {
            // MTEXT anchors via attachment point 1-9 (1-3 top / 4-6 mid / 7-9
            // bottom, columns L/C/R), not horiz/vertAlignment — the fallback
            // 0/0 (left-baseline) pushed table cells to the top-right.
            const ap = be.attachment ?? bd.attachment ?? be.attachmentPoint ?? bd.attachmentPoint ?? 5;
            ah = ([1,4,7].includes(ap) ? 0 : [3,6,9].includes(ap) ? 2 : 1);
            av = ([1,2,3].includes(ap) ? 3 : [7,8,9].includes(ap) ? 1 : 2);
            const xd = be.xAxisDir ?? bd.xAxisDir;
            if (xd) rot = Math.atan2(xd.y, xd.x) + rotAcc;
          } else {
            ah = bd.horizAlignment ?? be.horizAlignment ?? 0;
            av = bd.vertAlignment  ?? be.vertAlignment  ?? 0;
          }
          const useAp = bt !== 'MTEXT' && (ah !== 0 || av !== 0);
          const alignPt  = be.alignmentPt ?? bd.alignmentPt;
          const insertPt = be.insertionPt ?? bd.insertionPt ?? bd.insertionPoint;
          const tpos = useAp
            ? (alignPt ?? insertPt ?? {x:0,y:0})
            : (insertPt ?? {x:0,y:0});
          const [tx, ty] = xf(tpos.x, tpos.y);
          const ht  = (bd.textHeight ?? bd.height ?? be.textHeight ?? 2.5) * scaleAcc;
          if (text) {
            const entry = { text, pos:{x:tx, y:ty}, height:ht, rotation:rot, color: ecol, alignH:ah, alignV:av };
            if (bt === 'MTEXT') {
              entry.linespacingFactor = be.linespacingFactor ?? bd.linespacingFactor ?? 1;
              entry.rectWidth = (be.rectWidth ?? bd.rectWidth ?? 0) * scaleAcc;
              entry.rectHeight = (be.rectHeight ?? bd.rectHeight ?? 0) * scaleAcc;
              entry.bgFillFlags = be.bgFillFlags ?? bd.bgFillFlags ?? 0;
              entry.bgScale = be.bgScale ?? bd.bgScale ?? 1.5;
              entry.bgColorIndex = be.bgColorIndex ?? bd.bgColorIndex;
              entry.bgColorRgb = be.bgColorRgb ?? bd.bgColorRgb;
            }
            pendingTexts.push(entry);
          }
        }
      } catch { /* skip */ }
    }
  }

  // Fallback dimension rendering from entity properties when no block geometry available
  _renderDimFallback(e, d, type, color, pushSeg, pendingTexts, expand) {
    const pt10  = e.pt10  ?? d.pt10;
    const pt13  = e.pt13  ?? d.pt13;
    const pt14  = e.pt14  ?? d.pt14;
    const pt15  = e.pt15  ?? d.pt15;
    const textMidPt = e.textMidPt ?? d.textMidPt;
    const actualMeasurement = e.actualMeasurement ?? d.actualMeasurement ?? 0;
    const textRot = e.textRot ?? d.textRot ?? 0;
    const dimRot  = e.dimRot  ?? d.dimRot  ?? 0;
    const userText = e.userText ?? d.userText ?? '';

    const fmtLen = (v) => Math.abs(v) < 1 ? v.toFixed(3) : v.toFixed(2);

    const drawLine = (a, b) => {
      if (!a || !b) return;
      pushSeg(a.x, a.y, b.x, b.y, 0, color);
      expand(a.x, a.y); expand(b.x, b.y);
    };
    const drawArc = (cx, cy, r, sa, ea) => {
      this._arcSegs({ x:cx, y:cy }, r, sa, ea, 0, color, pushSeg);
    };
    const arrow = (pt, rot, sz) => this._arrowMesh(pt, rot, sz, color);
    const drawText = (pos, text, height, rot) => {
      if (text && pos) pendingTexts.push({ text, pos, height, rotation: rot ?? 0, color, alignH: 1, alignV: 2 });
    };

    switch (type) {
      case 'DIMENSION':
      case 'DIMENSION_LINEAR':
      case 'DIMENSION_ALIGNED': {
        if (!pt13 || !pt14 || !pt10) return;
        let d1x, d1y, d2x, d2y;
        if (type === 'DIMENSION_ALIGNED') {
          const ddx = pt14.x-pt13.x, ddy = pt14.y-pt13.y;
          const len = Math.hypot(ddx, ddy);
          if (len < 1e-9) return;
          const ux = ddx/len, uy = ddy/len;
          const half = actualMeasurement / 2;
          d1x = pt10.x - ux*half; d1y = pt10.y - uy*half;
          d2x = pt10.x + ux*half; d2y = pt10.y + uy*half;
        } else {
          const isV = Math.abs(Math.sin(dimRot)) > 0.5;
          const half = actualMeasurement / 2;
          d1x = pt10.x - (isV ? 0 : half); d1y = pt10.y - (isV ? half : 0);
          d2x = pt10.x + (isV ? 0 : half); d2y = pt10.y + (isV ? half : 0);
        }
        const arrowSz = Math.max(actualMeasurement * 0.04, 1);
        drawLine({x:d1x,y:d1y}, {x:d2x,y:d2y});
        drawLine(pt13, {x:d1x,y:d1y});
        drawLine(pt14, {x:d2x,y:d2y});
        arrow({x:d1x,y:d1y,z:0}, Math.atan2(d1y-d2y, d1x-d2x), arrowSz);
        arrow({x:d2x,y:d2y,z:0}, Math.atan2(d2y-d1y, d2x-d1x), arrowSz);
        drawText(textMidPt ?? {x:(d1x+d2x)/2, y:(d1y+d2y)/2}, userText || fmtLen(actualMeasurement), Math.max(arrowSz*1.5,1), textRot);
        break;
      }
      case 'DIMENSION_RADIUS': {
        if (!pt10 || !pt15) return;
        const arrowSzR = Math.max(actualMeasurement * 0.05, 0.5);
        drawLine(pt10, pt15);
        arrow({x:pt15.x,y:pt15.y,z:0}, Math.atan2(pt15.y-pt10.y, pt15.x-pt10.x), arrowSzR);
        drawText(textMidPt ?? {x:(pt10.x+pt15.x)/2,y:(pt10.y+pt15.y)/2}, userText || `R${fmtLen(actualMeasurement)}`, Math.max(arrowSzR*2,1));
        break;
      }
      case 'DIMENSION_DIAMETER': {
        if (!pt10 || !pt15) return;
        const opp = {x:2*pt10.x-pt15.x, y:2*pt10.y-pt15.y};
        const arrowSzD = Math.max((actualMeasurement/2)*0.05, 0.5);
        drawLine(pt15, opp);
        arrow({x:pt15.x,y:pt15.y,z:0}, Math.atan2(pt15.y-pt10.y, pt15.x-pt10.x), arrowSzD);
        arrow({x:opp.x,y:opp.y,z:0},   Math.atan2(opp.y-pt10.y,  opp.x-pt10.x),  arrowSzD);
        drawText(textMidPt ?? pt10, userText || `Ø${fmtLen(actualMeasurement)}`, Math.max(arrowSzD*2,1));
        break;
      }
      case 'DIMENSION_ANG_3PT':
      case 'DIMENSION_ANG_2LN': {
        if (!pt10 || !pt13 || !pt14) return;
        const vx = pt10.x, vy = pt10.y;
        const rr = Math.hypot(pt13.x-vx, pt13.y-vy);
        if (rr < 1e-9) return;
        let sa = Math.atan2(pt13.y-vy, pt13.x-vx);
        let ea = Math.atan2(pt14.y-vy, pt14.x-vx);
        let sweep = ea - sa;
        while (sweep < 0) sweep += Math.PI*2;
        if (sweep > Math.PI) { [sa, ea] = [ea, sa]; sweep = Math.PI*2 - sweep; }
        drawArc(vx, vy, rr, sa, sa+sweep);
        const arrowSzA = Math.max(rr * 0.05, 0.5);
        arrow({x:vx+Math.cos(sa)*rr,         y:vy+Math.sin(sa)*rr,         z:0}, sa-Math.PI/2,         arrowSzA);
        arrow({x:vx+Math.cos(sa+sweep)*rr,   y:vy+Math.sin(sa+sweep)*rr,   z:0}, (sa+sweep)+Math.PI/2, arrowSzA);
        const midA = sa + sweep/2;
        drawText(textMidPt ?? {x:vx+Math.cos(midA)*rr*1.2, y:vy+Math.sin(midA)*rr*1.2},
                 userText || `${(actualMeasurement*180/Math.PI).toFixed(1)}°`, Math.max(rr*0.1,1));
        break;
      }
      case 'DIMENSION_ORDINATE': {
        if (!pt10 || !pt13) return;
        drawLine(pt10, pt13);
        drawText(textMidPt ?? pt13, userText || (actualMeasurement?.toFixed(2) ?? ''), 2.5);
        break;
      }
    }
  }

  _onClick(e) {
    // ignore clicks that were really a pan/zoom drag (>5px movement)
    if (this._downXY) {
      const dx = e.clientX - this._downXY[0], dy = e.clientY - this._downXY[1];
      if (Math.hypot(dx, dy) > 5) return;
    }
    const rect = this._renderer.domElement.getBoundingClientRect();
    const ndcX = ((e.clientX - rect.left) / rect.width)  * 2 - 1;
    const ndcY = -((e.clientY - rect.top)  / rect.height) * 2 + 1;
    const cam  = this._camera;
    // unproject through the camera so pan (position) and zoom are accounted for
    const v = new THREE.Vector3(ndcX, ndcY, 0).unproject(cam);
    const wx = v.x, wy = v.y;

    if (this._measureActive) { this._doMeasure2D(wx, wy); return; }

    const thresh = CLICK_THRESHOLD_PX * (cam.right - cam.left) / (rect.width * (cam.zoom || 1));

    // Geometric pick — raycast the actual rendered geometry, not a bounds proxy.
    // 1) Nearest real line segment within the pixel threshold (lines, arcs,
    //    circles, polylines, block wires, dimension leaders/arrows).
    let bestIdx = -1, bestDist = thresh;
    const S = this._pickSegs, SM = this._pickSegMeta;
    for (let i = 0, j = 0; i < S.length; i += 4, j++) {
      const d = this._segDist(wx, wy, S[i], S[i + 1], S[i + 2], S[i + 3]);
      if (d < bestDist) { bestDist = d; bestIdx = SM[j]; }
    }
    // 2) No line under the cursor → a filled region (hatch / SOLID / text box).
    //    Pick the smallest-area fill so text on top of a hatch wins.
    if (bestIdx < 0) {
      let bestArea = Infinity;
      for (const f of this._pickFills) {
        if (this._fillHit(f.loops, wx, wy)) {
          const a = this._loopArea(f.loops[0] || []);
          if (a < bestArea) { bestArea = a; bestIdx = f.metaIdx; }
        }
      }
    }
    const bestMeta = bestIdx >= 0 ? this._entityMeta[bestIdx] : null;
    this._highlight(bestMeta);
    this._onSelectCb?.(bestMeta ? bestMeta.entity : null);
  }

  // Distance from point (px,py) to segment (ax,ay)-(bx,by).
  _segDist(px, py, ax, ay, bx, by) {
    const dx = bx - ax, dy = by - ay;
    const len2 = dx * dx + dy * dy;
    if (!len2) return Math.hypot(px - ax, py - ay);
    const t = Math.max(0, Math.min(1, ((px - ax) * dx + (py - ay) * dy) / len2));
    return Math.hypot(px - (ax + t * dx), py - (ay + t * dy));
  }

  startMeasure(cb) {
    this.stopMeasure();
    this._measureCb = cb;
    this._measureActive = true;
  }

  stopMeasure() {
    this._measureActive = false;
    this._measureCb = null;
    this._measurePtA = null;
    for (const m of this._measureMarkers) {
      this._group.remove(m);
      m.geometry?.dispose();
      m.material?.dispose();
    }
    this._measureMarkers = [];
  }

  _doMeasure2D(wx, wy) {
    if (!this._measurePtA) {
      this._measurePtA = { x: wx, y: wy };
      const mk = this._mkMeasureMarker(wx, wy);
      this._measureMarkers.push(mk);
      this._group.add(mk);
      this._measureCb?.({ phase: 'a', ax: wx, ay: wy, az: 0, bx: wx, by: wy, bz: 0, d: 0 });
    } else {
      const a = this._measurePtA;
      const d = Math.hypot(wx - a.x, wy - a.y);
      const mkB = this._mkMeasureMarker(wx, wy);
      const ln  = this._mkMeasureLine(a.x, a.y, wx, wy);
      this._measureMarkers.push(mkB, ln);
      this._group.add(mkB, ln);
      this._measureCb?.({ phase: 'done', ax: a.x, ay: a.y, az: 0, bx: wx, by: wy, bz: 0, d });
      this._measurePtA = null;
    }
  }

  _mkMeasureMarker(x, y) {
    const cam = this._camera;
    const rect = this._renderer.domElement.getBoundingClientRect();
    const s = ((cam.right - cam.left) / (rect.width * (cam.zoom || 1))) * 8;
    const pts = [
      new THREE.Vector3(x - s, y, 0), new THREE.Vector3(x + s, y, 0),
      new THREE.Vector3(x, y - s, 0), new THREE.Vector3(x, y + s, 0),
    ];
    const geo = new THREE.BufferGeometry().setFromPoints(pts);
    geo.setIndex([0, 1, 2, 3]);
    const mat = new THREE.LineBasicMaterial({ color: 0xe63030, depthTest: false });
    const m = new THREE.LineSegments(geo, mat);
    m.renderOrder = 100;
    return m;
  }

  _mkMeasureLine(x1, y1, x2, y2) {
    const geo = new THREE.BufferGeometry().setFromPoints([
      new THREE.Vector3(x1, y1, 0), new THREE.Vector3(x2, y2, 0),
    ]);
    const mat = new THREE.LineBasicMaterial({ color: 0xe63030, depthTest: false });
    const m = new THREE.Line(geo, mat);
    m.renderOrder = 100;
    return m;
  }

  /** Recolor the selected entity's line geometry to the accent color (deselect previous). */
  _highlight(meta) {
    const attr = this._lineColorAttr, orig = this._origColors;
    if (this._selMeta && attr && orig) {
      const a = this._selMeta;
      for (let i = a.colStart; i < a.colEnd && i < orig.length; i++) attr.array[i] = orig[i];
    }
    this._selMeta = meta || null;
    if (meta && attr && meta.colEnd > meta.colStart) {
      const c = this._selColor;
      for (let i = meta.colStart; i < meta.colEnd; i += 3) {
        attr.array[i] = c.r; attr.array[i + 1] = c.g; attr.array[i + 2] = c.b;
      }
    }
    if (attr) attr.needsUpdate = true;
  }

  /** Selection highlight color (keeps in sync with the UI accent). */
  setAccent(hex) {
    this._selColor = {
      r: parseInt(hex.slice(1, 3), 16) / 255,
      g: parseInt(hex.slice(3, 5), 16) / 255,
      b: parseInt(hex.slice(5, 7), 16) / 255,
    };
    if (this._selMeta) { const m = this._selMeta; this._selMeta = null; this._highlight(m); }
  }

  _distToBounds(wx, wy, b) {
    if (b.type === 'point')  return Math.hypot(wx - b.cx, wy - b.cy);
    if (b.type === 'circle') return Math.abs(Math.hypot(wx - b.cx, wy - b.cy) - b.r);
    if (b.type === 'line') {
      const dx = b.x2-b.x1, dy = b.y2-b.y1;
      const len2 = dx*dx + dy*dy;
      if (!len2) return Math.hypot(wx - b.x1, wy - b.y1);
      const t = Math.max(0, Math.min(1, ((wx-b.x1)*dx + (wy-b.y1)*dy) / len2));
      return Math.hypot(wx - (b.x1+t*dx), wy - (b.y1+t*dy));
    }
    return Infinity;
  }

  _fit(box) {
    const c    = box.getCenter(new THREE.Vector3());
    const size = box.getSize(new THREE.Vector3());
    const w    = this._container.clientWidth  || 800;
    const h    = this._container.clientHeight || 600;
    const aspect = w / h;
    let vw = Math.max(size.x, 1) * 1.1;
    let vh = Math.max(size.y, 1) * 1.1;
    if (vw / vh > aspect) vh = vw / aspect; else vw = vh * aspect;
    this._camera.zoom = 1;
    this._camera.left   = -vw/2; this._camera.right  =  vw/2;
    this._camera.top    =  vh/2; this._camera.bottom = -vh/2;
    this._camera.position.set(c.x, c.y, 100);
    // Un-twist the sheet: rotate the view (camera up) by -viewTwist.
    const a = -(this._viewTwist || 0);
    this._camera.up.set(-Math.sin(a), Math.cos(a), 0);
    this._camera.updateProjectionMatrix();
    this._controls.target.set(c.x, c.y, 0);
    this._controls.update();
  }

  _clear() {
    for (let i = this._group.children.length - 1; i >= 0; i--) {
      const o = this._group.children[i];
      o.geometry?.dispose();
      if (o.material) { o.material.map?.dispose(); o.material.dispose(); }
      this._group.remove(o);
    }
    // Shared text textures were disposed via the sprites above (re-dispose is a
    // no-op); drop the cache so the next load rasterizes fresh.
    this._texCache?.clear();
    this._textGen++; // invalidate any in-flight async text flush
  }

  _onResize() {
    const w = this._container.clientWidth, h = this._container.clientHeight;
    if (!w || !h) return;
    this._renderer.setSize(w, h);
    // Frustum planes are CAMERA-LOCAL (relative to camera.position), not world coords.
    // Just preserve half-widths and re-adjust aspect — camera position tracks panning via OrbitControls.
    const halfW = (this._camera.right - this._camera.left) / 2;
    const halfH = halfW / (w / h);
    this._camera.left   = -halfW; this._camera.right  =  halfW;
    this._camera.top    =  halfH; this._camera.bottom = -halfH;
    this._camera.updateProjectionMatrix();
  }

  _animate() {
    requestAnimationFrame(() => this._animate());
    this._controls.update();
    this._renderer.render(this._scene, this._camera);
  }
}