@mylasertools/kerfscript 0.2.0 → 0.2.1

package/dist/cli.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-/*! @mylasertools/kerfscript | (c) MyLaserTools | AGPL-3.0-only or commercial licence, see COMMERCIAL-LICENSE.md. Includes Clipper2 (BSL-1.0) and opentype.js (MIT), see THIRD-PARTY-NOTICES.md. */
+/*! @mylasertools/kerfscript | (c) MyLaserTools | AGPL-3.0-only or commercial licence, see COMMERCIAL-LICENSE.md. Includes Clipper2 (BSL-1.0), opentype.js, tiny-inflate and string.prototype.codepointat (MIT), see THIRD-PARTY-NOTICES.md. */
 var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
@@ -32,9 +32,9 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 
-// node_modules/opentype.js/dist/opentype.js
+// ../kerfscript/node_modules/opentype.js/dist/opentype.js
 var require_opentype = __commonJS({
-  "node_modules/opentype.js/dist/opentype.js"(exports, module) {
+  "../kerfscript/node_modules/opentype.js/dist/opentype.js"(exports, module) {
     (function(global, factory) {
       typeof exports === "object" && typeof module !== "undefined" ? factory(exports) : typeof define === "function" && define.amd ? define(["exports"], factory) : (global = global || self, factory(global.opentype = {}));
     })(exports, (function(exports2) {
@@ -12400,8 +12400,8 @@ var FUNCTIONS = {
   atan: math1("atan", (x) => Math.atan(x) / RAD),
   atan2: (a) => clean(Math.atan2(num(a[0], "atan2"), num(a[1], "atan2")) / RAD),
   pow: (a) => Math.pow(num(a[0], "pow"), num(a[1], "pow")),
-  min: (a) => minmax(a, (xs) => Math.min(...xs), "min"),
-  max: (a) => minmax(a, (xs) => Math.max(...xs), "max"),
+  min: (a) => minmax(a, (xs) => xs.reduce((m, x) => x < m ? x : m, Infinity), "min"),
+  max: (a) => minmax(a, (xs) => xs.reduce((m, x) => x > m ? x : m, -Infinity), "max"),
   clamp: (a) => Math.min(Math.max(num(a[0], "clamp"), num(a[1], "clamp")), num(a[2], "clamp")),
   lerp: (a) => {
     const t = num(a[2], "lerp");
@@ -12411,7 +12411,7 @@ var FUNCTIONS = {
     }
     return num(a[0], "lerp") + (num(a[1], "lerp") - num(a[0], "lerp")) * t;
   },
-  norm: (a) => Math.hypot(...list(a[0], "norm").map((x) => num(x, "norm"))),
+  norm: (a) => Math.sqrt(list(a[0], "norm").reduce((s, x) => s + num(x, "norm") ** 2, 0)),
   cross: (a) => {
     const u = list(a[0], "cross").map((x) => num(x, "cross"));
     const v = list(a[1], "cross").map((x) => num(x, "cross"));
@@ -12474,7 +12474,7 @@ var FUNCTIONS = {
   type_of: (a) => typeName(a[0])
 };
 
-// node_modules/clipper2-ts/dist/Core.js
+// ../kerfscript/node_modules/clipper2-ts/dist/Core.js
 var ClipType;
 (function(ClipType2) {
   ClipType2[ClipType2["NoClip"] = 0] = "NoClip";
@@ -13133,7 +13133,7 @@ var RectDUtils = {
 var InvalidRect64 = Object.freeze(Rect64Utils.createInvalid());
 var InvalidRectD = Object.freeze(RectDUtils.createInvalid());
 
-// node_modules/clipper2-ts/dist/Engine.js
+// ../kerfscript/node_modules/clipper2-ts/dist/Engine.js
 var B02 = BigInt(0);
 var B22 = BigInt(2);
 var B42 = BigInt(4);
@@ -15898,7 +15898,7 @@ var Clipper = {
   }
 };
 
-// node_modules/clipper2-ts/dist/Offset.js
+// ../kerfscript/node_modules/clipper2-ts/dist/Offset.js
 var JoinType;
 (function(JoinType2) {
   JoinType2[JoinType2["Miter"] = 0] = "Miter";
@@ -16511,7 +16511,7 @@ var ClipperOffset = class _ClipperOffset {
   }
 };
 
-// node_modules/clipper2-ts/dist/Clipper.js
+// ../kerfscript/node_modules/clipper2-ts/dist/Clipper.js
 var B23 = BigInt(2);
 function union(subject, clipOrFillRule, fillRule) {
   if (typeof clipOrFillRule === "number") {
@@ -16672,21 +16672,31 @@ function merge(shapes) {
   for (const s of shapes) {
     for (const [k, l] of s.layers) {
       const t = out.layers.get(k) ?? { regions: [], lines: [] };
-      t.regions.push(...l.regions);
-      t.lines.push(...l.lines);
+      for (const p of l.regions) t.regions.push(p);
+      for (const p of l.lines) t.lines.push(p);
       out.layers.set(k, t);
     }
-    out.parts.push(...s.parts);
+    for (const p of s.parts) out.parts.push(p);
   }
   return out;
 }
-function retag(s, layer) {
+function allOn(layers, layer) {
   const all = { regions: [], lines: [] };
-  for (const l of s.layers.values()) {
-    all.regions.push(...l.regions);
-    all.lines.push(...l.lines);
+  for (const l of layers.values()) {
+    for (const p of l.regions) all.regions.push(p);
+    for (const p of l.lines) all.lines.push(p);
   }
-  return { layers: /* @__PURE__ */ new Map([[layer, all]]), parts: s.parts };
+  return /* @__PURE__ */ new Map([[layer, all]]);
+}
+function retag(s, layer) {
+  if (s.parts.length && layer !== "guide")
+    throw new Error(
+      `a part cannot go on the ${layer} layer as a whole. Put ${layer}() inside part() instead.`
+    );
+  return {
+    layers: allOn(s.layers, layer),
+    parts: s.parts.map((p) => ({ ...p, layers: allOn(p.layers, layer) }))
+  };
 }
 function bounds(polys) {
   let x0 = Infinity, y0 = Infinity, x1 = -Infinity, y1 = -Infinity;
@@ -16703,7 +16713,7 @@ function layerBounds(layers, skip) {
   const all = [];
   for (const [k, l] of layers) {
     if (skip?.(k)) continue;
-    all.push(...l.regions, ...l.lines);
+    for (const p of [...l.regions, ...l.lines]) all.push(p);
   }
   return bounds(all);
 }
@@ -17413,13 +17423,14 @@ function flatten(cmds, tolerance = 0.02) {
     } else {
       finish(true);
       last = start;
-      cur = [];
+      cur = [start];
     }
   }
   finish(false);
   return { closed, open };
 }
 function parseSvgPath(d2) {
+  const isCommand = (t) => /^[a-zA-Z]$/.test(t);
   const tokens = d2.match(/[a-zA-Z]|[-+]?(?:\d+\.?\d*|\.\d+)(?:[eE][-+]?\d+)?/g) ?? [];
   const out = [];
   let i = 0;
@@ -17429,8 +17440,7 @@ function parseSvgPath(d2) {
   let prev = "";
   const num2 = () => {
     const t = tokens[i++];
-    if (t === void 0 || /[a-zA-Z]/.test(t))
-      throw new Error(`Bad path data near "${t ?? "end"}"`);
+    if (t === void 0 || isCommand(t)) throw new Error(`Bad path data near "${t ?? "end"}"`);
     return Number(t);
   };
   const flag = () => {
@@ -17444,8 +17454,10 @@ function parseSvgPath(d2) {
     return Number(t);
   };
   while (i < tokens.length) {
-    if (/[a-zA-Z]/.test(tokens[i])) cmd = tokens[i++];
+    if (isCommand(tokens[i])) cmd = tokens[i++];
     else if (!cmd) throw new Error("Path data must start with a command");
+    else if (cmd === "Z" || cmd === "z")
+      throw new Error(`Bad path data near "${tokens[i]}": Z takes no numbers`);
     const rel = cmd === cmd.toLowerCase();
     const C = cmd.toUpperCase();
     const ox = rel ? x : 0, oy = rel ? y : 0;
@@ -17657,6 +17669,31 @@ var DEFAULT_LAYERS = [
   { name: "cut", mode: "cut", color: "#ff0000" },
   { name: "guide", mode: "guide", color: "#00a0ff" }
 ];
+var DEFAULT_LIMITS = {
+  maxParts: 1e4,
+  maxSegments: 1e4,
+  maxListLength: 1e6,
+  maxListItems: 3e6,
+  maxTextLength: 2e3,
+  maxPoints: 2e6,
+  maxOutputPoints: 1e6,
+  maxSheets: 200
+};
+var SHAPE_COST = 100;
+var LIST_COST = 4;
+var CHARS_PER_ITEM = 8;
+var shapePoints = (s) => {
+  let n2 = SHAPE_COST;
+  const add = (layers) => {
+    for (const l of layers.values()) {
+      for (const p of l.regions) n2 += p.length;
+      for (const p of l.lines) n2 += p.length;
+    }
+  };
+  add(s.layers);
+  for (const p of s.parts) add(p.layers);
+  return n2;
+};
 var Env = class {
   constructor(parent, caller) {
     this.parent = parent;
@@ -17696,11 +17733,15 @@ var Evaluator = class {
     this.opts = opts;
     this.steps = 0;
     this.depth = 0;
+    this.pointCount = 0;
+    this.itemCount = 0;
+    this.copies = 0;
     this.echoes = [];
     this.warnings = [];
     this.layers = new Map(DEFAULT_LAYERS.map((l) => [l.name, l]));
     this.loaded = /* @__PURE__ */ new Map();
     this.maxSteps = opts.maxSteps ?? 5e6;
+    this.limits = { ...DEFAULT_LIMITS, ...opts.limits };
     this.builtins = this.makeBuiltins();
   }
   run(program) {
@@ -17747,16 +17788,28 @@ var Evaluator = class {
       if (s.kind === "module") env.mods.set(s.name, { params: s.params, body: s.body, env });
       else if (s.kind === "function") env.fns.set(s.name, { params: s.params, body: s.body, env });
       else if (s.kind === "use" && !s.include) {
-        const lib = this.load(s.path, s.pos);
+        const body = this.included(this.load(s.path, s.pos).body, /* @__PURE__ */ new Set([s.path]));
         const libEnv = new Env(env);
-        this.hoist(lib.body, libEnv);
-        for (const ls of lib.body)
+        this.hoist(body, libEnv);
+        for (const ls of body)
           if (ls.kind === "assign") this.assign(ls.name, this.expr(ls.value, libEnv), libEnv);
         for (const [k, v] of libEnv.mods) env.mods.set(k, v);
         for (const [k, v] of libEnv.fns) env.fns.set(k, v);
       }
     }
   }
+  // A library's statements with the files it includes written out in place
+  included(stmts, seen) {
+    const out = [];
+    for (const s of stmts) {
+      if (s.kind !== "use" || !s.include) out.push(s);
+      else if (!seen.has(s.path)) {
+        seen.add(s.path);
+        for (const t of this.included(this.load(s.path, s.pos).body, seen)) out.push(t);
+      }
+    }
+    return out;
+  }
   assign(name, value, env) {
     env.vars.set(name, value);
   }
@@ -17855,8 +17908,10 @@ var Evaluator = class {
     });
     for (const k of args.named.keys()) {
       if (k.startsWith("$")) env.vars.set(k, args.named.get(k));
-      else if (!names.has(k))
-        this.warnings.push(`${what}: unknown argument "${k}" (line ${args.at.line})`);
+      else if (!names.has(k)) {
+        const warning = `${what}: unknown argument "${k}" (line ${args.at.line})`;
+        if (!this.warnings.includes(warning)) this.warnings.push(warning);
+      }
     }
     void defEnv;
   }
@@ -17892,20 +17947,28 @@ var Evaluator = class {
       childList: () => {
         const e = childEnv();
         this.hoist(s.children, e);
-        const out = [];
+        const out2 = [];
         for (const st of s.children) {
           const r = this.stmt(st, e);
-          if (kids.includes(st)) out.push(r ?? emptyShape());
+          if (kids.includes(st)) out2.push(r ?? emptyShape());
         }
-        return out;
+        return out2;
       }
     };
+    let out;
     try {
-      return b(ctx);
+      out = b(ctx);
     } catch (e) {
       if (e instanceof KerfError) throw e;
       throw new KerfError(`${s.name}(): ${e.message}`, s.pos);
     }
+    this.pointCount += shapePoints(out);
+    if (this.pointCount > this.limits.maxPoints)
+      throw new KerfError(
+        `The shapes have more than ${this.limits.maxPoints} points, the limit. Use fewer or simpler shapes, or a lower $fn.`,
+        s.pos
+      );
+    return out;
   }
   childStmts(stmts) {
     return stmts.filter(
@@ -17943,7 +18006,8 @@ var Evaluator = class {
       }
       case "list": {
         const out = [];
-        for (const it of x.items) this.listItem(it, env, out);
+        for (const it of x.items) this.listItem(it, env, out, x.pos);
+        this.charge(LIST_COST, x.pos);
         return out;
       }
       case "range": {
@@ -18005,30 +18069,50 @@ var Evaluator = class {
       }
     }
   }
-  listItem(it, env, out) {
+  listItem(it, env, out, at) {
     switch (it.kind) {
-      case "item":
-        out.push(this.expr(it.expr, env));
+      case "item": {
+        const v = this.expr(it.expr, env);
+        this.grow(out, 1, at);
+        out.push(v);
         return;
+      }
       case "each": {
-        const v = this.expr(it.expr, env);
-        out.push(...this.iterable(v, { line: 0, col: 0, offset: 0 }));
+        const xs = this.iterable(this.expr(it.expr, env), at);
+        this.grow(out, xs.length, at);
+        for (const x of xs) out.push(x);
         return;
       }
       case "for":
-        this.loop(it.assigns, env, (e) => this.listItem(it.body, e, out));
+        this.loop(it.assigns, env, (e) => this.listItem(it.body, e, out, at));
         return;
       case "if":
-        if (truthy(this.expr(it.cond, env))) this.listItem(it.then, env, out);
-        else if (it.else) this.listItem(it.else, env, out);
+        if (truthy(this.expr(it.cond, env))) this.listItem(it.then, env, out, at);
+        else if (it.else) this.listItem(it.else, env, out, at);
         return;
       case "let": {
         const e = new Env(env);
         this.bindSeq(it.assigns, e);
-        this.listItem(it.body, e, out);
+        this.listItem(it.body, e, out, at);
       }
     }
   }
+  grow(out, n2, at) {
+    if (out.length + n2 > this.limits.maxListLength)
+      throw new KerfError(
+        `a list of ${out.length + n2} items is more than the limit of ${this.limits.maxListLength}`,
+        at
+      );
+    this.charge(n2, at);
+  }
+  charge(items, at) {
+    this.itemCount += items;
+    if (!(this.itemCount <= this.limits.maxListItems))
+      throw new KerfError(
+        `The lists and strings hold more than ${this.limits.maxListItems} items in all, the limit. Is a loop building more than it needs?`,
+        at
+      );
+  }
   call(x, env) {
     if (x.callee.kind === "var") {
       const name = x.callee.name;
@@ -18041,11 +18125,17 @@ var Evaluator = class {
         const b = FUNCTIONS[name];
         if (b) {
           const args = this.evalArgs(x.args, env, x.pos);
+          let out;
           try {
-            return b(args.pos, args.named);
+            out = b(args.pos, args.named);
           } catch (e) {
-            throw new KerfError(e.message, x.pos);
+            throw new KerfError(
+              e instanceof RangeError ? `${name}(): the result is too large` : e.message,
+              x.pos
+            );
           }
+          this.checkValue(out, x.pos, name);
+          return out;
         }
         throw new KerfError(`Unknown function ${name}()`, x.pos);
       }
@@ -18060,7 +18150,7 @@ var Evaluator = class {
   specialFunction(name, x, env) {
     if (name === "echo") {
       const a = this.evalArgs(x.args, env, x.pos);
-      this.echoes.push(this.echoText(a));
+      this.echo(this.echoText(a), x.pos);
       return { handled: true, value: void 0 };
     }
     if (name === "assert") {
@@ -18088,6 +18178,10 @@ var Evaluator = class {
     }
     return { handled: false };
   }
+  echo(text, at) {
+    this.charge(Math.ceil(text.length / CHARS_PER_ITEM), at);
+    this.echoes.push(text);
+  }
   echoText(a) {
     const parts = a.pos.map((v) => typeof v === "string" ? v : show(v));
     for (const [k, v] of a.named) parts.push(`${k} = ${show(v)}`);
@@ -18110,7 +18204,10 @@ var Evaluator = class {
           return Math.pow(a, b);
       }
     }
-    if (op === "+" && typeof a === "string" && typeof b === "string") return a + b;
+    if (op === "+" && typeof a === "string" && typeof b === "string") {
+      this.checkSize(a.length + b.length, true, at);
+      return a + b;
+    }
     if (Array.isArray(a) && Array.isArray(b)) {
       if (op === "+" || op === "-") {
         if (a.length !== b.length)
@@ -18118,12 +18215,14 @@ var Evaluator = class {
             `Can't ${op === "+" ? "add" : "subtract"} lists of length ${a.length} and ${b.length}`,
             at
           );
+        this.charge(a.length + LIST_COST, at);
         return a.map((x, i) => this.arith(op, x, b[i], at));
       }
       if (op === "*") {
         if (Array.isArray(a[0])) return a.map((row) => this.arith("*", row, b, at));
         if (Array.isArray(b[0])) {
           const cols = b[0].length;
+          this.checkSize(cols, false, at);
           return Array.from(
             { length: cols },
             (_, j) => a.reduce(
@@ -18137,10 +18236,14 @@ var Evaluator = class {
         return a.reduce((s, x, i) => s + this.arith("*", x, b[i], at), 0);
       }
     }
-    if (Array.isArray(a) && typeof b === "number" && (op === "*" || op === "/"))
+    if (Array.isArray(a) && typeof b === "number" && (op === "*" || op === "/")) {
+      this.charge(a.length + LIST_COST, at);
       return a.map((x) => this.arith(op, x, b, at));
-    if (typeof a === "number" && Array.isArray(b) && op === "*")
+    }
+    if (typeof a === "number" && Array.isArray(b) && op === "*") {
+      this.charge(b.length + LIST_COST, at);
       return b.map((x) => this.arith(op, a, x, at));
+    }
     const verb = {
       "+": "add",
       "-": "subtract",
@@ -18157,20 +18260,21 @@ var Evaluator = class {
     return def;
   }
   num(v, fn, name) {
-    if (typeof v !== "number" || Number.isNaN(v))
-      throw new Error(`${name} must be a number, got ${show(v)}`);
+    if (typeof v !== "number" || !Number.isFinite(v))
+      throw new Error(`${name} must be a finite number, got ${show(v)}`);
     return v;
   }
   vec2(v, name, scalarBoth = true) {
-    if (typeof v === "number" && scalarBoth) return [v, v];
-    if (Array.isArray(v) && typeof v[0] === "number")
-      return [v[0], typeof v[1] === "number" ? v[1] : 0];
+    const ok = (x) => typeof x === "number" && Number.isFinite(x);
+    if (ok(v) && scalarBoth) return [v, v];
+    if (Array.isArray(v) && ok(v[0]) && (v[1] === void 0 || ok(v[1])))
+      return [v[0], v[1] ?? 0];
     throw new Error(`${name} must be a number or [x, y], got ${show(v)}`);
   }
   points(v, name) {
     if (!Array.isArray(v)) throw new Error(`${name} must be a list of [x, y] points`);
     return v.map((p, i) => {
-      if (!Array.isArray(p) || typeof p[0] !== "number" || typeof p[1] !== "number")
+      if (!Array.isArray(p) || !Number.isFinite(p[0]) || !Number.isFinite(p[1]))
         throw new Error(`${name}[${i}] must be an [x, y] point, got ${show(p)}`);
       return [p[0], p[1]];
     });
@@ -18178,11 +18282,38 @@ var Evaluator = class {
   dyn(env, name) {
     return env.get(name).value;
   }
+  spend(points) {
+    this.pointCount += points;
+    if (!(this.pointCount <= this.limits.maxPoints))
+      throw new Error(
+        `the shapes need more than ${this.limits.maxPoints} points, the limit. Use fewer or simpler shapes.`
+      );
+  }
+  checkValue(v, pos, fn) {
+    if (Array.isArray(v) || typeof v === "string")
+      this.checkSize(v.length, typeof v === "string", pos, fn);
+  }
+  checkSize(n2, isString, pos, fn) {
+    if (n2 > this.limits.maxListLength)
+      throw new KerfError(
+        `${fn ? `${fn}(): ` : ""}${isString ? `a string of ${n2} characters` : `a list of ${n2} items`} is more than the limit of ${this.limits.maxListLength}`,
+        pos
+      );
+    this.charge(isString ? Math.ceil(n2 / CHARS_PER_ITEM) : n2 + LIST_COST, pos);
+  }
   segs(env) {
     const fn = Number(this.dyn(env, "$fn")) || 0;
     const fa = Number(this.dyn(env, "$fa")) || 2;
     const fs = Number(this.dyn(env, "$fs")) || 0.2;
-    return (r) => fragments(r, fn, fa, fs);
+    const max = this.limits.maxSegments;
+    return (r) => {
+      const n2 = fragments(r, fn, fa, fs);
+      if (!(n2 <= max))
+        throw new Error(
+          `a circle with ${n2} segments is more than the limit of ${max}. Lower $fn, or raise $fa or $fs.`
+        );
+      return n2;
+    };
   }
   thickness(env) {
     const t = this.dyn(env, "$thickness");
@@ -18253,12 +18384,16 @@ var Evaluator = class {
           Math.floor(this.num(this.arg(c.args, "n", 0, 6), "regular_polygon", "n"))
         );
         const r = this.num(this.arg(c.args, "r", 1, 10), "regular_polygon", "r");
+        if (!(n2 <= this.limits.maxSegments))
+          throw new Error(`${n2} corners is more than the limit of ${this.limits.maxSegments}`);
         return regionShape([ellipsePoly(r, r, n2)]);
       },
       star: (c) => {
         const n2 = Math.max(2, Math.floor(this.num(this.arg(c.args, "n", 0, 5), "star", "n")));
         const r = this.num(this.arg(c.args, "r", 1, 10), "star", "r");
         const ri = this.num(this.arg(c.args, "inner", 2, r * 0.45), "star", "inner");
+        if (!(n2 * 2 <= this.limits.maxSegments))
+          throw new Error(`${n2} points is more than the limit of ${this.limits.maxSegments / 2}`);
         const p = [];
         for (let i = 0; i < n2 * 2; i++) {
           const a = Math.PI / 2 + Math.PI * i / n2;
@@ -18298,6 +18433,10 @@ var Evaluator = class {
         const a0 = this.num(this.arg(c.args, "start", 1, 0), "arc", "start");
         const a1 = this.num(this.arg(c.args, "end", 2, 90), "arc", "end");
         const n2 = Math.max(2, Math.ceil(this.segs(c.env)(r) * Math.abs(a1 - a0) / 360));
+        if (!(n2 <= this.limits.maxSegments))
+          throw new Error(
+            `an arc with ${n2} segments is more than the limit of ${this.limits.maxSegments}`
+          );
         const p = [];
         for (let i = 0; i <= n2; i++) {
           const a = (a0 + (a1 - a0) * i / n2) * Math.PI / 180;
@@ -18311,13 +18450,12 @@ var Evaluator = class {
             "text() needs a font. Pass fonts to render(), or --font on the command line."
           );
         const text = this.arg(c.args, "text", 0, "");
-        return regionShape(
-          textRegions(
-            this.opts.fonts,
-            typeof text === "string" ? text : show(text),
-            this.textOpts(c.args, c.env)
-          )
-        );
+        const shown = typeof text === "string" ? text : show(text);
+        if (shown.length > this.limits.maxTextLength)
+          throw new Error(
+            `${shown.length} characters is more than the limit of ${this.limits.maxTextLength} for one text()`
+          );
+        return regionShape(textRegions(this.opts.fonts, shown, this.textOpts(c.args, c.env)));
       },
       translate: (c) => {
         const [x, y] = this.vec2(this.arg(c.args, "v", 0, [0, 0]), "v", false);
@@ -18386,7 +18524,7 @@ var Evaluator = class {
             key = k;
             first = false;
           }
-          for (const p of [...l.regions, ...l.lines]) pts.push(...p);
+          for (const p of [...l.regions, ...l.lines]) for (const q of p) pts.push(q);
         }
         const h = hull(pts);
         return {
@@ -18439,6 +18577,9 @@ var Evaluator = class {
       part: (c) => {
         const name = String(this.arg(c.args, "name", 0, "part"));
         const qty = Math.max(1, Math.floor(Number(this.arg(c.args, "qty", 1, 1)) || 1));
+        this.copies += qty;
+        if (!(this.copies <= this.limits.maxParts))
+          throw new Error(`more than ${this.limits.maxParts} part copies in total, the limit`);
         const s = c.children();
         return {
           layers: /* @__PURE__ */ new Map(),
@@ -18487,7 +18628,7 @@ var Evaluator = class {
         return merge(out);
       },
       echo: (c) => {
-        this.echoes.push(this.echoText(c.args));
+        this.echo(this.echoText(c.args), c.args.at);
         return c.children();
       },
       assert: (c) => {
@@ -18503,15 +18644,17 @@ var Evaluator = class {
         const [w, h] = this.vec2(this.arg(c.args, "size", 0), "size");
         const edges = this.edges(this.arg(c.args, "edges", 1, "out"));
         const t = this.thickness(c.env);
-        return regionShape(fingerRect(w, h, edges, t, this.fingerWidth(c.args, c.env, 2)));
+        const finger = this.fingerWidth(c.args, c.env, 2);
+        this.spend(2 * (Math.abs(w) + Math.abs(h)) / finger * 4);
+        return regionShape(fingerRect(w, h, edges, t, finger));
       },
       finger_holes: (c) => {
         const L = this.num(this.arg(c.args, "length", 0), "finger_holes", "length");
         const e = this.edges(this.arg(c.args, "edge", 1, "out"))[0];
         if (e === "flat") throw new Error('edge must be "out" or "in"');
-        return regionShape(
-          fingerHoles(L, e, this.thickness(c.env), this.fingerWidth(c.args, c.env, 2))
-        );
+        const finger = this.fingerWidth(c.args, c.env, 2);
+        this.spend(Math.abs(L) / finger * 4);
+        return regionShape(fingerHoles(L, e, this.thickness(c.env), finger));
       },
       tslot: (c) => {
         const d2 = this.num(this.arg(c.args, "d", 0, 3), "tslot", "d");
@@ -18531,6 +18674,7 @@ var Evaluator = class {
         );
         if (spacing <= 0 || bridge <= 0 || cut <= 0)
           throw new Error("spacing, bridge and cut must be positive");
+        this.spend((Math.abs(w) / spacing + 1) * (Math.abs(h) / (cut + bridge) + 2) * 2);
         return lineShape(livingHinge(w, h, spacing, bridge, cut));
       }
     };
@@ -18538,14 +18682,20 @@ var Evaluator = class {
       const out = { regions: [], lines: [] };
       for (const s of shapes) {
         if (s.parts.length) throw new Error(`part() can only be the first child of ${fn}()`);
-        for (const l of s.layers.values()) out.regions.push(...l.regions);
+        for (const l of s.layers.values()) for (const p of l.regions) out.regions.push(p);
       }
       return out;
     }
     function mapLayers(s, f) {
-      const layers = /* @__PURE__ */ new Map();
-      for (const [k, l] of s.layers) layers.set(k, f(l));
-      return { layers, parts: s.parts };
+      const each = (from) => {
+        const layers = /* @__PURE__ */ new Map();
+        for (const [k, l] of from) layers.set(k, f(l));
+        return layers;
+      };
+      return {
+        layers: each(s.layers),
+        parts: s.parts.map((p) => ({ ...p, layers: each(p.layers) }))
+      };
     }
   }
 };
@@ -18556,7 +18706,18 @@ var n = (v) => {
   return Object.is(r, -0) ? "0" : String(r);
 };
 var esc = (s) => s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/"/g, "&quot;");
-var d = (p, closed) => `M${p.map(([x, y]) => `${n(x)} ${n(y)}`).join("L")}${closed ? "Z" : ""}`;
+function tidy(p, closed) {
+  const out = [];
+  for (const [x, y] of p) {
+    const q = [n(x), n(y)];
+    const prev = out[out.length - 1];
+    if (!prev || prev[0] !== q[0] || prev[1] !== q[1]) out.push(q);
+  }
+  while (closed && out.length > 1 && out[0][0] === out[out.length - 1][0] && out[0][1] === out[out.length - 1][1])
+    out.pop();
+  return out;
+}
+var d = (p, closed) => `M${tidy(p, closed).map(([x, y]) => `${x} ${y}`).join("L")}${closed ? "Z" : ""}`;
 function layerPaths(items, layers) {
   const out = [];
   for (const def of layers) {
@@ -18673,11 +18834,14 @@ function toDxf(items, _width, height, layers) {
     g(20, 0);
     g(30, 0);
     g(70, closed ? 1 : 0);
-    for (const [x, y] of p) {
+    for (const [x, y] of tidy(
+      p.map(([x2, y2]) => [x2, height - y2]),
+      closed
+    )) {
       g(0, "VERTEX");
       g(8, layer);
-      g(10, n(x));
-      g(20, n(height - y));
+      g(10, x);
+      g(20, y);
       g(30, 0);
     }
     g(0, "SEQEND");
@@ -18715,13 +18879,17 @@ function render(source, options = {}) {
     overrides: options.params,
     resolve: options.resolve,
     fonts,
-    maxSteps: options.maxSteps
+    maxSteps: options.maxSteps,
+    limits: options.limits
   });
+  const limits = ev.limits;
   let res;
   try {
     res = ev.run(program);
   } catch (e) {
-    const err = e instanceof RangeError && /call stack/i.test(e.message) ? new KerfError("Recursion too deep: the program calls itself without stopping") : e;
+    const err = e instanceof RangeError ? new KerfError(
+      /call stack/i.test(e.message) ? "Recursion too deep: the program calls itself without stopping" : "A value grew too large. Is a list or string doubling without end?"
+    ) : e;
     if (err instanceof KerfError) {
       err.echoes = ev.echoes;
       if (fonts?.missing.size) err.missingFonts = [...fonts.missing];
@@ -18778,6 +18946,8 @@ function render(source, options = {}) {
       }
     const b = layerBounds(layers) ?? [0, 0, 0, 0];
     const kerf = options.kerf ?? p.kerf;
+    if (!(Number.isFinite(kerf) && kerf >= 0))
+      throw new KerfError("$kerf must be a number, 0 or more");
     const info = {
       name: p.name,
       qty: p.qty,
@@ -18804,11 +18974,27 @@ function render(source, options = {}) {
     infos.push(info);
     ready.push({ info, layers });
   }
+  let outputPoints = 0;
+  for (const r of ready) {
+    let n2 = 0;
+    for (const l of r.layers.values()) {
+      for (const p of l.regions) n2 += p.length;
+      for (const p of l.lines) n2 += p.length;
+    }
+    outputPoints += n2 * r.info.qty;
+  }
+  if (outputPoints > limits.maxOutputPoints)
+    throw new KerfError(
+      `The files would have ${outputPoints} points, more than the limit of ${limits.maxOutputPoints}. Use fewer copies or simpler shapes.`
+    );
   const sheetSize = options.sheet ?? g("$sheet");
-  if (!Array.isArray(sheetSize) || typeof sheetSize[0] !== "number" || typeof sheetSize[1] !== "number")
-    throw new KerfError("$sheet must be [width, height]");
+  if (!Array.isArray(sheetSize) || !(Number.isFinite(sheetSize[0]) && sheetSize[0] > 0) || !(Number.isFinite(sheetSize[1]) && sheetSize[1] > 0))
+    throw new KerfError("$sheet must be [width, height], both more than 0");
   const gap = options.gap ?? Number(g("$gap") ?? 3);
   const margin = options.margin ?? gap;
+  if (!(Number.isFinite(gap) && gap >= 0)) throw new KerfError("$gap must be a number, 0 or more");
+  if (!(Number.isFinite(margin) && margin >= 0))
+    throw new KerfError("margin must be a number, 0 or more");
   const layoutMode = options.layout ?? (g("$layout") === "none" ? "none" : "pack");
   const order = [
     "engrave",
@@ -18836,8 +19022,8 @@ function render(source, options = {}) {
     for (const it of items)
       for (const [k, l] of it.layers) {
         const t = all.get(k) ?? { regions: [], lines: [] };
-        t.regions.push(...l.regions);
-        t.lines.push(...l.lines);
+        for (const p of l.regions) t.regions.push(p);
+        for (const p of l.lines) t.lines.push(p);
         all.set(k, t);
       }
     const b = exportBounds(all);
@@ -18879,6 +19065,10 @@ function render(source, options = {}) {
       let items = [];
       let x = margin, y = margin, shelf = 0, usedW = 0, usedH = 0;
       const flush = () => {
+        if (items.length && sheets.length >= limits.maxSheets)
+          throw new KerfError(
+            `The parts need more than ${limits.maxSheets} sheets, the limit. Use fewer copies or a bigger $sheet.`
+          );
         if (items.length)
           sheets.push(
             finishSheet(
@@ -19037,7 +19227,7 @@ function parameters(source) {
 }
 
 // src/index.ts
-var VERSION = "0.2.0";
+var VERSION = "0.2.1";
 var LANGUAGE_VERSION = "0.1";
 
 // src/cli.ts