@yumiai/chat-widget 0.1.2 → 0.2.0

package/dist/gerber-2d-entry-OQ4SQRBY.js

@@ -0,0 +1,3950 @@
+import {
+  extractRar,
+  initUrlIdHandler,
+  parseUrlFileUrl,
+  parseUrlId,
+  require_lib
+} from "./chunk-7A4FY6FK.js";
+import {
+  __toESM
+} from "./chunk-7D4SUZUM.js";
+
+// src/components/jetPaveGerberViewer/src/viewer-src/2dPage/js/gerber-parser-direct.js
+import earcut from "earcut";
+var GerberDirectParser = class {
+  constructor(options = {}) {
+    this.vertices = [];
+    this.colors = [];
+    this.indices = [];
+    this.triangleIndices = [];
+    this.features = [];
+    this.minLineWidth = options.minLineWidth || 0;
+    this.state = {
+      x: 0,
+      y: 0,
+      i: 0,
+      j: 0,
+      d: 0,
+      // D-code (1: draw, 2: move, 3: flash)
+      g: 1,
+      // G-code (1: linear, 2: cw arc, 3: ccw arc, 36/37: region)
+      aperture: null,
+      // 当前光圈 D-code (例如 10, 11...)
+      interpolation: "linear",
+      // linear, cw, ccw
+      regionMode: false,
+      // G36/G37
+      quadrant: "multi",
+      // 'single' or 'multi' (G74/G75)
+      unit: "mm",
+      // 'mm' or 'inch'
+      polarity: "dark",
+      // 'dark' (正极性，填充) 或 'clear' (负极性，挖空)
+      format: {
+        integer: 2,
+        decimal: 4,
+        zero: "L"
+        // 'L'eading or 'T'railing
+      }
+    };
+    this.polarityRuns = [{ polarity: this.state.polarity, start: 0, end: 0 }];
+    this.apertures = {};
+    this.macros = {};
+    this.currentRegionContours = [];
+    this._currentRegionContour = null;
+  }
+  parse(content) {
+    const lines = content.split(/[\n\r]+/);
+    for (let line of lines) {
+      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 (this.polarityRuns.length > 0) {
+      this.polarityRuns[this.polarityRuns.length - 1].end = this.triangleIndices.length;
+    }
+    return {
+      vertices: new Float32Array(this.vertices),
+      colors: new Float32Array(this.colors),
+      triangleIndices: new Uint32Array(this.triangleIndices),
+      // 改用 Uint32Array 支持大索引
+      features: this.features,
+      // 返回特征点
+      // 仅返回非空 run，避免产生大量空段
+      polarityRuns: this.polarityRuns.filter((r) => r.end - r.start > 0)
+    };
+  }
+  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";
+    } else if (cmd.startsWith("AD")) {
+      const match = cmd.match(/ADD(\d+)([a-zA-Z]+),?(.*)/);
+      if (match) {
+        const dCode = parseInt(match[1]);
+        const type = match[2];
+        const params = match[3].split("X").map((p) => parseFloat(p));
+        this.apertures[dCode] = { type, params };
+      }
+    } else if (cmd.startsWith("LP")) {
+      if (cmd.startsWith("LPD")) this._switchPolarity("dark");
+      else if (cmd.startsWith("LPC")) this._switchPolarity("clear");
+    }
+  }
+  _switchPolarity(nextPolarity) {
+    if (!nextPolarity || this.state.polarity === nextPolarity) return;
+    if (this.polarityRuns.length > 0) {
+      this.polarityRuns[this.polarityRuns.length - 1].end = this.triangleIndices.length;
+    }
+    this.state.polarity = nextPolarity;
+    const start = this.triangleIndices.length;
+    this.polarityRuns.push({ polarity: nextPolarity, start, end: start });
+  }
+  parseCommand(cmd) {
+    if (cmd.startsWith("G")) {
+      const gCode = parseInt(cmd.substring(1, 3));
+      if (gCode === 54) {
+        const dSel = cmd.match(/D(\d+)/);
+        if (dSel) {
+          const dCode = parseInt(dSel[1], 10);
+          if (dCode >= 10) {
+            this.state.aperture = dCode;
+            return;
+          }
+        }
+        return;
+      }
+      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")) {
+      const dCode = parseInt(cmd.substring(1));
+      if (dCode >= 10) {
+        this.state.aperture = dCode;
+        return;
+      }
+      if (dCode === 1 || dCode === 2 || dCode === 3) {
+        const x = this.state.x;
+        const y = this.state.y;
+        if (dCode === 1) {
+          if (this.state.aperture) {
+          }
+        } else if (dCode === 2) {
+        } else if (dCode === 3) {
+          this.addFlash(x, y);
+        }
+        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]);
+    }
+    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 {
+          if (this.state.interpolation === "linear") {
+            this.addStroke(prevX, prevY, x, y);
+            if (this.state.aperture && this.apertures[this.state.aperture]?.type === "C") {
+              let width = this.apertures[this.state.aperture].params[0];
+              if (this.state.unit === "inch") width *= 25.4;
+              if (width < this.minLineWidth) width = this.minLineWidth;
+              this.addCircle(prevX, prevY, width / 2);
+              this.addCircle(x, y, width / 2);
+            }
+          } else {
+            this.addArcStroke(prevX, prevY, x, y, iOffset, jOffset, this.state.interpolation === "cw");
+          }
+        }
+      } else if (d === 2) {
+        if (this.state.regionMode) {
+          this._startRegionContour(x, y);
+        }
+      } else if (d === 3) {
+        this.addFlash(x, y);
+      }
+    }
+  }
+  _startRegionContour(x, y) {
+    const contour = [{ x, y }];
+    this.currentRegionContours.push(contour);
+    this._currentRegionContour = contour;
+  }
+  // 添加圆弧绘制逻辑
+  addArcStroke(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) {
+      console.warn("Radius too small, skipping arc");
+      return;
+    }
+    let startAngle = Math.atan2(y1 - cy, x1 - cx);
+    let endAngle = Math.atan2(y2 - cy, x2 - cx);
+    const dist = Math.sqrt(Math.pow(x1 - x2, 2) + Math.pow(y1 - y2, 2));
+    const isFullCircle = dist < 1e-4;
+    if (isCw) {
+      if (isFullCircle) {
+        endAngle = startAngle - 2 * Math.PI;
+      } else if (endAngle >= startAngle) {
+        endAngle -= 2 * Math.PI;
+      }
+    } else {
+      if (isFullCircle) {
+        endAngle = startAngle + 2 * Math.PI;
+      } else if (endAngle <= startAngle) {
+        endAngle += 2 * Math.PI;
+      }
+    }
+    const arcLength = Math.abs(endAngle - startAngle) * radius;
+    const segments = Math.ceil(arcLength / 0.1);
+    const limitedSegments = Math.min(Math.max(segments, 8), 64);
+    let prevPx = x1;
+    let prevPy = y1;
+    if (this.state.aperture && this.apertures[this.state.aperture]?.type === "C") {
+      let width = this.apertures[this.state.aperture].params[0];
+      if (this.state.unit === "inch") width *= 25.4;
+      if (width < this.minLineWidth) width = this.minLineWidth;
+      this.addCircle(x1, y1, width / 2);
+    }
+    for (let k = 1; k <= limitedSegments; k++) {
+      const t = k / limitedSegments;
+      const angle = startAngle + (endAngle - startAngle) * t;
+      const px = cx + radius * Math.cos(angle);
+      const py = cy + radius * Math.sin(angle);
+      this.addStroke(prevPx, prevPy, px, py);
+      prevPx = px;
+      prevPy = py;
+    }
+    if (this.state.aperture && this.apertures[this.state.aperture]?.type === "C") {
+      let width = this.apertures[this.state.aperture].params[0];
+      if (this.state.unit === "inch") width *= 25.4;
+      if (width < this.minLineWidth) width = this.minLineWidth;
+      this.addCircle(x2, y2, width / 2);
+    }
+  }
+  addArcToRegion(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;
+    let startAngle = Math.atan2(y1 - cy, x1 - cx);
+    let endAngle = Math.atan2(y2 - cy, x2 - cx);
+    const dist = Math.sqrt(Math.pow(x1 - x2, 2) + Math.pow(y1 - y2, 2));
+    const isFullCircle = dist < 1e-4;
+    if (isCw) {
+      if (isFullCircle) {
+        endAngle = startAngle - 2 * Math.PI;
+      } else if (endAngle >= startAngle) {
+        endAngle -= 2 * Math.PI;
+      }
+    } else {
+      if (isFullCircle) {
+        endAngle = startAngle + 2 * Math.PI;
+      } else if (endAngle <= startAngle) {
+        endAngle += 2 * Math.PI;
+      }
+    }
+    const arcLength = Math.abs(endAngle - startAngle) * radius;
+    const segments = Math.max(8, Math.ceil(arcLength / 0.1));
+    for (let k = 1; k <= segments; k++) {
+      const t = k / segments;
+      const angle = startAngle + (endAngle - startAngle) * t;
+      if (this._currentRegionContour) {
+        this._currentRegionContour.push({
+          x: cx + radius * Math.cos(angle),
+          y: cy + radius * Math.sin(angle)
+        });
+      }
+    }
+  }
+  parseValue(str) {
+    if (str.includes(".")) return parseFloat(str);
+    const totalLen = this.state.format.integer + this.state.format.decimal;
+    const sign = str.startsWith("-") || str.startsWith("+") ? str[0] : "";
+    const numStr = sign ? str.substring(1) : str;
+    let val = 0;
+    const scale2 = Math.pow(10, this.state.format.decimal);
+    val = parseInt(str) / scale2;
+    if (this.state.unit === "inch") val *= 25.4;
+    return val;
+  }
+  addStroke(x1, y1, x2, y2) {
+    if (!this.state.aperture) {
+      console.warn("[addStroke] No aperture selected");
+      return;
+    }
+    const ap = this.apertures[this.state.aperture];
+    if (!ap) {
+      console.warn(`[addStroke] Aperture D${this.state.aperture} not defined`);
+      return;
+    }
+    let width = 0;
+    if (ap.type === "C") width = ap.params[0];
+    if (ap.type === "R") width = ap.params[0];
+    if (this.state.unit === "inch") width *= 25.4;
+    if (width === 0) {
+      console.warn(`[GerberDirect] Aperture D${this.state.aperture} \u5BBD\u5EA6\u4E3A0\uFF0C\u4F7F\u7528\u9ED8\u8BA4\u5BBD\u5EA6 0.1mm`);
+      width = 0.1;
+    }
+    if (width < this.minLineWidth) {
+      width = this.minLineWidth;
+    }
+    const dx = x2 - x1;
+    const dy = y2 - y1;
+    const len = Math.sqrt(dx * dx + dy * dy);
+    if (len === 0) return;
+    const ux = -dy / len * (width / 2);
+    const uy = dx / len * (width / 2);
+    const p1 = { x: x1 + ux, y: y1 + uy };
+    const p2 = { x: x1 - ux, y: y1 - uy };
+    const p3 = { x: x2 - ux, y: y2 - uy };
+    const p4 = { x: x2 + ux, y: y2 + uy };
+    this.addQuad(p1, p2, p3, p4);
+    if (ap.type === "C") {
+      this.addCircle(x1, y1, width / 2);
+      this.addCircle(x2, y2, width / 2);
+    }
+  }
+  addFlash(x, y) {
+    if (!this.state.aperture) return;
+    const ap = this.apertures[this.state.aperture];
+    if (!ap) return;
+    if (ap.type === "C") {
+      let r = ap.params[0] / 2;
+      if (this.state.unit === "inch") r *= 25.4;
+      if (r === 0) {
+        console.warn(`[GerberDirect] Aperture D${this.state.aperture} \u534A\u5F84\u4E3A0\uFF0C\u4F7F\u7528\u9ED8\u8BA4\u534A\u5F84 0.05mm (\u76F4\u5F840.1mm)`);
+        r = 0.05;
+      }
+      this.addCircle(x, y, r);
+      this.features.push({
+        type: "circle",
+        x,
+        y,
+        r
+      });
+    } else if (ap.type === "R") {
+      let w = ap.params[0];
+      let h = ap.params[1];
+      if (this.state.unit === "inch") {
+        w *= 25.4;
+        h *= 25.4;
+      }
+      const p1 = { x: x - w / 2, y: y - h / 2 };
+      const p2 = { x: x + w / 2, y: y - h / 2 };
+      const p3 = { x: x + w / 2, y: y + h / 2 };
+      const p4 = { x: x - w / 2, y: y + h / 2 };
+      this.addQuad(p1, p2, p3, p4);
+      this.features.push({
+        type: "rect",
+        x,
+        y,
+        w,
+        h
+      });
+    } else if (ap.type === "O") {
+      let w = ap.params[0];
+      let h = ap.params[1];
+      if (this.state.unit === "inch") {
+        w *= 25.4;
+        h *= 25.4;
+      }
+      this.addObround(x, y, w, h);
+      this.features.push({
+        type: "obround",
+        x,
+        y,
+        w,
+        h
+      });
+    }
+  }
+  finishRegion() {
+    const rawContours = this.currentRegionContours || [];
+    if (rawContours.length === 0) return;
+    const cleanContour = (pts) => {
+      if (!pts || pts.length === 0) return [];
+      const out = [];
+      let last = null;
+      for (const p of pts) {
+        if (!last || Math.abs(p.x - last.x) > 1e-9 || Math.abs(p.y - last.y) > 1e-9) {
+          out.push({ x: p.x, y: p.y });
+          last = p;
+        }
+      }
+      if (out.length >= 2) {
+        const first = out[0];
+        const end = out[out.length - 1];
+        if (Math.abs(first.x - end.x) < 1e-9 && Math.abs(first.y - end.y) < 1e-9) {
+          out.pop();
+        }
+      }
+      if (out.length < 3) return [];
+      return out;
+    };
+    const contours = rawContours.map(cleanContour).filter((c) => c.length >= 3);
+    if (contours.length === 0) return;
+    const signedArea = (pts) => {
+      let a = 0;
+      for (let i = 0; i < pts.length; i++) {
+        const p = pts[i];
+        const q = pts[(i + 1) % pts.length];
+        a += p.x * q.y - q.x * p.y;
+      }
+      return a / 2;
+    };
+    const bboxOf = (pts) => {
+      let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
+      for (const p of pts) {
+        minX = Math.min(minX, p.x);
+        minY = Math.min(minY, p.y);
+        maxX = Math.max(maxX, p.x);
+        maxY = Math.max(maxY, p.y);
+      }
+      return { minX, minY, maxX, maxY };
+    };
+    const pointInPoly = (pt, poly) => {
+      let inside = false;
+      for (let i = 0, j = poly.length - 1; i < poly.length; j = i++) {
+        const xi = poly[i].x, yi = poly[i].y;
+        const xj = poly[j].x, yj = poly[j].y;
+        const intersect = yi > pt.y !== yj > pt.y && pt.x < (xj - xi) * (pt.y - yi) / (yj - yi || 1e-30) + xi;
+        if (intersect) inside = !inside;
+      }
+      return inside;
+    };
+    const metas = contours.map((pts, idx) => ({
+      id: idx,
+      pts,
+      areaAbs: Math.abs(signedArea(pts)),
+      bbox: bboxOf(pts),
+      parent: -1,
+      depth: 0
+    }));
+    for (const a of metas) {
+      const p = a.pts[0];
+      let bestParent = null;
+      for (const b of metas) {
+        if (a.id === b.id) continue;
+        if (p.x < b.bbox.minX || p.x > b.bbox.maxX || p.y < b.bbox.minY || p.y > b.bbox.maxY) continue;
+        if (!pointInPoly(p, b.pts)) continue;
+        if (!bestParent || b.areaAbs < bestParent.areaAbs) {
+          bestParent = b;
+        }
+      }
+      if (bestParent) a.parent = bestParent.id;
+    }
+    const depthOf = (id) => {
+      let d = 0;
+      let cur = metas[id];
+      while (cur.parent !== -1) {
+        d++;
+        cur = metas[cur.parent];
+      }
+      return d;
+    };
+    for (const m of metas) m.depth = depthOf(m.id);
+    const childrenMap = /* @__PURE__ */ new Map();
+    for (const m of metas) {
+      if (!childrenMap.has(m.parent)) childrenMap.set(m.parent, []);
+      childrenMap.get(m.parent).push(m.id);
+    }
+    const triangulateOne = (outerPts, holePtsList) => {
+      const flat = [];
+      const holeIndices = [];
+      for (const p of outerPts) flat.push(p.x, p.y);
+      let cursor = outerPts.length;
+      for (const holePts of holePtsList) {
+        holeIndices.push(cursor);
+        for (const p of holePts) flat.push(p.x, p.y);
+        cursor += holePts.length;
+      }
+      const triangles = earcut(flat, holeIndices.length ? holeIndices : null);
+      if (!triangles || triangles.length === 0) return;
+      const baseIndex = this.vertices.length / 3;
+      for (let i = 0; i < flat.length; i += 2) {
+        this.vertices.push(flat[i], flat[i + 1], 0);
+        this.colors.push(1, 0, 0);
+      }
+      for (let i = 0; i < triangles.length; i++) {
+        this.triangleIndices.push(baseIndex + triangles[i]);
+      }
+    };
+    for (const m of metas) {
+      if (m.depth % 2 !== 0) continue;
+      const childIds = childrenMap.get(m.id) || [];
+      const directHoles = childIds.map((id) => metas[id]).filter((c) => c.depth === m.depth + 1).map((c) => c.pts);
+      triangulateOne(m.pts, directHoles);
+    }
+  }
+  addQuad(p1, p2, p3, p4) {
+    const baseIndex = this.vertices.length / 3;
+    this.vertices.push(p1.x, p1.y, 0);
+    this.colors.push(1, 0, 0);
+    this.vertices.push(p2.x, p2.y, 0);
+    this.colors.push(1, 0, 0);
+    this.vertices.push(p3.x, p3.y, 0);
+    this.colors.push(1, 0, 0);
+    this.vertices.push(p4.x, p4.y, 0);
+    this.colors.push(1, 0, 0);
+    this.triangleIndices.push(baseIndex, baseIndex + 1, baseIndex + 2);
+    this.triangleIndices.push(baseIndex, baseIndex + 2, baseIndex + 3);
+  }
+  addCircle(cx, cy, r) {
+    if (r === 0) {
+      r = 0.05;
+    }
+    const circumference = 2 * Math.PI * r;
+    const segments = Math.min(Math.max(Math.ceil(circumference / 0.2), 12), 64);
+    const baseIndex = this.vertices.length / 3;
+    this.vertices.push(cx, cy, 0);
+    this.colors.push(1, 0, 0);
+    for (let i = 0; i <= segments; i++) {
+      const theta = i / segments * Math.PI * 2;
+      this.vertices.push(cx + Math.cos(theta) * r, cy + Math.sin(theta) * r, 0);
+      this.colors.push(1, 0, 0);
+    }
+    for (let i = 0; i < segments; i++) {
+      this.triangleIndices.push(baseIndex, baseIndex + 1 + i, baseIndex + 1 + i + 1);
+    }
+  }
+  addObround(cx, cy, w, h) {
+    if (w === 0) w = 0.1;
+    if (h === 0) h = 0.1;
+    if (w > h) {
+      const radius = h / 2;
+      const rectWidth = w - h;
+      const segments = Math.max(8, Math.ceil(radius * 4));
+      const leftCx = cx - rectWidth / 2;
+      let baseIndex = this.vertices.length / 3;
+      this.vertices.push(leftCx, cy, 0);
+      this.colors.push(1, 0, 0);
+      for (let i = 0; i <= segments; i++) {
+        const angle = Math.PI / 2 + i / segments * Math.PI;
+        this.vertices.push(leftCx + Math.cos(angle) * radius, cy + Math.sin(angle) * radius, 0);
+        this.colors.push(1, 0, 0);
+      }
+      for (let i = 0; i < segments; i++) {
+        this.triangleIndices.push(baseIndex, baseIndex + 1 + i, baseIndex + 1 + i + 1);
+      }
+      if (rectWidth > 0) {
+        const p1 = { x: cx - rectWidth / 2, y: cy - radius };
+        const p2 = { x: cx - rectWidth / 2, y: cy + radius };
+        const p3 = { x: cx + rectWidth / 2, y: cy + radius };
+        const p4 = { x: cx + rectWidth / 2, y: cy - radius };
+        this.addQuad(p1, p2, p3, p4);
+      }
+      const rightCx = cx + rectWidth / 2;
+      baseIndex = this.vertices.length / 3;
+      this.vertices.push(rightCx, cy, 0);
+      this.colors.push(1, 0, 0);
+      for (let i = 0; i <= segments; i++) {
+        const angle = -Math.PI / 2 + i / segments * Math.PI;
+        this.vertices.push(rightCx + Math.cos(angle) * radius, cy + Math.sin(angle) * radius, 0);
+        this.colors.push(1, 0, 0);
+      }
+      for (let i = 0; i < segments; i++) {
+        this.triangleIndices.push(baseIndex, baseIndex + 1 + i, baseIndex + 1 + i + 1);
+      }
+    } else {
+      const radius = w / 2;
+      const rectHeight = h - w;
+      const segments = Math.max(8, Math.ceil(radius * 4));
+      const topCy = cy + rectHeight / 2;
+      let baseIndex = this.vertices.length / 3;
+      this.vertices.push(cx, topCy, 0);
+      this.colors.push(1, 0, 0);
+      for (let i = 0; i <= segments; i++) {
+        const angle = i / segments * Math.PI;
+        this.vertices.push(cx + Math.cos(angle) * radius, topCy + Math.sin(angle) * radius, 0);
+        this.colors.push(1, 0, 0);
+      }
+      for (let i = 0; i < segments; i++) {
+        this.triangleIndices.push(baseIndex, baseIndex + 1 + i, baseIndex + 1 + i + 1);
+      }
+      if (rectHeight > 0) {
+        const p1 = { x: cx - radius, y: cy + rectHeight / 2 };
+        const p2 = { x: cx - radius, y: cy - rectHeight / 2 };
+        const p3 = { x: cx + radius, y: cy - rectHeight / 2 };
+        const p4 = { x: cx + radius, y: cy + rectHeight / 2 };
+        this.addQuad(p1, p2, p3, p4);
+      }
+      const bottomCy = cy - rectHeight / 2;
+      baseIndex = this.vertices.length / 3;
+      this.vertices.push(cx, bottomCy, 0);
+      this.colors.push(1, 0, 0);
+      for (let i = 0; i <= segments; i++) {
+        const angle = Math.PI + i / segments * Math.PI;
+        this.vertices.push(cx + Math.cos(angle) * radius, bottomCy + Math.sin(angle) * radius, 0);
+        this.colors.push(1, 0, 0);
+      }
+      for (let i = 0; i < segments; i++) {
+        this.triangleIndices.push(baseIndex, baseIndex + 1 + i, baseIndex + 1 + i + 1);
+      }
+    }
+  }
+};
+
+// src/components/jetPaveGerberViewer/src/viewer-src/2dPage/js/main.js
+var import_jszip = __toESM(require_lib(), 1);
+import { parse, plot, renderSVG } from "web-gerber";
+import earcut2 from "earcut";
+var canvas = document.getElementById("canvas");
+var fileInput = document.getElementById("fileInput");
+var status = document.getElementById("status");
+var fileInfo = document.getElementById("fileInfo");
+var fileName = document.getElementById("fileName");
+var fileSize = document.getElementById("fileSize");
+var layerList = document.getElementById("layerList");
+var layerToggleAll = document.getElementById("layerToggleAll");
+var layerToggleAllCheckbox = document.getElementById("layerToggleAllCheckbox");
+var loadingOverlay = document.getElementById("loadingOverlay");
+function showLoading() {
+  if (loadingOverlay) loadingOverlay.classList.add("active");
+}
+function hideLoading() {
+  if (loadingOverlay) loadingOverlay.classList.remove("active");
+}
+var gl = canvas.getContext("webgl", {
+  stencil: true,
+  // 启用模版缓冲，用于处理层内重叠
+  alpha: false,
+  preserveDrawingBuffer: true
+});
+var program = null;
+var positionLocation;
+var uColorLocation;
+var uAlphaLocation;
+var uMatrixLocation;
+var quadVertexBuffer = null;
+var quadIndexBuffer = null;
+var IDENTITY_MATRIX = [
+  1,
+  0,
+  0,
+  0,
+  0,
+  1,
+  0,
+  0,
+  0,
+  0,
+  1,
+  0,
+  0,
+  0,
+  0,
+  1
+];
+var layers = [];
+var scale = 1;
+var transX = 0;
+var transY = 0;
+var isDragging = false;
+var dragStartX = 0;
+var dragStartY = 0;
+var dragStartTransX = 0;
+var dragStartTransY = 0;
+var cacheNeedsUpdate = true;
+var baseColors = [
+  "#FF0000",
+  "#14FF00",
+  "#0014FF",
+  "#FFFF14",
+  "#FF930C",
+  "#B2FF0C",
+  "#3CB2FF",
+  "#C9B20A",
+  "#B2C932",
+  "#6432C9",
+  "#93B20A",
+  "#B27C52",
+  "#7EC755",
+  "#C73C7E",
+  "#3778C7",
+  "#9B9B40",
+  "#7A409B",
+  "#407A9B",
+  "#7A9B40",
+  "#583778"
+];
+function pickColor(idx) {
+  return idx < baseColors.length ? baseColors[idx] : "#FFFFFF";
+}
+var layerColorMap = /* @__PURE__ */ new Map();
+var isSoloMode = false;
+var soloLayerOrder = [];
+var soloTargetLayerIndex = null;
+if (!gl) {
+  alert("WebGL not supported");
+} else {
+  initWebGL();
+  animate();
+}
+function initWebGL() {
+  const vsSource = `
+    attribute vec3 a_position;
+    uniform mat4 u_matrix;
+    void main() {
+      gl_Position = u_matrix * vec4(a_position, 1.0);
+    }
+  `;
+  const fsSource = `
+    precision mediump float;
+    uniform vec3 u_color;
+    uniform float u_alpha;
+    void main() {
+      gl_FragColor = vec4(u_color, u_alpha);
+    }
+  `;
+  const ext = gl.getExtension("OES_element_index_uint");
+  if (!ext) {
+    console.warn("OES_element_index_uint not supported");
+  }
+  const vs = createShader(gl, gl.VERTEX_SHADER, vsSource);
+  const fs = createShader(gl, gl.FRAGMENT_SHADER, fsSource);
+  program = createProgram(gl, vs, fs);
+  positionLocation = gl.getAttribLocation(program, "a_position");
+  uColorLocation = gl.getUniformLocation(program, "u_color");
+  uAlphaLocation = gl.getUniformLocation(program, "u_alpha");
+  uMatrixLocation = gl.getUniformLocation(program, "u_matrix");
+  quadVertexBuffer = gl.createBuffer();
+  gl.bindBuffer(gl.ARRAY_BUFFER, quadVertexBuffer);
+  gl.bufferData(gl.ARRAY_BUFFER, new Float32Array([
+    -1,
+    -1,
+    0,
+    1,
+    -1,
+    0,
+    1,
+    1,
+    0,
+    -1,
+    1,
+    0
+  ]), gl.STATIC_DRAW);
+  quadIndexBuffer = gl.createBuffer();
+  gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, quadIndexBuffer);
+  gl.bufferData(gl.ELEMENT_ARRAY_BUFFER, new Uint16Array([0, 1, 2, 0, 2, 3]), gl.STATIC_DRAW);
+  gl.enable(gl.BLEND);
+  gl.blendFunc(gl.SRC_ALPHA, gl.ONE);
+  resize();
+  window.addEventListener("resize", resize);
+  canvas.style.cursor = "grab";
+  canvas.addEventListener("mousedown", (e) => {
+    if (e.button !== 0) return;
+    isDragging = true;
+    dragStartX = e.clientX;
+    dragStartY = e.clientY;
+    dragStartTransX = transX;
+    dragStartTransY = transY;
+    canvas.style.cursor = "grabbing";
+  });
+  window.addEventListener("mousemove", (e) => {
+    if (!isDragging) return;
+    const deltaX = e.clientX - dragStartX;
+    const deltaY = e.clientY - dragStartY;
+    const rect = canvas.getBoundingClientRect();
+    const normalizedDeltaX = deltaX / rect.width * 2;
+    const normalizedDeltaY = -(deltaY / rect.height) * 2;
+    transX = dragStartTransX + normalizedDeltaX;
+    transY = dragStartTransY + normalizedDeltaY;
+  });
+  window.addEventListener("mouseup", () => {
+    if (isDragging) {
+      isDragging = false;
+      canvas.style.cursor = "grab";
+    }
+  });
+  canvas.addEventListener("mouseleave", () => {
+    if (isDragging) {
+      isDragging = false;
+      canvas.style.cursor = "grab";
+    }
+  });
+  canvas.addEventListener("wheel", (e) => {
+    e.preventDefault();
+    const rect = canvas.getBoundingClientRect();
+    const mouseX = e.clientX - rect.left;
+    const mouseY = e.clientY - rect.top;
+    const normalizedX = mouseX / rect.width * 2 - 1;
+    const normalizedY = -(mouseY / rect.height * 2 - 1);
+    const canvasAspect = rect.width / rect.height;
+    const worldXBefore = (normalizedX - transX) / (scale / canvasAspect);
+    const worldYBefore = (normalizedY - transY) / scale;
+    const scaleFactor = e.deltaY > 0 ? 0.9 : 1.1;
+    scale *= scaleFactor;
+    transX = normalizedX - worldXBefore * (scale / canvasAspect);
+    transY = normalizedY - worldYBefore * scale;
+  });
+}
+function createShader(gl2, type, source) {
+  const shader = gl2.createShader(type);
+  gl2.shaderSource(shader, source);
+  gl2.compileShader(shader);
+  if (!gl2.getShaderParameter(shader, gl2.COMPILE_STATUS)) {
+    console.error(gl2.getShaderInfoLog(shader));
+    gl2.deleteShader(shader);
+    return null;
+  }
+  return shader;
+}
+function createProgram(gl2, vs, fs) {
+  const p = gl2.createProgram();
+  gl2.attachShader(p, vs);
+  gl2.attachShader(p, fs);
+  gl2.linkProgram(p);
+  return p;
+}
+function resize() {
+  const oldWidth = canvas.width;
+  const oldHeight = canvas.height;
+  canvas.width = canvas.clientWidth;
+  canvas.height = canvas.clientHeight;
+  gl.viewport(0, 0, canvas.width, canvas.height);
+  if (oldWidth > 0 && oldHeight > 0 && layers.length > 0) {
+    const oldAspect = oldWidth / oldHeight;
+    const newAspect = canvas.width / canvas.height;
+    transX = transX * (oldAspect / newAspect);
+  }
+  if (layers.length > 0) {
+    cacheNeedsUpdate = true;
+    requestAnimationFrame(() => {
+      if (typeof render === "function") {
+        render();
+      }
+    });
+  }
+}
+function hexToRgb(hex) {
+  const result = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i.exec(hex);
+  return result ? {
+    r: parseInt(result[1], 16) / 255,
+    g: parseInt(result[2], 16) / 255,
+    b: parseInt(result[3], 16) / 255
+  } : { r: 1, g: 0, b: 0 };
+}
+var inheritedGerberFormatHint = null;
+function updateInheritedGerberFormatHintFromText(text, fileName2) {
+  if (!text || typeof text !== "string") return;
+  if (/\bM48\b/i.test(text)) return;
+  const fsMatch = text.match(/%FS([LT])?[AI]X(\d)(\d)Y(\d)(\d)\*%/i);
+  if (!fsMatch) return;
+  const zero = ((fsMatch[1] || "L") + "").toUpperCase() === "T" ? "T" : "L";
+  const integerPlaces = parseInt(fsMatch[2], 10);
+  const decimalPlaces = parseInt(fsMatch[3], 10);
+  if (!Number.isFinite(integerPlaces) || !Number.isFinite(decimalPlaces)) return;
+  let unit = null;
+  const moMatch = text.match(/%MO(IN|MM)\*%/i);
+  if (moMatch) {
+    unit = moMatch[1].toUpperCase() === "IN" ? "in" : "mm";
+  } else {
+    if (/%MOIN\*%/i.test(text) || /\bG70\b/.test(text)) unit = "in";
+    if (/%MOMM\*%/i.test(text) || /\bG71\b/.test(text)) unit = "mm";
+  }
+  inheritedGerberFormatHint = {
+    integerPlaces,
+    decimalPlaces,
+    totalPlaces: integerPlaces + decimalPlaces,
+    places: [integerPlaces, decimalPlaces],
+    zero,
+    unit,
+    from: fileName2
+  };
+  console.log(
+    `[\u683C\u5F0F\u515C\u5E95] \u4ECE ${fileName2} \u63D0\u53D6 Gerber \u683C\u5F0F: ${zero === "L" ? "LZ" : "TZ"} ${integerPlaces}:${decimalPlaces} (unit=${unit || "unknown"})`
+  );
+}
+async function parseWithWebGerber(text, fileName2) {
+  try {
+    let parseSvgPath2 = function(d, scale3) {
+      const coords = [];
+      const commands = d.match(/[MLHVCSQTAZ][^MLHVCSQTAZ]*/gi) || [];
+      let currentX = 0, currentY = 0;
+      let startX = 0, startY = 0;
+      commands.forEach((cmd) => {
+        const type = cmd[0].toUpperCase();
+        const isRelative = cmd[0] === cmd[0].toLowerCase();
+        const args = cmd.slice(1).trim().split(/[\s,]+/).filter((s) => s).map(parseFloat);
+        switch (type) {
+          case "M":
+            if (args.length >= 2) {
+              currentX = isRelative ? currentX + args[0] : args[0];
+              currentY = isRelative ? currentY + args[1] : args[1];
+              startX = currentX;
+              startY = currentY;
+              coords.push(currentX * scale3, currentY * scale3 * -1);
+            }
+            break;
+          case "L":
+            if (args.length >= 2) {
+              currentX = isRelative ? currentX + args[0] : args[0];
+              currentY = isRelative ? currentY + args[1] : args[1];
+              coords.push(currentX * scale3, currentY * scale3 * -1);
+            }
+            break;
+          case "H":
+            if (args.length >= 1) {
+              currentX = isRelative ? currentX + args[0] : args[0];
+              coords.push(currentX * scale3, currentY * scale3 * -1);
+            }
+            break;
+          case "V":
+            if (args.length >= 1) {
+              currentY = isRelative ? currentY + args[0] : args[0];
+              coords.push(currentX * scale3, currentY * scale3 * -1);
+            }
+            break;
+          case "Z":
+            if (currentX !== startX || currentY !== startY) {
+              coords.push(startX * scale3, startY * scale3 * -1);
+            }
+            break;
+        }
+      });
+      return coords;
+    };
+    var parseSvgPath = parseSvgPath2;
+    console.log(`[web-gerber] \u5F00\u59CB\u89E3\u6790 ${fileName2}`);
+    const isDrillFile = /\bM48\b/i.test(text);
+    const fileType = isDrillFile ? "drill" : "gerber";
+    console.log(`[web-gerber] \u6587\u4EF6\u7C7B\u578B: ${fileType}`);
+    let detectedFormat = null;
+    let drillUnits = null;
+    let drillZero = null;
+    if (isDrillFile) {
+      const lines = text.split("\n").map((line) => line.trim());
+      for (const line of lines) {
+        if (!drillUnits) {
+          if (/^METRIC\b/i.test(line) || /^M71\b/i.test(line)) drillUnits = "mm";
+          if (/^INCH\b/i.test(line) || /^M72\b/i.test(line)) drillUnits = "in";
+        }
+        if (!drillZero) {
+          if (/\bLZ\b/i.test(line)) drillZero = "LZ";
+          if (/\bTZ\b/i.test(line)) drillZero = "TZ";
+        }
+        if (drillUnits && drillZero) break;
+      }
+      for (const line of lines) {
+        const formatMatch = line.match(/FILE_FORMAT[=:](\d+)[:.](\d+)/i);
+        if (formatMatch) {
+          const integerPlaces = parseInt(formatMatch[1]);
+          const decimalPlaces = parseInt(formatMatch[2]);
+          detectedFormat = {
+            integerPlaces,
+            decimalPlaces,
+            totalPlaces: integerPlaces + decimalPlaces,
+            places: [integerPlaces, decimalPlaces]
+          };
+          console.log(`[web-gerber] \u68C0\u6D4B\u5230\u683C\u5F0F: ${integerPlaces}:${decimalPlaces} (${integerPlaces}\u4F4D\u6574\u6570, ${decimalPlaces}\u4F4D\u5C0F\u6570)`);
+          break;
+        }
+      }
+      let maxDigits = 0;
+      const coordMatchesAll = text.match(/[XY](-?\d+)/g);
+      if (coordMatchesAll) {
+        for (const coord of coordMatchesAll) {
+          const digits = coord.substring(1).replace(/-/g, "").length;
+          maxDigits = Math.max(maxDigits, digits);
+        }
+      }
+      if (!detectedFormat) {
+        if (inheritedGerberFormatHint && inheritedGerberFormatHint.places) {
+          detectedFormat = {
+            integerPlaces: inheritedGerberFormatHint.integerPlaces,
+            decimalPlaces: inheritedGerberFormatHint.decimalPlaces,
+            totalPlaces: inheritedGerberFormatHint.integerPlaces + inheritedGerberFormatHint.decimalPlaces,
+            places: [inheritedGerberFormatHint.integerPlaces, inheritedGerberFormatHint.decimalPlaces]
+          };
+          console.warn(
+            `[web-gerber] Drill\u672A\u58F0\u660EFILE_FORMAT\uFF0C\u7EE7\u627F Gerber(${inheritedGerberFormatHint.from}) \u683C\u5F0F: ${detectedFormat.integerPlaces}:${detectedFormat.decimalPlaces}`
+          );
+        } else if (maxDigits > 0) {
+          const integerPlaces = Math.min(2, maxDigits);
+          const decimalPlaces = Math.max(0, maxDigits - integerPlaces);
+          detectedFormat = {
+            integerPlaces,
+            decimalPlaces,
+            totalPlaces: integerPlaces + decimalPlaces,
+            places: [integerPlaces, decimalPlaces]
+          };
+          console.warn(
+            `[web-gerber] Drill\u672A\u58F0\u660EFILE_FORMAT\uFF0C\u6309\u5750\u6807\u4F4D\u6570\u63A8\u65AD\u683C\u5F0F: ${integerPlaces}:${decimalPlaces} (maxDigits=${maxDigits})`
+          );
+        }
+      }
+      if (!drillUnits && inheritedGerberFormatHint && inheritedGerberFormatHint.unit) {
+        drillUnits = inheritedGerberFormatHint.unit === "in" ? "in" : "mm";
+      }
+      if (!drillZero && inheritedGerberFormatHint && inheritedGerberFormatHint.zero) {
+        drillZero = inheritedGerberFormatHint.zero === "T" ? "TZ" : "LZ";
+      }
+      if (detectedFormat) {
+        const coordMatches = coordMatchesAll;
+        if (coordMatches) {
+          const definedDigits = detectedFormat.totalPlaces;
+          console.log(`[web-gerber] \u5B9A\u4E49\u683C\u5F0F: [${detectedFormat.integerPlaces}, ${detectedFormat.decimalPlaces}] (${definedDigits}\u4F4D)`);
+          console.log(`[web-gerber] \u5B9E\u9645\u6700\u957F\u5750\u6807: ${maxDigits}\u4F4D`);
+          if (maxDigits > definedDigits) {
+            const extraDigits = maxDigits - definedDigits;
+            detectedFormat.integerPlaces += extraDigits;
+            detectedFormat.totalPlaces = detectedFormat.integerPlaces + detectedFormat.decimalPlaces;
+            detectedFormat.places = [detectedFormat.integerPlaces, detectedFormat.decimalPlaces];
+            console.log(`[web-gerber] \u2713 \u52A8\u6001\u8C03\u6574\u683C\u5F0F\u4E3A: [${detectedFormat.integerPlaces}, ${detectedFormat.decimalPlaces}] (${maxDigits}\u4F4D)`);
+            const oldFormatPattern = /FILE_FORMAT[=:]\d+[:.]\d+/i;
+            const newFormatStr = `FILE_FORMAT=${detectedFormat.integerPlaces}:${detectedFormat.decimalPlaces}`;
+            if (oldFormatPattern.test(text)) {
+              text = text.replace(oldFormatPattern, newFormatStr);
+              console.log(`[web-gerber] \u2713 \u5DF2\u4FEE\u6539\u6587\u4EF6\u683C\u5F0F\u5B9A\u4E49 \u2192 ${newFormatStr}`);
+            }
+          }
+        }
+      }
+    }
+    let parseResult = null;
+    if (isDrillFile && detectedFormat && detectedFormat.places) {
+      const zeroChar = (drillZero || "LZ").toUpperCase() === "TZ" ? "T" : "L";
+      const parseOpts = {
+        // 兼容不同版本的 web-gerber：同时提供 type/filetype
+        type: "drill",
+        filetype: "drill",
+        format: { places: detectedFormat.places, zero: zeroChar }
+      };
+      try {
+        console.log(
+          `[web-gerber] Drill\u4F7F\u7528\u663E\u5F0Fformat\u89E3\u6790: places=[${detectedFormat.places[0]},${detectedFormat.places[1]}], zero=${zeroChar}, units=${drillUnits || "auto"}`
+        );
+        parseResult = parse(text, parseOpts);
+      } catch (e) {
+        console.warn(`[web-gerber] Drill\u663E\u5F0Fformat\u89E3\u6790\u5931\u8D25\uFF0C\u56DE\u9000\u9ED8\u8BA4\u89E3\u6790: ${e?.message || e}`);
+        parseResult = null;
+      }
+    }
+    if (!parseResult) {
+      parseResult = parse(text, { filetype: fileType });
+    }
+    const plotResult = plot(parseResult);
+    console.log(`[web-gerber] plotResult.children \u6570\u91CF:`, plotResult.children?.length);
+    const svgTree = renderSVG(plotResult);
+    console.log(`[web-gerber] SVG\u6811\u751F\u6210\u5B8C\u6210, children \u6570\u91CF:`, svgTree?.children?.length);
+    const fileNameOnly = fileName2.split(/[/\\]/).pop();
+    const fileExtension = "." + fileNameOnly.split(".").pop().toUpperCase();
+    const fileNameUpper = fileNameOnly.toUpperCase();
+    const isOutlineLayer = fileExtension === ".GKO" || fileExtension === ".GM" || /^\.GM\d+$/i.test(fileExtension) || fileNameUpper.includes("OUTLINE") || /EDGE[._-]CUTS/i.test(fileNameUpper) || fileNameUpper.includes("WX") || fileNameUpper.includes("BOARD") || fileNameUpper.startsWith("GKO") || fileNameUpper.startsWith("OUT");
+    const minWidth = isOutlineLayer ? 0.3 : 0;
+    if (isOutlineLayer) {
+      console.log(`[\u8F6E\u5ED3\u5C42] ${fileNameOnly}: minWidth=${minWidth}mm`);
+    }
+    const vertices = [];
+    const indices = [];
+    const drillPosScaleRuns = isDrillFile ? [] : null;
+    const polarityRuns = [];
+    let currentPolarity = "dark";
+    let currentRunStart = 0;
+    const ensurePolarity = (nextPolarity) => {
+      const p = nextPolarity || "dark";
+      if (p === currentPolarity) return;
+      if (indices.length > currentRunStart) {
+        polarityRuns.push({ polarity: currentPolarity, start: currentRunStart, end: indices.length });
+      }
+      currentPolarity = p;
+      currentRunStart = indices.length;
+    };
+    const scale2 = plotResult.units === "in" ? 25.4 : 1;
+    let coordPosScaleFix = 1;
+    const parseFixedCoord = (rawDigits, fmt, zeroMode) => {
+      if (!fmt || rawDigits == null) return null;
+      const s = String(rawDigits).trim();
+      const sign = s.startsWith("-") ? -1 : 1;
+      let digits = s.replace(/[^0-9]/g, "");
+      if (!digits) return null;
+      const need = fmt.totalPlaces;
+      if (need && digits.length < need) {
+        if ((zeroMode || "").toUpperCase() === "LZ") {
+          digits = digits.padStart(need, "0");
+        } else {
+          digits = digits.padEnd(need, "0");
+        }
+      }
+      const denom = Math.pow(10, fmt.decimalPlaces || 0);
+      const n = parseInt(digits, 10);
+      if (!Number.isFinite(n) || denom === 0) return null;
+      return sign * (n / denom);
+    };
+    if (isDrillFile && detectedFormat && Array.isArray(plotResult.children) && plotResult.children.length > 0) {
+      try {
+        const xyMatch = text.match(/X(-?\d+)\s*Y(-?\d+)/i);
+        const firstCircle = plotResult.children.find(
+          (c) => c?.type === "imageShape" && c.shape?.type === "circle" && Number.isFinite(c.shape.cx) && Number.isFinite(c.shape.cy)
+        );
+        if (xyMatch && firstCircle) {
+          const actX = firstCircle.shape.cx;
+          const actY = firstCircle.shape.cy;
+          const plotUnits = plotResult.units === "in" ? "in" : "mm";
+          const srcUnits = drillUnits || plotUnits;
+          const evalZeroMode = (zeroMode) => {
+            let expX = parseFixedCoord(xyMatch[1], detectedFormat, zeroMode);
+            let expY = parseFixedCoord(xyMatch[2], detectedFormat, zeroMode);
+            if (expX != null && expY != null) {
+              if (srcUnits === "in" && plotUnits === "mm") {
+                expX *= 25.4;
+                expY *= 25.4;
+              }
+              if (srcUnits === "mm" && plotUnits === "in") {
+                expX /= 25.4;
+                expY /= 25.4;
+              }
+            }
+            const ratios = [];
+            if (Number.isFinite(expX) && actX !== 0) ratios.push(expX / actX);
+            if (Number.isFinite(expY) && actY !== 0) ratios.push(expY / actY);
+            if (ratios.length === 0) return null;
+            const avg = ratios.reduce((s, v) => s + v, 0) / ratios.length;
+            const max = Math.max(...ratios);
+            const min = Math.min(...ratios);
+            const spread = avg !== 0 ? Math.abs(max - min) / Math.abs(avg) : 999;
+            return { zeroMode, expX, expY, avg, spread };
+          };
+          const primaryZero = (drillZero || "").toUpperCase() === "TZ" ? "TZ" : "LZ";
+          const altZero = primaryZero === "TZ" ? "LZ" : "TZ";
+          const primary = evalZeroMode(primaryZero);
+          const alt = evalZeroMode(altZero);
+          const near1 = (r) => r && Number.isFinite(r.avg) && r.spread < 0.05 && Math.abs(r.avg - 1) <= 0.05;
+          if (near1(primary)) {
+          } else if (near1(alt)) {
+            console.warn(`[web-gerber] \u26A0\uFE0F Drill\u96F6\u6291\u5236\u58F0\u660E\u4E3A ${primaryZero}\uFF0C\u4F46\u5750\u6807\u66F4\u7B26\u5408 ${altZero}\uFF08ratio\u22481\uFF09\uFF0C\u8DF3\u8FC7 posScaleFix \u4EE5\u907F\u514D\u8BEF\u7F29\u653E`);
+          } else {
+            const chosen = primary || alt;
+            if (chosen && Number.isFinite(chosen.avg) && Math.abs(chosen.avg - 1) > 0.05 && chosen.spread < 0.05) {
+              const absAvg = Math.abs(chosen.avg);
+              const pow10 = Math.pow(10, Math.round(Math.log10(absAvg)));
+              const snapped = Math.abs(absAvg - pow10) / pow10 < 0.15 ? pow10 : absAvg;
+              if (snapped >= 0.01 && snapped <= 1e4) {
+                coordPosScaleFix = snapped;
+                console.warn(`[web-gerber] \u26A0\uFE0F Drill\u5750\u6807\u683C\u5F0F\u7591\u4F3C\u88AB\u9519\u8BEF\u89E3\u91CA\uFF0C\u542F\u7528 FILE_FORMAT \u5750\u6807\u7F29\u653E\u4FEE\u6B63\uFF1AposScaleFix=${coordPosScaleFix} (units=${plotUnits}, zero=${chosen.zeroMode})`);
+              }
+            }
+          }
+        }
+      } catch (e) {
+        console.warn("[web-gerber] Drill FILE_FORMAT \u5750\u6807\u7F29\u653E\u4FEE\u6B63\u5931\u8D25\uFF0C\u5FFD\u7565:", e?.message || e);
+      }
+    }
+    const posScale = scale2 * coordPosScaleFix;
+    const sizeScale = scale2;
+    const processSvgElement = (element) => {
+      if (!element || !element.tagName) return;
+      const tagName = element.tagName.toLowerCase();
+      if (tagName === "circle") {
+        const cx = parseFloat(element.properties?.cx || element.attributes?.cx || 0) * scale2;
+        const cy = parseFloat(element.properties?.cy || element.attributes?.cy || 0) * scale2 * -1;
+        const r = parseFloat(element.properties?.r || element.attributes?.r || 0) * scale2;
+        if (r > 0) {
+          const segments = Math.min(Math.max(Math.ceil(2 * Math.PI * r / 0.2), 12), 64);
+          const baseIndex = vertices.length / 3;
+          vertices.push(cx, cy, 0);
+          for (let i = 0; i <= segments; i++) {
+            const angle = i / segments * Math.PI * 2;
+            vertices.push(cx + Math.cos(angle) * r, cy + Math.sin(angle) * r, 0);
+          }
+          for (let i = 0; i < segments; i++) {
+            indices.push(baseIndex, baseIndex + 1 + i, baseIndex + 1 + i + 1);
+          }
+          for (let i = 0; i < 10; i++) {
+            vertices.push(cx, cy, 0);
+          }
+        }
+      } else if (tagName === "ellipse") {
+        const cx = parseFloat(element.properties?.cx || element.attributes?.cx || 0) * scale2;
+        const cy = parseFloat(element.properties?.cy || element.attributes?.cy || 0) * scale2 * -1;
+        const rx = parseFloat(element.properties?.rx || element.attributes?.rx || 0) * scale2;
+        const ry = parseFloat(element.properties?.ry || element.attributes?.ry || 0) * scale2;
+        if (rx > 0 && ry > 0) {
+          const segments = Math.min(Math.max(Math.ceil(2 * Math.PI * Math.max(rx, ry) / 0.2), 12), 64);
+          const baseIndex = vertices.length / 3;
+          vertices.push(cx, cy, 0);
+          for (let i = 0; i <= segments; i++) {
+            const angle = i / segments * Math.PI * 2;
+            vertices.push(cx + Math.cos(angle) * rx, cy + Math.sin(angle) * ry, 0);
+          }
+          for (let i = 0; i < segments; i++) {
+            indices.push(baseIndex, baseIndex + 1 + i, baseIndex + 1 + i + 1);
+          }
+          for (let i = 0; i < 10; i++) {
+            vertices.push(cx, cy, 0);
+          }
+        }
+      } else if (tagName === "rect") {
+        const x = parseFloat(element.properties?.x || element.attributes?.x || 0) * scale2;
+        const y = parseFloat(element.properties?.y || element.attributes?.y || 0) * scale2 * -1;
+        const width = parseFloat(element.properties?.width || element.attributes?.width || 0) * scale2;
+        const height = parseFloat(element.properties?.height || element.attributes?.height || 0) * scale2;
+        const rx = parseFloat(element.properties?.rx || element.attributes?.rx || 0) * scale2;
+        const ry = parseFloat(element.properties?.ry || element.attributes?.ry || 0) * scale2;
+        if (width > 0 && height > 0) {
+          if (rx > 0 || ry > 0) {
+            const cornerRadius = Math.max(rx, ry);
+            if (width > height) {
+              const radius = height / 2;
+              const rectWidth = width - height;
+              const leftCx = x + radius;
+              const leftCy = y - radius;
+              const segments = Math.max(12, Math.ceil(radius * 2));
+              let centerIdx = vertices.length / 3;
+              vertices.push(leftCx, leftCy, 0);
+              for (let j = 0; j <= segments; j++) {
+                const angle = j / segments * Math.PI * 2;
+                vertices.push(leftCx + Math.cos(angle) * radius, leftCy + Math.sin(angle) * radius, 0);
+              }
+              for (let j = 0; j < segments; j++) {
+                indices.push(centerIdx, centerIdx + 1 + j, centerIdx + 1 + j + 1);
+              }
+              if (rectWidth > 0) {
+                const baseIndex = vertices.length / 3;
+                vertices.push(x + radius, y, 0);
+                vertices.push(x + radius + rectWidth, y, 0);
+                vertices.push(x + radius + rectWidth, y - height, 0);
+                vertices.push(x + radius, y - height, 0);
+                indices.push(baseIndex, baseIndex + 1, baseIndex + 2);
+                indices.push(baseIndex, baseIndex + 2, baseIndex + 3);
+              }
+              const rightCx = x + width - radius;
+              const rightCy = y - radius;
+              centerIdx = vertices.length / 3;
+              vertices.push(rightCx, rightCy, 0);
+              for (let j = 0; j <= segments; j++) {
+                const angle = j / segments * Math.PI * 2;
+                vertices.push(rightCx + Math.cos(angle) * radius, rightCy + Math.sin(angle) * radius, 0);
+              }
+              for (let j = 0; j < segments; j++) {
+                indices.push(centerIdx, centerIdx + 1 + j, centerIdx + 1 + j + 1);
+              }
+            } else {
+              const radius = width / 2;
+              const rectHeight = height - width;
+              const topCx = x + radius;
+              const topCy = y - radius;
+              const segments = Math.max(12, Math.ceil(radius * 2));
+              let centerIdx = vertices.length / 3;
+              vertices.push(topCx, topCy, 0);
+              for (let j = 0; j <= segments; j++) {
+                const angle = j / segments * Math.PI * 2;
+                vertices.push(topCx + Math.cos(angle) * radius, topCy + Math.sin(angle) * radius, 0);
+              }
+              for (let j = 0; j < segments; j++) {
+                indices.push(centerIdx, centerIdx + 1 + j, centerIdx + 1 + j + 1);
+              }
+              if (rectHeight > 0) {
+                const baseIndex = vertices.length / 3;
+                vertices.push(x, y - radius, 0);
+                vertices.push(x + width, y - radius, 0);
+                vertices.push(x + width, y - radius - rectHeight, 0);
+                vertices.push(x, y - radius - rectHeight, 0);
+                indices.push(baseIndex, baseIndex + 1, baseIndex + 2);
+                indices.push(baseIndex, baseIndex + 2, baseIndex + 3);
+              }
+              const bottomCx = x + radius;
+              const bottomCy = y - height + radius;
+              centerIdx = vertices.length / 3;
+              vertices.push(bottomCx, bottomCy, 0);
+              for (let j = 0; j <= segments; j++) {
+                const angle = j / segments * Math.PI * 2;
+                vertices.push(bottomCx + Math.cos(angle) * radius, bottomCy + Math.sin(angle) * radius, 0);
+              }
+              for (let j = 0; j < segments; j++) {
+                indices.push(centerIdx, centerIdx + 1 + j, centerIdx + 1 + j + 1);
+              }
+            }
+          } else {
+            const baseIndex = vertices.length / 3;
+            vertices.push(x, y, 0);
+            vertices.push(x + width, y, 0);
+            vertices.push(x + width, y - height, 0);
+            vertices.push(x, y - height, 0);
+            indices.push(baseIndex, baseIndex + 1, baseIndex + 2);
+            indices.push(baseIndex, baseIndex + 2, baseIndex + 3);
+          }
+        }
+      } else if (tagName === "path") {
+        const d = element.properties?.d || element.attributes?.d || "";
+        const fill = element.properties?.fill || element.attributes?.fill || "";
+        const stroke = element.properties?.stroke || element.attributes?.stroke || "";
+        const isFillPath = fill && fill !== "none";
+        const isStrokePath = stroke && stroke !== "none";
+        if (d) {
+          const pathPoints = parseSvgPath2(d, scale2);
+          if (isFillPath && pathPoints && pathPoints.length >= 6) {
+            try {
+              const triangles = earcut2(pathPoints);
+              if (triangles && triangles.length > 0) {
+                const baseIndex = vertices.length / 3;
+                for (let i = 0; i < pathPoints.length; i += 2) {
+                  vertices.push(pathPoints[i], pathPoints[i + 1], 0);
+                }
+                for (let i = 0; i < triangles.length; i++) {
+                  indices.push(baseIndex + triangles[i]);
+                }
+              }
+            } catch (e) {
+              console.warn("[SVG Path Fill] \u4E09\u89D2\u5316\u5931\u8D25:", e);
+            }
+          } else if (isStrokePath && pathPoints && pathPoints.length >= 4) {
+            let strokeWidth = parseFloat(element.properties?.["stroke-width"] || element.attributes?.["stroke-width"] || 0.15) * scale2;
+            if (strokeWidth < minWidth) strokeWidth = minWidth;
+            const radius = strokeWidth / 2;
+            for (let i = 0; i < pathPoints.length - 2; i += 2) {
+              const x1 = pathPoints[i];
+              const y1 = pathPoints[i + 1];
+              const x2 = pathPoints[i + 2];
+              const y2 = pathPoints[i + 3];
+              const dx = x2 - x1;
+              const dy = y2 - y1;
+              const len = Math.sqrt(dx * dx + dy * dy);
+              if (len > 1e-3) {
+                const nx = -dy / len * radius;
+                const ny = dx / len * radius;
+                const baseIndex = vertices.length / 3;
+                vertices.push(x1 + nx, y1 + ny, 0);
+                vertices.push(x1 - nx, y1 - ny, 0);
+                vertices.push(x2 + nx, y2 + ny, 0);
+                vertices.push(x2 - nx, y2 - ny, 0);
+                indices.push(baseIndex, baseIndex + 1, baseIndex + 2);
+                indices.push(baseIndex + 1, baseIndex + 3, baseIndex + 2);
+                if (i === 0) {
+                  const segments = Math.max(8, Math.ceil(radius * 2));
+                  const centerIdx = vertices.length / 3;
+                  vertices.push(x1, y1, 0);
+                  for (let j = 0; j <= segments; j++) {
+                    const angle = j / segments * Math.PI * 2;
+                    vertices.push(x1 + Math.cos(angle) * radius, y1 + Math.sin(angle) * radius, 0);
+                  }
+                  for (let j = 0; j < segments; j++) {
+                    indices.push(centerIdx, centerIdx + 1 + j, centerIdx + 1 + j + 1);
+                  }
+                }
+                {
+                  const segments = Math.max(8, Math.ceil(radius * 2));
+                  const centerIdx = vertices.length / 3;
+                  vertices.push(x2, y2, 0);
+                  for (let j = 0; j <= segments; j++) {
+                    const angle = j / segments * Math.PI * 2;
+                    vertices.push(x2 + Math.cos(angle) * radius, y2 + Math.sin(angle) * radius, 0);
+                  }
+                  for (let j = 0; j < segments; j++) {
+                    indices.push(centerIdx, centerIdx + 1 + j, centerIdx + 1 + j + 1);
+                  }
+                }
+              }
+            }
+          }
+        }
+      } else if (tagName === "line") {
+        const x1 = parseFloat(element.properties?.x1 || element.attributes?.x1 || 0) * scale2;
+        const y1 = parseFloat(element.properties?.y1 || element.attributes?.y1 || 0) * scale2 * -1;
+        const x2 = parseFloat(element.properties?.x2 || element.attributes?.x2 || 0) * scale2;
+        const y2 = parseFloat(element.properties?.y2 || element.attributes?.y2 || 0) * scale2 * -1;
+        let strokeWidth = parseFloat(element.properties?.["stroke-width"] || element.attributes?.["stroke-width"] || 0.15) * scale2;
+        if (strokeWidth < minWidth) strokeWidth = minWidth;
+        const radius = strokeWidth / 2;
+        const dx = x2 - x1;
+        const dy = y2 - y1;
+        const len = Math.sqrt(dx * dx + dy * dy);
+        if (len > 0) {
+          const nx = -dy / len * radius;
+          const ny = dx / len * radius;
+          const baseIndex = vertices.length / 3;
+          vertices.push(x1 + nx, y1 + ny, 0);
+          vertices.push(x1 - nx, y1 - ny, 0);
+          vertices.push(x2 + nx, y2 + ny, 0);
+          vertices.push(x2 - nx, y2 - ny, 0);
+          indices.push(baseIndex, baseIndex + 1, baseIndex + 2);
+          indices.push(baseIndex + 1, baseIndex + 3, baseIndex + 2);
+          const segments = Math.max(8, Math.ceil(radius * 2));
+          let centerIdx = vertices.length / 3;
+          vertices.push(x1, y1, 0);
+          for (let j = 0; j <= segments; j++) {
+            const angle = j / segments * Math.PI * 2;
+            vertices.push(x1 + Math.cos(angle) * radius, y1 + Math.sin(angle) * radius, 0);
+          }
+          for (let j = 0; j < segments; j++) {
+            indices.push(centerIdx, centerIdx + 1 + j, centerIdx + 1 + j + 1);
+          }
+          centerIdx = vertices.length / 3;
+          vertices.push(x2, y2, 0);
+          for (let j = 0; j <= segments; j++) {
+            const angle = j / segments * Math.PI * 2;
+            vertices.push(x2 + Math.cos(angle) * radius, y2 + Math.sin(angle) * radius, 0);
+          }
+          for (let j = 0; j < segments; j++) {
+            indices.push(centerIdx, centerIdx + 1 + j, centerIdx + 1 + j + 1);
+          }
+        }
+      } else if (tagName === "polyline" || tagName === "polygon") {
+        const pointsStr = element.properties?.points || element.attributes?.points || "";
+        if (pointsStr) {
+          const coords = pointsStr.trim().split(/[\s,]+/).map(parseFloat);
+          if (coords.length >= 6) {
+            const pathPoints = [];
+            for (let i = 0; i < coords.length; i += 2) {
+              if (!isNaN(coords[i]) && !isNaN(coords[i + 1])) {
+                pathPoints.push(coords[i] * scale2, coords[i + 1] * scale2 * -1);
+              }
+            }
+            if (pathPoints.length >= 6) {
+              try {
+                const triangles = earcut2(pathPoints);
+                if (triangles && triangles.length > 0) {
+                  const baseIndex = vertices.length / 3;
+                  for (let i = 0; i < pathPoints.length; i += 2) {
+                    vertices.push(pathPoints[i], pathPoints[i + 1], 0);
+                  }
+                  for (let i = 0; i < triangles.length; i++) {
+                    indices.push(baseIndex + triangles[i]);
+                  }
+                }
+              } catch (e) {
+                console.warn("[SVG Polyline] \u4E09\u89D2\u5316\u5931\u8D25:", e);
+              }
+            }
+          }
+        }
+      }
+      if (element.children && element.children.length > 0) {
+        element.children.forEach((child) => processSvgElement(child));
+      }
+    };
+    if (!isDrillFile && svgTree && svgTree.children) {
+      svgTree.children.forEach((child) => processSvgElement(child));
+      console.log(`[web-gerber] \u4ECESVG\u6811\u63D0\u53D6: ${vertices.length / 3} \u9876\u70B9, ${indices.length / 3} \u4E09\u89D2\u5F62`);
+    }
+    if (plotResult.children && plotResult.children.length > 0) {
+      const verticesBefore = vertices.length / 3;
+      console.log(`[web-gerber] \u8865\u5145\u5904\u7406 plotResult.children (${plotResult.children.length} \u4E2A)`);
+      const typeCount = {};
+      plotResult.children.forEach((child) => {
+        typeCount[child.type] = (typeCount[child.type] || 0) + 1;
+      });
+      plotResult.children.forEach((child, idx) => {
+        ensurePolarity(child.polarity || "dark");
+        if (child.type === "imagePath" && child.segments && child.segments.length > 0) {
+          child.segments.forEach((segment, segIdx) => {
+            if (segment.type === "line" && segment.start && segment.end) {
+              const startX = segment.start[0] * scale2;
+              const startY = segment.start[1] * scale2;
+              const endX = segment.end[0] * scale2;
+              const endY = segment.end[1] * scale2;
+              const baseIndex = vertices.length / 3;
+              vertices.push(startX, startY, 0);
+              vertices.push(endX, endY, 0);
+              let width = (segment.width ?? child.width ?? 0.15) * scale2;
+              if (width < minWidth) width = minWidth;
+              const radius = width / 2;
+              const dx = endX - startX;
+              const dy = endY - startY;
+              const len = Math.sqrt(dx * dx + dy * dy);
+              if (len > 0) {
+                const nx = -dy / len * radius;
+                const ny = dx / len * radius;
+                const v1 = vertices.length / 3;
+                vertices.push(startX + nx, startY + ny, 0);
+                vertices.push(startX - nx, startY - ny, 0);
+                vertices.push(endX + nx, endY + ny, 0);
+                vertices.push(endX - nx, endY - ny, 0);
+                indices.push(v1, v1 + 1, v1 + 2);
+                indices.push(v1 + 1, v1 + 3, v1 + 2);
+                if (segIdx === 0) {
+                  const segments = Math.max(8, Math.ceil(radius * 2));
+                  const centerIdx = vertices.length / 3;
+                  vertices.push(startX, startY, 0);
+                  for (let j = 0; j <= segments; j++) {
+                    const angle = j / segments * Math.PI * 2;
+                    vertices.push(startX + Math.cos(angle) * radius, startY + Math.sin(angle) * radius, 0);
+                  }
+                  for (let j = 0; j < segments; j++) {
+                    indices.push(centerIdx, centerIdx + 1 + j, centerIdx + 1 + j + 1);
+                  }
+                }
+                {
+                  const segments = Math.max(8, Math.ceil(radius * 2));
+                  const centerIdx = vertices.length / 3;
+                  vertices.push(endX, endY, 0);
+                  for (let j = 0; j <= segments; j++) {
+                    const angle = j / segments * Math.PI * 2;
+                    vertices.push(endX + Math.cos(angle) * radius, endY + Math.sin(angle) * radius, 0);
+                  }
+                  for (let j = 0; j < segments; j++) {
+                    indices.push(centerIdx, centerIdx + 1 + j, centerIdx + 1 + j + 1);
+                  }
+                }
+              }
+            } else if (segment.type === "arc") {
+              const sx = segment.start[0];
+              const sy = segment.start[1];
+              const ex = segment.end[0];
+              const ey = segment.end[1];
+              const cx0 = segment.center[0];
+              const cy0 = segment.center[1];
+              const startX = sx * scale2;
+              const startY = sy * scale2;
+              const endX = ex * scale2;
+              const endY = ey * scale2;
+              const cx = cx0 * scale2;
+              const cy = cy0 * scale2;
+              const startAngle = segment.start.length > 2 && typeof segment.start[2] === "number" ? segment.start[2] : Math.atan2(sy - cy0, sx - cx0);
+              const endAngle = segment.end.length > 2 && typeof segment.end[2] === "number" ? segment.end[2] : Math.atan2(ey - cy0, ex - cx0);
+              const arcRadius = (typeof segment.radius === "number" && segment.radius > 0 ? segment.radius : Math.sqrt(Math.pow(sx - cx0, 2) + Math.pow(sy - cy0, 2))) * scale2;
+              const isFullCircle = Math.abs(startX - endX) < 1e-3 && Math.abs(startY - endY) < 1e-3;
+              let angleDiff = endAngle - startAngle;
+              if (isFullCircle) {
+                angleDiff = Math.PI * 2;
+                if (idx < 5) {
+                }
+              } else if (Math.abs(angleDiff) < 1e-3) {
+                return;
+              }
+              const arcSegments = Math.max(8, Math.ceil(Math.abs(angleDiff) * arcRadius / 0.5));
+              let arcWidth = (segment.width ?? child.width ?? 0.15) * scale2;
+              if (arcWidth < minWidth) arcWidth = minWidth;
+              const lineRadius = arcWidth / 2;
+              for (let i = 0; i < arcSegments; i++) {
+                const t1 = i / arcSegments;
+                const t2 = (i + 1) / arcSegments;
+                const angle1 = startAngle + angleDiff * t1;
+                const angle2 = startAngle + angleDiff * t2;
+                const x1 = cx + Math.cos(angle1) * arcRadius;
+                const y1 = cy + Math.sin(angle1) * arcRadius;
+                const x2 = cx + Math.cos(angle2) * arcRadius;
+                const y2 = cy + Math.sin(angle2) * arcRadius;
+                const dx = x2 - x1;
+                const dy = y2 - y1;
+                const len = Math.sqrt(dx * dx + dy * dy);
+                if (len > 0) {
+                  const nx = -dy / len * lineRadius;
+                  const ny = dx / len * lineRadius;
+                  const v1 = vertices.length / 3;
+                  vertices.push(x1 + nx, y1 + ny, 0);
+                  vertices.push(x1 - nx, y1 - ny, 0);
+                  vertices.push(x2 + nx, y2 + ny, 0);
+                  vertices.push(x2 - nx, y2 - ny, 0);
+                  indices.push(v1, v1 + 1, v1 + 2);
+                  indices.push(v1 + 1, v1 + 3, v1 + 2);
+                }
+              }
+              if (!isFullCircle && segIdx === 0) {
+                const capSegments = Math.max(8, Math.ceil(lineRadius * 2));
+                const centerIdx = vertices.length / 3;
+                vertices.push(startX, startY, 0);
+                for (let j = 0; j <= capSegments; j++) {
+                  const angle = j / capSegments * Math.PI * 2;
+                  vertices.push(startX + Math.cos(angle) * lineRadius, startY + Math.sin(angle) * lineRadius, 0);
+                }
+                for (let j = 0; j < capSegments; j++) {
+                  indices.push(centerIdx, centerIdx + 1 + j, centerIdx + 1 + j + 1);
+                }
+              }
+              if (!isFullCircle) {
+                const capSegments = Math.max(8, Math.ceil(lineRadius * 2));
+                const centerIdx = vertices.length / 3;
+                vertices.push(endX, endY, 0);
+                for (let j = 0; j <= capSegments; j++) {
+                  const angle = j / capSegments * Math.PI * 2;
+                  vertices.push(endX + Math.cos(angle) * lineRadius, endY + Math.sin(angle) * lineRadius, 0);
+                }
+                for (let j = 0; j < capSegments; j++) {
+                  indices.push(centerIdx, centerIdx + 1 + j, centerIdx + 1 + j + 1);
+                }
+              }
+            }
+          });
+        } else if (child.type === "imageShape" && child.shape) {
+          const shape = child.shape;
+          const polarity = child.polarity || "dark";
+          const emitCircle = (cx, cy, r) => {
+            if (!(r > 0)) return;
+            const x = cx * posScale;
+            const y = cy * posScale;
+            const radius = r * sizeScale;
+            const segments = Math.min(Math.max(Math.ceil(2 * Math.PI * radius / 0.2), 12), 64);
+            const baseIndex = vertices.length / 3;
+            vertices.push(x, y, 0);
+            for (let i = 0; i <= segments; i++) {
+              const angle = i / segments * Math.PI * 2;
+              vertices.push(x + Math.cos(angle) * radius, y + Math.sin(angle) * radius, 0);
+            }
+            for (let i = 0; i < segments; i++) {
+              indices.push(baseIndex, baseIndex + 1 + i, baseIndex + 1 + i + 1);
+            }
+            for (let i = 0; i < 10; i++) {
+              vertices.push(x, y, 0);
+            }
+            if (drillPosScaleRuns) {
+              const endIndex = vertices.length / 3;
+              drillPosScaleRuns.push({ start: baseIndex, count: endIndex - baseIndex, cx: x, cy: y, kind: "circle" });
+            }
+          };
+          const emitRectangle = (x, y, xSize, ySize, r) => {
+            const x0 = (x || 0) * posScale;
+            const y0 = (y || 0) * posScale;
+            const w = (xSize || 0) * sizeScale;
+            const h = (ySize || 0) * sizeScale;
+            if (!(w > 0 && h > 0)) return;
+            const baseIndex = vertices.length / 3;
+            vertices.push(x0, y0, 0);
+            vertices.push(x0 + w, y0, 0);
+            vertices.push(x0 + w, y0 + h, 0);
+            vertices.push(x0, y0 + h, 0);
+            indices.push(baseIndex, baseIndex + 1, baseIndex + 2);
+            indices.push(baseIndex, baseIndex + 2, baseIndex + 3);
+            const cx = x0 + w / 2;
+            const cy = y0 + h / 2;
+            for (let i = 0; i < 10; i++) {
+              vertices.push(cx, cy, 0);
+            }
+            if (drillPosScaleRuns) {
+              const endIndex = vertices.length / 3;
+              drillPosScaleRuns.push({ start: baseIndex, count: endIndex - baseIndex, cx, cy, kind: "rectangle" });
+            }
+          };
+          const emitPolygon = (pts) => {
+            if (!Array.isArray(pts) || pts.length < 3) return;
+            const flat = [];
+            for (const p of pts) {
+              if (!p || p.length < 2) continue;
+              flat.push(p[0] * posScale, p[1] * posScale);
+            }
+            if (flat.length < 6) return;
+            const triangles = earcut2(flat);
+            if (!triangles || triangles.length === 0) return;
+            const baseIndex = vertices.length / 3;
+            for (let i = 0; i < flat.length; i += 2) {
+              vertices.push(flat[i], flat[i + 1], 0);
+            }
+            for (let i = 0; i < triangles.length; i++) {
+              indices.push(baseIndex + triangles[i]);
+            }
+          };
+          const emitOutline = (segments) => {
+            if (!Array.isArray(segments) || segments.length === 0) return;
+            const pts = [];
+            let started = false;
+            const pushPoint = (x, y) => {
+              pts.push(x * posScale, y * posScale);
+            };
+            for (const seg of segments) {
+              if (!seg || !seg.type) continue;
+              if (seg.type === "line" && seg.start && seg.end) {
+                if (!started) {
+                  pushPoint(seg.start[0], seg.start[1]);
+                  started = true;
+                }
+                pushPoint(seg.end[0], seg.end[1]);
+              } else if (seg.type === "arc" && seg.start && seg.end && seg.center) {
+                const cx = seg.center[0] * posScale;
+                const cy = seg.center[1] * posScale;
+                const radius = (seg.radius ?? Math.sqrt(Math.pow(seg.start[0] - seg.center[0], 2) + Math.pow(seg.start[1] - seg.center[1], 2))) * posScale;
+                const startTheta = seg.start.length > 2 ? seg.start[2] : Math.atan2(seg.start[1] - seg.center[1], seg.start[0] - seg.center[0]);
+                let endTheta = seg.end.length > 2 ? seg.end[2] : Math.atan2(seg.end[1] - seg.center[1], seg.end[0] - seg.center[0]);
+                if (endTheta < startTheta) endTheta += Math.PI * 2;
+                if (!started) {
+                  pushPoint(seg.start[0], seg.start[1]);
+                  started = true;
+                }
+                const arcLen = Math.abs(endTheta - startTheta) * radius;
+                const arcSegments = Math.max(8, Math.ceil(arcLen / 0.5));
+                for (let i = 1; i <= arcSegments; i++) {
+                  const t = i / arcSegments;
+                  const theta = startTheta + (endTheta - startTheta) * t;
+                  const x = cx + Math.cos(theta) * radius;
+                  const y = cy + Math.sin(theta) * radius;
+                  pts.push(x, y);
+                }
+              }
+            }
+            if (pts.length < 6) return;
+            const triangles = earcut2(pts);
+            if (!triangles || triangles.length === 0) return;
+            const baseIndex = vertices.length / 3;
+            for (let i = 0; i < pts.length; i += 2) {
+              vertices.push(pts[i], pts[i + 1], 0);
+            }
+            for (let i = 0; i < triangles.length; i++) {
+              indices.push(baseIndex + triangles[i]);
+            }
+          };
+          const emitSimpleShape = (s) => {
+            if (!s || !s.type) return;
+            if (s.type === "circle") {
+              emitCircle(s.cx || 0, s.cy || 0, s.r || 0);
+            } else if (s.type === "rectangle") {
+              emitRectangle(s.x || 0, s.y || 0, s.xSize || 0, s.ySize || 0, s.r || 0);
+            } else if (s.type === "polygon") {
+              emitPolygon(s.points || []);
+            } else if (s.type === "outline") {
+              emitOutline(s.segments || []);
+            }
+          };
+          if (shape.type === "layeredShape" && Array.isArray(shape.shapes)) {
+            for (const sub of shape.shapes) {
+              const localPolarity = sub && sub.erase === true ? "clear" : polarity;
+              ensurePolarity(localPolarity);
+              emitSimpleShape(sub);
+            }
+            ensurePolarity(polarity);
+          } else {
+            emitSimpleShape(shape);
+          }
+        } else if (child.type === "imageRegion" && child.segments && child.segments.length > 0) {
+          const regionPoints = [];
+          const holeIndices = [];
+          let lastEnd = null;
+          child.segments.forEach((segment, segIdx) => {
+            let startX, startY, endX, endY;
+            let isArc = false;
+            let arcParams = null;
+            if (segment.type === "line") {
+              startX = segment.start[0] * scale2;
+              startY = segment.start[1] * scale2;
+              endX = segment.end[0] * scale2;
+              endY = segment.end[1] * scale2;
+            } else if (segment.type === "arc") {
+              isArc = true;
+              const sx = segment.start[0];
+              const sy = segment.start[1];
+              const ex = segment.end[0];
+              const ey = segment.end[1];
+              startX = sx * scale2;
+              startY = sy * scale2;
+              endX = ex * scale2;
+              endY = ey * scale2;
+              const cx0 = segment.center[0];
+              const cy0 = segment.center[1];
+              const cx = cx0 * scale2;
+              const cy = cy0 * scale2;
+              const startAngle = segment.start.length > 2 && typeof segment.start[2] === "number" ? segment.start[2] : Math.atan2(sy - cy0, sx - cx0);
+              const endAngle = segment.end.length > 2 && typeof segment.end[2] === "number" ? segment.end[2] : Math.atan2(ey - cy0, ex - cx0);
+              const radius0 = typeof segment.radius === "number" && segment.radius > 0 ? segment.radius : Math.sqrt(Math.pow(sx - cx0, 2) + Math.pow(sy - cy0, 2));
+              const radius = radius0 * scale2;
+              let angleDiff = endAngle - startAngle;
+              const isSamePoint = Math.abs(sx - ex) < 1e-9 && Math.abs(sy - ey) < 1e-9;
+              if (isSamePoint && Math.abs(angleDiff) < 1e-6) {
+                angleDiff = Math.PI * 2;
+              }
+              arcParams = { cx, cy, radius, startAngle, angleDiff };
+            }
+            let isNewContour = false;
+            if (lastEnd) {
+              const dist = Math.sqrt(Math.pow(startX - lastEnd.x, 2) + Math.pow(startY - lastEnd.y, 2));
+              if (dist > 0.01) {
+                isNewContour = true;
+                holeIndices.push(regionPoints.length / 2);
+              }
+            } else {
+              isNewContour = true;
+            }
+            if (isNewContour) {
+              regionPoints.push(startX, startY);
+            }
+            if (isArc && arcParams) {
+              const { cx, cy, radius, startAngle, angleDiff } = arcParams;
+              const arcLength = Math.abs(angleDiff) * radius;
+              const arcSegments = Math.max(8, Math.ceil(arcLength / 0.5));
+              for (let i = 1; i <= arcSegments; i++) {
+                const t = i / arcSegments;
+                const angle = startAngle + angleDiff * t;
+                regionPoints.push(
+                  cx + Math.cos(angle) * radius,
+                  cy + Math.sin(angle) * radius
+                );
+              }
+            } else {
+              regionPoints.push(endX, endY);
+            }
+            lastEnd = { x: endX, y: endY };
+          });
+          if (regionPoints.length >= 6) {
+            try {
+              const triangles = earcut2(regionPoints, holeIndices);
+              if (triangles.length > 0) {
+                const baseIndex = vertices.length / 3;
+                for (let i = 0; i < regionPoints.length; i += 2) {
+                  vertices.push(regionPoints[i], regionPoints[i + 1], 0);
+                }
+                for (let i = 0; i < triangles.length; i++) {
+                  indices.push(baseIndex + triangles[i]);
+                }
+                if (isOutlineLayer && minWidth > 0) {
+                  const strokeRadius = minWidth / 2;
+                  for (let i = 0; i < regionPoints.length - 2; i += 2) {
+                    const x1 = regionPoints[i];
+                    const y1 = regionPoints[i + 1];
+                    const x2 = regionPoints[i + 2];
+                    const y2 = regionPoints[i + 3];
+                    const dx = x2 - x1;
+                    const dy = y2 - y1;
+                    const len = Math.sqrt(dx * dx + dy * dy);
+                    if (len > 1e-3) {
+                      const nx = -dy / len * strokeRadius;
+                      const ny = dx / len * strokeRadius;
+                      const v1 = vertices.length / 3;
+                      vertices.push(x1 + nx, y1 + ny, 0);
+                      vertices.push(x1 - nx, y1 - ny, 0);
+                      vertices.push(x2 + nx, y2 + ny, 0);
+                      vertices.push(x2 - nx, y2 - ny, 0);
+                      indices.push(v1, v1 + 1, v1 + 2);
+                      indices.push(v1 + 1, v1 + 3, v1 + 2);
+                      const segments = Math.max(8, Math.ceil(strokeRadius * 4));
+                      if (i === 0) {
+                        const centerIdx2 = vertices.length / 3;
+                        vertices.push(x1, y1, 0);
+                        for (let j = 0; j <= segments; j++) {
+                          const angle = j / segments * Math.PI * 2;
+                          vertices.push(x1 + Math.cos(angle) * strokeRadius, y1 + Math.sin(angle) * strokeRadius, 0);
+                        }
+                        for (let j = 0; j < segments; j++) {
+                          indices.push(centerIdx2, centerIdx2 + 1 + j, centerIdx2 + 1 + j + 1);
+                        }
+                      }
+                      const centerIdx = vertices.length / 3;
+                      vertices.push(x2, y2, 0);
+                      for (let j = 0; j <= segments; j++) {
+                        const angle = j / segments * Math.PI * 2;
+                        vertices.push(x2 + Math.cos(angle) * strokeRadius, y2 + Math.sin(angle) * strokeRadius, 0);
+                      }
+                      for (let j = 0; j < segments; j++) {
+                        indices.push(centerIdx, centerIdx + 1 + j, centerIdx + 1 + j + 1);
+                      }
+                    }
+                  }
+                }
+              }
+            } catch (error) {
+              console.error(`[web-gerber] Region ${idx} \u4E09\u89D2\u5316\u5931\u8D25:`, error);
+            }
+          }
+        }
+      });
+      if (indices.length > currentRunStart) {
+        polarityRuns.push({ polarity: currentPolarity, start: currentRunStart, end: indices.length });
+      }
+      const verticesAdded = vertices.length / 3 - verticesBefore;
+      const trianglesAdded = indices.length / 3 - (verticesBefore > 0 ? indices.length / 3 - verticesBefore : 0);
+      console.log(`[web-gerber] \u8865\u5145\u63D0\u53D6: +${verticesAdded} \u9876\u70B9, \u603B\u8BA1 ${vertices.length / 3} \u9876\u70B9, ${indices.length / 3} \u4E09\u89D2\u5F62`);
+    }
+    console.log(`[web-gerber] ${fileName2}: ${vertices.length / 3} \u9876\u70B9, ${indices.length / 3} \u4E09\u89D2\u5F62`);
+    if (vertices.length > 0) {
+      let minX = Infinity, maxX = -Infinity;
+      let minY = Infinity, maxY = -Infinity;
+      for (let i = 0; i < vertices.length; i += 3) {
+        minX = Math.min(minX, vertices[i]);
+        maxX = Math.max(maxX, vertices[i]);
+        minY = Math.min(minY, vertices[i + 1]);
+        maxY = Math.max(maxY, vertices[i + 1]);
+      }
+      console.log(`[web-gerber] ${fileName2} \u5750\u6807\u8303\u56F4: X=[${minX.toFixed(2)}, ${maxX.toFixed(2)}] mm, Y=[${minY.toFixed(2)}, ${maxY.toFixed(2)}] mm`);
+    }
+    return {
+      vertices: new Float32Array(vertices),
+      triangleIndices: new Uint32Array(indices),
+      polarityRuns: polarityRuns.filter((r) => r.end - r.start > 0),
+      // 仅 drill 文件会有内容
+      drillPosScaleRuns: drillPosScaleRuns && drillPosScaleRuns.length > 0 ? drillPosScaleRuns : null
+    };
+  } catch (error) {
+    console.error(`[web-gerber] \u89E3\u6790\u5931\u8D25:`, error);
+    console.error(`[web-gerber] \u9519\u8BEF\u5806\u6808:`, error.stack);
+    throw error;
+  }
+}
+function getLayerDisplayName(fileNameOrLayer) {
+  if (typeof fileNameOrLayer === "object" && fileNameOrLayer !== null) {
+    if (fileNameOrLayer.phoLayerType) {
+      return fileNameOrLayer.phoLayerType;
+    }
+    fileNameOrLayer = fileNameOrLayer.name;
+  }
+  const fileName2 = fileNameOrLayer;
+  const fileNameOnly = fileName2.split(/[/\\]/).pop();
+  const fileExtension = "." + fileNameOnly.split(".").pop().toUpperCase();
+  const fileNameUpper = fileNameOnly.toUpperCase();
+  if (fileExtension === ".GBR") {
+    const nameUpper = fileNameOnly.toUpperCase();
+    const nameLower = fileNameOnly.toLowerCase();
+    const baseNameUpper = fileNameOnly.replace(/\.[^.]+$/, "").toUpperCase();
+    const directLayerNames = /* @__PURE__ */ new Set([
+      "GTO",
+      "GTP",
+      "GTS",
+      "GTL",
+      "GBL",
+      "GBS",
+      "GBP",
+      "GBO",
+      "GKO"
+    ]);
+    if (directLayerNames.has(baseNameUpper) || /^G\d+$/i.test(baseNameUpper) || /^SIG\d+$/i.test(baseNameUpper)) {
+      return baseNameUpper;
+    }
+    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 (nameUpper.includes("PROFILE")) {
+      return "GKO";
+    }
+    if (/EDGE[._-]CUTS/i.test(nameUpper)) return "GKO";
+    if (/F[._-]CU\b/i.test(nameUpper)) return "GTL";
+    if (/B[._-]CU\b/i.test(nameUpper)) return "GBL";
+    if (/F[._-]MASK/i.test(nameUpper)) return "GTS";
+    if (/B[._-]MASK/i.test(nameUpper)) return "GBS";
+    if (/F[._-]SILKS?/i.test(nameUpper)) return "GTO";
+    if (/B[._-]SILKS?/i.test(nameUpper)) return "GBO";
+    if (/F[._-]PASTE/i.test(nameUpper)) return "GTP";
+    if (/B[._-]PASTE/i.test(nameUpper)) return "GBP";
+    if (/F[._-]FAB/i.test(nameUpper)) return "GTO";
+    if (/B[._-]FAB/i.test(nameUpper)) return "GBO";
+    if (/IN(\d+)[._-]CU/i.test(nameUpper)) {
+      const m = nameUpper.match(/IN(\d+)[._-]CU/);
+      return "SIG" + (parseInt(m[1], 10) + 1);
+    }
+    if (nameUpper.startsWith("ZH-TOP") || nameUpper.includes("ZH-TOP")) return "GTS";
+    if (nameUpper.startsWith("ZH-BOT") || nameUpper.includes("ZH-BOT")) return "GBS";
+    if (nameUpper.startsWith("XL-TOP") || nameUpper.includes("XL-TOP")) return "GTL";
+    if (nameUpper.startsWith("XL-BOT") || nameUpper.includes("XL-BOT")) return "GBL";
+    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 (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 === ".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 fileNameOnly;
+  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";
+    return fileNameOnly;
+  }
+  if (fileExtension === ".PHO") {
+    const nameUpper = fileNameOnly.toUpperCase();
+    if (nameUpper.startsWith("SST")) {
+      return "GTO";
+    }
+    if (nameUpper.startsWith("SMD")) {
+      const numberMatch = nameUpper.match(/^SMD(\d+)/);
+      if (numberMatch) {
+        const number = parseInt(numberMatch[1], 10);
+        return number < 20 ? "GTP" : "GBP";
+      } else {
+        return "GTP";
+      }
+    }
+    if (nameUpper.startsWith("SM")) {
+      const numberMatch = nameUpper.match(/^SM(\d+)/);
+      if (numberMatch) {
+        const number = parseInt(numberMatch[1], 10);
+        return number < 20 ? "GTS" : "GBS";
+      } else {
+        return "GTS";
+      }
+    }
+    if (nameUpper.startsWith("ART")) {
+      const numberMatch = nameUpper.match(/^ART(\d+)/);
+      if (numberMatch) {
+        const number = parseInt(numberMatch[1], 10);
+        return number < 20 ? "GTL" : "GBL";
+      } else {
+        return "GTL";
+      }
+    }
+    if (nameUpper.startsWith("SSB")) {
+      return "GBO";
+    }
+    if (nameUpper.startsWith("DRL")) {
+      return "DRL";
+    }
+    if (nameUpper.startsWith("DD")) {
+      return fileNameOnly;
+    }
+    return fileNameOnly;
+  }
+  if (/^\.GD\d+$/i.test(fileExtension) || /^\.GG\d+$/i.test(fileExtension)) {
+    return fileNameOnly;
+  }
+  if (fileExtension === ".GM" || /^\.GM\d+$/i.test(fileExtension)) {
+    return fileNameOnly;
+  }
+  if (/^\.INT\d+$/i.test(fileExtension)) {
+    return fileNameOnly;
+  }
+  const gNumberMatch = fileExtension.match(/^\.G(\d+)$/i);
+  if (gNumberMatch) {
+    const inCuMatch = fileNameUpper.match(/IN(\d+)[._-]CU/i);
+    if (inCuMatch) return "SIG" + (parseInt(inCuMatch[1], 10) + 1);
+    const number = parseInt(gNumberMatch[1], 10);
+    return "SIG" + (number + 1);
+  }
+  const gpNumberMatch = fileExtension.match(/^\.GP(\d+)$/i);
+  if (gpNumberMatch) {
+    const number = parseInt(gpNumberMatch[1], 10);
+    return "GP" + number;
+  }
+  const isTxFile = /^\.TX\d*$/i.test(fileExtension) || fileExtension === ".TXT";
+  if (isTxFile) {
+    if (/slotholes/i.test(fileName2)) {
+      return "SLOT";
+    }
+    if (/[_\s]via/i.test(fileName2)) {
+      return "VIA";
+    }
+    return "DRL";
+  }
+  return fileExtension.substring(1);
+}
+function getLayerOrder(fileName2) {
+  const fileNameOnly = fileName2.split(/[/\\]/).pop();
+  const fileExtension = "." + fileNameOnly.split(".").pop().toUpperCase();
+  const fileNameUpper = fileNameOnly.toUpperCase();
+  const ext = fileExtension.substring(1);
+  const layerTypeOrder = {
+    "GTO": 0,
+    "GTP": 1,
+    "GTS": 2,
+    "GTL": 3,
+    "G1": 4,
+    "G2": 5,
+    "GBL": 6,
+    "GBS": 7,
+    "GBP": 7.5,
+    "GBO": 8,
+    "GKO": 9,
+    "SLOT": 9.5,
+    "DRL_TXT": 9.6,
+    "VIA": 11,
+    "rout": 11.5,
+    "GDD": 12,
+    "GDL": 13,
+    "GM": 14,
+    "GPB": 14.5,
+    "GPT": 15,
+    "DRL": 200
+  };
+  if (ext === "GBR") {
+    const nameUpper = fileNameOnly.toUpperCase();
+    const nameLower = fileNameOnly.toLowerCase();
+    const baseNameUpper = fileNameOnly.replace(/\.[^.]+$/, "").toUpperCase();
+    if (layerTypeOrder[baseNameUpper] !== void 0 || /^G\d+$/i.test(baseNameUpper) || /^SIG\d+$/i.test(baseNameUpper)) {
+      const order = layerTypeOrder[baseNameUpper] !== void 0 ? layerTypeOrder[baseNameUpper] : 10;
+      console.log(`\u6587\u4EF6 ${fileName2} \u8BC6\u522B\u4E3A GBR->${baseNameUpper} (basename), order=${order}`);
+      return order;
+    }
+    if (nameLower.includes("legend_top") || nameLower.includes("legend") && nameLower.includes("top") && !nameLower.includes("signal")) {
+      console.log(`\u6587\u4EF6 ${fileName2} \u8BC6\u522B\u4E3A GBR->GTO (legend_Top), order=0`);
+      return 0;
+    }
+    if (nameLower.includes("paste_top")) {
+      console.log(`\u6587\u4EF6 ${fileName2} \u8BC6\u522B\u4E3A GBR->GTP (Paste_Top), order=1`);
+      return 1;
+    }
+    if (nameLower.includes("paste_bot")) {
+      console.log(`\u6587\u4EF6 ${fileName2} \u8BC6\u522B\u4E3A GBR->GBP (Paste_Bot), order=7.5`);
+      return 7.5;
+    }
+    if (nameLower.includes("soldermask_top")) {
+      console.log(`\u6587\u4EF6 ${fileName2} \u8BC6\u522B\u4E3A GBR->GTS (soldermask_Top), order=2`);
+      return 2;
+    }
+    if (nameLower.includes("soldermask_bot")) {
+      console.log(`\u6587\u4EF6 ${fileName2} \u8BC6\u522B\u4E3A GBR->GBS (soldermask_Bot), order=7`);
+      return 7;
+    }
+    const signalMatch = nameLower.match(/(?:copper_)?signal[_\s](\d+)/i);
+    if (signalMatch) {
+      const number = parseInt(signalMatch[1], 10);
+      const order = Math.min(3 + number * 0.1, 5.9);
+      console.log(`\u6587\u4EF6 ${fileName2} \u8BC6\u522B\u4E3A GBR->SIG${number + 1} (signal_${number}), order=${order}`);
+      return order;
+    }
+    if (nameLower.includes("signal_top") || nameLower.includes("copper_signal_top")) {
+      console.log(`\u6587\u4EF6 ${fileName2} \u8BC6\u522B\u4E3A GBR->GTL (signal_Top), order=3`);
+      return 3;
+    }
+    if (nameLower.includes("signal_bot") || nameLower.includes("copper_signal_bot")) {
+      console.log(`\u6587\u4EF6 ${fileName2} \u8BC6\u522B\u4E3A GBR->GBL (signal_Bot), order=6`);
+      return 6;
+    }
+    if (nameUpper.includes("PROFILE")) {
+      console.log(`\u6587\u4EF6 ${fileName2} \u8BC6\u522B\u4E3A GBR->GKO (Profile), order=9`);
+      return 9;
+    }
+    if (/EDGE[._-]CUTS/i.test(nameUpper)) return 9;
+    if (/F[._-]CU\b/i.test(nameUpper)) return 3;
+    if (/B[._-]CU\b/i.test(nameUpper)) return 6;
+    if (/F[._-]MASK/i.test(nameUpper)) return 2;
+    if (/B[._-]MASK/i.test(nameUpper)) return 7;
+    if (/F[._-]SILKS?/i.test(nameUpper)) return 0;
+    if (/B[._-]SILKS?/i.test(nameUpper)) return 8;
+    if (/F[._-]PASTE/i.test(nameUpper)) return 1;
+    if (/B[._-]PASTE/i.test(nameUpper)) return 7.5;
+    if (/F[._-]FAB/i.test(nameUpper)) return 0;
+    if (/B[._-]FAB/i.test(nameUpper)) return 8;
+    if (/IN(\d+)[._-]CU/i.test(nameUpper)) {
+      const m = nameUpper.match(/IN(\d+)[._-]CU/);
+      return Math.min(3 + parseInt(m[1], 10) * 0.1, 5.9);
+    }
+    if (nameUpper.startsWith("ZH-TOP") || nameUpper.includes("ZH-TOP")) return 2;
+    if (nameUpper.startsWith("ZH-BOT") || nameUpper.includes("ZH-BOT")) return 7;
+    if (nameUpper.startsWith("XL-TOP") || nameUpper.includes("XL-TOP")) return 3;
+    if (nameUpper.startsWith("XL-BOT") || nameUpper.includes("XL-BOT")) return 6;
+    console.log(`\u6587\u4EF6 ${fileName2} \u8BC6\u522B\u4E3A GBR (\u672A\u8BC6\u522B), order=10`);
+    return 10;
+  }
+  if (fileNameUpper.endsWith("_SST") || fileNameUpper.includes("_SST.")) return 0;
+  if (fileNameUpper.endsWith("_PMT") || fileNameUpper.includes("_PMT.")) return 1;
+  if (fileNameUpper.endsWith("_SMT") || fileNameUpper.includes("_SMT.")) return 2;
+  if (fileNameUpper.endsWith("_TOP") || fileNameUpper.includes("_TOP.")) return 3;
+  if (fileNameUpper.endsWith("_SMB") || fileNameUpper.includes("_SMB.")) return 7;
+  if (fileNameUpper.endsWith("_PMB") || fileNameUpper.includes("_PMB.")) return 7.5;
+  if (fileNameUpper.endsWith("_SSB") || fileNameUpper.includes("_SSB.")) return 8;
+  if (fileNameUpper.includes("OUTLINE")) return 9;
+  const intMatch = fileNameUpper.match(/_INT(\d+)$/i) || fileNameUpper.match(/_INT(\d+)\./i);
+  if (intMatch) {
+    const number = parseInt(intMatch[1], 10);
+    return 100 + number;
+  }
+  if ((ext === "DRL" || ext === "D") && fileNameOnly.toUpperCase() === "NP.DRL") {
+    return 9.65;
+  }
+  if ((ext === "DRL" || ext === "D") && fileNameOnly.toUpperCase() === "P.DRL") {
+    return 9.6;
+  }
+  if (layerTypeOrder[ext] !== void 0) {
+    return layerTypeOrder[ext];
+  }
+  const inCuForOrder = fileNameUpper.match(/IN(\d+)[._-]CU/i);
+  if (inCuForOrder && /^G\d+$/i.test(ext)) {
+    return Math.min(3 + parseInt(inCuForOrder[1], 10) * 0.1, 5.9);
+  }
+  const gNumberMatch = ext.match(/^G(\d+)$/i);
+  if (gNumberMatch) {
+    const number = parseInt(gNumberMatch[1], 10);
+    return Math.min(3 + number * 0.1, 5.9);
+  }
+  const gpNumberMatch = ext.match(/^GP(\d+)$/i);
+  if (gpNumberMatch) {
+    const number = parseInt(gpNumberMatch[1], 10);
+    return Math.min(5.9 + number * 0.01, 5.99);
+  }
+  const intNumberMatch = ext.match(/^INT(\d+)$/i);
+  if (intNumberMatch) {
+    const number = parseInt(intNumberMatch[1], 10);
+    return 100 + number;
+  }
+  const gdNumberMatch = ext.match(/^GD(\d+)$/i);
+  if (gdNumberMatch) {
+    const number = parseInt(gdNumberMatch[1], 10);
+    return Math.min(14 + number * 0.1, 14.4);
+  }
+  const ggNumberMatch = ext.match(/^GG(\d+)$/i);
+  if (ggNumberMatch) {
+    const number = parseInt(ggNumberMatch[1], 10);
+    return Math.min(14 + number * 0.1, 14.4);
+  }
+  const gmNumberMatch = ext.match(/^GM(\d+)$/i);
+  if (gmNumberMatch) {
+    const number = parseInt(gmNumberMatch[1], 10);
+    if (number === 1) {
+      return 14.2;
+    } else {
+      return Math.min(14 + number * 0.1, 14.4);
+    }
+  }
+  const isTxFile = /^TX\d*$/i.test(ext) || ext === "TXT";
+  if (isTxFile && /slotholes/i.test(fileName2)) {
+    console.log(`\u6587\u4EF6 ${fileName2} \u8BC6\u522B\u4E3A SLOT, order=9.5`);
+    return 9.5;
+  }
+  if (/[_\s]via/i.test(fileName2) && isTxFile) {
+    console.log(`\u6587\u4EF6 ${fileName2} \u8BC6\u522B\u4E3A VIA, order=11`);
+    return 11;
+  }
+  if (isTxFile) {
+    console.log(`\u6587\u4EF6 ${fileName2} \u8BC6\u522B\u4E3A DRL (TXT), order=9.6`);
+    return 9.6;
+  }
+  if (ext === "ART") {
+    const dot = fileNameOnly.lastIndexOf(".");
+    const stemUpper = (dot > 0 ? fileNameOnly.substring(0, dot) : fileNameOnly).toUpperCase();
+    if (stemUpper === "SST") return 0;
+    if (stemUpper === "SMT") return 2;
+    if (stemUpper === "TOP") return 3;
+    if (stemUpper === "BOT") return 6;
+    if (stemUpper === "SMB") return 7;
+    if (stemUpper === "SSB") return 8;
+    if (stemUpper === "OUT") return 9;
+    console.log(`\u6587\u4EF6 ${fileName2} \u8BC6\u522B\u4E3A ART(unknown), order=100`);
+    return 100;
+  }
+  if (ext === "PHO") {
+    console.log(`\u6587\u4EF6 ${fileName2} \u8BC6\u522B\u4E3A PHO (\u4E34\u65F6order=100\uFF0C\u540E\u5904\u7406\u4F1A\u66F4\u65B0)`);
+    return 100;
+  }
+  if (ext === "DRL" || ext === "D" || ext === "DRI") {
+    console.log(`\u6587\u4EF6 ${fileName2} \u8BC6\u522B\u4E3A DRL, order=200`);
+    return 200;
+  }
+  if (ext === "ROU") {
+    console.log(`\u6587\u4EF6 ${fileName2} \u8BC6\u522B\u4E3A ROU, order=11.5`);
+    return 11.5;
+  }
+  if (ext === "BOT") return 6;
+  if (ext === "TOP") return 3;
+  if (ext === "SOB") return 7;
+  if (ext === "SOT") return 2;
+  if (ext === "SST") return 0;
+  if (ext === "SSB") return 8;
+  if (ext === "SMT") return 2;
+  if (ext === "SMB") return 7;
+  if (ext === "PMT") return 1;
+  if (ext === "PMB") return 7.5;
+  if (ext === "SER") {
+    console.log(`\u6587\u4EF6 ${fileName2} \u8BC6\u522B\u4E3A SER (\u663E\u793A\u6587\u4EF6\u540D), order=1000`);
+    return 1e3;
+  }
+  return 100;
+}
+function animate() {
+  render();
+  requestAnimationFrame(animate);
+}
+function render() {
+  gl.clearColor(0, 0, 0, 1);
+  gl.clear(gl.COLOR_BUFFER_BIT | gl.STENCIL_BUFFER_BIT);
+  if (layers.length === 0) return;
+  gl.useProgram(program);
+  gl.enableVertexAttribArray(positionLocation);
+  gl.enable(gl.STENCIL_TEST);
+  const aspect = canvas.width / canvas.height;
+  const matrix = [
+    scale / aspect,
+    0,
+    0,
+    0,
+    0,
+    scale,
+    0,
+    0,
+    0,
+    0,
+    1,
+    0,
+    transX,
+    transY,
+    0,
+    1
+  ];
+  gl.uniformMatrix4fv(uMatrixLocation, false, matrix);
+  const layerHasClearPolarity = (layer) => {
+    return Array.isArray(layer.polarityRuns) && layer.polarityRuns.some((r) => r && r.polarity === "clear" && r.end - r.start > 0);
+  };
+  const drawLayer = (layer, blendFunc, alpha) => {
+    if (layerHasClearPolarity(layer) && quadVertexBuffer && quadIndexBuffer) {
+      gl.clear(gl.STENCIL_BUFFER_BIT);
+      gl.colorMask(false, false, false, false);
+      gl.stencilOp(gl.KEEP, gl.KEEP, gl.REPLACE);
+      gl.uniformMatrix4fv(uMatrixLocation, false, matrix);
+      gl.bindBuffer(gl.ARRAY_BUFFER, layer.vertexBuffer);
+      gl.vertexAttribPointer(positionLocation, 3, gl.FLOAT, false, 0, 0);
+      gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, layer.indexBuffer);
+      for (const run of layer.polarityRuns) {
+        if (!run) continue;
+        const count = run.end - run.start;
+        if (count <= 0) continue;
+        const ref = run.polarity === "clear" ? 0 : 1;
+        gl.stencilFunc(gl.ALWAYS, ref, 255);
+        gl.drawElements(gl.TRIANGLES, count, gl.UNSIGNED_INT, run.start * 4);
+      }
+      gl.colorMask(true, true, true, true);
+      gl.stencilFunc(gl.EQUAL, 1, 255);
+      gl.stencilOp(gl.KEEP, gl.KEEP, gl.KEEP);
+      gl.blendEquation(gl.FUNC_ADD);
+      gl.blendFunc(...blendFunc);
+      gl.uniform3fv(uColorLocation, layer.color);
+      gl.uniform1f(uAlphaLocation, alpha);
+      gl.uniformMatrix4fv(uMatrixLocation, false, IDENTITY_MATRIX);
+      gl.bindBuffer(gl.ARRAY_BUFFER, quadVertexBuffer);
+      gl.vertexAttribPointer(positionLocation, 3, gl.FLOAT, false, 0, 0);
+      gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, quadIndexBuffer);
+      gl.drawElements(gl.TRIANGLES, 6, gl.UNSIGNED_SHORT, 0);
+      gl.uniformMatrix4fv(uMatrixLocation, false, matrix);
+      return;
+    }
+    gl.clear(gl.STENCIL_BUFFER_BIT);
+    gl.stencilFunc(gl.NOTEQUAL, 1, 255);
+    gl.stencilOp(gl.KEEP, gl.KEEP, gl.REPLACE);
+    gl.blendEquation(gl.FUNC_ADD);
+    gl.blendFunc(...blendFunc);
+    gl.uniform3fv(uColorLocation, layer.color);
+    gl.uniform1f(uAlphaLocation, alpha);
+    gl.bindBuffer(gl.ARRAY_BUFFER, layer.vertexBuffer);
+    gl.vertexAttribPointer(positionLocation, 3, gl.FLOAT, false, 0, 0);
+    gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, layer.indexBuffer);
+    gl.drawElements(gl.TRIANGLES, layer.vertexCount, gl.UNSIGNED_INT, 0);
+  };
+  const diffBlendNames = ["GTS", "GBS", "GTP", "GBP", "GPT", "GPB"];
+  const diffIndices = [];
+  const drillIndices = [];
+  const gdgggmIndices = [];
+  for (let i = layers.length - 1; i >= 0; i--) {
+    const layer = layers[i];
+    if (!layer.visible || !layer.vertexBuffer || !layer.indexBuffer) continue;
+    const displayName = getLayerDisplayName(layer);
+    const order = layer.order !== void 0 ? layer.order : 100;
+    const nameUpper = layer.name.toUpperCase();
+    const isGdNum = /\.GD\d+$/.test(nameUpper);
+    const isGgNum = /\.GG\d+$/.test(nameUpper);
+    const gmNumMatch = nameUpper.match(/\.GM(\d+)$/);
+    const isGm1 = gmNumMatch && gmNumMatch[1] === "1";
+    const isGdGgGmNum = isGdNum || isGgNum || isGm1;
+    if (isGdGgGmNum) {
+      gdgggmIndices.push(i);
+      continue;
+    }
+    if (layer.isDrillFile || layer.isSlotFile) {
+      drillIndices.push(i);
+      continue;
+    }
+    const isSigInner = /^SIG\d+$/i.test(displayName);
+    const isDiffBlend = diffBlendNames.includes(displayName) || isSigInner;
+    if (isDiffBlend) {
+      diffIndices.push(i);
+      continue;
+    }
+    const additiveNames = ["GTS", "GBS", "GTL", "GBL", "GPT", "GBP", "GTP", "GPB"];
+    const isAdditiveLayer = additiveNames.includes(displayName) || order >= 2 && order <= 15;
+    const isSpecialLayer = Math.abs(order - 0) < 0.1 || Math.abs(order - 1) < 0.1;
+    const alpha = 1;
+    let blendFunc = null;
+    if (isSpecialLayer) {
+      blendFunc = [gl.ONE_MINUS_DST_COLOR, gl.ONE_MINUS_SRC_COLOR];
+    } else if (isAdditiveLayer) {
+      blendFunc = [gl.ONE, gl.ONE];
+    } else {
+      blendFunc = [gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA];
+    }
+    drawLayer(layer, blendFunc, alpha);
+  }
+  for (const i of diffIndices.reverse()) {
+    const layer = layers[i];
+    if (!layer.visible || !layer.vertexBuffer || !layer.indexBuffer) continue;
+    const alpha = 1;
+    drawLayer(layer, [gl.ONE_MINUS_DST_COLOR, gl.ONE_MINUS_SRC_COLOR], alpha);
+  }
+  for (const i of drillIndices.reverse()) {
+    const layer = layers[i];
+    if (!layer.visible || !layer.vertexBuffer || !layer.indexBuffer) continue;
+    const alpha = 1;
+    drawLayer(layer, [gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA], alpha);
+  }
+  for (const i of gdgggmIndices.reverse()) {
+    const layer = layers[i];
+    if (!layer.visible || !layer.vertexBuffer || !layer.indexBuffer) continue;
+    const alpha = 1;
+    drawLayer(layer, [gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA], alpha);
+  }
+  gl.disable(gl.STENCIL_TEST);
+}
+function sortLayersByOrder(layers2) {
+  return layers2.map((layer, originalIndex) => ({
+    layer,
+    originalIndex,
+    order: layer.order !== void 0 ? layer.order : 100,
+    displayName: getLayerDisplayName(layer)
+  })).sort((a, b) => {
+    const sigMatchA = a.displayName.match(/^SIG(\d+)$/i);
+    const sigMatchB = b.displayName.match(/^SIG(\d+)$/i);
+    if (sigMatchA && sigMatchB) {
+      const numA = parseInt(sigMatchA[1], 10);
+      const numB = parseInt(sigMatchB[1], 10);
+      return numA - numB;
+    }
+    if (sigMatchA || sigMatchB) {
+      return a.order - b.order;
+    }
+    const orderDiff = a.order - b.order;
+    if (orderDiff !== 0) return orderDiff;
+    return a.originalIndex - b.originalIndex;
+  });
+}
+function reassignColorsByOrder(layers2) {
+  const sortedLayers = sortLayersByOrder(layers2);
+  sortedLayers.forEach(({ layer, originalIndex }, colorIndex) => {
+    const hexColor = pickColor(colorIndex);
+    const rgb = hexToRgb(hexColor);
+    layer.hexColor = hexColor;
+    layer.color = [rgb.r, rgb.g, rgb.b];
+    layerColorMap.set(originalIndex, hexColor);
+    console.log(`[\u989C\u8272\u91CD\u65B0\u5206\u914D] ${layer.name}: order=${layer.order}, originalIndex=${originalIndex}, colorIndex=${colorIndex}, color=${hexColor}`);
+  });
+}
+function updatePhoLayerTypes(layers2) {
+  const phoFiles = layers2.filter((layer) => {
+    const fileNameOnly = (layer.name || "").split(/[/\\]/).pop();
+    const fileExtension = "." + fileNameOnly.split(".").pop().toUpperCase();
+    return fileExtension === ".PHO";
+  });
+  if (phoFiles.length === 0) return;
+  const prefixGroups = {};
+  for (const layer of phoFiles) {
+    const fileNameOnly = (layer.name || "").split(/[/\\]/).pop();
+    const nameUpper = fileNameOnly.toUpperCase();
+    let prefix = null;
+    let number = null;
+    if (nameUpper.startsWith("SST")) {
+      prefix = "sst";
+      const match = nameUpper.match(/^SST(\d+)/);
+      number = match ? parseInt(match[1], 10) : 0;
+    } else if (nameUpper.startsWith("SMD")) {
+      prefix = "smd";
+      const match = nameUpper.match(/^SMD(\d+)/);
+      number = match ? parseInt(match[1], 10) : 0;
+    } else if (nameUpper.startsWith("SM")) {
+      prefix = "sm";
+      const match = nameUpper.match(/^SM(\d+)/);
+      number = match ? parseInt(match[1], 10) : 0;
+    } else if (nameUpper.startsWith("ART")) {
+      prefix = "art";
+      const match = nameUpper.match(/^ART(\d+)/);
+      number = match ? parseInt(match[1], 10) : 0;
+    } else if (nameUpper.startsWith("SSB")) {
+      prefix = "ssb";
+      number = 0;
+    } else if (nameUpper.startsWith("DRL")) {
+      prefix = "drl";
+      number = 0;
+    } else if (nameUpper.startsWith("DD")) {
+      prefix = "dd";
+      number = 0;
+    }
+    if (prefix) {
+      if (!prefixGroups[prefix]) {
+        prefixGroups[prefix] = [];
+      }
+      prefixGroups[prefix].push({ layer, number, fileNameOnly });
+    }
+  }
+  for (const [prefix, files] of Object.entries(prefixGroups)) {
+    files.sort((a, b) => a.number - b.number);
+    for (let i = 0; i < files.length; i++) {
+      const { layer, number } = files[i];
+      const isSmallest = i === 0;
+      let layerType = null;
+      let order = null;
+      switch (prefix) {
+        case "sst":
+          layerType = "GTO";
+          order = 0;
+          break;
+        case "smd":
+          if (isSmallest) {
+            layerType = "GTP";
+            order = 1;
+          } else {
+            layerType = "GBP";
+            order = 7.5;
+          }
+          break;
+        case "sm":
+          if (isSmallest) {
+            layerType = "GTS";
+            order = 2;
+          } else {
+            layerType = "GBS";
+            order = 7;
+          }
+          break;
+        case "art":
+          if (isSmallest) {
+            layerType = "GTL";
+            order = 3;
+          } else {
+            layerType = "GBL";
+            order = 6;
+          }
+          break;
+        case "ssb":
+          layerType = "GBO";
+          order = 8;
+          break;
+        case "drl":
+          layerType = "DRL";
+          order = 200;
+          break;
+        case "dd":
+          layerType = null;
+          order = 201;
+          break;
+      }
+      if (order !== null) {
+        layer.order = order;
+        if (layerType) {
+          layer.phoLayerType = layerType;
+          console.log(`[PHO\u56FE\u5C42\u8BC6\u522B] ${layer.name}: \u524D\u7F00=${prefix}, \u6570\u5B57=${number}, \u7C7B\u578B=${layerType}, order=${order}`);
+        } else {
+          console.log(`[PHO\u56FE\u5C42\u8BC6\u522B] ${layer.name}: \u524D\u7F00=${prefix}, \u6570\u5B57=${number}, \u663E\u793A\u5B8C\u6574\u6587\u4EF6\u540D, order=${order}`);
+        }
+      }
+    }
+  }
+}
+fileInput.addEventListener("change", async (e) => {
+  const file = e.target.files[0];
+  if (!file) return;
+  showStatus(`Processing ${file.name}...`, "loading");
+  showFileInfo(file.name, file.size);
+  showLoading();
+  let filesToProcess = [];
+  const ext = "." + file.name.split(".").pop().toLowerCase();
+  try {
+    if (ext === ".zip") {
+      filesToProcess = await extractZip(file);
+    } else if (ext === ".rar") {
+      filesToProcess = await extractRar(file);
+    } else {
+      filesToProcess = [file];
+    }
+    if (filesToProcess.length === 0) {
+      showStatus("No Gerber files found.", "error");
+      hideLoading();
+      return;
+    }
+    filesToProcess.sort((a, b) => getLayerOrder(a.name) - getLayerOrder(b.name));
+    layers = [];
+    layerList.innerHTML = "";
+    layerColorMap.clear();
+    isSoloMode = false;
+    soloLayerOrder = [];
+    soloTargetLayerIndex = null;
+    cacheNeedsUpdate = true;
+    render();
+    let colorIndex = 0;
+    const pendingLayers = [];
+    for (let i = 0; i < filesToProcess.length; i++) {
+      const f = filesToProcess[i];
+      showStatus(`Parsing ${i + 1}/${filesToProcess.length}: ${f.name}...`, "loading");
+      const fileExt = "." + f.name.split(".").pop().toLowerCase();
+      const text = await f.text();
+      updateInheritedGerberFormatHintFromText(text, f.name);
+      const isTxFile = /^\.tx\d*$/i.test(fileExt) || fileExt === ".txt";
+      const isGbrFile = fileExt === ".gbr";
+      const isPhoFile = fileExt === ".pho";
+      const isArtFile = fileExt === ".art";
+      const isDrlFile = fileExt === ".drl" || fileExt === ".d" || fileExt === ".dri";
+      const isRouFile = fileExt === ".rou";
+      let isM48DrillFile = false;
+      let isSlotFile = false;
+      let useWebGerber = false;
+      let useDirectParser = false;
+      if (isTxFile) {
+        if (/slotholes/i.test(f.name)) {
+          isSlotFile = true;
+          console.log(`[SLOT] ${f.name} \u662F SlotHoles \u6587\u4EF6`);
+        }
+        const lines = text.trim().split("\n").slice(0, 10);
+        const hasM48 = lines.some((line) => /^M48$/i.test(line.trim()));
+        if (hasM48) {
+          isM48DrillFile = true;
+          useWebGerber = true;
+          if (isSlotFile) {
+            console.log(`[SLOT] ${f.name} \u662F Excellon SlotHoles \u6587\u4EF6\uFF08\u542BM48\uFF09\uFF0C\u4F7F\u7528 web-gerber \u89E3\u6790`);
+          } else {
+            console.log(`[\u94BB\u5B54] ${f.name} \u662F Excellon \u94BB\u5B54\u6587\u4EF6\uFF08\u542BM48\uFF09\uFF0C\u4F7F\u7528 web-gerber \u89E3\u6790`);
+          }
+        } else {
+          console.log(`[Gerber] ${f.name} \u662F TXT \u6587\u4EF6\u4F46\u4E0D\u542B M48\uFF0C\u4F7F\u7528 web-gerber \u89E3\u6790`);
+          useWebGerber = true;
+        }
+      } else if (isGbrFile) {
+        console.log(`[Gerber] ${f.name} \u662F GBR \u6587\u4EF6\uFF0C\u4F7F\u7528 web-gerber \u89E3\u6790`);
+        useWebGerber = true;
+      } else if (isPhoFile) {
+        console.log(`[Gerber] ${f.name} \u662F PHO \u6587\u4EF6\uFF0C\u4F7F\u7528 web-gerber \u89E3\u6790`);
+        useWebGerber = true;
+      } else if (isArtFile) {
+        console.log(`[Gerber] ${f.name} \u662F ART \u6587\u4EF6\uFF0C\u4F7F\u7528 web-gerber \u89E3\u6790`);
+        useWebGerber = true;
+      } else if (isDrlFile) {
+        console.log(`[\u94BB\u5B54] ${f.name} \u662F DRL \u94BB\u5B54\u6587\u4EF6\uFF0C\u4F7F\u7528 web-gerber \u89E3\u6790`);
+        isM48DrillFile = true;
+        useWebGerber = true;
+      } else if (isRouFile) {
+        console.log(`[\u94E3\u8FB9] ${f.name} \u662F ROU \u94E3\u8FB9\u6587\u4EF6\uFF0C\u4F7F\u7528 web-gerber \u89E3\u6790`);
+        useWebGerber = true;
+      } else {
+        const isCam350File = [".bot", ".top", ".sob", ".sot", ".ser", ".sst", ".ssb", ".smt", ".smb", ".pmt", ".pmb"].includes(fileExt);
+        if (isCam350File) {
+          console.log(`[Gerber] ${f.name} \u662F CAM350 \u683C\u5F0F\u6587\u4EF6\uFF0C\u4F7F\u7528 web-gerber \u89E3\u6790`);
+          useWebGerber = true;
+        } else {
+          const hasMacroDefinition = /%AM[A-Z0-9_]+\*/i.test(text);
+          const hasRegionFill = /G36\*/i.test(text);
+          if (hasMacroDefinition) {
+            console.log(`[\u5B8F\u5B9A\u4E49] ${f.name} \u5305\u542B Aperture Macro \u5B9A\u4E49\uFF0C\u4F7F\u7528 web-gerber \u89E3\u6790`);
+            useWebGerber = true;
+          } else if (hasRegionFill) {
+            console.log(`[\u533A\u57DF\u586B\u5145] ${f.name} \u5305\u542B G36 \u533A\u57DF\u586B\u5145\u547D\u4EE4\uFF0C\u4F7F\u7528 web-gerber \u89E3\u6790`);
+            useWebGerber = true;
+          }
+        }
+      }
+      try {
+        let data;
+        const fileNameOnly = f.name.split(/[/\\]/).pop();
+        const fileExtension = "." + fileNameOnly.split(".").pop().toUpperCase();
+        const fileNameUpper = fileNameOnly.toUpperCase();
+        const isOutlineLayer = getLayerDisplayName(f.name) === "GKO" || fileExtension === ".GKO" || fileExtension === ".GM" || /^\.GM\d+$/i.test(fileExtension) || fileNameUpper.includes("OUTLINE") || /EDGE[._-]CUTS/i.test(fileNameUpper) || fileNameUpper.includes("WX") || fileNameUpper.includes("BOARD") || fileNameUpper.startsWith("GKO") || fileNameUpper.startsWith("OUT");
+        const parserOpts = {
+          minLineWidth: isOutlineLayer ? 0.3 : 0
+          // 轮廓层（GKO、GM1等）最小线宽 0.3mm
+        };
+        if (isOutlineLayer) {
+          console.log(`[\u8F6E\u5ED3\u5C42] ${fileNameOnly}, minLineWidth=${parserOpts.minLineWidth}mm`);
+        }
+        if (useWebGerber) {
+          data = await parseWithWebGerber(text, f.name);
+          if ((!data.vertices || data.vertices.length === 0) && !isM48DrillFile) {
+            console.log(`[\u56DE\u9000] ${f.name} web-gerber \u65E0\u51E0\u4F55\u6570\u636E\uFF0C\u5C1D\u8BD5 GerberDirectParser`);
+            const parser = new GerberDirectParser(parserOpts);
+            data = parser.parse(text);
+            console.log(`[\u56DE\u9000\u7ED3\u679C] ${f.name}: ${data.vertices.length / 3} \u9876\u70B9, ${data.triangleIndices.length / 3} \u4E09\u89D2\u5F62`);
+          }
+        } else if (useDirectParser) {
+          console.log(`[\u76F4\u63A5\u89E3\u6790] \u5F00\u59CB\u89E3\u6790 ${f.name}`);
+          const parser = new GerberDirectParser(parserOpts);
+          data = parser.parse(text);
+          console.log(`[\u76F4\u63A5\u89E3\u6790] ${f.name}: ${data.vertices.length / 3} \u9876\u70B9, ${data.triangleIndices.length / 3} \u4E09\u89D2\u5F62`);
+        } else {
+          const parser = new GerberDirectParser(parserOpts);
+          data = parser.parse(text);
+        }
+        if (!data.vertices || data.vertices.length === 0) {
+          console.log(`[\u8DF3\u8FC7] ${f.name} \u6CA1\u6709\u51E0\u4F55\u6570\u636E`);
+          continue;
+        }
+        let featureExtractionVertices = null;
+        const refLayerFileName = f.name.split(/[/\\]/).pop();
+        const refLayerExt = "." + refLayerFileName.split(".").pop().toUpperCase();
+        const refLayerExtName = refLayerExt.substring(1);
+        const logicalLayerType = getLayerDisplayName(f.name);
+        const isRefLayer = ["GTS", "GBS", "GTL", "GBL"].includes(refLayerExtName) || ["GTS", "GBS", "GTL", "GBL"].includes(logicalLayerType);
+        if (isRefLayer && !useWebGerber) {
+          console.log(`[\u7279\u5F81\u63D0\u53D6] ${f.name} (${refLayerExtName}) \u989D\u5916\u7528web-gerber\u89E3\u6790\u4EE5\u63D0\u53D6\u5706\u5FC3`);
+          try {
+            const originalLog = console.log;
+            const silencedPatterns = ["[web-gerber]", "plotResult", "SVG", "Child"];
+            console.log = (...args) => {
+              const message = args.join(" ");
+              if (!silencedPatterns.some((pattern) => message.includes(pattern))) {
+                originalLog.apply(console, args);
+              }
+            };
+            const featureData = await parseWithWebGerber(text, f.name);
+            console.log = originalLog;
+            if (featureData && featureData.vertices && featureData.vertices.length > 0) {
+              featureExtractionVertices = featureData.vertices;
+              console.log(`[\u7279\u5F81\u63D0\u53D6] ${f.name} \u2713 \u63D0\u53D6\u5230 ${featureExtractionVertices.length / 3} \u4E2A\u9876\u70B9\u7528\u4E8E\u5706\u5FC3\u8BC6\u522B`);
+            }
+          } catch (err) {
+            console.log = console.log.bind(console);
+            console.warn(`[\u7279\u5F81\u63D0\u53D6] ${f.name} \u2717 web-gerber\u89E3\u6790\u5931\u8D25:`, err.message);
+          }
+        }
+        let minX = Infinity, maxX = -Infinity, minY = Infinity, maxY = -Infinity;
+        for (let k = 0; k < data.vertices.length; k += 3) {
+          const x = data.vertices[k];
+          const y = data.vertices[k + 1];
+          minX = Math.min(minX, x);
+          maxX = Math.max(maxX, x);
+          minY = Math.min(minY, y);
+          maxY = Math.max(maxY, y);
+        }
+        const bounds = { minX, minY, maxX, maxY };
+        const hexColor = pickColor(colorIndex);
+        const rgb = hexToRgb(hexColor);
+        colorIndex++;
+        const vertexBuffer = gl.createBuffer();
+        gl.bindBuffer(gl.ARRAY_BUFFER, vertexBuffer);
+        gl.bufferData(gl.ARRAY_BUFFER, data.vertices, gl.STATIC_DRAW);
+        const indexBuffer = gl.createBuffer();
+        gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, indexBuffer);
+        gl.bufferData(gl.ELEMENT_ARRAY_BUFFER, data.triangleIndices, gl.STATIC_DRAW);
+        let rawVerticesForFeatureExtraction = null;
+        if (featureExtractionVertices) {
+          rawVerticesForFeatureExtraction = featureExtractionVertices;
+        } else if (isRefLayer && useWebGerber) {
+          rawVerticesForFeatureExtraction = data.vertices;
+        } else if (isM48DrillFile || isDrlFile) {
+          rawVerticesForFeatureExtraction = data.vertices;
+        }
+        pendingLayers.push({
+          name: f.name,
+          visible: true,
+          color: [rgb.r, rgb.g, rgb.b],
+          hexColor,
+          // vertices: Array.from(data.vertices), // 不再保留 CPU 端数据以节省内存
+          // indices: Array.from(data.triangleIndices),
+          vertexBuffer,
+          indexBuffer,
+          vertexCount: data.triangleIndices.length,
+          // Gerber LP（LPC/LPD）极性段落：用于 stencil 挖空（主要影响铜层大面积铺铜的“避空/开窗”）
+          polarityRuns: data.polarityRuns || null,
+          // Drill：记录每个孔(或中心+尺寸形状)的顶点区间，用于后续“只缩放孔位、不缩放孔径”的修正
+          drillPosScaleRuns: data.drillPosScaleRuns || null,
+          order: getLayerOrder(f.name),
+          isDrillFile: isM48DrillFile,
+          isSlotFile,
+          bounds,
+          // rawVertices用于特征提取（钻孔层用渲染顶点，参考层用web-gerber生成的专用顶点）
+          rawVertices: rawVerticesForFeatureExtraction
+        });
+        console.log(`[\u6210\u529F] ${f.name}: ${data.vertices.length / 3} \u9876\u70B9, ${data.triangleIndices.length / 3} \u4E09\u89D2\u5F62`);
+      } catch (error) {
+        console.error(`[\u9519\u8BEF] \u89E3\u6790\u6587\u4EF6 ${f.name} \u5931\u8D25:`, error.message);
+      }
+      if (i < filesToProcess.length - 1) {
+        await new Promise((resolve) => setTimeout(resolve, 0));
+      }
+    }
+    if (pendingLayers.length === 0) {
+      showStatus("No geometry generated.", "error");
+      hideLoading();
+      return;
+    }
+    layers = pendingLayers;
+    updatePhoLayerTypes(layers);
+    reassignColorsByOrder(layers);
+    checkDrillLayerAlignment();
+    const totalTris = layers.reduce((sum, l) => sum + l.vertexCount / 3, 0);
+    showStatus(`\u2713 Rendered ${layers.length} layers (${Math.floor(totalTris)} tris)`, "success");
+    hideLoading();
+    updateLayerList();
+    cacheNeedsUpdate = true;
+    centerView();
+  } catch (err) {
+    console.error(err);
+    showStatus("\u2717 Error: " + err.message, "error");
+    hideLoading();
+  }
+});
+function showStatus(msg, type = "") {
+  status.textContent = msg;
+  status.className = `status ${type}`;
+}
+function showFileInfo(name, size) {
+  fileName.textContent = name;
+  fileSize.textContent = (size / 1024).toFixed(2) + " KB";
+  fileInfo.classList.add("active");
+}
+function updateLayerList() {
+  layerList.innerHTML = "";
+  const sortedLayers = sortLayersByOrder(layers);
+  console.log("[\u56FE\u5C42\u5217\u8868\u6392\u5E8F] \u6392\u5E8F\u540E\u7684\u56FE\u5C42\u987A\u5E8F:");
+  sortedLayers.forEach(({ layer, originalIndex }, index) => {
+    const displayName = getLayerDisplayName(layer);
+    console.log(`  ${index + 1}. ${displayName} (order=${layer.order || 100}, originalIndex=${originalIndex})`);
+  });
+  sortedLayers.forEach(({ layer, originalIndex }, displayIndex) => {
+    const item = document.createElement("div");
+    item.className = layer.visible ? "layer-item" : "layer-item disabled";
+    const indexSpan = document.createElement("span");
+    indexSpan.className = "layer-index";
+    indexSpan.textContent = displayIndex + 1;
+    const toggle = document.createElement("div");
+    toggle.className = `layer-toggle ${layer.visible ? "checked" : ""}`;
+    toggle.onclick = (e) => {
+      e.stopPropagation();
+      toggleLayer(originalIndex);
+    };
+    const colorBox = document.createElement("div");
+    colorBox.className = "layer-color";
+    if (!layer.visible) {
+      colorBox.style.backgroundColor = "#cccccc";
+    } else {
+      let displayColor = layer.hexColor;
+      if (layerColorMap.has(originalIndex)) {
+        displayColor = layerColorMap.get(originalIndex);
+      }
+      colorBox.style.backgroundColor = displayColor;
+    }
+    const nameSpan = document.createElement("div");
+    nameSpan.className = "layer-name";
+    let displayName = getLayerDisplayName(layer);
+    if (layer.isSlotFile) {
+      displayName = "SLOT";
+    } else if (layer.isDrillFile) {
+      const fileName2 = layer.name;
+      if (/[_\s]via/i.test(fileName2)) {
+        displayName = "VIA";
+      } else {
+        displayName = "DRL";
+      }
+    }
+    nameSpan.textContent = displayName;
+    nameSpan.setAttribute("title", layer.name);
+    nameSpan.addEventListener("dblclick", (e) => {
+      e.stopPropagation();
+      soloLayer(originalIndex);
+    });
+    item.appendChild(indexSpan);
+    item.appendChild(toggle);
+    item.appendChild(colorBox);
+    item.appendChild(nameSpan);
+    layerList.appendChild(item);
+  });
+  updateToggleAllState();
+}
+function toggleLayer(index) {
+  if (index < 0 || index >= layers.length) return;
+  layers[index].visible = !layers[index].visible;
+  if (isSoloMode) {
+    if (layers[index].visible) {
+      if (soloLayerOrder.indexOf(index) === -1) {
+        soloLayerOrder.push(index);
+        if (layerColorMap.has(index)) {
+          const existingColor = layerColorMap.get(index);
+          updateLayerColor(index, existingColor);
+        } else {
+          const colorIndex = layerColorMap.size;
+          const newColor = pickColor(colorIndex);
+          layerColorMap.set(index, newColor);
+          updateLayerColor(index, newColor);
+        }
+      } else {
+        if (layerColorMap.has(index)) {
+          const existingColor = layerColorMap.get(index);
+          updateLayerColor(index, existingColor);
+        }
+      }
+    }
+  }
+  updateLayerList();
+  cacheNeedsUpdate = true;
+}
+function soloLayer(targetLayerIndex) {
+  console.log(`\u5355\u72EC\u663E\u793A\u56FE\u5C42 ${targetLayerIndex}`);
+  isSoloMode = true;
+  layerColorMap.clear();
+  soloLayerOrder = [];
+  layers.forEach((layer, index) => {
+    layer.visible = false;
+  });
+  layers[targetLayerIndex].visible = true;
+  soloLayerOrder.push(targetLayerIndex);
+  soloTargetLayerIndex = targetLayerIndex;
+  const newColor = baseColors[0];
+  layerColorMap.set(targetLayerIndex, newColor);
+  updateLayerColor(targetLayerIndex, newColor);
+  updateLayerList();
+  cacheNeedsUpdate = true;
+  console.log(`\u56FE\u5C42 ${targetLayerIndex} \u989C\u8272\u91CD\u7F6E\u4E3A: ${newColor}`);
+}
+function updateLayerColor(layerIndex, hexColor) {
+  if (layerIndex < 0 || layerIndex >= layers.length) return;
+  const layer = layers[layerIndex];
+  const rgb = hexToRgb(hexColor);
+  layer.color = [rgb.r, rgb.g, rgb.b];
+  layer.hexColor = hexColor;
+}
+layerToggleAll.onclick = () => {
+  if (layers.length === 0) return;
+  const allVisible = layers.every((l) => l.visible);
+  const newVisible = !allVisible;
+  if (isSoloMode && !allVisible) {
+    const sortedLayers = layers.map((layer, idx) => ({ layer, idx })).sort((a, b) => (a.layer.order || 100) - (b.layer.order || 100));
+    soloLayerOrder = [];
+    let colorIndex = 1;
+    sortedLayers.forEach(({ layer, idx }) => {
+      layer.visible = true;
+      if (idx === soloTargetLayerIndex) {
+        const newColor = baseColors[0];
+        layerColorMap.set(idx, newColor);
+        updateLayerColor(idx, newColor);
+        soloLayerOrder.push(idx);
+      } else {
+        const newColor = pickColor(colorIndex);
+        layerColorMap.set(idx, newColor);
+        updateLayerColor(idx, newColor);
+        soloLayerOrder.push(idx);
+        colorIndex++;
+      }
+    });
+    console.log("solo\u6A21\u5F0F\u4E0B\u5168\u90E8\u663E\u793A\uFF0C\u53CC\u51FB\u7684\u56FE\u5C42\u4FDD\u6301\u7EA2\u8272\uFF0C\u5176\u4F59\u56FE\u5C42\u6309\u6392\u5E8F\u987A\u5E8F\u5206\u914D\u989C\u8272");
+  } else {
+    layers.forEach((layer) => {
+      layer.visible = newVisible;
+    });
+  }
+  updateLayerList();
+  cacheNeedsUpdate = true;
+};
+function updateToggleAllState() {
+  const allVisible = layers.every((l) => l.visible);
+  if (allVisible) {
+    layerToggleAllCheckbox.classList.add("checked");
+  } else {
+    layerToggleAllCheckbox.classList.remove("checked");
+  }
+}
+async function extractZip(file) {
+  const files = [];
+  try {
+    const zip = await import_jszip.default.loadAsync(file);
+    for (const [filename, zipEntry] of Object.entries(zip.files)) {
+      if (!zipEntry.dir && isGerberFile(filename)) {
+        const blob = await zipEntry.async("blob");
+        files.push(new File([blob], filename));
+      }
+    }
+  } catch (e) {
+    console.error(e);
+    throw new Error("Failed to unzip");
+  }
+  return files;
+}
+function isGerberFile(fileName2) {
+  const fileNameOnly = fileName2.split(/[/\\]/).pop();
+  const fileNameUpper = fileNameOnly.toUpperCase();
+  const specialSuffixes = ["_SST", "_PMT", "_SMT", "_TOP", "_SMB", "_PMB", "_SSB", "OUTLINE"];
+  for (const suffix of specialSuffixes) {
+    if (fileNameUpper.endsWith(suffix) || fileNameUpper.includes(suffix + ".")) {
+      return true;
+    }
+  }
+  if (/.*_INT\d+$/i.test(fileNameUpper) || /.*_INT\d+\./i.test(fileNameUpper)) {
+    return true;
+  }
+  const validExtensions = [
+    ".gtl",
+    ".gbl",
+    ".gts",
+    ".gbs",
+    ".gto",
+    ".gbo",
+    ".gtp",
+    ".gbp",
+    ".gm1",
+    ".drl",
+    ".gbr",
+    ".gko",
+    ".gdl",
+    ".gdd",
+    ".gm",
+    ".gd1",
+    ".gg1",
+    ".gpb",
+    ".gpt",
+    ".txt",
+    ".art",
+    ".d",
+    ".rou",
+    ".pho",
+    // 新增：CAM350 等软件导出的扩展名
+    ".bot",
+    ".top",
+    ".sob",
+    ".sot",
+    ".dri",
+    ".ser",
+    ".sst",
+    ".ssb",
+    ".smt",
+    ".smb",
+    ".pmt",
+    ".pmb"
+  ];
+  const fileExtension = "." + fileNameOnly.split(".").pop().toLowerCase();
+  return validExtensions.includes(fileExtension) || /^\.g\d+$/i.test(fileExtension) || /^\.gm\d+$/i.test(fileExtension) || /^\.gp\d+$/i.test(fileExtension) || /^\.tx\d+$/i.test(fileExtension) || /^\.int\d+$/i.test(fileExtension);
+}
+function checkDrillLayerAlignment() {
+  const drillLayers = layers.filter((layer) => layer.isDrillFile || layer.isSlotFile);
+  if (drillLayers.length === 0) {
+    console.log("[\u94BB\u5B54\u5BF9\u9F50] \u672A\u627E\u5230\u94BB\u5B54\u5C42\uFF0C\u8DF3\u8FC7");
+    return;
+  }
+  const combineBounds = (layersToCombine) => {
+    let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
+    for (const l of layersToCombine) {
+      if (!l || !l.bounds) continue;
+      minX = Math.min(minX, l.bounds.minX);
+      minY = Math.min(minY, l.bounds.minY);
+      maxX = Math.max(maxX, l.bounds.maxX);
+      maxY = Math.max(maxY, l.bounds.maxY);
+    }
+    if (!Number.isFinite(minX) || !Number.isFinite(minY) || !Number.isFinite(maxX) || !Number.isFinite(maxY)) {
+      return null;
+    }
+    return { minX, minY, maxX, maxY };
+  };
+  const translateBounds = (b, dx, dy) => ({
+    minX: b.minX + dx,
+    maxX: b.maxX + dx,
+    minY: b.minY + dy,
+    maxY: b.maxY + dy
+  });
+  const computeOverflow = (b, ref) => {
+    const left = Math.max(0, ref.minX - b.minX);
+    const right = Math.max(0, b.maxX - ref.maxX);
+    const bottom = Math.max(0, ref.minY - b.minY);
+    const top = Math.max(0, b.maxY - ref.maxY);
+    const total = left + right + bottom + top;
+    return { left, right, bottom, top, total };
+  };
+  const outlineLayer = layers.find((layer) => {
+    const fileNameOnly = (layer.name || "").split(/[/\\]/).pop();
+    const fileExtension = "." + fileNameOnly.split(".").pop().toUpperCase();
+    const ext = fileExtension.substring(1);
+    const upper = fileNameOnly.toUpperCase();
+    return ext === "GKO" || ext === "GM" || /^GM\d+$/i.test(ext) || upper.includes("_PROFILE") || upper.includes("PROFILE") || upper.includes("OUTLINE") || upper.includes("BOARD") || upper.startsWith("GKO");
+  });
+  let outlineBounds = outlineLayer && outlineLayer.bounds ? outlineLayer.bounds : null;
+  let combinedDrillBounds = combineBounds(drillLayers);
+  if (!combinedDrillBounds) {
+    console.log("[\u94BB\u5B54\u5BF9\u9F50] \u65E0\u6CD5\u8BA1\u7B97\u94BB\u5B54\u5C42 bounds\uFF0C\u8DF3\u8FC7");
+    return;
+  }
+  const getLayerType = (name) => getLayerDisplayName(name);
+  const sizeOfBounds = (b) => Math.max(b.maxX - b.minX, b.maxY - b.minY);
+  if (outlineBounds) {
+    const priority = ["GTL", "GBL", "GTS", "GBS"];
+    let ref = null;
+    for (const t of priority) {
+      const l = layers.find((x) => x && x.bounds && !x.isDrillFile && !x.isSlotFile && getLayerType(x.name) === t);
+      if (l) {
+        ref = { name: l.name, bounds: l.bounds, reason: t };
+        break;
+      }
+    }
+    if (!ref) {
+      const any = layers.find((x) => x && x.bounds && !x.isDrillFile && !x.isSlotFile);
+      if (any) ref = { name: any.name, bounds: any.bounds, reason: "any" };
+    }
+    if (ref && ref.bounds) {
+      const outlineSize = sizeOfBounds(outlineBounds);
+      const refSize = sizeOfBounds(ref.bounds);
+      const ratio = refSize > 0 ? outlineSize / refSize : Infinity;
+      if (Number.isFinite(ratio) && ratio > 5) {
+        console.warn(`[\u94BB\u5B54\u5BF9\u9F50] \u26A0\uFE0F Outline(${outlineLayer?.name || "unknown"}) \u5C3A\u5BF8=${outlineSize.toFixed(3)}mm \u8FDC\u5927\u4E8E\u53C2\u8003\u5C42(${ref.reason}): ${ref.name} \u5C3A\u5BF8=${refSize.toFixed(3)}mm (ratio=${ratio.toFixed(2)})\uFF0C\u5224\u5B9A\u4E3A\u201C\u4E0D\u53EF\u4FE1Outline\u201D\uFF0C\u5C06\u8DF3\u8FC7GKO\u515C\u5E95\u5E76\u7528\u94DC\u5C42\u505A\u5BF9\u9F50\u53C2\u8003\u3002`);
+        outlineBounds = null;
+      }
+    }
+  }
+  const pickReferenceForScale = () => {
+    if (outlineBounds) return { name: outlineLayer.name, bounds: outlineBounds, reason: "outline" };
+    const priority = ["GTL", "GBL", "GTS", "GBS"];
+    for (const t of priority) {
+      const l = layers.find((x) => x && x.bounds && !x.isDrillFile && !x.isSlotFile && getLayerType(x.name) === t);
+      if (l) return { name: l.name, bounds: l.bounds, reason: t };
+    }
+    const any = layers.find((x) => x && x.bounds && !x.isDrillFile && !x.isSlotFile);
+    if (any) return { name: any.name, bounds: any.bounds, reason: "any" };
+    return null;
+  };
+  const decidePow10ScaleFix = (ratio) => {
+    if (!Number.isFinite(ratio) || ratio <= 0) return 1;
+    const acceptLow = 0.7;
+    const acceptHigh = 1.3;
+    if (ratio > 2) {
+      const pow10 = Math.pow(10, Math.round(Math.log10(ratio)));
+      const cand = 1 / pow10;
+      const newRatio = ratio * cand;
+      if (cand !== 1 && newRatio >= acceptLow && newRatio <= acceptHigh) return cand;
+    } else if (ratio < 0.5) {
+      const inv = 1 / ratio;
+      const pow10 = Math.pow(10, Math.round(Math.log10(inv)));
+      const cand = pow10;
+      const newRatio = ratio * cand;
+      if (cand !== 1 && newRatio >= acceptLow && newRatio <= acceptHigh) return cand;
+    }
+    return 1;
+  };
+  const applyPosScaleFixToDrills = (scaleX, scaleY, tag) => {
+    const isUniform = scaleX === scaleY;
+    if (isUniform) {
+      console.warn(`[\u94BB\u5B54\u5BF9\u9F50] \u26A0\uFE0F \u5E94\u7528\u94BB\u5B54\u5750\u6807\u7F29\u653E(${tag}): scale=${scaleX}\uFF08\u4EC5\u7F29\u653E\u5B54\u4F4D\uFF0C\u4E0D\u7F29\u653E\u5B54\u5F84\uFF09`);
+    } else {
+      console.warn(`[\u94BB\u5B54\u5BF9\u9F50] \u26A0\uFE0F \u5E94\u7528\u94BB\u5B54\u5750\u6807\u7F29\u653E(${tag}): scaleX=${scaleX}, scaleY=${scaleY}\uFF08\u4EC5\u7F29\u653E\u5B54\u4F4D\uFF0C\u4E0D\u7F29\u653E\u5B54\u5F84\uFF09`);
+    }
+    for (const dl of drillLayers) {
+      if (!dl.rawVertices || !dl.drillPosScaleRuns || dl.drillPosScaleRuns.length === 0) continue;
+      const vertices = dl.rawVertices;
+      const runs = dl.drillPosScaleRuns;
+      for (const run of runs) {
+        if (!run || !(run.count > 0) || run.start == null) continue;
+        const dx = (run.cx || 0) * (scaleX - 1);
+        const dy = (run.cy || 0) * (scaleY - 1);
+        const start = run.start * 3;
+        const end = (run.start + run.count) * 3;
+        for (let i = start; i < end; i += 3) {
+          vertices[i] += dx;
+          vertices[i + 1] += dy;
+        }
+        run.cx = (run.cx || 0) * scaleX;
+        run.cy = (run.cy || 0) * scaleY;
+      }
+      gl.bindBuffer(gl.ARRAY_BUFFER, dl.vertexBuffer);
+      gl.bufferData(gl.ARRAY_BUFFER, vertices, gl.STATIC_DRAW);
+      let minX = Infinity, maxX = -Infinity, minY = Infinity, maxY = -Infinity;
+      for (let k = 0; k < vertices.length; k += 3) {
+        const x = vertices[k];
+        const y = vertices[k + 1];
+        minX = Math.min(minX, x);
+        maxX = Math.max(maxX, x);
+        minY = Math.min(minY, y);
+        maxY = Math.max(maxY, y);
+      }
+      dl.bounds = { minX, minY, maxX, maxY };
+      if (isUniform) {
+        console.log(`[\u94BB\u5B54\u5BF9\u9F50] \u2713 ${dl.name} \u5DF2\u5E94\u7528\u5750\u6807\u7F29\u653E scale=${scaleX}`);
+      } else {
+        console.log(`[\u94BB\u5B54\u5BF9\u9F50] \u2713 ${dl.name} \u5DF2\u5E94\u7528\u5750\u6807\u7F29\u653E scaleX=${scaleX}, scaleY=${scaleY}`);
+      }
+    }
+  };
+  const refForScale = pickReferenceForScale();
+  if (refForScale && refForScale.bounds) {
+    const refBounds = refForScale.bounds;
+    const refWidth = refBounds.maxX - refBounds.minX;
+    const refHeight = refBounds.maxY - refBounds.minY;
+    const drillWidth = combinedDrillBounds.maxX - combinedDrillBounds.minX;
+    const drillHeight = combinedDrillBounds.maxY - combinedDrillBounds.minY;
+    const holeCount = drillLayers.reduce((n, dl) => n + (dl && dl.drillPosScaleRuns ? dl.drillPosScaleRuns.length : 0), 0);
+    const overflowToRef = computeOverflow(combinedDrillBounds, refBounds);
+    const refSize = Math.max(refWidth, refHeight);
+    const inRef = overflowToRef.total <= 1e-3;
+    if (inRef) {
+      console.log(`[\u94BB\u5B54\u5BF9\u9F50] \u2139\uFE0F Drill bounds \u5DF2\u5728\u53C2\u8003\u5C42(${refForScale.reason})\u8303\u56F4\u5185(holes=${holeCount}, drillW=${drillWidth.toFixed(3)}, drillH=${drillHeight.toFixed(3)}), \u8DF3\u8FC7 bounds-fit \u5750\u6807\u7F29\u653E\u515C\u5E95`);
+    } else if (holeCount > 0 && holeCount < 50 && overflowToRef.total < refSize * 0.2) {
+      console.log(`[\u94BB\u5B54\u5BF9\u9F50] \u2139\uFE0F Drill \u5B54\u6570\u8F83\u5C11(${holeCount})\u4E14\u8D8A\u754C\u4E0D\u660E\u663E(total=${overflowToRef.total.toFixed(3)}mm)\uFF0C\u8DF3\u8FC7 bounds-fit \u5750\u6807\u7F29\u653E\u515C\u5E95`);
+    } else {
+      const ratioX = drillWidth > 0 && refWidth > 0 ? drillWidth / refWidth : 1;
+      const ratioY = drillHeight > 0 && refHeight > 0 ? drillHeight / refHeight : 1;
+      const scaleX = decidePow10ScaleFix(ratioX);
+      const scaleY = decidePow10ScaleFix(ratioY);
+      if ((scaleX !== 1 || scaleY !== 1) && scaleX !== scaleY) {
+        console.warn(`[\u94BB\u5B54\u5BF9\u9F50] \u26A0\uFE0F bounds-fit \u63A8\u65AD\u4E3A\u975E\u7B49\u6BD4(scaleX=${scaleX}, scaleY=${scaleY})\uFF0C\u4E3A\u907F\u514D\u8BEF\u7F29\u653E\u5DF2\u5FFD\u7565\uFF1B\u5C06\u8F6C\u800C\u5C1D\u8BD5\u5E73\u79FB/\u7279\u5F81\u70B9\u5BF9\u9F50`);
+      } else if (scaleX !== 1 || scaleY !== 1) {
+        console.warn(`[\u94BB\u5B54\u5BF9\u9F50] \u26A0\uFE0F Drill bounds \u500D\u6570\u5F02\u5E38\uFF1AdrillW=${drillWidth.toFixed(3)} drillH=${drillHeight.toFixed(3)} refW=${refWidth.toFixed(3)} refH=${refHeight.toFixed(3)} ratioX=${ratioX.toFixed(2)} ratioY=${ratioY.toFixed(2)} ref=${refForScale.name}(${refForScale.reason}) \u2192 \u5C1D\u8BD5 scaleX=${scaleX} scaleY=${scaleY}`);
+        applyPosScaleFixToDrills(scaleX, scaleY, `bounds-fit (ref=${refForScale.reason})`);
+        combinedDrillBounds = combineBounds(drillLayers) || combinedDrillBounds;
+      }
+    }
+  } else {
+    console.log("[\u94BB\u5B54\u5BF9\u9F50] \u672A\u627E\u5230\u53C2\u8003\u5C42 bounds\uFF0C\u8DF3\u8FC7\u94BB\u5B54\u5750\u6807\u7F29\u653E\u515C\u5E95");
+  }
+  let overflowBefore = null;
+  if (outlineBounds) {
+    overflowBefore = computeOverflow(combinedDrillBounds, outlineBounds);
+    console.log(`[\u94BB\u5B54\u5BF9\u9F50] GKO/Outline\u5C42: ${outlineLayer.name}`);
+    console.log(`[\u94BB\u5B54\u5BF9\u9F50] Drill bounds(before): minX=${combinedDrillBounds.minX.toFixed(3)}, minY=${combinedDrillBounds.minY.toFixed(3)}, maxX=${combinedDrillBounds.maxX.toFixed(3)}, maxY=${combinedDrillBounds.maxY.toFixed(3)}`);
+    console.log(`[\u94BB\u5B54\u5BF9\u9F50] Outline bounds:      minX=${outlineBounds.minX.toFixed(3)}, minY=${outlineBounds.minY.toFixed(3)}, maxX=${outlineBounds.maxX.toFixed(3)}, maxY=${outlineBounds.maxY.toFixed(3)}`);
+    console.log(`[\u94BB\u5B54\u5BF9\u9F50] Overflow(before): left=${overflowBefore.left.toFixed(3)} right=${overflowBefore.right.toFixed(3)} bottom=${overflowBefore.bottom.toFixed(3)} top=${overflowBefore.top.toFixed(3)} total=${overflowBefore.total.toFixed(3)} (mm)`);
+  } else {
+    console.log("[\u94BB\u5B54\u5BF9\u9F50] \u672A\u627E\u5230GKO/Outline\u5C42\uFF0C\u5C06\u4EC5\u4F7F\u7528\u7279\u5F81\u70B9\u5339\u914D\u5BF9\u9F50\uFF08\u82E5\u53EF\u7528\uFF09");
+  }
+  const applyOffsetToAllDrills = (dx, dy, tag) => {
+    console.log(`[\u94BB\u5B54\u5BF9\u9F50] \u26A0\uFE0F \u5E94\u7528\u5168\u5C40\u504F\u79FB(${tag}): X=${dx.toFixed(3)}mm, Y=${dy.toFixed(3)}mm`);
+    for (const dl of drillLayers) {
+      if (!dl.rawVertices) continue;
+      const vertices = dl.rawVertices;
+      for (let k = 0; k < vertices.length; k += 3) {
+        vertices[k] += dx;
+        vertices[k + 1] += dy;
+      }
+      gl.bindBuffer(gl.ARRAY_BUFFER, dl.vertexBuffer);
+      gl.bufferData(gl.ARRAY_BUFFER, vertices, gl.STATIC_DRAW);
+      if (dl.bounds) {
+        dl.bounds.minX += dx;
+        dl.bounds.maxX += dx;
+        dl.bounds.minY += dy;
+        dl.bounds.maxY += dy;
+      }
+      console.log(`[\u94BB\u5B54\u5BF9\u9F50] \u2713 ${dl.name} \u5DF2\u5E94\u7528\u5168\u5C40\u504F\u79FB`);
+    }
+    if (outlineBounds) {
+      const afterBounds = translateBounds(combinedDrillBounds, dx, dy);
+      const overflowAfter = computeOverflow(afterBounds, outlineBounds);
+      console.log(`[\u94BB\u5B54\u5BF9\u9F50] Overflow(after):  left=${overflowAfter.left.toFixed(3)} right=${overflowAfter.right.toFixed(3)} bottom=${overflowAfter.bottom.toFixed(3)} top=${overflowAfter.top.toFixed(3)} total=${overflowAfter.total.toFixed(3)} (mm)`);
+    }
+    console.log("[\u94BB\u5B54\u5BF9\u9F50] \u5BF9\u9F50\u68C0\u67E5\u5B8C\u6210");
+  };
+  let featureOffset = null;
+  let anchorLayer = null;
+  let anchorFeatures = null;
+  let anchorCircleCount = 0;
+  let anchorScore = -Infinity;
+  let fallbackLayer = null;
+  let fallbackFeatures = null;
+  let fallbackScore = -Infinity;
+  for (const dl of drillLayers) {
+    if (!dl.rawVertices) continue;
+    const featsAll = extractFeaturesFromLayer(dl);
+    if (featsAll.length < 3) continue;
+    const nameUpper = (dl.name || "").toUpperCase();
+    const viaPenalty = /VIA/.test(nameUpper) ? 1e5 : 0;
+    const slotPenalty = dl.isSlotFile ? 5e4 : 0;
+    const circleFeats = featsAll.filter((f) => f && f.type === "circle");
+    const circleCount = circleFeats.length;
+    if (circleCount >= 3) {
+      const score = circleCount * 1e3 - viaPenalty - slotPenalty;
+      if (score > anchorScore) {
+        anchorScore = score;
+        anchorLayer = dl;
+        anchorFeatures = circleFeats;
+        anchorCircleCount = circleCount;
+      }
+    } else {
+      const score = featsAll.length - viaPenalty - slotPenalty;
+      if (score > fallbackScore) {
+        fallbackScore = score;
+        fallbackLayer = dl;
+        fallbackFeatures = featsAll;
+      }
+    }
+  }
+  if (!anchorLayer && fallbackLayer) {
+    anchorLayer = fallbackLayer;
+    anchorFeatures = fallbackFeatures;
+    anchorCircleCount = (anchorFeatures || []).filter((f) => f && f.type === "circle").length;
+  }
+  if (!anchorLayer || !anchorFeatures) {
+    console.log("[\u94BB\u5B54\u5BF9\u9F50] \u26A0\uFE0F \u672A\u627E\u5230\u53EF\u7528\u7684\u951A\u70B9\u94BB\u5B54\u5C42\uFF08\u7279\u5F81\u70B9\u4E0D\u8DB3\uFF09\uFF0C\u8DF3\u8FC7\u7279\u5F81\u70B9\u5BF9\u9F50");
+  } else {
+    console.log(`[\u94BB\u5B54\u5BF9\u9F50] \u9009\u5B9A\u951A\u70B9\u94BB\u5B54\u5C42: ${anchorLayer.name} (features=${anchorFeatures.length}, circle=${anchorCircleCount}, slot=${!!anchorLayer.isSlotFile})`);
+    const nonDrillLayers = layers.filter((layer) => !layer.isDrillFile && !layer.isSlotFile);
+    const getLayerType2 = (name) => getLayerDisplayName(name);
+    const refTypePriority = ["GTL", "GBL", "GTS", "GBS"];
+    const refCandidates = [];
+    for (const t of refTypePriority) {
+      for (const l of nonDrillLayers) {
+        if (!l || !l.rawVertices) continue;
+        if (getLayerType2(l.name) === t) refCandidates.push(l);
+      }
+    }
+    if (refCandidates.length === 0) {
+      console.log("[\u94BB\u5B54\u5BF9\u9F50] \u672A\u627E\u5230\u53EF\u7528\u53C2\u8003\u5C42\uFF08GTL/GBL/GTS/GBS \u6216\u7F3A\u5C11 rawVertices\uFF09\uFF0C\u8DF3\u8FC7\u7279\u5F81\u70B9\u5BF9\u9F50");
+    } else {
+      const selectedAnchorFeatures = selectFeaturesWithXYDistribution(anchorFeatures, Math.min(80, anchorFeatures.length));
+      let best = null;
+      let secondBest = null;
+      for (const refLayer of refCandidates) {
+        console.log(`[\u94BB\u5B54\u5BF9\u9F50] \u5C1D\u8BD5\u53C2\u8003\u5C42: ${refLayer.name}`);
+        const refAll = extractFeaturesFromLayer(refLayer);
+        const refCircle = refAll.filter((f) => f && f.type === "circle");
+        const refFeatures = refCircle.length >= 3 ? refCircle : refAll;
+        if (refFeatures.length < 3) {
+          console.log(`[\u94BB\u5B54\u5BF9\u9F50] \u53C2\u8003\u5C42\u7279\u5F81\u70B9\u4E0D\u8DB3\uFF08${refFeatures.length}\u4E2A\uFF09\uFF0C\u8DF3\u8FC7`);
+          continue;
+        }
+        const selectedRefFeatures = selectFeaturesWithXYDistribution(refFeatures, Math.min(80, refFeatures.length));
+        const vote = estimateOffsetByVoting(selectedAnchorFeatures, selectedRefFeatures, { binSize: 0.2, maxCount: 80, minVotes: 3 });
+        if (!vote) {
+          console.log("[\u94BB\u5B54\u5BF9\u9F50] \u5E73\u79FB\u6295\u7968\u672A\u5F97\u5230\u7A33\u5B9A\u5019\u9009");
+        } else {
+          const tolLoose = 0.6;
+          const tolRefine = 0.3;
+          const tolTight = 0.2;
+          const vRef = verifyOffset(anchorFeatures, refFeatures, vote.dx, vote.dy, tolRefine);
+          if (vRef.matchCount >= 2) {
+            let sumDx = 0, sumDy = 0;
+            for (const p of vRef.matchedPairs) {
+              sumDx += p.refPoint.x - p.drillPoint.x;
+              sumDy += p.refPoint.y - p.drillPoint.y;
+            }
+            const refinedDx = sumDx / vRef.matchedPairs.length;
+            const refinedDy = sumDy / vRef.matchedPairs.length;
+            const vTight = verifyOffset(anchorFeatures, refFeatures, refinedDx, refinedDy, tolTight);
+            const vLoose = verifyOffset(anchorFeatures, refFeatures, refinedDx, refinedDy, tolLoose);
+            const cand = {
+              dx: refinedDx,
+              dy: refinedDy,
+              matchTight: vTight.matchCount,
+              maxErrorTight: vTight.maxError,
+              avgErrorTight: vTight.avgError,
+              matchLoose: vLoose.matchCount,
+              maxErrorLoose: vLoose.maxError,
+              avgErrorLoose: vLoose.avgError,
+              refType: getLayerType2(refLayer.name),
+              refTypeRank: { GTL: 0, GBL: 1, GTS: 2, GBS: 3 }[getLayerType2(refLayer.name)] ?? 9,
+              refLayerName: refLayer.name,
+              method: `vote(bin=${vote.binSize}, votes=${vote.votes})`
+            };
+            const isBetter = (a, b) => {
+              if (!b) return true;
+              if (a.matchTight !== b.matchTight) return a.matchTight > b.matchTight;
+              if (a.avgErrorTight !== b.avgErrorTight) return a.avgErrorTight < b.avgErrorTight;
+              if (a.matchLoose !== b.matchLoose) return a.matchLoose > b.matchLoose;
+              if (a.avgErrorLoose !== b.avgErrorLoose) return a.avgErrorLoose < b.avgErrorLoose;
+              if ((a.refTypeRank ?? 9) !== (b.refTypeRank ?? 9)) return (a.refTypeRank ?? 9) < (b.refTypeRank ?? 9);
+              const sa = Math.abs(a.dx) + Math.abs(a.dy);
+              const sb = Math.abs(b.dx) + Math.abs(b.dy);
+              if (sa !== sb) return sa < sb;
+              return false;
+            };
+            if (isBetter(cand, best)) {
+              secondBest = best;
+              best = cand;
+            } else if (isBetter(cand, secondBest)) {
+              secondBest = cand;
+            }
+            console.log(`[\u94BB\u5B54\u5BF9\u9F50] \u6295\u7968\u5019\u9009: dx=${cand.dx.toFixed(3)} dy=${cand.dy.toFixed(3)} tight=${cand.matchTight} loose=${cand.matchLoose} errT(avg/max)=${(cand.avgErrorTight ?? 0).toFixed(3)}/${(cand.maxErrorTight ?? 0).toFixed(3)} (${cand.method})`);
+          } else {
+            console.log(`[\u94BB\u5B54\u5BF9\u9F50] \u6295\u7968\u5019\u9009\u5339\u914D\u4E0D\u8DB3\uFF08matchRef=${vRef.matchCount}\uFF09\uFF0C\u5FFD\u7565`);
+          }
+        }
+      }
+      const totalAnchor = anchorFeatures?.length || 0;
+      const minMatches = totalAnchor <= 10 ? 3 : totalAnchor <= 50 ? 5 : Math.max(8, Math.ceil(totalAnchor * 0.02));
+      const bestTight = best?.matchTight ?? 0;
+      const secondTight = secondBest?.matchTight ?? 0;
+      const separationByCount = secondTight === 0 ? true : bestTight >= secondTight + 3 || bestTight >= Math.ceil(secondTight * 1.5);
+      let separationByError = true;
+      if (!separationByCount && secondBest && bestTight === secondTight && secondTight > 0) {
+        const be = best?.avgErrorTight ?? Infinity;
+        const se = secondBest?.avgErrorTight ?? Infinity;
+        separationByError = be + 1e-6 < se * 0.8 || se - be > 0.05;
+      }
+      let separationOk = separationByCount || separationByError;
+      if (!separationOk && best && secondBest && bestTight === secondTight && secondTight > 0) {
+        const delta = Math.hypot((best.dx ?? 0) - (secondBest.dx ?? 0), (best.dy ?? 0) - (secondBest.dy ?? 0));
+        if (delta < 0.05) {
+          separationOk = true;
+          console.log(`[\u94BB\u5B54\u5BF9\u9F50] \u2139\uFE0F tight \u6253\u5E73\u4F46\u504F\u79FB\u51E0\u4E4E\u4E00\u81F4(\u0394=${delta.toFixed(3)}mm)\uFF0C\u89C6\u4E3A\u53EF\u9760`);
+        }
+      }
+      if (best && bestTight >= minMatches && separationOk) {
+        featureOffset = { dx: best.dx, dy: best.dy, matchCount: bestTight, maxError: best.maxErrorTight, avgError: best.avgErrorTight, refLayerName: best.refLayerName };
+        console.log(`[\u94BB\u5B54\u5BF9\u9F50] \u2713 \u9009\u62E9\u6700\u4F73\u53C2\u8003\u5C42: ${best.refLayerName}`);
+        console.log(`[\u94BB\u5B54\u5BF9\u9F50] \u2713 \u7279\u5F81\u70B9\u5019\u9009\u504F\u79FB: X=${featureOffset.dx.toFixed(3)}mm, Y=${featureOffset.dy.toFixed(3)}mm (tight=${bestTight}/${totalAnchor}, secondTight=${secondTight}, errT(avg/max)=${(best.avgErrorTight ?? 0).toFixed(3)}/${(best.maxErrorTight ?? 0).toFixed(3)}mm, method=${best.method})`);
+      } else {
+        const bestLoose = best?.matchLoose ?? 0;
+        console.log(`[\u94BB\u5B54\u5BF9\u9F50] \u26A0\uFE0F \u591A\u53C2\u8003\u5C42\u5C1D\u8BD5\u540E\u672A\u8FBE\u5230\u53EF\u9760\u5339\u914D\u9608\u503C\uFF1AbestTight=${bestTight}/${totalAnchor} (min=${minMatches}), secondTight=${secondTight}, separationOk=${separationOk}, bestLoose=${bestLoose}\uFF0C\u8DF3\u8FC7\u7279\u5F81\u70B9\u5BF9\u9F50`);
+      }
+    }
+  }
+  const applyThresholdMm = 0.2;
+  let chosen = null;
+  if (featureOffset) {
+    const dx = featureOffset.dx;
+    const dy = featureOffset.dy;
+    if (Math.abs(dx) < applyThresholdMm && Math.abs(dy) < applyThresholdMm) {
+      console.log(`[\u94BB\u5B54\u5BF9\u9F50] \u2713 \u7279\u5F81\u70B9\u5339\u914D\u663E\u793A\u94BB\u5B54\u5DF2\u5BF9\u9F50(\u0394<${applyThresholdMm}mm, match=${featureOffset.matchCount}, avgErr=${(featureOffset.avgError ?? 0).toFixed(3)}). \u8DF3\u8FC7\u5BF9\u9F50\u4E0EGKO\u515C\u5E95`);
+      return;
+    } else if (outlineBounds && overflowBefore) {
+      const afterBounds = translateBounds(combinedDrillBounds, dx, dy);
+      const overflowAfter = computeOverflow(afterBounds, outlineBounds);
+      const improvement = overflowBefore.total - overflowAfter.total;
+      if (improvement > 0.2 || overflowAfter.total <= overflowBefore.total + 0.1) {
+        chosen = { dx, dy, tag: `feature-match (improve=${improvement.toFixed(3)}mm)` };
+      } else {
+        console.warn(`[\u94BB\u5B54\u5BF9\u9F50] \u26A0\uFE0F \u7279\u5F81\u70B9\u504F\u79FB\u4F1A\u8BA9\u94BB\u5B54\u66F4\u8D8A\u754C\uFF08before=${overflowBefore.total.toFixed(3)} after=${overflowAfter.total.toFixed(3)}\uFF09\uFF0C\u62D2\u7EDD\u5E76\u542F\u7528GKO\u515C\u5E95`);
+      }
+    } else {
+      chosen = { dx, dy, tag: "feature-match (no-outline-check)" };
+    }
+  }
+  if (!chosen && outlineBounds && overflowBefore) {
+    if (overflowBefore.total <= 0.2) {
+      console.log("[\u94BB\u5B54\u5BF9\u9F50] \u2713 \u94BB\u5B54\u5C42\u672A\u660E\u663E\u8D8A\u754C\uFF0C\u65E0\u9700GKO\u515C\u5E95\u5BF9\u9F50");
+    } else {
+      const drillCenterX = (combinedDrillBounds.minX + combinedDrillBounds.maxX) / 2;
+      const drillCenterY = (combinedDrillBounds.minY + combinedDrillBounds.maxY) / 2;
+      const outlineCenterX = (outlineBounds.minX + outlineBounds.maxX) / 2;
+      const outlineCenterY = (outlineBounds.minY + outlineBounds.maxY) / 2;
+      const candidatesX = [
+        0,
+        outlineBounds.minX - combinedDrillBounds.minX,
+        outlineBounds.maxX - combinedDrillBounds.maxX,
+        outlineCenterX - drillCenterX
+      ];
+      const candidatesY = [
+        0,
+        outlineBounds.minY - combinedDrillBounds.minY,
+        outlineBounds.maxY - combinedDrillBounds.maxY,
+        outlineCenterY - drillCenterY
+      ];
+      let best = { dx: 0, dy: 0, error: Infinity, shift: Infinity };
+      for (const dx of candidatesX) {
+        for (const dy of candidatesY) {
+          const afterBounds = translateBounds(combinedDrillBounds, dx, dy);
+          const ov = computeOverflow(afterBounds, outlineBounds);
+          const shift = Math.abs(dx) + Math.abs(dy);
+          if (ov.total < best.error - 1e-6 || Math.abs(ov.total - best.error) < 1e-6 && shift < best.shift) {
+            best = { dx, dy, error: ov.total, shift };
+          }
+        }
+      }
+      const improvement = overflowBefore.total - best.error;
+      console.log(`[\u94BB\u5B54\u5BF9\u9F50] GKO\u515C\u5E95\u5019\u9009\u504F\u79FB: X=${best.dx.toFixed(3)}mm, Y=${best.dy.toFixed(3)}mm (overflowAfter=${best.error.toFixed(3)}mm, improve=${improvement.toFixed(3)}mm)`);
+      if ((Math.abs(best.dx) >= applyThresholdMm || Math.abs(best.dy) >= applyThresholdMm) && (improvement > 0.2 || best.error <= overflowBefore.total + 0.1)) {
+        chosen = { dx: best.dx, dy: best.dy, tag: `outline-fit (improve=${improvement.toFixed(3)}mm)` };
+      } else {
+        console.log("[\u94BB\u5B54\u5BF9\u9F50] \u26A0\uFE0F GKO\u515C\u5E95\u504F\u79FB\u4E0D\u663E\u8457/\u8FC7\u5C0F\uFF0C\u8DF3\u8FC7");
+      }
+    }
+  }
+  if (!chosen && !outlineBounds) {
+    const ref = pickReferenceForScale();
+    if (ref && ref.bounds) {
+      const overflowRefBefore = computeOverflow(combinedDrillBounds, ref.bounds);
+      if (overflowRefBefore.total > 0.2) {
+        const drillCenterX = (combinedDrillBounds.minX + combinedDrillBounds.maxX) / 2;
+        const drillCenterY = (combinedDrillBounds.minY + combinedDrillBounds.maxY) / 2;
+        const refCenterX = (ref.bounds.minX + ref.bounds.maxX) / 2;
+        const refCenterY = (ref.bounds.minY + ref.bounds.maxY) / 2;
+        const candidatesX = [
+          0,
+          ref.bounds.minX - combinedDrillBounds.minX,
+          ref.bounds.maxX - combinedDrillBounds.maxX,
+          refCenterX - drillCenterX
+        ];
+        const candidatesY = [
+          0,
+          ref.bounds.minY - combinedDrillBounds.minY,
+          ref.bounds.maxY - combinedDrillBounds.maxY,
+          refCenterY - drillCenterY
+        ];
+        let best = { dx: 0, dy: 0, error: Infinity, shift: Infinity };
+        for (const dx of candidatesX) {
+          for (const dy of candidatesY) {
+            const afterBounds = translateBounds(combinedDrillBounds, dx, dy);
+            const ov = computeOverflow(afterBounds, ref.bounds);
+            const shift = Math.abs(dx) + Math.abs(dy);
+            if (ov.total < best.error - 1e-6 || Math.abs(ov.total - best.error) < 1e-6 && shift < best.shift) {
+              best = { dx, dy, error: ov.total, shift };
+            }
+          }
+        }
+        const improvement = overflowRefBefore.total - best.error;
+        if ((Math.abs(best.dx) >= applyThresholdMm || Math.abs(best.dy) >= applyThresholdMm) && (improvement > 0.2 || best.error <= overflowRefBefore.total + 0.1)) {
+          console.warn(`[\u94BB\u5B54\u5BF9\u9F50] \u26A0\uFE0F \u65E0Outline\u65F6\u53C2\u8003\u5C42\u56DE\u62C9: ref=${ref.name}(${ref.reason}), dx=${best.dx.toFixed(3)} dy=${best.dy.toFixed(3)} improve=${improvement.toFixed(3)}mm`);
+          chosen = { dx: best.dx, dy: best.dy, tag: `ref-fit (ref=${ref.reason}, improve=${improvement.toFixed(3)}mm)` };
+        }
+      }
+    }
+  }
+  if (!chosen) {
+    console.log("[\u94BB\u5B54\u5BF9\u9F50] \u672A\u9009\u62E9\u4EFB\u4F55\u6709\u6548\u504F\u79FB\uFF0C\u8DF3\u8FC7");
+    return;
+  }
+  applyOffsetToAllDrills(chosen.dx, chosen.dy, chosen.tag);
+}
+function extractFeaturesFromLayer(layer) {
+  if (!layer.rawVertices) return [];
+  const features = [];
+  const vertices = layer.rawVertices;
+  const centerCandidates = /* @__PURE__ */ new Map();
+  for (let i = 0; i < vertices.length; i += 3) {
+    const x = vertices[i];
+    const y = vertices[i + 1];
+    const key = `${Math.round(x * 100) / 100},${Math.round(y * 100) / 100}`;
+    centerCandidates.set(key, (centerCandidates.get(key) || 0) + 1);
+  }
+  const circleThreshold = 8;
+  centerCandidates.forEach((count, key) => {
+    if (count >= circleThreshold) {
+      const [x, y] = key.split(",").map(Number);
+      features.push({ x, y, type: "circle", count });
+    }
+  });
+  console.log(`[\u63D0\u53D6\u7279\u5F81\u70B9] ${layer.name} - \u627E\u5230 ${features.length} \u4E2A\u5706\u5FC3\u5019\u9009\u70B9 (\u9608\u503C=${circleThreshold})`);
+  if (features.length > 0) {
+    features.slice(0, 5).forEach((f, idx) => {
+      console.log(`  \u5706\u5FC3${idx + 1}: (${f.x.toFixed(3)}, ${f.y.toFixed(3)}), \u91CD\u590D\u6B21\u6570=${f.count}`);
+    });
+  }
+  if (features.length === 0) {
+    console.log(`[\u63D0\u53D6\u7279\u5F81\u70B9] ${layer.name} - \u672A\u627E\u5230\u5706\u5FC3\uFF0C\u5C1D\u8BD5\u63D0\u53D6\u552F\u4E00\u70B9`);
+    const uniquePoints = /* @__PURE__ */ new Set();
+    for (let i = 0; i < vertices.length; i += 3) {
+      const x = Math.round(vertices[i] * 100) / 100;
+      const y = Math.round(vertices[i + 1] * 100) / 100;
+      uniquePoints.add(`${x},${y}`);
+    }
+    uniquePoints.forEach((key) => {
+      const [x, y] = key.split(",").map(Number);
+      features.push({ x, y, type: "point" });
+    });
+    console.log(`[\u63D0\u53D6\u7279\u5F81\u70B9] ${layer.name} - \u63D0\u53D6\u5230 ${features.length} \u4E2A\u552F\u4E00\u70B9`);
+  }
+  return features;
+}
+function selectFeaturesWithXYDistribution(features, maxCount) {
+  if (features.length <= maxCount) {
+    return features;
+  }
+  let minX = Infinity;
+  let maxX = -Infinity;
+  let minY = Infinity;
+  let maxY = -Infinity;
+  for (const feature of features) {
+    minX = Math.min(minX, feature.x);
+    maxX = Math.max(maxX, feature.x);
+    minY = Math.min(minY, feature.y);
+    maxY = Math.max(maxY, feature.y);
+  }
+  const rangeX = maxX - minX;
+  const rangeY = maxY - minY;
+  if (rangeX < 1e-3 || rangeY < 1e-3) {
+    features.sort((a, b) => {
+      if (Math.abs(a.y - b.y) > 1e-4) {
+        return a.y - b.y;
+      }
+      return a.x - b.x;
+    });
+    return features.slice(0, maxCount);
+  }
+  const selectedFeatures = [];
+  const usedFeatures = /* @__PURE__ */ new Set();
+  const cornerRegionSize = 0.33;
+  const corners = [
+    { name: "\u5DE6\u4E0B\u89D2", xMin: minX, xMax: minX + rangeX * cornerRegionSize, yMin: minY, yMax: minY + rangeY * cornerRegionSize },
+    { name: "\u53F3\u4E0B\u89D2", xMin: maxX - rangeX * cornerRegionSize, xMax: maxX, yMin: minY, yMax: minY + rangeY * cornerRegionSize },
+    { name: "\u5DE6\u4E0A\u89D2", xMin: minX, xMax: minX + rangeX * cornerRegionSize, yMin: maxY - rangeY * cornerRegionSize, yMax: maxY },
+    { name: "\u53F3\u4E0A\u89D2", xMin: maxX - rangeX * cornerRegionSize, xMax: maxX, yMin: maxY - rangeY * cornerRegionSize, yMax: maxY }
+  ];
+  for (const corner of corners) {
+    const cornerFeatures = features.filter(
+      (f) => f.x >= corner.xMin && f.x <= corner.xMax && f.y >= corner.yMin && f.y <= corner.yMax && !usedFeatures.has(f)
+    );
+    if (cornerFeatures.length > 0) {
+      let cornerCenterX, cornerCenterY;
+      if (corner.name === "\u5DE6\u4E0B\u89D2") {
+        cornerCenterX = minX;
+        cornerCenterY = minY;
+      } else if (corner.name === "\u53F3\u4E0B\u89D2") {
+        cornerCenterX = maxX;
+        cornerCenterY = minY;
+      } else if (corner.name === "\u5DE6\u4E0A\u89D2") {
+        cornerCenterX = minX;
+        cornerCenterY = maxY;
+      } else {
+        cornerCenterX = maxX;
+        cornerCenterY = maxY;
+      }
+      const circleFeatures = cornerFeatures.filter((f) => f.type === "circle");
+      let closestFeature = null;
+      let minDistance = Infinity;
+      const featuresToCheck = circleFeatures.length > 0 ? circleFeatures : cornerFeatures;
+      for (const feature of featuresToCheck) {
+        const distance = Math.sqrt(
+          Math.pow(feature.x - cornerCenterX, 2) + Math.pow(feature.y - cornerCenterY, 2)
+        );
+        if (distance < minDistance) {
+          minDistance = distance;
+          closestFeature = feature;
+        }
+      }
+      if (closestFeature) {
+        selectedFeatures.push(closestFeature);
+        usedFeatures.add(closestFeature);
+      }
+    }
+  }
+  console.log(`[\u7279\u5F81\u70B9\u9009\u62E9] \u56DB\u4E2A\u89D2\u5171\u9009\u62E9 ${selectedFeatures.length} \u4E2A\u7279\u5F81\u70B9`);
+  if (selectedFeatures.length < maxCount) {
+    const remainingFeatures = features.filter((f) => !usedFeatures.has(f));
+    if (remainingFeatures.length > 0) {
+      const gridSize = Math.ceil(Math.sqrt(maxCount - selectedFeatures.length));
+      const cellWidth = rangeX / gridSize;
+      const cellHeight = rangeY / gridSize;
+      const grid = Array(gridSize).fill(null).map(() => Array(gridSize).fill(null).map(() => []));
+      for (const feature of remainingFeatures) {
+        const gridX = Math.min(Math.floor((feature.x - minX) / cellWidth), gridSize - 1);
+        const gridY = Math.min(Math.floor((feature.y - minY) / cellHeight), gridSize - 1);
+        grid[gridY][gridX].push(feature);
+      }
+      for (let y = 0; y < gridSize; y++) {
+        for (let x = 0; x < gridSize; x++) {
+          const cellFeatures = grid[y][x];
+          if (cellFeatures.length > 0) {
+            const cellCenterX = minX + (x + 0.5) * cellWidth;
+            const cellCenterY = minY + (y + 0.5) * cellHeight;
+            let closestFeature = cellFeatures[0];
+            let minDistance = Infinity;
+            for (const feature of cellFeatures) {
+              const distance = Math.sqrt(
+                Math.pow(feature.x - cellCenterX, 2) + Math.pow(feature.y - cellCenterY, 2)
+              );
+              if (distance < minDistance) {
+                minDistance = distance;
+                closestFeature = feature;
+              }
+            }
+            selectedFeatures.push(closestFeature);
+            usedFeatures.add(closestFeature);
+            if (selectedFeatures.length >= maxCount) {
+              break;
+            }
+          }
+        }
+        if (selectedFeatures.length >= maxCount) {
+          break;
+        }
+      }
+      console.log(`[\u7279\u5F81\u70B9\u9009\u62E9] \u4ECE\u5269\u4F59\u533A\u57DF\u8865\u5145 ${selectedFeatures.length - (selectedFeatures.length > 4 ? 4 : selectedFeatures.length)} \u4E2A\u7279\u5F81\u70B9`);
+    }
+  }
+  console.log(`[\u7279\u5F81\u70B9\u9009\u62E9] \u6700\u7EC8\u4ECE ${features.length} \u4E2A\u7279\u5F81\u70B9\u4E2D\u9009\u62E9 ${selectedFeatures.length} \u4E2A`);
+  return selectedFeatures;
+}
+function verifyOffset(drillFeatures, refFeatures, offsetX, offsetY, tolerance) {
+  let matchCount = 0;
+  let maxError = 0;
+  let sumError = 0;
+  const matchedPairs = [];
+  const usedRefIndices = /* @__PURE__ */ new Set();
+  for (const drillPoint of drillFeatures) {
+    const transformedX = drillPoint.x + offsetX;
+    const transformedY = drillPoint.y + offsetY;
+    let minDistance = Infinity;
+    let nearestRefPoint = null;
+    let nearestRefIndex = -1;
+    for (let i = 0; i < refFeatures.length; i++) {
+      if (usedRefIndices.has(i)) continue;
+      const refPoint = refFeatures[i];
+      const distance = Math.sqrt(
+        Math.pow(transformedX - refPoint.x, 2) + Math.pow(transformedY - refPoint.y, 2)
+      );
+      if (distance < minDistance) {
+        minDistance = distance;
+        nearestRefPoint = refPoint;
+        nearestRefIndex = i;
+      }
+    }
+    if (minDistance <= tolerance && nearestRefIndex !== -1) {
+      matchCount++;
+      maxError = Math.max(maxError, minDistance);
+      sumError += minDistance;
+      usedRefIndices.add(nearestRefIndex);
+      matchedPairs.push({
+        drillPoint,
+        refPoint: nearestRefPoint,
+        error: minDistance
+      });
+    }
+  }
+  const avgError = matchCount > 0 ? sumError / matchCount : Infinity;
+  return { matchCount, maxError, avgError, matchedPairs };
+}
+function estimateOffsetByVoting(drillFeatures, refFeatures, options = {}) {
+  const binSize = options.binSize ?? 0.2;
+  const maxCount = options.maxCount ?? 80;
+  const minVotes = options.minVotes ?? 3;
+  if (!Array.isArray(drillFeatures) || !Array.isArray(refFeatures)) return null;
+  if (drillFeatures.length === 0 || refFeatures.length === 0) return null;
+  const drillSample = selectFeaturesWithXYDistribution(drillFeatures, Math.min(maxCount, drillFeatures.length));
+  const refSample = selectFeaturesWithXYDistribution(refFeatures, Math.min(maxCount, refFeatures.length));
+  const bins = /* @__PURE__ */ new Map();
+  for (const d of drillSample) {
+    for (const r of refSample) {
+      const dx2 = r.x - d.x;
+      const dy2 = r.y - d.y;
+      const qx = Math.round(dx2 / binSize);
+      const qy = Math.round(dy2 / binSize);
+      const key = `${qx},${qy}`;
+      const cur = bins.get(key) || { count: 0, sumDx: 0, sumDy: 0 };
+      cur.count += 1;
+      cur.sumDx += dx2;
+      cur.sumDy += dy2;
+      bins.set(key, cur);
+    }
+  }
+  let bestKey = null;
+  let best = null;
+  for (const [k, v] of bins.entries()) {
+    if (!best || v.count > best.count) {
+      best = v;
+      bestKey = k;
+    }
+  }
+  if (!best || best.count < minVotes) return null;
+  const dx = best.sumDx / best.count;
+  const dy = best.sumDy / best.count;
+  return { dx, dy, votes: best.count, binSize, key: bestKey };
+}
+function centerView() {
+  let viewBounds = null;
+  let useLargePadding = false;
+  const gkoLayer = layers.find((layer) => {
+    const fileName2 = layer.name;
+    const fileNameOnly = fileName2.split(/[/\\]/).pop();
+    const fileExtension = "." + fileNameOnly.split(".").pop().toUpperCase();
+    const ext = fileExtension.substring(1);
+    const display = getLayerDisplayName(fileName2);
+    return display === "GKO" || ext === "GKO" || fileNameOnly.includes("_Profile") || fileNameOnly.toLowerCase().includes("outline");
+  });
+  const gtlLayer = layers.find((layer) => {
+    const fileName2 = layer.name;
+    const fileNameOnly = fileName2.split(/[/\\]/).pop();
+    const fileExtension = "." + fileNameOnly.split(".").pop().toUpperCase();
+    const ext = fileExtension.substring(1);
+    const display = getLayerDisplayName(fileName2);
+    return display === "GTL" || ext === "GTL" || fileNameOnly.includes("_TOP") || fileNameOnly.includes("_Copper_Signal_Top");
+  });
+  if (gkoLayer && gkoLayer.bounds && gtlLayer && gtlLayer.bounds) {
+    const gkoBounds = gkoLayer.bounds;
+    const gtlBounds = gtlLayer.bounds;
+    const gkoWidth = gkoBounds.maxX - gkoBounds.minX;
+    const gkoHeight = gkoBounds.maxY - gkoBounds.minY;
+    const gkoSize = Math.max(gkoWidth, gkoHeight);
+    const gtlWidth = gtlBounds.maxX - gtlBounds.minX;
+    const gtlHeight = gtlBounds.maxY - gtlBounds.minY;
+    const gtlSize = Math.max(gtlWidth, gtlHeight);
+    const ratio = gtlSize > 0 ? gkoSize / gtlSize : Infinity;
+    console.log(`[\u89C6\u56FE\u5C45\u4E2D] GKO\u5C42\u5927\u5C0F: ${gkoSize.toFixed(6)}, GTL\u5C42\u5927\u5C0F: ${gtlSize.toFixed(6)}`);
+    if (Number.isFinite(ratio) && ratio > 5) {
+      viewBounds = { ...gtlBounds };
+      console.warn(`[\u89C6\u56FE\u5C45\u4E2D] \u26A0\uFE0F GKO\u5C3A\u5BF8\u8FDC\u5927\u4E8EGTL (ratio=${ratio.toFixed(2)} > 5)\uFF0C\u4E3A\u907F\u514D\u89C6\u56FE\u88AB\u5F02\u5E38\u6491\u5927\uFF0C\u6539\u4E3A\u4F7F\u7528GTL\u5C42bounds\u8BBE\u7F6E\u89C6\u56FE`);
+      console.log(`[\u89C6\u56FE\u5C45\u4E2D]   GTL: minX=${gtlBounds.minX.toFixed(6)}, minY=${gtlBounds.minY.toFixed(6)}, maxX=${gtlBounds.maxX.toFixed(6)}, maxY=${gtlBounds.maxY.toFixed(6)}`);
+    } else {
+      viewBounds = {
+        minX: Math.min(gkoBounds.minX, gtlBounds.minX),
+        minY: Math.min(gkoBounds.minY, gtlBounds.minY),
+        maxX: Math.max(gkoBounds.maxX, gtlBounds.maxX),
+        maxY: Math.max(gkoBounds.maxY, gtlBounds.maxY)
+      };
+      console.log(`[\u89C6\u56FE\u5C45\u4E2D] \u4F7F\u7528GKO\u548CGTL\u5C42\u7684\u5408\u5E76\u8FB9\u754C\u8BBE\u7F6E\u89C6\u56FE`);
+      console.log(`[\u89C6\u56FE\u5C45\u4E2D]   GKO: minX=${gkoBounds.minX.toFixed(6)}, minY=${gkoBounds.minY.toFixed(6)}, maxX=${gkoBounds.maxX.toFixed(6)}, maxY=${gkoBounds.maxY.toFixed(6)}`);
+      console.log(`[\u89C6\u56FE\u5C45\u4E2D]   GTL: minX=${gtlBounds.minX.toFixed(6)}, minY=${gtlBounds.minY.toFixed(6)}, maxX=${gtlBounds.maxX.toFixed(6)}, maxY=${gtlBounds.maxY.toFixed(6)}`);
+      console.log(`[\u89C6\u56FE\u5C45\u4E2D]   \u5408\u5E76: minX=${viewBounds.minX.toFixed(6)}, minY=${viewBounds.minY.toFixed(6)}, maxX=${viewBounds.maxX.toFixed(6)}, maxY=${viewBounds.maxY.toFixed(6)}`);
+    }
+  } else if (gkoLayer && gkoLayer.bounds) {
+    viewBounds = { ...gkoLayer.bounds };
+    console.log(`[\u89C6\u56FE\u5C45\u4E2D] \u4F7F\u7528GKO\u5C42 (${gkoLayer.name}) \u7684bounds\u8BBE\u7F6E\u89C6\u56FE`);
+  } else if (gtlLayer && gtlLayer.bounds) {
+    viewBounds = { ...gtlLayer.bounds };
+    console.log(`[\u89C6\u56FE\u5C45\u4E2D] \u4F7F\u7528GTL\u5C42 (${gtlLayer.name}) \u7684bounds\u8BBE\u7F6E\u89C6\u56FE`);
+  } else {
+    const gtoLayer = layers.find((layer) => {
+      const fileName2 = layer.name;
+      const fileNameOnly = fileName2.split(/[/\\]/).pop();
+      const fileExtension = "." + fileNameOnly.split(".").pop().toUpperCase();
+      const ext = fileExtension.substring(1);
+      const display = getLayerDisplayName(fileName2);
+      return display === "GTO" || ext === "GTO" || fileNameOnly.includes("_Legend_Top") || fileNameOnly.toLowerCase().includes("legend") && fileNameOnly.toLowerCase().includes("top") || fileNameOnly.toLowerCase().includes("silkscreen") && fileNameOnly.toLowerCase().includes("top");
+    });
+    if (gtoLayer && gtoLayer.bounds) {
+      viewBounds = { ...gtoLayer.bounds };
+      console.log(`[\u89C6\u56FE\u5C45\u4E2D] \u4F7F\u7528GTO\u5C42 (${gtoLayer.name}) \u7684bounds\u8BBE\u7F6E\u89C6\u56FE`);
+    } else {
+      const artLayer = layers.find((layer) => {
+        const fileName2 = layer.name;
+        const fileNameOnly = fileName2.split(/[/\\]/).pop();
+        return fileNameOnly.toLowerCase().startsWith("art");
+      });
+      if (artLayer && artLayer.bounds) {
+        viewBounds = { ...artLayer.bounds };
+        console.log(`[\u89C6\u56FE\u5C45\u4E2D] \u4F7F\u7528art\u5F00\u5934\u6587\u4EF6 (${artLayer.name}) \u7684bounds\u8BBE\u7F6E\u89C6\u56FE`);
+      } else {
+        let minX = Infinity, maxX = -Infinity, minY = Infinity, maxY = -Infinity;
+        layers.forEach((layer) => {
+          if (layer.bounds) {
+            minX = Math.min(minX, layer.bounds.minX);
+            maxX = Math.max(maxX, layer.bounds.maxX);
+            minY = Math.min(minY, layer.bounds.minY);
+            maxY = Math.max(maxY, layer.bounds.maxY);
+          }
+        });
+        viewBounds = { minX, maxX, minY, maxY };
+        useLargePadding = true;
+        console.log(`[\u89C6\u56FE\u5C45\u4E2D] \u672A\u627E\u5230GKO/GTL/GTO/art\u5F00\u5934\u6587\u4EF6\uFF0C\u4F7F\u7528\u6240\u6709\u56FE\u5C42\u8FB9\u754C\uFF08\u5927\u8FB9\u8DDD\uFF09`);
+      }
+    }
+  }
+  if (!viewBounds) return;
+  const width = viewBounds.maxX - viewBounds.minX;
+  const height = viewBounds.maxY - viewBounds.minY;
+  if (width <= 0 || height <= 0) {
+    console.warn(`[\u89C6\u56FE\u5C45\u4E2D] \u65E0\u6548\u8FB9\u754C: width=${width}, height=${height}`);
+    return;
+  }
+  const paddingRatio = useLargePadding ? 0.4 : 0.1;
+  const padding = Math.max(width, height) * paddingRatio;
+  const paddedWidth = width + padding * 2;
+  const paddedHeight = height + padding * 2;
+  const cx = (viewBounds.minX + viewBounds.maxX) / 2;
+  const cy = (viewBounds.minY + viewBounds.maxY) / 2;
+  const aspect = canvas.width / canvas.height;
+  const contentAspect = paddedWidth / paddedHeight;
+  if (contentAspect > aspect) {
+    scale = 2 / paddedWidth * 1.4;
+  } else {
+    scale = 2 / paddedHeight / aspect * 1.4;
+  }
+  transX = -cx * (scale / aspect);
+  transY = -cy * scale;
+  console.log(`[\u89C6\u56FE\u5C45\u4E2D] \u8FB9\u754C: [${viewBounds.minX.toFixed(2)}, ${viewBounds.maxX.toFixed(2)}] x [${viewBounds.minY.toFixed(2)}, ${viewBounds.maxY.toFixed(2)}]`);
+  console.log(`[\u89C6\u56FE\u5C45\u4E2D] \u7F29\u653E: ${scale.toFixed(6)}, \u5E73\u79FB: (${transX.toFixed(6)}, ${transY.toFixed(6)})`);
+}
+async function handleFileSelectionForDirect(files) {
+  if (files.length === 0) return;
+  const file = files[0];
+  if (!file) return;
+  const dataTransfer = new DataTransfer();
+  dataTransfer.items.add(file);
+  fileInput.files = dataTransfer.files;
+  const event = new Event("change", { bubbles: true });
+  fileInput.dispatchEvent(event);
+}
+window.addEventListener("load", () => {
+  initUrlIdHandler(handleFileSelectionForDirect, showStatus);
+  const baseUrl = "/";
+  const buildPageUrl = (path) => `${baseUrl}${path.replace(/^\/+/, "")}`;
+  const getTargetUrl = (basePath) => {
+    const targetBase = buildPageUrl(basePath);
+    const id = parseUrlId();
+    if (id) return `${targetBase}?id=${encodeURIComponent(id)}`;
+    const url = parseUrlFileUrl();
+    if (url) return `${targetBase}?url=${encodeURIComponent(url)}`;
+    return targetBase;
+  };
+  const mode3DBtn = document.querySelector("#mode3DBtnId");
+  if (mode3DBtn) {
+    mode3DBtn.addEventListener("click", () => {
+      window.location.href = getTargetUrl("/3dPage");
+    });
+  }
+  const modeSimulationBtn = document.querySelector("#modeSimulationBtnId");
+  if (modeSimulationBtn) {
+    modeSimulationBtn.addEventListener("click", () => {
+      window.location.href = getTargetUrl("/simulation");
+    });
+  }
+});
+//# sourceMappingURL=gerber-2d-entry-OQ4SQRBY.js.map