@tscircuit/cli 0.1.2410 → 0.1.2412

package/dist/cli/build/build.worker.js

@@ -6839,6 +6839,651 @@ var require_cjs = __commonJS(function(exports) {
   }
 });
 
+// node_modules/earcut/src/earcut.js
+function earcut(data, holeIndices, dim = 2) {
+  const hasHoles = holeIndices && holeIndices.length;
+  const outerLen = hasHoles ? holeIndices[0] * dim : data.length;
+  if (steiners.size)
+    steiners.clear();
+  let outerNode = linkedList(data, 0, outerLen, dim, true);
+  const triangles = [];
+  if (!outerNode || outerNode.next === outerNode.prev)
+    return triangles;
+  let minX = 0, minY = 0, invSize = 0;
+  if (hasHoles)
+    outerNode = eliminateHoles(data, holeIndices, outerNode, dim);
+  if (data.length > 80 * dim) {
+    minX = data[0];
+    minY = data[1];
+    let maxX = minX;
+    let maxY = minY;
+    for (let i = dim;i < outerLen; i += dim) {
+      const x = data[i];
+      const y = data[i + 1];
+      if (x < minX)
+        minX = x;
+      if (y < minY)
+        minY = y;
+      if (x > maxX)
+        maxX = x;
+      if (y > maxY)
+        maxY = y;
+    }
+    invSize = Math.max(maxX - minX, maxY - minY);
+    invSize = invSize !== 0 ? 32767 / invSize : 0;
+  }
+  earcutLinked(outerNode, triangles, minX, minY, invSize);
+  return triangles;
+}
+function linkedList(data, start, end, dim, clockwise) {
+  let last = null;
+  if (clockwise === signedArea(data, start, end, dim) > 0) {
+    for (let i = start;i < end; i += dim)
+      last = insertNode(i / dim | 0, data[i], data[i + 1], last);
+  } else {
+    for (let i = end - dim;i >= start; i -= dim)
+      last = insertNode(i / dim | 0, data[i], data[i + 1], last);
+  }
+  if (last && equals(last, last.next)) {
+    removeNode(last);
+    last = last.next;
+  }
+  return last;
+}
+function filterPoints(start, end = start) {
+  const full = end === start;
+  let p = start, again;
+  do {
+    again = false;
+    if (p !== p.next && (steiners.size === 0 || !steiners.has(p)) && (equals(p, p.next) || area(p.prev, p, p.next) === 0)) {
+      if (full || p === end)
+        end = p.prev;
+      filteredOut = true;
+      removeNode(p);
+      p = p.prev;
+      again = true;
+    } else if (full || p !== end) {
+      p = p.next;
+      again = !full;
+    }
+  } while (again || p !== end);
+  return end;
+}
+function earcutLinked(ear, triangles, minX, minY, invSize) {
+  if (invSize)
+    indexCurve(ear, minX, minY, invSize);
+  let stop = ear, cured = false;
+  while (ear.prev !== ear.next) {
+    const prev = ear.prev;
+    const next = ear.next;
+    if (area(prev, ear, next) < 0 && (invSize ? isEarHashed(ear, minX, minY, invSize) : isEar(ear))) {
+      triangles.push(prev.i, ear.i, next.i);
+      removeNode(ear);
+      ear = next;
+      stop = next;
+      continue;
+    }
+    ear = next;
+    if (ear === stop) {
+      filteredOut = false;
+      ear = filterPoints(ear);
+      if (filteredOut) {
+        stop = ear;
+        continue;
+      }
+      if (!cured) {
+        ear = cureLocalIntersections(ear, triangles);
+        stop = ear;
+        cured = true;
+        continue;
+      }
+      splitEarcut(ear, triangles, minX, minY, invSize);
+      break;
+    }
+  }
+}
+function isEar(ear) {
+  const a = ear.prev, b = ear, c = ear.next, ax = a.x, bx = b.x, cx = c.x, ay = a.y, by = b.y, cy = c.y, x0 = Math.min(ax, bx, cx), y0 = Math.min(ay, by, cy), x1 = Math.max(ax, bx, cx), y1 = Math.max(ay, by, cy);
+  let p = c.next;
+  while (p !== a) {
+    if (p.x >= x0 && p.x <= x1 && p.y >= y0 && p.y <= y1 && !(ax === p.x && ay === p.y) && pointInTriangle(ax, ay, bx, by, cx, cy, p.x, p.y) && area(p.prev, p, p.next) >= 0)
+      return false;
+    p = p.next;
+  }
+  return true;
+}
+function isEarHashed(ear, minX, minY, invSize) {
+  const a = ear.prev, b = ear, c = ear.next, ax = a.x, bx = b.x, cx = c.x, ay = a.y, by = b.y, cy = c.y, x0 = Math.min(ax, bx, cx), y0 = Math.min(ay, by, cy), x1 = Math.max(ax, bx, cx), y1 = Math.max(ay, by, cy), minZ = zOrder(x0, y0, minX, minY, invSize), maxZ = zOrder(x1, y1, minX, minY, invSize);
+  let p = ear.prevZ;
+  while (p && p.z >= minZ) {
+    if (p.x >= x0 && p.x <= x1 && p.y >= y0 && p.y <= y1 && p !== c && !(ax === p.x && ay === p.y) && pointInTriangle(ax, ay, bx, by, cx, cy, p.x, p.y) && area(p.prev, p, p.next) >= 0)
+      return false;
+    p = p.prevZ;
+  }
+  let n = ear.nextZ;
+  while (n && n.z <= maxZ) {
+    if (n.x >= x0 && n.x <= x1 && n.y >= y0 && n.y <= y1 && n !== c && !(ax === n.x && ay === n.y) && pointInTriangle(ax, ay, bx, by, cx, cy, n.x, n.y) && area(n.prev, n, n.next) >= 0)
+      return false;
+    n = n.nextZ;
+  }
+  return true;
+}
+function cureLocalIntersections(start, triangles) {
+  let p = start;
+  let cured = false;
+  do {
+    const a = p.prev, b = p.next.next;
+    if (intersects(a, p, p.next, b, false) && locallyInside(a, b) && locallyInside(b, a)) {
+      triangles.push(a.i, p.i, b.i);
+      removeNode(p);
+      removeNode(p.next);
+      p = start = b;
+      cured = true;
+    }
+    p = p.next;
+  } while (p !== start);
+  return cured ? filterPoints(p) : p;
+}
+function splitEarcut(start, triangles, minX, minY, invSize) {
+  let a = start;
+  do {
+    let b = a.next.next;
+    while (b !== a.prev) {
+      if (a.i !== b.i && isValidDiagonal(a, b)) {
+        let c = splitPolygon(a, b);
+        a = filterPoints(a, a.next);
+        c = filterPoints(c, c.next);
+        earcutLinked(a, triangles, minX, minY, invSize);
+        earcutLinked(c, triangles, minX, minY, invSize);
+        return;
+      }
+      b = b.next;
+    }
+    a = a.next;
+  } while (a !== start);
+}
+function eliminateHoles(data, holeIndices, outerNode, dim) {
+  const queue = [];
+  for (let i = 0, len = holeIndices.length;i < len; i++) {
+    const start = holeIndices[i] * dim;
+    const end = i < len - 1 ? holeIndices[i + 1] * dim : data.length;
+    const list = linkedList(data, start, end, dim, false);
+    if (list === list.next)
+      steiners.add(list);
+    queue.push(getLeftmost(list));
+  }
+  queue.sort(compareXYSlope);
+  buildBlockIndex(data.length / dim, holeIndices.length);
+  indexSegment(outerNode, outerNode);
+  indexActive = true;
+  for (let i = 0;i < queue.length; i++) {
+    outerNode = eliminateHole(queue[i], outerNode);
+  }
+  indexActive = false;
+  return filterPoints(outerNode);
+}
+function compareXYSlope(a, b) {
+  return a.x - b.x || a.y - b.y || (a.next.y - a.y) / (a.next.x - a.x) - (b.next.y - b.y) / (b.next.x - b.x);
+}
+function eliminateHole(hole, outerNode) {
+  const bridge = findHoleBridge(hole, outerNode);
+  if (!bridge) {
+    return outerNode;
+  }
+  const bridgeReverse = splitPolygon(bridge, hole);
+  const bridge2 = bridgeReverse.next;
+  indexSegment(bridge, bridge2.next);
+  filterPoints(bridgeReverse, bridgeReverse.next);
+  return filterPoints(bridge, bridge.next);
+}
+function buildBlockIndex(maxNodes, numHoles) {
+  const maxBlocks = Math.ceil((maxNodes + 2 * numHoles) / K) + numHoles + 2;
+  if (blockBBox.length < maxBlocks * 4)
+    blockBBox = new Float64Array(maxBlocks * 4);
+  numBlocks = 0;
+}
+function indexSegment(head, stop) {
+  let p = head;
+  do {
+    const b = numBlocks++;
+    blockHead[b] = p;
+    let minX = p.x, minY = p.y, maxX = p.x, maxY = p.y;
+    let k = 0;
+    do {
+      const c = p.next;
+      p.z = b;
+      if (c.x < minX)
+        minX = c.x;
+      if (c.x > maxX)
+        maxX = c.x;
+      if (c.y < minY)
+        minY = c.y;
+      if (c.y > maxY)
+        maxY = c.y;
+      p = c;
+    } while (++k < K && p !== stop);
+    blockStop[b] = p;
+    const g = b * 4;
+    blockBBox[g] = minX;
+    blockBBox[g + 1] = minY;
+    blockBBox[g + 2] = maxX;
+    blockBBox[g + 3] = maxY;
+  } while (p !== stop);
+}
+function growBlock(head, tail) {
+  const g = head.z * 4;
+  if (tail.x < blockBBox[g])
+    blockBBox[g] = tail.x;
+  if (tail.y < blockBBox[g + 1])
+    blockBBox[g + 1] = tail.y;
+  if (tail.x > blockBBox[g + 2])
+    blockBBox[g + 2] = tail.x;
+  if (tail.y > blockBBox[g + 3])
+    blockBBox[g + 3] = tail.y;
+}
+function liveBlockStop(b) {
+  let stop = blockStop[b];
+  while (stop.prev.next !== stop)
+    stop = stop.next;
+  blockStop[b] = stop;
+  return stop;
+}
+function liveBlockHead(b) {
+  let head = blockHead[b];
+  while (head.prev.next !== head)
+    head = head.next;
+  blockHead[b] = head;
+  return head;
+}
+function findHoleBridge(hole, outerNode) {
+  let p = outerNode;
+  const hx = hole.x;
+  const hy = hole.y;
+  let qx = -Infinity;
+  let m;
+  if (equals(hole, p))
+    return p;
+  for (let b = 0, g = 0;b < numBlocks; b++, g += 4) {
+    if (hy < blockBBox[g + 1] || hy > blockBBox[g + 3] || blockBBox[g] > hx || blockBBox[g + 2] <= qx)
+      continue;
+    const stop = liveBlockStop(b);
+    p = liveBlockHead(b);
+    do {
+      if (p.prev.next === p) {
+        if (equals(hole, p.next))
+          return p.next;
+        else if (hy <= p.y && hy >= p.next.y && p.next.y !== p.y) {
+          const x = p.x + (hy - p.y) * (p.next.x - p.x) / (p.next.y - p.y);
+          if (x <= hx && x > qx) {
+            qx = x;
+            m = p.x < p.next.x ? p : p.next;
+            if (x === hx)
+              return m;
+          }
+        }
+      }
+      p = p.next;
+    } while (p !== stop);
+  }
+  if (!m)
+    return null;
+  const mx = m.x;
+  const my = m.y;
+  const tminY = Math.min(hy, my);
+  const tmaxY = Math.max(hy, my);
+  let tanMin = Infinity;
+  for (let b = 0, g = 0;b < numBlocks; b++, g += 4) {
+    if (blockBBox[g + 2] < mx || blockBBox[g] > hx || blockBBox[g + 3] < tminY || blockBBox[g + 1] > tmaxY)
+      continue;
+    const stop = liveBlockStop(b);
+    p = liveBlockHead(b);
+    do {
+      if (p.prev.next === p && hx >= p.x && p.x >= mx && hx !== p.x && pointInTriangle(hy < my ? hx : qx, hy, mx, my, hy < my ? qx : hx, hy, p.x, p.y)) {
+        const tan = Math.abs(hy - p.y) / (hx - p.x);
+        if ((locallyInside(p, hole) || p.y === hy && p.next.y === hy && p.next.x > hx) && (tan < tanMin || tan === tanMin && (p.x > m.x || p.x === m.x && sectorContainsSector(m, p)))) {
+          m = p;
+          tanMin = tan;
+        }
+      }
+      p = p.next;
+    } while (p !== stop);
+  }
+  return m;
+}
+function sectorContainsSector(m, p) {
+  return area(m.prev, m, p.prev) < 0 && area(p.next, m, m.next) < 0;
+}
+function indexCurve(start, minX, minY, invSize) {
+  let p = start;
+  let n = 0;
+  do {
+    p.z = zOrder(p.x, p.y, minX, minY, invSize);
+    sortArr[n++] = p;
+    p = p.next;
+  } while (p !== start);
+  sortNodes(n);
+  let prev = null;
+  for (let i = 0;i < n; i++) {
+    const node = sortArr[i];
+    node.prevZ = prev;
+    if (prev)
+      prev.nextZ = node;
+    prev = node;
+  }
+  prev.nextZ = null;
+  sortArr.fill(null, 0, n);
+  sortBuf.fill(null, 0, n);
+}
+function sortNodes(n) {
+  if (n <= 32) {
+    for (let i = 1;i < n; i++) {
+      const node = sortArr[i], z = node.z;
+      let j = i - 1;
+      while (j >= 0 && sortArr[j].z > z) {
+        sortArr[j + 1] = sortArr[j];
+        j--;
+      }
+      sortArr[j + 1] = node;
+    }
+    return;
+  }
+  if (zArr.length < n) {
+    zArr = new Uint32Array(n);
+    zBuf = new Uint32Array(n);
+    sortBuf = new Array(n);
+  }
+  for (let i = 0;i < n; i++)
+    zArr[i] = sortArr[i].z;
+  radixPass(n, sortArr, zArr, sortBuf, zBuf, 0);
+  radixPass(n, sortBuf, zBuf, sortArr, zArr, 8);
+  radixPass(n, sortArr, zArr, sortBuf, zBuf, 16);
+  radixPass(n, sortBuf, zBuf, sortArr, zArr, 24);
+}
+function radixPass(n, src, srcZ, dst, dstZ, shift) {
+  counts.fill(0);
+  for (let i = 0;i < n; i++)
+    counts[srcZ[i] >>> shift & 255]++;
+  let sum = 0;
+  for (let b = 0;b < 256; b++) {
+    const c = counts[b];
+    counts[b] = sum;
+    sum += c;
+  }
+  for (let i = 0;i < n; i++) {
+    const z = srcZ[i];
+    const pos = counts[z >>> shift & 255]++;
+    dst[pos] = src[i];
+    dstZ[pos] = z;
+  }
+}
+function zOrder(x, y, minX, minY, invSize) {
+  x = (x - minX) * invSize | 0;
+  y = (y - minY) * invSize | 0;
+  x = (x | x << 8) & 16711935;
+  x = (x | x << 4) & 252645135;
+  x = (x | x << 2) & 858993459;
+  x = (x | x << 1) & 1431655765;
+  y = (y | y << 8) & 16711935;
+  y = (y | y << 4) & 252645135;
+  y = (y | y << 2) & 858993459;
+  y = (y | y << 1) & 1431655765;
+  return x | y << 1;
+}
+function getLeftmost(start) {
+  let p = start, leftmost = start;
+  do {
+    if (p.x < leftmost.x || p.x === leftmost.x && p.y < leftmost.y)
+      leftmost = p;
+    p = p.next;
+  } while (p !== start);
+  return leftmost;
+}
+function pointInTriangle(ax, ay, bx, by, cx, cy, px, py) {
+  return (cx - px) * (ay - py) >= (ax - px) * (cy - py) && (ax - px) * (by - py) >= (bx - px) * (ay - py) && (bx - px) * (cy - py) >= (cx - px) * (by - py);
+}
+function isValidDiagonal(a, b) {
+  const zeroLength = equals(a, b) && area(a.prev, a, a.next) > 0 && area(b.prev, b, b.next) > 0;
+  return a.next.i !== b.i && (zeroLength || locallyInside(a, b) && locallyInside(b, a) && (area(a.prev, a, b.prev) !== 0 || area(a, b.prev, b) !== 0)) && !intersectsPolygon(a, b) && (zeroLength || middleInside(a, b));
+}
+function area(p, q, r) {
+  return (q.y - p.y) * (r.x - q.x) - (q.x - p.x) * (r.y - q.y);
+}
+function equals(p1, p2) {
+  return p1.x === p2.x && p1.y === p2.y;
+}
+function intersects(p1, q1, p2, q2, includeBoundary = true) {
+  const o1 = area(p1, q1, p2);
+  const o2 = area(p1, q1, q2);
+  const o3 = area(p2, q2, p1);
+  const o4 = area(p2, q2, q1);
+  if ((o1 > 0 && o2 < 0 || o1 < 0 && o2 > 0) && (o3 > 0 && o4 < 0 || o3 < 0 && o4 > 0))
+    return true;
+  if (!includeBoundary)
+    return false;
+  if (o1 === 0 && onSegment(p1, p2, q1))
+    return true;
+  if (o2 === 0 && onSegment(p1, q2, q1))
+    return true;
+  if (o3 === 0 && onSegment(p2, p1, q2))
+    return true;
+  if (o4 === 0 && onSegment(p2, q1, q2))
+    return true;
+  return false;
+}
+function onSegment(p, q, r) {
+  return q.x <= Math.max(p.x, r.x) && q.x >= Math.min(p.x, r.x) && q.y <= Math.max(p.y, r.y) && q.y >= Math.min(p.y, r.y);
+}
+function intersectsPolygon(a, b) {
+  const minX = Math.min(a.x, b.x);
+  const maxX = Math.max(a.x, b.x);
+  const minY = Math.min(a.y, b.y);
+  const maxY = Math.max(a.y, b.y);
+  let p = a;
+  do {
+    const n = p.next;
+    if (p.x > maxX && n.x > maxX || p.x < minX && n.x < minX || p.y > maxY && n.y > maxY || p.y < minY && n.y < minY) {
+      p = n;
+      continue;
+    }
+    if (p.i !== a.i && n.i !== a.i && p.i !== b.i && n.i !== b.i && intersects(p, n, a, b))
+      return true;
+    p = n;
+  } while (p !== a);
+  return false;
+}
+function locallyInside(a, b) {
+  return area(a.prev, a, a.next) < 0 ? area(a, b, a.next) >= 0 && area(a, a.prev, b) >= 0 : area(a, b, a.prev) < 0 || area(a, a.next, b) < 0;
+}
+function middleInside(a, b) {
+  let p = a;
+  let inside = false;
+  const px = (a.x + b.x) / 2;
+  const py = (a.y + b.y) / 2;
+  do {
+    const n = p.next;
+    if (p.y > py !== n.y > py && px < (n.x - p.x) * (py - p.y) / (n.y - p.y) + p.x)
+      inside = !inside;
+    p = n;
+  } while (p !== a);
+  return inside;
+}
+function splitPolygon(a, b) {
+  const a2 = createNode(a.i, a.x, a.y), b2 = createNode(b.i, b.x, b.y), an = a.next, bp = b.prev;
+  a.next = b;
+  b.prev = a;
+  a2.next = an;
+  an.prev = a2;
+  b2.next = a2;
+  a2.prev = b2;
+  bp.next = b2;
+  b2.prev = bp;
+  return b2;
+}
+function insertNode(i, x, y, last) {
+  const p = createNode(i, x, y);
+  if (!last) {
+    p.prev = p;
+    p.next = p;
+  } else {
+    p.next = last.next;
+    p.prev = last;
+    last.next.prev = p;
+    last.next = p;
+  }
+  return p;
+}
+function removeNode(p) {
+  p.next.prev = p.prev;
+  p.prev.next = p.next;
+  if (p.prevZ)
+    p.prevZ.nextZ = p.nextZ;
+  if (p.nextZ)
+    p.nextZ.prevZ = p.prevZ;
+  if (indexActive)
+    growBlock(p.prev, p.next);
+}
+function createNode(i, x, y) {
+  return {
+    i,
+    x,
+    y,
+    prev: null,
+    next: null,
+    z: 0,
+    prevZ: null,
+    nextZ: null
+  };
+}
+function signedArea(data, start, end, dim) {
+  let sum = 0;
+  for (let i = start, j = end - dim;i < end; i += dim) {
+    sum += (data[j] - data[i]) * (data[i + 1] + data[j + 1]);
+    j = i;
+  }
+  return sum;
+}
+function refine(triangles, coords, dim = 2) {
+  const t = triangles;
+  const n = t.length;
+  if (n < 6)
+    return;
+  ensureScratch(n);
+  gen++;
+  he.fill(-1, 0, n);
+  let i = 0;
+  for (let e = 0;e < n; e++) {
+    const a = t[e], b = t[nextHE(e)];
+    const lo = a < b ? a : b, hi = a < b ? b : a;
+    let h = (Math.imul(lo, 2654435761) ^ Math.imul(hi, 2246822507)) & hMask;
+    while (hStamp[h] === gen) {
+      const s = hTable[h];
+      if (s !== -1) {
+        const sa = t[s], sb = t[nextHE(s)];
+        if (sa === lo && sb === hi || sa === hi && sb === lo) {
+          he[e] = s;
+          he[s] = e;
+          hTable[h] = -1;
+          edgeStamp[s] = 1;
+          edgeStack[i++] = s;
+          break;
+        }
+      }
+      h = h + 1 & hMask;
+    }
+    if (hStamp[h] !== gen) {
+      hTable[h] = e;
+      hStamp[h] = gen;
+    }
+  }
+  while (i > 0) {
+    const a = edgeStack[--i];
+    edgeStamp[a] = 0;
+    const b = he[a];
+    if (b === -1)
+      continue;
+    const a0 = a - a % 3;
+    const b0 = b - b % 3;
+    const ar = a0 + (a + 2) % 3;
+    const al = a0 + (a + 1) % 3;
+    const bl = b0 + (b + 2) % 3;
+    const br = b0 + (b + 1) % 3;
+    const p0 = t[ar], pr = t[a], pl = t[al], p1 = t[bl];
+    const x0 = coords[p0 * dim], y0 = coords[p0 * dim + 1];
+    const xr = coords[pr * dim], yr = coords[pr * dim + 1];
+    const xl = coords[pl * dim], yl = coords[pl * dim + 1];
+    const x1 = coords[p1 * dim], y1 = coords[p1 * dim + 1];
+    if (!inCircle(x0, y0, xr, yr, xl, yl, x1, y1) && orient(x0, y0, xr, yr, x1, y1) > 0 && orient(x0, y0, x1, y1, xl, yl) > 0) {
+      t[a] = p1;
+      t[b] = p0;
+      const hbl = he[bl], har = he[ar];
+      he[a] = hbl;
+      if (hbl !== -1)
+        he[hbl] = a;
+      he[b] = har;
+      if (har !== -1)
+        he[har] = b;
+      he[ar] = bl;
+      he[bl] = ar;
+      if (hbl !== -1 && edgeStamp[a] === 0) {
+        edgeStamp[a] = 1;
+        edgeStack[i++] = a;
+      }
+      if (har !== -1 && edgeStamp[b] === 0) {
+        edgeStamp[b] = 1;
+        edgeStack[i++] = b;
+      }
+      if (he[al] !== -1 && edgeStamp[al] === 0) {
+        edgeStamp[al] = 1;
+        edgeStack[i++] = al;
+      }
+      if (he[br] !== -1 && edgeStamp[br] === 0) {
+        edgeStamp[br] = 1;
+        edgeStack[i++] = br;
+      }
+    }
+  }
+}
+function orient(ax, ay, bx, by, cx, cy) {
+  return (bx - ax) * (cy - ay) - (by - ay) * (cx - ax);
+}
+function inCircle(ax, ay, bx, by, cx, cy, px, py) {
+  const dx = ax - px, dy = ay - py, ex = bx - px, ey = by - py, fx = cx - px, fy = cy - py;
+  const ap = dx * dx + dy * dy, bp = ex * ex + ey * ey, cp = fx * fx + fy * fy;
+  const s = ap + bp + cp;
+  return dx * (ey * cp - bp * fy) - dy * (ex * cp - bp * fx) + ap * (ex * fy - ey * fx) <= 0.0000000000001 * s * s;
+}
+function nextHE(e) {
+  return e - e % 3 + (e + 1) % 3;
+}
+function ensureScratch(n) {
+  if (!edgeStack || edgeStack.length < n)
+    edgeStack = new Int32Array(n);
+  if (!he || he.length < n)
+    he = new Int32Array(n);
+  if (!edgeStamp || edgeStamp.length < n)
+    edgeStamp = new Uint8Array(n);
+  let size = 1;
+  while (size < n * 4)
+    size <<= 1;
+  if (!hTable || hTable.length < size) {
+    hTable = new Int32Array(size);
+    hStamp = new Uint32Array(size);
+  }
+  hMask = size - 1;
+}
+var steiners, filteredOut = false, indexActive = false, K = 16, blockBBox, numBlocks = 0, blockHead, blockStop, sortArr, sortBuf, zArr, zBuf, counts, edgeStack, he, hTable, hStamp, edgeStamp, hMask = 0, gen = 0;
+var init_earcut = __esm(() => {
+  steiners = new Set;
+  blockBBox = new Float64Array(0);
+  blockHead = [];
+  blockStop = [];
+  sortArr = [];
+  sortBuf = [];
+  zArr = new Uint32Array(0);
+  zBuf = new Uint32Array(0);
+  counts = new Uint32Array(256);
+});
+
 // node_modules/fflate/esm/index.mjs
 import { createRequire as createRequire3 } from "module";
 function deflateSync(data, opts) {
@@ -19977,6 +20622,7 @@ __export(exports_dist, {
   createEdgeDrawCall: () => createEdgeDrawCall,
   createGrid: () => createGrid,
   createInfiniteGrid: () => createInfiniteGrid,
+  createOutlineSection: () => createOutlineSection,
   createSceneFromGLTF: () => createSceneFromGLTF,
   createUint8Bitmap: () => createUint8Bitmap,
   decodeImageFromBuffer: () => decodeImageFromBuffer,
@@ -19998,15 +20644,273 @@ import {
   glyphLineAlphabet,
   textMetrics
 } from "@tscircuit/alphabet";
+function findSectionLoops(input) {
+  const { positions, axis, offset, epsilon = 0.00001 } = input;
+  const k = axis === "x" ? 0 : axis === "y" ? 1 : 2;
+  let minimum = Infinity, maximum = -Infinity;
+  for (let i = k;i < positions.length; i += 3) {
+    minimum = Math.min(minimum, positions[i]);
+    maximum = Math.max(maximum, positions[i]);
+  }
+  if (offset <= minimum + epsilon || offset >= maximum - epsilon)
+    return { loops: [], openChains: 0 };
+  const u = (k + 1) % 3;
+  const v = (k + 2) % 3;
+  const points = /* @__PURE__ */ new Map;
+  const adjacency = /* @__PURE__ */ new Map;
+  const edges = /* @__PURE__ */ new Set;
+  const key = (p) => `${Math.round(p[0] / epsilon)},${Math.round(p[1] / epsilon)}`;
+  for (let i = 0;i < positions.length; i += 9) {
+    const hits = [];
+    const distances = [0, 1, 2].map((j) => positions[i + j * 3 + k] - offset);
+    const onPlane = distances.filter((d) => Math.abs(d) <= epsilon).length;
+    if (onPlane === 3)
+      continue;
+    if (!(distances.some((d) => d > epsilon) && distances.some((d) => d < -epsilon)) && !(onPlane === 2 && distances.some((d) => d < -epsilon)))
+      continue;
+    for (let j = 0;j < 3; j++) {
+      const a2 = i + j * 3;
+      const b2 = i + (j + 1) % 3 * 3;
+      const da = distances[j];
+      const db = distances[(j + 1) % 3];
+      if (Math.abs(da) <= epsilon)
+        hits.push([positions[a2 + u], positions[a2 + v]]);
+      else if (da > 0 !== db > 0 && Math.abs(db) > epsilon) {
+        const t = da / (da - db);
+        hits.push([
+          positions[a2 + u] + t * (positions[b2 + u] - positions[a2 + u]),
+          positions[a2 + v] + t * (positions[b2 + v] - positions[a2 + v])
+        ]);
+      }
+    }
+    const unique = [...new Map(hits.map((p) => [key(p), p])).values()];
+    if (unique.length !== 2)
+      continue;
+    const [a, b] = unique.map(key);
+    if (a === b)
+      continue;
+    const edge2 = a < b ? `${a}|${b}` : `${b}|${a}`;
+    if (edges.has(edge2))
+      continue;
+    edges.add(edge2);
+    points.set(a, unique[0]);
+    points.set(b, unique[1]);
+    if (!adjacency.has(a))
+      adjacency.set(a, /* @__PURE__ */ new Set);
+    if (!adjacency.has(b))
+      adjacency.set(b, /* @__PURE__ */ new Set);
+    adjacency.get(a).add(b);
+    adjacency.get(b).add(a);
+  }
+  const loops = [];
+  let openChains = 0;
+  while (edges.size) {
+    const first = edges.values().next().value;
+    const [start, next] = first.split("|");
+    const path = [start];
+    let previous = start;
+    let current = next;
+    const remove = (a, b) => {
+      edges.delete(a < b ? `${a}|${b}` : `${b}|${a}`);
+      adjacency.get(a)?.delete(b);
+      adjacency.get(b)?.delete(a);
+    };
+    remove(start, next);
+    while (current !== start) {
+      path.push(current);
+      const candidates = [...adjacency.get(current) ?? []];
+      if (!candidates.length)
+        break;
+      const p = points.get(previous);
+      const c = points.get(current);
+      candidates.sort((a, b) => {
+        const score = (s) => {
+          const n = points.get(s);
+          return ((c[0] - p[0]) * (n[0] - c[0]) + (c[1] - p[1]) * (n[1] - c[1])) / (Math.hypot(n[0] - c[0], n[1] - c[1]) || 1);
+        };
+        return score(b) - score(a);
+      });
+      const chosen = candidates[0];
+      remove(current, chosen);
+      previous = current;
+      current = chosen;
+    }
+    if (current === start && path.length >= 3)
+      loops.push(path.map((p) => points.get(p)));
+    else
+      openChains++;
+  }
+  return { loops, openChains };
+}
+function contains(p, polygon) {
+  let inside = false;
+  for (let i = 0, j = polygon.length - 1;i < polygon.length; j = i++) {
+    const a = polygon[i], b = polygon[j];
+    if (a[1] > p[1] !== b[1] > p[1] && p[0] < (b[0] - a[0]) * (p[1] - a[1]) / (b[1] - a[1]) + a[0])
+      inside = !inside;
+  }
+  return inside;
+}
+function createOutlineSection(drawCalls, spec) {
+  const k = spec.axis === "x" ? 0 : spec.axis === "y" ? 1 : 2;
+  const u = (k + 1) % 3, v = (k + 2) % 3;
+  const spacing = spec.hatchSpacing ?? 1;
+  if (!["x", "y", "z"].includes(spec.axis) || !Number.isFinite(spec.offset) || !["less", "greater"].includes(spec.keepSide) || !Number.isFinite(spacing) || spacing <= 0)
+    throw new Error("Invalid outline section plane or hatch spacing");
+  const output = [];
+  let openChains = 0;
+  const texture = createUint8Bitmap(128, 128);
+  for (let y = 0;y < 128; y++)
+    for (let x = 0;x < 128; x++) {
+      const c = (x + 127 - y) % 16 < 2 ? 0 : 255;
+      texture.data.set([c, c, c, 255], (y * 128 + x) * 4);
+    }
+  const sign = spec.keepSide === "less" ? 1 : -1;
+  for (const dc of drawCalls) {
+    const points = [];
+    for (let i = 0;i < dc.positions.length; i += 3)
+      points.push(Array.from(import_gl_matrix.vec3.transformMat4(import_gl_matrix.vec3.create(), dc.positions.subarray(i, i + 3), dc.model)));
+    const indices = dc.indices ?? Uint32Array.from(points, (_, i) => i);
+    const clipped = [], triangles = [];
+    const distance = (p) => sign * (p[k] - spec.offset);
+    const intersection = (a, b) => {
+      const t = distance(a) / (distance(a) - distance(b));
+      return a.map((n, j) => n + t * (b[j] - n));
+    };
+    if (dc.mode === 1) {
+      for (let i = 0;i + 1 < indices.length; i += 2) {
+        let a = points[indices[i]], b = points[indices[i + 1]];
+        if (distance(a) > 0 && distance(b) > 0)
+          continue;
+        if (distance(a) > 0)
+          a = intersection(a, b);
+        else if (distance(b) > 0)
+          b = intersection(a, b);
+        clipped.push(...a, ...b);
+      }
+      output.push({
+        ...dc,
+        positions: new Float32Array(clipped),
+        indices: null,
+        model: import_gl_matrix.mat4.create()
+      });
+      continue;
+    }
+    if (dc.mode != null && dc.mode !== 4)
+      continue;
+    for (let i = 0;i + 2 < indices.length; i += 3) {
+      const triangle = [
+        points[indices[i]],
+        points[indices[i + 1]],
+        points[indices[i + 2]]
+      ];
+      triangles.push(...triangle.flat());
+      const polygon = [];
+      for (let j = 0;j < 3; j++) {
+        const a = triangle[j], b = triangle[(j + 1) % 3];
+        if (distance(a) <= 0)
+          polygon.push(a);
+        if (distance(a) < 0 && distance(b) > 0 || distance(a) > 0 && distance(b) < 0)
+          polygon.push(intersection(a, b));
+      }
+      for (let j = 1;j + 1 < polygon.length; j++)
+        clipped.push(...polygon[0], ...polygon[j], ...polygon[j + 1]);
+    }
+    const white = {
+      baseColorFactor: [1, 1, 1, 1],
+      baseColorTexture: null
+    };
+    const mesh = {
+      ...dc,
+      positions: new Float32Array(clipped),
+      indices: null,
+      model: import_gl_matrix.mat4.create(),
+      normals: null,
+      colors: null,
+      uvs: null,
+      material: white
+    };
+    output.push(mesh);
+    const extent = Math.max(...[0, 1, 2].map((axis) => {
+      let min = Infinity, max = -Infinity;
+      for (const p of points) {
+        min = Math.min(min, p[axis]);
+        max = Math.max(max, p[axis]);
+      }
+      return max - min;
+    }));
+    const result = findSectionLoops({
+      positions: new Float32Array(triangles),
+      axis: spec.axis,
+      offset: spec.offset,
+      epsilon: Math.max(extent * 0.0000001, 0.000000001)
+    });
+    openChains += result.openChains;
+    const rings = result.loops.map((points2) => ({
+      points: points2,
+      area: Math.abs(points2.reduce((a, p, i) => {
+        const q = points2[(i + 1) % points2.length];
+        return a + p[0] * q[1] - q[0] * p[1];
+      }, 0)),
+      parent: -1,
+      depth: 0
+    })).sort((a, b) => b.area - a.area);
+    rings.forEach((ring, i) => {
+      for (let j = 0;j < i; j++)
+        if (contains(ring.points[0], rings[j].points))
+          ring.parent = j;
+      ring.depth = ring.parent < 0 ? 0 : rings[ring.parent].depth + 1;
+    });
+    const cap = [], uv = [];
+    rings.forEach((ring, i) => {
+      if (ring.depth % 2)
+        return;
+      const holes = rings.filter((r) => r.parent === i && r.depth % 2);
+      const flat = [...ring.points], starts = [];
+      for (const hole of holes) {
+        starts.push(flat.length);
+        flat.push(...hole.points);
+      }
+      const faces = earcut(flat.flat(), starts, 2);
+      for (let j = 0;j < faces.length; j += 3) {
+        const ids = faces.slice(j, j + 3);
+        const a = flat[ids[0]], b = flat[ids[1]], c = flat[ids[2]];
+        if (((b[0] - a[0]) * (c[1] - a[1]) - (b[1] - a[1]) * (c[0] - a[0])) * sign < 0)
+          ids.reverse();
+        for (const id of ids) {
+          const p = flat[id], xyz = [0, 0, 0];
+          xyz[k] = spec.offset;
+          xyz[u] = p[0];
+          xyz[v] = p[1];
+          cap.push(...xyz);
+          uv.push(p[0] / (spacing * 8 * Math.SQRT2), p[1] / (spacing * 8 * Math.SQRT2));
+        }
+      }
+    });
+    if (cap.length)
+      output.push({
+        ...mesh,
+        outlineSectionCap: true,
+        positions: new Float32Array(cap),
+        uvs: new Float32Array(uv),
+        material: {
+          ...white,
+          baseColorTexture: texture,
+          baseColorTextureWrap: "repeat"
+        }
+      });
+  }
+  return { drawCalls: output, openChains };
+}
 function computeWorldAABB(drawCalls) {
   const min = [Infinity, Infinity, Infinity];
   const max = [-Infinity, -Infinity, -Infinity];
-  const tmp = import_gl_matrix2.vec4.create();
+  const tmp = import_gl_matrix3.vec4.create();
   for (const dc of drawCalls) {
     const { positions, model } = dc;
     for (let i = 0;i < positions.length; i += 3) {
-      import_gl_matrix2.vec4.set(tmp, positions[i], positions[i + 1], positions[i + 2], 1);
-      import_gl_matrix2.vec4.transformMat4(tmp, tmp, model);
+      import_gl_matrix3.vec4.set(tmp, positions[i], positions[i + 1], positions[i + 2], 1);
+      import_gl_matrix3.vec4.transformMat4(tmp, tmp, model);
       const x = tmp[0];
       const y = tmp[1];
       const z = tmp[2];
@@ -20029,75 +20933,75 @@ function computeWorldAABB(drawCalls) {
 function getWorldUpVector(up) {
   switch (up) {
     case "y-":
-      return import_gl_matrix.vec3.fromValues(0, -1, 0);
+      return import_gl_matrix2.vec3.fromValues(0, -1, 0);
     case "x+":
-      return import_gl_matrix.vec3.fromValues(1, 0, 0);
+      return import_gl_matrix2.vec3.fromValues(1, 0, 0);
     case "x-":
-      return import_gl_matrix.vec3.fromValues(-1, 0, 0);
+      return import_gl_matrix2.vec3.fromValues(-1, 0, 0);
     case "z+":
-      return import_gl_matrix.vec3.fromValues(0, 0, 1);
+      return import_gl_matrix2.vec3.fromValues(0, 0, 1);
     case "z-":
-      return import_gl_matrix.vec3.fromValues(0, 0, -1);
+      return import_gl_matrix2.vec3.fromValues(0, 0, -1);
     case "y+":
     default:
-      return import_gl_matrix.vec3.fromValues(0, 1, 0);
+      return import_gl_matrix2.vec3.fromValues(0, 1, 0);
   }
 }
 function buildCameraWorldMatrix(eye, forward, up) {
-  const normalizedForward = import_gl_matrix.vec3.normalize(import_gl_matrix.vec3.create(), forward);
-  const right = import_gl_matrix.vec3.cross(import_gl_matrix.vec3.create(), normalizedForward, up);
-  if (import_gl_matrix.vec3.squaredLength(right) === 0) {
+  const normalizedForward = import_gl_matrix2.vec3.normalize(import_gl_matrix2.vec3.create(), forward);
+  const right = import_gl_matrix2.vec3.cross(import_gl_matrix2.vec3.create(), normalizedForward, up);
+  if (import_gl_matrix2.vec3.squaredLength(right) === 0) {
     return null;
   }
-  import_gl_matrix.vec3.normalize(right, right);
-  const correctedUp = import_gl_matrix.vec3.cross(import_gl_matrix.vec3.create(), right, normalizedForward);
-  if (import_gl_matrix.vec3.squaredLength(correctedUp) === 0) {
+  import_gl_matrix2.vec3.normalize(right, right);
+  const correctedUp = import_gl_matrix2.vec3.cross(import_gl_matrix2.vec3.create(), right, normalizedForward);
+  if (import_gl_matrix2.vec3.squaredLength(correctedUp) === 0) {
     return null;
   }
-  import_gl_matrix.vec3.normalize(correctedUp, correctedUp);
-  return import_gl_matrix.mat4.fromValues(right[0], right[1], right[2], 0, correctedUp[0], correctedUp[1], correctedUp[2], 0, -normalizedForward[0], -normalizedForward[1], -normalizedForward[2], 0, eye[0], eye[1], eye[2], 1);
+  import_gl_matrix2.vec3.normalize(correctedUp, correctedUp);
+  return import_gl_matrix2.mat4.fromValues(right[0], right[1], right[2], 0, correctedUp[0], correctedUp[1], correctedUp[2], 0, -normalizedForward[0], -normalizedForward[1], -normalizedForward[2], 0, eye[0], eye[1], eye[2], 1);
 }
 function getDefaultForwardForUp(up) {
-  const zForward = import_gl_matrix.vec3.fromValues(0, 0, -1);
-  if (Math.abs(import_gl_matrix.vec3.dot(up, zForward)) < 0.999) {
+  const zForward = import_gl_matrix2.vec3.fromValues(0, 0, -1);
+  if (Math.abs(import_gl_matrix2.vec3.dot(up, zForward)) < 0.999) {
     return zForward;
   }
-  return import_gl_matrix.vec3.fromValues(1, 0, 0);
+  return import_gl_matrix2.vec3.fromValues(1, 0, 0);
 }
 function buildViewFromRotation(eye, up, rotation) {
   const cameraWorld = buildCameraWorldMatrix(eye, getDefaultForwardForUp(up), up);
   if (!cameraWorld) {
-    return import_gl_matrix.mat4.create();
+    return import_gl_matrix2.mat4.create();
   }
   if (rotation.x !== 0) {
-    import_gl_matrix.mat4.rotateX(cameraWorld, cameraWorld, toRad(rotation.x));
+    import_gl_matrix2.mat4.rotateX(cameraWorld, cameraWorld, toRad(rotation.x));
   }
   if (rotation.y !== 0) {
-    import_gl_matrix.mat4.rotateY(cameraWorld, cameraWorld, toRad(rotation.y));
+    import_gl_matrix2.mat4.rotateY(cameraWorld, cameraWorld, toRad(rotation.y));
   }
   if (rotation.z !== 0) {
-    import_gl_matrix.mat4.rotateZ(cameraWorld, cameraWorld, toRad(rotation.z));
+    import_gl_matrix2.mat4.rotateZ(cameraWorld, cameraWorld, toRad(rotation.z));
   }
-  const view = import_gl_matrix.mat4.create();
-  import_gl_matrix.mat4.invert(view, cameraWorld);
+  const view = import_gl_matrix2.mat4.create();
+  import_gl_matrix2.mat4.invert(view, cameraWorld);
   return view;
 }
 function buildViewFromLookAt(eye, center, up) {
-  const forward = import_gl_matrix.vec3.subtract(import_gl_matrix.vec3.create(), center, eye);
-  if (import_gl_matrix.vec3.squaredLength(forward) === 0) {
-    return import_gl_matrix.mat4.create();
+  const forward = import_gl_matrix2.vec3.subtract(import_gl_matrix2.vec3.create(), center, eye);
+  if (import_gl_matrix2.vec3.squaredLength(forward) === 0) {
+    return import_gl_matrix2.mat4.create();
   }
   const cameraWorld = buildCameraWorldMatrix(eye, forward, up);
   if (!cameraWorld) {
-    return import_gl_matrix.mat4.create();
+    return import_gl_matrix2.mat4.create();
   }
-  const view = import_gl_matrix.mat4.create();
-  import_gl_matrix.mat4.invert(view, cameraWorld);
+  const view = import_gl_matrix2.mat4.create();
+  import_gl_matrix2.mat4.invert(view, cameraWorld);
   return view;
 }
 function getAutoDistance(drawCalls, fovDeg) {
   const aabb = computeWorldAABB(drawCalls);
-  const diag = import_gl_matrix.vec3.distance(import_gl_matrix.vec3.fromValues(aabb.min[0], aabb.min[1], aabb.min[2]), import_gl_matrix.vec3.fromValues(aabb.max[0], aabb.max[1], aabb.max[2]));
+  const diag = import_gl_matrix2.vec3.distance(import_gl_matrix2.vec3.fromValues(aabb.min[0], aabb.min[1], aabb.min[2]), import_gl_matrix2.vec3.fromValues(aabb.max[0], aabb.max[1], aabb.max[2]));
   const radius = diag * 0.5;
   const fov = toRad(fovDeg);
   return radius / Math.tan(fov * 0.5) + radius * 0.5;
@@ -20111,7 +21015,7 @@ function getAABBCornerDistances(aabb, eye) {
   for (const x of xs) {
     for (const y of ys) {
       for (const z of zs) {
-        const distance = import_gl_matrix.vec3.distance(eye, import_gl_matrix.vec3.fromValues(x, y, z));
+        const distance = import_gl_matrix2.vec3.distance(eye, import_gl_matrix2.vec3.fromValues(x, y, z));
         farthest = Math.max(farthest, distance);
       }
     }
@@ -20119,40 +21023,56 @@ function getAABBCornerDistances(aabb, eye) {
   return { nearest, farthest };
 }
 function getCameraForwardFromView(view) {
-  const cameraWorld = import_gl_matrix.mat4.create();
-  import_gl_matrix.mat4.invert(cameraWorld, view);
-  return import_gl_matrix.vec3.fromValues(-cameraWorld[8], -cameraWorld[9], -cameraWorld[10]);
+  const cameraWorld = import_gl_matrix2.mat4.create();
+  import_gl_matrix2.mat4.invert(cameraWorld, view);
+  return import_gl_matrix2.vec3.fromValues(-cameraWorld[8], -cameraWorld[9], -cameraWorld[10]);
 }
-function buildCamera(drawCalls, width, height, fovDeg, camPos, lookAt, up = "y+", cameraRotation = null) {
+function buildCamera(drawCalls, width, height, fovDeg, camPos, lookAt, up = "y+", cameraRotation = null, projection = "perspective", orthographicHeight = null) {
   const aspect = width / height;
   const worldUp = getWorldUpVector(up);
   const aabb = computeWorldAABB(drawCalls);
-  const center = import_gl_matrix.vec3.fromValues(0.5 * (aabb.min[0] + aabb.max[0]), 0.5 * (aabb.min[1] + aabb.max[1]), 0.5 * (aabb.min[2] + aabb.max[2]));
+  const center = import_gl_matrix2.vec3.fromValues(0.5 * (aabb.min[0] + aabb.max[0]), 0.5 * (aabb.min[1] + aabb.max[1]), 0.5 * (aabb.min[2] + aabb.max[2]));
   const autoDistance = getAutoDistance(drawCalls, fovDeg);
   if (cameraRotation) {
-    const provisionalEye = camPos ? import_gl_matrix.vec3.fromValues(camPos[0], camPos[1], camPos[2]) : import_gl_matrix.vec3.clone(center);
+    const provisionalEye = camPos ? import_gl_matrix2.vec3.fromValues(camPos[0], camPos[1], camPos[2]) : import_gl_matrix2.vec3.clone(center);
     const provisionalView = buildViewFromRotation(provisionalEye, worldUp, cameraRotation);
-    const eye2 = camPos ? provisionalEye : import_gl_matrix.vec3.scaleAndAdd(import_gl_matrix.vec3.create(), center, getCameraForwardFromView(provisionalView), -autoDistance);
+    const eye2 = camPos ? provisionalEye : import_gl_matrix2.vec3.scaleAndAdd(import_gl_matrix2.vec3.create(), center, getCameraForwardFromView(provisionalView), -autoDistance);
     const { nearest: nearest2, farthest: farthest2 } = getAABBCornerDistances(aabb, eye2);
     const near2 = Math.max(0.01, nearest2 * 0.5);
     const far2 = Math.max(1000, farthest2 * 1.1);
-    const proj2 = import_gl_matrix.mat4.create();
-    import_gl_matrix.mat4.perspective(proj2, toRad(fovDeg), aspect, near2, far2);
+    const proj2 = import_gl_matrix2.mat4.create();
+    const view2 = buildViewFromRotation(eye2, worldUp, cameraRotation);
+    setProjection(proj2, view2, aabb, projection, orthographicHeight, fovDeg, aspect, near2, far2);
     return {
-      view: buildViewFromRotation(eye2, worldUp, cameraRotation),
+      view: view2,
       proj: proj2
     };
   }
-  const eye = camPos ? import_gl_matrix.vec3.fromValues(camPos[0], camPos[1], camPos[2]) : import_gl_matrix.vec3.fromValues(center[0] + autoDistance, center[1] + autoDistance * 0.3, center[2] + autoDistance);
-  const target = lookAt ? import_gl_matrix.vec3.fromValues(lookAt[0], lookAt[1], lookAt[2]) : center;
+  const eye = camPos ? import_gl_matrix2.vec3.fromValues(camPos[0], camPos[1], camPos[2]) : import_gl_matrix2.vec3.fromValues(center[0] + autoDistance, center[1] + autoDistance * 0.3, center[2] + autoDistance);
+  const target = lookAt ? import_gl_matrix2.vec3.fromValues(lookAt[0], lookAt[1], lookAt[2]) : center;
   const { nearest, farthest } = getAABBCornerDistances(aabb, eye);
   const near = Math.max(0.01, nearest * 0.5);
   const far = Math.max(1000, farthest * 1.1);
-  const proj = import_gl_matrix.mat4.create();
-  import_gl_matrix.mat4.perspective(proj, toRad(fovDeg), aspect, near, far);
+  const proj = import_gl_matrix2.mat4.create();
   const view = buildViewFromLookAt(eye, target, worldUp);
+  setProjection(proj, view, aabb, projection, orthographicHeight, fovDeg, aspect, near, far);
   return { view, proj };
 }
+function setProjection(proj, view, aabb, projection, height, fov, aspect, near, far) {
+  if (projection === "perspective") {
+    import_gl_matrix2.mat4.perspective(proj, toRad(fov), aspect, near, far);
+    return;
+  }
+  let halfHeight = 0;
+  for (const x of [aabb.min[0], aabb.max[0]])
+    for (const y of [aabb.min[1], aabb.max[1]])
+      for (const z of [aabb.min[2], aabb.max[2]]) {
+        const p = import_gl_matrix2.vec3.transformMat4(import_gl_matrix2.vec3.create(), [x, y, z], view);
+        halfHeight = Math.max(halfHeight, Math.abs(p[1]), Math.abs(p[0]) / aspect);
+      }
+  halfHeight = height != null && Number.isFinite(height) && height > 0 ? height / 2 : Math.max(halfHeight * 1.1, 0.001);
+  import_gl_matrix2.mat4.ortho(proj, -halfHeight * aspect, halfHeight * aspect, -halfHeight, halfHeight, near, far);
+}
 function createGrid(options = {}) {
   const size = options.size ?? 10;
   const sizeX = typeof size === "number" ? size : size[0];
@@ -20177,8 +21097,8 @@ function createGrid(options = {}) {
     positions.push(halfSizeX, 0, pZ);
     indices.push(vertexIndex++, vertexIndex++);
   }
-  const model = import_gl_matrix3.mat4.create();
-  import_gl_matrix3.mat4.fromTranslation(model, [offset.x, offset.y, offset.z]);
+  const model = import_gl_matrix4.mat4.create();
+  import_gl_matrix4.mat4.fromTranslation(model, [offset.x, offset.y, offset.z]);
   return {
     positions: new Float32Array(positions),
     indices: new Uint32Array(indices),
@@ -20210,7 +21130,7 @@ function triangleNormal(positions, i0, i1, i2) {
     return null;
   return [nx / length, ny / length, nz / length];
 }
-function addEdge(edges, positions, i0, i1, normal) {
+function addEdge(edges, positions, i0, i1, thirdVertex, normal, facing) {
   const key0 = positionKey(positions, i0);
   const key1 = positionKey(positions, i1);
   const isForward = key0 < key1;
@@ -20220,8 +21140,15 @@ function addEdge(edges, positions, i0, i1, normal) {
   if (existing) {
     if (normal)
       existing.normals.push(normal);
+    existing.adjacentVertices.push(thirdVertex);
+    existing.facings.push(facing);
   } else {
-    edges.set(key, { indices, normals: normal ? [normal] : [] });
+    edges.set(key, {
+      indices,
+      normals: normal ? [normal] : [],
+      adjacentVertices: [thirdVertex],
+      facings: [facing]
+    });
   }
 }
 function hasCrease(normals, minimumDot) {
@@ -20238,29 +21165,42 @@ function hasCrease(normals, minimumDot) {
   }
   return false;
 }
-function createEdgeDrawCall(mesh, creaseAngleDegrees = DEFAULT_CREASE_ANGLE_DEGREES) {
+function createEdgeDrawCall(mesh, creaseAngleDegrees = DEFAULT_CREASE_ANGLE_DEGREES, camera) {
   if (mesh.mode != null && mesh.mode !== 4)
     return null;
   const vertexCount = Math.floor(mesh.positions.length / 3);
   const triangleIndices = mesh.indices ?? Uint32Array.from({ length: vertexCount }, (_, i) => i);
   if (triangleIndices.length < 3)
     return null;
+  let normalPositions = mesh.positions;
+  if (camera) {
+    const modelView = import_gl_matrix5.mat4.multiply(import_gl_matrix5.mat4.create(), camera.view, mesh.model);
+    normalPositions = new Float32Array(mesh.positions.length);
+    for (let i = 0;i < vertexCount; i++) {
+      const point = import_gl_matrix5.vec3.transformMat4(import_gl_matrix5.vec3.create(), mesh.positions.subarray(i * 3, i * 3 + 3), modelView);
+      normalPositions.set(point, i * 3);
+    }
+  }
   const edges = /* @__PURE__ */ new Map;
   for (let i = 0;i + 2 < triangleIndices.length; i += 3) {
     const i0 = triangleIndices[i];
     const i1 = triangleIndices[i + 1];
     const i2 = triangleIndices[i + 2];
-    const normal = triangleNormal(mesh.positions, i0, i1, i2);
-    addEdge(edges, mesh.positions, i0, i1, normal);
-    addEdge(edges, mesh.positions, i1, i2, normal);
-    addEdge(edges, mesh.positions, i2, i0, normal);
+    const normal = triangleNormal(normalPositions, i0, i1, i2);
+    const facing = !normal ? 0 : camera?.projection === "perspective" ? -(normal[0] * normalPositions[i0 * 3] + normal[1] * normalPositions[i0 * 3 + 1] + normal[2] * normalPositions[i0 * 3 + 2]) : normal[2];
+    addEdge(edges, mesh.positions, i0, i1, i2, normal, facing);
+    addEdge(edges, mesh.positions, i1, i2, i0, normal, facing);
+    addEdge(edges, mesh.positions, i2, i0, i1, normal, facing);
   }
   const minimumDot = Math.cos(creaseAngleDegrees * Math.PI / 180);
   const edgeIndices = [];
+  const edgeAdjacentVertices = [];
   for (const edge2 of edges.values()) {
-    if (!hasCrease(edge2.normals, minimumDot))
+    const silhouette = camera && edge2.facings.some((n) => n > 0.0000001) && edge2.facings.some((n) => n <= 0.0000001);
+    if (!hasCrease(edge2.normals, minimumDot) && !silhouette)
       continue;
     edgeIndices.push(edge2.indices[0], edge2.indices[1]);
+    edgeAdjacentVertices.push(edge2.adjacentVertices);
   }
   if (edgeIndices.length === 0)
     return null;
@@ -20275,7 +21215,8 @@ function createEdgeDrawCall(mesh, creaseAngleDegrees = DEFAULT_CREASE_ANGLE_DEGR
       baseColorTexture: null,
       alphaMode: "BLEND"
     },
-    mode: 1
+    mode: 1,
+    edgeAdjacentVertices
   };
 }
 function downsampleBitmap(source, targetWidth, targetHeight, imageFactory) {
@@ -20482,14 +21423,102 @@ function clipMeshToNearPlane(mesh, mvp) {
     indices: new Uint32Array(indices)
   };
 }
+function clipLine(start, end, marginX, marginY) {
+  if (![...start, ...end].every(Number.isFinite))
+    return null;
+  const distances = (p) => [
+    p[3] * (1 + marginX) + p[0],
+    p[3] * (1 + marginX) - p[0],
+    p[3] * (1 + marginY) + p[1],
+    p[3] * (1 + marginY) - p[1],
+    p[3] + p[2],
+    p[3] - p[2]
+  ];
+  const a = distances(start);
+  const b = distances(end);
+  let from = 0;
+  let to = 1;
+  for (let plane = 0;plane < 6; plane++) {
+    if (a[plane] < 0 && b[plane] < 0)
+      return null;
+    if (a[plane] < 0 !== b[plane] < 0) {
+      const t = a[plane] / (a[plane] - b[plane]);
+      if (a[plane] < 0)
+        from = Math.max(from, t);
+      else
+        to = Math.min(to, t);
+    }
+  }
+  if (from > to)
+    return null;
+  return [from, to].map((t) => Array.from(start, (value, axis) => value + t * (end[axis] - value)));
+}
+function rasterizeWideLine(start, end, width, height, strokeWidth, dashed, dashLength, fragment) {
+  const radius = strokeWidth / 2;
+  const padding = radius + 0.5;
+  const clipped = clipLine(start, end, 2 * padding / Math.max(1, width - 1), 2 * padding / Math.max(1, height - 1));
+  if (!clipped)
+    return;
+  const project = (p) => [
+    (p[0] / p[3] * 0.5 + 0.5) * (width - 1),
+    (0.5 - p[1] / p[3] * 0.5) * (height - 1),
+    Math.max(0, Math.min(1, p[2] / p[3] * 0.5 + 0.5))
+  ];
+  const a = project(clipped[0]);
+  const b = project(clipped[1]);
+  if (![...a, ...b].every(Number.isFinite))
+    return;
+  const [x0, y0, z0] = a;
+  const [x1, y1, z1] = b;
+  const dx = x1 - x0;
+  const dy = y1 - y0;
+  const lengthSquared = dx * dx + dy * dy;
+  const length = Math.sqrt(lengthSquared);
+  const original = start[3] > 0 ? project(start) : a;
+  const phase = Math.hypot(x0 - original[0], y0 - original[1]);
+  const drawPixel = (x, y) => {
+    const t = lengthSquared === 0 ? 0 : Math.max(0, Math.min(1, ((x - x0) * dx + (y - y0) * dy) / lengthSquared));
+    if (dashed && Math.floor((phase + t * length) / dashLength) % 2 === 1)
+      return;
+    const distance = Math.hypot(x - (x0 + t * dx), y - (y0 + t * dy));
+    const coverage = Math.min(1, padding - distance);
+    if (coverage > 0)
+      fragment(x, y, z0 + t * (z1 - z0), coverage);
+  };
+  if (Math.abs(dx) >= Math.abs(dy)) {
+    const band = length === 0 ? padding : padding * length / Math.abs(dx);
+    const first = Math.max(0, Math.ceil(Math.min(x0, x1) - padding));
+    const last = Math.min(width - 1, Math.floor(Math.max(x0, x1) + padding));
+    for (let x = first;x <= last; x++) {
+      const t = dx === 0 ? 0 : Math.max(0, Math.min(1, (x - x0) / dx));
+      const centerY = y0 + t * dy;
+      const top = Math.max(0, Math.ceil(centerY - band));
+      const bottom = Math.min(height - 1, Math.floor(centerY + band));
+      for (let y = top;y <= bottom; y++)
+        drawPixel(x, y);
+    }
+  } else {
+    const band = padding * length / Math.abs(dy);
+    const first = Math.max(0, Math.ceil(Math.min(y0, y1) - padding));
+    const last = Math.min(height - 1, Math.floor(Math.max(y0, y1) + padding));
+    for (let y = first;y <= last; y++) {
+      const t = Math.max(0, Math.min(1, (y - y0) / dy));
+      const centerX = x0 + t * dx;
+      const left = Math.max(0, Math.ceil(centerX - band));
+      const right = Math.min(width - 1, Math.floor(centerX + band));
+      for (let x = left;x <= right; x++)
+        drawPixel(x, y);
+    }
+  }
+}
 function edge(a, b, p) {
   return (p[0] - a[0]) * (b[1] - a[1]) - (p[1] - a[1]) * (b[0] - a[0]);
 }
 function drawDebugPoints(renderer, camera, debugPoints, debugFontSize, debugPointColor, debugLabelColor) {
   if (debugPoints.length === 0)
     return;
-  const viewProj = import_gl_matrix4.mat4.create();
-  import_gl_matrix4.mat4.multiply(viewProj, camera.proj, camera.view);
+  const viewProj = import_gl_matrix6.mat4.create();
+  import_gl_matrix6.mat4.multiply(viewProj, camera.proj, camera.view);
   const markerColor = toColorRGBA(debugPointColor, DEFAULT_MARKER_COLOR);
   const textColor = toColorRGBA(debugLabelColor, DEFAULT_TEXT_COLOR);
   const labelScale = typeof debugFontSize === "number" && Number.isFinite(debugFontSize) ? Math.max(1, Math.round(debugFontSize)) : Math.max(12, Math.round(Math.min(renderer.width, renderer.height) * 0.028));
@@ -20503,8 +21532,8 @@ function drawDebugPoints(renderer, camera, debugPoints, debugFontSize, debugPoin
   }
 }
 function projectWorldToScreen(position, viewProj, renderer) {
-  const clip = import_gl_matrix4.vec4.fromValues(position.x, position.y, position.z, 1);
-  import_gl_matrix4.vec4.transformMat4(clip, clip, viewProj);
+  const clip = import_gl_matrix6.vec4.fromValues(position.x, position.y, position.z, 1);
+  import_gl_matrix6.vec4.transformMat4(clip, clip, viewProj);
   if (!Number.isFinite(clip[3]) || clip[3] <= 0)
     return null;
   const invW = 1 / clip[3];
@@ -20632,23 +21661,23 @@ function drawInfiniteGrid(software_renderer, params) {
   const camera = params.camera;
   const view = camera.view;
   const proj = camera.proj;
-  const inv_view = import_gl_matrix6.mat4.create();
-  import_gl_matrix6.mat4.invert(inv_view, view);
+  const inv_view = import_gl_matrix8.mat4.create();
+  import_gl_matrix8.mat4.invert(inv_view, view);
   const cam_pos_x = inv_view[12];
   const cam_pos_y = inv_view[13];
   const cam_pos_z = inv_view[14];
-  const vp = import_gl_matrix6.mat4.create();
-  import_gl_matrix6.mat4.multiply(vp, proj, view);
-  const inv_vp = import_gl_matrix6.mat4.create();
-  import_gl_matrix6.mat4.invert(inv_vp, vp);
+  const vp = import_gl_matrix8.mat4.create();
+  import_gl_matrix8.mat4.multiply(vp, proj, view);
+  const inv_vp = import_gl_matrix8.mat4.create();
+  import_gl_matrix8.mat4.invert(inv_vp, vp);
   for (let y = 0;y < software_renderer.height; y++) {
     for (let x = 0;x < software_renderer.width; x++) {
       const ndc_x = x / (software_renderer.width - 1) * 2 - 1;
       const ndc_y = 1 - y / (software_renderer.height - 1) * 2;
-      const near_point = import_gl_matrix6.vec4.fromValues(ndc_x, ndc_y, -1, 1);
-      const far_point = import_gl_matrix6.vec4.fromValues(ndc_x, ndc_y, 1, 1);
-      import_gl_matrix6.vec4.transformMat4(near_point, near_point, inv_vp);
-      import_gl_matrix6.vec4.transformMat4(far_point, far_point, inv_vp);
+      const near_point = import_gl_matrix8.vec4.fromValues(ndc_x, ndc_y, -1, 1);
+      const far_point = import_gl_matrix8.vec4.fromValues(ndc_x, ndc_y, 1, 1);
+      import_gl_matrix8.vec4.transformMat4(near_point, near_point, inv_vp);
+      import_gl_matrix8.vec4.transformMat4(far_point, far_point, inv_vp);
       near_point[0] /= near_point[3];
       near_point[1] /= near_point[3];
       near_point[2] /= near_point[3];
@@ -20665,9 +21694,9 @@ function drawInfiniteGrid(software_renderer, params) {
         continue;
       const world_x = near_point[0] + t * ray_dir_x;
       const world_z = near_point[2] + t * ray_dir_z;
-      const world_pt = import_gl_matrix6.vec4.fromValues(world_x, grid_y, world_z, 1);
-      const clip_pt = import_gl_matrix6.vec4.create();
-      import_gl_matrix6.vec4.transformMat4(clip_pt, world_pt, vp);
+      const world_pt = import_gl_matrix8.vec4.fromValues(world_x, grid_y, world_z, 1);
+      const clip_pt = import_gl_matrix8.vec4.create();
+      import_gl_matrix8.vec4.transformMat4(clip_pt, world_pt, vp);
       const ndc_z = clip_pt[2] / clip_pt[3];
       const depth_01 = ndc_z * 0.5 + 0.5;
       const di = y * software_renderer.width + x;
@@ -20753,17 +21782,36 @@ function resolveCameraRotation(cameraRotation) {
 }
 function resolveRenderOptions(options = {}) {
   const supersampling = typeof options.supersampling === "number" && Number.isFinite(options.supersampling) ? Math.max(1, Math.floor(options.supersampling)) : DEFAULT_RENDER_OPTIONS.supersampling;
+  const outline = options.renderStyle === "outline";
   return {
     ...DEFAULT_RENDER_OPTIONS,
     ...options,
+    renderStyle: outline ? "outline" : "shaded",
+    projection: options.projection === "orthographic" || outline && options.projection !== "perspective" ? "orthographic" : "perspective",
+    orthographicHeight: typeof options.orthographicHeight === "number" && Number.isFinite(options.orthographicHeight) && options.orthographicHeight > 0 ? options.orthographicHeight : null,
+    ...outline ? {
+      realistic: false,
+      ambient: 1,
+      gamma: false,
+      cull: false,
+      backgroundColor: options.backgroundColor ?? "#ffffff"
+    } : {},
     supersampling,
     lightDir: options.lightDir != null ? options.lightDir : DEFAULT_RENDER_OPTIONS.lightDir,
     camPos: options.camPos !== undefined ? options.camPos : DEFAULT_RENDER_OPTIONS.camPos,
     lookAt: options.lookAt !== undefined ? options.lookAt : DEFAULT_RENDER_OPTIONS.lookAt,
     up: resolveCameraUp(options.up),
-    cameraRotation: resolveCameraRotation(options.cameraRotation)
+    cameraRotation: resolveCameraRotation(options.cameraRotation),
+    showEdges: options.showEdges ?? outline,
+    showHiddenEdges: typeof options.showHiddenEdges === "boolean" ? options.showHiddenEdges : outline ? false : null,
+    edgeWidth: resolveWidth(options.edgeWidth),
+    lineWidth: resolveWidth(options.lineWidth),
+    hiddenEdgeOpacity: typeof options.hiddenEdgeOpacity === "number" && Number.isFinite(options.hiddenEdgeOpacity) ? Math.max(0, Math.min(1, options.hiddenEdgeOpacity)) : DEFAULT_RENDER_OPTIONS.hiddenEdgeOpacity
   };
 }
+function resolveWidth(width) {
+  return typeof width === "number" && Number.isFinite(width) && width > 0 ? width : 1;
+}
 function dotNormal(normal, direction) {
   return normal[0] * direction[0] + normal[1] * direction[1] + normal[2] * direction[2];
 }
@@ -20787,7 +21835,7 @@ function basis(n) {
     ]
   ];
 }
-function orient(x, y, z, n, t, b) {
+function orient2(x, y, z, n, t, b) {
   return [
     t[0] * x + b[0] * y + n[0] * z,
     t[1] * x + b[1] * y + n[1] * z,
@@ -20829,14 +21877,14 @@ function getTables() {
       ];
       const [t, b] = basis(n), index = y * W + x;
       for (const s of diffuseSamples) {
-        const l = orient(...s, n, t, b);
+        const l = orient2(...s, n, t, b);
         for (let j = 0;j < lobes.length; j++)
           diffuse[j][index] += Math.exp(lobes[j].sharpness * (dot(l, lobes[j].direction) - 1)) / SAMPLES;
       }
       for (let r = 0;r < ROUGHNESSES.length; r++) {
         let weight = 0;
         for (const s of halfSamples[r]) {
-          const h = orient(...s, n, t, b), nh = dot(n, h);
+          const h = orient2(...s, n, t, b), nh = dot(n, h);
           const l = [
             2 * nh * h[0] - n[0],
             2 * nh * h[1] - n[1],
@@ -20877,11 +21925,150 @@ function getTables() {
   cachedTables = { diffuse, specular, brdf };
   return cachedTables;
 }
+function createExplosionLineDrawCall(line) {
+  if (line.points.length < 2 || line.points.some((point) => point.length !== 3 || !point.every(Number.isFinite))) {
+    throw new Error("Explosion lines need at least two finite XYZ points");
+  }
+  const color = line.color ?? [0.08, 0.2, 0.35];
+  if (color.length !== 3 || color.some((channel) => !Number.isFinite(channel) || channel < 0 || channel > 1)) {
+    throw new Error("Explosion line colors must be linear RGB values from 0 to 1");
+  }
+  const indices = [];
+  for (let vertex = 1;vertex < line.points.length; vertex++) {
+    indices.push(vertex - 1, vertex);
+  }
+  return {
+    positions: new Float32Array(line.points.flatMap((point) => [...point])),
+    indices: new Uint32Array(indices),
+    normals: null,
+    uvs: null,
+    model: import_gl_matrix11.mat4.create(),
+    material: { baseColorFactor: [...color, 1], baseColorTexture: null },
+    mode: 1
+  };
+}
+function clipExplosionLineDrawCall(drawCall, camera) {
+  const viewProjection = import_gl_matrix11.mat4.multiply(import_gl_matrix11.mat4.create(), camera.proj, camera.view);
+  const positions = [];
+  const indices = [];
+  const distances = (point) => [
+    point[3] + point[0],
+    point[3] - point[0],
+    point[3] + point[1],
+    point[3] - point[1],
+    point[3] + point[2],
+    point[3] - point[2]
+  ];
+  for (let segment = 0;segment < drawCall.indices.length; segment += 2) {
+    const startIndex = drawCall.indices[segment] * 3;
+    const endIndex = drawCall.indices[segment + 1] * 3;
+    const start = import_gl_matrix11.vec4.fromValues(drawCall.positions[startIndex], drawCall.positions[startIndex + 1], drawCall.positions[startIndex + 2], 1);
+    const end = import_gl_matrix11.vec4.fromValues(drawCall.positions[endIndex], drawCall.positions[endIndex + 1], drawCall.positions[endIndex + 2], 1);
+    const startDistances = distances(import_gl_matrix11.vec4.transformMat4(import_gl_matrix11.vec4.create(), start, viewProjection));
+    const endDistances = distances(import_gl_matrix11.vec4.transformMat4(import_gl_matrix11.vec4.create(), end, viewProjection));
+    let from = 0;
+    let to = 1;
+    for (let plane = 0;plane < 6; plane++) {
+      const a = startDistances[plane];
+      const b = endDistances[plane];
+      if (a < 0 && b < 0) {
+        to = -1;
+        break;
+      }
+      if (a < 0 !== b < 0) {
+        const intersection = a / (a - b);
+        if (a < 0)
+          from = Math.max(from, intersection);
+        else
+          to = Math.min(to, intersection);
+      }
+    }
+    if (from > to)
+      continue;
+    const vertex = positions.length / 3;
+    for (const progress of [from, to]) {
+      for (let axis = 0;axis < 3; axis++) {
+        positions.push(start[axis] + progress * (end[axis] - start[axis]));
+      }
+    }
+    indices.push(vertex, vertex + 1);
+  }
+  return {
+    ...drawCall,
+    positions: new Float32Array(positions),
+    indices: new Uint32Array(indices)
+  };
+}
+function createExplosionArrowDrawCall(drawCall, camera, width, height, supersampling) {
+  if (width <= 1 || height <= 1)
+    return null;
+  const points = drawCall.positions;
+  const end = points.length - 3;
+  let start = end - 3;
+  while (start >= 0 && points[start] === points[end] && points[start + 1] === points[end + 1] && points[start + 2] === points[end + 2]) {
+    start -= 3;
+  }
+  if (start < 0)
+    return null;
+  const viewProjection = import_gl_matrix12.mat4.multiply(import_gl_matrix12.mat4.create(), camera.proj, camera.view);
+  const tip = import_gl_matrix12.vec4.transformMat4(import_gl_matrix12.vec4.create(), import_gl_matrix12.vec4.fromValues(points[end], points[end + 1], points[end + 2], 1), viewProjection);
+  if (!Array.from(tip).every(Number.isFinite) || tip[3] <= 0 || Math.abs(tip[0]) > tip[3] || Math.abs(tip[1]) > tip[3] || Math.abs(tip[2]) > tip[3]) {
+    return null;
+  }
+  const clipped = clipExplosionLineDrawCall({
+    ...drawCall,
+    positions: new Float32Array([
+      points[start],
+      points[start + 1],
+      points[start + 2],
+      points[end],
+      points[end + 1],
+      points[end + 2]
+    ]),
+    indices: new Uint32Array([0, 1])
+  }, camera);
+  if (!clipped.indices?.length)
+    return null;
+  const tail = import_gl_matrix12.vec4.transformMat4(import_gl_matrix12.vec4.create(), import_gl_matrix12.vec4.fromValues(clipped.positions[0], clipped.positions[1], clipped.positions[2], 1), viewProjection);
+  if (tail[3] <= 0)
+    return null;
+  const dx = (tip[0] / tip[3] - tail[0] / tail[3]) * (width - 1) / 2;
+  const dy = (tip[1] / tip[3] - tail[1] / tail[3]) * (height - 1) / 2;
+  const length = Math.hypot(dx, dy);
+  if (!Number.isFinite(length) || length < 0.001)
+    return null;
+  const arrowLength = Math.min(10 * supersampling, length / 2);
+  const ux = dx / length;
+  const uy = dy / length;
+  const inverse = import_gl_matrix12.mat4.invert(import_gl_matrix12.mat4.create(), viewProjection);
+  if (!inverse)
+    return null;
+  const positions = [points[end], points[end + 1], points[end + 2]];
+  for (const side of [-1, 1]) {
+    const offsetX = -ux * arrowLength - side * uy * arrowLength * 0.45;
+    const offsetY = -uy * arrowLength + side * ux * arrowLength * 0.45;
+    const wing = import_gl_matrix12.vec4.transformMat4(import_gl_matrix12.vec4.create(), import_gl_matrix12.vec4.fromValues(tip[0] / tip[3] + 2 * offsetX / (width - 1), tip[1] / tip[3] + 2 * offsetY / (height - 1), tip[2] / tip[3], 1), inverse);
+    if (!Array.from(wing).every(Number.isFinite) || wing[3] === 0)
+      return null;
+    positions.push(wing[0] / wing[3], wing[1] / wing[3], wing[2] / wing[3]);
+  }
+  return {
+    ...drawCall,
+    positions: new Float32Array(positions),
+    indices: new Uint32Array([0, 1, 0, 2])
+  };
+}
 function renderDrawCalls(drawCalls, optionsInput = {}, imageFactory = createUint8Bitmap) {
   const options = resolveRenderOptions(optionsInput);
+  if (options.section) {
+    if (options.renderStyle !== "outline")
+      throw new Error("section requires renderStyle: outline");
+    drawCalls = createOutlineSection(drawCalls, options.section).drawCalls;
+  }
   const renderWidth = options.width * options.supersampling;
   const renderHeight = options.height * options.supersampling;
-  const camera = buildCamera(drawCalls, renderWidth, renderHeight, options.fov, options.camPos ?? null, options.lookAt ?? null, options.up, options.cameraRotation ?? null);
+  const explosionDrawCalls = (options.explosionLines ?? []).map(createExplosionLineDrawCall);
+  const camera = buildCamera([...drawCalls, ...explosionDrawCalls], renderWidth, renderHeight, options.fov, options.camPos ?? null, options.lookAt ?? null, options.up, options.cameraRotation ?? null, options.projection, options.orthographicHeight);
   const renderer = new SoftwareRenderer(renderWidth, renderHeight, imageFactory, options.realistic);
   let rgb = null;
   if (options.backgroundColor) {
@@ -20902,7 +22089,17 @@ function renderDrawCalls(drawCalls, optionsInput = {}, imageFactory = createUint
   } else {
     renderer.clear([0, 0, 0, 0]);
   }
-  const allDrawCalls = [...drawCalls];
+  const allDrawCalls = options.renderStyle === "outline" ? drawCalls.map((dc) => dc.mode === 1 || dc.outlineSectionCap ? dc : {
+    ...dc,
+    normals: null,
+    colors: null,
+    uvs: null,
+    material: {
+      baseColorFactor: [1, 1, 1, 1],
+      baseColorTexture: null,
+      alphaMode: "OPAQUE"
+    }
+  }) : [...drawCalls];
   let infiniteGridOptions = null;
   if (options.grid) {
     const userGridOptions = typeof options.grid === "boolean" ? {} : options.grid;
@@ -20953,7 +22150,9 @@ function renderDrawCalls(drawCalls, optionsInput = {}, imageFactory = createUint
     for (let i = 0;i < dcs.length; i++) {
       const dc = dcs[i];
       if (dc.mode === 1) {
-        renderer.drawLines(dc, camera, options.gamma);
+        renderer.drawLines(dc, camera, options.gamma, {
+          width: options.lineWidth * options.supersampling
+        });
       } else {
         renderer.drawMesh(dc, camera, { dir: options.lightDir, ambient: options.ambient }, dc.material, options.cull, options.gamma, studio, opaque && winners ? { winners, triangleOffset: triangleOffsets[i], depthOnly: false } : undefined);
       }
@@ -20980,24 +22179,50 @@ function renderDrawCalls(drawCalls, optionsInput = {}, imageFactory = createUint
   renderGroup(blendDraws);
   renderer.denoise(options.gamma);
   for (const dc of drawCalls) {
-    if (!dc.showHiddenEdges)
+    const showHiddenEdges = options.showHiddenEdges ?? dc.showHiddenEdges;
+    if (!options.showEdges && !showHiddenEdges)
       continue;
-    const edgeDrawCall = createEdgeDrawCall(dc);
+    const edgeDrawCall = createEdgeDrawCall(dc, 30, options.renderStyle === "outline" ? { view: camera.view, projection: options.projection } : undefined);
     if (!edgeDrawCall)
       continue;
     renderer.drawLines(edgeDrawCall, camera, options.gamma, {
       depthCompare: "less-equal",
       depthWrite: false,
-      depthBias: 0.0001
+      depthBias: 0.0001,
+      width: options.edgeWidth * options.supersampling
     });
+    if (!showHiddenEdges)
+      continue;
     renderer.drawLines(edgeDrawCall, camera, options.gamma, {
       depthCompare: "greater",
       depthWrite: false,
       depthBias: 0.0001,
       dashed: true,
       dashLength: 4 * options.supersampling,
-      opacity: 0.35
+      opacity: options.hiddenEdgeOpacity,
+      width: options.edgeWidth * options.supersampling
+    });
+  }
+  for (const [index, drawCall] of explosionDrawCalls.entries()) {
+    renderer.drawLines(clipExplosionLineDrawCall(drawCall, camera), camera, options.gamma, {
+      depthCompare: "less-equal",
+      depthWrite: false,
+      depthBias: 0.0001,
+      dashed: options.explosionLines[index].dashed ?? true,
+      dashLength: 4 * options.supersampling,
+      width: options.lineWidth * options.supersampling
     });
+    if (options.explosionLines[index].arrow) {
+      const arrow = createExplosionArrowDrawCall(drawCall, camera, renderWidth, renderHeight, options.supersampling);
+      if (arrow) {
+        renderer.drawLines(clipExplosionLineDrawCall(arrow, camera), camera, options.gamma, {
+          depthCompare: "less-equal",
+          depthWrite: false,
+          depthBias: 0.0001,
+          width: options.lineWidth * options.supersampling
+        });
+      }
+    }
   }
   if (options.debugPoints?.length) {
     drawDebugPoints(renderer, camera, options.debugPoints, options.debugFontSize, options.debugPointColor, options.debugLabelColor);
@@ -21028,9 +22253,9 @@ function createInfiniteGrid(options = {}) {
     size
   ]);
   const indices = new Uint32Array([0, 1, 2, 0, 2, 3]);
-  const model = import_gl_matrix9.mat4.create();
+  const model = import_gl_matrix13.mat4.create();
   const offset = options.offset ?? {};
-  import_gl_matrix9.mat4.fromTranslation(model, [offset.x ?? 0, offset.y ?? 0, offset.z ?? 0]);
+  import_gl_matrix13.mat4.fromTranslation(model, [offset.x ?? 0, offset.y ?? 0, offset.z ?? 0]);
   return {
     positions,
     indices,
@@ -21204,7 +22429,7 @@ function readIndices(ctx, accessorIndex) {
 }
 function nodeLocalMatrix(node) {
   if (node.matrix) {
-    const m2 = import_gl_matrix10.mat4.create();
+    const m2 = import_gl_matrix14.mat4.create();
     for (let i = 0;i < 16; i++)
       m2[i] = node.matrix[i];
     return m2;
@@ -21212,10 +22437,10 @@ function nodeLocalMatrix(node) {
   const translation = node.translation || [0, 0, 0];
   const rotation = node.rotation || [0, 0, 0, 1];
   const scale = node.scale || [1, 1, 1];
-  const m = import_gl_matrix10.mat4.create();
-  const tmp = import_gl_matrix10.mat4.create();
-  import_gl_matrix10.mat4.fromRotationTranslationScale(tmp, rotation, translation, scale);
-  import_gl_matrix10.mat4.copy(m, tmp);
+  const m = import_gl_matrix14.mat4.create();
+  const tmp = import_gl_matrix14.mat4.create();
+  import_gl_matrix14.mat4.fromRotationTranslationScale(tmp, rotation, translation, scale);
+  import_gl_matrix14.mat4.copy(m, tmp);
   return m;
 }
 function getMaterial(gltf, textures, images, materialIndex) {
@@ -21259,8 +22484,8 @@ function createSceneFromGLTF(gltf, resources) {
     if (!node)
       return;
     const local = nodeLocalMatrix(node);
-    const world = import_gl_matrix10.mat4.create();
-    import_gl_matrix10.mat4.multiply(world, parentMatrix, local);
+    const world = import_gl_matrix14.mat4.create();
+    import_gl_matrix14.mat4.multiply(world, parentMatrix, local);
     if (Number.isInteger(node.mesh)) {
       const mesh = meshes[node.mesh];
       if (mesh) {
@@ -21296,7 +22521,7 @@ function createSceneFromGLTF(gltf, resources) {
       traverse(childIndex, world);
     }
   }
-  const identity = import_gl_matrix10.mat4.create();
+  const identity = import_gl_matrix14.mat4.create();
   for (const rootIndex of scene.nodes || []) {
     traverse(rootIndex, identity);
   }
@@ -21582,11 +22807,11 @@ async function renderGLTFToPNGFromGLB(glb, options = {}) {
 function renderSceneFromGLTF(scene, options, imageFactory) {
   return renderDrawCalls(scene.drawCalls, options, imageFactory);
 }
-var import_gl_matrix, import_gl_matrix2, import_gl_matrix3, import_gl_matrix4, import_gl_matrix5, import_gl_matrix6, import_gl_matrix7, import_gl_matrix8, import_gl_matrix9, import_gl_matrix10, toRad = (degrees) => degrees * Math.PI / 180, DEFAULT_CREASE_ANGLE_DEGREES = 30, createUint8Bitmap = (width, height) => ({
+var import_gl_matrix, import_gl_matrix2, import_gl_matrix3, import_gl_matrix4, import_gl_matrix5, import_gl_matrix6, import_gl_matrix7, import_gl_matrix8, import_gl_matrix9, import_gl_matrix10, import_gl_matrix11, import_gl_matrix12, import_gl_matrix13, import_gl_matrix14, createUint8Bitmap = (width, height) => ({
   width,
   height,
   data: new Uint8ClampedArray(width * height * 4)
-}), DEFAULT_LIGHT_DIR, DEFAULT_RENDER_OPTIONS, clamp = (value, min, max) => Math.max(min, Math.min(max, value)), GeometryDenoiser = class {
+}), toRad = (degrees) => degrees * Math.PI / 180, DEFAULT_CREASE_ANGLE_DEGREES = 30, DEFAULT_LIGHT_DIR, DEFAULT_RENDER_OPTIONS, clamp = (value, min, max) => Math.max(min, Math.min(max, value)), GeometryDenoiser = class {
   constructor(width, height) {
     this.width = width;
     this.height = height;
@@ -21724,16 +22949,18 @@ var import_gl_matrix, import_gl_matrix2, import_gl_matrix3, import_gl_matrix4, i
       return;
     const view = camera.view;
     const proj = camera.proj;
-    const mvp = import_gl_matrix5.mat4.create();
-    import_gl_matrix5.mat4.multiply(mvp, proj, import_gl_matrix5.mat4.multiply(import_gl_matrix5.mat4.create(), view, model));
+    const mvp = import_gl_matrix7.mat4.create();
+    import_gl_matrix7.mat4.multiply(mvp, proj, import_gl_matrix7.mat4.multiply(import_gl_matrix7.mat4.create(), view, model));
     const vertexCount = positions.length / 3 | 0;
     const vScreen = new Array(vertexCount);
     const vInvW = new Float32Array(vertexCount);
     const vNDCz = new Float32Array(vertexCount);
+    const clipVertices = [];
     for (let i = 0;i < vertexCount; i++) {
-      const p = import_gl_matrix5.vec4.fromValues(positions[i * 3 + 0], positions[i * 3 + 1], positions[i * 3 + 2], 1);
-      const c = import_gl_matrix5.vec4.create();
-      import_gl_matrix5.vec4.transformMat4(c, p, mvp);
+      const p = import_gl_matrix7.vec4.fromValues(positions[i * 3 + 0], positions[i * 3 + 1], positions[i * 3 + 2], 1);
+      const c = import_gl_matrix7.vec4.create();
+      import_gl_matrix7.vec4.transformMat4(c, p, mvp);
+      clipVertices.push(c);
       const invW = 1 / c[3];
       vInvW[i] = invW;
       if (!isFinite(invW)) {
@@ -21768,9 +22995,58 @@ var import_gl_matrix, import_gl_matrix2, import_gl_matrix3, import_gl_matrix4, i
     const depthWrite = options.depthWrite ?? true;
     const depthBias = options.depthBias ?? 0;
     const dashLength = Math.max(1, options.dashLength ?? 4);
+    const strokeWidth = typeof options.width === "number" && Number.isFinite(options.width) && options.width > 0 ? options.width : 1;
+    const drawFragment = (xi, yi, z, coverage = 1) => {
+      if (z < 0 || z > 1)
+        return;
+      const di = yi * this.width + xi;
+      const currentDepth = this.depth[di];
+      const passesDepth = depthCompare === "greater" ? z > currentDepth + depthBias : depthCompare === "less-equal" ? z <= currentDepth + depthBias : z < currentDepth - depthBias;
+      if (!passesDepth)
+        return;
+      if (depthWrite)
+        this.depth[di] = z;
+      const pixelIndex = di * 4;
+      const destinationAlpha = this.buffer[pixelIndex + 3] / 255;
+      const alpha = sourceAlpha * coverage;
+      const oneMinusSourceAlpha = 1 - alpha;
+      const outAlpha = alpha + destinationAlpha * oneMinusSourceAlpha;
+      const blend = (channel, offset) => outAlpha === 0 ? 0 : (channel * alpha + this.buffer[pixelIndex + offset] * destinationAlpha * oneMinusSourceAlpha) / outAlpha;
+      this.setPixel(xi, yi, blend(r255, 0), blend(g255, 1), blend(b255, 2), outAlpha * 255);
+    };
     for (let i = 0;i < indices.length; i += 2) {
       const i0 = indices[i + 0];
       const i1 = indices[i + 1];
+      if (strokeWidth !== 1) {
+        const sourceFaces = (mesh.edgeAdjacentVertices?.[i / 2] ?? []).flatMap((third) => {
+          if (clipVertices[i0][3] <= 0 || clipVertices[i1][3] <= 0 || clipVertices[third][3] <= 0)
+            return [];
+          const a2 = vScreen[i0];
+          const b2 = vScreen[i1];
+          const c = vScreen[third];
+          const area = edge(a2, b2, c);
+          if (!Number.isFinite(area) || area === 0)
+            return [];
+          return [{ a: a2, b: b2, c, inverseArea: 1 / area, third }];
+        });
+        rasterizeWideLine(clipVertices[i0], clipVertices[i1], this.width, this.height, strokeWidth, options.dashed ?? false, dashLength, sourceFaces.length === 0 ? drawFragment : (x2, y2, z2, coverage) => {
+          let surfaceDepth = Infinity;
+          const sample = [x2 + 0.5, y2 + 0.5];
+          for (const face of sourceFaces) {
+            const l0 = edge(face.b, face.c, sample) * face.inverseArea;
+            const l1 = edge(face.c, face.a, sample) * face.inverseArea;
+            const l2 = 1 - l0 - l1;
+            if (l0 < -0.000001 || l1 < -0.000001 || l2 < -0.000001)
+              continue;
+            const depth = (l0 * vNDCz[i0] + l1 * vNDCz[i1] + l2 * vNDCz[face.third]) * 0.5 + 0.5;
+            if (depth >= 0 && depth <= 1) {
+              surfaceDepth = Math.min(surfaceDepth, depth);
+            }
+          }
+          drawFragment(x2, y2, surfaceDepth === Infinity ? z2 : surfaceDepth, coverage);
+        });
+        continue;
+      }
       const v0s = vScreen[i0];
       const v1s = vScreen[i1];
       const z0_ndc = vNDCz[i0];
@@ -21806,21 +23082,7 @@ var import_gl_matrix, import_gl_matrix2, import_gl_matrix3, import_gl_matrix4, i
         const xi = Math.round(x);
         const yi = Math.round(y);
         if (xi >= 0 && xi < this.width && yi >= 0 && yi < this.height && z >= 0 && z <= 1) {
-          const di = yi * this.width + xi;
-          const currentDepth = this.depth[di];
-          const passesDepth = depthCompare === "greater" ? z > currentDepth + depthBias : depthCompare === "less-equal" ? z <= currentDepth + depthBias : z < currentDepth - depthBias;
-          if (passesDepth) {
-            if (depthWrite)
-              this.depth[di] = z;
-            const pixelIndex = di * 4;
-            const destinationAlpha = this.buffer[pixelIndex + 3] / 255;
-            const oneMinusSourceAlpha = 1 - sourceAlpha;
-            const outAlpha = sourceAlpha + destinationAlpha * oneMinusSourceAlpha;
-            const outR = outAlpha === 0 ? 0 : (r255 * sourceAlpha + this.buffer[pixelIndex + 0] * destinationAlpha * oneMinusSourceAlpha) / outAlpha;
-            const outG = outAlpha === 0 ? 0 : (g255 * sourceAlpha + this.buffer[pixelIndex + 1] * destinationAlpha * oneMinusSourceAlpha) / outAlpha;
-            const outB = outAlpha === 0 ? 0 : (b255 * sourceAlpha + this.buffer[pixelIndex + 2] * destinationAlpha * oneMinusSourceAlpha) / outAlpha;
-            this.setPixel(xi, yi, outR, outG, outB, outAlpha * 255);
-          }
+          drawFragment(xi, yi, z);
         }
         x += xinc;
         y += yinc;
@@ -21859,13 +23121,13 @@ var import_gl_matrix, import_gl_matrix2, import_gl_matrix3, import_gl_matrix4, i
     const materialId = this.denoiser?.materialId(material) ?? 0;
     const lightDir = light.dir ?? DEFAULT_LIGHT_DIR;
     const ambient = clamp(light.ambient ?? DEFAULT_RENDER_OPTIONS.ambient, 0, 1);
-    const L = studio ? null : import_gl_matrix5.vec3.normalize(import_gl_matrix5.vec3.create(), import_gl_matrix5.vec3.fromValues(lightDir[0], lightDir[1], lightDir[2]));
+    const L = studio ? null : import_gl_matrix7.vec3.normalize(import_gl_matrix7.vec3.create(), import_gl_matrix7.vec3.fromValues(lightDir[0], lightDir[1], lightDir[2]));
     const view = camera.view;
     const proj = camera.proj;
-    const mvp = import_gl_matrix5.mat4.create();
-    import_gl_matrix5.mat4.multiply(mvp, proj, import_gl_matrix5.mat4.multiply(import_gl_matrix5.mat4.create(), view, model));
-    const normalMat = import_gl_matrix5.mat3.create();
-    import_gl_matrix5.mat3.normalFromMat4(normalMat, model);
+    const mvp = import_gl_matrix7.mat4.create();
+    import_gl_matrix7.mat4.multiply(mvp, proj, import_gl_matrix7.mat4.multiply(import_gl_matrix7.mat4.create(), view, model));
+    const normalMat = import_gl_matrix7.mat3.create();
+    import_gl_matrix7.mat3.normalFromMat4(normalMat, model);
     let vertexCount = positions.length / 3 | 0;
     let idx = indices ?? (() => {
       const a = new Uint32Array(vertexCount);
@@ -21892,11 +23154,11 @@ var import_gl_matrix, import_gl_matrix2, import_gl_matrix3, import_gl_matrix4, i
     const vWorldP = studio && !depthOnly ? new Array(vertexCount) : null;
     const vColor = new Array(depthOnly ? 0 : vertexCount);
     for (let i = 0;i < vertexCount; i++) {
-      const p = import_gl_matrix5.vec4.fromValues(positions[i * 3 + 0], positions[i * 3 + 1], positions[i * 3 + 2], 1);
-      const c = import_gl_matrix5.vec4.create();
-      import_gl_matrix5.vec4.transformMat4(c, p, mvp);
+      const p = import_gl_matrix7.vec4.fromValues(positions[i * 3 + 0], positions[i * 3 + 1], positions[i * 3 + 2], 1);
+      const c = import_gl_matrix7.vec4.create();
+      import_gl_matrix7.vec4.transformMat4(c, p, mvp);
       if (vWorldP) {
-        const world = import_gl_matrix5.vec4.transformMat4(import_gl_matrix5.vec4.create(), p, model);
+        const world = import_gl_matrix7.vec4.transformMat4(import_gl_matrix7.vec4.create(), p, model);
         vWorldP[i] = [world[0], world[1], world[2]];
       }
       const invW = 1 / c[3];
@@ -21910,9 +23172,9 @@ var import_gl_matrix, import_gl_matrix2, import_gl_matrix3, import_gl_matrix4, i
       vNDCz[i] = ndcZ;
       if (depthOnly)
         continue;
-      const n = import_gl_matrix5.vec3.fromValues(useNormals[i * 3 + 0], useNormals[i * 3 + 1], useNormals[i * 3 + 2]);
-      const nw = import_gl_matrix5.vec3.create();
-      import_gl_matrix5.vec3.transformMat3(nw, n, normalMat);
+      const n = import_gl_matrix7.vec3.fromValues(useNormals[i * 3 + 0], useNormals[i * 3 + 1], useNormals[i * 3 + 2]);
+      const nw = import_gl_matrix7.vec3.create();
+      import_gl_matrix7.vec3.transformMat3(nw, n, normalMat);
       vWorldN[i] = [nw[0], nw[1], nw[2]];
       if (colors && colors.length >= (i + 1) * 3) {
         vColor[i] = [colors[i * 3 + 0], colors[i * 3 + 1], colors[i * 3 + 2]];
@@ -21999,7 +23261,7 @@ var import_gl_matrix, import_gl_matrix2, import_gl_matrix3, import_gl_matrix4, i
           ];
           if (uv && material.baseColorTexture) {
             const uvp = this.perspInterp(uv, invW, [l0, l1, l2]);
-            const texel = this.sampleTextureNearest(material.baseColorTexture, uvp[0], uvp[1]);
+            const texel = this.sampleTextureNearest(material.baseColorTexture, material.baseColorTextureWrap === "repeat" ? uvp[0] - Math.floor(uvp[0]) : uvp[0], material.baseColorTextureWrap === "repeat" ? uvp[1] - Math.floor(uvp[1]) : uvp[1]);
             baseColor = mulColor(baseColor, [
               srgbDecodeToLinear01(texel[0]),
               srgbDecodeToLinear01(texel[1]),
@@ -22124,7 +23386,7 @@ var import_gl_matrix, import_gl_matrix2, import_gl_matrix3, import_gl_matrix4, i
       const count = dc.indices?.length ?? dc.positions.length / 3;
       const worldVertices = [];
       for (let i = 0;i < dc.positions.length; i += 3) {
-        const p = import_gl_matrix8.vec3.transformMat4(import_gl_matrix8.vec3.create(), [dc.positions[i], dc.positions[i + 1], dc.positions[i + 2]], dc.model);
+        const p = import_gl_matrix10.vec3.transformMat4(import_gl_matrix10.vec3.create(), [dc.positions[i], dc.positions[i + 1], dc.positions[i + 2]], dc.model);
         worldVertices.push([p[0], p[1], p[2]]);
       }
       const vertex = (index) => worldVertices[dc.indices?.[index] ?? index];
@@ -22446,7 +23708,7 @@ var import_gl_matrix, import_gl_matrix2, import_gl_matrix3, import_gl_matrix4, i
   }
   constructor(drawCalls, camera) {
     this.occlusion = new RayOcclusion(drawCalls);
-    const world = import_gl_matrix7.mat4.invert(import_gl_matrix7.mat4.create(), camera.view);
+    const world = import_gl_matrix9.mat4.invert(import_gl_matrix9.mat4.create(), camera.view);
     if (!world)
       throw new Error("Realistic rendering requires an invertible camera view.");
     this.eye = [world[12], world[13], world[14]];
@@ -22454,7 +23716,7 @@ var import_gl_matrix, import_gl_matrix2, import_gl_matrix3, import_gl_matrix4, i
       const [t, b] = basis(l.direction);
       return Array.from({ length: SHADOW_SAMPLES }, (_, i) => {
         const u = (i + 0.5) / SHADOW_SAMPLES, cos = 1 + Math.log(1 - u) / l.sharpness, sin = Math.sqrt(Math.max(0, 1 - cos * cos)), phi = 2 * Math.PI * radicalInverse(i);
-        const direction = orient(sin * Math.cos(phi), sin * Math.sin(phi), cos, l.direction, t, b);
+        const direction = orient2(sin * Math.cos(phi), sin * Math.sin(phi), cos, l.direction, t, b);
         const parallel = dot(direction, l.direction);
         return {
           parallel: l.direction.map((v) => v * parallel),
@@ -22577,7 +23839,7 @@ var import_gl_matrix, import_gl_matrix2, import_gl_matrix3, import_gl_matrix4, i
     const [t, b] = basis(n);
     let blocked = 0;
     for (let i = 0;metal < 1 && i < DIFFUSE_SAMPLES; i++) {
-      const phi = i * 2 * Math.PI / DIFFUSE_SAMPLES + phase, l = orient(0.7 * Math.cos(phi), 0.7 * Math.sin(phi), Math.sqrt(0.51), n, t, b);
+      const phi = i * 2 * Math.PI / DIFFUSE_SAMPLES + phase, l = orient2(0.7 * Math.cos(phi), 0.7 * Math.sin(phi), Math.sqrt(0.51), n, t, b);
       const hit = this.occlusion.trace(origin, l);
       if (hit) {
         blocked++;
@@ -22600,7 +23862,7 @@ var import_gl_matrix, import_gl_matrix2, import_gl_matrix3, import_gl_matrix4, i
       this.reflectionSamples.set(rough, samples);
     }
     for (const [sx, sy, nh] of samples) {
-      const h = orient(sx * cosPhase - sy * sinPhase, sx * sinPhase + sy * cosPhase, nh, reflected, rt, rb);
+      const h = orient2(sx * cosPhase - sy * sinPhase, sx * sinPhase + sy * cosPhase, nh, reflected, rt, rb);
       const l = [
         2 * nh * h[0] - reflected[0],
         2 * nh * h[1] - reflected[1],
@@ -22624,6 +23886,7 @@ var import_gl_matrix, import_gl_matrix2, import_gl_matrix3, import_gl_matrix4, i
   }
 }, COMPONENT_INFO, NUM_COMPONENTS, MAGIC = 1179937895, JSON_CHUNK_TYPE = 1313821514, BIN_CHUNK_TYPE = 5130562;
 var init_dist = __esm(() => {
+  init_earcut();
   init_lib();
   init_lib();
   import_gl_matrix = __toESM(require_cjs(), 1);
@@ -22636,8 +23899,16 @@ var init_dist = __esm(() => {
   import_gl_matrix8 = __toESM(require_cjs(), 1);
   import_gl_matrix9 = __toESM(require_cjs(), 1);
   import_gl_matrix10 = __toESM(require_cjs(), 1);
+  import_gl_matrix11 = __toESM(require_cjs(), 1);
+  import_gl_matrix12 = __toESM(require_cjs(), 1);
+  import_gl_matrix13 = __toESM(require_cjs(), 1);
+  import_gl_matrix14 = __toESM(require_cjs(), 1);
   DEFAULT_LIGHT_DIR = [-0.4, -0.9, -0.2];
   DEFAULT_RENDER_OPTIONS = {
+    renderStyle: "shaded",
+    section: null,
+    projection: "perspective",
+    orthographicHeight: null,
     realistic: false,
     width: 800,
     height: 600,
@@ -22656,7 +23927,13 @@ var init_dist = __esm(() => {
     debugPoints: null,
     debugFontSize: null,
     debugPointColor: null,
-    debugLabelColor: null
+    debugLabelColor: null,
+    explosionLines: null,
+    showEdges: false,
+    showHiddenEdges: null,
+    edgeWidth: 1,
+    lineWidth: 1,
+    hiddenEdgeOpacity: 0.35
   };
   DEFAULT_MARKER_COLOR = [
     255,
@@ -31961,6 +33238,8 @@ var projectConfigSchema = z.object({
     kicadLibrary: z.boolean().optional(),
     kicadPcm: z.boolean().optional(),
     previewImages: z.boolean().optional(),
+    drawings: z.boolean().optional(),
+    drawing: z.string().optional(),
     glbs: z.boolean().optional(),
     step: z.boolean().optional(),
     workerTimeoutMs: z.number().int().positive().optional(),