lineadraw 0.10.0 → 0.11.0

package/dist/{chunk-YYJAXJOY.js → chunk-7UFXC7OI.js}

@@ -2,6 +2,811 @@ import {
   __export
 } from "./chunk-PZ5AY32C.js";
 
+// ../core/src/geometry/vec2.ts
+var add = (a2, b) => ({ x: a2.x + b.x, y: a2.y + b.y });
+var sub = (a2, b) => ({ x: a2.x - b.x, y: a2.y - b.y });
+var scale = (a2, s) => ({ x: a2.x * s, y: a2.y * s });
+var dot = (a2, b) => a2.x * b.x + a2.y * b.y;
+var lenSq = (a2) => a2.x * a2.x + a2.y * a2.y;
+var len = (a2) => Math.hypot(a2.x, a2.y);
+var dist = (a2, b) => Math.hypot(b.x - a2.x, b.y - a2.y);
+var norm = (a2) => {
+  const l = len(a2);
+  return l === 0 ? a2 : { x: a2.x / l, y: a2.y / l };
+};
+var lerp = (a2, b, t) => ({
+  x: a2.x + (b.x - a2.x) * t,
+  y: a2.y + (b.y - a2.y) * t
+});
+var mid = (a2, b) => lerp(a2, b, 0.5);
+var angle = (a2) => Math.atan2(a2.y, a2.x);
+var rot = (a2, angle2) => {
+  const c2 = Math.cos(angle2);
+  const s = Math.sin(angle2);
+  return { x: a2.x * c2 - a2.y * s, y: a2.x * s + a2.y * c2 };
+};
+var rotAround = (p2, center, angle2) => add(center, rot(sub(p2, center), angle2));
+var perp = (a2) => ({ x: -a2.y, y: a2.x });
+var fromAngle = (angle2) => ({
+  x: Math.cos(angle2),
+  y: Math.sin(angle2)
+});
+var normAngle = (angle2) => {
+  const t = angle2 % (Math.PI * 2);
+  return t < 0 ? t + Math.PI * 2 : t;
+};
+
+// ../core/src/paint/painters/arrows.ts
+var arrowLineStart = (tip, toward, size, type = "filled") => type === "filled" ? add(tip, scale(norm(sub(toward, tip)), Math.min(size, dist(tip, toward)))) : tip;
+var paintArrowhead = (sink, tip, toward, size, color, type = "filled", opacity) => {
+  if (type === "none") return;
+  const dir = norm(sub(toward, tip));
+  if (dir.x === 0 && dir.y === 0) return;
+  switch (type) {
+    case "filled": {
+      const base = add(tip, scale(dir, size));
+      const half = scale(perp(dir), size / 3);
+      sink.beginPath();
+      sink.moveTo(tip);
+      sink.lineTo(add(base, half));
+      sink.lineTo(sub(base, half));
+      sink.closePath();
+      sink.fill({ color, opacity });
+      break;
+    }
+    case "open": {
+      const base = add(tip, scale(dir, size));
+      const half = scale(perp(dir), size / 3);
+      sink.beginPath();
+      sink.moveTo(add(base, half));
+      sink.lineTo(tip);
+      sink.lineTo(sub(base, half));
+      sink.stroke({ color, widthMm: Math.min(size / 10, 0.25), opacity });
+      break;
+    }
+    case "tick": {
+      const diag = scale(norm(add(dir, perp(dir))), size / 2);
+      sink.beginPath();
+      sink.moveTo(sub(tip, diag));
+      sink.lineTo(add(tip, diag));
+      sink.stroke({ color, widthMm: Math.min(size / 8, 0.35), opacity });
+      break;
+    }
+    case "dot": {
+      sink.beginPath();
+      sink.arc(tip, size / 4, 0, Math.PI * 2, true);
+      sink.fill({ color, opacity });
+      break;
+    }
+  }
+};
+
+// ../core/src/geometry/nurbs.ts
+var nurbsDomain = (c2) => {
+  const n = c2.controlPoints.length;
+  return [c2.knots[c2.degree], c2.knots[n]];
+};
+var findSpan = (c2, u5) => {
+  const n = c2.controlPoints.length;
+  const p2 = c2.degree;
+  if (u5 >= c2.knots[n]) return n - 1;
+  if (u5 <= c2.knots[p2]) return p2;
+  let lo = p2;
+  let hi = n;
+  let mid2 = lo + hi >> 1;
+  while (u5 < c2.knots[mid2] || u5 >= c2.knots[mid2 + 1]) {
+    if (u5 < c2.knots[mid2]) hi = mid2;
+    else lo = mid2;
+    mid2 = lo + hi >> 1;
+  }
+  return mid2;
+};
+var evaluateNurbs = (c2, u5) => {
+  const p2 = c2.degree;
+  const k2 = findSpan(c2, u5);
+  const d2 = [];
+  for (let j = 0; j <= p2; j++) {
+    const i = k2 - p2 + j;
+    const cp = c2.controlPoints[i];
+    const w3 = c2.weights?.[i] ?? 1;
+    d2.push([cp.x * w3, cp.y * w3, w3]);
+  }
+  for (let r = 1; r <= p2; r++)
+    for (let j = p2; j >= r; j--) {
+      const i = k2 - p2 + j;
+      const den = c2.knots[i + p2 - r + 1] - c2.knots[i];
+      const a2 = den === 0 ? 0 : (u5 - c2.knots[i]) / den;
+      d2[j] = [
+        (1 - a2) * d2[j - 1][0] + a2 * d2[j][0],
+        (1 - a2) * d2[j - 1][1] + a2 * d2[j][1],
+        (1 - a2) * d2[j - 1][2] + a2 * d2[j][2]
+      ];
+    }
+  const [x2, y2, w2] = d2[p2];
+  return w2 === 0 ? { x: x2, y: y2 } : { x: x2 / w2, y: y2 / w2 };
+};
+var isValidNurbs = (c2) => c2.degree >= 1 && c2.controlPoints.length > c2.degree && c2.knots.length === c2.controlPoints.length + c2.degree + 1 && (c2.weights === void 0 || c2.weights.length === c2.controlPoints.length) && c2.knots.every((v2, i) => i === 0 || v2 >= c2.knots[i - 1]);
+var sampleNurbs = (c2, tolerance, maxDepth = 10) => {
+  const [u0, u1] = nurbsDomain(c2);
+  const out = [evaluateNurbs(c2, u0)];
+  const push = (q) => {
+    const last = out[out.length - 1];
+    if (Math.hypot(q.x - last.x, q.y - last.y) > 1e-9) out.push(q);
+  };
+  const refine = (a2, pa, b, pb, depth) => {
+    const m2 = (a2 + b) / 2;
+    const pm = evaluateNurbs(c2, m2);
+    const chord = { x: (pa.x + pb.x) / 2, y: (pa.y + pb.y) / 2 };
+    const dev = Math.hypot(pm.x - chord.x, pm.y - chord.y);
+    if (depth >= maxDepth || dev <= tolerance) {
+      if (dev > tolerance / 4) push(pm);
+      push(pb);
+      return;
+    }
+    refine(a2, pa, m2, pm, depth + 1);
+    refine(m2, pm, b, pb, depth + 1);
+  };
+  const spans = [];
+  for (let i = c2.degree; i < c2.controlPoints.length; i++) {
+    const a2 = Math.max(c2.knots[i], u0);
+    const b = Math.min(c2.knots[i + 1], u1);
+    if (b > a2) spans.push(a2, b);
+  }
+  for (let i = 0; i < spans.length; i += 2) {
+    const a2 = spans[i];
+    const b = spans[i + 1];
+    const pa = evaluateNurbs(c2, a2);
+    const pb = evaluateNurbs(c2, b);
+    const m2 = (a2 + b) / 2;
+    const pm = evaluateNurbs(c2, m2);
+    refine(a2, pa, m2, pm, 1);
+    refine(m2, pm, b, pb, 1);
+  }
+  return dropCollinear(out, tolerance / 10);
+};
+var dropCollinear = (pts, eps) => {
+  if (pts.length < 3) return pts;
+  const out = [pts[0]];
+  for (let i = 1; i < pts.length - 1; i++) {
+    const a2 = out[out.length - 1];
+    const b = pts[i + 1];
+    const q = pts[i];
+    const abx = b.x - a2.x;
+    const aby = b.y - a2.y;
+    const len22 = abx * abx + aby * aby;
+    const t = len22 === 0 ? 0 : Math.max(
+      0,
+      Math.min(1, ((q.x - a2.x) * abx + (q.y - a2.y) * aby) / len22)
+    );
+    const dist3 = Math.hypot(q.x - (a2.x + t * abx), q.y - (a2.y + t * aby));
+    if (dist3 > eps) out.push(q);
+  }
+  out.push(pts[pts.length - 1]);
+  return out;
+};
+var interpolateFitPoints = (input, degree = 3, tangents) => {
+  const points = input.filter(
+    (q, i) => i === 0 || Math.hypot(q.x - input[i - 1].x, q.y - input[i - 1].y) > 1e-9
+  );
+  const n = points.length;
+  if (n < 2) return null;
+  const p2 = Math.min(degree, n - 1);
+  const u5 = [0];
+  let total = 0;
+  for (let i = 1; i < n; i++) {
+    total += Math.hypot(
+      points[i].x - points[i - 1].x,
+      points[i].y - points[i - 1].y
+    );
+    u5.push(total);
+  }
+  if (total === 0) return null;
+  for (let i = 0; i < n; i++) u5[i] /= total;
+  if (degree >= 3 && (tangents?.start || tangents?.end))
+    return throughWithTangents(points, u5, total, tangents);
+  const knots = new Array(p2 + 1).fill(0);
+  for (let j = 1; j <= n - p2 - 1; j++) {
+    let s = 0;
+    for (let i = j; i <= j + p2 - 1; i++) s += u5[i];
+    knots.push(s / p2);
+  }
+  knots.push(...new Array(p2 + 1).fill(1));
+  return solveThrough(points, u5, knots, p2);
+};
+var solveThrough = (points, params, knots, p2) => {
+  const n = points.length;
+  if (params.length !== n || knots.length !== n + p2 + 1) return null;
+  const A = params.map((ui) => basisRow(knots, p2, n, ui));
+  const controlPoints = solveLinear(A, points);
+  return controlPoints ? { degree: p2, controlPoints, knots } : null;
+};
+var basisRow = (knots, p2, m2, u5) => {
+  const row = new Array(m2).fill(0);
+  for (let j = 0; j < m2; j++)
+    row[j] = evaluateNurbs(
+      {
+        degree: p2,
+        controlPoints: Array.from({ length: m2 }, (_2, k2) => ({
+          x: k2 === j ? 1 : 0,
+          y: 0
+        })),
+        knots
+      },
+      u5
+    ).x;
+  return row;
+};
+var solveLinear = (A0, B2) => {
+  const n = B2.length;
+  const A = A0.map((r) => [...r]);
+  const bx = B2.map((q) => q.x);
+  const by = B2.map((q) => q.y);
+  for (let col = 0; col < n; col++) {
+    let pivot = col;
+    for (let r = col + 1; r < n; r++)
+      if (Math.abs(A[r][col]) > Math.abs(A[pivot][col])) pivot = r;
+    if (Math.abs(A[pivot][col]) < 1e-12) return null;
+    [A[col], A[pivot]] = [A[pivot], A[col]];
+    [bx[col], bx[pivot]] = [bx[pivot], bx[col]];
+    [by[col], by[pivot]] = [by[pivot], by[col]];
+    for (let r = 0; r < n; r++) {
+      if (r === col) continue;
+      const k2 = A[r][col] / A[col][col];
+      if (k2 === 0) continue;
+      for (let c2 = col; c2 < n; c2++) A[r][c2] -= k2 * A[col][c2];
+      bx[r] -= k2 * bx[col];
+      by[r] -= k2 * by[col];
+    }
+  }
+  return bx.map((x2, i) => ({ x: x2 / A[i][i], y: by[i] / A[i][i] }));
+};
+var unit = (v2) => {
+  const l = Math.hypot(v2.x, v2.y);
+  return l === 0 ? { x: 1, y: 0 } : { x: v2.x / l, y: v2.y / l };
+};
+var throughWithTangents = (points, u5, total, tangents) => {
+  const n = points.length;
+  const p2 = 3;
+  const m2 = n + 2;
+  const knots = [0, 0, 0, 0, ...u5.slice(1, n - 1), 1, 1, 1, 1];
+  const free = interpolateFitPoints(points);
+  const dir = (given, at) => unit(
+    given ?? (free ? nurbsTangent(free, at) : { x: points[1].x - points[0].x, y: points[1].y - points[0].y })
+  );
+  const d0 = dir(tangents.start, 0);
+  const d1 = dir(tangents.end, 1);
+  const derivRow = (a2, b, k2) => {
+    const r = new Array(m2).fill(0);
+    r[a2] = -k2;
+    r[b] = k2;
+    return r;
+  };
+  const rows = [
+    basisRow(knots, p2, m2, 0),
+    derivRow(0, 1, p2 / knots[p2 + 1])
+  ];
+  const rhs = [points[0], { x: d0.x * total, y: d0.y * total }];
+  for (let i = 1; i < n - 1; i++) {
+    rows.push(basisRow(knots, p2, m2, u5[i]));
+    rhs.push(points[i]);
+  }
+  rows.push(
+    derivRow(m2 - 2, m2 - 1, p2 / (1 - knots[m2 - 1])),
+    basisRow(knots, p2, m2, 1)
+  );
+  rhs.push({ x: d1.x * total, y: d1.y * total }, points[n - 1]);
+  const controlPoints = solveLinear(rows, rhs);
+  return controlPoints ? { degree: p2, controlPoints, knots } : null;
+};
+var interpolateClosed = (input, degree = 3) => {
+  const near = (a2, b) => Math.hypot(a2.x - b.x, a2.y - b.y) <= 1e-9;
+  let points = input.filter((q, i) => i === 0 || !near(q, input[i - 1]));
+  if (points.length > 1 && near(points[0], points[points.length - 1]))
+    points = points.slice(0, -1);
+  const n = points.length;
+  if (n < 3) return null;
+  const p2 = Math.min(degree, n - 1);
+  const u5 = [0];
+  let total = 0;
+  for (let i = 1; i <= n; i++) {
+    total += Math.hypot(
+      points[i % n].x - points[i - 1].x,
+      points[i % n].y - points[i - 1].y
+    );
+    u5.push(total);
+  }
+  for (let i = 0; i <= n; i++) u5[i] /= total;
+  const knots = periodicKnots(u5, p2);
+  const m2 = n + p2;
+  const A = u5.slice(0, n).map((ui) => {
+    const full = basisRow(knots, p2, m2, ui);
+    const row = new Array(n).fill(0);
+    full.forEach((v2, j) => row[j % n] += v2);
+    return row;
+  });
+  const P = solveLinear(A, points);
+  if (!P) return null;
+  return { degree: p2, controlPoints: [...P, ...P.slice(0, p2)], knots };
+};
+var periodicKnots = (u5, p2) => {
+  const n = u5.length - 1;
+  const period = u5[n] - u5[0];
+  const t = new Array(n + 2 * p2 + 1);
+  for (let k2 = 0; k2 <= n; k2++) t[p2 + k2] = u5[k2];
+  for (let i = p2 - 1; i >= 0; i--) t[i] = t[i + n] - period;
+  for (let i = n + p2 + 1; i < t.length; i++) t[i] = t[i - n] + period;
+  return t;
+};
+var insertKnot = (c2, u5) => {
+  const p2 = c2.degree;
+  const n = c2.controlPoints.length;
+  let k2 = p2;
+  while (k2 < n - 1 && c2.knots[k2 + 1] <= u5) k2++;
+  const w2 = (i) => c2.weights?.[i] ?? 1;
+  const cps = [];
+  const ws = [];
+  for (let i = 0; i <= n; i++) {
+    if (i <= k2 - p2) {
+      cps.push(c2.controlPoints[i]);
+      ws.push(w2(i));
+    } else if (i > k2) {
+      cps.push(c2.controlPoints[i - 1]);
+      ws.push(w2(i - 1));
+    } else {
+      const den = c2.knots[i + p2] - c2.knots[i];
+      const a2 = den === 0 ? 0 : (u5 - c2.knots[i]) / den;
+      const w0 = w2(i - 1);
+      const w1 = w2(i);
+      const wn = (1 - a2) * w0 + a2 * w1;
+      const P0 = c2.controlPoints[i - 1];
+      const P1 = c2.controlPoints[i];
+      cps.push({
+        x: ((1 - a2) * P0.x * w0 + a2 * P1.x * w1) / wn,
+        y: ((1 - a2) * P0.y * w0 + a2 * P1.y * w1) / wn
+      });
+      ws.push(wn);
+    }
+  }
+  const knots = [...c2.knots.slice(0, k2 + 1), u5, ...c2.knots.slice(k2 + 1)];
+  return {
+    degree: p2,
+    controlPoints: cps,
+    knots,
+    ...c2.weights ? { weights: ws } : {}
+  };
+};
+var nurbsClamped = (c2) => {
+  const p2 = c2.degree;
+  const k2 = c2.knots;
+  for (let i = 1; i <= p2; i++)
+    if (k2[i] !== k2[0] || k2[k2.length - 1 - i] !== k2[k2.length - 1]) return false;
+  return true;
+};
+var nurbsToBeziers = (c0) => {
+  const p2 = c0.degree;
+  if (p2 < 1 || p2 > 3 || !isValidNurbs(c0)) return null;
+  const c2 = nurbsClamped(c0) ? c0 : nurbsSegment(c0, ...nurbsDomain(c0));
+  if (c2.weights?.some((w2) => w2 !== c2.weights[0])) return null;
+  let cur = { ...c2, weights: void 0 };
+  const [u0, u1] = nurbsDomain(c2);
+  const interior = [...new Set(c2.knots)].filter((v2) => v2 > u0 && v2 < u1);
+  for (const v2 of interior) {
+    let m2 = cur.knots.filter((k2) => k2 === v2).length;
+    if (m2 > p2) return null;
+    while (m2 < p2) {
+      cur = insertKnot(cur, v2);
+      m2++;
+    }
+  }
+  const P = cur.controlPoints;
+  const lerp2 = (a2, b, t) => ({
+    x: a2.x + (b.x - a2.x) * t,
+    y: a2.y + (b.y - a2.y) * t
+  });
+  const out = [];
+  for (let i = 0; i + p2 < P.length; i += p2) {
+    const q = P.slice(i, i + p2 + 1);
+    if (p2 === 3) out.push({ start: q[0], c1: q[1], c2: q[2], end: q[3] });
+    else if (p2 === 2)
+      out.push({
+        start: q[0],
+        c1: lerp2(q[0], q[1], 2 / 3),
+        c2: lerp2(q[2], q[1], 2 / 3),
+        end: q[2]
+      });
+    else
+      out.push({
+        start: q[0],
+        c1: lerp2(q[0], q[1], 1 / 3),
+        c2: lerp2(q[0], q[1], 2 / 3),
+        end: q[1]
+      });
+  }
+  return out;
+};
+var nurbsBounds = (c2) => {
+  let minX = Infinity;
+  let minY = Infinity;
+  let maxX = -Infinity;
+  let maxY = -Infinity;
+  for (const q of c2.controlPoints) {
+    minX = Math.min(minX, q.x);
+    minY = Math.min(minY, q.y);
+    maxX = Math.max(maxX, q.x);
+    maxY = Math.max(maxY, q.y);
+  }
+  return { minX, minY, maxX, maxY };
+};
+var curveTolerance = (c2) => {
+  const b = nurbsBounds(c2);
+  return Math.max(1e-3, Math.hypot(b.maxX - b.minX, b.maxY - b.minY) / 2e3);
+};
+var multiplicity = (c2, u5) => c2.knots.filter((k2) => k2 === u5).length;
+var raiseKnot = (c2, u5, m2) => {
+  let cur = c2;
+  for (let k2 = multiplicity(cur, u5); k2 < Math.min(m2, c2.degree + 1); k2++)
+    cur = insertKnot(cur, u5);
+  return cur;
+};
+var nurbsSegment = (c2, a2, b) => {
+  const p2 = c2.degree;
+  const cur = raiseKnot(raiseKnot(c2, a2, p2), b, p2);
+  const k2 = cur.knots;
+  const sA = k2.indexOf(a2);
+  const j0 = sA + multiplicity(cur, a2) - p2 - 1;
+  const j1 = k2.indexOf(b) - 1;
+  const inner = k2.filter((v2) => v2 > a2 && v2 < b);
+  return {
+    degree: p2,
+    controlPoints: cur.controlPoints.slice(j0, j1 + 1),
+    knots: [...new Array(p2 + 1).fill(a2), ...inner, ...new Array(p2 + 1).fill(b)],
+    ...cur.weights ? { weights: cur.weights.slice(j0, j1 + 1) } : {}
+  };
+};
+var nurbsTangent = (c2, u5) => {
+  const [u0, u1] = nurbsDomain(c2);
+  const h = (u1 - u0) * 1e-6;
+  const a2 = evaluateNurbs(c2, Math.max(u0, u5 - h));
+  const b = evaluateNurbs(c2, Math.min(u1, u5 + h));
+  const l = Math.hypot(b.x - a2.x, b.y - a2.y);
+  return l === 0 ? { x: 1, y: 0 } : { x: (b.x - a2.x) / l, y: (b.y - a2.y) / l };
+};
+
+// ../core/src/geometry/arcs.ts
+var arcSweep = (a2) => {
+  const s = normAngle(a2.endAngle - a2.startAngle);
+  return s === 0 ? Math.PI * 2 : s;
+};
+var pointOnArc = (a2, angle2) => ({
+  x: a2.center.x + Math.cos(angle2) * a2.radius,
+  y: a2.center.y + Math.sin(angle2) * a2.radius
+});
+var arcStartPoint = (a2) => pointOnArc(a2, a2.startAngle);
+var arcEndPoint = (a2) => pointOnArc(a2, a2.endAngle);
+var arcMidPoint = (a2) => pointOnArc(a2, a2.startAngle + arcSweep(a2) / 2);
+var angleInArc = (a2, angle2) => normAngle(angle2 - a2.startAngle) <= arcSweep(a2) + 1e-12;
+var bulgeToArc = (a2, b, bulge) => {
+  if (Math.abs(bulge) < 1e-12) return null;
+  const chord = dist(a2, b);
+  if (chord < 1e-12) return null;
+  const sweep = 4 * Math.atan(bulge);
+  const radius = Math.abs(chord / (2 * Math.sin(sweep / 2)));
+  const m2 = mid(a2, b);
+  const dir = scale(sub(b, a2), 1 / chord);
+  const h = chord / 2 / Math.tan(sweep / 2);
+  const center = add(m2, scale(perp(dir), h));
+  const angA = angle(sub(a2, center));
+  const angB = angle(sub(b, center));
+  return bulge > 0 ? { center, radius, startAngle: angA, endAngle: angB } : { center, radius, startAngle: angB, endAngle: angA };
+};
+var bulgeFrom3Points = (a2, m2, b) => {
+  let turn = angle(sub(b, m2)) - angle(sub(m2, a2));
+  while (turn > Math.PI) turn -= 2 * Math.PI;
+  while (turn < -Math.PI) turn += 2 * Math.PI;
+  return Math.tan(turn / 2);
+};
+var circleFrom3Points = (p1, p2, p3) => {
+  const ax = p1.x;
+  const ay = p1.y;
+  const bx = p2.x;
+  const by = p2.y;
+  const cx = p3.x;
+  const cy = p3.y;
+  const d2 = 2 * (ax * (by - cy) + bx * (cy - ay) + cx * (ay - by));
+  if (Math.abs(d2) < 1e-12) return null;
+  const a2 = ax * ax + ay * ay;
+  const b2 = bx * bx + by * by;
+  const c2 = cx * cx + cy * cy;
+  const center = {
+    x: (a2 * (by - cy) + b2 * (cy - ay) + c2 * (ay - by)) / d2,
+    y: (a2 * (cx - bx) + b2 * (ax - cx) + c2 * (bx - ax)) / d2
+  };
+  return { center, radius: dist(center, p1) };
+};
+var arcFrom3Points = (start, on, end) => {
+  const c2 = circleFrom3Points(start, on, end);
+  if (!c2) return null;
+  const angS = angle(sub(start, c2.center));
+  const angO = angle(sub(on, c2.center));
+  const angE = angle(sub(end, c2.center));
+  const ccw = {
+    center: c2.center,
+    radius: c2.radius,
+    startAngle: angS,
+    endAngle: angE
+  };
+  if (angleInArc(ccw, angO)) return ccw;
+  return {
+    center: c2.center,
+    radius: c2.radius,
+    startAngle: angE,
+    endAngle: angS
+  };
+};
+var closestPointOnArc = (a2, p2) => {
+  const v2 = sub(p2, a2.center);
+  const ang = angle(v2);
+  if (angleInArc(a2, ang)) return pointOnArc(a2, ang);
+  const s = arcStartPoint(a2);
+  const e = arcEndPoint(a2);
+  return dist(p2, s) <= dist(p2, e) ? s : e;
+};
+var distToArc = (a2, p2) => dist(p2, closestPointOnArc(a2, p2));
+var tessellateArc = (a2, chordTolerance = 0.1) => {
+  const sweep = arcSweep(a2);
+  const maxStep = a2.radius <= chordTolerance ? sweep : 2 * Math.acos(Math.max(-1, 1 - chordTolerance / a2.radius));
+  const n = Math.max(2, Math.ceil(sweep / Math.max(maxStep, 1e-3)));
+  const pts = [];
+  for (let i = 0; i <= n; i++) {
+    pts.push(pointOnArc(a2, a2.startAngle + sweep * i / n));
+  }
+  return pts;
+};
+
+// ../core/src/geometry/hatchLoop.ts
+var TAU = Math.PI * 2;
+var sweepOf = (start, end) => {
+  const s = ((end - start) % TAU + TAU) % TAU;
+  return s < 1e-12 ? TAU : s;
+};
+var ellipsePoint = (e, t) => {
+  const minor = { x: -e.majorAxis.y * e.ratio, y: e.majorAxis.x * e.ratio };
+  return {
+    x: e.center.x + e.majorAxis.x * Math.cos(t) + minor.x * Math.sin(t),
+    y: e.center.y + e.majorAxis.y * Math.cos(t) + minor.y * Math.sin(t)
+  };
+};
+var stepsFor = (r, sweep, tolerance) => {
+  if (r <= tolerance) return Math.max(2, Math.ceil(sweep / (Math.PI / 4)));
+  const step = 2 * Math.acos(Math.max(-1, 1 - tolerance / r));
+  return Math.max(2, Math.ceil(sweep / Math.max(step, 1e-3)));
+};
+var edgePoints = (edge, tolerance = 0.1) => {
+  switch (edge.kind) {
+    case "line":
+      return [edge.a, edge.b];
+    case "arc": {
+      const sweep = sweepOf(edge.startAngle, edge.endAngle);
+      const n = stepsFor(edge.radius, sweep, tolerance);
+      return Array.from({ length: n + 1 }, (_2, i) => {
+        const t = edge.startAngle + sweep * i / n;
+        return {
+          x: edge.center.x + edge.radius * Math.cos(t),
+          y: edge.center.y + edge.radius * Math.sin(t)
+        };
+      });
+    }
+    case "ellipse": {
+      const sweep = sweepOf(edge.startAngle, edge.endAngle);
+      const r = Math.hypot(edge.majorAxis.x, edge.majorAxis.y);
+      const n = stepsFor(r, sweep, tolerance);
+      return Array.from(
+        { length: n + 1 },
+        (_2, i) => ellipsePoint(edge, edge.startAngle + sweep * i / n)
+      );
+    }
+    case "spline":
+      return sampleNurbs(edge, Math.min(tolerance, curveTolerance(edge)));
+  }
+};
+var edgeEnds = (edge) => {
+  switch (edge.kind) {
+    case "line":
+      return { start: edge.a, end: edge.b };
+    case "arc": {
+      const at = (t) => ({
+        x: edge.center.x + edge.radius * Math.cos(t),
+        y: edge.center.y + edge.radius * Math.sin(t)
+      });
+      return { start: at(edge.startAngle), end: at(edge.endAngle) };
+    }
+    case "ellipse":
+      return {
+        start: ellipsePoint(edge, edge.startAngle),
+        end: ellipsePoint(edge, edge.endAngle)
+      };
+    case "spline": {
+      const [u0, u1] = nurbsDomain(edge);
+      return { start: evaluateNurbs(edge, u0), end: evaluateNurbs(edge, u1) };
+    }
+  }
+};
+var chainEdges = (loop) => {
+  const out = [];
+  const edges = loop.edges;
+  if (edges.length === 0) return out;
+  let reversed = false;
+  if (edges.length > 1) {
+    const e0 = edgeEnds(edges[0]);
+    const e1 = edgeEnds(edges[1]);
+    const toNext = (p2) => Math.min(dist(p2, e1.start), dist(p2, e1.end));
+    reversed = toNext(e0.start) < toNext(e0.end);
+  }
+  out.push({ edge: edges[0], reversed });
+  let at = reversed ? edgeEnds(edges[0]).start : edgeEnds(edges[0]).end;
+  for (let i = 1; i < edges.length; i++) {
+    const { start, end } = edgeEnds(edges[i]);
+    const rev = dist(at, end) < dist(at, start);
+    out.push({ edge: edges[i], reversed: rev });
+    at = rev ? start : end;
+  }
+  return out;
+};
+var loopPolygon = (loop, tolerance = 0.1) => {
+  const ring = [];
+  for (const { edge, reversed } of chainEdges(loop)) {
+    const pts = edgePoints(edge, tolerance);
+    if (reversed) pts.reverse();
+    ring.push(...pts.slice(0, -1));
+  }
+  return ring;
+};
+var emitLoopPath = (sink, loop) => {
+  const chain = chainEdges(loop);
+  if (chain.length === 0) return;
+  const first = edgeEnds(chain[0].edge);
+  sink.moveTo(chain[0].reversed ? first.end : first.start);
+  for (const { edge, reversed } of chain) {
+    if (edge.kind === "line") {
+      sink.lineTo(reversed ? edge.a : edge.b);
+      continue;
+    }
+    if (edge.kind === "arc") {
+      const sweep = sweepOf(edge.startAngle, edge.endAngle);
+      if (reversed)
+        sink.arc(
+          edge.center,
+          edge.radius,
+          edge.startAngle + sweep,
+          edge.startAngle,
+          false
+        );
+      else
+        sink.arc(
+          edge.center,
+          edge.radius,
+          edge.startAngle,
+          edge.startAngle + sweep,
+          true
+        );
+      continue;
+    }
+    if (edge.kind === "spline") {
+      const pieces = nurbsToBeziers(edge);
+      if (pieces) {
+        if (reversed)
+          for (let i = pieces.length - 1; i >= 0; i--)
+            sink.bezierTo(pieces[i].c2, pieces[i].c1, pieces[i].start);
+        else for (const p2 of pieces) sink.bezierTo(p2.c1, p2.c2, p2.end);
+        continue;
+      }
+    }
+    const pts = edgePoints(edge, curveToleranceOf(edge));
+    if (reversed) pts.reverse();
+    for (const p2 of pts.slice(1)) sink.lineTo(p2);
+  }
+  sink.closePath();
+};
+var curveToleranceOf = (edge) => {
+  if (edge.kind === "spline") return curveTolerance(edge);
+  if (edge.kind === "ellipse")
+    return Math.max(
+      1e-3,
+      Math.hypot(edge.majorAxis.x, edge.majorAxis.y) / 2e3
+    );
+  return 0.05;
+};
+var loopCurves = (loop) => {
+  const segments = [];
+  const arcs = [];
+  for (const edge of loop.edges) {
+    if (edge.kind === "line") segments.push({ a: edge.a, b: edge.b });
+    else if (edge.kind === "arc")
+      arcs.push({
+        center: edge.center,
+        radius: edge.radius,
+        startAngle: edge.startAngle,
+        endAngle: edge.startAngle + sweepOf(edge.startAngle, edge.endAngle) - 1e-9
+      });
+    else {
+      const pts = edgePoints(edge, 0.1);
+      for (let i = 1; i < pts.length; i++)
+        segments.push({ a: pts[i - 1], b: pts[i] });
+    }
+  }
+  return { segments, arcs };
+};
+var loopCorners = (loop) => chainEdges(loop).map(({ edge, reversed }) => {
+  const e = edgeEnds(edge);
+  return reversed ? e.end : e.start;
+});
+var ringArea = (ring) => {
+  let s = 0;
+  for (let i = 0; i < ring.length; i++) {
+    const p2 = ring[i];
+    const q = ring[(i + 1) % ring.length];
+    s += p2.x * q.y - q.x * p2.y;
+  }
+  return Math.abs(s) / 2;
+};
+var hatchArea = (loops) => {
+  const areas = loops.map((l) => ringArea(loopPolygon(l, 0.01)));
+  if (areas.length === 0) return 0;
+  const holes = areas.slice(1).reduce((a2, b) => a2 + b, 0);
+  return Math.max(areas[0] - holes, 0);
+};
+var verticesToLoop = (vertices) => {
+  const edges = [];
+  const n = vertices.length;
+  for (let i = 0; i < n; i++) {
+    const va = vertices[i];
+    const vb = vertices[(i + 1) % n];
+    const a2 = { x: va.x, y: va.y };
+    const b = { x: vb.x, y: vb.y };
+    if (dist(a2, b) < 1e-9) continue;
+    const arc = bulgeToArc(a2, b, va.bulge);
+    if (!arc) {
+      edges.push({ kind: "line", a: a2, b });
+      continue;
+    }
+    edges.push({
+      kind: "arc",
+      center: arc.center,
+      radius: arc.radius,
+      // CCW: a → b for a positive bulge, b → a for a negative one.
+      startAngle: va.bulge > 0 ? angle(sub(a2, arc.center)) : angle(sub(b, arc.center)),
+      endAngle: va.bulge > 0 ? angle(sub(b, arc.center)) : angle(sub(a2, arc.center))
+    });
+  }
+  return { edges };
+};
+var loopToVertices = (loop) => {
+  if (loop.edges.some((e) => e.kind === "ellipse" || e.kind === "spline"))
+    return null;
+  const out = [];
+  for (const { edge, reversed } of chainEdges(loop)) {
+    if (edge.kind === "line") {
+      const s = reversed ? edge.b : edge.a;
+      out.push({ x: s.x, y: s.y, bulge: 0 });
+      continue;
+    }
+    if (edge.kind !== "arc") return null;
+    const sweep = sweepOf(edge.startAngle, edge.endAngle);
+    const pieces = sweep > Math.PI + 1e-9 ? 2 : 1;
+    const step = sweep / pieces;
+    const bulge = Math.tan(step / 4) * (reversed ? -1 : 1);
+    for (let k2 = 0; k2 < pieces; k2++) {
+      const t = reversed ? edge.startAngle + sweep - step * k2 : edge.startAngle + step * k2;
+      out.push({
+        x: edge.center.x + edge.radius * Math.cos(t),
+        y: edge.center.y + edge.radius * Math.sin(t),
+        bulge
+      });
+    }
+  }
+  return out;
+};
+
 // ../core/src/model/hatchPatterns.ts
 import { z as z2 } from "zod";
 
@@ -41,9 +846,9 @@ var matApply = (m2, p2) => ({
   y: m2[1] * p2.x + m2[3] * p2.y + m2[5]
 });
 var signedArcSweep = (startAngle, endAngle, ccw) => {
-  const TAU = Math.PI * 2;
-  let sweep = ccw ? ((endAngle - startAngle) % TAU + TAU) % TAU : -(((startAngle - endAngle) % TAU + TAU) % TAU);
-  if (sweep === 0) sweep = ccw ? TAU : -TAU;
+  const TAU2 = Math.PI * 2;
+  let sweep = ccw ? ((endAngle - startAngle) % TAU2 + TAU2) % TAU2 : -(((startAngle - endAngle) % TAU2 + TAU2) % TAU2);
+  if (sweep === 0) sweep = ccw ? TAU2 : -TAU2;
   return sweep;
 };
 var arcToBeziers = (center, r, startAngle, sweep) => {
@@ -727,7 +1532,6 @@ import {
   LWPolylineFlags,
   TextHorizontalAlignment,
   TextVerticalAlignment,
-  HatchBoundaryPaths,
   HatchPolylineBoundary,
   HatchPredefinedPatterns,
   pattern
@@ -954,12 +1758,7 @@ var StoredInputsSchema = z3.union([
   z3.array(ValueSchema),
   z3.record(
     z3.string(),
-    z3.union([
-      Vec2Schema,
-      z3.string(),
-      z3.array(Vec2Schema),
-      z3.array(z3.string())
-    ])
+    z3.union([Vec2Schema, z3.string(), z3.array(Vec2Schema), z3.array(z3.string())])
   )
 ]);
 var isNamedInputs = (inputs) => !Array.isArray(inputs);
@@ -975,8 +1774,7 @@ var inputPoints = (inputs) => inputValues(inputs).filter((v2) => typeof v2 !== "
 var inputRefs = (inputs) => inputValues(inputs).filter((v2) => typeof v2 === "string");
 var mapInputValues = (inputs, fn2) => {
   let i = 0;
-  if (!isNamedInputs(inputs))
-    return inputs.map((v2) => fn2(v2, i++));
+  if (!isNamedInputs(inputs)) return inputs.map((v2) => fn2(v2, i++));
   const out = {};
   for (const [name, v2] of Object.entries(inputs))
     out[name] = Array.isArray(v2) ? v2.map((x2) => fn2(x2, i++)) : fn2(v2, i++);
@@ -1023,8 +1821,73 @@ var EllipseSchema = ObjectBaseSchema.extend({
   startAngle: z4.number().default(0),
   endAngle: z4.number().default(Math.PI * 2)
 });
+var nurbsFields = {
+  degree: z4.number().int().min(1).max(11),
+  controlPoints: z4.array(Vec2Schema).min(2),
+  knots: z4.array(z4.number()),
+  weights: z4.array(z4.number().positive()).optional()
+};
+var refineNurbs = (s, ctx) => {
+  const n = s.controlPoints.length;
+  if (n <= s.degree)
+    ctx.addIssue({
+      code: "custom",
+      path: ["controlPoints"],
+      message: `a degree-${s.degree} spline needs more than ${s.degree} control points`
+    });
+  if (s.knots.length !== n + s.degree + 1)
+    ctx.addIssue({
+      code: "custom",
+      path: ["knots"],
+      message: `expected ${n + s.degree + 1} knots (control points + degree + 1)`
+    });
+  if (s.knots.some((k2, i) => i > 0 && k2 < s.knots[i - 1]))
+    ctx.addIssue({
+      code: "custom",
+      path: ["knots"],
+      message: "knots must be non-decreasing"
+    });
+  if (s.weights && s.weights.length !== n)
+    ctx.addIssue({
+      code: "custom",
+      path: ["weights"],
+      message: "one weight per control point"
+    });
+};
+var SplineSchema = ObjectBaseSchema.extend({
+  type: z4.literal("spline"),
+  ...nurbsFields,
+  fitPoints: z4.array(Vec2Schema).min(2).optional(),
+  startTangent: Vec2Schema.optional(),
+  endTangent: Vec2Schema.optional(),
+  closed: z4.boolean().default(false)
+}).superRefine(refineNurbs);
+var HatchEdgeSchema = z4.discriminatedUnion("kind", [
+  z4.object({ kind: z4.literal("line"), a: Vec2Schema, b: Vec2Schema }),
+  z4.object({
+    kind: z4.literal("arc"),
+    center: Vec2Schema,
+    radius: z4.number().positive(),
+    startAngle: z4.number(),
+    endAngle: z4.number()
+  }),
+  z4.object({
+    kind: z4.literal("ellipse"),
+    center: Vec2Schema,
+    majorAxis: Vec2Schema,
+    ratio: z4.number().gt(0).max(1),
+    startAngle: z4.number().default(0),
+    endAngle: z4.number().default(Math.PI * 2)
+  }),
+  z4.object({
+    kind: z4.literal("spline"),
+    ...nurbsFields,
+    /** Drawn through points: those points (its grips), as on a spline. */
+    fitPoints: z4.array(Vec2Schema).min(2).optional()
+  }).superRefine(refineNurbs)
+]);
 var HatchLoopSchema = z4.object({
-  points: z4.array(PolylineVertexSchema).min(3)
+  edges: z4.array(HatchEdgeSchema).min(1)
 });
 var HatchFillSchema = z4.discriminatedUnion("kind", [
   z4.object({ kind: z4.literal("solid") }),
@@ -1409,11 +2272,7 @@ var TableShapeSchema = ObjectBaseSchema.extend({
   ),
   /** Row-major: `cells[row][column]`, exactly rows × columns. Input may
    * give a cell as a plain string (= `{ text }`). */
-  cells: z4.array(
-    z4.array(
-      z4.preprocess(cellInput, TableCellSchema)
-    )
-  ),
+  cells: z4.array(z4.array(z4.preprocess(cellInput, TableCellSchema))),
   /** Rows above the heavier header rule. */
   headerRows: z4.number().int().min(0).default(0),
   /** Text inset from the cell edges (mm). */
@@ -1530,6 +2389,7 @@ var ModelObjectSchema = z4.discriminatedUnion("type", [
   CircleSchema,
   ArcSchema,
   EllipseSchema,
+  SplineSchema,
   HatchSchema,
   TextSchema,
   DimensionSchema,
@@ -1702,11 +2562,11 @@ var normalizeName2 = (name) => name.trim().toUpperCase().replace(/[\s.-]+/g, "_"
 var asciiPreview = (dashesMm) => {
   const WIDTH = 15;
   if (!dashesMm.length) return "_".repeat(WIDTH * 0.8);
-  const unit = Math.max(1.5875, Math.max(...dashesMm.map(Math.abs)) / 5);
+  const unit2 = Math.max(1.5875, Math.max(...dashesMm.map(Math.abs)) / 5);
   let out = "";
   while (out.length < WIDTH) {
     for (const d2 of dashesMm) {
-      const n = Math.max(1, Math.min(10, Math.round(Math.abs(d2) / unit)));
+      const n = Math.max(1, Math.min(10, Math.round(Math.abs(d2) / unit2)));
       out += d2 > 0 ? "_".repeat(n) : d2 < 0 ? " ".repeat(n) : ".";
       if (out.length >= WIDTH) break;
     }
@@ -1774,40 +2634,6 @@ var resolveLineType = (name, lineTypes) => {
   return getLineType(name);
 };
 
-// ../core/src/geometry/vec2.ts
-var add = (a2, b) => ({ x: a2.x + b.x, y: a2.y + b.y });
-var sub = (a2, b) => ({ x: a2.x - b.x, y: a2.y - b.y });
-var scale = (a2, s) => ({ x: a2.x * s, y: a2.y * s });
-var dot = (a2, b) => a2.x * b.x + a2.y * b.y;
-var lenSq = (a2) => a2.x * a2.x + a2.y * a2.y;
-var len = (a2) => Math.hypot(a2.x, a2.y);
-var dist = (a2, b) => Math.hypot(b.x - a2.x, b.y - a2.y);
-var norm = (a2) => {
-  const l = len(a2);
-  return l === 0 ? a2 : { x: a2.x / l, y: a2.y / l };
-};
-var lerp = (a2, b, t) => ({
-  x: a2.x + (b.x - a2.x) * t,
-  y: a2.y + (b.y - a2.y) * t
-});
-var mid = (a2, b) => lerp(a2, b, 0.5);
-var angle = (a2) => Math.atan2(a2.y, a2.x);
-var rot = (a2, angle2) => {
-  const c2 = Math.cos(angle2);
-  const s = Math.sin(angle2);
-  return { x: a2.x * c2 - a2.y * s, y: a2.x * s + a2.y * c2 };
-};
-var rotAround = (p2, center, angle2) => add(center, rot(sub(p2, center), angle2));
-var perp = (a2) => ({ x: -a2.y, y: a2.x });
-var fromAngle = (angle2) => ({
-  x: Math.cos(angle2),
-  y: Math.sin(angle2)
-});
-var normAngle = (angle2) => {
-  const t = angle2 % (Math.PI * 2);
-  return t < 0 ? t + Math.PI * 2 : t;
-};
-
 // ../core/src/extensions/paramLists.ts
 var NUMBER = /^[+-]?(\d+([.,]\d*)?|[.,]\d+)(e[+-]?\d+)?$/i;
 var REPEAT = /^(\d+)\*(.+)$/;
@@ -2059,6 +2885,7 @@ var OBJECT_TYPE_NAMES = [
   "circle",
   "arc",
   "ellipse",
+  "spline",
   "hatch",
   "text",
   "dimension",
@@ -2193,16 +3020,21 @@ var mapObjectPoints = (obj, fn2) => {
     case "arc":
     case "ellipse":
       return { ...obj, center: fn2(obj.center) };
+    case "spline":
+      return {
+        ...obj,
+        controlPoints: obj.controlPoints.map(fn2),
+        ...obj.fitPoints ? { fitPoints: obj.fitPoints.map(fn2) } : {}
+      };
     case "hatch":
       return {
         ...obj,
         // The pattern frame moves with its region, as in AutoCAD — an
         // unanchored fill's frame is the drawing origin, which moves along
         // too (else the pattern would swim inside a moved hatch).
-        fill: obj.fill.kind === "pattern" ? { ...obj.fill, origin: fn2(obj.fill.origin ?? { x: 0, y: 0 }) } : obj.fill,
-        loops: obj.loops.map((loop) => ({
-          points: loop.points.map((v2) => ({ ...v2, ...fn2(v2) }))
-        }))
+        // (Its boundary edges are transformed by each caller, as the
+        // objects they are — see hatchEdgesVia.)
+        fill: obj.fill.kind === "pattern" ? { ...obj.fill, origin: fn2(obj.fill.origin ?? { x: 0, y: 0 }) } : obj.fill
       };
     case "text":
       return {
@@ -2224,8 +3056,45 @@ var mapObjectPoints = (obj, fn2) => {
       return { ...obj, position: fn2(obj.position) };
   }
 };
+var EDGE_FIELDS = {
+  line: ["a", "b"],
+  arc: ["center", "radius", "startAngle", "endAngle"],
+  ellipse: ["center", "majorAxis", "ratio", "startAngle", "endAngle"],
+  spline: ["degree", "controlPoints", "knots", "weights", "fitPoints"]
+};
+var hatchEdgeAsObject = (edge) => {
+  const { kind, ...geometry } = edge;
+  const closed = kind === "spline" ? (() => {
+    const { start, end } = edgeEnds(edge);
+    return Math.hypot(start.x - end.x, start.y - end.y) < 1e-9;
+  })() : void 0;
+  return {
+    ...geometry,
+    type: kind,
+    id: "",
+    layerId: "",
+    ...closed !== void 0 ? { closed } : {}
+  };
+};
+var objectAsHatchEdge = (obj, kind) => {
+  const source = obj;
+  const out = { kind };
+  for (const key of EDGE_FIELDS[kind])
+    if (source[key] !== void 0) out[key] = source[key];
+  return out;
+};
+var hatchEdgesVia = (hatch, transform) => ({
+  ...hatch,
+  loops: hatch.loops.map((loop) => ({
+    edges: loop.edges.map(
+      (edge) => objectAsHatchEdge(transform(hatchEdgeAsObject(edge)), edge.kind)
+    )
+  }))
+});
 var translateObject = (obj, delta) => {
   const mapped = mapObjectPoints(obj, (p2) => add(p2, delta));
+  if (mapped.type === "hatch")
+    return hatchEdgesVia(mapped, (o) => translateObject(o, delta));
   return mapped.type === "viewport" ? {
     ...mapped,
     rect: {
@@ -2268,11 +3137,15 @@ var rotateObject = (obj, center, ang) => {
     case "reference":
       return { ...mapped, rotation: normAngle(mapped.rotation + ang) };
     case "hatch":
-      return { ...mapped, fill: turnFill(mapped.fill, (a2) => a2 + ang) };
+      return {
+        ...hatchEdgesVia(mapped, (o) => rotateObject(o, center, ang)),
+        fill: turnFill(mapped.fill, (a2) => a2 + ang)
+      };
     case "line":
     case "point":
     case "polyline":
     case "circle":
+    case "spline":
     case "comment":
       return mapped;
     default:
@@ -2290,7 +3163,7 @@ var scaleObjectUniform = (obj, s) => {
       return { ...mapped, majorAxis: m2(mapped.majorAxis) };
     case "hatch":
       return {
-        ...mapped,
+        ...hatchEdgesVia(mapped, (o) => scaleObjectUniform(o, s)),
         fill: mapped.fill.kind === "lines" ? { ...mapped.fill, spacing: mapped.fill.spacing * s } : mapped.fill.kind === "pattern" ? { ...mapped.fill, scale: mapped.fill.scale * s } : mapped.fill
       };
     case "text":
@@ -2328,6 +3201,7 @@ var scaleObjectUniform = (obj, s) => {
       return mapped;
     case "line":
     case "polyline":
+    case "spline":
     case "comment":
       return mapped;
     default:
@@ -2383,11 +3257,8 @@ var mirrorObject = (obj, a2, b) => {
       };
     case "hatch":
       return {
-        ...mapped,
-        fill: turnFill(mapped.fill, mirrorAngle),
-        loops: mapped.loops.map((loop) => ({
-          points: loop.points.map((v2) => ({ ...v2, bulge: -v2.bulge }))
-        }))
+        ...hatchEdgesVia(mapped, (o) => mirrorObject(o, a2, b)),
+        fill: turnFill(mapped.fill, mirrorAngle)
       };
     case "text": {
       const reflected = normAngle(mirrorAngle(mapped.rotation));
@@ -2417,6 +3288,7 @@ var mirrorObject = (obj, a2, b) => {
     case "line":
     case "point":
     case "circle":
+    case "spline":
     case "comment":
       return mapped;
     // Mirrored above, before the point map.
@@ -2470,7 +3342,9 @@ var acquireInputTable = async (table, pickers, extras = {}) => {
         break;
       case "host": {
         if (!pickers.host)
-          throw new Error(`"${def.name}" needs a host block \u2014 pick it in the editor`);
+          throw new Error(
+            `"${def.name}" needs a host block \u2014 pick it in the editor`
+          );
         const picked = await pickers.host(def);
         out[def.name] = picked.id;
         extras.hostPoint = picked.point;
@@ -2534,7 +3408,9 @@ var checkNamedInputs = (who, table, given, lookup) => {
           throw new Error(`${who}: input "${def.name}" \u2014 expected a block id`);
         const host = lookup?.(v2);
         if (lookup && host?.type !== "block")
-          throw new Error(`${who}: input "${def.name}" \u2014 no block with id ${v2}`);
+          throw new Error(
+            `${who}: input "${def.name}" \u2014 no block with id ${v2}`
+          );
         if (host?.type === "block" && def.types.length > 0 && !def.types.includes(host.definitionId))
           throw new Error(
             `${who}: input "${def.name}" \u2014 a "${host.definitionId}" can't host this (takes ${def.types.join(", ")})`
@@ -2621,7 +3497,9 @@ var resolveNamedInputs = (table, stored, pivot, resolve) => {
       case "host":
         break;
       case "objects": {
-        const ids = Array.isArray(v2) ? v2.filter((id) => typeof id === "string") : [];
+        const ids = Array.isArray(v2) ? v2.filter(
+          (id) => typeof id === "string"
+        ) : [];
         out[def.name] = ids.map(obj).filter((o) => o !== null);
         break;
       }
@@ -2743,7 +3621,7 @@ var PX_TO_MM = 25.4 / 96;
 var embeddedAssetId = (o) => o.type === "reference" && o.source?.kind === "asset" ? o.source.assetId : void 0;
 
 // ../core/src/model/migrations.ts
-var CURRENT_DOCUMENT_VERSION = 24;
+var CURRENT_DOCUMENT_VERSION = 25;
 var leaderRawToText = (raw) => {
   const points = Array.isArray(raw.points) ? raw.points : [];
   const extraLines = Array.isArray(raw.extraLines) ? raw.extraLines : [];
@@ -3374,6 +4252,31 @@ var migrateV22toV23 = (doc) => {
   return { ...doc, objects: mapObjects(doc.objects), layouts, version: 23 };
 };
 var migrateV23toV24 = (doc) => ({ ...doc, version: 24 });
+var hatchRawPointsToEdges = (raw) => {
+  if (!Array.isArray(raw.loops)) return raw;
+  const vertex = (v2) => Array.isArray(v2) ? { x: Number(v2[0]), y: Number(v2[1]), bulge: Number(v2[2] ?? 0) } : {
+    x: Number(v2.x),
+    y: Number(v2.y),
+    bulge: Number(v2.bulge ?? 0)
+  };
+  return {
+    ...raw,
+    loops: raw.loops.map(
+      (loop) => loop !== null && typeof loop === "object" && Array.isArray(loop.points) ? verticesToLoop(loop.points.map(vertex)) : loop
+    )
+  };
+};
+var migrateV24toV25 = (doc) => {
+  const mapObjects = (list) => Array.isArray(list) ? list.map(
+    (raw) => raw !== null && typeof raw === "object" && raw.type === "hatch" ? hatchRawPointsToEdges(raw) : raw
+  ) : list;
+  const layouts = Array.isArray(doc.layouts) ? doc.layouts.map((raw) => {
+    if (raw === null || typeof raw !== "object") return raw;
+    const layout = raw;
+    return { ...layout, objects: mapObjects(layout.objects) };
+  }) : doc.layouts;
+  return { ...doc, objects: mapObjects(doc.objects), layouts, version: 25 };
+};
 var MIGRATION_STEPS = [
   migrateV1toV2,
   migrateV2toV3,
@@ -3397,7 +4300,8 @@ var MIGRATION_STEPS = [
   migrateV20toV21,
   migrateV21toV22,
   migrateV22toV23,
-  migrateV23toV24
+  migrateV23toV24,
+  migrateV24toV25
 ];
 function migrateDocument(raw) {
   if (raw === null || typeof raw !== "object") return raw;
@@ -3437,6 +4341,7 @@ var BlockChildSchema = z7.preprocess(
         dimRawScaleToField(dimensionRawToOffset(obj))
       );
     if (obj.type === "text") return textRawStyleToOverride(obj);
+    if (obj.type === "hatch") return hatchRawPointsToEdges(obj);
     return obj;
   },
   z7.discriminatedUnion("type", [
@@ -3545,10 +4450,12 @@ var RawHandleSchema = z8.strictObject({
     if (h.along && !h.along.origin) issue("`along` needs an `origin`");
   } else {
     if (!h.from || !h.to) issue("a line handle needs `from` and `to`");
-    if (h.around) issue("a line handle drags along a direction, not `around`");
+    if (h.around)
+      issue("a line handle drags along a direction, not `around`");
     if (h.input !== void 0) issue("a line handle can't move an `input`");
   }
-  if (behaviours > 1) issue("give a handle ONE of `param`, `input` or `drag`");
+  if (behaviours > 1)
+    issue("give a handle ONE of `param`, `input` or `drag`");
   if (h.along && h.around)
     issue("`along` and `around` are alternative constraints \u2014 pick one");
   if (!h.fixed && behaviours === 0 && !h.click && !h.menu?.length && !h.actions?.length)
@@ -3556,7 +4463,9 @@ var RawHandleSchema = z8.strictObject({
       "the handle does nothing \u2014 add `param`, `input`, `drag`, `click`, `menu` or `actions`, or mark it `fixed`"
     );
   if (h.kind === "point" && h.param !== void 0 && !h.along && !h.around)
-    issue("a `param` handle needs `along` or `around` (what value it measures)");
+    issue(
+      "a `param` handle needs `along` or `around` (what value it measures)"
+    );
   if (h.along && Math.hypot(h.along.direction.x, h.along.direction.y) === 0)
     issue("`along.direction` is zero");
 });
@@ -5630,8 +6539,7 @@ var fromGeom = (multi) => multi.flatMap(
   (polygon) => polygon.map((ring) => {
     const pts = ring.map(([x2, y2]) => ({ x: x2, y: y2 }));
     const [first, last] = [pts[0], pts[pts.length - 1]];
-    if (pts.length > 1 && first.x === last.x && first.y === last.y)
-      pts.pop();
+    if (pts.length > 1 && first.x === last.x && first.y === last.y) pts.pop();
     return pts;
   })
 );
@@ -5652,50 +6560,489 @@ var intersection2 = (...polygons) => {
   return fromGeom(index.intersection(gs[0], ...gs.slice(1)));
 };
 
+// ../core/src/extensions/scriptCurves.ts
+var scriptCurves_exports = {};
+__export(scriptCurves_exports, {
+  hatchLoop: () => hatchLoop,
+  splineThrough: () => splineThrough
+});
+var splineThrough = (points, degree = 3) => {
+  const pts = points.map(
+    (p2) => Array.isArray(p2) ? { x: p2[0], y: p2[1] } : { x: p2.x, y: p2.y }
+  );
+  const curve = interpolateFitPoints(pts, degree);
+  if (!curve)
+    throw new Error("splineThrough: needs at least two distinct points");
+  return {
+    type: "spline",
+    degree: curve.degree,
+    controlPoints: curve.controlPoints,
+    knots: curve.knots,
+    fitPoints: pts
+  };
+};
+var hatchLoop = (points) => verticesToLoop(
+  points.map(
+    (p2) => Array.isArray(p2) ? {
+      x: p2[0],
+      y: p2[1],
+      bulge: p2[2] ?? 0
+    } : {
+      x: p2.x,
+      y: p2.y,
+      bulge: p2.bulge ?? 0
+    }
+  )
+);
+
+// ../core/src/extensions/sandbox.ts
+var COMMAND_BUDGET_MS = 5e3;
+var BLOCK_BUDGET_MS = 200;
+var MEMORY_LIMIT = 256 * 1024 * 1024;
+var STACK_LIMIT = 1024 * 1024;
+var HOST_FN = "\0fn";
+var HOST_OBJ = "\0obj";
+var VM_FN = "
fn";
+var FROZEN = "\0frozen";
+var PRELUDE = String.raw`(() => {
+  const host = globalThis.__host;
+  delete globalThis.__host;
+  const fns = new Map();
+  let next = 0;
+  const encode = (v) =>
+    JSON.stringify([v], (k, x) => {
+      if (typeof x !== "function") return x;
+      fns.set(next, x);
+      return { "\u0001fn": next++ };
+    });
+  const settle = (r) => (typeof r === "string" ? revive(r) : r.then(revive));
+  const revive = (s) =>
+    JSON.parse(s, (k, x) => {
+      if (x !== null && typeof x === "object") {
+        if ("\u0000frozen" in x) return Object.freeze(x["\u0000frozen"]);
+        if ("\u0000fn" in x) {
+          const id = x["\u0000fn"];
+          return (...a) => settle(host.call(id, encode(a)));
+        }
+        if ("\u0000obj" in x) {
+          const id = x["\u0000obj"];
+          return new Proxy({}, {
+            get: (_, p) => (typeof p === "string" ? revive(host.get(id, p)) : undefined),
+          });
+        }
+      }
+      return x;
+    })[0];
+  const out = (r) =>
+    r !== null && typeof r === "object" && typeof r.then === "function"
+      ? Promise.resolve(r).then(encode)
+      : encode(r);
+  return {
+    call: (id, args, freed) => {
+      for (const f of JSON.parse(freed)) fns.delete(f);
+      return out(fns.get(id)(...revive(args)));
+    },
+    load: (code, helpersJson, localHelpers) => {
+      // Pure helpers run here (a host call per vector op costs ~20 µs);
+      // the heavy ones (booleans, curves) stay host calls.
+      const helpers = Object.freeze({
+        ...revive(helpersJson),
+        ...new Function("return (" + localHelpers + ")")(),
+      });
+      const lineadraw = { helpers, defineBlock: (s) => s, defineCommand: (s) => s };
+      const require = (spec) => {
+        if (spec === "lineadraw/helpers" || spec === "linea/helpers") return helpers;
+        if (spec === "lineadraw" || spec === "linea") return lineadraw;
+        throw new Error('Cannot import "' + spec + '" — scripts may only import from "lineadraw" and "lineadraw/helpers"');
+      };
+      const module = { exports: {} };
+      new Function("exports", "require", "module", code)(module.exports, require, module);
+      return encode(module.exports);
+    },
+  };
+})()`;
+var wasm = null;
+var wasmLoading = null;
+var ensureSandbox = () => {
+  if (wasm) return Promise.resolve(wasm);
+  wasmLoading ??= Promise.all([
+    import("./dist-56K6CNML.js"),
+    import("./dist-IEN64QSV.js")
+  ]).then(
+    ([{ newQuickJSWASMModuleFromVariant }, variant]) => newQuickJSWASMModuleFromVariant(variant.default)
+  ).then((m2) => {
+    wasm = m2;
+    return m2;
+  });
+  return wasmLoading;
+};
+var ScriptTimeoutError = class extends Error {
+  code = "scriptTimeout";
+};
+var BUILTIN_ERRORS = {
+  TypeError,
+  RangeError,
+  SyntaxError,
+  ReferenceError
+};
+var isPlain = (x2) => {
+  if (Array.isArray(x2)) return true;
+  const p2 = Object.getPrototypeOf(x2);
+  return p2 === Object.prototype || p2 === null;
+};
+var runtime = null;
+var live = /* @__PURE__ */ new Set();
+var resetListeners = /* @__PURE__ */ new Set();
+var stack = [];
+var deadline = 0;
+var entryBudget = 0;
+var interrupted = null;
+var resetPending = false;
+var getRuntime = () => {
+  if (runtime) return runtime;
+  if (!wasm) throw new Error("Script sandbox is still loading");
+  const rt = wasm.newRuntime();
+  rt.setMemoryLimit(MEMORY_LIMIT);
+  rt.setMaxStackSize(STACK_LIMIT);
+  rt.setInterruptHandler(() => {
+    if (Date.now() <= deadline) return false;
+    interrupted ??= stack[stack.length - 1] ?? null;
+    return true;
+  });
+  runtime = rt;
+  return rt;
+};
+var onSandboxReset = (cb) => {
+  resetListeners.add(cb);
+  return () => resetListeners.delete(cb);
+};
+var resetRuntime = () => {
+  resetPending = false;
+  for (const s of live) s.kill();
+  live.clear();
+  runtime?.dispose();
+  runtime = null;
+  for (const cb of resetListeners) cb();
+};
+var ModuleSandbox = class {
+  ctx;
+  bridge;
+  hostFns = [];
+  hostObjs = [];
+  bound = /* @__PURE__ */ new Map();
+  baseFns = 0;
+  baseObjs = 0;
+  loaded = false;
+  /** VM function refs whose host callables were collected; sent along with
+   * the next call so the VM drops them too. */
+  vmFreed = [];
+  vmFinalizer = new FinalizationRegistry(
+    (id) => this.vmFreed.push(id)
+  );
+  depth = 0;
+  pendingAsync = 0;
+  poisoned = null;
+  dead = false;
+  disposeOnIdle = false;
+  lastHostError = null;
+  opts;
+  constructor(opts) {
+    this.opts = opts;
+    this.ctx = getRuntime().newContext();
+    live.add(this);
+    const ctx = this.ctx;
+    const host = ctx.newObject();
+    const call = ctx.newFunction("call", (idH, argsH) => {
+      const fn2 = this.hostFns[ctx.getNumber(idH)];
+      let r;
+      try {
+        if (!fn2)
+          throw new Error(
+            "A host function was called after the call that handed it over ended"
+          );
+        r = fn2(...this.decode(ctx.getString(argsH))[0]);
+      } catch (e) {
+        this.lastHostError = e;
+        throw e;
+      }
+      if (!(r instanceof Promise)) return ctx.newString(this.encode(r));
+      const d2 = ctx.newPromise();
+      r.then(
+        (v2) => {
+          if (this.dead) return;
+          const s = ctx.newString(this.encode(v2));
+          d2.resolve(s);
+          s.dispose();
+        },
+        (e) => {
+          if (this.dead) return;
+          this.lastHostError = e;
+          const eh = ctx.newError(e instanceof Error ? e.message : String(e));
+          d2.reject(eh);
+          eh.dispose();
+        }
+      ).finally(() => {
+        if (this.dead) return;
+        d2.dispose();
+        this.drain();
+      });
+      return d2.handle.dup();
+    });
+    const get = ctx.newFunction("get", (idH, keyH) => {
+      const id = ctx.getNumber(idH);
+      const key = ctx.getString(keyH);
+      const obj = this.hostObjs[id];
+      if (!obj)
+        throw new Error(
+          "A host object was used after the call that handed it over ended"
+        );
+      const v2 = obj[key];
+      if (typeof v2 !== "function") return ctx.newString(this.encode(v2));
+      const k2 = `${id}:${key}`;
+      let fnId = this.bound.get(k2);
+      if (fnId === void 0) {
+        fnId = this.hostFns.push(v2.bind(obj)) - 1;
+        this.bound.set(k2, fnId);
+      }
+      return ctx.newString(JSON.stringify([{ [HOST_FN]: fnId }]));
+    });
+    ctx.setProp(host, "call", call);
+    ctx.setProp(host, "get", get);
+    ctx.setProp(ctx.global, "__host", host);
+    call.dispose();
+    get.dispose();
+    host.dispose();
+    this.bridge = this.enter(
+      () => this.unwrap(ctx.evalCode(PRELUDE, "prelude.js"))
+    );
+  }
+  /** Host value → JSON for the VM (functions/instances become refs). */
+  encode(v2) {
+    return JSON.stringify([v2], (_k, x2) => {
+      if (typeof x2 === "function")
+        return { [HOST_FN]: this.hostFns.push(x2) - 1 };
+      if (x2 === null || typeof x2 !== "object") return x2;
+      if (!isPlain(x2)) return { [HOST_OBJ]: this.hostObjs.push(x2) - 1 };
+      if (Object.isFrozen(x2) && !(FROZEN in x2))
+        return { [FROZEN]: Array.isArray(x2) ? [...x2] : { ...x2 } };
+      return x2;
+    });
+  }
+  /** VM JSON → host value (VM function refs become host callables). */
+  decode(s) {
+    return JSON.parse(
+      s,
+      (_k, x2) => x2 !== null && typeof x2 === "object" && VM_FN in x2 ? this.vmFunction(x2[VM_FN]) : x2
+    );
+  }
+  /** Run `fn` as VM work. The outermost entry on the shared stack starts the
+   * budget; nested entries (a script calling the host calling a script)
+   * spend the same one. */
+  enter(fn2) {
+    if (this.dead)
+      throw new Error(
+        "This script's sandbox was reset; it re-compiles on next use"
+      );
+    if (this.poisoned) throw this.poisoned;
+    if (stack.length === 0) {
+      getRuntime();
+      deadline = Date.now() + this.opts.budgetMs;
+      entryBudget = this.opts.budgetMs;
+      interrupted = null;
+    }
+    if (this.depth === 0) this.lastHostError = null;
+    stack.push(this);
+    this.depth++;
+    try {
+      return fn2();
+    } finally {
+      stack.pop();
+      this.depth--;
+      this.idle();
+      if (stack.length === 0 && resetPending) resetRuntime();
+    }
+  }
+  /** Nothing of this module running or awaited: drop the host refs its
+   * calls handed over (a script that keeps one past its call gets a clear
+   * error using it). VM refs live until the host collects their callables. */
+  idle() {
+    if (this.depth > 0 || this.pendingAsync > 0) return;
+    if (this.disposeOnIdle) return this.dispose();
+    if (!this.loaded) return;
+    this.hostFns.length = this.baseFns;
+    this.hostObjs.length = this.baseObjs;
+    for (const [k2, id] of this.bound)
+      if (id >= this.baseFns) this.bound.delete(k2);
+  }
+  drain() {
+    this.enter(() => {
+      const r = getRuntime().executePendingJobs();
+      if (r.error) r.error.dispose();
+    });
+  }
+  unwrap(r) {
+    if (!r.error) return r.value;
+    const dumped = this.ctx.dump(r.error);
+    r.error.dispose();
+    throw this.toHostError(dumped);
+  }
+  toHostError(dumped) {
+    if (interrupted) {
+      const e = new ScriptTimeoutError(
+        `Script exceeded its ${entryBudget} ms time budget and was stopped.`
+      );
+      if (interrupted === this && this.opts.poisonOnTimeout)
+        this.poisoned = new ScriptTimeoutError(
+          `${e.message} It stays off until its source changes.`
+        );
+      return e;
+    }
+    const field = (k2) => dumped !== null && typeof dumped === "object" && k2 in dumped ? String(dumped[k2]) : "";
+    const message = field("message") || String(dumped);
+    if (/out of memory/i.test(message)) {
+      resetPending = true;
+      return new Error(
+        `Script ran out of memory (${MEMORY_LIMIT / 1024 / 1024} MB for all scripts) and was stopped.`
+      );
+    }
+    const host = this.lastHostError;
+    if (host instanceof Error && host.message === message) return host;
+    return new (BUILTIN_ERRORS[field("name")] ?? Error)(message);
+  }
+  /** The VM's answer: a JSON string, or a promise of one. */
+  result(h) {
+    if (this.ctx.typeof(h) === "string") {
+      const s = this.ctx.getString(h);
+      h.dispose();
+      return this.decode(s)[0];
+    }
+    const p2 = this.ctx.resolvePromise(h);
+    h.dispose();
+    this.pendingAsync++;
+    this.drain();
+    return p2.then((r) => {
+      const v2 = this.unwrap(r);
+      const s = this.ctx.getString(v2);
+      v2.dispose();
+      return this.decode(s)[0];
+    }).finally(() => {
+      this.pendingAsync--;
+      this.idle();
+    });
+  }
+  callBridge(method, args) {
+    return this.enter(() => {
+      const fnH = this.ctx.getProp(this.bridge, method);
+      const argHs = args.map(
+        (a2) => typeof a2 === "number" ? this.ctx.newNumber(a2) : this.ctx.newString(a2)
+      );
+      const r = this.ctx.callFunction(fnH, this.ctx.undefined, argHs);
+      fnH.dispose();
+      for (const a2 of argHs) a2.dispose();
+      return this.result(this.unwrap(r));
+    });
+  }
+  vmFunction(id) {
+    const f2 = (...args) => {
+      const freed = JSON.stringify(this.vmFreed);
+      this.vmFreed = [];
+      return this.callBridge("call", [id, this.encode(args), freed]);
+    };
+    this.vmFinalizer.register(f2, id);
+    return f2;
+  }
+  load(code, helpers2, localHelpers) {
+    const exported = this.callBridge("load", [
+      code,
+      this.encode(helpers2),
+      localHelpers
+    ]);
+    this.baseFns = this.hostFns.length;
+    this.baseObjs = this.hostObjs.length;
+    this.loaded = true;
+    return exported;
+  }
+  /** The compile cache dropped the module: free its context (once idle). */
+  dispose() {
+    if (this.dead) return;
+    if (this.depth > 0 || this.pendingAsync > 0) {
+      this.disposeOnIdle = true;
+      return;
+    }
+    this.kill();
+    live.delete(this);
+  }
+  /** Free the context now (runtime reset, or an idle dispose). */
+  kill() {
+    if (this.dead) return;
+    this.dead = true;
+    this.hostFns.length = 0;
+    this.hostObjs.length = 0;
+    this.bound.clear();
+    if (this.bridge?.alive) this.bridge.dispose();
+    if (this.ctx.alive) this.ctx.dispose();
+  }
+};
+var executeInSandbox = (code, helpers2, localHelpers, opts = { budgetMs: COMMAND_BUDGET_MS }) => {
+  localSource ??= `{${Object.entries(localHelpers).map(([k2, f2]) => `${JSON.stringify(k2)}: ${f2.toString()}`).join(",")}}`;
+  const box = new ModuleSandbox(opts);
+  try {
+    return {
+      exports: box.load(code, helpers2, localSource),
+      release: () => box.dispose()
+    };
+  } catch (e) {
+    box.dispose();
+    throw e;
+  }
+};
+var localSource = null;
+
 // ../core/src/extensions/scriptRuntime.ts
-var scriptHelpers = Object.freeze({ ...scriptHelpers_exports, ...scriptBooleans_exports });
+var releases = /* @__PURE__ */ new WeakMap();
+var releaseScriptModule = (mod) => {
+  releases.get(mod)?.();
+  releases.delete(mod);
+};
+var scriptHelpers = Object.freeze({
+  ...scriptHelpers_exports,
+  ...scriptBooleans_exports,
+  ...scriptCurves_exports
+});
 var helpers = Object.freeze({ ...scriptHelpers });
 var onTranspilerReady = null;
 var transpiler = null;
 var transpilerLoading = null;
 var ensureScriptTranspiler = () => {
   if (transpiler) return Promise.resolve(transpiler);
-  transpilerLoading ??= import("sucrase").then(({ transform }) => {
-    transpiler = (script) => {
-      const code = transform(script, {
-        transforms: ["typescript", "imports"]
-      }).code;
-      const moduleShim = { exports: {} };
-      new Function("exports", "require", "module", code)(
-        moduleShim.exports,
-        (spec2) => {
-          if (spec2 === "lineadraw/helpers" || spec2 === "linea/helpers")
-            return scriptHelpers;
-          if (spec2 === "lineadraw" || spec2 === "linea")
-            return {
-              helpers,
-              defineBlock: (blockSpec) => blockSpec,
-              defineCommand: (commandSpec) => commandSpec
-            };
-          throw new Error(
-            `Cannot import "${spec2}" \u2014 scripts may only import from "lineadraw" and "lineadraw/helpers"`
-          );
-        },
-        moduleShim
-      );
-      const exported = moduleShim.exports;
-      const spec = exported.default;
-      return spec !== null && typeof spec === "object" && !Array.isArray(spec) ? { ...exported, ...spec } : exported;
-    };
-    onTranspilerReady?.();
-    return transpiler;
-  });
+  transpilerLoading ??= Promise.all([import("sucrase"), ensureSandbox()]).then(
+    ([{ transform }]) => {
+      transpiler = (script, kind = "command") => {
+        const code = transform(script, {
+          transforms: ["typescript", "imports"]
+        }).code;
+        const { exports: exported, release } = executeInSandbox(
+          code,
+          scriptHelpers,
+          scriptHelpers_exports,
+          kind === "block" ? { budgetMs: BLOCK_BUDGET_MS, poisonOnTimeout: true } : { budgetMs: COMMAND_BUDGET_MS }
+        );
+        const spec = exported.default;
+        const mod = spec !== null && typeof spec === "object" && !Array.isArray(spec) ? { ...exported, ...spec } : exported;
+        releases.set(mod, release);
+        return mod;
+      };
+      onTranspilerReady?.();
+      return transpiler;
+    }
+  );
   return transpilerLoading;
 };
-var executeScriptModule = (script) => {
+var executeScriptModule = (script, kind) => {
   if (!transpiler) throw transpilerLoadingError();
-  return transpiler(script);
+  return transpiler(script, kind);
 };
+onSandboxReset(() => onTranspilerReady?.());
 var scriptTranspilerReady = () => transpiler !== null;
 var transpilerLoadingError = () => {
   void ensureScriptTranspiler();
@@ -5717,6 +7064,7 @@ var hashString = (s) => {
 };
 var isLabelArray = (v2) => Array.isArray(v2) && v2.every((s) => typeof s === "string");
 var compileCache = /* @__PURE__ */ new Map();
+onSandboxReset(() => compileCache.clear());
 var COMPILE_CACHE_MAX = 200;
 var resultCache = /* @__PURE__ */ new Map();
 var RESULT_CACHE_MAX = 500;
@@ -5868,13 +7216,24 @@ var compileBlock = (script) => {
     compileCache.set(script, cached);
     return cached;
   }
-  const mod = toBlockModule(executeScriptModule(script));
-  const meta = extractMeta(mod);
+  const raw = executeScriptModule(script, "block");
+  let mod;
+  let meta;
+  try {
+    mod = toBlockModule(raw);
+    meta = extractMeta(mod);
+  } catch (e) {
+    releaseScriptModule(raw);
+    throw e;
+  }
   if (compileCache.size >= COMPILE_CACHE_MAX) {
     const oldest = compileCache.keys().next().value;
-    if (oldest !== void 0) compileCache.delete(oldest);
+    if (oldest !== void 0) {
+      releaseScriptModule(compileCache.get(oldest).raw);
+      compileCache.delete(oldest);
+    }
   }
-  const compiled = { mod, meta, hash: hashString(script) };
+  const compiled = { raw, mod, meta, hash: hashString(script) };
   compileCache.set(script, compiled);
   return compiled;
 };
@@ -6149,7 +7508,9 @@ var testBlockDefinition = async (script) => {
     }
     if (mod.handles)
       parseBlockHandles(
-        mod.handles(scriptProps({ params: { ...defaultParams(meta) }, inputs: local })),
+        mod.handles(
+          scriptProps({ params: { ...defaultParams(meta) }, inputs: local })
+        ),
         meta.params,
         meta.inputs,
         defaultParams(meta)
@@ -6228,9 +7589,21 @@ var framePose = (instance, hostId, scripts, resolveObject, depth) => {
   if (depth >= MAX_HOST_DEPTH) return null;
   const host = resolveObject?.(hostId);
   if (host?.type !== "block") return null;
-  return framePose(host, blockHostId(host, scripts), scripts, resolveObject, depth + 1);
+  return framePose(
+    host,
+    blockHostId(host, scripts),
+    scripts,
+    resolveObject,
+    depth + 1
+  );
 };
-var instancePose = (instance, scripts, resolveObject) => framePose(instance, blockHostId(instance, scripts), scripts, resolveObject, 0);
+var instancePose = (instance, scripts, resolveObject) => framePose(
+  instance,
+  blockHostId(instance, scripts),
+  scripts,
+  resolveObject,
+  0
+);
 var exposeMemo = /* @__PURE__ */ new Map();
 var getBlockExposed = (instance, scripts) => {
   const def = resolveDefinition(instance, scripts);
@@ -6238,9 +7611,7 @@ var getBlockExposed = (instance, scripts) => {
   try {
     const hit = exposeMemo.get(instance.id);
     if (hit && hit.key === def.key) return hit.value;
-    const value = z10.json().parse(
-      def.mod.expose(scriptProps({ params: def.params }))
-    );
+    const value = z10.json().parse(def.mod.expose(scriptProps({ params: def.params })));
     exposeMemo.set(instance.id, { key: def.key, value });
     return value;
   } catch {
@@ -6305,7 +7676,12 @@ var resolvePlaced = (def, instance, scripts, resolveObject) => {
   const hosting = hostingProps(instance, def, scripts, resolveObject);
   const hostingSig = hosting.host === null && hosting.hosted.length === 0 ? "" : String(hashString(JSON.stringify(hosting)));
   let inputs;
-  const drawInputs = () => inputs ??= drawInputsFor(def.meta, instance.inputs, pose.pivot, resolveObject);
+  const drawInputs = () => inputs ??= drawInputsFor(
+    def.meta,
+    instance.inputs,
+    pose.pivot,
+    resolveObject
+  );
   return {
     ok: true,
     def,
@@ -10317,7 +11693,7 @@ var angularFrame = (obj) => {
   return { vertex, radius, start, sweep, frame };
 };
 var overlaps = (a2, b) => a2[0] < b[1] - 1e-9 && b[0] < a2[1] - 1e-9;
-var placeLabel = (frame, spec, index2, label, style, arrowCount, mode, stack) => {
+var placeLabel = (frame, spec, index2, label, style, arrowCount, mode, stack2) => {
   const s = style.scale;
   const h = style.textHeight * s;
   const gap = style.textOffset * s;
@@ -10339,8 +11715,8 @@ var placeLabel = (frame, spec, index2, label, style, arrowCount, mode, stack) =>
       along = (frame.s0 + frame.s1) / 2;
       row = 1;
       const interval2 = [along - width / 2, along + width / 2];
-      if (stack && stack.row >= 1 && overlaps(interval2, stack.interval))
-        row = stack.row + 1;
+      if (stack2 && stack2.row >= 1 && overlaps(interval2, stack2.interval))
+        row = stack2.row + 1;
       across = row * (h + gap);
     }
   }
@@ -10399,7 +11775,7 @@ var linearGeometry = (obj, style) => {
   const arrows = [];
   const labels = [];
   const leaders = [];
-  let stack = null;
+  let stack2 = null;
   frames.forEach((frame, i) => {
     const L = frame.s1 - frame.s0;
     const value = L;
@@ -10416,9 +11792,9 @@ var linearGeometry = (obj, style) => {
       style,
       2,
       mode,
-      stack
+      stack2
     );
-    stack = placed.row > 0 ? {
+    stack2 = placed.row > 0 ? {
       row: placed.row,
       interval: [
         placed.text.along - placed.text.width / 2,
@@ -11413,7 +12789,7 @@ var isSymbolFont = (fontCode) => /^symbol(\.ttf)?$/i.test(fontCode.split("|")[0]
 var scanMtext = (text, opts) => {
   const chunks = [];
   let st = { symbol: false };
-  const stack = [];
+  const stack2 = [];
   const attrs = (extra) => opts ? {
     ...st.font !== void 0 ? { font: st.font } : {},
     ...st.bold !== void 0 ? { bold: st.bold } : {},
@@ -11439,11 +12815,11 @@ var scanMtext = (text, opts) => {
   while (i < text.length) {
     const ch = text[i];
     if (ch === "{") {
-      stack.push(st);
+      stack2.push(st);
       st = { ...st };
       i++;
     } else if (ch === "}") {
-      st = stack.pop() ?? st;
+      st = stack2.pop() ?? st;
       i++;
     } else if (ch !== "\\") {
       emit(st.symbol ? SYMBOL_FONT[ch] ?? ch : ch);
@@ -11984,7 +13360,24 @@ var classesSection = (content) => DXF_CLASSES.filter(([name]) => content.include
 0
 ${name}
 `)).map(
-  ([name, cpp, app, proxy, isEntity]) => [0, "CLASS", 1, name, 2, cpp, 3, app, 90, proxy, 91, 0, 280, 0, 281, isEntity].map((v2) => `${v2}
+  ([name, cpp, app, proxy, isEntity]) => [
+    0,
+    "CLASS",
+    1,
+    name,
+    2,
+    cpp,
+    3,
+    app,
+    90,
+    proxy,
+    91,
+    0,
+    280,
+    0,
+    281,
+    isEntity
+  ].map((v2) => `${v2}
 `).join("")
 ).join("");
 
@@ -12283,6 +13676,103 @@ var dxfPatternName = (name) => {
   const key = name.toUpperCase().replace(/-/g, "_").replace(/\./g, "_");
   return HatchPredefinedPatterns[key] ?? HatchPredefinedPatterns.ANSI31;
 };
+var HatchLoopPaths = class {
+  loops;
+  constructor(loops) {
+    this.loops = loops;
+  }
+  get length() {
+    return this.loops.length;
+  }
+  dxfy(dx) {
+    for (const loop of this.loops) {
+      const vertices = loopToVertices(loop);
+      if (vertices) {
+        dx.push(92, PATH_POLYLINE);
+        new HatchPolylineBoundary(vertices).dxfy(dx);
+        continue;
+      }
+      const chain = chainEdges(loop);
+      dx.push(92, PATH_DEFAULT);
+      dx.push(93, chain.length);
+      for (const { edge, reversed } of chain) writeEdge(dx, edge, reversed);
+      dx.push(97, 0);
+    }
+  }
+};
+var PATH_DEFAULT = 0;
+var PATH_POLYLINE = 2;
+var writeEdge = (dx, edge, reversed) => {
+  switch (edge.kind) {
+    case "line": {
+      const [a2, b] = reversed ? [edge.b, edge.a] : [edge.a, edge.b];
+      dx.push(72, 1);
+      dx.point2d(a2);
+      dx.push(11, b.x);
+      dx.push(21, b.y);
+      return;
+    }
+    case "arc": {
+      const full = sameAngle(edge.startAngle, edge.endAngle);
+      const s0 = edge.startAngle * RAD2DEG2;
+      const e0 = full ? s0 + 360 : edge.endAngle * RAD2DEG2;
+      dx.push(72, 2);
+      dx.point2d(edge.center);
+      dx.push(40, edge.radius);
+      dx.push(50, reversed ? -e0 : s0);
+      dx.push(51, reversed ? -s0 : e0);
+      dx.push(73, reversed ? 0 : 1);
+      return;
+    }
+    case "ellipse": {
+      const full = sameAngle(edge.startAngle, edge.endAngle);
+      const trueDeg = (t) => Math.atan2(edge.ratio * Math.sin(t), Math.cos(t)) * RAD2DEG2;
+      const s0 = full ? 0 : trueDeg(edge.startAngle);
+      const e0 = full ? 360 : trueDeg(edge.endAngle);
+      dx.push(72, 3);
+      dx.point2d(edge.center);
+      dx.push(11, edge.majorAxis.x);
+      dx.push(21, edge.majorAxis.y);
+      dx.push(40, edge.ratio);
+      dx.push(50, reversed ? -e0 : s0);
+      dx.push(51, reversed ? -s0 : e0);
+      dx.push(73, reversed ? 0 : 1);
+      return;
+    }
+    case "spline":
+      writeSplineEdge(dx, reversed ? reverseNurbs(edge) : edge);
+  }
+};
+var sameAngle = (a2, b) => {
+  const d2 = ((b - a2) % (Math.PI * 2) + Math.PI * 2) % (Math.PI * 2);
+  return d2 < 1e-9 || Math.PI * 2 - d2 < 1e-9;
+};
+var reverseNurbs = (c2) => {
+  const k0 = c2.knots[0];
+  const kn = c2.knots[c2.knots.length - 1];
+  return {
+    degree: c2.degree,
+    controlPoints: [...c2.controlPoints].reverse(),
+    knots: [...c2.knots].reverse().map((k2) => k0 + kn - k2),
+    ...c2.weights ? { weights: [...c2.weights].reverse() } : {}
+  };
+};
+var writeSplineEdge = (dx, curve0) => {
+  const curve = nurbsClamped(curve0) ? curve0 : nurbsSegment(curve0, ...nurbsDomain(curve0));
+  const rational = curve.weights?.some((w2) => w2 !== 1) ?? false;
+  dx.push(72, 4);
+  dx.push(94, curve.degree);
+  dx.push(73, rational ? 1 : 0);
+  dx.push(74, 0);
+  dx.push(95, curve.knots.length);
+  dx.push(96, curve.controlPoints.length);
+  for (const k2 of curve.knots) dx.push(40, k2);
+  curve.controlPoints.forEach((p2, i) => {
+    dx.point2d(p2);
+    if (rational) dx.push(42, curve.weights[i]);
+  });
+  dx.push(97, 0);
+};
 var writeHatch = (space, obj, opts, ctx) => {
   if (obj.type !== "hatch") return;
   if (obj.fill.kind === "gradient") {
@@ -12292,14 +13782,7 @@ var writeHatch = (space, obj, opts, ctx) => {
       trueColor: String(hexToTrueColor(obj.fill.color1))
     };
   }
-  const boundary = new HatchBoundaryPaths();
-  for (const loop of obj.loops) {
-    boundary.addPolylineBoundary(
-      new HatchPolylineBoundary(
-        loop.points.map((v2) => ({ x: v2.x, y: v2.y, bulge: v2.bulge }))
-      )
-    );
-  }
+  const boundary = new HatchLoopPaths(obj.loops);
   const fill = (
     // Gradient exports as SOLID in the start color — DXF gradient data
     // (codes 450+) is beyond dxf-writer, and a solid keeps the region and
@@ -12322,7 +13805,11 @@ var writeHatch = (space, obj, opts, ctx) => {
       scale: obj.fill.spacing * obj.scale / ANSI31_BASE_SPACING
     })
   );
-  const written = space.addHatch(boundary, fill, opts);
+  const written = space.addHatch(
+    boundary,
+    fill,
+    opts
+  );
   if (obj.fill.kind === "pattern" && obj.fill.origin)
     ctx.hatchOrigins.set(written.handle, obj.fill.origin);
 };
@@ -12623,6 +14110,19 @@ var writeObjectEntities = (space, obj, ctx) => {
         opts
       );
       break;
+    case "spline":
+      space.addSpline(
+        {
+          controlPoints: obj.controlPoints.map(v3),
+          degreeCurve: obj.degree,
+          knots: obj.knots,
+          ...obj.weights ? { weights: obj.weights } : {},
+          ...obj.fitPoints ? { fitPoints: obj.fitPoints.map(v3) } : {},
+          flags: 8 | (obj.closed ? 1 : 0) | (obj.closed && !nurbsClamped(obj) ? 2 : 0) | (obj.weights ? 4 : 0)
+        },
+        opts
+      );
+      break;
     case "hatch":
       writeHatch(space, obj, opts, ctx);
       break;
@@ -12647,8 +14147,16 @@ var writeObjectEntities = (space, obj, ctx) => {
         );
       if (obj.leaderLines.length > 0 && ctx.explodeLeaders) {
         for (const line of obj.leaderLines) {
+          const start = arrowLineStart(
+            line[0],
+            line[1],
+            arrowSize * obj.scale,
+            arrowType
+          );
           space.addLWPolyline(
-            line.map((v2) => ({ point: { x: v2.x, y: v2.y } })),
+            [start, ...line.slice(1)].map((v2) => ({
+              point: { x: v2.x, y: v2.y }
+            })),
             opts
           );
           addArrowhead(
@@ -13068,13 +14576,35 @@ export {
   dot,
   len,
   dist,
-  norm,
   mid,
   angle,
   perp,
   fromAngle,
   normAngle,
   closestPointOnSegment,
+  arcSweep,
+  pointOnArc,
+  arcStartPoint,
+  arcEndPoint,
+  arcMidPoint,
+  angleInArc,
+  bulgeToArc,
+  bulgeFrom3Points,
+  arcFrom3Points,
+  distToArc,
+  tessellateArc,
+  isValidNurbs,
+  sampleNurbs,
+  interpolateFitPoints,
+  interpolateClosed,
+  nurbsToBeziers,
+  curveTolerance,
+  loopPolygon,
+  emitLoopPath,
+  loopCurves,
+  loopCorners,
+  hatchArea,
+  verticesToLoop,
   Vec2Schema,
   ColorSchema,
   inputPoints,
@@ -13094,10 +14624,12 @@ export {
   fontFromDxfStyle,
   TextStyleSchema,
   DEFAULT_TEXT_STYLE,
+  TextStyleOverrideSchema,
   textStyleFor,
   effectiveTextFont,
   DimStyleSchema,
   DEFAULT_DIM_STYLE,
+  DimStyleOverrideSchema,
   assertKnownStyleOverrideKeys,
   dimStyleFor,
   dimFontFace,
@@ -13154,6 +14686,10 @@ export {
   resolveDocumentObject,
   documentBlocks,
   documentObjectResolver,
+  splineThrough,
+  hatchLoop,
+  onSandboxReset,
+  releaseScriptModule,
   ensureScriptTranspiler,
   executeScriptModule,
   scriptTranspilerReady,
@@ -13172,6 +14708,7 @@ export {
   getBlockMeta,
   getBlockMetaResult,
   listBlockMeta,
+  findBlockScript,
   blockScriptId,
   blockDefinitionExists,
   dryRunObjectResolver,
@@ -13180,6 +14717,8 @@ export {
   hostedClosure,
   getEvaluatedWorldChildren,
   ANSI31_BASE_SPACING,
+  arrowLineStart,
+  paintArrowhead,
   linearAxis,
   dimensionGeometry,
   hexToRgb,
@@ -13194,4 +14733,4 @@ export {
   DWG_DXF_OPTIONS,
   buildDxf
 };
-//# sourceMappingURL=chunk-YYJAXJOY.js.map
+//# sourceMappingURL=chunk-7UFXC7OI.js.map