@yumiai/chat-widget 0.1.2 → 0.2.0

package/dist/gerber-3d-entry-DEHDBOO2.js

@@ -0,0 +1,3679 @@
+import {
+  GerberParser
+} from "./chunk-O3NXUM6C.js";
+import {
+  extractRar,
+  fetchFileById,
+  fetchFileByUrl,
+  parseUrlFileUrl,
+  parseUrlId,
+  require_lib
+} from "./chunk-7A4FY6FK.js";
+import {
+  __toESM
+} from "./chunk-7D4SUZUM.js";
+
+// src/components/jetPaveGerberViewer/src/viewer-src/3dPage/js/main.js
+var import_jszip = __toESM(require_lib(), 1);
+import * as THREE2 from "three";
+import { OrbitControls } from "three/addons/controls/OrbitControls.js";
+import earcut from "earcut";
+
+// src/components/jetPaveGerberViewer/src/viewer-src/3dPage/js/gerber-parser-direct.js
+import * as THREE from "three";
+var GerberOutlineParser = class {
+  constructor() {
+    this.shapes = [];
+    this.strokeSegments = [];
+    this.state = {
+      x: 0,
+      y: 0,
+      i: 0,
+      j: 0,
+      d: 0,
+      lastD: null,
+      // 🚀 Modal D-code
+      g: 1,
+      // 1: linear, 2: cw, 3: ccw, 36: region start, 37: region end
+      interpolation: "linear",
+      regionMode: false,
+      quadrant: "multi",
+      unit: "mm",
+      format: {
+        integer: 2,
+        decimal: 4,
+        zero: "L"
+      }
+    };
+    this.currentRegionContours = [];
+    this._currentRegionContour = null;
+    this.segments = [];
+  }
+  parse(content) {
+    this.shapes = [];
+    this.segments = [];
+    this.currentRegionContours = [];
+    this.strokeSegments = [];
+    const lines = content.split(/[\n\r]+/);
+    const MAX_SEGMENTS_DURING_PARSE = 3e5;
+    let abortedDueToSize = false;
+    for (let line of lines) {
+      if (this.segments.length > MAX_SEGMENTS_DURING_PARSE || this.strokeSegments.length > MAX_SEGMENTS_DURING_PARSE) {
+        abortedDueToSize = true;
+        break;
+      }
+      line = line.trim();
+      if (!line) continue;
+      if (line.startsWith("%") && line.endsWith("%")) {
+        this.parseExtendedCommand(line.substring(1, line.length - 1));
+        continue;
+      }
+      const commands = line.split("*");
+      for (let cmd of commands) {
+        cmd = cmd.trim();
+        if (!cmd) continue;
+        this.parseCommand(cmd);
+      }
+    }
+    if (abortedDueToSize) {
+      console.warn(`[GerberOutline] \u89E3\u6790\u4E2D\u6B62\uFF1A\u7EBF\u6BB5\u6570\u91CF\u8FC7\u591A (segments=${this.segments.length}, strokes=${this.strokeSegments.length})\uFF0C\u8DF3\u8FC7\u590D\u6742\u89E3\u6790`);
+      return { shapes: [], strokes: [] };
+    }
+    if (this.currentRegionContours.length > 0) {
+      this.processRegions();
+    }
+    if (this.segments.length > 0) {
+      this.stitchSegmentsToShapes();
+    }
+    if (this.strokeSegments.length >= 1e5) {
+    }
+    return {
+      shapes: this.shapes,
+      strokes: this.strokeSegments
+    };
+  }
+  parseExtendedCommand(cmd) {
+    if (cmd.startsWith("FS")) {
+      const match = cmd.match(/FS([LT])?[AI]X(\d)(\d)Y(\d)(\d)/);
+      if (match) {
+        this.state.format.zero = match[1] || "L";
+        this.state.format.integer = parseInt(match[2]);
+        this.state.format.decimal = parseInt(match[3]);
+      }
+    } else if (cmd.startsWith("MO")) {
+      this.state.unit = cmd.includes("IN") ? "inch" : "mm";
+    }
+  }
+  parseCommand(cmd) {
+    if (cmd.startsWith("G")) {
+      const gCode = parseInt(cmd.substring(1, 3));
+      if (gCode === 1) this.state.interpolation = "linear";
+      if (gCode === 2) this.state.interpolation = "cw";
+      if (gCode === 3) this.state.interpolation = "ccw";
+      if (gCode === 36) {
+        this.state.regionMode = true;
+        this.currentRegionContours = [];
+        this._currentRegionContour = null;
+      }
+      if (gCode === 37) {
+        this.state.regionMode = false;
+        this.finishRegion();
+      }
+      if (cmd.length > 3) this.parseCoordinate(cmd.substring(3));
+      return;
+    }
+    if (cmd.startsWith("D") && parseInt(cmd.substring(1)) >= 10) {
+      return;
+    }
+    this.parseCoordinate(cmd);
+  }
+  parseCoordinate(cmd) {
+    let x = this.state.x;
+    let y = this.state.y;
+    let iOffset = 0;
+    let jOffset = 0;
+    let d = null;
+    const xMatch = cmd.match(/X([-+]?\d+)/);
+    if (xMatch) x = this.parseValue(xMatch[1]);
+    const yMatch = cmd.match(/Y([-+]?\d+)/);
+    if (yMatch) y = this.parseValue(yMatch[1]);
+    const iMatch = cmd.match(/I([-+]?\d+)/);
+    if (iMatch) iOffset = this.parseValue(iMatch[1]);
+    const jMatch = cmd.match(/J([-+]?\d+)/);
+    if (jMatch) jOffset = this.parseValue(jMatch[1]);
+    const dMatch = cmd.match(/D(\d+)/);
+    if (dMatch) {
+      d = parseInt(dMatch[1]);
+      if (d === 1 || d === 2) {
+        this.state.lastD = d;
+      }
+    } else {
+      if ((xMatch || yMatch || iMatch || jMatch) && this.state.lastD) {
+        d = this.state.lastD;
+      }
+    }
+    const prevX = this.state.x;
+    const prevY = this.state.y;
+    this.state.x = x;
+    this.state.y = y;
+    if (d !== null) {
+      if (d === 1) {
+        if (this.state.regionMode) {
+          if (this.state.interpolation === "linear") {
+            if (!this._currentRegionContour) this._startRegionContour(prevX, prevY);
+            this._currentRegionContour.push({ x, y });
+          } else {
+            if (!this._currentRegionContour) this._startRegionContour(prevX, prevY);
+            this.addArcToRegion(prevX, prevY, x, y, iOffset, jOffset, this.state.interpolation === "cw");
+          }
+        } else {
+          this.addSegment(prevX, prevY, x, y, iOffset, jOffset, this.state.interpolation);
+        }
+      } else if (d === 2) {
+        if (this.state.regionMode) {
+          this._startRegionContour(x, y);
+        }
+      }
+    }
+  }
+  parseValue(str) {
+    let scale = Math.pow(10, this.state.format.decimal);
+    let val = parseFloat(str) / scale;
+    if (this.state.unit === "inch") val *= 25.4;
+    return val;
+  }
+  // --- Region Logic ---
+  _startRegionContour(x, y) {
+    const contour = [{ x, y }];
+    this.currentRegionContours.push(contour);
+    this._currentRegionContour = contour;
+  }
+  addArcToRegion(x1, y1, x2, y2, iOffset, jOffset, isCw) {
+    const pts = this.discretizeArc(x1, y1, x2, y2, iOffset, jOffset, isCw);
+    for (let i = 1; i < pts.length; i++) {
+      if (this._currentRegionContour) {
+        this._currentRegionContour.push(pts[i]);
+      }
+    }
+  }
+  finishRegion() {
+    if (this.currentRegionContours.length > 0) {
+      const newShapes = this.contoursToShapes(this.currentRegionContours);
+      this.shapes.push(...newShapes);
+      this.currentRegionContours = [];
+    }
+    this._currentRegionContour = null;
+  }
+  processRegions() {
+    if (this.currentRegionContours.length > 0) {
+      const newShapes = this.contoursToShapes(this.currentRegionContours);
+      this.shapes.push(...newShapes);
+      this.currentRegionContours = [];
+    }
+  }
+  contoursToShapes(rawContours) {
+    const shapes = [];
+    for (const rawPts of rawContours) {
+      const pts = [];
+      let last = null;
+      for (const p of rawPts) {
+        if (!last || Math.hypot(p.x - last.x, p.y - last.y) > 1e-4) {
+          pts.push(p);
+          last = p;
+        }
+      }
+      let forcedClose = false;
+      if (pts.length > 2) {
+        const first = pts[0];
+        const end = pts[pts.length - 1];
+        const gap = Math.hypot(first.x - end.x, first.y - end.y);
+        const WARN_GAP = 10;
+        const MAX_GAP = 1e3;
+        if (gap > WARN_GAP) {
+          forcedClose = true;
+        }
+        if (gap > MAX_GAP) {
+          continue;
+        }
+        if (gap > 1e-3) {
+          pts.push({ x: first.x, y: first.y });
+        }
+      } else {
+        continue;
+      }
+      if (pts.length >= 3) {
+        const shape = new THREE.Shape();
+        shape.moveTo(pts[0].x, pts[0].y);
+        for (let i = 1; i < pts.length; i++) {
+          shape.lineTo(pts[i].x, pts[i].y);
+        }
+        shape.closePath();
+        shape.userData = { forcedClose };
+        shapes.push(shape);
+      } else {
+      }
+    }
+    return shapes;
+  }
+  // --- Non-Region Segment Logic ---
+  addSegment(x1, y1, x2, y2, iOffset, jOffset, mode) {
+    if (mode === "linear") {
+      this.segments.push({
+        start: new THREE.Vector2(x1, y1),
+        end: new THREE.Vector2(x2, y2)
+      });
+    } else {
+      const pts = this.discretizeArc(x1, y1, x2, y2, iOffset, jOffset, mode === "cw");
+      for (let i = 0; i < pts.length - 1; i++) {
+        this.segments.push({
+          start: new THREE.Vector2(pts[i].x, pts[i].y),
+          end: new THREE.Vector2(pts[i + 1].x, pts[i + 1].y)
+        });
+      }
+    }
+  }
+  discretizeArc(x1, y1, x2, y2, iOffset, jOffset, isCw) {
+    const cx = x1 + iOffset;
+    const cy = y1 + jOffset;
+    const radius = Math.sqrt(iOffset * iOffset + jOffset * jOffset);
+    if (radius < 1e-4) return [{ x: x1, y: y1 }, { x: x2, y: y2 }];
+    let startAngle = Math.atan2(y1 - cy, x1 - cx);
+    let endAngle = Math.atan2(y2 - cy, x2 - cx);
+    if (isCw) {
+      if (endAngle >= startAngle) endAngle -= 2 * Math.PI;
+    } else {
+      if (endAngle <= startAngle) endAngle += 2 * Math.PI;
+    }
+    const arcLength = Math.abs(endAngle - startAngle) * radius;
+    const angleSpan = Math.abs(endAngle - startAngle);
+    let segmentSize;
+    let minSegments;
+    const isSmallCorner = radius < 10;
+    if (isSmallCorner) {
+      segmentSize = 3e-3;
+      minSegments = Math.max(32, Math.ceil(angleSpan / (Math.PI / 2) * 32));
+    } else if (arcLength > 100) {
+      segmentSize = 0.02;
+      minSegments = 12;
+    } else if (arcLength > 10) {
+      segmentSize = 0.01;
+      minSegments = 16;
+    } else {
+      segmentSize = 5e-3;
+      minSegments = 20;
+    }
+    const segments = Math.max(minSegments, Math.ceil(arcLength / segmentSize));
+    const pts = [];
+    pts.push({ x: x1, y: y1 });
+    for (let k = 1; k <= segments; k++) {
+      const t = k / segments;
+      const angle = startAngle + (endAngle - startAngle) * t;
+      pts.push({
+        x: cx + radius * Math.cos(angle),
+        y: cy + radius * Math.sin(angle)
+      });
+    }
+    pts[pts.length - 1] = { x: x2, y: y2 };
+    return pts;
+  }
+  stitchSegmentsToShapes() {
+    const uniqueSegments = [];
+    const seen = /* @__PURE__ */ new Set();
+    const keyFn = (p) => `${Math.round(p.x * 1e5)},${Math.round(p.y * 1e5)}`;
+    for (const seg of this.segments) {
+      const k1 = keyFn(seg.start) + "|" + keyFn(seg.end);
+      const k2 = keyFn(seg.end) + "|" + keyFn(seg.start);
+      if (!seen.has(k1) && !seen.has(k2)) {
+        seen.add(k1);
+        uniqueSegments.push(seg);
+      }
+    }
+    if (uniqueSegments.length === 0) return;
+    let minX = Infinity, maxX = -Infinity, minY = Infinity, maxY = -Infinity;
+    for (const seg of uniqueSegments) {
+      minX = Math.min(minX, seg.start.x, seg.end.x);
+      maxX = Math.max(maxX, seg.start.x, seg.end.x);
+      minY = Math.min(minY, seg.start.y, seg.end.y);
+      maxY = Math.max(maxY, seg.start.y, seg.end.y);
+    }
+    const boardSize = Math.max(maxX - minX, maxY - minY);
+    let TOLERANCE;
+    if (boardSize > 100) {
+      TOLERANCE = 0.5;
+    } else if (boardSize > 50) {
+      TOLERANCE = 0.25;
+    } else {
+      TOLERANCE = 0.1;
+    }
+    const cellSize = TOLERANCE;
+    const grid = /* @__PURE__ */ new Map();
+    const getCell = (pt) => `${Math.floor(pt.x / cellSize)},${Math.floor(pt.y / cellSize)}`;
+    this.strokeSegments = uniqueSegments.map((s) => ({
+      start: s.start.clone(),
+      end: s.end.clone()
+    }));
+    const poolItems = uniqueSegments.map((s) => ({ seg: s, used: false }));
+    const addToGrid = (item) => {
+      const k1 = getCell(item.seg.start);
+      const k2 = getCell(item.seg.end);
+      if (!grid.has(k1)) grid.set(k1, []);
+      grid.get(k1).push(item);
+      if (k1 !== k2) {
+        if (!grid.has(k2)) grid.set(k2, []);
+        grid.get(k2).push(item);
+      }
+    };
+    poolItems.forEach(addToGrid);
+    const getCandidates = (pt) => {
+      const cx = Math.floor(pt.x / cellSize);
+      const cy = Math.floor(pt.y / cellSize);
+      const results = /* @__PURE__ */ new Set();
+      for (let dx = -1; dx <= 1; dx++) {
+        for (let dy = -1; dy <= 1; dy++) {
+          const k = `${cx + dx},${cy + dy}`;
+          const list = grid.get(k);
+          if (list) {
+            for (const item of list) results.add(item);
+          }
+        }
+      }
+      return results;
+    };
+    const chains = [];
+    for (const startItem of poolItems) {
+      if (startItem.used) continue;
+      startItem.used = true;
+      const chain = [startItem.seg.start, startItem.seg.end];
+      let tail = startItem.seg.end;
+      let head = startItem.seg.start;
+      let finding = true;
+      while (finding) {
+        finding = false;
+        const candidates = getCandidates(tail);
+        let bestNext = null;
+        let minDst = Infinity;
+        let isReverse = false;
+        for (const item of candidates) {
+          if (item.used) continue;
+          const d1 = item.seg.start.distanceTo(tail);
+          if (d1 < TOLERANCE && d1 < minDst) {
+            minDst = d1;
+            bestNext = item;
+            isReverse = false;
+          }
+          const d2 = item.seg.end.distanceTo(tail);
+          if (d2 < TOLERANCE && d2 < minDst) {
+            minDst = d2;
+            bestNext = item;
+            isReverse = true;
+          }
+        }
+        if (bestNext) {
+          bestNext.used = true;
+          if (isReverse) {
+            chain.push(bestNext.seg.start);
+            tail = bestNext.seg.start;
+          } else {
+            chain.push(bestNext.seg.end);
+            tail = bestNext.seg.end;
+          }
+          finding = true;
+        }
+      }
+      finding = true;
+      while (finding) {
+        finding = false;
+        const candidates = getCandidates(head);
+        let bestPrev = null;
+        let minDst = Infinity;
+        let isReverse = false;
+        for (const item of candidates) {
+          if (item.used) continue;
+          const d1 = item.seg.end.distanceTo(head);
+          if (d1 < TOLERANCE && d1 < minDst) {
+            minDst = d1;
+            bestPrev = item;
+            isReverse = false;
+          }
+          const d2 = item.seg.start.distanceTo(head);
+          if (d2 < TOLERANCE && d2 < minDst) {
+            minDst = d2;
+            bestPrev = item;
+            isReverse = true;
+          }
+        }
+        if (bestPrev) {
+          bestPrev.used = true;
+          if (isReverse) {
+            chain.unshift(bestPrev.seg.end);
+            head = bestPrev.seg.end;
+          } else {
+            chain.unshift(bestPrev.seg.start);
+            head = bestPrev.seg.start;
+          }
+          finding = true;
+        }
+      }
+      chains.push(chain);
+    }
+    const contours = [];
+    for (const chain of chains) {
+      if (chain.length < 3) {
+        continue;
+      }
+      const pts = chain.map((p) => ({ x: p.x, y: p.y }));
+      contours.push(pts);
+    }
+    const newShapes = this.contoursToShapes(contours);
+    this.shapes.push(...newShapes);
+    if (uniqueSegments.length > 0) {
+      const fallbackShapes = this.buildLoopsFromSegments(uniqueSegments, TOLERANCE);
+      if (fallbackShapes.length > 0) {
+        this.shapes.push(...fallbackShapes);
+      }
+    }
+  }
+  /**
+   * 从无向线段集合中提取简单闭合环，适用于拼板网格等分叉场景。
+   * 算法：构建邻接表，遍历未使用的边，沿邻接边走到回到起点即认为闭合。
+   */
+  buildLoopsFromSegments(segments, tol = 0.2) {
+    const keyFn = (p) => `${Math.round(p.x / tol)},${Math.round(p.y / tol)}`;
+    const nodes = /* @__PURE__ */ new Map();
+    const addNode = (p) => {
+      const k = keyFn(p);
+      if (!nodes.has(k)) {
+        nodes.set(k, { pt: p.clone(), neighbors: /* @__PURE__ */ new Set() });
+      }
+      return k;
+    };
+    const edges = /* @__PURE__ */ new Map();
+    const edgeKey = (aKey, bKey) => aKey < bKey ? `${aKey}|${bKey}` : `${bKey}|${aKey}`;
+    for (const seg of segments) {
+      const aKey = addNode(seg.start);
+      const bKey = addNode(seg.end);
+      const ek = edgeKey(aKey, bKey);
+      if (edges.has(ek)) continue;
+      edges.set(ek, { aKey, bKey, used: false });
+      nodes.get(aKey).neighbors.add(bKey);
+      nodes.get(bKey).neighbors.add(aKey);
+    }
+    const loops = [];
+    for (const [ek, edge] of edges) {
+      if (edge.used) continue;
+      const pathKeys = [];
+      let prevKey = edge.aKey;
+      let currKey = edge.bKey;
+      edge.used = true;
+      pathKeys.push(prevKey, currKey);
+      let closed = false;
+      const MAX_STEPS = segments.length * 4;
+      let steps = 0;
+      while (steps < MAX_STEPS) {
+        steps++;
+        const currNode = nodes.get(currKey);
+        if (!currNode) break;
+        let nextKey = null;
+        for (const nbKey of currNode.neighbors) {
+          if (nbKey === prevKey) continue;
+          const nk = edgeKey(currKey, nbKey);
+          const e = edges.get(nk);
+          if (e && !e.used) {
+            nextKey = nbKey;
+            e.used = true;
+            break;
+          }
+        }
+        if (nextKey === null) {
+          const startNode = nodes.get(pathKeys[0]);
+          const currNodePt = nodes.get(currKey)?.pt;
+          if (startNode && currNodePt) {
+            const gap = startNode.pt.distanceTo(currNodePt);
+            if (gap <= tol && pathKeys.length > 2) {
+              closed = true;
+            }
+          }
+          break;
+        }
+        pathKeys.push(nextKey);
+        prevKey = currKey;
+        currKey = nextKey;
+        if (currKey === pathKeys[0] && pathKeys.length > 3) {
+          closed = true;
+          break;
+        }
+      }
+      if (closed) {
+        const pts = [];
+        pathKeys.forEach((k) => {
+          const n = nodes.get(k);
+          if (n) pts.push({ x: n.pt.x, y: n.pt.y });
+        });
+        if (pts.length > 1 && Math.hypot(pts[0].x - pts[pts.length - 1].x, pts[0].y - pts[pts.length - 1].y) < 1e-6) {
+          pts.pop();
+        }
+        if (pts.length >= 3) {
+          const shape = new THREE.Shape();
+          shape.moveTo(pts[0].x, pts[0].y);
+          for (let i = 1; i < pts.length; i++) {
+            shape.lineTo(pts[i].x, pts[i].y);
+          }
+          shape.closePath();
+          loops.push(shape);
+        }
+      }
+    }
+    return loops;
+  }
+  // 根据线框生成外接矩形兜底面（修复堆栈溢出：使用循环而不是展开运算符）
+  buildBBoxShapeFromStrokes(segments) {
+    if (!segments || segments.length === 0) return null;
+    let minX = Infinity, maxX = -Infinity;
+    let minY = Infinity, maxY = -Infinity;
+    for (let i = 0; i < segments.length; i++) {
+      const seg = segments[i];
+      if (seg.start.x < minX) minX = seg.start.x;
+      if (seg.start.x > maxX) maxX = seg.start.x;
+      if (seg.start.y < minY) minY = seg.start.y;
+      if (seg.start.y > maxY) maxY = seg.start.y;
+      if (seg.end.x < minX) minX = seg.end.x;
+      if (seg.end.x > maxX) maxX = seg.end.x;
+      if (seg.end.y < minY) minY = seg.end.y;
+      if (seg.end.y > maxY) maxY = seg.end.y;
+    }
+    if (!isFinite(minX) || !isFinite(maxX) || !isFinite(minY) || !isFinite(maxY)) return null;
+    const shape = new THREE.Shape();
+    shape.moveTo(minX, minY);
+    shape.lineTo(maxX, minY);
+    shape.lineTo(maxX, maxY);
+    shape.lineTo(minX, maxY);
+    shape.closePath();
+    return shape;
+  }
+};
+
+// src/components/jetPaveGerberViewer/src/viewer-src/3dPage/js/main.js
+import { parse, plot, renderSVG } from "web-gerber";
+var DEBUG_MODE = true;
+var debugLog = DEBUG_MODE ? console.log.bind(console) : () => {
+};
+var debugWarn = DEBUG_MODE ? console.warn.bind(console) : () => {
+};
+function stitchSegmentsToShapes(segments) {
+  if (!segments || segments.length === 0) return [];
+  const startTime = performance.now();
+  const PRECISION = 1e4;
+  const seen = /* @__PURE__ */ new Set();
+  const uniqueSegments = [];
+  for (let i = 0; i < segments.length; i++) {
+    const seg = segments[i];
+    const sx = Math.round(seg.start.x * PRECISION);
+    const sy = Math.round(seg.start.y * PRECISION);
+    const ex = Math.round(seg.end.x * PRECISION);
+    const ey = Math.round(seg.end.y * PRECISION);
+    let key;
+    if (sx < ex || sx === ex && sy < ey) {
+      key = `${sx},${sy}|${ex},${ey}`;
+    } else {
+      key = `${ex},${ey}|${sx},${sy}`;
+    }
+    if (!seen.has(key)) {
+      seen.add(key);
+      uniqueSegments.push(seg);
+    }
+  }
+  console.log(`[stitchSegmentsToShapes] \u7EBF\u6BB5\u53BB\u91CD: ${segments.length} -> ${uniqueSegments.length}`);
+  if (uniqueSegments.length === 0) return [];
+  const MAX_SEGMENTS = 15e4;
+  if (uniqueSegments.length > MAX_SEGMENTS) {
+    console.warn(`[stitchSegmentsToShapes] \u26A0\uFE0F \u7EBF\u6BB5\u8FC7\u591A (${uniqueSegments.length} > ${MAX_SEGMENTS})\uFF0C\u8DF3\u8FC7\u62FC\u63A5`);
+    return [];
+  }
+  let minX = Infinity, maxX = -Infinity, minY = Infinity, maxY = -Infinity;
+  const n = uniqueSegments.length;
+  for (let i = 0; i < n; i++) {
+    const seg = uniqueSegments[i];
+    const s = seg.start, e = seg.end;
+    if (s.x < minX) minX = s.x;
+    if (s.x > maxX) maxX = s.x;
+    if (e.x < minX) minX = e.x;
+    if (e.x > maxX) maxX = e.x;
+    if (s.y < minY) minY = s.y;
+    if (s.y > maxY) maxY = s.y;
+    if (e.y < minY) minY = e.y;
+    if (e.y > maxY) maxY = e.y;
+  }
+  const boardSize = Math.max(maxX - minX, maxY - minY);
+  const TOLERANCE = boardSize > 100 ? 0.5 : boardSize > 50 ? 0.25 : 0.1;
+  const TOLERANCE_SQ = TOLERANCE * TOLERANCE;
+  const cellSize = TOLERANCE;
+  const invCellSize = 1 / cellSize;
+  const grid = /* @__PURE__ */ new Map();
+  const poolItems = new Array(n);
+  for (let i = 0; i < n; i++) {
+    const seg = uniqueSegments[i];
+    const item = { seg, used: false, idx: i };
+    poolItems[i] = item;
+    const cx1 = Math.floor(seg.start.x * invCellSize);
+    const cy1 = Math.floor(seg.start.y * invCellSize);
+    const k1 = cx1 << 16 ^ cy1;
+    if (!grid.has(k1)) grid.set(k1, []);
+    grid.get(k1).push(item);
+    const cx2 = Math.floor(seg.end.x * invCellSize);
+    const cy2 = Math.floor(seg.end.y * invCellSize);
+    const k2 = cx2 << 16 ^ cy2;
+    if (k1 !== k2) {
+      if (!grid.has(k2)) grid.set(k2, []);
+      grid.get(k2).push(item);
+    }
+  }
+  const distSq = (p1, p2) => {
+    const dx = p1.x - p2.x;
+    const dy = p1.y - p2.y;
+    return dx * dx + dy * dy;
+  };
+  const getCandidates = (x, y) => {
+    const cx = Math.floor(x * invCellSize);
+    const cy = Math.floor(y * invCellSize);
+    const results = [];
+    for (let dy = -1; dy <= 1; dy++) {
+      const ccy = cy + dy;
+      for (let dx = -1; dx <= 1; dx++) {
+        const k = cx + dx << 16 ^ ccy;
+        const list = grid.get(k);
+        if (list) {
+          for (let i = 0, len = list.length; i < len; i++) {
+            const item = list[i];
+            if (!item.used) results.push(item);
+          }
+        }
+      }
+    }
+    return results;
+  };
+  const chains = [];
+  for (let startIdx = 0; startIdx < n; startIdx++) {
+    const startItem = poolItems[startIdx];
+    if (startItem.used) continue;
+    startItem.used = true;
+    const front = [];
+    const back = [startItem.seg.start, startItem.seg.end];
+    let tail = startItem.seg.end;
+    let head = startItem.seg.start;
+    let finding = true;
+    let tx = tail.x, ty = tail.y;
+    while (finding) {
+      finding = false;
+      const candidates = getCandidates(tx, ty);
+      let bestNext = null;
+      let minDstSq = TOLERANCE_SQ;
+      let isReverse = false;
+      for (let i = 0, len = candidates.length; i < len; i++) {
+        const item = candidates[i];
+        const seg = item.seg;
+        let dx = seg.start.x - tx;
+        let dy = seg.start.y - ty;
+        let d1 = dx * dx + dy * dy;
+        if (d1 < minDstSq) {
+          minDstSq = d1;
+          bestNext = item;
+          isReverse = false;
+        }
+        dx = seg.end.x - tx;
+        dy = seg.end.y - ty;
+        let d2 = dx * dx + dy * dy;
+        if (d2 < minDstSq) {
+          minDstSq = d2;
+          bestNext = item;
+          isReverse = true;
+        }
+      }
+      if (bestNext) {
+        bestNext.used = true;
+        if (isReverse) {
+          tail = bestNext.seg.start;
+          tx = tail.x;
+          ty = tail.y;
+          back.push(tail);
+        } else {
+          tail = bestNext.seg.end;
+          tx = tail.x;
+          ty = tail.y;
+          back.push(tail);
+        }
+        finding = true;
+      }
+    }
+    finding = true;
+    let hx = head.x, hy = head.y;
+    while (finding) {
+      finding = false;
+      const candidates = getCandidates(hx, hy);
+      let bestPrev = null;
+      let minDstSq = TOLERANCE_SQ;
+      let isReverse = false;
+      for (let i = 0, len = candidates.length; i < len; i++) {
+        const item = candidates[i];
+        const seg = item.seg;
+        let dx = seg.end.x - hx;
+        let dy = seg.end.y - hy;
+        let d1 = dx * dx + dy * dy;
+        if (d1 < minDstSq) {
+          minDstSq = d1;
+          bestPrev = item;
+          isReverse = false;
+        }
+        dx = seg.start.x - hx;
+        dy = seg.start.y - hy;
+        let d2 = dx * dx + dy * dy;
+        if (d2 < minDstSq) {
+          minDstSq = d2;
+          bestPrev = item;
+          isReverse = true;
+        }
+      }
+      if (bestPrev) {
+        bestPrev.used = true;
+        if (isReverse) {
+          head = bestPrev.seg.end;
+          hx = head.x;
+          hy = head.y;
+          front.push(head);
+        } else {
+          head = bestPrev.seg.start;
+          hx = head.x;
+          hy = head.y;
+          front.push(head);
+        }
+        finding = true;
+      }
+    }
+    const chain = front.length > 0 ? front.reverse().concat(back) : back;
+    chains.push(chain);
+  }
+  const shapes = [];
+  for (let c = 0; c < chains.length; c++) {
+    const chain = chains[c];
+    if (chain.length < 3) continue;
+    const first = chain[0];
+    const last = chain[chain.length - 1];
+    const gapSq = distSq(first, last);
+    const gap = Math.sqrt(gapSq);
+    let forcedClose = false;
+    if (gap > 10) forcedClose = true;
+    if (gap > 1e3) continue;
+    const shape = new THREE2.Shape();
+    shape.moveTo(chain[0].x, chain[0].y);
+    for (let i = 1; i < chain.length; i++) {
+      shape.lineTo(chain[i].x, chain[i].y);
+    }
+    if (gap > 1e-3) {
+      shape.lineTo(first.x, first.y);
+    }
+    shape.closePath();
+    shape.userData = { forcedClose };
+    shapes.push(shape);
+  }
+  const elapsed = performance.now() - startTime;
+  console.log(`[stitchSegmentsToShapes] \u62FC\u63A5\u5B8C\u6210: ${shapes.length} \u4E2A\u5F62\u72B6\uFF0C\u8017\u65F6 ${elapsed.toFixed(1)}ms`);
+  return shapes;
+}
+var COLORS = {
+  OUTLINE: 1857803,
+  // 基材 (用户指定: #1C590B)
+  OUTLINE_EDGE: 0,
+  // 边框线（黑色）
+  COPPER: 4223518,
+  // 线路 (用户指定: #40721E)
+  GOLD: 13938487,
+  // 焊盘 (金色 Gold)
+  DRILL: 0,
+  // 钻孔 (黑色 Black)
+  SILKSCREEN: 15658734,
+  // 丝印 (白色 White)
+  SOLDER_MASK: 1857803,
+  // 阻焊 (同基材)
+  PASTE: 10066329
+  // 锡膏 (灰色 Gray)
+};
+var IGNORED_GERBER_BASENAMES_UPPER = new Set([
+  "PZT_Core-v1.0.GM15",
+  "PZT_Core-v1.0.GM2",
+  "PZT_Core-v1.0.GM3",
+  "PZT_Core-v1.0.GM4",
+  "PZT_Core-v1.0.GM5",
+  "PZT_Core-v1.0.GM6",
+  "PZT_Core-v1.0.GM8",
+  "PZT_Core-v1.0.GM13"
+].map((s) => s.toUpperCase()));
+var BOARD_THICKNESS = 1.6;
+var Viewer3D = class {
+  constructor() {
+    this.scene = null;
+    this.camera = null;
+    this.renderer = null;
+    this.controls = null;
+    this.baseGroup = new THREE2.Group();
+    this.materialCache = /* @__PURE__ */ new Map();
+    this.initThree();
+    this.initEvents();
+    this.checkUrlParams();
+  }
+  initThree() {
+    this.scene = new THREE2.Scene();
+    this.scene.background = new THREE2.Color(0);
+    const getViewportSize = () => {
+      const host = document.getElementById("viewer3d-canvas-host");
+      if (host && host.clientWidth > 0 && host.clientHeight > 0) {
+        return { w: host.clientWidth, h: host.clientHeight };
+      }
+      return { w: window.innerWidth, h: window.innerHeight };
+    };
+    const { w: vw, h: vh } = getViewportSize();
+    const safeW = Math.max(vw, 1);
+    const safeH = Math.max(vh, 1);
+    this.camera = new THREE2.PerspectiveCamera(45, safeW / safeH, 0.1, 2e3);
+    this.camera.position.set(0, 0, 30);
+    this.renderer = new THREE2.WebGLRenderer({ antialias: true, logarithmicDepthBuffer: true });
+    const pr = Math.min(window.devicePixelRatio || 1, 2);
+    this.renderer.setPixelRatio(pr);
+    this.renderer.setSize(safeW, safeH);
+    const canvasHost = document.getElementById("viewer3d-canvas-host");
+    (canvasHost || document.body).appendChild(this.renderer.domElement);
+    this.controls = new OrbitControls(this.camera, this.renderer.domElement);
+    this.controls.enableDamping = true;
+    const ambientLight = new THREE2.AmbientLight(16777215, 1.8);
+    this.scene.add(ambientLight);
+    const dirLight = new THREE2.DirectionalLight(16777215, 1.2);
+    dirLight.position.set(50, 50, 100);
+    this.scene.add(dirLight);
+    const fillLight = new THREE2.DirectionalLight(16777215, 1);
+    fillLight.position.set(-50, -50, 100);
+    this.scene.add(fillLight);
+    const backLight = new THREE2.DirectionalLight(16777215, 0.8);
+    backLight.position.set(0, 0, -100);
+    this.scene.add(backLight);
+    this.scene.add(this.baseGroup);
+    const applyResize = () => {
+      const { w, h } = getViewportSize();
+      const W = Math.max(w, 1);
+      const H = Math.max(h, 1);
+      this.camera.aspect = W / H;
+      this.camera.updateProjectionMatrix();
+      this.renderer.setSize(W, H);
+    };
+    window.addEventListener("resize", applyResize);
+    if (canvasHost && typeof ResizeObserver !== "undefined") {
+      this._canvasHostResizeObserver = new ResizeObserver(() => applyResize());
+      this._canvasHostResizeObserver.observe(canvasHost);
+    }
+    requestAnimationFrame(() => applyResize());
+    this.animate();
+  }
+  animate() {
+    requestAnimationFrame(() => this.animate());
+    this.controls.update();
+    this.renderer.render(this.scene, this.camera);
+  }
+  initEvents() {
+    const fileInput = document.getElementById("file-input");
+    fileInput.addEventListener("change", (e) => this.handleFileSelect(e));
+    const baseUrl = import.meta.env.BASE_URL || "/";
+    const buildPageUrl = (path) => `${baseUrl}${path.replace(/^\/+/, "")}`;
+    const closeBtn = document.getElementById("close-btn");
+    if (closeBtn) {
+      closeBtn.addEventListener("click", () => {
+        const id = parseUrlId();
+        if (id) {
+          window.location.href = `${buildPageUrl("/2dPage")}?id=${encodeURIComponent(id)}`;
+          return;
+        }
+        const url = parseUrlFileUrl();
+        if (url) {
+          window.location.href = `${buildPageUrl("/2dPage")}?url=${encodeURIComponent(url)}`;
+          return;
+        }
+        window.location.href = buildPageUrl("/2dPage");
+      });
+    }
+  }
+  async checkUrlParams() {
+    console.log("[\u6027\u80FD] checkUrlParams \u5F00\u59CB");
+    const startTime = performance.now();
+    const id = parseUrlId();
+    const url = parseUrlFileUrl();
+    if (id) {
+      const loadingEl = document.getElementById("loading");
+      if (loadingEl) {
+        loadingEl.textContent = "\u6B63\u5728\u5904\u7406\u4E2D...";
+        loadingEl.style.display = "flex";
+      }
+      try {
+        console.log("[3D-new] \u4F7F\u7528 fetchFileById \u83B7\u53D6\u6587\u4EF6...");
+        await fetchFileById(
+          id,
+          async (files) => {
+            console.log("[3D-new] \u6536\u5230\u6587\u4EF6\uFF0C\u5F00\u59CB\u5904\u7406...");
+            await this.processFiles(files);
+            if (loadingEl) {
+              loadingEl.style.display = "none";
+            }
+            const endTime = performance.now();
+            const totalTime = (endTime - startTime) / 1e3;
+            console.log(`[\u6027\u80FD] ========== checkUrlParams \u5B8C\u6210\uFF0C\u603B\u8017\u65F6: ${totalTime.toFixed(2)}\u79D2 ==========`);
+          },
+          (message, type) => {
+            console.log(`[3D-new] \u72B6\u6001: ${message}`);
+          }
+        );
+      } catch (error) {
+        const endTime = performance.now();
+        const totalTime = (endTime - startTime) / 1e3;
+        console.error(`[\u9519\u8BEF] checkUrlParams \u5931\u8D25 (\u8017\u65F6: ${totalTime.toFixed(2)}\u79D2):`, error);
+        if (loadingEl) {
+          loadingEl.style.display = "none";
+        }
+        alert("\u83B7\u53D6\u6587\u4EF6\u5931\u8D25: " + error.message);
+      }
+    } else if (url) {
+      const loadingEl = document.getElementById("loading");
+      if (loadingEl) {
+        loadingEl.textContent = "\u6B63\u5728\u5904\u7406\u4E2D...";
+        loadingEl.style.display = "flex";
+      }
+      try {
+        console.log("[3D-new] \u4F7F\u7528 fetchFileByUrl \u83B7\u53D6\u6587\u4EF6...");
+        await fetchFileByUrl(
+          url,
+          async (files) => {
+            console.log("[3D-new] \u6536\u5230\u6587\u4EF6\uFF0C\u5F00\u59CB\u5904\u7406...");
+            await this.processFiles(files);
+            if (loadingEl) {
+              loadingEl.style.display = "none";
+            }
+            const endTime = performance.now();
+            const totalTime = (endTime - startTime) / 1e3;
+            console.log(`[\u6027\u80FD] ========== checkUrlParams \u5B8C\u6210\uFF0C\u603B\u8017\u65F6: ${totalTime.toFixed(2)}\u79D2 ==========`);
+          },
+          (message, type) => {
+            console.log(`[3D-new] \u72B6\u6001: ${message}`);
+          }
+        );
+      } catch (error) {
+        const endTime = performance.now();
+        const totalTime = (endTime - startTime) / 1e3;
+        console.error(`[\u9519\u8BEF] checkUrlParams \u5931\u8D25 (\u8017\u65F6: ${totalTime.toFixed(2)}\u79D2):`, error);
+        if (loadingEl) {
+          loadingEl.style.display = "none";
+        }
+        alert("\u83B7\u53D6\u6587\u4EF6\u5931\u8D25: " + error.message);
+      }
+    } else {
+      console.log("[3D-new] URL \u4E2D\u6CA1\u6709 ID \u53C2\u6570");
+    }
+  }
+  async handleFileSelect(event) {
+    console.log("[\u6027\u80FD] handleFileSelect \u5F00\u59CB");
+    const startTime = performance.now();
+    const files = event.target.files;
+    if (!files || files.length === 0) return;
+    document.getElementById("loading").style.display = "flex";
+    try {
+      await this.processFiles(files);
+      const endTime = performance.now();
+      const totalTime = (endTime - startTime) / 1e3;
+      console.log(`[\u6027\u80FD] ========== \u6587\u4EF6\u5904\u7406\u5B8C\u6210\uFF0C\u603B\u8017\u65F6: ${totalTime.toFixed(2)}\u79D2 ==========`);
+    } catch (e) {
+      const endTime = performance.now();
+      const totalTime = (endTime - startTime) / 1e3;
+      console.error(`[\u9519\u8BEF] \u6587\u4EF6\u5904\u7406\u5931\u8D25 (\u8017\u65F6: ${totalTime.toFixed(2)}\u79D2):`, e);
+      alert("\u5904\u7406\u6587\u4EF6\u65F6\u51FA\u9519: " + e.message);
+    } finally {
+      document.getElementById("loading").style.display = "none";
+      event.target.value = "";
+    }
+  }
+  async processFiles(fileList) {
+    console.log(`[\u6027\u80FD] processFiles \u5F00\u59CB\uFF0C\u6587\u4EF6\u6570: ${fileList.length}`);
+    const startTimeTotal = performance.now();
+    this.clearScene();
+    this.outlineBbox = null;
+    if (this.renderer && this.renderer.domElement) {
+      this.renderer.domElement.style.visibility = "hidden";
+    }
+    console.log("[\u6027\u80FD] \u5F00\u59CB\u89E3\u538B\u6587\u4EF6...");
+    const startTimeExtract = performance.now();
+    const gerberFiles = [];
+    for (const file of fileList) {
+      const ext = file.name.split(".").pop().toLowerCase();
+      if (ext === "zip") {
+        console.log(`[\u6027\u80FD] \u89E3\u538B ZIP: ${file.name}`);
+        const startTimeZip = performance.now();
+        const zip = await import_jszip.default.loadAsync(file);
+        for (const filename in zip.files) {
+          if (zip.files[filename].dir) continue;
+          const content = await zip.files[filename].async("blob");
+          gerberFiles.push(new File([content], filename));
+        }
+        const endTimeZip = performance.now();
+        console.log(`[\u6027\u80FD] ZIP \u89E3\u538B\u5B8C\u6210\uFF0C\u8017\u65F6: ${(endTimeZip - startTimeZip).toFixed(2)}ms`);
+      } else if (ext === "rar") {
+        console.log(`[\u6027\u80FD] \u89E3\u538B RAR: ${file.name}`);
+        const startTimeRar = performance.now();
+        const extracted = await extractRar(file);
+        const endTimeRar = performance.now();
+        console.log(`[\u6027\u80FD] RAR \u89E3\u538B\u5B8C\u6210\uFF0C\u8017\u65F6: ${(endTimeRar - startTimeRar).toFixed(2)}ms`);
+        gerberFiles.push(...extracted);
+      } else {
+        gerberFiles.push(file);
+      }
+    }
+    const endTimeExtract = performance.now();
+    console.log(`[\u6027\u80FD] \u6587\u4EF6\u89E3\u538B\u603B\u8017\u65F6: ${(endTimeExtract - startTimeExtract).toFixed(2)}ms, \u89E3\u538B\u540E\u6587\u4EF6\u6570: ${gerberFiles.length}`);
+    if (IGNORED_GERBER_BASENAMES_UPPER.size > 0 && gerberFiles.length > 0) {
+      const kept = [];
+      const ignored = [];
+      for (const f of gerberFiles) {
+        const base = (f.name.split(/[/\\]/).pop() || "").toUpperCase();
+        if (IGNORED_GERBER_BASENAMES_UPPER.has(base)) {
+          ignored.push(f.name);
+        } else {
+          kept.push(f);
+        }
+      }
+      if (ignored.length > 0) {
+        debugWarn(`[3D-new] \u5DF2\u5FFD\u7565 ${ignored.length} \u4E2A\u6587\u4EF6\uFF08\u4E0D\u53C2\u4E0E\u6E32\u67D3/\u4E0D\u5F71\u54CD\u57FA\u6750\u5C3A\u5BF8\uFF09:`, ignored);
+      }
+      gerberFiles.length = 0;
+      gerberFiles.push(...kept);
+    }
+    console.log(`[3D-new] \u5F00\u59CB\u89E3\u6790\u6587\u4EF6\uFF0C\u5171 ${gerberFiles.length} \u4E2A\u6587\u4EF6:`, gerberFiles.map((f) => f.name));
+    console.log("[\u6027\u80FD] \u5F00\u59CB\u6587\u4EF6\u5206\u7C7B...");
+    const startTimeClassify = performance.now();
+    const buildPhoGroups = (files) => {
+      const groups = /* @__PURE__ */ new Map();
+      const add = (prefix, num) => {
+        if (!groups.has(prefix)) {
+          groups.set(prefix, { min: num });
+        } else {
+          groups.get(prefix).min = Math.min(groups.get(prefix).min, num);
+        }
+      };
+      files.forEach((f) => {
+        const nameOnly = f.name.split(/[/\\]/).pop() || "";
+        const ext = "." + nameOnly.split(".").pop().toLowerCase();
+        if (ext !== ".pho") return;
+        const upper = nameOnly.toUpperCase();
+        let prefix = null;
+        let num = 0;
+        if (upper.startsWith("SST")) {
+          prefix = "sst";
+          const m = upper.match(/^SST(\d+)/);
+          num = m ? parseInt(m[1], 10) : 0;
+        } else if (upper.startsWith("SMD")) {
+          prefix = "smd";
+          const m = upper.match(/^SMD(\d+)/);
+          num = m ? parseInt(m[1], 10) : 0;
+        } else if (upper.startsWith("SM")) {
+          prefix = "sm";
+          const m = upper.match(/^SM(\d+)/);
+          num = m ? parseInt(m[1], 10) : 0;
+        } else if (upper.startsWith("ART")) {
+          prefix = "art";
+          const m = upper.match(/^ART(\d+)/);
+          num = m ? parseInt(m[1], 10) : 0;
+        }
+        if (prefix) add(prefix, num);
+      });
+      return groups;
+    };
+    const phoGroups = buildPhoGroups(gerberFiles);
+    const getLayerType = (fileName) => {
+      const fileNameOnly = fileName.split(/[/\\]/).pop();
+      const fileExtension = "." + fileNameOnly.split(".").pop().toUpperCase();
+      const fileNameUpper = fileNameOnly.toUpperCase();
+      const nameLower = fileNameOnly.toLowerCase();
+      if (fileExtension === ".GBR") {
+        const nameWithoutExt = fileNameOnly.substring(0, fileNameOnly.lastIndexOf(".")).toUpperCase();
+        if (nameWithoutExt === "GKO" || nameWithoutExt === "GTL" || nameWithoutExt === "GTO" || nameWithoutExt === "GTS" || nameWithoutExt === "GBL" || nameWithoutExt === "GBS" || nameWithoutExt === "GBP" || nameWithoutExt === "GBO" || nameWithoutExt === "GTP") {
+          return nameWithoutExt;
+        }
+        if (nameLower.includes("outline") || nameLower.includes("boardoutline")) {
+          return "GKO";
+        }
+        if (nameLower.includes("topmask") || nameLower.includes("topsolder") || nameLower.includes("soldertop") || nameLower.includes("maskstop")) {
+          return "GTS";
+        }
+        if (nameLower.includes("bottommask") || nameLower.includes("bottomsolder") || nameLower.includes("solderbottom") || nameLower.includes("masksbot")) {
+          return "GBS";
+        }
+        if (nameLower.includes("topsilk") || nameLower.includes("silktop") || nameLower.includes("toplegend") || nameLower.includes("legendtop")) {
+          return "GTO";
+        }
+        if (nameLower.includes("bottomsilk") || nameLower.includes("silkbottom") || nameLower.includes("bottomlegend") || nameLower.includes("legendbottom")) {
+          return "GBO";
+        }
+        if (nameLower.includes("toppaste") || nameLower.includes("pastetop")) {
+          return "GTP";
+        }
+        if (nameLower.includes("bottompaste") || nameLower.includes("pastebottom")) {
+          return "GBP";
+        }
+        if (nameLower.includes("l1") || nameLower.includes("layer1") || nameLower.includes("top") && !nameLower.includes("paste") && !nameLower.includes("mask") && !nameLower.includes("silk")) {
+          return "GTL";
+        }
+        if (nameLower.includes("l4") || nameLower.includes("layer4") || nameLower.includes("bottom") && !nameLower.includes("paste") && !nameLower.includes("mask") && !nameLower.includes("silk")) {
+          return "GBL";
+        }
+        if (nameLower.includes("legend_top") || nameLower.includes("legend") && nameLower.includes("top") && !nameLower.includes("signal")) {
+          return "GTO";
+        }
+        if (nameLower.includes("paste_top")) return "GTP";
+        if (nameLower.includes("paste_bot")) return "GBP";
+        if (nameLower.includes("soldermask_top")) return "GTS";
+        if (nameLower.includes("soldermask_bot")) return "GBS";
+        const signalMatch = nameLower.match(/(?:copper_)?signal[_\s](\d+)/i);
+        if (signalMatch) {
+          const number = parseInt(signalMatch[1], 10);
+          const displayNumber = number + 1;
+          return "SIG" + displayNumber;
+        }
+        if (nameLower.includes("signal_top") || nameLower.includes("copper_signal_top")) return "GTL";
+        if (nameLower.includes("signal_bot") || nameLower.includes("copper_signal_bot")) return "GBL";
+        if (fileNameUpper.includes("PROFILE")) return "GKO";
+        if (nameWithoutExt === "WX" || fileNameUpper.includes("WX")) return "GKO";
+        if (nameLower.includes("l2") || nameLower.includes("layer2") || nameLower.includes("inner 1") || nameLower.includes("inner1")) {
+          return "SIG2";
+        }
+        if (nameLower.includes("l3") || nameLower.includes("layer3") || nameLower.includes("inner 2") || nameLower.includes("inner2")) {
+          return "SIG3";
+        }
+        if (fileNameUpper.startsWith("ZH-TOP") || fileNameUpper.includes("ZH-TOP")) return "GTS";
+        if (fileNameUpper.startsWith("ZH-BOT") || fileNameUpper.includes("ZH-BOT")) return "GBS";
+        if (fileNameUpper.startsWith("XL-TOP") || fileNameUpper.includes("XL-TOP")) return "GTL";
+        if (fileNameUpper.startsWith("XL-BOT") || fileNameUpper.includes("XL-BOT")) return "GBL";
+        if (/EDGE[._-]CUTS/i.test(fileNameUpper)) return "GKO";
+        if (/F[._-]CU\b/i.test(fileNameUpper)) return "GTL";
+        if (/B[._-]CU\b/i.test(fileNameUpper)) return "GBL";
+        const inCuGbr = fileNameUpper.match(/IN(\d+)[._-]CU/i);
+        if (inCuGbr) return "SIG" + (parseInt(inCuGbr[1], 10) + 1);
+        const keywords = ["_Drawing", "_Drillmap", "_NPTH", "_Pads", "_PTH"];
+        for (const keyword of keywords) {
+          if (fileNameOnly.includes(keyword)) {
+            const keywordIndex = fileNameOnly.indexOf(keyword);
+            return fileNameOnly.substring(keywordIndex);
+          }
+        }
+        return fileNameOnly;
+      }
+      if (fileExtension === ".PHO") {
+        if (fileNameUpper.startsWith("SST")) return "GTO";
+        const pickByGroup = (prefix, topType, botType, defaultType = null) => {
+          const m = fileNameUpper.match(new RegExp(`^${prefix}(\\d+)`));
+          const num = m ? parseInt(m[1], 10) : 0;
+          const g = phoGroups.get(prefix.toLowerCase());
+          if (g) {
+            return num === g.min ? topType : botType;
+          }
+          return defaultType || topType;
+        };
+        if (fileNameUpper.startsWith("SMD")) {
+          return pickByGroup("SMD", "GTP", "GBP", "GTP");
+        }
+        if (fileNameUpper.startsWith("SM")) {
+          return pickByGroup("SM", "GTS", "GBS", "GTS");
+        }
+        if (fileNameUpper.startsWith("ART")) {
+          return pickByGroup("ART", "GTL", "GBL", "GTL");
+        }
+        if (fileNameUpper.startsWith("SSB")) return "GBO";
+      }
+      if (fileNameUpper.endsWith("_SST") || fileNameUpper.includes("_SST.")) return "GTO";
+      if (fileNameUpper.endsWith("_PMT") || fileNameUpper.includes("_PMT.")) return "GTP";
+      if (fileNameUpper.endsWith("_SMT") || fileNameUpper.includes("_SMT.")) return "GTS";
+      if (fileNameUpper.endsWith("_TOP") || fileNameUpper.includes("_TOP.")) return "GTL";
+      if (fileNameUpper.endsWith("_SMB") || fileNameUpper.includes("_SMB.")) return "GBS";
+      if (fileNameUpper.endsWith("_PMB") || fileNameUpper.includes("_PMB.")) return "GBP";
+      if (fileNameUpper.endsWith("_SSB") || fileNameUpper.includes("_SSB.")) return "GBO";
+      if (fileNameUpper.includes("OUTLINE")) return "GKO";
+      if (/.*_INT\d+$/i.test(fileNameUpper) || /.*_INT\d+\./i.test(fileNameUpper)) return fileNameOnly;
+      if (fileExtension === ".GTO") return "GTO";
+      if (fileExtension === ".GTP") return "GTP";
+      if (fileExtension === ".GTS") return "GTS";
+      if (fileExtension === ".GTL") return "GTL";
+      if (fileExtension === ".GBL") return "GBL";
+      if (fileExtension === ".GBS") return "GBS";
+      if (fileExtension === ".GBP") return "GBP";
+      if (fileExtension === ".GBO") return "GBO";
+      if (fileExtension === ".GKO" || fileNameUpper.includes("PROFILE")) return "GKO";
+      if (fileExtension === ".GM1" || fileExtension === ".GM2") return "GKO";
+      if (fileExtension === ".GM" || fileExtension === ".GML" || fileExtension === ".OUTLINE" || fileExtension === ".OUT" || fileExtension === ".OLN") return "GKO";
+      if (fileExtension === ".D" || fileExtension === ".DRL" || fileExtension === ".DRI") {
+        if (fileNameUpper === "NP.DRL" || fileNameUpper === "NP.D") return "DRL2";
+        if (fileNameUpper === "P.DRL" || fileNameUpper === "P.D") return "DRL";
+        return "DRL";
+      }
+      if (fileExtension === ".ROU") return "rout";
+      if (fileExtension === ".BOT") return "GBL";
+      if (fileExtension === ".TOP") return "GTL";
+      if (fileExtension === ".SOB") return "GBS";
+      if (fileExtension === ".SOT") return "GTS";
+      if (fileExtension === ".SST") return "GTO";
+      if (fileExtension === ".SSB") return "GBO";
+      if (fileExtension === ".SMT") return "GTS";
+      if (fileExtension === ".SMB") return "GBS";
+      if (fileExtension === ".PMT") return "GTP";
+      if (fileExtension === ".PMB") return "GBP";
+      if (fileExtension === ".SER") return "GTO";
+      if (fileExtension === ".ART") {
+        const dot = fileNameOnly.lastIndexOf(".");
+        const stemUpper = (dot > 0 ? fileNameOnly.substring(0, dot) : fileNameOnly).toUpperCase();
+        if (stemUpper === "SST") return "GTO";
+        if (stemUpper === "SMT") return "GTS";
+        if (stemUpper === "TOP") return "GTL";
+        if (stemUpper === "BOT") return "GBL";
+        if (stemUpper === "SMB") return "GBS";
+        if (stemUpper === "SSB") return "GBO";
+        if (stemUpper === "OUT") return "GKO";
+        const layMatch = stemUpper.match(/^LAY(\d+)$/);
+        if (layMatch) {
+          const layerNum = parseInt(layMatch[1], 10);
+          return "SIG" + layerNum;
+        }
+        return fileNameOnly;
+      }
+      const gExtMatch = fileExtension.match(/^\.G(\d+)$/i);
+      if (gExtMatch) {
+        const inCu = fileNameUpper.match(/IN(\d+)[._-]CU/i);
+        if (inCu) return "SIG" + (parseInt(inCu[1], 10) + 1);
+        const gn = parseInt(gExtMatch[1], 10);
+        return "SIG" + (gn + 1);
+      }
+      const gpExtMatch = fileExtension.match(/^\.GP(\d+)$/i);
+      if (gpExtMatch) {
+        return "GP" + parseInt(gpExtMatch[1], 10);
+      }
+      return null;
+    };
+    const outlineFiles = [];
+    const topCopperFiles = [];
+    const bottomCopperFiles = [];
+    const topMaskFiles = [];
+    const bottomMaskFiles = [];
+    const topPasteFiles = [];
+    const bottomPasteFiles = [];
+    const topSilkFiles = [];
+    const bottomSilkFiles = [];
+    const innerCopperFiles = [];
+    for (const file of gerberFiles) {
+      const fileNameOnly = file.name.split(/[/\\]/).pop() || "";
+      const fileExtension = "." + fileNameOnly.split(".").pop().toUpperCase();
+      if (fileExtension === ".PHO") {
+        continue;
+      }
+      const layerType = getLayerType(file.name);
+      if (layerType === "GKO") {
+        outlineFiles.push(file);
+      } else if (layerType === "GTL") {
+        topCopperFiles.push(file);
+      } else if (layerType === "GBL") {
+        bottomCopperFiles.push(file);
+      } else if (layerType === "GTS") {
+        topMaskFiles.push(file);
+      } else if (layerType === "GBS") {
+        bottomMaskFiles.push(file);
+      } else if (layerType === "GTP") {
+        topPasteFiles.push(file);
+      } else if (layerType === "GBP") {
+        bottomPasteFiles.push(file);
+      } else if (layerType === "GTO") {
+        topSilkFiles.push(file);
+      } else if (layerType === "GBO") {
+        bottomSilkFiles.push(file);
+      } else if (layerType && /^SIG\d+$/i.test(layerType)) {
+        innerCopperFiles.push(file);
+      }
+    }
+    if (outlineFiles.length === 0) {
+      const fallbackFiles = gerberFiles.filter((f) => {
+        const name = f.name.toLowerCase();
+        return name.endsWith(".gm2");
+      });
+      if (fallbackFiles.length > 0) {
+        outlineFiles.push(...fallbackFiles);
+      }
+    }
+    const pickBestOutlineFiles = async () => {
+      if (!outlineFiles || outlineFiles.length <= 1) return { files: outlineFiles || [], refBbox: null };
+      const baseNameUpper = (name) => (name.split(/[/\\]/).pop() || "").toUpperCase();
+      const isExt = (nameUpper, extUpper) => nameUpper.endsWith(extUpper);
+      const outlineCandidates = [...outlineFiles];
+      const pickReferenceFile = () => {
+        return topCopperFiles[0] || bottomCopperFiles[0] || topSilkFiles[0] || bottomSilkFiles[0] || topMaskFiles[0] || bottomMaskFiles[0] || topPasteFiles[0] || bottomPasteFiles[0] || null;
+      };
+      const getReferenceBbox = async () => {
+        const refFile = pickReferenceFile();
+        if (!refFile) return null;
+        try {
+          const res = await GerberParser.parseFile(refFile, "#ffffff");
+          if (!res || !res.data) return null;
+          const bbox = this.calculateLayerBbox([res.data]);
+          if (!bbox || bbox.isEmpty()) return null;
+          let scale = 1;
+          if (res.units === "in" || res.units === "inch") scale = 25.4;
+          bbox.min.multiplyScalar(scale);
+          bbox.max.multiplyScalar(scale);
+          return { bbox, refFileName: refFile.name, scale, units: res.units };
+        } catch (e) {
+          return null;
+        }
+      };
+      const computeOutlineBbox = async (file) => {
+        const nameUpper = baseNameUpper(file.name);
+        const parser = new GerberOutlineParser();
+        const text = await file.text();
+        const { shapes, strokes } = parser.parse(text);
+        let minX = Infinity, maxX = -Infinity, minY = Infinity, maxY = -Infinity;
+        let pointCount = 0;
+        const pushXY = (x, y) => {
+          if (!Number.isFinite(x) || !Number.isFinite(y)) return;
+          if (x < minX) minX = x;
+          if (x > maxX) maxX = x;
+          if (y < minY) minY = y;
+          if (y > maxY) maxY = y;
+          pointCount++;
+        };
+        const consumeShape = (s) => {
+          const curves = s?.curves || [];
+          if (curves.length > 0) {
+            for (const c of curves) {
+              if (c?.isLineCurve) {
+                const v1 = c.v1;
+                const v2 = c.v2;
+                if (v1) pushXY(v1.x, v1.y);
+                if (v2) pushXY(v2.x, v2.y);
+              } else {
+                const p0 = c?.getPoint?.(0);
+                const p1 = c?.getPoint?.(1);
+                if (p0) pushXY(p0.x, p0.y);
+                if (p1) pushXY(p1.x, p1.y);
+              }
+            }
+            return;
+          }
+          const pts = s?.getPoints?.() || [];
+          for (const p of pts) pushXY(p.x, p.y);
+        };
+        if (shapes && shapes.length > 0) {
+          for (const s of shapes) consumeShape(s);
+        }
+        if (pointCount === 0 && strokes && strokes.length > 0) {
+          for (const seg of strokes) {
+            pushXY(seg.start.x, seg.start.y);
+            pushXY(seg.end.x, seg.end.y);
+          }
+        }
+        const valid = Number.isFinite(minX) && Number.isFinite(maxX) && Number.isFinite(minY) && Number.isFinite(maxY) && maxX > minX && maxY > minY;
+        if (!valid) {
+          return {
+            file,
+            name: file.name,
+            nameUpper,
+            valid: false,
+            shapesCount: shapes?.length || 0,
+            strokesCount: strokes?.length || 0
+          };
+        }
+        const bbox = new THREE2.Box3(
+          new THREE2.Vector3(minX, minY, 0),
+          new THREE2.Vector3(maxX, maxY, 0)
+        );
+        const size = bbox.getSize(new THREE2.Vector3());
+        const center = bbox.getCenter(new THREE2.Vector3());
+        const area = size.x * size.y;
+        return {
+          file,
+          name: file.name,
+          nameUpper,
+          valid: true,
+          bbox,
+          size,
+          center,
+          area,
+          shapesCount: shapes?.length || 0,
+          strokesCount: strokes?.length || 0
+        };
+      };
+      const ref = await getReferenceBbox();
+      const infos = [];
+      for (const f of outlineCandidates) {
+        try {
+          infos.push(await computeOutlineBbox(f));
+        } catch (e) {
+          infos.push({ file: f, name: f.name, nameUpper: baseNameUpper(f.name), valid: false });
+        }
+      }
+      try {
+        const logList = infos.map((i) => {
+          if (!i.valid) {
+            return { file: i.name, valid: false, shapes: i.shapesCount || 0, strokes: i.strokesCount || 0 };
+          }
+          return {
+            file: i.name,
+            valid: true,
+            w: Number(i.size.x.toFixed(2)),
+            h: Number(i.size.y.toFixed(2)),
+            area: Number(i.area.toFixed(2)),
+            cx: Number(i.center.x.toFixed(2)),
+            cy: Number(i.center.y.toFixed(2)),
+            shapes: i.shapesCount || 0,
+            strokes: i.strokesCount || 0
+          };
+        });
+        debugWarn("[3D-new][OutlineCandidates] \u8F6E\u5ED3\u5019\u9009\u6587\u4EF6 bbox \u5217\u8868:", logList);
+        if (ref?.bbox) {
+          const refSize = ref.bbox.getSize(new THREE2.Vector3());
+          const refCenter = ref.bbox.getCenter(new THREE2.Vector3());
+          debugWarn("[3D-new][OutlineCandidates] \u53C2\u8003\u5C42:", {
+            file: ref.refFileName,
+            units: ref.units,
+            scale: ref.scale,
+            w: Number(refSize.x.toFixed(2)),
+            h: Number(refSize.y.toFixed(2)),
+            cx: Number(refCenter.x.toFixed(2)),
+            cy: Number(refCenter.y.toFixed(2))
+          });
+        }
+      } catch (e) {
+      }
+      const validInfos = infos.filter((i) => i.valid);
+      if (validInfos.length === 0) return { files: outlineFiles, refBbox: ref?.bbox || null };
+      const hasGko = validInfos.some((i) => isExt(i.nameUpper, ".GKO"));
+      const scoreInfo = (i) => {
+        let score = 0;
+        if (hasGko && !isExt(i.nameUpper, ".GKO")) score += 3;
+        if (isExt(i.nameUpper, ".GM2") || isExt(i.nameUpper, ".GM1")) score += 0.5;
+        if ((i.shapesCount || 0) === 0 && (i.strokesCount || 0) > 0) score += 0.5;
+        if ((i.shapesCount || 0) === 0 && (i.strokesCount || 0) === 0) score += 10;
+        if (ref?.bbox) {
+          const refBox = ref.bbox;
+          const refSize = refBox.getSize(new THREE2.Vector3());
+          const refCenter = refBox.getCenter(new THREE2.Vector3());
+          const expandedRef = refBox.clone().expandByScalar(Math.max(10, Math.max(refSize.x, refSize.y) * 0.05));
+          if (!expandedRef.intersectsBox(i.bbox)) score += 1e3;
+          const rx = i.size.x / Math.max(1e-9, refSize.x);
+          const ry = i.size.y / Math.max(1e-9, refSize.y);
+          score += Math.abs(Math.log(rx)) + Math.abs(Math.log(ry));
+          const dist = i.center.distanceTo(refCenter);
+          const maxDim = Math.max(refSize.x, refSize.y);
+          score += dist / Math.max(1e-9, maxDim);
+        } else {
+        }
+        return score;
+      };
+      let chosen = null;
+      let bestScore = Infinity;
+      for (const i of validInfos) {
+        const s = scoreInfo(i);
+        if (s < bestScore) {
+          bestScore = s;
+          chosen = i;
+        }
+      }
+      if (!chosen) return { files: outlineFiles, refBbox: ref?.bbox || null };
+      const chosenFile = chosen.file;
+      const chosenNameUpper = (chosenFile.name || "").toUpperCase();
+      const filesToKeep = [chosenFile];
+      if (chosenNameUpper.endsWith(".GKO")) {
+        const gm1Files = outlineCandidates.filter((f) => {
+          const nameUpper = (f.name || "").toUpperCase();
+          return nameUpper.endsWith(".GM1") && f !== chosenFile;
+        });
+        if (gm1Files.length > 0) {
+          filesToKeep.push(...gm1Files);
+          debugLog("[3D-new][OutlineCandidates] \u{1F517} \u53D1\u73B0GM1\u5C42\uFF0C\u5C06\u4E0EGKO\u5408\u5E76\u751F\u6210\u5B8C\u6574\u8F6E\u5ED3");
+        }
+      }
+      const ignored = outlineCandidates.filter((f) => !filesToKeep.includes(f)).map((f) => f.name);
+      if (ignored.length > 0) {
+        debugLog("[3D-new][OutlineCandidates] \u8F6E\u5ED3\u5C42\u5DF2\u9009\u62E9:", filesToKeep.map((f) => f.name).join(" + "), "\uFF1B\u5FFD\u7565\u5176\u4F59:", ignored);
+      } else {
+        debugLog("[3D-new][OutlineCandidates] \u8F6E\u5ED3\u5C42\u5DF2\u9009\u62E9:", filesToKeep.map((f) => f.name).join(" + "));
+      }
+      return { files: filesToKeep, refBbox: ref?.bbox || null };
+    };
+    const pickResult = await pickBestOutlineFiles();
+    const referenceBbox = pickResult.refBbox;
+    outlineFiles.splice(0, outlineFiles.length, ...pickResult.files);
+    const drillFiles = gerberFiles.filter((f) => {
+      const name = f.name.toLowerCase();
+      return name.match(/(\.drl|\.dri|\.txt|\.drd)/i) && !name.includes("status report") && !name.includes(".rep") && !name.includes(".log") && !name.includes(".apr");
+    });
+    const endTimeClassify = performance.now();
+    console.log(`[\u6027\u80FD] \u6587\u4EF6\u5206\u7C7B\u5B8C\u6210\uFF0C\u8017\u65F6: ${(endTimeClassify - startTimeClassify).toFixed(2)}ms`);
+    console.log("[\u6027\u80FD] \u5F00\u59CB\u6E32\u67D3\u8F6E\u5ED3\u5C42...");
+    const startTimeOutline = performance.now();
+    let hasOutline = false;
+    let fallbackLayerForCamera = null;
+    const outlineStrokes = [];
+    let usedBboxOutlineFallback = false;
+    const OUTLINE_MIN_AREA_RATIO = 0.3;
+    const OUTLINE_TOTAL_AREA_RATIO = 0.5;
+    const OUTLINE_SHAPE_COUNT_LIMIT = 50;
+    const OUTLINE_FORCED_RATIO_LIMIT = 0.5;
+    const OUTLINE_MERGE_TOLERANCE = 0.2;
+    if (outlineFiles.length > 0) {
+      const parser = new GerberOutlineParser();
+      let shapes = [];
+      for (const file of outlineFiles) {
+        const text = await file.text();
+        const { shapes: fileShapes, strokes } = parser.parse(text);
+        if (fileShapes?.length > 0) {
+          for (const s of fileShapes) shapes.push(s);
+        }
+        if (strokes?.length > 0) {
+          for (const seg of strokes) outlineStrokes.push(seg);
+        }
+      }
+      if (outlineFiles.length > 1 && outlineStrokes.length > 0) {
+        debugLog(`[\u8F6E\u5ED3\u5C42] \u{1F517} \u5408\u5E76 ${outlineFiles.length} \u4E2A\u6587\u4EF6\uFF0C\u7EBF\u6BB5\u6570: ${outlineStrokes.length}`);
+        const mergedShapes = stitchSegmentsToShapes(outlineStrokes);
+        if (mergedShapes?.length > 0) {
+          debugLog(`[\u8F6E\u5ED3\u5C42] \u2705 \u5408\u5E76\u6210\u529F\uFF0C\u751F\u6210 ${mergedShapes.length} \u4E2A\u5F62\u72B6`);
+          mergedShapes.sort((a, b) => {
+            const areaA = Math.abs(THREE2.ShapeUtils.area(a.getPoints()));
+            const areaB = Math.abs(THREE2.ShapeUtils.area(b.getPoints()));
+            return areaB - areaA;
+          });
+          shapes = mergedShapes;
+        }
+      }
+      debugLog(`[\u8F6E\u5ED3\u5C42] \u5F62\u72B6: ${shapes.length}, \u7EBF\u6BB5: ${outlineStrokes.length}`);
+      const MAX_POINTS_PER_SHAPE = 3e3;
+      const simplifyDouglasPeucker = (points, epsilon) => {
+        if (!points || points.length < 3) return points || [];
+        const sq = (v) => v * v;
+        const distPointToSegSq = (p, a, b) => {
+          const vx = b.x - a.x;
+          const vy = b.y - a.y;
+          const wx = p.x - a.x;
+          const wy = p.y - a.y;
+          const c1 = vx * wx + vy * wy;
+          if (c1 <= 0) return sq(p.x - a.x) + sq(p.y - a.y);
+          const c2 = vx * vx + vy * vy;
+          if (c2 <= c1) return sq(p.x - b.x) + sq(p.y - b.y);
+          const t = c1 / c2;
+          const px = a.x + t * vx;
+          const py = a.y + t * vy;
+          return sq(p.x - px) + sq(p.y - py);
+        };
+        const epsSq = epsilon * epsilon;
+        const keep = new Array(points.length).fill(false);
+        keep[0] = true;
+        keep[points.length - 1] = true;
+        const stack = [[0, points.length - 1]];
+        while (stack.length) {
+          const [s, e] = stack.pop();
+          let maxD = 0;
+          let idx = -1;
+          const a = points[s];
+          const b = points[e];
+          for (let i = s + 1; i < e; i++) {
+            const d = distPointToSegSq(points[i], a, b);
+            if (d > maxD) {
+              maxD = d;
+              idx = i;
+            }
+          }
+          if (idx >= 0 && maxD > epsSq) {
+            keep[idx] = true;
+            stack.push([s, idx], [idx, e]);
+          }
+        }
+        const out = [];
+        for (let i = 0; i < points.length; i++) if (keep[i]) out.push(points[i]);
+        return out;
+      };
+      for (let i = 0; i < shapes.length; i++) {
+        const shape = shapes[i];
+        let currentPoints = shape.getPoints();
+        if (currentPoints.length > MAX_POINTS_PER_SHAPE) {
+          let minX = Infinity, maxX = -Infinity, minY = Infinity, maxY = -Infinity;
+          for (const p of currentPoints) {
+            minX = Math.min(minX, p.x);
+            maxX = Math.max(maxX, p.x);
+            minY = Math.min(minY, p.y);
+            maxY = Math.max(maxY, p.y);
+          }
+          const boardSize = Math.max(maxX - minX, maxY - minY);
+          const targetPoints = 2e3;
+          const epsilon = Math.max(0.05, boardSize * 3e-4);
+          const simplified = simplifyDouglasPeucker(currentPoints, epsilon);
+          debugLog(`[\u8F6E\u5ED3\u5C42] \u7B80\u5316\u5F62\u72B6 ${i}: ${currentPoints.length} -> ${simplified.length} \u70B9 (\u5BB9\u5DEE=${epsilon.toFixed(4)}mm)`);
+          if (simplified.length >= 4) {
+            const newShape = new THREE2.Shape();
+            newShape.moveTo(simplified[0].x, simplified[0].y);
+            for (let j = 1; j < simplified.length; j++) {
+              newShape.lineTo(simplified[j].x, simplified[j].y);
+            }
+            newShape.closePath();
+            newShape.userData = shape.userData;
+            shapes[i] = newShape;
+          }
+        }
+      }
+      const attachOutlineHoles = (inputShapes, referenceBbox2) => {
+        if (!inputShapes || inputShapes.length <= 1) return inputShapes || [];
+        const isPointInShape = (pt, shape) => {
+          const points = shape.getPoints();
+          if (!points || points.length < 3) return false;
+          let inside = false;
+          for (let i = 0, j = points.length - 1; i < points.length; j = i++) {
+            const xi = points[i].x, yi = points[i].y;
+            const xj = points[j].x, yj = points[j].y;
+            if (yi > pt.y !== yj > pt.y && pt.x < (xj - xi) * (pt.y - yi) / (yj - yi) + xi) inside = !inside;
+          }
+          return inside;
+        };
+        const signedArea = (pts) => {
+          return THREE2.ShapeUtils.area(pts);
+        };
+        const bboxOfShape = (s) => {
+          const pts = s.getPoints();
+          let minX = Infinity, maxX = -Infinity, minY = Infinity, maxY = -Infinity;
+          for (const p of pts) {
+            if (p.x < minX) minX = p.x;
+            if (p.x > maxX) maxX = p.x;
+            if (p.y < minY) minY = p.y;
+            if (p.y > maxY) maxY = p.y;
+          }
+          const valid = isFinite(minX) && isFinite(maxX) && isFinite(minY) && isFinite(maxY) && maxX > minX && maxY > minY;
+          if (!valid) return null;
+          return { minX, minY, maxX, maxY, w: maxX - minX, h: maxY - minY, area: (maxX - minX) * (maxY - minY) };
+        };
+        const bboxContains = (outer, inner, pad = 0.2) => {
+          return inner.minX >= outer.minX - pad && inner.maxX <= outer.maxX + pad && inner.minY >= outer.minY - pad && inner.maxY <= outer.maxY + pad;
+        };
+        const refArea = referenceBbox2 && !referenceBbox2.isEmpty() ? referenceBbox2.getSize(new THREE2.Vector3()).x * referenceBbox2.getSize(new THREE2.Vector3()).y : 0;
+        const items = inputShapes.map((s) => {
+          const pts = s.getPoints();
+          const area = Math.abs(THREE2.ShapeUtils.area(pts));
+          const bbox = bboxOfShape(s);
+          let cx = 0, cy = 0;
+          for (const p of pts) {
+            cx += p.x;
+            cy += p.y;
+          }
+          const n = Math.max(1, pts.length);
+          const center = { x: cx / n, y: cy / n };
+          return { shape: s, area, bbox, center };
+        }).filter((i) => i.area > 1e-3 && i.bbox);
+        if (items.length <= 1) return inputShapes;
+        const largestArea = items.reduce((m, it) => Math.max(m, it.area), 0);
+        const minHoleArea = Math.max(0.05, largestArea * 5e-5);
+        const maxHoleAreaByRef = refArea > 0 ? refArea * 0.3 : Infinity;
+        items.sort((a, b) => a.area - b.area);
+        const isHole = /* @__PURE__ */ new Set();
+        for (const child of items) {
+          if (child.area < minHoleArea) continue;
+          if (child.area > maxHoleAreaByRef) continue;
+          let bestParent = null;
+          let bestParentArea = Infinity;
+          for (const parent of items) {
+            if (parent === child) continue;
+            if (parent.area <= child.area) continue;
+            if (!bboxContains(parent.bbox, child.bbox, 0.2)) continue;
+            if (child.area / Math.max(1e-9, parent.area) > 0.6) continue;
+            if (!isPointInShape(child.center, parent.shape)) continue;
+            if (parent.area < bestParentArea) {
+              bestParent = parent;
+              bestParentArea = parent.area;
+            }
+          }
+          if (bestParent) {
+            const parentPts = bestParent.shape.getPoints();
+            const childPts0 = child.shape.getPoints();
+            if (parentPts && parentPts.length >= 3 && childPts0 && childPts0.length >= 3) {
+              let childPts = childPts0.slice();
+              const parentA = signedArea(parentPts);
+              const childA = signedArea(childPts);
+              if (parentA * childA > 0) {
+                childPts = childPts.slice().reverse();
+              }
+              const holePath = new THREE2.Path();
+              holePath.moveTo(childPts[0].x, childPts[0].y);
+              for (let k = 1; k < childPts.length; k++) {
+                holePath.lineTo(childPts[k].x, childPts[k].y);
+              }
+              holePath.closePath();
+              bestParent.shape.holes = bestParent.shape.holes || [];
+              bestParent.shape.holes.push(holePath);
+            }
+            isHole.add(child.shape);
+          }
+        }
+        const roots = inputShapes.filter((s) => !isHole.has(s));
+        const holeCount = inputShapes.length - roots.length;
+        if (holeCount > 0) {
+          debugLog(`[Outline] \u2705 \u5DF2\u6302\u5B54\u6D1E: holes=${holeCount}, roots=${roots.length}`);
+        }
+        return roots;
+      };
+      shapes = attachOutlineHoles(shapes, referenceBbox);
+      if (shapes.length > 0) {
+        const isPointInShape = (pt, shape) => {
+          const points = shape.getPoints();
+          if (!points || points.length < 3) return false;
+          let inside = false;
+          for (let i = 0, j = points.length - 1; i < points.length; j = i++) {
+            const xi = points[i].x, yi = points[i].y;
+            const xj = points[j].x, yj = points[j].y;
+            if (yi > pt.y !== yj > pt.y && pt.x < (xj - xi) * (pt.y - yi) / (yj - yi) + xi) {
+              inside = !inside;
+            }
+          }
+          return inside;
+        };
+        let selectedOuterShape = null;
+        let selectedOuterMeta = null;
+        if (referenceBbox && !referenceBbox.isEmpty()) {
+          const refCenter = referenceBbox.getCenter(new THREE2.Vector3());
+          const focusCenter = { x: refCenter.x, y: refCenter.y };
+          const refSize = referenceBbox.getSize(new THREE2.Vector3());
+          const refMinX = refCenter.x - refSize.x / 2;
+          const refMaxX = refCenter.x + refSize.x / 2;
+          const refMinY = refCenter.y - refSize.y / 2;
+          const refMaxY = refCenter.y + refSize.y / 2;
+          const refArea = refSize.x * refSize.y;
+          const MIN_OUTER_AREA = 1;
+          const candidates = [];
+          for (const s of shapes) {
+            const area = Math.abs(THREE2.ShapeUtils.area(s.getPoints()));
+            if (area < MIN_OUTER_AREA) continue;
+            try {
+              const pts = s.getPoints();
+              let sMinX = Infinity, sMaxX = -Infinity, sMinY = Infinity, sMaxY = -Infinity;
+              for (const p of pts) {
+                if (p.x < sMinX) sMinX = p.x;
+                if (p.x > sMaxX) sMaxX = p.x;
+                if (p.y < sMinY) sMinY = p.y;
+                if (p.y > sMaxY) sMaxY = p.y;
+              }
+              const overlapMinX = Math.max(refMinX, sMinX);
+              const overlapMaxX = Math.min(refMaxX, sMaxX);
+              const overlapMinY = Math.max(refMinY, sMinY);
+              const overlapMaxY = Math.min(refMaxY, sMaxY);
+              const overlapW = Math.max(0, overlapMaxX - overlapMinX);
+              const overlapH = Math.max(0, overlapMaxY - overlapMinY);
+              const overlapArea = overlapW * overlapH;
+              const overlapRatio = refArea > 0 ? overlapArea / refArea : 0;
+              const sW = sMaxX - sMinX;
+              const sH = sMaxY - sMinY;
+              const sBboxArea = sW * sH;
+              if (overlapRatio > 0.3) {
+                candidates.push({
+                  shape: s,
+                  area,
+                  overlapRatio,
+                  shapeBbox: { minX: sMinX, maxX: sMaxX, minY: sMinY, maxY: sMaxY, w: sW, h: sH, area: sBboxArea }
+                });
+              }
+            } catch (_) {
+            }
+          }
+          if (candidates.length > 0) {
+            const highOverlapCandidates = candidates.filter((c) => c.overlapRatio > 0.8);
+            const refSize2 = referenceBbox.getSize(new THREE2.Vector3());
+            const refArea2 = refSize2.x * refSize2.y;
+            let selectedCandidate;
+            if (highOverlapCandidates.length > 1) {
+              const validBboxCandidates = highOverlapCandidates.filter((c) => (c?.shapeBbox?.area || 0) >= refArea2 * 0.8);
+              const pool = validBboxCandidates.length > 0 ? validBboxCandidates : highOverlapCandidates;
+              pool.sort((a, b) => {
+                const aB = a?.shapeBbox?.area || 0;
+                const bB = b?.shapeBbox?.area || 0;
+                return Math.abs(aB - refArea2) - Math.abs(bB - refArea2);
+              });
+              selectedCandidate = pool[0];
+              debugLog(`[Outline] \u{1F50D} \u591A\u4E2A\u9AD8overlap\u5019\u9009\uFF0C\u9009\u62E9bbox\u6700\u63A5\u8FD1\u53C2\u8003\u5C42\u7684: bbox=${(selectedCandidate.shapeBbox?.area || 0).toFixed(2)}mm\xB2 (\u53C2\u8003=${refArea2.toFixed(2)}mm\xB2), poly=${selectedCandidate.area.toFixed(2)}mm\xB2`);
+            } else {
+              candidates.sort((a, b) => b.overlapRatio - a.overlapRatio);
+              selectedCandidate = candidates[0];
+            }
+            const selectedArea = selectedCandidate.area;
+            selectedOuterMeta = {
+              bbox: selectedCandidate.shapeBbox || null,
+              polyArea: selectedArea,
+              overlapRatio: selectedCandidate.overlapRatio || 0
+            };
+            if (selectedArea < refArea2 * 0.5 && candidates.length > 1) {
+              const totalArea = candidates.reduce((sum, c) => sum + c.area, 0);
+              if (totalArea > refArea2 * 0.6) {
+                debugLog(`[Outline] \u{1F517} \u68C0\u6D4B\u5230\u62FC\u677F\uFF1A\u6700\u9AD8\u91CD\u53E0=${selectedArea.toFixed(2)}mm\xB2 (overlap=${(selectedCandidate.overlapRatio * 100).toFixed(1)}%)\uFF0C\u603B\u9762\u79EF=${totalArea.toFixed(2)}mm\xB2\uFF0C\u4F7F\u7528 ${candidates.length} \u4E2A\u5019\u9009`);
+                selectedOuterShape = null;
+              } else {
+                selectedOuterShape = selectedCandidate.shape;
+                debugLog(`[Outline] \u{1F3AF} \u4F7F\u7528bbox\u91CD\u53E0\u9009\u62E9\u5916\u8F6E\u5ED3: \u9762\u79EF=${selectedArea.toFixed(2)}mm\xB2, overlap=${(selectedCandidate.overlapRatio * 100).toFixed(1)}%, \u5019\u9009\u6570=${candidates.length}`);
+              }
+            } else {
+              selectedOuterShape = selectedCandidate.shape;
+              debugLog(`[Outline] \u{1F3AF} \u4F7F\u7528bbox\u91CD\u53E0\u9009\u62E9\u5916\u8F6E\u5ED3: \u9762\u79EF=${selectedArea.toFixed(2)}mm\xB2, overlap=${(selectedCandidate.overlapRatio * 100).toFixed(1)}%, \u5019\u9009\u6570=${candidates.length}`);
+            }
+          } else {
+            const shapesWithArea = shapes.map((s) => ({
+              shape: s,
+              area: Math.abs(THREE2.ShapeUtils.area(s.getPoints()))
+            })).filter((item) => item.area >= 1);
+            if (shapesWithArea.length > 0) {
+              shapesWithArea.sort((a, b) => b.area - a.area);
+              const maxShape = shapesWithArea[0];
+              const refSize2 = referenceBbox.getSize(new THREE2.Vector3());
+              const refArea2 = refSize2.x * refSize2.y;
+              if (maxShape.area > refArea2 * 0.3) {
+                selectedOuterShape = maxShape.shape;
+                debugLog(`[Outline] \u{1F3AF} \u4F7F\u7528\u6700\u5927\u9762\u79EF\u5F62\u72B6\u4F5C\u4E3A\u5916\u8F6E\u5ED3: \u9762\u79EF=${maxShape.area.toFixed(2)}mm\xB2 (\u53C2\u8003\u5C42\u9762\u79EF=${refArea2.toFixed(2)}mm\xB2)`);
+              } else {
+                debugWarn(`[Outline] \u26A0\uFE0F \u6700\u5927\u5F62\u72B6\u9762\u79EF\u8FC7\u5C0F (${maxShape.area.toFixed(2)}mm\xB2 < ${(refArea2 * 0.3).toFixed(2)}mm\xB2)\uFF0C\u56DE\u9000\u5230\u788E\u7247\u5316\u5904\u7406`);
+              }
+            } else {
+              debugWarn("[Outline] \u26A0\uFE0F \u6CA1\u6709\u6709\u6548\u5F62\u72B6\uFF08\u9762\u79EF>=1mm\xB2\uFF09\uFF0C\u56DE\u9000\u5230\u788E\u7247\u5316\u5904\u7406");
+            }
+          }
+        }
+        if (selectedOuterShape) {
+          if (selectedOuterMeta?.bbox?.area && selectedOuterMeta?.polyArea) {
+            const ratio = selectedOuterMeta.polyArea / Math.max(1e-9, selectedOuterMeta.bbox.area);
+            if (ratio < 0.6) {
+              const hullShape = outlineStrokes && outlineStrokes.length > 0 ? this.buildHullShapeFromSegments(outlineStrokes) : null;
+              if (hullShape) {
+                selectedOuterShape = hullShape;
+                usedBboxOutlineFallback = true;
+                debugWarn(`[Outline] \u26A0\uFE0F \u9009\u4E2D\u5916\u5F62\u591A\u8FB9\u5F62\u9762\u79EF\u504F\u5C0F(poly/bbox=${(ratio * 100).toFixed(1)}%)\uFF0C\u6539\u7528\u51F8\u5305\u5B9E\u5FC3\u677F\u515C\u5E95`);
+              } else {
+                const bb = selectedOuterMeta.bbox;
+                const rectShape = new THREE2.Shape();
+                rectShape.moveTo(bb.minX, bb.minY);
+                rectShape.lineTo(bb.maxX, bb.minY);
+                rectShape.lineTo(bb.maxX, bb.maxY);
+                rectShape.lineTo(bb.minX, bb.maxY);
+                rectShape.closePath();
+                selectedOuterShape = rectShape;
+                usedBboxOutlineFallback = true;
+                debugWarn(`[Outline] \u26A0\uFE0F \u9009\u4E2D\u5916\u5F62\u591A\u8FB9\u5F62\u9762\u79EF\u504F\u5C0F(poly/bbox=${(ratio * 100).toFixed(1)}%)\uFF0C\u6539\u7528bbox\u5B9E\u5FC3\u677F\u515C\u5E95`);
+              }
+            }
+          }
+          this.renderOutlineBoard([selectedOuterShape], !usedBboxOutlineFallback);
+          hasOutline = true;
+          debugLog("[Outline] \u2705 \u4F7F\u7528\u53C2\u8003\u5C42\u9009\u62E9\u7684\u5F02\u5F62\u5916\u8F6E\u5ED3\u6E32\u67D3\u57FA\u6750");
+        } else {
+          const shapeInfos = shapes.map((s) => ({
+            shape: s,
+            area: Math.abs(THREE2.ShapeUtils.area(s.getPoints())),
+            forcedClose: s.userData?.forcedClose || false
+          }));
+          const maxInfo = shapeInfos.reduce((max, cur) => cur.area > max.area ? cur : max);
+          const forcedCount = shapeInfos.filter((info) => info.forcedClose).length;
+          const totalArea = shapeInfos.reduce((sum, info) => sum + info.area, 0);
+          const shapeBboxShape = this.buildBBoxShapeFromShapes(shapes);
+          const strokeBboxShape = outlineStrokes.length > 0 ? this.buildBBoxShapeFromSegments(outlineStrokes) : null;
+          const strokeHullShape = outlineStrokes.length > 0 ? this.buildHullShapeFromSegments(outlineStrokes) : null;
+          const shapeBboxArea = shapeBboxShape ? Math.abs(THREE2.ShapeUtils.area(shapeBboxShape.getPoints())) : 0;
+          const strokeBboxArea = strokeBboxShape ? Math.abs(THREE2.ShapeUtils.area(strokeBboxShape.getPoints())) : 0;
+          const strokeHullArea = strokeHullShape ? Math.abs(THREE2.ShapeUtils.area(strokeHullShape.getPoints())) : 0;
+          const bboxShape = strokeBboxArea > shapeBboxArea ? strokeBboxShape : shapeBboxShape;
+          const bboxArea = Math.max(shapeBboxArea, strokeBboxArea);
+          const fallbackShape = strokeHullShape && strokeHullArea > 0 ? strokeHullShape : bboxShape;
+          const fallbackType = strokeHullShape && strokeHullArea > 0 ? "\u51F8\u5305" : "\u77E9\u5F62";
+          if (strokeHullShape && strokeHullArea > 0) {
+            debugLog(`[Outline] \u51F8\u5305\u53EF\u7528\u4E8E\u5F02\u5F62\u515C\u5E95\uFF08\u9762\u79EF=${strokeHullArea.toFixed(2)}mm\xB2\uFF09`);
+          }
+          let finalShapes = shapes;
+          if (bboxShape && bboxArea > 0) {
+            let maxShape = null;
+            let maxArea = 0;
+            let forcedCount2 = 0;
+            let bestNonForced = null;
+            let bestNonForcedArea = 0;
+            for (const s of shapes) {
+              const a = Math.abs(THREE2.ShapeUtils.area(s.getPoints()));
+              const isForced = !!s?.userData?.forcedClose;
+              if (isForced) forcedCount2++;
+              if (!isForced && a > bestNonForcedArea) {
+                bestNonForcedArea = a;
+                bestNonForced = s;
+              }
+              if (a > maxArea) {
+                maxArea = a;
+                maxShape = s;
+              }
+            }
+            const refAreaForOutline = strokeHullArea > 0 ? strokeHullArea : bboxArea;
+            const forcedAreaRatio = refAreaForOutline > 0 ? maxArea / refAreaForOutline : 0;
+            const forcedLooksGood = forcedAreaRatio >= 0.85;
+            if (maxShape?.userData?.forcedClose) {
+              if (bestNonForced && bestNonForcedArea > 0 && bestNonForcedArea >= refAreaForOutline * 0.6) {
+                finalShapes = [bestNonForced];
+                debugWarn(`[Outline] \u6700\u5927\u8F6E\u5ED3\u4E3A\u5F3A\u5236\u95ED\u5408\uFF0C\u6539\u7528\u975E\u5F3A\u5236\u95ED\u5408\u5916\u8F6E\u5ED3 (area=${bestNonForcedArea.toFixed(2)}mm\xB2)`);
+              } else if (!forcedLooksGood) {
+                finalShapes = [fallbackShape];
+                debugWarn(`[Outline] \u6700\u5927\u8F6E\u5ED3\u4E3A\u5F3A\u5236\u95ED\u5408\u4E14\u9762\u79EF\u504F\u5C0F(ratio=${(forcedAreaRatio * 100).toFixed(1)}%)\uFF0C\u4F7F\u7528${fallbackType}\u515C\u5E95`);
+              } else if (maxArea < bboxArea * OUTLINE_MIN_AREA_RATIO) {
+                finalShapes = [fallbackShape];
+                debugWarn(`[Outline] \u6700\u5927\u8F6E\u5ED3\u4E3A\u5F3A\u5236\u95ED\u5408\u4E14\u9762\u79EF\u8FC7\u5C0F\uFF0C\u4F7F\u7528${fallbackType}\u515C\u5E95`);
+              } else {
+                debugLog(`[Outline] \u6700\u5927\u8F6E\u5ED3\u4E3A\u5F3A\u5236\u95ED\u5408\u4F46\u9762\u79EF\u63A5\u8FD1\u53C2\u8003(ratio=${(forcedAreaRatio * 100).toFixed(1)}%)\uFF0C\u4F7F\u7528\u5F02\u5F62\u8F6E\u5ED3`);
+              }
+            } else if (maxArea < bboxArea * OUTLINE_MIN_AREA_RATIO && (shapes.length > OUTLINE_SHAPE_COUNT_LIMIT || forcedCount2 / Math.max(1, shapes.length) > OUTLINE_FORCED_RATIO_LIMIT)) {
+              finalShapes = [fallbackShape];
+              const forcedRatio = forcedCount2 / Math.max(1, shapes.length);
+              debugWarn(`[Outline] \u8F6E\u5ED3\u788E\u7247\u5316(\u9762\u79EF=${maxArea.toFixed(2)}mm\xB2\uFF0C\u5F62\u72B6\u6570=${shapes.length}\uFF0C\u5F3A\u5236\u95ED\u5408\u6BD4=${forcedRatio.toFixed(2)})\uFF0C\u4F7F\u7528${fallbackType}\u515C\u5E95`);
+            } else {
+              const localTotalArea = shapes.reduce((acc, s) => acc + Math.abs(THREE2.ShapeUtils.area(s.getPoints())), 0);
+              if (localTotalArea < bboxArea * OUTLINE_TOTAL_AREA_RATIO) {
+                finalShapes = [fallbackShape];
+                debugLog(`[Outline] \u603B\u9762\u79EF\u8FC7\u5C0F\uFF0C\u4F7F\u7528${fallbackType}\u515C\u5E95`);
+              }
+            }
+          }
+          const usedBboxSolid = fallbackShape && finalShapes.length === 1 && finalShapes[0] === fallbackShape;
+          usedBboxOutlineFallback = usedBboxSolid;
+          this.renderOutlineBoard(finalShapes, !usedBboxSolid);
+          hasOutline = true;
+        }
+      } else if (outlineStrokes.length > 0) {
+        const strokeBboxShape = this.buildBBoxShapeFromSegments(outlineStrokes);
+        if (strokeBboxShape) {
+          const allPoints = strokeBboxShape.getPoints().map((p) => new THREE2.Vector3(p.x, p.y, 0));
+          const bbox = new THREE2.Box3().setFromPoints(allPoints);
+          this.outlineBbox = bbox.clone();
+          debugLog(`[\u8F6E\u5ED3\u5C42] \u4F7F\u7528\u7EBF\u6BB5\u5916\u63A5\u77E9\u5F62\u4F5C\u4E3Abbox: ${bbox.getSize(new THREE2.Vector3()).x.toFixed(2)} x ${bbox.getSize(new THREE2.Vector3()).y.toFixed(2)}`);
+        }
+      } else {
+        debugWarn("[3D-new] \u8F6E\u5ED3\u5C42\u89E3\u6790\u5931\u8D25\uFF08\u65E0\u5F62\u72B6\u65E0\u7EBF\u6BB5\uFF09\uFF0C\u5C1D\u8BD5\u4ECE\u5176\u4ED6\u5C42\u8BA1\u7B97\u5916\u63A5\u77E9\u5F62\u4F5C\u4E3A\u57FA\u6750...");
+        const fallbackFilesForOutline = [...topMaskFiles, ...bottomMaskFiles, ...topCopperFiles, ...bottomCopperFiles];
+        if (fallbackFilesForOutline.length > 0) {
+          let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
+          let hasValidBounds = false;
+          for (const file of fallbackFilesForOutline) {
+            try {
+              const res = await GerberParser.parseFile(file, "#ffffff");
+              if (res && res.data && res.data.vertices && res.data.vertices.length > 0) {
+                let scale = 1;
+                if (res.units === "in" || res.units === "inch") {
+                  scale = 25.4;
+                }
+                for (let i = 0; i < res.data.vertices.length; i += 3) {
+                  const x = res.data.vertices[i] * scale;
+                  const y = -res.data.vertices[i + 1] * scale;
+                  if (x < minX) minX = x;
+                  if (x > maxX) maxX = x;
+                  if (y < minY) minY = y;
+                  if (y > maxY) maxY = y;
+                }
+                hasValidBounds = true;
+              }
+            } catch (e) {
+              debugWarn(`[3D-new] \u4ECE ${file.name} \u8BA1\u7B97\u8FB9\u754C\u5931\u8D25:`, e.message);
+            }
+          }
+          if (hasValidBounds && isFinite(minX) && isFinite(maxX) && isFinite(minY) && isFinite(maxY)) {
+            const width = maxX - minX;
+            const height = maxY - minY;
+            debugLog(`[3D-new] \u8F6E\u5ED3\u89E3\u6790\u5931\u8D25\u56DE\u9000\uFF1A\u8BA1\u7B97\u5F97\u5230\u5916\u63A5\u77E9\u5F62: ${width.toFixed(2)} x ${height.toFixed(2)}`);
+            const padding = Math.max(width, height) * 0.02;
+            const rectShape = new THREE2.Shape();
+            rectShape.moveTo(minX - padding, minY - padding);
+            rectShape.lineTo(maxX + padding, minY - padding);
+            rectShape.lineTo(maxX + padding, maxY + padding);
+            rectShape.lineTo(minX - padding, maxY + padding);
+            rectShape.lineTo(minX - padding, minY - padding);
+            this.renderOutlineBoard([rectShape], false);
+            hasOutline = true;
+            const bboxPoints = rectShape.getPoints().map((p) => new THREE2.Vector3(p.x, p.y, 0));
+            this.outlineBbox = new THREE2.Box3().setFromPoints(bboxPoints);
+          }
+        }
+      }
+    } else {
+      debugWarn("[3D-new] \u672A\u627E\u5230\u8F6E\u5ED3\u5C42\u6587\u4EF6\uFF0C\u5C1D\u8BD5\u4ECE\u5176\u4ED6\u5C42\u8BA1\u7B97\u5916\u63A5\u77E9\u5F62\u4F5C\u4E3A\u57FA\u6750...");
+      const fallbackFiles = [...topMaskFiles, ...bottomMaskFiles, ...topCopperFiles, ...bottomCopperFiles];
+      if (fallbackFiles.length > 0) {
+        let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
+        let hasValidBounds = false;
+        for (const file of fallbackFiles) {
+          try {
+            const res = await GerberParser.parseFile(file, "#ffffff");
+            if (res && res.data && res.data.vertices && res.data.vertices.length > 0) {
+              let scale = 1;
+              if (res.units === "in" || res.units === "inch") {
+                scale = 25.4;
+              }
+              for (let i = 0; i < res.data.vertices.length; i += 3) {
+                const x = res.data.vertices[i] * scale;
+                const y = -res.data.vertices[i + 1] * scale;
+                if (x < minX) minX = x;
+                if (x > maxX) maxX = x;
+                if (y < minY) minY = y;
+                if (y > maxY) maxY = y;
+              }
+              hasValidBounds = true;
+              debugLog(`[3D-new] \u4ECE ${file.name} \u63D0\u53D6\u8FB9\u754C: minX=${minX.toFixed(2)}, maxX=${maxX.toFixed(2)}, minY=${minY.toFixed(2)}, maxY=${maxY.toFixed(2)}`);
+            }
+          } catch (e) {
+            debugWarn(`[3D-new] \u4ECE ${file.name} \u8BA1\u7B97\u8FB9\u754C\u5931\u8D25:`, e.message);
+          }
+        }
+        if (hasValidBounds && isFinite(minX) && isFinite(maxX) && isFinite(minY) && isFinite(maxY)) {
+          const width = maxX - minX;
+          const height = maxY - minY;
+          const centerX = (minX + maxX) / 2;
+          const centerY = (minY + maxY) / 2;
+          debugLog(`[3D-new] \u8BA1\u7B97\u5F97\u5230\u5916\u63A5\u77E9\u5F62: ${width.toFixed(2)} x ${height.toFixed(2)}, \u4E2D\u5FC3=(${centerX.toFixed(2)}, ${centerY.toFixed(2)})`);
+          const padding = Math.max(width, height) * 0.02;
+          const rectShape = new THREE2.Shape();
+          rectShape.moveTo(minX - padding, minY - padding);
+          rectShape.lineTo(maxX + padding, minY - padding);
+          rectShape.lineTo(maxX + padding, maxY + padding);
+          rectShape.lineTo(minX - padding, maxY + padding);
+          rectShape.lineTo(minX - padding, minY - padding);
+          this.renderOutlineBoard([rectShape], false);
+          hasOutline = true;
+        } else {
+          debugWarn("[3D-new] \u65E0\u6CD5\u8BA1\u7B97\u6709\u6548\u8FB9\u754C");
+        }
+      }
+      if (!hasOutline) {
+        debugWarn("[3D-new] \u65E0\u6CD5\u4ECE\u4EFB\u4F55\u5C42\u63D0\u53D6\u8F6E\u5ED3\uFF0C\u8DF3\u8FC7\u57FA\u6750\u6E32\u67D3");
+        BOARD_THICKNESS = 1.6;
+        this.clearScene();
+        if (topSilkFiles.length > 0) {
+          fallbackLayerForCamera = { type: "GTO", files: topSilkFiles };
+        } else if (topCopperFiles.length > 0) {
+          fallbackLayerForCamera = { type: "GTL", files: topCopperFiles };
+        }
+      }
+    }
+    if (outlineStrokes.length > 0) {
+      const MAX_STROKES_FOR_BORDER = 2e5;
+      if (outlineStrokes.length > MAX_STROKES_FOR_BORDER) {
+        debugWarn(`[Outline] \u7EBF\u6BB5\u6570\u91CF\u8FC7\u591A(${outlineStrokes.length})\uFF0C\u8DF3\u8FC7\u9ED1\u8272\u63CF\u8FB9\u4EE5\u907F\u514D\u6027\u80FD\u95EE\u9898`);
+      } else if (usedBboxOutlineFallback) {
+        BOARD_THICKNESS = BOARD_THICKNESS || 1.6;
+        const zTop = BOARD_THICKNESS / 2 + 0.05;
+        const zBottom = -BOARD_THICKNESS / 2 - 0.05 + 1e-3;
+        this.renderOutlineStrokes(outlineStrokes, 0.1, COLORS.OUTLINE_EDGE, zTop);
+        this.renderOutlineStrokes(outlineStrokes, 0.1, COLORS.OUTLINE_EDGE, zBottom);
+      } else if (!hasOutline) {
+        BOARD_THICKNESS = BOARD_THICKNESS || 1.6;
+        const zTop = BOARD_THICKNESS / 2 + 0.05;
+        const zBottom = -BOARD_THICKNESS / 2 - 0.05 + 1e-3;
+        this.renderOutlineStrokes(outlineStrokes, 0.1, COLORS.OUTLINE_EDGE, zTop);
+        this.renderOutlineStrokes(outlineStrokes, 0.1, COLORS.OUTLINE_EDGE, zBottom);
+        hasOutline = true;
+      }
+    }
+    const endTimeOutline = performance.now();
+    console.log(`[\u6027\u80FD] \u8F6E\u5ED3\u5C42\u6E32\u67D3\u5B8C\u6210\uFF0C\u8017\u65F6: ${(endTimeOutline - startTimeOutline).toFixed(2)}ms`);
+    console.log("[\u6027\u80FD] \u5F00\u59CB\u6E32\u67D3\u5176\u4ED6\u56FE\u5C42...");
+    const startTimeOtherLayers = performance.now();
+    console.log(
+      `[3D-new] \u5F00\u59CB\u6E32\u67D3\u5176\u4ED6\u56FE\u5C42\uFF0C\u6587\u4EF6\u5206\u7EC4\u60C5\u51B5:`,
+      `\u8F6E\u5ED3: ${outlineFiles.length}`,
+      `\u9876\u94DC: ${topCopperFiles.length}`,
+      `\u5185\u5C42\u94DC: ${innerCopperFiles.length}`,
+      `\u5E95\u94DC: ${bottomCopperFiles.length}`,
+      `\u9876\u963B\u710A: ${topMaskFiles.length}`,
+      `\u5E95\u963B\u710A: ${bottomMaskFiles.length}`,
+      `\u9876\u4E1D\u5370: ${topSilkFiles.length}`,
+      `\u5E95\u4E1D\u5370: ${bottomSilkFiles.length}`,
+      `\u94BB\u5B54: ${drillFiles.length}`
+    );
+    const parseLayer = async (file) => {
+      const res = await GerberParser.parseFile(file, "#ffffff");
+      return res;
+    };
+    const processLayerGroup = async (files, renderer, z, isTop) => {
+      for (const file of files) {
+        try {
+          console.log(`[3D-new] \u6B63\u5728\u89E3\u6790\u6587\u4EF6: ${file.name}`);
+          const res = await parseLayer(file);
+          if (res && res.data) {
+            console.log(`[3D-new] \u89E3\u6790\u6210\u529F: ${file.name}, \u5355\u4F4D: ${res.units}`);
+            let scale = 1;
+            if (res.units === "in" || res.units === "inch") {
+              scale = 25.4;
+            }
+            renderer.call(this, [res], z, isTop, scale);
+          } else {
+            console.warn(`[3D-new] \u89E3\u6790\u5931\u8D25\u6216\u65E0\u6570\u636E: ${file.name}`);
+          }
+        } catch (e) {
+          console.error(`[3D-new] \u89E3\u6790\u56FE\u5C42\u51FA\u9519: ${file.name}`, e);
+          console.error(`[3D-new] \u9519\u8BEF\u5806\u6808:`, e.stack);
+        }
+      }
+    };
+    const halfThick = BOARD_THICKNESS / 2;
+    const layerSpacing = 0.05;
+    const zTopCu = halfThick + layerSpacing;
+    const zBotCu = -halfThick - layerSpacing;
+    await processLayerGroup(topCopperFiles, this.renderCopperLayer, zTopCu, true);
+    innerCopperFiles.sort((a, b) => {
+      const sa = getLayerType(a.name) || "";
+      const sb = getLayerType(b.name) || "";
+      const ma = sa.match(/^SIG(\d+)$/i);
+      const mb = sb.match(/^SIG(\d+)$/i);
+      return (ma ? parseInt(ma[1], 10) : 0) - (mb ? parseInt(mb[1], 10) : 0);
+    });
+    const nInner = innerCopperFiles.length;
+    for (let i = 0; i < nInner; i++) {
+      const t = (i + 1) / (nInner + 1);
+      const zInner = zTopCu - t * (zTopCu - zBotCu);
+      await processLayerGroup([innerCopperFiles[i]], this.renderCopperLayer, zInner, zInner >= 0);
+    }
+    await processLayerGroup(bottomCopperFiles, this.renderCopperLayer, zBotCu, false);
+    await processLayerGroup(topMaskFiles, this.renderMaskLayer, halfThick + layerSpacing * 2, true);
+    await processLayerGroup(bottomMaskFiles, this.renderMaskLayer, -halfThick - layerSpacing * 2, false);
+    await processLayerGroup(topPasteFiles, this.renderPasteLayer, halfThick + layerSpacing * 2.5, true);
+    await processLayerGroup(bottomPasteFiles, this.renderPasteLayer, -halfThick - layerSpacing * 2.5, false);
+    await processLayerGroup(topSilkFiles, this.renderSilkscreenLayer, halfThick + layerSpacing * 3, true);
+    await processLayerGroup(bottomSilkFiles, this.renderSilkscreenLayer, -halfThick - layerSpacing * 3, false);
+    await this.renderPhoFiles(gerberFiles, halfThick, layerSpacing);
+    let drillRefBbox = null;
+    if (this.outlineBbox && !this.outlineBbox.isEmpty()) {
+      drillRefBbox = this.outlineBbox.clone();
+    } else if (this.baseGroup.children.length > 0) {
+      drillRefBbox = new THREE2.Box3().setFromObject(this.baseGroup);
+    }
+    const expandedDrillRefBbox = drillRefBbox ? drillRefBbox.clone().expandByScalar(20) : null;
+    for (const file of drillFiles) {
+      try {
+        const res = await parseLayer(file);
+        if (res && res.data) {
+          let scale = 1;
+          if (res.units === "in" || res.units === "inch") {
+            scale = 25.4;
+          }
+          if (expandedDrillRefBbox) {
+            debugLog(`[Drill] \u5904\u7406 ${file.name}...`);
+            const fixResult = this.fixDrillLayerAlignment(res.data, scale, drillRefBbox);
+            scale = fixResult.scale;
+            if (!fixResult.success || !fixResult.bbox) {
+              debugWarn(`[Drill] ${file.name} \u4FEE\u6B63\u5931\u8D25\uFF0C\u8DF3\u8FC7\u6E32\u67D3`);
+              continue;
+            }
+            const drillBbox = fixResult.bbox;
+            if (!this.validateDrillBbox(drillBbox, drillRefBbox, expandedDrillRefBbox, file.name)) {
+              continue;
+            }
+          }
+          this.renderDrillLayer([res.data], scale);
+        }
+      } catch (e) {
+        console.error(`Error processing drill ${file.name}:`, e);
+      }
+    }
+    const endTimeOtherLayers = performance.now();
+    console.log(`[\u6027\u80FD] \u5176\u4ED6\u56FE\u5C42\u6E32\u67D3\u5B8C\u6210\uFF0C\u8017\u65F6: ${(endTimeOtherLayers - startTimeOtherLayers).toFixed(2)}ms`);
+    console.log("[\u6027\u80FD] \u5F00\u59CB\u76F8\u673A\u9002\u914D...");
+    const startTimeCamera = performance.now();
+    if (this.baseGroup.children.length > 0) {
+      let finalBbox = null;
+      if (this.outlineBbox) {
+        if (this.outlineBbox.isEmpty()) {
+          debugLog("[Camera] outlineBbox\u5B58\u5728\u4F46\u4E3A\u7A7A");
+        } else {
+          const size = this.outlineBbox.getSize(new THREE2.Vector3());
+          const center = this.outlineBbox.getCenter(new THREE2.Vector3());
+          debugLog(`[Camera] outlineBbox\u72B6\u6001: \u5C3A\u5BF8=${size.x.toFixed(2)} x ${size.y.toFixed(2)}, \u4E2D\u5FC3=(${center.x.toFixed(2)}, ${center.y.toFixed(2)})`);
+        }
+      } else {
+        debugLog("[Camera] outlineBbox\u4E0D\u5B58\u5728");
+      }
+      if (this.outlineBbox && !this.outlineBbox.isEmpty()) {
+        finalBbox = this.outlineBbox;
+        const size = finalBbox.getSize(new THREE2.Vector3());
+        const center = finalBbox.getCenter(new THREE2.Vector3());
+        debugLog(`[Camera] \u4F7F\u7528\u8F6E\u5ED3\u5C42bbox\u8FDB\u884C\u81EA\u9002\u5E94: \u5C3A\u5BF8=${size.x.toFixed(2)} x ${size.y.toFixed(2)}, \u4E2D\u5FC3=(${center.x.toFixed(2)}, ${center.y.toFixed(2)})`);
+        this.fitCameraToBbox(finalBbox);
+      } else {
+        let gtlBbox = null;
+        let gblBbox = null;
+        if (topCopperFiles.length > 0) {
+          try {
+            const res = await parseLayer(topCopperFiles[0]);
+            if (res && res.data) {
+              gtlBbox = this.calculateLayerBbox([res.data]);
+            }
+          } catch (e) {
+          }
+        }
+        if (bottomCopperFiles.length > 0) {
+          try {
+            const res = await parseLayer(bottomCopperFiles[0]);
+            if (res && res.data) {
+              gblBbox = this.calculateLayerBbox([res.data]);
+            }
+          } catch (e) {
+          }
+        }
+        const referenceBbox2 = gtlBbox && !gtlBbox.isEmpty() ? gtlBbox : gblBbox && !gblBbox.isEmpty() ? gblBbox : null;
+        if (referenceBbox2) {
+          finalBbox = referenceBbox2;
+          const size = finalBbox.getSize(new THREE2.Vector3());
+          const center = finalBbox.getCenter(new THREE2.Vector3());
+          const layerName = gtlBbox && !gtlBbox.isEmpty() ? "GTL" : "GBL";
+          debugLog(`[Camera] \u65E0\u8F6E\u5ED3\u5C42\uFF0C\u4F7F\u7528${layerName}\u5C42bbox\u8FDB\u884C\u81EA\u9002\u5E94: \u5C3A\u5BF8=${size.x.toFixed(2)} x ${size.y.toFixed(2)}, \u4E2D\u5FC3=(${center.x.toFixed(2)}, ${center.y.toFixed(2)})`);
+          this.fitCameraToBbox(finalBbox);
+        } else if (fallbackLayerForCamera) {
+          try {
+            const res = await parseLayer(fallbackLayerForCamera.files[0]);
+            if (res && res.data) {
+              const bbox = this.calculateLayerBbox([res.data]);
+              if (bbox && !bbox.isEmpty()) {
+                finalBbox = bbox;
+                const size = finalBbox.getSize(new THREE2.Vector3());
+                const center = finalBbox.getCenter(new THREE2.Vector3());
+                debugLog(`[Camera] \u4F7F\u7528${fallbackLayerForCamera.type}\u5C42bbox\u8FDB\u884C\u81EA\u9002\u5E94: \u5C3A\u5BF8=${size.x.toFixed(2)} x ${size.y.toFixed(2)}, \u4E2D\u5FC3=(${center.x.toFixed(2)}, ${center.y.toFixed(2)})`);
+                this.fitCameraToBbox(finalBbox);
+              } else {
+                debugLog("[Camera] \u672A\u627E\u5230\u6709\u6548bbox\uFF0C\u4F7F\u7528\u6240\u6709\u56FE\u5C42\u8FDB\u884C\u81EA\u9002\u5E94");
+                this.fitCameraToObject(this.baseGroup);
+              }
+            } else {
+              debugLog("[Camera] \u672A\u627E\u5230\u6709\u6548bbox\uFF0C\u4F7F\u7528\u6240\u6709\u56FE\u5C42\u8FDB\u884C\u81EA\u9002\u5E94");
+              this.fitCameraToObject(this.baseGroup);
+            }
+          } catch (e) {
+            debugLog("[Camera] \u672A\u627E\u5230\u6709\u6548bbox\uFF0C\u4F7F\u7528\u6240\u6709\u56FE\u5C42\u8FDB\u884C\u81EA\u9002\u5E94");
+            this.fitCameraToObject(this.baseGroup);
+          }
+        } else {
+          debugLog("[Camera] \u672A\u627E\u5230\u6709\u6548bbox\uFF0C\u4F7F\u7528\u6240\u6709\u56FE\u5C42\u8FDB\u884C\u81EA\u9002\u5E94");
+          this.fitCameraToObject(this.baseGroup);
+        }
+      }
+      const endTimeCamera = performance.now();
+      console.log(`[\u6027\u80FD] \u76F8\u673A\u9002\u914D\u5B8C\u6210\uFF0C\u8017\u65F6: ${(endTimeCamera - startTimeCamera).toFixed(2)}ms`);
+      if (this.renderer && this.renderer.domElement) {
+        this.renderer.domElement.style.visibility = "visible";
+      }
+      const endTimeTotal = performance.now();
+      const totalProcessTime = (endTimeTotal - startTimeTotal) / 1e3;
+      console.log(`[\u6027\u80FD] ========== processFiles \u5B8C\u6210\uFF0C\u603B\u8017\u65F6: ${totalProcessTime.toFixed(2)}\u79D2 ==========`);
+      console.log(`[\u6027\u80FD] \u8BE6\u7EC6\u8017\u65F6\uFF1A\u89E3\u538B=${((endTimeExtract - startTimeExtract) / 1e3).toFixed(2)}\u79D2, \u5206\u7C7B=${((endTimeClassify - startTimeClassify) / 1e3).toFixed(2)}\u79D2, \u8F6E\u5ED3=${((endTimeOutline - startTimeOutline) / 1e3).toFixed(2)}\u79D2, \u5176\u4ED6\u56FE\u5C42=${((endTimeOtherLayers - startTimeOtherLayers) / 1e3).toFixed(2)}\u79D2, \u76F8\u673A=${((endTimeCamera - startTimeCamera) / 1e3).toFixed(2)}\u79D2`);
+      console.log(`[3D-new] \u6E32\u67D3\u5B8C\u6210\uFF0C\u573A\u666F\u4E2D\u5171\u6709 ${this.baseGroup.children.length} \u4E2A\u5BF9\u8C61`);
+    } else {
+      console.warn("[3D-new] \u6CA1\u6709\u6E32\u67D3\u4EFB\u4F55\u56FE\u5C42\uFF0CbaseGroup \u4E3A\u7A7A");
+      if (this.renderer && this.renderer.domElement) {
+        this.renderer.domElement.style.visibility = "visible";
+      }
+      const endTimeTotal = performance.now();
+      const totalProcessTime = (endTimeTotal - startTimeTotal) / 1e3;
+      console.log(`[\u6027\u80FD] ========== processFiles \u5B8C\u6210\uFF08\u65E0\u6E32\u67D3\uFF09\uFF0C\u603B\u8017\u65F6: ${totalProcessTime.toFixed(2)}\u79D2 ==========`);
+    }
+  }
+  clearScene() {
+    while (this.baseGroup.children.length) {
+      const obj = this.baseGroup.children.pop();
+      obj.geometry?.dispose?.();
+      obj.material?.dispose?.();
+    }
+  }
+  renderOutlineBoard(shapes, showEdges = true) {
+    this.clearScene();
+    const allPointsForBbox = [];
+    shapes.forEach((shape) => {
+      const points = shape.getPoints();
+      if (points && points.length > 0) {
+        allPointsForBbox.push(...points.map((p) => new THREE2.Vector3(p.x, p.y, 0)));
+      }
+    });
+    if (allPointsForBbox.length > 0) {
+      const bbox2 = new THREE2.Box3().setFromPoints(allPointsForBbox);
+      this.outlineBbox = bbox2.clone();
+      if (!this.outlineBbox.isEmpty()) {
+        const size2 = this.outlineBbox.getSize(new THREE2.Vector3());
+        const center = this.outlineBbox.getCenter(new THREE2.Vector3());
+        debugLog(`[\u8F6E\u5ED3\u5C42] \u8BBE\u7F6EoutlineBbox: \u5C3A\u5BF8=${size2.x.toFixed(2)} x ${size2.y.toFixed(2)}, \u4E2D\u5FC3=(${center.x.toFixed(2)}, ${center.y.toFixed(2)})`);
+      } else {
+        debugWarn("[\u8F6E\u5ED3\u5C42] outlineBbox\u4E3A\u7A7A\uFF0C\u53EF\u80FD\u65E0\u6CD5\u6B63\u786E\u81EA\u9002\u5E94");
+      }
+    }
+    const validShapes = shapes.filter((s) => {
+      const area = THREE2.ShapeUtils.area(s.getPoints());
+      return Math.abs(area) > 1e-3;
+    });
+    if (validShapes.length === 0) {
+      return;
+    }
+    const allPoints = [];
+    validShapes.forEach((shape) => {
+      allPoints.push(...shape.getPoints().map((p) => new THREE2.Vector3(p.x, p.y, 0)));
+    });
+    const bbox = new THREE2.Box3().setFromPoints(allPoints);
+    const size = new THREE2.Vector3();
+    bbox.getSize(size);
+    const maxDim = Math.max(size.x, size.y);
+    if (maxDim < 20) {
+      BOARD_THICKNESS = 0.063 * 25.4;
+      BOARD_THICKNESS = 1.6;
+    } else {
+      BOARD_THICKNESS = 1.6;
+    }
+    const material = this.getCachedMaterial(
+      "outline-fill",
+      () => new THREE2.MeshPhysicalMaterial({
+        color: COLORS.OUTLINE,
+        metalness: 0,
+        roughness: 0.8,
+        side: THREE2.DoubleSide
+      })
+    );
+    const edgeMat = this.getCachedMaterial(
+      "outline-edge",
+      () => new THREE2.MeshBasicMaterial({ color: COLORS.OUTLINE_EDGE, side: THREE2.DoubleSide })
+    );
+    const createThickLineLoop = (points, z, width = 0.1) => {
+      if (points.length < 2) return null;
+      const first = points[0];
+      const last = points[points.length - 1];
+      const isClosed = Math.hypot(first.x - last.x, first.y - last.y) < 1e-4;
+      const workingPoints = isClosed && points.length > 2 ? points.slice(0, -1) : points;
+      if (workingPoints.length < 2) return null;
+      const vertices = [];
+      const indices = [];
+      let baseIndex = 0;
+      for (let i = 0; i < workingPoints.length; i++) {
+        const p1 = workingPoints[i];
+        const p2 = workingPoints[(i + 1) % workingPoints.length];
+        const dx = p2.x - p1.x;
+        const dy = p2.y - p1.y;
+        const len = Math.sqrt(dx * dx + dy * dy);
+        if (len < 1e-6) continue;
+        const perpX = -dy / len * (width / 2);
+        const perpY = dx / len * (width / 2);
+        const p1x = p1.x + perpX;
+        const p1y = p1.y + perpY;
+        const p2x = p1.x - perpX;
+        const p2y = p1.y - perpY;
+        const p3x = p2.x - perpX;
+        const p3y = p2.y - perpY;
+        const p4x = p2.x + perpX;
+        const p4y = p2.y + perpY;
+        vertices.push(p1x, p1y, z);
+        vertices.push(p2x, p2y, z);
+        vertices.push(p3x, p3y, z);
+        vertices.push(p4x, p4y, z);
+        indices.push(baseIndex, baseIndex + 1, baseIndex + 2);
+        indices.push(baseIndex, baseIndex + 2, baseIndex + 3);
+        baseIndex += 4;
+      }
+      if (vertices.length === 0) return null;
+      const geo = new THREE2.BufferGeometry();
+      geo.setAttribute("position", new THREE2.Float32BufferAttribute(vertices, 3));
+      geo.setIndex(indices);
+      geo.computeVertexNormals();
+      return new THREE2.Mesh(geo, edgeMat);
+    };
+    const triangulateWithEarcut = (shape) => {
+      const points = shape.getPoints();
+      if (points.length < 3) return null;
+      const vertices = [];
+      for (const pt of points) {
+        vertices.push(pt.x, pt.y);
+      }
+      const holeIndices = [];
+      if (shape.holes && shape.holes.length > 0) {
+        for (const hole of shape.holes) {
+          const holePts = hole.getPoints();
+          if (holePts.length >= 3) {
+            holeIndices.push(vertices.length / 2);
+            for (const pt of holePts) {
+              vertices.push(pt.x, pt.y);
+            }
+          }
+        }
+      }
+      let triangleIndices;
+      try {
+        triangleIndices = earcut(vertices, holeIndices.length > 0 ? holeIndices : null, 2);
+      } catch (err) {
+        debugWarn("[Outline] earcut\u5931\u8D25:", err.message);
+        return null;
+      }
+      if (!triangleIndices || triangleIndices.length === 0) {
+        return null;
+      }
+      const topZ = BOARD_THICKNESS / 2;
+      const bottomZ = -BOARD_THICKNESS / 2;
+      const positions = [];
+      const indices = [];
+      const numVertices2D = vertices.length / 2;
+      for (let i = 0; i < numVertices2D; i++) {
+        const x = vertices[i * 2];
+        const y = vertices[i * 2 + 1];
+        positions.push(x, y, topZ);
+      }
+      for (let i = 0; i < numVertices2D; i++) {
+        const x = vertices[i * 2];
+        const y = vertices[i * 2 + 1];
+        positions.push(x, y, bottomZ);
+      }
+      for (let i = 0; i < triangleIndices.length; i += 3) {
+        indices.push(triangleIndices[i], triangleIndices[i + 1], triangleIndices[i + 2]);
+      }
+      for (let i = 0; i < triangleIndices.length; i += 3) {
+        const a = triangleIndices[i] + numVertices2D;
+        const b = triangleIndices[i + 1] + numVertices2D;
+        const c = triangleIndices[i + 2] + numVertices2D;
+        indices.push(a, c, b);
+      }
+      const outerPointCount = holeIndices.length > 0 ? holeIndices[0] : numVertices2D;
+      for (let i = 0; i < outerPointCount; i++) {
+        const next = (i + 1) % outerPointCount;
+        const topA = i;
+        const topB = next;
+        const bottomA = i + numVertices2D;
+        const bottomB = next + numVertices2D;
+        indices.push(topA, bottomA, topB);
+        indices.push(topB, bottomA, bottomB);
+      }
+      const geometry = new THREE2.BufferGeometry();
+      geometry.setAttribute("position", new THREE2.Float32BufferAttribute(positions, 3));
+      geometry.setIndex(indices);
+      geometry.computeVertexNormals();
+      return geometry;
+    };
+    const MAX_POINTS_FOR_EXTRUDE = 500;
+    const MAX_POINTS_FOR_EARCUT = 5e3;
+    let renderedCount = 0;
+    let skippedComplexCount = 0;
+    validShapes.forEach((shape) => {
+      try {
+        const points = shape.getPoints();
+        if (points.length <= MAX_POINTS_FOR_EXTRUDE) {
+          const geo = new THREE2.ExtrudeGeometry(shape, { depth: BOARD_THICKNESS, bevelEnabled: false });
+          geo.translate(0, 0, -BOARD_THICKNESS / 2);
+          const mesh = new THREE2.Mesh(geo, material);
+          this.baseGroup.add(mesh);
+          renderedCount++;
+        } else if (points.length <= MAX_POINTS_FOR_EARCUT) {
+          const geo = triangulateWithEarcut(shape);
+          if (geo) {
+            const mesh = new THREE2.Mesh(geo, material);
+            this.baseGroup.add(mesh);
+            renderedCount++;
+            debugLog(`[Outline] \u4F7F\u7528earcut\u6E32\u67D3\u590D\u6742\u5F62\u72B6\uFF08${points.length}\u70B9\uFF09`);
+          } else {
+            skippedComplexCount++;
+          }
+        } else {
+          debugWarn(`[Outline] \u5F62\u72B6\u8FC7\u4E8E\u590D\u6742\uFF08${points.length}\u70B9 > ${MAX_POINTS_FOR_EARCUT}\uFF09\uFF0C\u8DF3\u8FC7`);
+          skippedComplexCount++;
+          return;
+        }
+        if (showEdges && !shape.userData?.forcedClose) {
+          const EDGE_Z_TOP = BOARD_THICKNESS / 2 + 0.05;
+          const EDGE_Z_BOTTOM = -BOARD_THICKNESS / 2 - 0.05 + 1e-3;
+          const pts2 = shape.getPoints();
+          const thickTop = createThickLineLoop(pts2, EDGE_Z_TOP);
+          const thickBottom = createThickLineLoop(pts2, EDGE_Z_BOTTOM);
+          if (thickTop) this.baseGroup.add(thickTop);
+          if (thickBottom) this.baseGroup.add(thickBottom);
+        }
+        if (showEdges && shape.holes && shape.holes.length > 0) {
+          shape.holes.forEach((path) => {
+            const EDGE_Z_TOP = BOARD_THICKNESS / 2 + 0.05;
+            const EDGE_Z_BOTTOM = -BOARD_THICKNESS / 2 - 0.05 + 1e-3;
+            const hPts2 = path.getPoints();
+            const thickHoleTop = createThickLineLoop(hPts2, EDGE_Z_TOP);
+            const thickHoleBottom = createThickLineLoop(hPts2, EDGE_Z_BOTTOM);
+            if (thickHoleTop) this.baseGroup.add(thickHoleTop);
+            if (thickHoleBottom) this.baseGroup.add(thickHoleBottom);
+          });
+        }
+      } catch (err) {
+        debugWarn(`[Outline] \u6E32\u67D3\u5931\u8D25:`, err.message);
+        skippedComplexCount++;
+      }
+    });
+    if (skippedComplexCount > 0) {
+      debugWarn(`[Outline] \u8DF3\u8FC7\u4E86 ${skippedComplexCount} \u4E2A\u5F62\u72B6`);
+    }
+    if (renderedCount === 0 && validShapes.length > 0) {
+      debugWarn("[Outline] \u6240\u6709\u5F62\u72B6\u90FD\u88AB\u8DF3\u8FC7\uFF0C\u4F7F\u7528bbox\u515C\u5E95");
+      const bboxShape = this.buildBBoxShapeFromShapes(validShapes);
+      if (bboxShape) {
+        try {
+          const geo = new THREE2.ExtrudeGeometry(bboxShape, { depth: BOARD_THICKNESS, bevelEnabled: false });
+          geo.translate(0, 0, -BOARD_THICKNESS / 2);
+          const mesh = new THREE2.Mesh(geo, material);
+          this.baseGroup.add(mesh);
+        } catch (err) {
+          debugWarn("[Outline] bbox\u515C\u5E95\u4E5F\u5931\u8D25:", err.message);
+        }
+      }
+    }
+  }
+  // 基于线段点集求凸包，生成单一 Shape 兜底
+  buildHullShapeFromSegments(segments) {
+    if (!segments || segments.length === 0) return null;
+    const pts = [];
+    for (const seg of segments) {
+      pts.push(new THREE2.Vector2(seg.start.x, seg.start.y));
+      pts.push(new THREE2.Vector2(seg.end.x, seg.end.y));
+    }
+    if (pts.length < 3) return null;
+    pts.sort((a, b) => a.x === b.x ? a.y - b.y : a.x - b.x);
+    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 p of pts) {
+      while (lower.length >= 2 && cross(lower[lower.length - 2], lower[lower.length - 1], p) <= 0) {
+        lower.pop();
+      }
+      lower.push(p);
+    }
+    const upper = [];
+    for (let i = pts.length - 1; i >= 0; i--) {
+      const p = pts[i];
+      while (upper.length >= 2 && cross(upper[upper.length - 2], upper[upper.length - 1], p) <= 0) {
+        upper.pop();
+      }
+      upper.push(p);
+    }
+    upper.pop();
+    lower.pop();
+    const hull = lower.concat(upper);
+    if (hull.length < 3) return null;
+    const shape = new THREE2.Shape();
+    shape.moveTo(hull[0].x, hull[0].y);
+    for (let i = 1; i < hull.length; i++) shape.lineTo(hull[i].x, hull[i].y);
+    shape.closePath();
+    return shape;
+  }
+  // 基于已存在的闭合 shapes 计算外接矩形，作为兜底
+  buildBBoxShapeFromShapes(shapes) {
+    if (!shapes || shapes.length === 0) return null;
+    let minX = Infinity, maxX = -Infinity, minY = Infinity, maxY = -Infinity;
+    for (const s of shapes) {
+      const pts = s.getPoints();
+      for (const p of pts) {
+        if (p.x < minX) minX = p.x;
+        if (p.x > maxX) maxX = p.x;
+        if (p.y < minY) minY = p.y;
+        if (p.y > maxY) maxY = p.y;
+      }
+    }
+    if (!isFinite(minX) || !isFinite(maxX) || !isFinite(minY) || !isFinite(maxY)) return null;
+    const shape = new THREE2.Shape();
+    shape.moveTo(minX, minY);
+    shape.lineTo(maxX, minY);
+    shape.lineTo(maxX, maxY);
+    shape.lineTo(minX, maxY);
+    shape.closePath();
+    return shape;
+  }
+  // 基于线段集合计算外接矩形，用于兜底渲染和相机适配
+  buildBBoxShapeFromSegments(segments) {
+    if (!segments || segments.length === 0) return null;
+    let minX = Infinity, maxX = -Infinity, minY = Infinity, maxY = -Infinity;
+    for (const seg of segments) {
+      if (seg.start.x < minX) minX = seg.start.x;
+      if (seg.start.x > maxX) maxX = seg.start.x;
+      if (seg.start.y < minY) minY = seg.start.y;
+      if (seg.start.y > maxY) maxY = seg.start.y;
+      if (seg.end.x < minX) minX = seg.end.x;
+      if (seg.end.x > maxX) maxX = seg.end.x;
+      if (seg.end.y < minY) minY = seg.end.y;
+      if (seg.end.y > maxY) maxY = seg.end.y;
+    }
+    if (!isFinite(minX) || !isFinite(maxX) || !isFinite(minY) || !isFinite(maxY)) return null;
+    const shape = new THREE2.Shape();
+    shape.moveTo(minX, minY);
+    shape.lineTo(maxX, minY);
+    shape.lineTo(maxX, maxY);
+    shape.lineTo(minX, maxY);
+    shape.closePath();
+    return shape;
+  }
+  // 兜底：用线段直接画轮廓（G01/G02/G03 离散后），不做布尔运算
+  renderOutlineStrokes(segments, lineWidth = 0.1, color = COLORS.OUTLINE_EDGE, zOverride = null) {
+    if (!segments || segments.length === 0) return;
+    const points = [];
+    segments.forEach((seg) => {
+      points.push(new THREE2.Vector3(seg.start.x, seg.start.y, 0));
+      points.push(new THREE2.Vector3(seg.end.x, seg.end.y, 0));
+    });
+    if (points.length > 0) {
+      const bbox = new THREE2.Box3().setFromPoints(points);
+      if (!this.outlineBbox || this.outlineBbox.isEmpty()) {
+        this.outlineBbox = bbox.clone();
+      }
+    }
+    const key = `outline-stroke-${color.toString(16)}-${lineWidth}`;
+    const edgeMat = this.getCachedMaterial(
+      key,
+      () => new THREE2.MeshBasicMaterial({ color, side: THREE2.DoubleSide })
+    );
+    const LINE_WIDTH = lineWidth;
+    const vertices = [];
+    const indices = [];
+    let baseIndex = 0;
+    const z = typeof zOverride === "number" ? zOverride : BOARD_THICKNESS / 2 + 0.05;
+    for (const seg of segments) {
+      const x1 = seg.start.x;
+      const y1 = seg.start.y;
+      const x2 = seg.end.x;
+      const y2 = seg.end.y;
+      const dx = x2 - x1;
+      const dy = y2 - y1;
+      const len = Math.sqrt(dx * dx + dy * dy);
+      if (len < 1e-6) continue;
+      const perpX = -dy / len * (LINE_WIDTH / 2);
+      const perpY = dx / len * (LINE_WIDTH / 2);
+      const p1x = x1 + perpX;
+      const p1y = y1 + perpY;
+      const p2x = x1 - perpX;
+      const p2y = y1 - perpY;
+      const p3x = x2 - perpX;
+      const p3y = y2 - perpY;
+      const p4x = x2 + perpX;
+      const p4y = y2 + perpY;
+      vertices.push(p1x, p1y, z);
+      vertices.push(p2x, p2y, z);
+      vertices.push(p3x, p3y, z);
+      vertices.push(p4x, p4y, z);
+      indices.push(baseIndex, baseIndex + 1, baseIndex + 2);
+      indices.push(baseIndex, baseIndex + 2, baseIndex + 3);
+      baseIndex += 4;
+    }
+    if (vertices.length === 0) return;
+    const geo = new THREE2.BufferGeometry();
+    geo.setAttribute("position", new THREE2.Float32BufferAttribute(vertices, 3));
+    geo.setIndex(indices);
+    geo.computeVertexNormals();
+    const mesh = new THREE2.Mesh(geo, edgeMat);
+    this.baseGroup.add(mesh);
+  }
+  // ==================== OTHER LAYER RENDERING ====================
+  renderCopperLayer(layers, z, isTop, scale = 1) {
+    const allShapes = [];
+    for (const layer of layers) {
+      const webglData = layer.data || layer;
+      if (webglData.lineStrips && webglData.vertices) {
+        for (const strip of webglData.lineStrips) {
+          if (strip.count < 2) continue;
+          const pts = [];
+          for (let j = 0; j < strip.count; j++) {
+            const ptr = (strip.start + j) * 3;
+            pts.push(new THREE2.Vector2(webglData.vertices[ptr], -webglData.vertices[ptr + 1]));
+          }
+          if (pts.length < 2) continue;
+          const first = pts[0];
+          const last = pts[pts.length - 1];
+          const isClosed = first.distanceTo(last) < 1e-3;
+          if (!isClosed) continue;
+          if (pts.length > 2 && first.distanceTo(last) < 1e-9) {
+            pts.pop();
+          }
+          if (pts.length < 3) continue;
+          const shape = new THREE2.Shape();
+          shape.moveTo(pts[0].x, pts[0].y);
+          for (let i = 1; i < pts.length; i++) {
+            shape.lineTo(pts[i].x, pts[i].y);
+          }
+          shape.closePath();
+          allShapes.push(shape);
+        }
+      }
+    }
+    if (allShapes.length === 0) return;
+    const shapesToRender = allShapes;
+    const shapesWithArea = shapesToRender.map((shape, idx) => {
+      const pts = shape.getPoints();
+      const area = Math.abs(THREE2.ShapeUtils.area(pts));
+      return { shape, area, idx, pointCount: pts.length };
+    });
+    shapesWithArea.sort((a, b) => b.area - a.area);
+    const maxArea = shapesWithArea[0]?.area || 0;
+    const filteredShapes = shapesWithArea;
+    if (filteredShapes.length === 0) return;
+    const shapes = filteredShapes.map((s) => s.shape);
+    const material = this.getCachedMaterial(
+      isTop ? "copper-top" : "copper-bot",
+      () => new THREE2.MeshPhysicalMaterial({
+        color: COLORS.COPPER,
+        metalness: 0.3,
+        roughness: 0.5,
+        side: THREE2.DoubleSide
+      })
+    );
+    this.renderShapesInChunks(shapes, material, z, scale, 2e3, isTop ? "GTL" : "GBL");
+  }
+  renderMaskLayer(layers, z, isTop, scale = 1) {
+    const shapes = this.collectStandardShapes(layers);
+    if (shapes.length === 0) return;
+    const material = this.getCachedMaterial(
+      "mask-opening",
+      () => new THREE2.MeshPhysicalMaterial({
+        color: COLORS.GOLD,
+        metalness: 0.8,
+        roughness: 0.2,
+        side: THREE2.DoubleSide
+      })
+    );
+    this.renderShapesInChunks(shapes, material, z + 1e-3, scale);
+  }
+  renderPasteLayer(layers, z, isTop, scale = 1) {
+    const shapes = this.collectStandardShapes(layers);
+    if (shapes.length === 0) return;
+    const material = this.getCachedMaterial(
+      "paste",
+      () => new THREE2.MeshPhysicalMaterial({
+        color: COLORS.PASTE,
+        // Gray color for solder paste
+        metalness: 0.3,
+        roughness: 0.7,
+        side: THREE2.DoubleSide
+      })
+    );
+    this.renderShapesInChunks(shapes, material, z, scale);
+  }
+  renderSilkscreenLayer(layers, z, isTop, scale = 1) {
+    const openPolylines = [];
+    const strokeLoops = [];
+    const fillShapes = [];
+    for (const layer of layers) {
+      const webglData = layer.data || layer;
+      if (webglData.lineStrips && webglData.vertices) {
+        for (const strip of webglData.lineStrips) {
+          if (strip.count < 2) continue;
+          const pts = [];
+          for (let j = 0; j < strip.count; j++) {
+            const ptr = (strip.start + j) * 3;
+            pts.push(new THREE2.Vector2(webglData.vertices[ptr], -webglData.vertices[ptr + 1]));
+          }
+          if (pts.length < 2) continue;
+          const first = pts[0];
+          const last = pts[pts.length - 1];
+          const isClosed = first.distanceTo(last) < 1e-3;
+          if (!isClosed) {
+            openPolylines.push(pts);
+            continue;
+          }
+          if (pts.length > 2 && first.distanceTo(last) < 1e-9) {
+            pts.pop();
+          }
+          if (pts.length < 3) continue;
+          if (strip.kind === "stroke") {
+            strokeLoops.push(pts);
+            continue;
+          }
+          if (strip.kind === "fill") {
+            const shape2 = new THREE2.Shape();
+            shape2.moveTo(pts[0].x, pts[0].y);
+            for (let i = 1; i < pts.length; i++) shape2.lineTo(pts[i].x, pts[i].y);
+            shape2.closePath();
+            fillShapes.push(shape2);
+            continue;
+          }
+          let minX = Infinity, maxX = -Infinity, minY = Infinity, maxY = -Infinity;
+          for (const p of pts) {
+            if (p.x < minX) minX = p.x;
+            if (p.x > maxX) maxX = p.x;
+            if (p.y < minY) minY = p.y;
+            if (p.y > maxY) maxY = p.y;
+          }
+          const w = maxX - minX;
+          const h = maxY - minY;
+          const cx = (minX + maxX) / 2;
+          const cy = (minY + maxY) / 2;
+          const rx = w / 2;
+          const ry = h / 2;
+          let ellipseLike = false;
+          if (rx > 1e-6 && ry > 1e-6) {
+            let sum = 0;
+            let sumSq = 0;
+            let n = 0;
+            for (const p of pts) {
+              const nx = (p.x - cx) / rx;
+              const ny = (p.y - cy) / ry;
+              const r = Math.sqrt(nx * nx + ny * ny);
+              if (!Number.isFinite(r)) continue;
+              sum += r;
+              sumSq += r * r;
+              n++;
+            }
+            if (n >= 8) {
+              const mean = sum / n;
+              const varR = Math.max(0, sumSq / n - mean * mean);
+              const std = Math.sqrt(varR);
+              ellipseLike = mean > 0.9 && mean < 1.1 && std < 0.03;
+            }
+          }
+          if (ellipseLike) {
+            strokeLoops.push(pts);
+            continue;
+          }
+          const shape = new THREE2.Shape();
+          shape.moveTo(pts[0].x, pts[0].y);
+          for (let i = 1; i < pts.length; i++) {
+            shape.lineTo(pts[i].x, pts[i].y);
+          }
+          shape.closePath();
+          fillShapes.push(shape);
+        }
+      }
+    }
+    if (fillShapes.length === 0 && strokeLoops.length === 0 && openPolylines.length === 0) return;
+    const material = this.getCachedMaterial(
+      "silkscreen",
+      () => new THREE2.MeshPhysicalMaterial({
+        color: COLORS.SILKSCREEN,
+        side: THREE2.DoubleSide
+      })
+    );
+    if (fillShapes.length > 0) {
+      const shapesWithHoles = this.processSilkscreenHoles(fillShapes);
+      if (shapesWithHoles.length > 0) {
+        this.renderShapesInChunks(shapesWithHoles, material, z, scale, 2e3, isTop ? "GTO" : "GBO");
+      }
+    }
+    const desiredWidthMm = 0.2;
+    const widthInLayerUnits = desiredWidthMm / (scale || 1);
+    const strokeShapes = [];
+    const allStrokePolylines = openPolylines.concat(strokeLoops);
+    for (const pts of allStrokePolylines) {
+      if (pts.length < 2) continue;
+      const first = pts[0];
+      const last = pts[pts.length - 1];
+      const isClosed = first.distanceTo(last) < 1e-3;
+      const n = isClosed && pts.length > 2 && first.distanceTo(last) < 1e-9 ? pts.length - 1 : pts.length;
+      const segCount = isClosed ? n : n - 1;
+      for (let i = 0; i < segCount; i++) {
+        const p1 = pts[i];
+        const p2 = isClosed && i === n - 1 ? pts[0] : pts[i + 1];
+        const dx = p2.x - p1.x;
+        const dy = p2.y - p1.y;
+        const len = Math.hypot(dx, dy);
+        if (len < 1e-8) continue;
+        const nx = -dy / len * (widthInLayerUnits / 2);
+        const ny = dx / len * (widthInLayerUnits / 2);
+        const s = new THREE2.Shape();
+        s.moveTo(p1.x + nx, p1.y + ny);
+        s.lineTo(p2.x + nx, p2.y + ny);
+        s.lineTo(p2.x - nx, p2.y - ny);
+        s.lineTo(p1.x - nx, p1.y - ny);
+        s.closePath();
+        strokeShapes.push(s);
+      }
+    }
+    if (strokeShapes.length > 0) {
+      const zOffset = isTop ? 1e-3 : -1e-3;
+      this.renderShapesInChunks(strokeShapes, material, z + zOffset, scale, 2e3, isTop ? "GTO" : "GBO");
+    }
+  }
+  renderDrillLayer(layers, scale = 1) {
+    const shapes = this.collectStandardShapes(layers);
+    if (shapes.length === 0) {
+      return;
+    }
+    const material = this.getCachedMaterial(
+      "drill",
+      () => new THREE2.MeshBasicMaterial({
+        color: COLORS.DRILL,
+        depthWrite: true,
+        depthTest: true
+      })
+    );
+    const extrusionSettings = {
+      depth: BOARD_THICKNESS + 0.35,
+      // Slightly longer than thickness for visibility, must exceed paste layer
+      bevelEnabled: false
+    };
+    const geo = new THREE2.ExtrudeGeometry(shapes, extrusionSettings);
+    geo.translate(0, 0, -BOARD_THICKNESS / 2 - 0.175);
+    const mesh = new THREE2.Mesh(geo, material);
+    mesh.scale.set(scale, scale, 1);
+    mesh.renderOrder = 10;
+    this.baseGroup.add(mesh);
+    debugLog(`[Drill Layer] \u63D0\u53D6\u5230 ${shapes.length} \u4E2A\u94BB\u5B54\u5F62\u72B6\uFF0Cscale=${scale}`);
+  }
+  /**
+   * 专门渲染 .pho 文件的函数
+   * 根据文件名前缀和数字识别图层类型，并调用对应的渲染函数
+   */
+  async renderPhoFiles(gerberFiles, halfThick, layerSpacing) {
+    const phoFiles = gerberFiles.filter((file) => {
+      const fileNameOnly = file.name.split(/[/\\]/).pop() || "";
+      const fileExtension = "." + fileNameOnly.split(".").pop().toUpperCase();
+      return fileExtension === ".PHO";
+    });
+    if (phoFiles.length === 0) return;
+    const buildPhoGroups = (files) => {
+      const groups = /* @__PURE__ */ new Map();
+      const add = (prefix, num) => {
+        if (!groups.has(prefix)) {
+          groups.set(prefix, { min: num });
+        } else {
+          groups.get(prefix).min = Math.min(groups.get(prefix).min, num);
+        }
+      };
+      files.forEach((f) => {
+        const nameOnly = f.name.split(/[/\\]/).pop() || "";
+        const upper = nameOnly.toUpperCase();
+        let prefix = null;
+        let num = 0;
+        if (upper.startsWith("SST")) {
+          prefix = "sst";
+          const m = upper.match(/^SST(\d+)/);
+          num = m ? parseInt(m[1], 10) : 0;
+        } else if (upper.startsWith("SMD")) {
+          prefix = "smd";
+          const m = upper.match(/^SMD(\d+)/);
+          num = m ? parseInt(m[1], 10) : 0;
+        } else if (upper.startsWith("SM")) {
+          prefix = "sm";
+          const m = upper.match(/^SM(\d+)/);
+          num = m ? parseInt(m[1], 10) : 0;
+        } else if (upper.startsWith("ART")) {
+          prefix = "art";
+          const m = upper.match(/^ART(\d+)/);
+          num = m ? parseInt(m[1], 10) : 0;
+        } else if (upper.startsWith("SSB")) {
+          prefix = "ssb";
+          num = 0;
+        } else if (upper.startsWith("DRL")) {
+          prefix = "drl";
+          num = 0;
+        } else if (upper.startsWith("DD")) {
+          prefix = "dd";
+          num = 0;
+        }
+        if (prefix) add(prefix, num);
+      });
+      return groups;
+    };
+    const phoGroups = buildPhoGroups(phoFiles);
+    const getPhoLayerType = (fileName) => {
+      const fileNameOnly = fileName.split(/[/\\]/).pop() || "";
+      const fileNameUpper = fileNameOnly.toUpperCase();
+      if (fileNameUpper.startsWith("SST")) return "GTO";
+      const pickByGroup = (prefix, topType, botType, defaultType = null) => {
+        const m = fileNameUpper.match(new RegExp(`^${prefix}(\\d+)`));
+        const num = m ? parseInt(m[1], 10) : 0;
+        const g = phoGroups.get(prefix.toLowerCase());
+        if (g) {
+          return num === g.min ? topType : botType;
+        }
+        return defaultType || topType;
+      };
+      if (fileNameUpper.startsWith("SMD")) {
+        return pickByGroup("SMD", "GTP", "GBP", "GTP");
+      }
+      if (fileNameUpper.startsWith("SM")) {
+        return pickByGroup("SM", "GTS", "GBS", "GTS");
+      }
+      if (fileNameUpper.startsWith("ART")) {
+        return pickByGroup("ART", "GTL", "GBL", "GTL");
+      }
+      if (fileNameUpper.startsWith("SSB")) return "GBO";
+      if (fileNameUpper.startsWith("DRL")) return "DRL";
+      return null;
+    };
+    for (const file of phoFiles) {
+      try {
+        const layerType = getPhoLayerType(file.name);
+        if (!layerType) continue;
+        const res = await GerberParser.parseFile(file, "#ffffff");
+        if (!res || !res.data) continue;
+        let scale = 1;
+        if (res.units === "in" || res.units === "inch") {
+          scale = 25.4;
+        }
+        switch (layerType) {
+          case "GTL":
+            this.renderCopperLayer([res.data], halfThick + layerSpacing, true, scale);
+            break;
+          case "GBL":
+            this.renderCopperLayer([res.data], -halfThick - layerSpacing, false, scale);
+            break;
+          case "GTS":
+            this.renderMaskLayer([res.data], halfThick + layerSpacing * 2, true, scale);
+            break;
+          case "GBS":
+            this.renderMaskLayer([res.data], -halfThick - layerSpacing * 2, false, scale);
+            break;
+          case "GTP":
+            this.renderPasteLayer([res.data], halfThick + layerSpacing * 2.5, true, scale);
+            break;
+          case "GBP":
+            this.renderPasteLayer([res.data], -halfThick - layerSpacing * 2.5, false, scale);
+            break;
+          case "GTO":
+            this.renderSilkscreenLayer([res], halfThick + layerSpacing * 3, true, scale);
+            break;
+          case "GBO":
+            this.renderSilkscreenLayer([res], -halfThick - layerSpacing * 3, false, scale);
+            break;
+          case "DRL":
+            this.renderDrillLayer([res.data], scale);
+            break;
+        }
+      } catch (e) {
+        console.error(`Error processing PHO file ${file.name}:`, e);
+      }
+    }
+  }
+  // ==================== HELPERS ====================
+  collectStandardShapes(layers) {
+    const shapes = [];
+    for (const layer of layers) {
+      const webglData = layer.data || layer;
+      if (webglData.lineStrips && webglData.vertices) {
+        for (const strip of webglData.lineStrips) {
+          if (strip.count < 2) continue;
+          const points = [];
+          for (let j = 0; j < strip.count; j++) {
+            const ptr = (strip.start + j) * 3;
+            points.push({
+              x: webglData.vertices[ptr],
+              y: -webglData.vertices[ptr + 1]
+              // Y轴翻转
+            });
+          }
+          if (points.length < 2) continue;
+          const first = points[0];
+          const last = points[points.length - 1];
+          const closeDist = Math.sqrt(
+            Math.pow(first.x - last.x, 2) + Math.pow(first.y - last.y, 2)
+          );
+          const isClosed = closeDist < 1e-3;
+          if (isClosed || points.length >= 4) {
+            const shape = new THREE2.Shape();
+            shape.moveTo(points[0].x, points[0].y);
+            for (let j = 1; j < points.length; j++) {
+              shape.lineTo(points[j].x, points[j].y);
+            }
+            if (!isClosed) {
+              shape.lineTo(points[0].x, points[0].y);
+            }
+            const area = Math.abs(THREE2.ShapeUtils.area(shape.getPoints()));
+            if (area > 1e-4) {
+              shapes.push(shape);
+            }
+          }
+        }
+      }
+      if (layer.children) {
+        const segments = [];
+        for (const child of layer.children) {
+          if (child.type === "imagePath" && child.segments) {
+            segments.push(...child.segments);
+          }
+        }
+        if (segments.length > 0) {
+          const stitched = this.buildShapesFromSegments(segments);
+          shapes.push(...stitched);
+        }
+      }
+    }
+    return shapes;
+  }
+  buildShapesFromSegments(segments) {
+    if (segments.length === 0) return [];
+    const pool = segments.map((s) => ({
+      start: new THREE2.Vector2(s.start[0], -s.start[1]),
+      // Flip Y for WebGL
+      end: new THREE2.Vector2(s.end[0], -s.end[1]),
+      // Flip Y
+      original: s,
+      used: false
+    }));
+    const shapes = [];
+    const EPSILON = 0.01;
+    const EPSILON_SQ = EPSILON * EPSILON;
+    while (true) {
+      const startSeg = pool.find((s) => !s.used);
+      if (!startSeg) break;
+      startSeg.used = true;
+      const currentPath = new THREE2.Shape();
+      currentPath.moveTo(startSeg.start.x, startSeg.start.y);
+      this.addSegmentToPath(currentPath, startSeg);
+      let currentPoint = startSeg.end;
+      let loopClosed = false;
+      let segmentCount = 0;
+      const MAX_SEGMENTS = 1e4;
+      while (!loopClosed && segmentCount < MAX_SEGMENTS) {
+        segmentCount++;
+        let nextSeg = null;
+        let minDistSq = EPSILON_SQ;
+        for (let i = 0; i < pool.length; i++) {
+          if (pool[i].used) continue;
+          const distSq = currentPoint.distanceToSquared(pool[i].start);
+          if (distSq < minDistSq) {
+            minDistSq = distSq;
+            nextSeg = pool[i];
+          }
+        }
+        if (!nextSeg) {
+          if (currentPoint.distanceToSquared(startSeg.start) < EPSILON_SQ) {
+            loopClosed = true;
+          } else {
+            break;
+          }
+        } else {
+          nextSeg.used = true;
+          this.addSegmentToPath(currentPath, nextSeg);
+          currentPoint = nextSeg.end;
+          if (currentPoint.distanceToSquared(startSeg.start) < EPSILON_SQ) {
+            loopClosed = true;
+          }
+        }
+      }
+      if (loopClosed) {
+        shapes.push(currentPath);
+      }
+    }
+    return shapes;
+  }
+  addSegmentToPath(path, seg) {
+    const s = seg.original;
+    if (s.type === "line") {
+      path.lineTo(seg.end.x, seg.end.y);
+    } else if (s.type === "arc") {
+      const cx = s.center[0];
+      const cy = -s.center[1];
+      const r = s.radius;
+      path.lineTo(seg.end.x, seg.end.y);
+    }
+  }
+  // --- Silkscreen helper: attach inner contours as holes to keep text counters hollow ---
+  processSilkscreenHoles(shapes) {
+    const items = shapes.map((s) => {
+      const points = s.getPoints();
+      if (!points || points.length < 3) return null;
+      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 area = Math.abs(THREE2.ShapeUtils.area(points));
+      if (!isFinite(area) || area <= 1e-6) return null;
+      const areaInMm2 = area * 645.16;
+      return { shape: s, points, minX, minY, maxX, maxY, area: areaInMm2, isHole: false };
+    }).filter(Boolean);
+    if (items.length === 0) return [];
+    items.sort((a, b) => b.area - a.area);
+    const roots = [];
+    for (let i = 0; i < items.length; i++) {
+      const child = items[i];
+      let parent = null;
+      for (let j = i - 1; j >= 0; j--) {
+        const potential = items[j];
+        if (child.minX >= potential.minX && child.maxX <= potential.maxX && child.minY >= potential.minY && child.maxY <= potential.maxY) {
+          if (this.isPointInPolygon(child.points[0], potential.points)) {
+            parent = potential;
+            break;
+          }
+        }
+      }
+      if (parent) {
+        const ratio = child.area / parent.area;
+        if (ratio > 0.9) {
+          parent = null;
+        }
+      }
+      if (parent) {
+        const ratio = child.area / parent.area;
+        let adaptiveMaxRatio;
+        if (child.area > 50) {
+          adaptiveMaxRatio = 0.45;
+        } else if (child.area > 10) {
+          adaptiveMaxRatio = 0.2;
+        } else if (child.area > 1) {
+          adaptiveMaxRatio = 0.65;
+        } else {
+          adaptiveMaxRatio = 0.9;
+        }
+        if (ratio < 5e-4) {
+          roots.push(child.shape);
+          continue;
+        }
+        if (ratio > adaptiveMaxRatio) {
+          console.log(`[3D\u5B54\u6D1E\u62D2\u7EDD] \u2717 \u5F62\u72B6\u9762\u79EF=${child.area.toFixed(2)}mm\xB2, ratio=${ratio.toFixed(4)} > maxRatio=${adaptiveMaxRatio.toFixed(2)}, \u7236\u9762\u79EF=${parent.area.toFixed(2)}mm\xB2`);
+          roots.push(child.shape);
+          continue;
+        }
+        if (parent.isHole) {
+          roots.push(child.shape);
+        } else {
+          parent.shape.holes.push(child.shape);
+          child.isHole = true;
+        }
+      } else {
+        roots.push(child.shape);
+      }
+    }
+    return roots;
+  }
+  isPointInPolygon(point, vs) {
+    const x = point.x, y = point.y;
+    let inside = false;
+    for (let i = 0, j = vs.length - 1; i < vs.length; j = i++) {
+      const xi = vs[i].x, yi = vs[i].y;
+      const xj = vs[j].x, yj = vs[j].y;
+      const intersect = yi > y !== yj > y && x < (xj - xi) * (y - yi) / (yj - yi || 1e-12) + xi;
+      if (intersect) inside = !inside;
+    }
+    return inside;
+  }
+  renderShapesInChunks(shapes, material, zPosition, scale = 1, chunkSize = 2e3, layerType = null) {
+    if (shapes.length === 0) return [];
+    const meshes = [];
+    let optimizedChunkSize = chunkSize;
+    if (shapes.length > 2e4) {
+      optimizedChunkSize = 200;
+    } else if (shapes.length > 1e4) {
+      optimizedChunkSize = 400;
+    } else if (shapes.length > 5e3) {
+      optimizedChunkSize = 800;
+    }
+    const useAsync = shapes.length > 3e3;
+    if (useAsync) {
+      this.renderShapesAsync(shapes, material, zPosition, scale, optimizedChunkSize, layerType);
+      return [];
+    } else {
+      for (let i = 0; i < shapes.length; i += optimizedChunkSize) {
+        const chunk = shapes.slice(i, i + optimizedChunkSize);
+        const geometry = new THREE2.ShapeGeometry(chunk, 3);
+        const mesh = new THREE2.Mesh(geometry, material);
+        mesh.position.z = zPosition;
+        mesh.scale.set(scale, scale, 1);
+        if (layerType) {
+          mesh.userData = { layerType };
+        }
+        this.baseGroup.add(mesh);
+        meshes.push(mesh);
+      }
+    }
+    return meshes;
+  }
+  renderShapesAsync(shapes, material, zPosition, scale, chunkSize, layerType = null) {
+    let index = 0;
+    const totalChunks = Math.ceil(shapes.length / chunkSize);
+    let renderedChunks = 0;
+    const renderNextChunk = () => {
+      if (index >= shapes.length) {
+        return;
+      }
+      const chunksPerFrame = 5;
+      for (let i = 0; i < chunksPerFrame && index < shapes.length; i++) {
+        const chunk = shapes.slice(index, index + chunkSize);
+        const geometry = new THREE2.ShapeGeometry(chunk, 3);
+        const mesh = new THREE2.Mesh(geometry, material);
+        mesh.position.z = zPosition;
+        mesh.scale.set(scale, scale, 1);
+        if (layerType) {
+          mesh.userData = { layerType };
+        }
+        this.baseGroup.add(mesh);
+        index += chunkSize;
+        renderedChunks++;
+      }
+      if (index < shapes.length) {
+        requestAnimationFrame(renderNextChunk);
+      }
+    };
+    renderNextChunk();
+  }
+  getCachedMaterial(key, creator) {
+    if (!this.materialCache.has(key)) {
+      this.materialCache.set(key, creator());
+    }
+    return this.materialCache.get(key);
+  }
+  fitCameraToObject(object) {
+    const box = new THREE2.Box3().setFromObject(object);
+    if (box.isEmpty()) return;
+    this.fitCameraToBbox(box);
+  }
+  fitCameraToBbox(box) {
+    if (box.isEmpty()) return;
+    const center = box.getCenter(new THREE2.Vector3());
+    const size = box.getSize(new THREE2.Vector3());
+    const maxDim = Math.max(size.x, size.y);
+    const fov = this.camera.fov * (Math.PI / 180);
+    let distance = maxDim / 2 / Math.tan(fov / 2);
+    distance *= 1.1;
+    this.camera.position.set(center.x, center.y, center.z + distance);
+    this.camera.near = distance / 100;
+    this.camera.far = distance * 100;
+    this.camera.updateProjectionMatrix();
+    this.controls.target.copy(center);
+    this.controls.update();
+  }
+  /**
+   * 检测并修正钻孔层的坐标缩放问题
+   * 
+   * 常见问题：
+   * - 10倍问题：mil被当作inch解析
+   * - 25.4倍问题：inch被当作mm解析
+   * 
+   * @param {Object} layerData - 钻孔层数据（包含vertices和lineStrips）
+   * @param {number} scale - 单位转换因子（inch -> mm 时为25.4）
+   * @param {THREE.Box3} referenceBbox - 参考层边界
+   * @returns {{ scale: number, bbox: THREE.Box3|null, success: boolean }}
+   */
+  fixDrillLayerAlignment(layerData, scale, referenceBbox) {
+    if (!layerData?.vertices || !referenceBbox) {
+      return { scale, bbox: null, success: false };
+    }
+    let drillBbox = this.calculateLayerBbox([layerData]);
+    if (!drillBbox || drillBbox.isEmpty()) {
+      return { scale, bbox: null, success: false };
+    }
+    drillBbox.min.multiplyScalar(scale);
+    drillBbox.max.multiplyScalar(scale);
+    const refSize = referenceBbox.getSize(new THREE2.Vector3());
+    const tolerance = 0.1;
+    const inRangeX = drillBbox.min.x >= referenceBbox.min.x - refSize.x * tolerance && drillBbox.max.x <= referenceBbox.max.x + refSize.x * tolerance;
+    const inRangeY = drillBbox.min.y >= referenceBbox.min.y - refSize.y * tolerance && drillBbox.max.y <= referenceBbox.max.y + refSize.y * tolerance;
+    if (inRangeX && inRangeY) {
+      debugLog("[Drill] \u5750\u6807\u5DF2\u5728\u8303\u56F4\u5185\uFF0C\u65E0\u9700\u4FEE\u6B63");
+      return { scale, bbox: drillBbox, success: true };
+    }
+    const drillSize = drillBbox.getSize(new THREE2.Vector3());
+    const avgSizeRatio = (drillSize.x / refSize.x + drillSize.y / refSize.y) / 2;
+    let scaleFix = 1;
+    if (avgSizeRatio > 5 && avgSizeRatio < 15) {
+      scaleFix = 10;
+    } else if (avgSizeRatio > 20 && avgSizeRatio < 30) {
+      scaleFix = 25.4;
+    } else if (avgSizeRatio > 1.5) {
+      scaleFix = avgSizeRatio;
+    }
+    if (scaleFix === 1) {
+      debugLog("[Drill] \u672A\u68C0\u6D4B\u5230\u5E38\u89C1\u7F29\u653E\u95EE\u9898");
+      return { scale, bbox: drillBbox, success: true };
+    }
+    debugLog(`[Drill] \u68C0\u6D4B\u5230${scaleFix.toFixed(1)}\u500D\u7F29\u653E\u95EE\u9898\uFF0C\u5F00\u59CB\u4FEE\u6B63...`);
+    const { vertices, lineStrips } = layerData;
+    if (lineStrips?.length > 0) {
+      this.applyDrillScaleFix(vertices, lineStrips, scale, scaleFix);
+    } else {
+      debugWarn("[Drill] \u7F3A\u5C11lineStrips\uFF0C\u5B54\u5F84\u4F1A\u88AB\u7F29\u653E");
+      for (let i = 0; i < vertices.length; i += 3) {
+        vertices[i] = vertices[i] * scale / scaleFix;
+        vertices[i + 1] = vertices[i + 1] * scale / scaleFix;
+      }
+    }
+    drillBbox = this.calculateLayerBbox([layerData]);
+    if (!drillBbox || drillBbox.isEmpty()) {
+      return { scale: 1, bbox: null, success: false };
+    }
+    debugLog(`[Drill] \u4FEE\u6B63\u540Ebbox: (${drillBbox.min.x.toFixed(2)}, ${drillBbox.min.y.toFixed(2)}) - (${drillBbox.max.x.toFixed(2)}, ${drillBbox.max.y.toFixed(2)})`);
+    return { scale: 1, bbox: drillBbox, success: true };
+  }
+  /**
+   * 应用缩放修正，只移动孔位中心，保持孔径不变
+   * 
+   * 原理：每个lineStrip代表一个钻孔圆，通过计算圆心位置并只平移顶点，
+   * 可以实现"缩放位置但保持孔径"的效果。
+   * 
+   * @param {Float32Array} vertices - 顶点数组
+   * @param {Array} lineStrips - 线段描述数组（每个代表一个圆）
+   * @param {number} scale - 单位转换因子（inch -> mm）
+   * @param {number} scaleFix - 缩放修正因子（如10.0表示除以10）
+   */
+  applyDrillScaleFix(vertices, lineStrips, scale, scaleFix) {
+    let processedCount = 0;
+    for (const strip of lineStrips) {
+      if (strip.count < 3) continue;
+      let sumX = 0, sumY = 0;
+      for (let i = 0; i < strip.count; i++) {
+        const idx = (strip.start + i) * 3;
+        sumX += vertices[idx];
+        sumY += vertices[idx + 1];
+      }
+      const centerX = sumX / strip.count * scale;
+      const centerY = -sumY / strip.count * scale;
+      const deltaX = centerX / scaleFix - centerX;
+      const deltaY = centerY / scaleFix - centerY;
+      for (let i = 0; i < strip.count; i++) {
+        const idx = (strip.start + i) * 3;
+        vertices[idx] = vertices[idx] * scale + deltaX;
+        vertices[idx + 1] = vertices[idx + 1] * scale - deltaY;
+      }
+      processedCount++;
+    }
+    debugLog(`[Drill] \u5DF2\u4FEE\u6B63 ${processedCount} \u4E2A\u94BB\u5B54\uFF0C\u5B54\u5F84\u4FDD\u6301\u4E0D\u53D8`);
+  }
+  /**
+   * 验证钻孔层边界是否在合理范围内
+   * 
+   * @param {THREE.Box3} drillBbox - 钻孔层边界
+   * @param {THREE.Box3} referenceBbox - 参考层边界
+   * @param {THREE.Box3} expandedReferenceBbox - 扩展后的参考层边界（含容差）
+   * @param {string} fileName - 文件名（用于日志）
+   * @returns {boolean} 是否通过验证
+   */
+  validateDrillBbox(drillBbox, referenceBbox, expandedReferenceBbox, fileName) {
+    if (!expandedReferenceBbox.intersectsBox(drillBbox)) {
+      debugWarn(`[Drill] ${fileName} \u4E0E\u677F\u5B50\u8303\u56F4\u65E0\u4EA4\u96C6\uFF08\u5BB9\u951920mm\uFF09\uFF0C\u8DF3\u8FC7\u6E32\u67D3`);
+      return false;
+    }
+    if (!referenceBbox) return true;
+    const refSize = referenceBbox.getSize(new THREE2.Vector3());
+    const drillSize = drillBbox.getSize(new THREE2.Vector3());
+    const maxRatio = 1.3;
+    const minRatio = 0.2;
+    if (drillSize.x > refSize.x * maxRatio || drillSize.y > refSize.y * maxRatio) {
+      debugWarn(`[Drill] ${fileName} \u94BB\u5B54\u8303\u56F4\u8FC7\u5927\uFF08>${maxRatio}x\uFF09\uFF0C\u8DF3\u8FC7\u6E32\u67D3`);
+      return false;
+    }
+    if (drillSize.x < refSize.x * minRatio && drillSize.y < refSize.y * minRatio) {
+      debugWarn(`[Drill] ${fileName} \u94BB\u5B54\u8303\u56F4\u8FC7\u5C0F\uFF08<${minRatio}x\uFF09\uFF0C\u8DF3\u8FC7\u6E32\u67D3`);
+      return false;
+    }
+    const centerRef = referenceBbox.getCenter(new THREE2.Vector3());
+    const centerDrill = drillBbox.getCenter(new THREE2.Vector3());
+    const maxDim = Math.max(refSize.x, refSize.y);
+    const centerThreshold = Math.max(maxDim * 0.15, 25);
+    const centerDist = centerRef.distanceTo(centerDrill);
+    const sizeRatioX = drillSize.x / Math.max(1e-9, refSize.x);
+    const sizeRatioY = drillSize.y / Math.max(1e-9, refSize.y);
+    const localized = Math.max(sizeRatioX, sizeRatioY) < 0.6;
+    if (!localized && centerDist > centerThreshold) {
+      debugWarn(`[Drill] ${fileName} \u4E2D\u5FC3\u504F\u79FB\u8FC7\u5927\uFF08${centerDist.toFixed(1)}mm\uFF09\uFF0C\u8DF3\u8FC7\u6E32\u67D3`);
+      return false;
+    }
+    return true;
+  }
+  /**
+   * 将线段拼接成THREE.Shape对象（用于多轮廓文件合并）
+   * @param {Array<{start:{x,y}, end:{x,y}}>} segments 线段数组
+   * @returns {Array<THREE.Shape>} 形状数组
+   */
+  stitchSegmentsToShapes3D(segments) {
+    if (!segments || segments.length === 0) return [];
+    let minX = Infinity, maxX = -Infinity, minY = Infinity, maxY = -Infinity;
+    for (const seg of segments) {
+      minX = Math.min(minX, seg.start.x, seg.end.x);
+      maxX = Math.max(maxX, seg.start.x, seg.end.x);
+      minY = Math.min(minY, seg.start.y, seg.end.y);
+      maxY = Math.max(maxY, seg.start.y, seg.end.y);
+    }
+    const boardSize = Math.max(maxX - minX, maxY - minY);
+    const TOLERANCE = boardSize > 100 ? 0.2 : boardSize > 50 ? 0.1 : 0.05;
+    const cellSize = TOLERANCE;
+    const grid = /* @__PURE__ */ new Map();
+    const getCell = (pt) => `${Math.floor(pt.x / cellSize)},${Math.floor(pt.y / cellSize)}`;
+    const poolItems = segments.map((s) => ({ seg: s, used: false }));
+    const addToGrid = (item) => {
+      const k1 = getCell(item.seg.start);
+      const k2 = getCell(item.seg.end);
+      if (!grid.has(k1)) grid.set(k1, []);
+      grid.get(k1).push(item);
+      if (k1 !== k2) {
+        if (!grid.has(k2)) grid.set(k2, []);
+        grid.get(k2).push(item);
+      }
+    };
+    poolItems.forEach(addToGrid);
+    const distanceTo = (p1, p2) => Math.sqrt((p1.x - p2.x) ** 2 + (p1.y - p2.y) ** 2);
+    const getCandidates = (pt) => {
+      const cx = Math.floor(pt.x / cellSize);
+      const cy = Math.floor(pt.y / cellSize);
+      const results = /* @__PURE__ */ new Set();
+      for (let dx = -1; dx <= 1; dx++) {
+        for (let dy = -1; dy <= 1; dy++) {
+          const k = `${cx + dx},${cy + dy}`;
+          const list = grid.get(k);
+          if (list) {
+            for (const item of list) results.add(item);
+          }
+        }
+      }
+      return results;
+    };
+    const chains = [];
+    for (const startItem of poolItems) {
+      if (startItem.used) continue;
+      startItem.used = true;
+      const chain = [startItem.seg.start, startItem.seg.end];
+      let tail = startItem.seg.end;
+      let head = startItem.seg.start;
+      let finding = true;
+      while (finding) {
+        finding = false;
+        const candidates = getCandidates(tail);
+        let bestNext = null;
+        let minDst = Infinity;
+        let isReverse = false;
+        for (const item of candidates) {
+          if (item.used) continue;
+          const d1 = distanceTo(item.seg.start, tail);
+          if (d1 < TOLERANCE && d1 < minDst) {
+            minDst = d1;
+            bestNext = item;
+            isReverse = false;
+          }
+          const d2 = distanceTo(item.seg.end, tail);
+          if (d2 < TOLERANCE && d2 < minDst) {
+            minDst = d2;
+            bestNext = item;
+            isReverse = true;
+          }
+        }
+        if (bestNext) {
+          bestNext.used = true;
+          if (isReverse) {
+            chain.push(bestNext.seg.start);
+            tail = bestNext.seg.start;
+          } else {
+            chain.push(bestNext.seg.end);
+            tail = bestNext.seg.end;
+          }
+          finding = true;
+        }
+      }
+      finding = true;
+      while (finding) {
+        finding = false;
+        const candidates = getCandidates(head);
+        let bestPrev = null;
+        let minDst = Infinity;
+        let isReverse = false;
+        for (const item of candidates) {
+          if (item.used) continue;
+          const d1 = distanceTo(item.seg.end, head);
+          if (d1 < TOLERANCE && d1 < minDst) {
+            minDst = d1;
+            bestPrev = item;
+            isReverse = false;
+          }
+          const d2 = distanceTo(item.seg.start, head);
+          if (d2 < TOLERANCE && d2 < minDst) {
+            minDst = d2;
+            bestPrev = item;
+            isReverse = true;
+          }
+        }
+        if (bestPrev) {
+          bestPrev.used = true;
+          if (isReverse) {
+            chain.unshift(bestPrev.seg.end);
+            head = bestPrev.seg.end;
+          } else {
+            chain.unshift(bestPrev.seg.start);
+            head = bestPrev.seg.start;
+          }
+          finding = true;
+        }
+      }
+      chains.push(chain);
+    }
+    const shapes = [];
+    const MIN_AREA = 0.01;
+    for (const chain of chains) {
+      if (chain.length < 3) continue;
+      const headPt = chain[0];
+      const tailPt = chain[chain.length - 1];
+      const isClosed = distanceTo(headPt, tailPt) < TOLERANCE;
+      if (!isClosed) continue;
+      let area = 0;
+      for (let i = 0; i < chain.length; i++) {
+        const p1 = chain[i];
+        const p2 = chain[(i + 1) % chain.length];
+        area += p1.x * p2.y - p2.x * p1.y;
+      }
+      area = Math.abs(area) / 2;
+      if (area < MIN_AREA) continue;
+      const shape = new THREE2.Shape();
+      shape.moveTo(chain[0].x, chain[0].y);
+      for (let i = 1; i < chain.length; i++) {
+        shape.lineTo(chain[i].x, chain[i].y);
+      }
+      shape.closePath();
+      shape.userData = { forcedClose: false, area };
+      shapes.push(shape);
+    }
+    return shapes;
+  }
+  calculateLayerBbox(layers) {
+    const allPoints = [];
+    for (const layer of layers) {
+      if (layer.lineStrips && layer.vertices) {
+        for (const strip of layer.lineStrips) {
+          for (let j = 0; j < strip.count; j++) {
+            const ptr = (strip.start + j) * 3;
+            allPoints.push(new THREE2.Vector3(
+              layer.vertices[ptr],
+              -layer.vertices[ptr + 1],
+              0
+            ));
+          }
+        }
+      }
+      if (layer.children) {
+        for (const child of layer.children) {
+          if (child.type === "imagePath" && child.segments) {
+            for (const seg of child.segments) {
+              allPoints.push(new THREE2.Vector3(seg.start[0], -seg.start[1], 0));
+              allPoints.push(new THREE2.Vector3(seg.end[0], -seg.end[1], 0));
+            }
+          }
+        }
+      }
+    }
+    if (allPoints.length === 0) return null;
+    return new THREE2.Box3().setFromPoints(allPoints);
+  }
+};
+window.onload = () => new Viewer3D();
+//# sourceMappingURL=gerber-3d-entry-DEHDBOO2.js.map