lineadraw 0.10.0 → 0.11.0

package/dist/sdk.js

@@ -1,10 +1,3 @@
-import {
-  BridgeError,
-  DEFAULT_BRIDGE_PORT,
-  bridgeFilePath,
-  connectEditors,
-  createBridge
-} from "./chunk-L2CWZAKW.js";
 import {
   ADVANCE_TABLES,
   ANSI31_BASE_SPACING,
@@ -13,6 +6,7 @@ import {
   ColorSchema,
   DEFAULT_DIM_STYLE,
   DEFAULT_TEXT_STYLE,
+  DimStyleOverrideSchema,
   DimStyleSchema,
   EXTRACTED_EXTRAS,
   EXTRACTED_RANGES,
@@ -24,18 +18,28 @@ import {
   PX_TO_MM,
   REAL_FACES,
   REFERENCE_FORMATS,
+  TextStyleOverrideSchema,
   TextStyleSchema,
   Vec2Schema,
   aciToHex,
   acquireInputTable,
   add,
   angle,
+  angleInArc,
   approximateTextMeasurer,
+  arcEndPoint,
+  arcFrom3Points,
+  arcMidPoint,
+  arcStartPoint,
+  arcSweep,
   arcToBeziers,
+  arrowLineStart,
   assertKnownStyleOverrideKeys,
   blockDefinitionExists,
   blockPivot,
   blockScriptId,
+  bulgeFrom3Points,
+  bulgeToArc,
   bytesToDataUrl,
   checkNamedInputs,
   cleanRichText,
@@ -43,6 +47,7 @@ import {
   closestPointOnSegment,
   computeHatchLines,
   computePatternGeometry,
+  curveTolerance,
   dataUrlBytes,
   decodeTextEscapes,
   dimFontFace,
@@ -51,6 +56,7 @@ import {
   dimensionRawToLabels,
   dimensionRawToOffset,
   dist,
+  distToArc,
   documentBlocks,
   documentObjectResolver,
   dot,
@@ -59,10 +65,12 @@ import {
   effectiveTextFont,
   ellipseArcToBeziers,
   embeddedAssetId,
+  emitLoopPath,
   ensureScriptTranspiler,
   estimatePatternSegments,
   executeScriptModule,
   expandWithBlockDependents,
+  findBlockScript,
   fontFace,
   fontFromDxfStyle,
   fromAngle,
@@ -73,6 +81,8 @@ import {
   getHatchPattern,
   getLineType,
   hashAsset,
+  hatchArea,
+  hatchLoop,
   hatchPatternKey,
   hexToRgb,
   hostedClosure,
@@ -80,14 +90,20 @@ import {
   inputLabel,
   inputPoints,
   inputRefs,
+  interpolateClosed,
+  interpolateFitPoints,
   invalidateBlockCache,
   isRequiredInput,
+  isValidNurbs,
   len,
   lineSegments,
   lineTypeKey,
   lineWeightToMm,
   linearAxis,
   listBlockMeta,
+  loopCorners,
+  loopCurves,
+  loopPolygon,
   mapInputValues,
   matApply,
   matIdentity,
@@ -97,15 +113,19 @@ import {
   mirrorObject,
   mtextFontFlags,
   mtextWidthFactor,
-  norm,
   normAngle,
   normalizeSpans,
+  nurbsToBeziers,
+  onSandboxReset,
+  paintArrowhead,
   paramMismatch,
   parseFontFace,
   parseInputTable,
   parseParamsExport,
   perp,
+  pointOnArc,
   realFace,
+  releaseScriptModule,
   remapBlockInputRefs,
   renderDashes,
   resolveDocumentObject,
@@ -115,14 +135,17 @@ import {
   rgbToHex,
   richTextBlock,
   rotateObject,
+  sampleNurbs,
   scale,
   scaleObjectUniform,
   scanScriptId,
   scriptTranspilerReady,
   selectionFits,
   signedArcSweep,
+  splineThrough,
   sub,
   tableLayout,
+  tessellateArc,
   testBlockDefinition,
   textArrowSize,
   textArrowType,
@@ -134,108 +157,25 @@ import {
   textWidth,
   translateObject,
   valueParams,
+  verticesToLoop,
   withEmptyLists
-} from "./chunk-YYJAXJOY.js";
+} from "./chunk-7UFXC7OI.js";
 import {
   embeddedPdfFonts
 } from "./chunk-L4FNH35X.js";
+import {
+  BridgeError,
+  DEFAULT_BRIDGE_PORT,
+  bridgeFilePath,
+  connectEditors,
+  createBridge
+} from "./chunk-RNA2RDGL.js";
 import "./chunk-PZ5AY32C.js";
 
 // src/document.ts
 import { readFile, writeFile } from "fs/promises";
 import { dirname, isAbsolute, resolve } from "path";
 
-// ../core/src/geometry/arcs.ts
-var arcSweep = (a) => {
-  const s = normAngle(a.endAngle - a.startAngle);
-  return s === 0 ? Math.PI * 2 : s;
-};
-var pointOnArc = (a, angle2) => ({
-  x: a.center.x + Math.cos(angle2) * a.radius,
-  y: a.center.y + Math.sin(angle2) * a.radius
-});
-var arcStartPoint = (a) => pointOnArc(a, a.startAngle);
-var arcEndPoint = (a) => pointOnArc(a, a.endAngle);
-var arcMidPoint = (a) => pointOnArc(a, a.startAngle + arcSweep(a) / 2);
-var angleInArc = (a, angle2) => normAngle(angle2 - a.startAngle) <= arcSweep(a) + 1e-12;
-var bulgeToArc = (a, b, bulge) => {
-  if (Math.abs(bulge) < 1e-12) return null;
-  const chord = dist(a, b);
-  if (chord < 1e-12) return null;
-  const sweep = 4 * Math.atan(bulge);
-  const radius = Math.abs(chord / (2 * Math.sin(sweep / 2)));
-  const m = mid(a, b);
-  const dir = scale(sub(b, a), 1 / chord);
-  const h = chord / 2 / Math.tan(sweep / 2);
-  const center = add(m, scale(perp(dir), h));
-  const angA = angle(sub(a, center));
-  const angB = angle(sub(b, center));
-  return bulge > 0 ? { center, radius, startAngle: angA, endAngle: angB } : { center, radius, startAngle: angB, endAngle: angA };
-};
-var bulgeFrom3Points = (a, m, b) => {
-  let turn = angle(sub(b, m)) - angle(sub(m, a));
-  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 d = 2 * (ax * (by - cy) + bx * (cy - ay) + cx * (ay - by));
-  if (Math.abs(d) < 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)) / d,
-    y: (a2 * (cx - bx) + b2 * (ax - cx) + c2 * (bx - ax)) / d
-  };
-  return { center, radius: dist(center, p1) };
-};
-var arcFrom3Points = (start, on, end) => {
-  const c = circleFrom3Points(start, on, end);
-  if (!c) return null;
-  const angS = angle(sub(start, c.center));
-  const angO = angle(sub(on, c.center));
-  const angE = angle(sub(end, c.center));
-  const ccw = {
-    center: c.center,
-    radius: c.radius,
-    startAngle: angS,
-    endAngle: angE
-  };
-  if (angleInArc(ccw, angO)) return ccw;
-  return {
-    center: c.center,
-    radius: c.radius,
-    startAngle: angE,
-    endAngle: angS
-  };
-};
-var closestPointOnArc = (a, p) => {
-  const v = sub(p, a.center);
-  const ang = angle(v);
-  if (angleInArc(a, ang)) return pointOnArc(a, ang);
-  const s = arcStartPoint(a);
-  const e = arcEndPoint(a);
-  return dist(p, s) <= dist(p, e) ? s : e;
-};
-var distToArc = (a, p) => dist(p, closestPointOnArc(a, p));
-var tessellateArc = (a, chordTolerance = 0.1) => {
-  const sweep = arcSweep(a);
-  const maxStep = a.radius <= chordTolerance ? sweep : 2 * Math.acos(Math.max(-1, 1 - chordTolerance / a.radius));
-  const n2 = Math.max(2, Math.ceil(sweep / Math.max(maxStep, 1e-3)));
-  const pts = [];
-  for (let i = 0; i <= n2; i++) {
-    pts.push(pointOnArc(a, a.startAngle + sweep * i / n2));
-  }
-  return pts;
-};
-
 // ../core/src/geometry/ellipse.ts
 var ellipseSweep = (e) => {
   const s = normAngle(e.endAngle - e.startAngle);
@@ -353,12 +293,6 @@ var chainLength = (points, closed) => {
   return sum;
 };
 var polylineArea = (points) => polygonArea(verticesToPolygon(points));
-var hatchArea = (loops) => {
-  const areas = loops.map((l) => polygonArea(verticesToPolygon(l.points)));
-  if (areas.length === 0) return 0;
-  const holes = areas.slice(1).reduce((a, b) => a + b, 0);
-  return Math.max(areas[0] - holes, 0);
-};
 
 // ../core/src/model/document.ts
 import { z as z2 } from "zod";
@@ -366,11 +300,13 @@ import { z as z2 } from "zod";
 // ../core/src/model/paperLayout.ts
 import { z } from "zod";
 var SHEET_PRESETS = {
+  A5: [148, 210],
   A4: [210, 297],
   A3: [297, 420],
   A2: [420, 594],
   A1: [594, 841],
-  A0: [841, 1189]
+  A0: [841, 1189],
+  Letter: [215.9, 279.4]
 };
 var resolveSheetSize = (sheet = "A3", defaultOrientation = "landscape") => {
   if (typeof sheet !== "string" && "width" in sheet)
@@ -421,7 +357,8 @@ var LayerSchema = z2.object({
 });
 var DEFAULT_DOCUMENT_NAME = "Untitled project";
 var DocumentSettingsSchema = z2.object({
-  units: z2.enum(["mm", "in"]).default("mm")
+  units: z2.enum(["mm", "in"]).default("mm"),
+  modelScale: z2.number().positive().default(1)
 });
 var LineaDocumentSchema = z2.preprocess(
   migrateDocument,
@@ -438,7 +375,7 @@ var LineaDocumentSchema = z2.preprocess(
     /** Document-wide settings (`DocumentSettingsSchema`). `units` is
      * declarative for now: geometry is always stored in mm and nothing
      * renders in inches yet. */
-    settings: DocumentSettingsSchema.default({ units: "mm" }),
+    settings: DocumentSettingsSchema.default({ units: "mm", modelScale: 1 }),
     layers: z2.array(LayerSchema).min(1),
     currentLayerId: z2.string(),
     /** Array order is draw order (bottom to top).
@@ -672,10 +609,10 @@ var SvgSink = class {
       transforms.push(
         `translate(${n(tp.x)} ${n(-tp.y)}) scale(${n(w)} 1) translate(${n(-tp.x)} ${n(tp.y)})`
       );
-    const rot2 = transforms.length > 0 ? ` transform="${transforms.join(" ")}"` : "";
+    const rot = transforms.length > 0 ? ` transform="${transforms.join(" ")}"` : "";
     const alpha = t.opacity !== void 0 && t.opacity < 1 ? ` fill-opacity="${n(t.opacity)}"` : "";
     this.els.push(
-      `<text x="${n(tp.x)}" y="${n(-tp.y)}" font-size="${n(t.heightMm / def.capHeight * scale2)}" font-family="${def.cssStack}"${face} fill="${t.color}"${alpha} text-anchor="${anchor}"${rot2}>${escapeXml(t.text)}</text>`
+      `<text x="${n(tp.x)}" y="${n(-tp.y)}" font-size="${n(t.heightMm / def.capHeight * scale2)}" font-family="${def.cssStack}"${face} fill="${t.color}"${alpha} text-anchor="${anchor}"${rot}>${escapeXml(t.text)}</text>`
     );
   }
   measureText(text, heightMm, font, widthFactor) {
@@ -690,10 +627,10 @@ var SvgSink = class {
     });
     const scale2 = Math.hypot(this.m[0], this.m[1]) || 1;
     const deg = -i.rotation * 180 / Math.PI;
-    const rot2 = deg !== 0 ? ` transform="rotate(${n(deg)} ${n(topLeft.x)} ${n(-topLeft.y)})"` : "";
+    const rot = deg !== 0 ? ` transform="rotate(${n(deg)} ${n(topLeft.x)} ${n(-topLeft.y)})"` : "";
     const opacity = i.opacity < 1 ? ` opacity="${n(i.opacity)}"` : "";
     this.els.push(
-      `<image x="${n(topLeft.x)}" y="${n(-topLeft.y)}" width="${n(i.widthMm * scale2)}" height="${n(i.heightMm * scale2)}" preserveAspectRatio="none"${opacity}${rot2} href="${i.data}"/>`
+      `<image x="${n(topLeft.x)}" y="${n(-topLeft.y)}" width="${n(i.widthMm * scale2)}" height="${n(i.heightMm * scale2)}" preserveAspectRatio="none"${opacity}${rot} href="${i.data}"/>`
     );
   }
   pushTransform(m) {
@@ -826,6 +763,22 @@ var paintEllipse = (obj, sink, env) => {
   sink.stroke(env.style);
 };
 
+// ../core/src/paint/painters/spline.ts
+var paintSpline = (obj, sink, env) => {
+  sink.beginPath();
+  const pieces = nurbsToBeziers(obj);
+  if (pieces && pieces.length > 0) {
+    sink.moveTo(pieces[0].start);
+    for (const b of pieces) sink.bezierTo(b.c1, b.c2, b.end);
+  } else {
+    const pts = sampleNurbs(obj, curveTolerance(obj));
+    if (pts.length < 2) return;
+    sink.moveTo(pts[0]);
+    for (let i = 1; i < pts.length; i++) sink.lineTo(pts[i]);
+  }
+  sink.stroke(env.style);
+};
+
 // ../core/src/paint/painters/hatch.ts
 var SINGLE_FAMILY = {
   name: "",
@@ -833,7 +786,7 @@ var SINGLE_FAMILY = {
 };
 var paintSolid = (obj, sink, env) => {
   sink.beginPath();
-  for (const loop of obj.loops) emitVertexPath(sink, loop.points, true);
+  for (const loop of obj.loops) emitLoopPath(sink, loop);
   sink.fill({ color: env.style.color, opacity: env.style.opacity });
 };
 var paintGradient = (obj, fill, sink, env) => {
@@ -842,7 +795,7 @@ var paintGradient = (obj, fill, sink, env) => {
   let maxX = -Infinity;
   let maxY = -Infinity;
   for (const loop of obj.loops)
-    for (const p of loop.points) {
+    for (const p of loopPolygon(loop)) {
       if (p.x < minX) minX = p.x;
       if (p.y < minY) minY = p.y;
       if (p.x > maxX) maxX = p.x;
@@ -865,7 +818,7 @@ var paintGradient = (obj, fill, sink, env) => {
     to = { x: c.x + dir.x * r, y: c.y + dir.y * r };
   }
   sink.beginPath();
-  for (const loop of obj.loops) emitVertexPath(sink, loop.points, true);
+  for (const loop of obj.loops) emitLoopPath(sink, loop);
   sink.fill({
     color: fill.color1,
     opacity: env.style.opacity,
@@ -883,7 +836,7 @@ var paintHatch = (obj, sink, env) => {
   }
   let lines = env.cache?.hatchLines.get(obj);
   if (!lines) {
-    const rings = obj.loops.map((loop) => verticesToPolygon(loop.points));
+    const rings = obj.loops.map((loop) => loopPolygon(loop));
     const s = obj.fill.kind === "pattern" ? obj.fill.scale * obj.scale : obj.scale;
     const pat = obj.fill.kind === "pattern" ? resolveHatchPattern(obj.fill.name, env.hatchPatterns) : void 0;
     const estimate = pat ? estimatePatternSegments(rings, pat, s) : estimatePatternSegments(
@@ -925,50 +878,6 @@ var paintHatch = (obj, sink, env) => {
   });
 };
 
-// ../core/src/paint/painters/arrows.ts
-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/paint/painters/text.ts
 var paintText = (obj, sink, env) => {
   const { font, widthFactor } = effectiveTextFont(obj, env.textStyles);
@@ -984,18 +893,20 @@ var paintText = (obj, sink, env) => {
     )
   };
   const { color, widthMm, opacity } = env.style;
+  const arrowSize = textArrowSize(obj, env.textStyles);
+  const arrowType = textArrowType(obj, env.textStyles);
   for (const line of obj.leaderLines) {
     sink.beginPath();
-    sink.moveTo(line[0]);
+    sink.moveTo(arrowLineStart(line[0], line[1], arrowSize, arrowType));
     for (let i = 1; i < line.length; i++) sink.lineTo(line[i]);
     sink.stroke({ color, widthMm, opacity });
     paintArrowhead(
       sink,
       line[0],
       line[1],
-      textArrowSize(obj, env.textStyles),
+      arrowSize,
       color,
-      textArrowType(obj, env.textStyles),
+      arrowType,
       opacity
     );
   }
@@ -1123,15 +1034,21 @@ var paintDimension = (obj, sink, env) => {
     dashMm: env.style.dashMm,
     opacity: env.style.opacity
   };
+  const trim = (p, other) => {
+    const arrow = geom.arrows.find(
+      (ar) => dist(ar.tip, p) < 1e-9 && dot(sub(ar.toward, ar.tip), sub(other, p)) > 0
+    );
+    return arrow ? arrowLineStart(p, other, arrow.size, geom.arrowType) : p;
+  };
   sink.beginPath();
-  for (const seg of [
-    ...geom.extensionLines,
-    ...geom.dimLines,
-    ...geom.leaders
-  ]) {
+  for (const seg of geom.extensionLines) {
     sink.moveTo(seg.a);
     sink.lineTo(seg.b);
   }
+  for (const seg of [...geom.dimLines, ...geom.leaders]) {
+    sink.moveTo(trim(seg.a, seg.b));
+    sink.lineTo(trim(seg.b, seg.a));
+  }
   if (geom.dimArc) {
     const arc = geom.dimArc;
     sink.moveTo(add(arc.center, scale(fromAngle(arc.startAngle), arc.radius)));
@@ -1246,7 +1163,7 @@ var paintChildren = (children, sink, env, parentLayerId) => {
           // Same width-proportional dash rule as resolveStyle.
           dashMm: scaleDash(
             dashForLineType(child.lineType, env.lineTypes),
-            (child.lineWidth ?? env.style.widthMm) * (child.lineTypeScale ?? 1)
+            (child.lineWidth ?? env.style.widthMm) * (child.lineTypeScale ?? 1) * (env.lineTypeScale ?? 1)
           ) ?? env.style.dashMm,
           opacity: child.opacity ?? env.style.opacity
         },
@@ -1256,6 +1173,7 @@ var paintChildren = (children, sink, env, parentLayerId) => {
         lineTypes: env.lineTypes,
         hatchPatterns: env.hatchPatterns,
         blockDefinitions: env.blockDefinitions,
+        lineTypeScale: env.lineTypeScale,
         resolveObject: env.resolveObject,
         assets: env.assets,
         // A reference child (linked / embedded file) loads like any other.
@@ -1464,6 +1382,17 @@ var buildEllipse = (obj) => {
     ]
   };
 };
+var buildSpline = (obj) => {
+  const pts = sampleNurbs(obj, curveTolerance(obj) / 10);
+  const segments = [];
+  for (let i = 1; i < pts.length; i++)
+    segments.push({ a: pts[i - 1], b: pts[i], facet: true });
+  const points = obj.closed || pts.length < 2 ? [] : [
+    { p: pts[0], type: "endpoint" },
+    { p: pts[pts.length - 1], type: "endpoint" }
+  ];
+  return { bounds: boundsOfPoints(pts), points, segments, arcs: [] };
+};
 var buildHatch = (obj) => {
   let bounds = emptyBounds();
   const points = [];
@@ -1471,12 +1400,11 @@ var buildHatch = (obj) => {
   const arcs = [];
   const rings = [];
   for (const loop of obj.loops) {
-    const curves = verticesToCurves(loop.points, true);
+    const curves = loopCurves(loop);
     segments.push(...curves.segments);
     arcs.push(...curves.arcs);
-    for (const v of loop.points)
-      points.push({ p: { x: v.x, y: v.y }, type: "endpoint" });
-    rings.push(verticesToPolygon(loop.points));
+    for (const p of loopCorners(loop)) points.push({ p, type: "endpoint" });
+    rings.push(loopPolygon(loop));
     bounds = unionBounds(bounds, curveBounds(curves.segments, curves.arcs));
   }
   return { bounds, points, segments, arcs, rings };
@@ -1662,6 +1590,8 @@ var buildEntry = (obj, ctx) => {
     }
     case "ellipse":
       return buildEllipse(obj);
+    case "spline":
+      return buildSpline(obj);
     case "hatch":
       return buildHatch(obj);
     case "text":
@@ -1825,7 +1755,8 @@ var referenceEntry = (obj, ctx) => {
         segments.push({
           a: applyMat(m, kept[0]),
           b: applyMat(m, kept[1]),
-          chord: seg.chord
+          chord: seg.chord,
+          facet: seg.facet
         });
     }
     for (const a of e.arcs) {
@@ -2061,174 +1992,6 @@ var mergeStyles = (existing, incoming, same, opts) => {
   return { styles, idByName, created };
 };
 
-// ../core/src/geometry/nurbs.ts
-var nurbsDomain = (c) => {
-  const n2 = c.controlPoints.length;
-  return [c.knots[c.degree], c.knots[n2]];
-};
-var findSpan = (c, u) => {
-  const n2 = c.controlPoints.length;
-  const p = c.degree;
-  if (u >= c.knots[n2]) return n2 - 1;
-  if (u <= c.knots[p]) return p;
-  let lo = p;
-  let hi = n2;
-  let mid2 = lo + hi >> 1;
-  while (u < c.knots[mid2] || u >= c.knots[mid2 + 1]) {
-    if (u < c.knots[mid2]) hi = mid2;
-    else lo = mid2;
-    mid2 = lo + hi >> 1;
-  }
-  return mid2;
-};
-var evaluateNurbs = (c, u) => {
-  const p = c.degree;
-  const k = findSpan(c, u);
-  const d = [];
-  for (let j = 0; j <= p; j++) {
-    const i = k - p + j;
-    const cp = c.controlPoints[i];
-    const w2 = c.weights?.[i] ?? 1;
-    d.push([cp.x * w2, cp.y * w2, w2]);
-  }
-  for (let r = 1; r <= p; r++)
-    for (let j = p; j >= r; j--) {
-      const i = k - p + j;
-      const den = c.knots[i + p - r + 1] - c.knots[i];
-      const a = den === 0 ? 0 : (u - c.knots[i]) / den;
-      d[j] = [
-        (1 - a) * d[j - 1][0] + a * d[j][0],
-        (1 - a) * d[j - 1][1] + a * d[j][1],
-        (1 - a) * d[j - 1][2] + a * d[j][2]
-      ];
-    }
-  const [x, y, w] = d[p];
-  return w === 0 ? { x, y } : { x: x / w, y: y / w };
-};
-var isValidNurbs = (c) => c.degree >= 1 && c.controlPoints.length > c.degree && c.knots.length === c.controlPoints.length + c.degree + 1 && (c.weights === void 0 || c.weights.length === c.controlPoints.length) && c.knots.every((v, i) => i === 0 || v >= c.knots[i - 1]);
-var sampleNurbs = (c, tolerance, maxDepth = 10) => {
-  const [u0, u1] = nurbsDomain(c);
-  const out = [evaluateNurbs(c, 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 = (a, pa, b, pb, depth) => {
-    const m = (a + b) / 2;
-    const pm = evaluateNurbs(c, m);
-    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(a, pa, m, pm, depth + 1);
-    refine(m, pm, b, pb, depth + 1);
-  };
-  const spans = [];
-  for (let i = c.degree; i < c.controlPoints.length; i++) {
-    const a = Math.max(c.knots[i], u0);
-    const b = Math.min(c.knots[i + 1], u1);
-    if (b > a) spans.push(a, b);
-  }
-  for (let i = 0; i < spans.length; i += 2) {
-    const a = spans[i];
-    const b = spans[i + 1];
-    const pa = evaluateNurbs(c, a);
-    const pb = evaluateNurbs(c, b);
-    const m = (a + b) / 2;
-    const pm = evaluateNurbs(c, m);
-    refine(a, pa, m, pm, 1);
-    refine(m, 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 a = out[out.length - 1];
-    const b = pts[i + 1];
-    const q = pts[i];
-    const abx = b.x - a.x;
-    const aby = b.y - a.y;
-    const len2 = abx * abx + aby * aby;
-    const t = len2 === 0 ? 0 : Math.max(
-      0,
-      Math.min(1, ((q.x - a.x) * abx + (q.y - a.y) * aby) / len2)
-    );
-    const dist2 = Math.hypot(q.x - (a.x + t * abx), q.y - (a.y + t * aby));
-    if (dist2 > eps) out.push(q);
-  }
-  out.push(pts[pts.length - 1]);
-  return out;
-};
-var interpolateFitPoints = (points, degree = 3) => {
-  const n2 = points.length;
-  if (n2 < 2) return null;
-  const p = Math.min(degree, n2 - 1);
-  const u = [0];
-  let total2 = 0;
-  for (let i = 1; i < n2; i++) {
-    total2 += Math.hypot(
-      points[i].x - points[i - 1].x,
-      points[i].y - points[i - 1].y
-    );
-    u.push(total2);
-  }
-  if (total2 === 0) return null;
-  for (let i = 0; i < n2; i++) u[i] /= total2;
-  const knots = new Array(p + 1).fill(0);
-  for (let j = 1; j <= n2 - p - 1; j++) {
-    let s = 0;
-    for (let i = j; i <= j + p - 1; i++) s += u[i];
-    knots.push(s / p);
-  }
-  knots.push(...new Array(p + 1).fill(1));
-  const basisRow = (ui) => {
-    const row = new Array(n2).fill(0);
-    const probe = {
-      degree: p,
-      controlPoints: points.map(() => ({ x: 0, y: 0 })),
-      knots
-    };
-    for (let j = 0; j < n2; j++) {
-      probe.controlPoints = points.map((_, k) => ({
-        x: k === j ? 1 : 0,
-        y: 0
-      }));
-      row[j] = evaluateNurbs(probe, ui).x;
-    }
-    return row;
-  };
-  const A = u.map((ui) => basisRow(ui));
-  const bx = points.map((q) => q.x);
-  const by = points.map((q) => q.y);
-  for (let col = 0; col < n2; col++) {
-    let pivot = col;
-    for (let r = col + 1; r < n2; 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 < n2; r++) {
-      if (r === col) continue;
-      const k = A[r][col] / A[col][col];
-      if (k === 0) continue;
-      for (let c = col; c < n2; c++) A[r][c] -= k * A[col][c];
-      bx[r] -= k * bx[col];
-      by[r] -= k * by[col];
-    }
-  }
-  const controlPoints = points.map((_, i) => ({
-    x: bx[i] / A[i][i],
-    y: by[i] / A[i][i]
-  }));
-  return { degree: p, controlPoints, knots };
-};
-
 // ../core/src/geometry/band.ts
 var left = (d) => ({ x: -d.y, y: d.x });
 var unit = (a, b) => {
@@ -3202,7 +2965,6 @@ var unitFactor = (insunits) => {
   }
 };
 var IMPORT_LINE_WIDTH_MM = 0.25;
-var SPLINE_TOLERANCE_MM = 0.02;
 var TEXT_TYPES = /* @__PURE__ */ new Set(["TEXT", "MTEXT", "ATTRIB", "ATTDEF"]);
 var DIM_TYPES = /* @__PURE__ */ new Set(["DIMENSION", "LEADER"]);
 var scanTags = (lines) => {
@@ -3412,48 +3174,55 @@ var baseFor = (e, ctx) => {
     hidden: false
   };
 };
-var hatchLoopPoints = (path, f, mirrored) => {
-  const points = hatchLoopPointsOcs(path, f);
-  return mirrored ? points.map((p) => ({ x: -p.x, y: p.y, bulge: -p.bulge })) : points;
-};
-var HATCH_ELLIPSE_TOLERANCE_MM = 0.1;
-var hatchLoopPointsOcs = (path, f) => {
-  if (path.isPolyline) {
-    return (path.vertices ?? []).map((v) => ({
-      x: v.x * f,
-      y: v.y * f,
-      bulge: v.bulge ?? 0
-    }));
-  }
-  const points = [];
-  const push = (x, y, bulge = 0) => points.push({ x: x * f, y: y * f, bulge });
+var hatchLoopEdges = (path, f, mirrored) => {
+  const edges = hatchLoopEdgesOcs(path, f);
+  if (!mirrored || edges.length === 0) return edges;
+  const reflected = mirrorObject(
+    {
+      type: "hatch",
+      id: "",
+      layerId: "",
+      loops: [{ edges }],
+      fill: { kind: "solid" },
+      scale: 1
+    },
+    { x: 0, y: 0 },
+    { x: 0, y: 1 }
+  );
+  return reflected.loops[0].edges;
+};
+var hatchLoopEdgesOcs = (path, f) => {
+  const pt2 = (p) => ({ x: p.x * f, y: p.y * f });
+  if (path.isPolyline)
+    return verticesToLoop(
+      (path.vertices ?? []).map((v) => ({
+        ...pt2(v),
+        bulge: v.bulge ?? 0
+      }))
+    ).edges;
+  const edges = [];
   for (const edge of path.edges ?? []) {
     switch (edge.kind) {
       case 1: {
-        const p = edge.points[0];
-        if (p) push(p.x, p.y);
+        const a = edge.points[0];
+        const b = edge.end;
+        if (a && b) edges.push({ kind: "line", a: pt2(a), b: pt2(b) });
         break;
       }
       case 2: {
         const c = edge.points[0];
         if (!c || !(edge.r40 > 0)) break;
-        const ccw = edge.ccw !== false;
         const a0 = (edge.startAngle ?? 0) * DEG2RAD;
-        let a1 = (edge.endAngle ?? 360) * DEG2RAD;
-        if (a1 <= a0 + 1e-12) a1 += Math.PI * 2;
-        const sweep = Math.min(a1 - a0, Math.PI * 2);
-        const sign = ccw ? 1 : -1;
-        const start = sign * a0;
-        const pieces = sweep > Math.PI + 1e-9 ? 2 : 1;
-        const bulge = sign * Math.tan(sweep / pieces / 4);
-        for (let i = 0; i < pieces; i++) {
-          const ang = start + sign * sweep * i / pieces;
-          push(
-            c.x + edge.r40 * Math.cos(ang),
-            c.y + edge.r40 * Math.sin(ang),
-            bulge
-          );
-        }
+        const a1 = (edge.endAngle ?? 360) * DEG2RAD;
+        const ccw = edge.ccw !== false;
+        const full = Math.abs(a1 - a0) >= Math.PI * 2 - 1e-9;
+        edges.push({
+          kind: "arc",
+          center: pt2(c),
+          radius: edge.r40 * f,
+          startAngle: ccw ? a0 : -a1,
+          endAngle: full ? ccw ? a0 : -a1 : ccw ? a1 : -a0
+        });
         break;
       }
       case 3: {
@@ -3463,29 +3232,21 @@ var hatchLoopPointsOcs = (path, f) => {
         const ratio = edge.r40 > 0 ? edge.r40 : 1;
         const ccw = edge.ccw !== false;
         const a0 = (edge.startAngle ?? 0) * DEG2RAD;
-        let a1 = (edge.endAngle ?? 360) * DEG2RAD;
-        if (a1 <= a0 + 1e-12) a1 += Math.PI * 2;
-        const sweep = Math.min(a1 - a0, Math.PI * 2);
-        const sign = ccw ? 1 : -1;
-        const L = Math.hypot(major.x, major.y);
-        const tol = HATCH_ELLIPSE_TOLERANCE_MM / f;
-        const maxStep = L <= tol ? sweep : 2 * Math.acos(Math.max(-1, 1 - tol / L));
-        const n2 = Math.max(8, Math.ceil(sweep / Math.max(maxStep, 1e-3)));
-        for (let i = 0; i < n2; i++) {
-          const theta = sign * (a0 + sweep * i / n2);
-          const t = Math.atan2(Math.sin(theta) / ratio, Math.cos(theta));
-          push(
-            c.x + major.x * Math.cos(t) - major.y * ratio * Math.sin(t),
-            c.y + major.y * Math.cos(t) + major.x * ratio * Math.sin(t)
-          );
-        }
+        const a1 = (edge.endAngle ?? 360) * DEG2RAD;
+        const full = Math.abs(a1 - a0) >= Math.PI * 2 - 1e-9;
+        const param = (theta) => Math.atan2(Math.sin(theta) / ratio, Math.cos(theta));
+        edges.push({
+          kind: "ellipse",
+          center: pt2(c),
+          majorAxis: pt2(major),
+          ratio: Math.min(1, ratio),
+          startAngle: full ? 0 : param(ccw ? a0 : -a1),
+          endAngle: full ? Math.PI * 2 : param(ccw ? a1 : -a0)
+        });
         break;
       }
       case 4: {
-        const control = (edge.points ?? []).map((p) => ({
-          x: p.x,
-          y: p.y
-        }));
+        const control = (edge.points ?? []).map(pt2);
         const weights = edge.weights ?? [];
         const curve = {
           degree: edge.degree ?? 3,
@@ -3493,36 +3254,24 @@ var hatchLoopPointsOcs = (path, f) => {
           knots: edge.knots ?? [],
           ...edge.rational && weights.length === control.length ? { weights } : {}
         };
-        const fit = (edge.fitPoints ?? []).map((p) => ({
-          x: p.x,
-          y: p.y
-        }));
-        const fitted = isValidNurbs(curve) ? null : interpolateFitPoints(fit);
-        const sampled = isValidNurbs(curve) ? sampleNurbs(curve, SPLINE_TOLERANCE_MM / f) : fitted ? sampleNurbs(fitted, SPLINE_TOLERANCE_MM / f) : fit.length >= 2 ? fit : control;
-        for (const p of sampled.slice(0, -1)) push(p.x, p.y);
+        const fit = (edge.fitPoints ?? []).map(pt2);
+        const exact = isValidNurbs(curve) ? curve : interpolateFitPoints(fit);
+        if (exact) {
+          edges.push({
+            kind: "spline",
+            ...exact,
+            ...fit.length >= 2 ? { fitPoints: fit } : {}
+          });
+          break;
+        }
+        const poly = fit.length >= 2 ? fit : control;
+        for (let i = 1; i < poly.length; i++)
+          edges.push({ kind: "line", a: poly[i - 1], b: poly[i] });
         break;
       }
     }
   }
-  return points.filter(
-    (p, i) => i === 0 || Math.abs(p.x - points[i - 1].x) > 1e-9 || Math.abs(p.y - points[i - 1].y) > 1e-9 || points[i - 1].bulge !== 0
-  );
-};
-var atLeastThreeVertices = (points) => {
-  if (points.length !== 2 || points.every((p) => p.bulge === 0)) return points;
-  const out = [];
-  for (let i = 0; i < 2; i++) {
-    const a = points[i];
-    const b = points[1 - i];
-    out.push(a);
-    const arc = a.bulge === 0 ? null : bulgeToArc(a, b, a.bulge);
-    if (!arc) continue;
-    const half = Math.tan(Math.atan(a.bulge) / 2);
-    const mid2 = arcMidPoint(arc);
-    out[out.length - 1] = { ...a, bulge: half };
-    out.push({ x: mid2.x, y: mid2.y, bulge: half });
-  }
-  return out;
+  return edges;
 };
 var convertHatch = (e, ctx) => {
   const anyE = e;
@@ -3530,8 +3279,8 @@ var convertHatch = (e, ctx) => {
   const mirrored = ctx.tags.mirroredHandles.has(String(anyE.handle));
   const flip = mirrored ? -1 : 1;
   const loops = (anyE.boundaryPaths ?? []).map((path) => ({
-    points: atLeastThreeVertices(hatchLoopPoints(path, ctx.f, mirrored))
-  })).filter((loop) => loop.points.length >= 3);
+    edges: hatchLoopEdges(path, ctx.f, mirrored)
+  })).filter((loop) => loop.edges.length > 0);
   if (loops.length === 0) return [];
   let fill;
   const patternMatch = typeof anyE.patternName === "string" ? getHatchPattern(anyE.patternName) : void 0;
@@ -3995,9 +3744,9 @@ var convertEntityInner = (e, dxf, ctx) => {
           return [
             {
               type: "hatch",
-              loops: loops.map((l) => ({
-                points: l.map((p) => ({ ...p, bulge: 0 }))
-              })),
+              loops: loops.map(
+                (l) => verticesToLoop(l.map((p) => ({ ...p, bulge: 0 })))
+              ),
               fill: { kind: "solid" },
               scale: 1,
               ...base
@@ -4127,32 +3876,46 @@ var convertEntityInner = (e, dxf, ctx) => {
     case "SPLINE": {
       const control = anyE.controlPoints ?? [];
       const weights = ctx.tags.splineWeightsByHandle.get(String(anyE.handle));
+      const fit = (anyE.fitPoints ?? []).map((p) => ({
+        x: p.x * f,
+        y: p.y * f
+      }));
       const curve = {
         degree: anyE.degreeOfSplineCurve ?? 3,
-        controlPoints: control.map((p) => ({ x: p.x, y: p.y })),
+        controlPoints: control.map((p) => ({ x: p.x * f, y: p.y * f })),
         knots: anyE.knotValues ?? [],
         ...weights && weights.length === control.length ? { weights } : {}
       };
-      const fit = anyE.fitPoints ?? [];
-      const fitted = isValidNurbs(curve) ? null : interpolateFitPoints(fit.map((p) => ({ x: p.x, y: p.y })));
-      let points;
-      if (isValidNurbs(curve)) {
-        points = sampleNurbs(curve, SPLINE_TOLERANCE_MM / f);
-        bump(ctx.degraded, "SPLINE\u2192polyline");
-      } else if (fitted) {
-        points = sampleNurbs(fitted, SPLINE_TOLERANCE_MM / f);
-        bump(ctx.degraded, "SPLINE\u2192polyline (fit points)");
-      } else {
-        const raw = fit.length >= 2 ? fit : control;
-        if (raw.length < 2) return [];
-        points = raw.map((p) => ({ x: p.x, y: p.y }));
-        bump(ctx.degraded, "SPLINE\u2192polyline (control points)");
-      }
-      if (points.length < 2) return [];
+      const tangent = (t) => t && Math.hypot(t.x, t.y) > 1e-12 ? { x: t.x, y: t.y } : void 0;
+      const startTangent = tangent(anyE.startTangent);
+      const endTangent = tangent(anyE.endTangent);
+      const closed = anyE.closed === true;
+      const fitted = isValidNurbs(curve) ? curve : closed ? interpolateClosed(fit) : interpolateFitPoints(fit, 3, {
+        start: startTangent,
+        end: endTangent
+      });
+      if (fitted && isValidNurbs(fitted))
+        return [
+          {
+            type: "spline",
+            degree: fitted.degree,
+            controlPoints: fitted.controlPoints,
+            knots: fitted.knots,
+            ...fitted.weights ? { weights: fitted.weights } : {},
+            ...fit.length >= 2 ? { fitPoints: fit } : {},
+            ...fit.length >= 2 && !closed && startTangent ? { startTangent } : {},
+            ...fit.length >= 2 && !closed && endTangent ? { endTangent } : {},
+            closed,
+            ...base
+          }
+        ];
+      const raw = fit.length >= 2 ? fit : control.map((p) => ({ x: p.x * f, y: p.y * f }));
+      if (raw.length < 2) return [];
+      bump(ctx.degraded, "SPLINE\u2192polyline (control points)");
       return [
         {
           type: "polyline",
-          points: points.map((p) => ({ x: p.x * f, y: p.y * f, bulge: 0 })),
+          points: raw.map((p) => ({ x: p.x, y: p.y, bulge: 0 })),
           closed: anyE.closed === true,
           ...base
         }
@@ -4167,7 +3930,9 @@ var convertEntityInner = (e, dxf, ctx) => {
       return [
         {
           type: "hatch",
-          loops: [{ points: points.map((p) => ({ ...pt(p, f), bulge: 0 })) }],
+          loops: [
+            verticesToLoop(points.map((p) => ({ ...pt(p, f), bulge: 0 })))
+          ],
           fill: { kind: "solid" },
           scale: 1,
           ...base
@@ -4183,9 +3948,7 @@ var convertEntityInner = (e, dxf, ctx) => {
         {
           type: "hatch",
           loops: [
-            {
-              points: ordered.map((p) => ({ ...ocs(p), bulge: 0 }))
-            }
+            verticesToLoop(ordered.map((p) => ({ ...ocs(p), bulge: 0 })))
           ],
           fill: { kind: "solid" },
           scale: 1,
@@ -4397,7 +4160,7 @@ var convertInsertInner = (e, dxf, ctx, depth, inheritedColor) => {
   const sx = anyE.xScale ?? 1;
   const sy = (anyE.yScale ?? 1) * (mirrored ? -1 : 1);
   const rot0 = (anyE.rotation ?? 0) * DEG2RAD;
-  const rot2 = mirrored ? Math.PI - rot0 : rot0;
+  const rot = mirrored ? Math.PI - rot0 : rot0;
   const pos = anyE.position ?? { x: 0, y: 0 };
   const insert = mirrored ? { x: -pos.x * ctx.f, y: pos.y * ctx.f } : pt(pos, ctx.f);
   if (e.type === "INSERT" && depth === 0 && !mirrored && sx > 0 && sy > 0 && Math.abs(sx - sy) < 1e-9) {
@@ -4408,7 +4171,7 @@ var convertInsertInner = (e, dxf, ctx, depth, inheritedColor) => {
           type: "block",
           definitionId: def.id,
           inputs: [insert],
-          rotation: rot2,
+          rotation: rot,
           scale: sx,
           params: {},
           ...baseFor(e, ctx)
@@ -4417,8 +4180,8 @@ var convertInsertInner = (e, dxf, ctx, depth, inheritedColor) => {
   }
   if (e.type === "INSERT" && depth === 0) bump(ctx.degraded, "INSERT\u2192exploded");
   const base = pt(block.position ?? { x: 0, y: 0 }, ctx.f);
-  const cos = Math.cos(rot2);
-  const sin = Math.sin(rot2);
+  const cos = Math.cos(rot);
+  const sin = Math.sin(rot);
   const reflect = sx * sy < 0;
   const meanScale = Math.sqrt(Math.abs(sx * sy)) || 1e-6;
   const lin = (v) => ({
@@ -4471,7 +4234,7 @@ var convertInsertInner = (e, dxf, ctx, depth, inheritedColor) => {
           return t;
         }
         const majorLen = Math.max(ax, ay);
-        const ang = rot2 + (ax >= ay ? 0 : Math.PI / 2);
+        const ang = rot + (ax >= ay ? 0 : Math.PI / 2);
         return {
           type: "ellipse",
           center,
@@ -4519,7 +4282,18 @@ var convertInsertInner = (e, dxf, ctx, depth, inheritedColor) => {
         return t;
       case "hatch": {
         t.loops = t.loops.map((loop) => ({
-          points: mapBulged(loop.points, true)
+          edges: loop.edges.flatMap((edge) => {
+            const { kind, ...geometry } = edge;
+            const moved = transform({
+              ...geometry,
+              type: kind,
+              layerId: t.layerId
+            });
+            if (!moved || moved.type !== kind) return [];
+            const out = { kind };
+            for (const key of Object.keys(geometry)) out[key] = moved[key];
+            return [out];
+          })
         }));
         if (t.fill.kind === "pattern" || t.fill.kind === "lines") {
           const d = lin({
@@ -4536,9 +4310,15 @@ var convertInsertInner = (e, dxf, ctx, depth, inheritedColor) => {
         }
         return t;
       }
+      case "spline":
+        t.controlPoints = t.controlPoints.map(map);
+        if (t.fitPoints) t.fitPoints = t.fitPoints.map(map);
+        if (t.startTangent) t.startTangent = lin(t.startTangent);
+        if (t.endTangent) t.endTangent = lin(t.endTangent);
+        return t;
       case "text":
         t.position = map(t.position);
-        t.rotation += rot2;
+        t.rotation += rot;
         if (meanScale !== 1) {
           const style = t.styleId && ctx.textStyleById.get(t.styleId) || ctx.defaultTextStyle;
           const o = t.styleOverride ?? {};
@@ -5148,7 +4928,7 @@ var FALLBACK_STYLE = {
   color: "#e8e8e8",
   widthMm: 0.25
 };
-var resolveStyle = (obj, layers, lineTypes) => {
+var resolveStyle = (obj, layers, lineTypes, lineTypeScale = 1) => {
   const layer = layers.find((l) => l.id === obj.layerId);
   const widthMm = obj.lineWidth ?? layer?.lineWidth ?? FALLBACK_STYLE.widthMm;
   return {
@@ -5156,10 +4936,11 @@ var resolveStyle = (obj, layers, lineTypes) => {
     widthMm,
     // Dash patterns are defined per 1 mm of line width (ISO 128 style —
     // pattern legibility tracks stroke weight), so the resolved lineweight
-    // scales them; lineTypeScale (CELTSCALE) multiplies on top.
+    // scales them; lineTypeScale (CELTSCALE) and the model scale multiply
+    // on top.
     dashMm: scaleDash(
       dashForLineType(obj.lineType ?? layer?.lineType, lineTypes),
-      widthMm * (obj.lineTypeScale ?? 1)
+      widthMm * (obj.lineTypeScale ?? 1) * lineTypeScale
     ),
     opacity: obj.opacity ?? layer?.opacity
   };
@@ -5176,7 +4957,7 @@ var rebaseSink = (sink, origin) => {
     lineTo: (p) => sink.lineTo(at(p)),
     bezierTo: (c1, c2, end) => sink.bezierTo(at(c1), at(c2), at(end)),
     arc: (center, r, a0, a1, ccw) => sink.arc(at(center), r, a0, a1, ccw),
-    ellipse: (center, rx, ry, rot2, a0, a1) => sink.ellipse(at(center), rx, ry, rot2, a0, a1),
+    ellipse: (center, rx, ry, rot, a0, a1) => sink.ellipse(at(center), rx, ry, rot, a0, a1),
     closePath: () => sink.closePath(),
     stroke: (s) => sink.stroke(s),
     fill: (f) => sink.fill(
@@ -5264,7 +5045,8 @@ var paintReference = (obj, sink, env) => {
     const own = resolveStyle(
       child,
       content.layers,
-      content.lineTypes
+      content.lineTypes,
+      env.lineTypeScale
     );
     paintObject(child, out, {
       // A highlight paints the whole reference in one style.
@@ -5333,6 +5115,7 @@ var painters = {
   circle: paintCircle,
   arc: paintArc,
   ellipse: paintEllipse,
+  spline: paintSpline,
   hatch: paintHatch,
   text: paintText,
   dimension: paintDimension,
@@ -5580,6 +5363,7 @@ var extractCommandMeta = (mod) => {
   };
 };
 var compileCache = /* @__PURE__ */ new Map();
+onSandboxReset(() => compileCache.clear());
 var COMPILE_CACHE_MAX = 100;
 var compileCommand = (script) => {
   const cached = compileCache.get(script);
@@ -5588,16 +5372,24 @@ var compileCommand = (script) => {
     compileCache.set(script, cached);
     return cached;
   }
-  const mod = executeScriptModule(script);
-  const meta = extractCommandMeta(mod);
-  const run = mod.run;
-  if (typeof run !== "function")
-    throw new Error("Command script must export a `run` function");
+  const mod = executeScriptModule(script, "command");
+  let meta;
+  try {
+    meta = extractCommandMeta(mod);
+    if (typeof mod.run !== "function")
+      throw new Error("Command script must export a `run` function");
+  } catch (e) {
+    releaseScriptModule(mod);
+    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).mod);
+      compileCache.delete(oldest);
+    }
   }
-  const compiled = { meta, run };
+  const compiled = { mod, meta, run: mod.run };
   compileCache.set(script, compiled);
   return compiled;
 };
@@ -6789,12 +6581,19 @@ var renderModelToSvg = (model, opts = {}) => {
   const origin = far ? { x: bbox.minX, y: bbox.minY } : { x: 0, y: 0 };
   const out = rebaseSink(sink, origin);
   for (const obj of toPaint) {
-    const style = resolveStyle(obj, model.layers, model.lineTypes);
+    const lineTypeScale = opts.lineTypeScale ?? 1;
+    const style = resolveStyle(
+      obj,
+      model.layers,
+      model.lineTypes,
+      lineTypeScale
+    );
     sink.beginObject(obj.id, layerName.get(obj.layerId));
     paintObject(obj, out, {
       style: { ...style, color: mapColor(style.color) },
       ...model,
-      mapColor
+      mapColor,
+      lineTypeScale
     });
     sink.endObject();
   }
@@ -6805,7 +6604,12 @@ var renderModelToSvg = (model, opts = {}) => {
       maxX: bbox.maxX - origin.x,
       maxY: bbox.maxY - origin.y
     },
-    opts.padding
+    // Default: 2% of the frame (at least 5 mm), so strokes and arrowheads
+    // at the extents aren't cut by the image edge.
+    opts.padding ?? Math.max(
+      5,
+      0.02 * Math.max(bbox.maxX - bbox.minX, bbox.maxY - bbox.minY)
+    )
   );
 };
 var FAR_MM = 1e7;
@@ -8379,17 +8183,188 @@ var DocumentKernel = class {
 
 // ../core/src/drawing/localDrawing.ts
 import { z as z6 } from "zod";
+
+// ../core/src/drawing/inputChecks.ts
+var DrawingError = class extends Error {
+  code;
+  issues;
+  constructor(code, message, issues) {
+    super(message);
+    this.code = code;
+    if (issues) this.issues = issues;
+  }
+};
+var MAX_COORDINATE_MM = 1e9;
+var STYLE_OVERRIDE_KEYS = {
+  text: TextStyleOverrideSchema.shape,
+  table: TextStyleOverrideSchema.shape,
+  dimension: DimStyleOverrideSchema.shape
+};
+var hintFor = (type, key) => {
+  if (type && key in (STYLE_OVERRIDE_KEYS[type] ?? {}))
+    return ` \u2014 style keys go in styleOverride: { ${key}: \u2026 }`;
+  if (type === "layer" && key === "hidden") return " \u2014 use visible: false";
+  if (type === "dimension" && (key === "upVector" || key === "linePoint"))
+    return " \u2014 `offset` is the signed distance of the dimension line";
+  if (type === "dimension" && key === "textOverride")
+    return " \u2014 use labels[i].content (with {value} for the measurement)";
+  return "";
+};
+var assertNoUnknownKeys = (sent, parsed, context, type) => {
+  const unknown = Object.keys(sent).filter(
+    (k) => sent[k] !== void 0 && !(k in parsed)
+  );
+  if (unknown.length > 0)
+    throw new DrawingError(
+      "unknownField",
+      `${context}: unknown field(s) ${unknown.map((k) => `"${k}"${hintFor(type, k)}`).join(", ")}`
+    );
+};
+var assertSaneNumbers = (value, context) => {
+  const walk = (v, path) => {
+    if (typeof v === "number") {
+      if (Math.abs(v) > MAX_COORDINATE_MM)
+        throw new DrawingError(
+          "outOfRange",
+          `${context}: ${path || "value"} = ${v} is out of range (|value| \u2264 ${MAX_COORDINATE_MM} mm)`
+        );
+    } else if (Array.isArray(v)) v.forEach((x, i) => walk(x, `${path}[${i}]`));
+    else if (v !== null && typeof v === "object")
+      for (const [k, x] of Object.entries(v))
+        walk(x, path ? `${path}.${k}` : k);
+  };
+  walk(value, "");
+};
+var knownLineType = (name, sources) => resolveLineType(name, sources.lineTypes) !== void 0 || getLineType(name) !== void 0;
+var knownFont = (font) => (font.includes(";") ? font.slice(0, font.indexOf(";")) : font) in FONTS;
+var fontList = Object.keys(FONTS).join(", ");
+var assertLineType = (name, sources, context) => {
+  if (name !== void 0 && !knownLineType(name, sources))
+    throw new DrawingError(
+      "unknownLineType",
+      `${context}: unknown line type "${name}" (the built-in catalogue or linea_list_line_types)`
+    );
+};
+var assertFont = (font, context) => {
+  if (typeof font === "string" && !knownFont(font))
+    throw new DrawingError(
+      "unknownFont",
+      `${context}: unknown font "${font}" (one of ${fontList})`
+    );
+};
+var assertObjectFields = (obj, fields, sources, context) => {
+  const o = obj;
+  if (fields.has("lineType"))
+    assertLineType(o.lineType, sources, context);
+  if (fields.has("font")) assertFont(o.font, context);
+  if (fields.has("styleOverride"))
+    assertFont(
+      o.styleOverride?.font,
+      context
+    );
+  if (obj.type === "hatch" && fields.has("fill") && obj.fill.kind === "pattern") {
+    if (!resolveHatchPattern(obj.fill.name, sources.hatchPatterns))
+      throw new DrawingError(
+        "unknownHatchPattern",
+        `${context}: unknown hatch pattern "${obj.fill.name}" (the built-in catalogue or linea_list_hatch_patterns)`
+      );
+  }
+  if (obj.type === "text" && (fields.has("spans") || fields.has("content")))
+    for (const [i, s] of (obj.spans ?? []).entries()) {
+      if (s.end > obj.content.length || s.start >= s.end)
+        throw new DrawingError(
+          "invalidSpan",
+          `${context}: spans[${i}] ${s.start}\u2013${s.end} must satisfy start < end \u2264 ${obj.content.length} (the content's length)`
+        );
+      assertFont(s.font, `${context}: spans[${i}]`);
+    }
+  if (obj.type === "block" && fields.has("params"))
+    assertBlockParams(obj, sources, context);
+};
+var assertBlockParams = (obj, sources, context) => {
+  let script;
+  try {
+    script = findBlockScript(sources.blockDefinitions, obj.definitionId);
+  } catch {
+    return;
+  }
+  if (!script) return;
+  const meta = getBlockMetaResult(script);
+  if (!meta.ok) return;
+  const defs = valueParams(meta.meta.params);
+  for (const [name, value] of Object.entries(obj.params ?? {})) {
+    const def = defs.find((d) => d.name === name);
+    if (!def)
+      throw new DrawingError(
+        "invalidParam",
+        `${context}: block "${obj.definitionId}" has no parameter "${name}"${defs.length ? ` (declares ${defs.map((d) => d.name).join(", ")})` : ""}`
+      );
+    const mismatch = paramMismatch(def, value);
+    if (mismatch)
+      throw new DrawingError(
+        "invalidParam",
+        `${context}: parameter "${name}" \u2014 ${mismatch}`
+      );
+  }
+};
+
+// ../core/src/drawing/localDrawing.ts
 var toVec = (p) => Vec2Schema.parse(p);
+var refuseRejected = (report, kind) => {
+  if (report.rejected.length === 0) return;
+  const lines = report.rejected.map(
+    (r, i) => `${i + 1}) ${scanScriptId(r.script, /define(Block|Command)\(|export\s+default\s*\{/) ?? "(no id)"}: ${r.error}`
+  );
+  throw Object.assign(
+    new Error(
+      `${report.rejected.length} ${kind} source(s) rejected, so none were added:
+${lines.join("\n")}`
+    ),
+    { code: "moduleRejected" }
+  );
+};
+var checkedStyle = (schema, full, sent, context) => {
+  let style;
+  try {
+    style = schema.parse(full);
+  } catch (e) {
+    throw wrapZod(e, context);
+  }
+  assertNoUnknownKeys(sent, style, context);
+  if ("font" in sent) assertFont(sent.font, context);
+  return style;
+};
+var assertDataUrl = (dataUrl) => {
+  const m = /^data:([\w.+-]+\/[\w.+-]+)(;[^,]*)?;base64,([A-Za-z0-9+/]*={0,2})$/.exec(
+    dataUrl
+  );
+  if (!m)
+    throw new DrawingError(
+      "invalidAsset",
+      "An asset must be a base64 data URL (data:<type>;base64,...)"
+    );
+  const bytes = Math.floor(m[3].length * 3 / 4) - (m[3].match(/=/g)?.length ?? 0);
+  if (bytes < 16)
+    throw new DrawingError(
+      "invalidAsset",
+      `The ${m[1]} data URL holds only ${bytes} bytes, not a real file`
+    );
+};
+var MAX_COPIES = 1e4;
 var wrapZod = (e, context) => {
   if (!(e instanceof z6.ZodError))
     return e instanceof Error ? e : new Error(String(e));
-  return new Error(`${context}: ${z6.prettifyError(e)}`);
+  return new DrawingError(
+    "validation",
+    `${context}: ${z6.prettifyError(e)}`,
+    e.issues
+  );
 };
 var PDF_PAGE_GAP_MM = 50;
 var selectPdfLayouts = (layouts, opts, fallback) => {
   const byRef = (ref) => {
     const l = layouts.find((x) => x.name === ref || x.id === ref);
-    if (!l) throw new Error(`Unknown layout "${ref}"`);
+    if (!l) throw new DrawingError("unknownLayout", `Unknown layout "${ref}"`);
     return l;
   };
   let selected = opts.layouts !== void 0 ? opts.layouts.map(byRef) : layouts.length > 0 ? [...layouts] : [fallback()];
@@ -8496,11 +8471,6 @@ var kernelHooks = (doc) => {
     revision: () => rev
   };
 };
-var withVisible = (layer) => {
-  const { hidden, ...rest } = layer;
-  if (hidden === void 0) return layer;
-  return { ...rest, visible: !hidden };
-};
 var LocalDrawing = class {
   hooks;
   /** Schema-version migration applied on open; null when none was needed. */
@@ -8556,7 +8526,7 @@ var LocalDrawing = class {
   findObject(id) {
     const doc = this.state;
     const obj = resolveDocumentObject(doc, id);
-    if (!obj) throw new Error(`Unknown object "${id}"`);
+    if (!obj) throw new DrawingError("unknownObject", `Unknown object "${id}"`);
     const layout = doc.layouts.find((l) => l.objects.includes(obj));
     return { obj, space: layout ? { layoutId: layout.id } : "model" };
   }
@@ -8638,8 +8608,11 @@ var LocalDrawing = class {
       (l) => l.name.toLowerCase() === layer.name.toLowerCase()
     );
     if (clash)
-      throw new Error(`addLayer(): layer "${clash.name}" already exists`);
-    const full = LayerSchema.parse(withVisible(layer));
+      throw new DrawingError(
+        "duplicateName",
+        `Layer "${clash.name}" already exists`
+      );
+    const full = this.checkedLayer(layer, layer, "add layer");
     this.applyForward({ type: "add-layer", layer: full });
     return full.id;
   }
@@ -8647,7 +8620,8 @@ var LocalDrawing = class {
     const l = this.state.layers.find(
       (x) => x.id === nameOrId || x.name === nameOrId
     );
-    if (!l) throw new Error(`Unknown layer "${nameOrId}"`);
+    if (!l)
+      throw new DrawingError("unknownLayer", `Unknown layer "${nameOrId}"`);
     return l;
   }
   /** Patch a layer (rename, color, lineWidth, visible, locked) by name or id. */
@@ -8658,13 +8632,36 @@ var LocalDrawing = class {
         (l) => l.name.toLowerCase() === patch.name.toLowerCase()
       );
       if (clash)
-        throw new Error(`updateLayer(): layer "${clash.name}" already exists`);
+        throw new DrawingError(
+          "duplicateName",
+          `Layer "${clash.name}" already exists`
+        );
     }
     this.applyForward({
       type: "update-layer",
-      layer: LayerSchema.parse({ ...cur, ...withVisible(patch), id: cur.id })
+      layer: this.checkedLayer(
+        { ...cur, ...patch, id: cur.id },
+        patch,
+        `update layer "${cur.name}"`
+      )
     });
   }
+  /** A layer parsed from `full`, refusing an empty name, unknown fields
+   * and an unknown line type among what the caller `sent`. */
+  checkedLayer(full, sent, context) {
+    if (typeof sent.name === "string" && sent.name.trim() === "")
+      throw new DrawingError("validation", `${context}: the name is empty`);
+    let layer;
+    try {
+      layer = LayerSchema.parse(full);
+    } catch (e) {
+      throw wrapZod(e, context);
+    }
+    assertNoUnknownKeys(sent, layer, context, "layer");
+    if ("lineType" in sent)
+      assertLineType(layer.lineType, this.nameSources, context);
+    return layer;
+  }
   /** Remove an EMPTY, non-current layer (the kernel refuses otherwise). */
   removeLayer(nameOrId) {
     this.applyForward({
@@ -8699,6 +8696,7 @@ var LocalDrawing = class {
    * Content-keyed: the same data reuses one entry.
    */
   addAsset(dataUrl) {
+    assertDataUrl(dataUrl);
     const id = hashAsset(dataUrl);
     if (this.state.assets[id] !== dataUrl)
       this.applyForward({ type: "set-asset", id, dataUrl });
@@ -8806,25 +8804,32 @@ var LocalDrawing = class {
   // (case-insensitive) on add and rename.
   resolveStyle(styles, nameOrId, what) {
     const s = styles.find((x) => x.id === nameOrId || x.name === nameOrId);
-    if (!s) throw new Error(`Unknown ${what} "${nameOrId}"`);
+    if (!s)
+      throw new DrawingError("unknownStyle", `Unknown ${what} "${nameOrId}"`);
     return s;
   }
-  assertStyleName(styles, name, context, except) {
+  assertStyleName(styles, name, except) {
     const clash = styles.find(
       (s) => s.id !== except && s.name.toLowerCase() === name.toLowerCase()
     );
     if (clash)
-      throw new Error(`${context}: style "${clash.name}" already exists`);
+      throw new DrawingError(
+        "duplicateName",
+        `Style "${clash.name}" already exists`
+      );
   }
   /** Layouts are addressed by name everywhere (`layout` on the object
    * tools, remove, reorder, render) — a duplicate would silently resolve to
    * the first match. */
-  assertLayoutName(name, context, except) {
+  assertLayoutName(name, except) {
     const clash = this.state.layouts.find(
       (l) => l.id !== except && l.name.toLowerCase() === name.toLowerCase()
     );
     if (clash)
-      throw new Error(`${context}: layout "${clash.name}" already exists`);
+      throw new DrawingError(
+        "duplicateName",
+        `Layout "${clash.name}" already exists`
+      );
   }
   /** Objects reference styles by id, but callers often pass the NAME:
    * resolve it (text/table → text styles, dimension → dim styles). An
@@ -8836,7 +8841,8 @@ var LocalDrawing = class {
     if (!styles) return {};
     const s = styles.find((x) => x.id === obj.styleId) ?? styles.find((x) => x.name === obj.styleId);
     if (!s)
-      throw new Error(
+      throw new DrawingError(
+        "unknownStyle",
         `${context}: unknown ${obj.type === "dimension" ? "dim" : "text"} style "${obj.styleId}"`
       );
     return { styleId: s.id };
@@ -8850,8 +8856,8 @@ var LocalDrawing = class {
   /** Create a text style (unique name; unset fields take the defaults);
    * returns its id. */
   addTextStyle(props) {
-    this.assertStyleName(this.state.textStyles, props.name, "addTextStyle()");
-    const style = TextStyleSchema.parse(props);
+    this.assertStyleName(this.state.textStyles, props.name);
+    const style = checkedStyle(TextStyleSchema, props, props, "add text style");
     this.applyForward({ type: "add-text-style", style });
     return style.id;
   }
@@ -8862,15 +8868,15 @@ var LocalDrawing = class {
       "text style"
     );
     if (patch.name !== void 0)
-      this.assertStyleName(
-        this.state.textStyles,
-        patch.name,
-        "updateTextStyle()",
-        cur.id
-      );
+      this.assertStyleName(this.state.textStyles, patch.name, cur.id);
     this.applyForward({
       type: "update-text-style",
-      style: TextStyleSchema.parse({ ...cur, ...patch, id: cur.id })
+      style: checkedStyle(
+        TextStyleSchema,
+        { ...cur, ...patch, id: cur.id },
+        patch,
+        `update text style "${cur.name}"`
+      )
     });
   }
   // --- line types / hatch patterns (name-keyed definitions) -----------------
@@ -8889,7 +8895,8 @@ var LocalDrawing = class {
     const cur = this.state.lineTypes.find(
       (t) => lineTypeKey(t.name) === lineTypeKey(name)
     );
-    if (!cur) throw new Error(`Unknown line type "${name}"`);
+    if (!cur)
+      throw new DrawingError("unknownLineType", `Unknown line type "${name}"`);
     const next = LineTypeSchema.parse({ ...cur, ...patch });
     if (lineTypeKey(next.name) !== lineTypeKey(cur.name)) {
       this.transaction(() => {
@@ -8916,7 +8923,11 @@ var LocalDrawing = class {
     const cur = this.state.hatchPatterns.find(
       (p) => hatchPatternKey(p.name) === hatchPatternKey(name)
     );
-    if (!cur) throw new Error(`Unknown hatch pattern "${name}"`);
+    if (!cur)
+      throw new DrawingError(
+        "unknownHatchPattern",
+        `Unknown hatch pattern "${name}"`
+      );
     const next = HatchPatternSchema.parse({ ...cur, ...patch });
     if (hatchPatternKey(next.name) !== hatchPatternKey(cur.name)) {
       this.transaction(() => {
@@ -8939,23 +8950,23 @@ var LocalDrawing = class {
   /** Create a dimension style (unique name; unset fields take the
    * defaults); returns its id. */
   addDimStyle(props) {
-    this.assertStyleName(this.state.dimStyles, props.name, "addDimStyle()");
-    const style = DimStyleSchema.parse(props);
+    this.assertStyleName(this.state.dimStyles, props.name);
+    const style = checkedStyle(DimStyleSchema, props, props, "add dim style");
     this.applyForward({ type: "add-dim-style", style });
     return style.id;
   }
   updateDimStyle(nameOrId, patch) {
     const cur = this.resolveStyle(this.state.dimStyles, nameOrId, "dim style");
     if (patch.name !== void 0)
-      this.assertStyleName(
-        this.state.dimStyles,
-        patch.name,
-        "updateDimStyle()",
-        cur.id
-      );
+      this.assertStyleName(this.state.dimStyles, patch.name, cur.id);
     this.applyForward({
       type: "update-dim-style",
-      style: DimStyleSchema.parse({ ...cur, ...patch, id: cur.id })
+      style: checkedStyle(
+        DimStyleSchema,
+        { ...cur, ...patch, id: cur.id },
+        patch,
+        `update dim style "${cur.name}"`
+      )
     });
   }
   /** Remove a dimension style no dimension uses (the kernel refuses
@@ -9031,6 +9042,7 @@ var LocalDrawing = class {
   async addBlockDefinitions(sources) {
     await ensureScriptTranspiler();
     const report = mergeBlockModules(this.state.blockDefinitions, sources);
+    refuseRejected(report, "block definition");
     this.applyForwardAll(
       diffModuleOps(
         this.state.blockDefinitions,
@@ -9043,6 +9055,7 @@ var LocalDrawing = class {
   async addUserCommands(sources) {
     await ensureScriptTranspiler();
     const report = mergeCommandModules(this.state.commands, sources);
+    refuseRejected(report, "user command");
     this.applyForwardAll(
       diffModuleOps(this.state.commands, report.merged, "commands")
     );
@@ -9132,7 +9145,6 @@ var LocalDrawing = class {
       };
       for (const plan of plans) {
         const r = plan.kind === "block" ? await this.addBlockDefinitions(plan.sources) : await this.addUserCommands(plan.sources);
-        if (r.rejected.length > 0) throw new Error(r.rejected[0].error);
         report.merged = r.merged;
         report.added.push(...r.added);
         report.replaced.push(...r.replaced);
@@ -9146,7 +9158,8 @@ var LocalDrawing = class {
     const source = this.state.blockDefinitions.find(
       (s) => listBlockMeta([s]).some((r) => r.ok && r.meta.id === id)
     );
-    if (source === void 0) throw new Error(`Unknown block "${id}"`);
+    if (source === void 0)
+      throw new DrawingError("unknownBlock", `Unknown block "${id}"`);
     this.applyForward({ type: "remove-block-definition", source });
   }
   /** Remove a command module by its exported id (unknown id → error). */
@@ -9154,7 +9167,8 @@ var LocalDrawing = class {
     const source = this.state.commands.find(
       (s) => listCommandMeta([s]).some((r) => r.ok && r.meta.id === id)
     );
-    if (source === void 0) throw new Error(`Unknown command "${id}"`);
+    if (source === void 0)
+      throw new DrawingError("unknownCommand", `Unknown command "${id}"`);
     this.applyForward({ type: "remove-document-command", source });
   }
   /**
@@ -9230,7 +9244,7 @@ var LocalDrawing = class {
    * to the model extents. Returns the layout id.
    */
   addLayout(name, opts = {}) {
-    this.assertLayoutName(name, "addLayout()");
+    this.assertLayoutName(name);
     const layout = this.makeLayout(name, opts);
     this.applyForward({ type: "add-layout", layout, index: opts.index });
     return layout.id;
@@ -9253,8 +9267,7 @@ var LocalDrawing = class {
   /** Patch a layout's name / sheet (preset or mm) / print palette. */
   updateLayout(nameOrId, patch) {
     const layout = this.resolveLayout(nameOrId);
-    if (patch.name !== void 0)
-      this.assertLayoutName(patch.name, "updateLayout()", layout.id);
+    if (patch.name !== void 0) this.assertLayoutName(patch.name, layout.id);
     const { sheet, ...rest } = patch;
     this.applyForward({
       type: "update-layout-meta",
@@ -9264,6 +9277,14 @@ var LocalDrawing = class {
     });
   }
   // --- object mutations ----------------------------------------------------
+  /** What names in a new or changed object must resolve against. */
+  get nameSources() {
+    return {
+      lineTypes: this.state.lineTypes,
+      hatchPatterns: this.state.hatchPatterns,
+      blockDefinitions: this.state.blockDefinitions
+    };
+  }
   normalize(input, index) {
     const { layer, layerId, id, ...rest } = input;
     const context = `add(): objects[${index ?? 0}] (${String(input.type ?? "?")})`;
@@ -9276,9 +9297,16 @@ var LocalDrawing = class {
         layerId: this.resolveLayerId(layer, layerId),
         id: id ?? crypto.randomUUID()
       };
-      return ModelObjectSchema.parse(
-        raw.type === "dimension" ? dimensionRawToLabels(dimensionRawToOffset(raw)) : raw
+      const obj = ModelObjectSchema.parse(raw);
+      assertNoUnknownKeys(raw, obj, context, obj.type);
+      assertSaneNumbers(obj, context);
+      assertObjectFields(
+        obj,
+        new Set(Object.keys(rest)),
+        this.nameSources,
+        context
       );
+      return obj;
     } catch (e) {
       throw wrapZod(
         e,
@@ -9310,18 +9338,25 @@ var LocalDrawing = class {
       `update(): "${id}" (${cur.type})`
     ) : {};
     const staleSpans = cur.type === "text" && "content" in rest && !("spans" in rest) ? { spans: void 0 } : {};
+    const context = `update(): "${id}" (${cur.type})`;
     try {
-      return {
-        space,
-        obj: ModelObjectSchema.parse({
-          ...cur,
-          ...rest,
-          ...staleSpans,
-          ...styleRef,
-          ...resolvedLayerId ? { layerId: resolvedLayerId } : {},
-          id
-        })
-      };
+      const obj = ModelObjectSchema.parse({
+        ...cur,
+        ...rest,
+        ...staleSpans,
+        ...styleRef,
+        ...resolvedLayerId ? { layerId: resolvedLayerId } : {},
+        id
+      });
+      assertNoUnknownKeys(rest, obj, context, cur.type);
+      assertSaneNumbers(rest, context);
+      assertObjectFields(
+        obj,
+        new Set(Object.keys(rest)),
+        this.nameSources,
+        context
+      );
+      return { space, obj };
     } catch (e) {
       throw wrapZod(e, `update(): "${id}" (${cur.type})`);
     }
@@ -9430,22 +9465,50 @@ var LocalDrawing = class {
   mirror(ids, a, b) {
     const pa = toVec(a);
     const pb = toVec(b);
+    if (pa.x === pb.x && pa.y === pb.y)
+      throw new DrawingError(
+        "validation",
+        "Mirror needs two different points for its axis"
+      );
     this.transformEach(ids, (o) => mirrorObject(o, pa, pb));
   }
   /** Duplicate objects (into their own space) displaced by `delta`. */
   copy(ids, delta) {
-    if (ids.length === 0) return [];
+    return this.copySteps(ids, [toVec(delta)]);
+  }
+  /**
+   * Linear array: `count` TOTAL instances (including the originals) stepped
+   * by `delta`. Returns the new ids, one batch per step, in one undo step.
+   */
+  array(ids, count, delta) {
+    if (!Number.isInteger(count) || count < 1)
+      throw new Error(`Invalid array count ${count}`);
     const d = toVec(delta);
-    const idMap = new Map(ids.map((id) => [id, crypto.randomUUID()]));
-    const clones = ids.map((id) => {
-      const { obj, space } = this.findObject(id);
-      return {
+    const steps = Array.from({ length: count - 1 }, (_, i) => ({
+      x: d.x * (i + 1),
+      y: d.y * (i + 1)
+    }));
+    return this.copySteps(ids, steps);
+  }
+  /** One displaced copy of `ids` per step, applied as ONE add op per space
+   * (an op per step re-copied the whole space each time: quadratic). */
+  copySteps(ids, steps) {
+    if (ids.length === 0 || steps.length === 0) return [];
+    const total2 = ids.length * steps.length;
+    if (total2 > MAX_COPIES)
+      throw new Error(
+        `That would create ${total2} objects; one copy or array makes at most ${MAX_COPIES}.`
+      );
+    const sources = ids.map((id) => this.findObject(id));
+    const clones = steps.flatMap((d) => {
+      const idMap = new Map(ids.map((id) => [id, crypto.randomUUID()]));
+      return sources.map(({ obj, space }) => ({
         space,
         obj: ModelObjectSchema.parse({
           ...remapBlockInputRefs(translateObject(obj, d), idMap),
-          id: idMap.get(id)
+          id: idMap.get(obj.id)
         })
-      };
+      }));
     });
     this.applyBySpace(clones, (space, objects) => ({
       type: "add-objects",
@@ -9454,21 +9517,6 @@ var LocalDrawing = class {
     }));
     return clones.map((c) => c.obj.id);
   }
-  /**
-   * Linear array: `count` TOTAL instances (including the originals) stepped
-   * by `delta`. Returns the new ids, one batch per step, in one undo step.
-   */
-  array(ids, count, delta) {
-    if (!Number.isInteger(count) || count < 1)
-      throw new Error(`Invalid array count ${count}`);
-    const d = toVec(delta);
-    return this.transaction(() => {
-      const created = [];
-      for (let i = 1; i < count; i++)
-        created.push(...this.copy(ids, { x: d.x * i, y: d.y * i }));
-      return created;
-    });
-  }
   // --- reads ---------------------------------------------------------------
   get measurer() {
     return this.hooks.measure ?? approximateTextMeasurer;
@@ -9632,7 +9680,8 @@ var LocalDrawing = class {
     const layout = this.state.layouts.find(
       (l) => l.name === nameOrId || l.id === nameOrId
     );
-    if (!layout) throw new Error(`Unknown layout "${nameOrId}"`);
+    if (!layout)
+      throw new DrawingError("unknownLayout", `Unknown layout "${nameOrId}"`);
     return layout;
   }
   /** Render model space (or a paper layout via `layout`) to an SVG string. */
@@ -9643,11 +9692,18 @@ var LocalDrawing = class {
         this.paintContext(),
         opts
       );
-    return renderModelToSvg(this.paintContext(), opts);
+    return renderModelToSvg(this.paintContext(), {
+      lineTypeScale: this.document.settings.modelScale,
+      // Model lineweights are true mm: on a building-sized drawing they
+      // rasterize sub-pixel and read as a blank sheet. Keep every stroke
+      // ≥ ~1.5 px at the output width (PNG) or a 1024 px view (SVG).
+      minStrokeFrac: 1.5 / (opts.width ?? 1024),
+      ...opts
+    });
   }
   /** Export the document to a DXF string. */
   async toDxf() {
-    const { buildDxf } = await import("./exportDxf-C4CLQCC3.js");
+    const { buildDxf } = await import("./exportDxf-6XTXQ4XN.js");
     return buildDxf(this.state, this.measurer).content;
   }
   /** Export the document to DWG bytes (the DXF content, wasm-transcoded).
@@ -9656,7 +9712,7 @@ var LocalDrawing = class {
    * exploded to plain geometry (DWG_DXF_OPTIONS — the transcoder's DWG
    * output for them is not accepted by AutoCAD). */
   async toDwg(opts) {
-    const { buildDxf, DWG_DXF_OPTIONS } = await import("./exportDxf-C4CLQCC3.js");
+    const { buildDxf, DWG_DXF_OPTIONS } = await import("./exportDxf-6XTXQ4XN.js");
     const dxf = buildDxf(this.state, this.measurer, DWG_DXF_OPTIONS).content;
     return dxfToDwg(dxf, opts?.version ?? "AC1027");
   }
@@ -9790,7 +9846,7 @@ var runCommandModule = async (source, opts) => {
   }
 };
 var namedEditorError = (name, e) => {
-  const m = e instanceof TypeError ? /reading '(pickPoint|pickPoints|pickObject|pickObjects|prompt|ask|toast|state|setSelection|setActiveSpace|zoom|listCommands|runCommand)'/.exec(
+  const m = e instanceof TypeError ? /(?:reading|property) '(pickPoint|pickPoints|pickObject|pickObjects|prompt|ask|toast|state|setSelection|setActiveSpace|zoom|listCommands|runCommand)'/.exec(
     e.message
   ) : null;
   if (!m) return e;
@@ -9982,7 +10038,10 @@ var Drawing = class extends LocalDrawing {
         this.paintContext(),
         opts
       );
-    return renderModelToPng(this.paintContext(), opts);
+    return renderModelToPng(this.paintContext(), {
+      lineTypeScale: this.document.settings.modelScale,
+      ...opts
+    });
   }
   /** Multi-page PDF of the layouts (default: all) with the embedded fonts. */
   async renderPdf(opts = {}) {
@@ -10094,10 +10153,12 @@ export {
   ensureScriptTranspiler,
   getBlockMetaResult,
   getCommandMetaResult,
+  hatchLoop,
   newDrawing,
   openDrawing,
   parseScale,
   renderBlockThumbnailSvg,
+  splineThrough,
   testBlockDefinition
 };
 //# sourceMappingURL=sdk.js.map