@developerz.ai/ts23d 0.0.0-stage → 0.2.0

package/dist/chunk-d1fv6hrm.js

@@ -0,0 +1,2532 @@
+import {
+  Ts23dError2,
+  MeshBuilder2,
+  frame2,
+  applyAffine2,
+  sub2,
+  dot2,
+  cross2,
+  length2,
+  normalize2
+} from "./chunk-hg7pf34j.js";
+import {
+  DEFAULT_SHEET2,
+  TRIM_SHEET_SIZE2,
+  stripRect2,
+  cellRect2
+} from "./chunk-y63c6zcv.js";
+
+// src/primitives/bevel-box.ts
+var FACES = [
+  { name: "front", u: [0, 1, 0], v: [0, 0, 1] },
+  { name: "back", u: [0, -1, 0], v: [0, 0, 1] },
+  { name: "left", u: [-1, 0, 0], v: [0, 0, 1] },
+  { name: "right", u: [1, 0, 0], v: [0, 0, 1] },
+  { name: "top", u: [1, 0, 0], v: [0, 1, 0] },
+  { name: "bottom", u: [1, 0, 0], v: [0, -1, 0] }
+];
+var SIGNS = [-1, 1];
+function bevelBox(o) {
+  const { half, centre, bevel: bv } = o;
+  const rect = stripRect2(o.strip);
+  const b = new MeshBuilder2;
+  const dot3 = (a, c) => a[0] * c[0] + a[1] * c[1] + a[2] * c[2];
+  const ext = (a) => Math.abs(a[0]) * half[0] + Math.abs(a[1]) * half[1] + Math.abs(a[2]) * half[2];
+  const point = (s, k) => [
+    centre[0] + (s[0] ?? 1) * (half[0] - (k === 0 ? 0 : bv)),
+    centre[1] + (s[1] ?? 1) * (half[1] - (k === 1 ? 0 : bv)),
+    centre[2] + (s[2] ?? 1) * (half[2] - (k === 2 ? 0 : bv))
+  ];
+  const put = (s, k, n) => {
+    const f = FACES[k * 2 + ((s[k] ?? 1) > 0 ? 0 : 1)] ?? { u: n, v: n };
+    const p = point(s, k);
+    const rel = [p[0] - centre[0], p[1] - centre[1], p[2] - centre[2]];
+    const eu = ext(f.u);
+    const ev = ext(f.v);
+    return b.vertex({
+      p,
+      n,
+      uv: [
+        rect.u0 + (dot3(rel, f.u) + eu) / rect.metres * (rect.u1 - rect.u0),
+        rect.v0 + (dot3(rel, f.v) + ev) / (2 * ev) * (rect.v1 - rect.v0)
+      ],
+      color: o.color
+    });
+  };
+  const poly = (corners, n) => {
+    const pts = corners.map(([s, k]) => point(s, k));
+    const [a = n, c = n, d = n] = pts;
+    const e1 = [c[0] - a[0], c[1] - a[1], c[2] - a[2]];
+    const e2 = [d[0] - a[0], d[1] - a[1], d[2] - a[2]];
+    const g = [
+      e1[1] * e2[2] - e1[2] * e2[1],
+      e1[2] * e2[0] - e1[0] * e2[2],
+      e1[0] * e2[1] - e1[1] * e2[0]
+    ];
+    const ids = corners.map(([s, k]) => put(s, k, n));
+    if (dot3(g, n) < 0)
+      ids.reverse();
+    const [i0 = 0, i1 = 0, i2 = 0, i3] = ids;
+    if (i3 === undefined)
+      b.tri(i0, i1, i2);
+    else
+      b.quad(i0, i1, i2, i3);
+  };
+  const unit = (k, s) => [k === 0 ? s : 0, k === 1 ? s : 0, k === 2 ? s : 0];
+  const corner = (k, sk, l, sl, m, sm) => {
+    const s = [1, 1, 1];
+    s[k] = sk;
+    s[l] = sl;
+    s[m] = sm;
+    return s;
+  };
+  for (let k = 0;k < 3; k++) {
+    const [l, m] = [(k + 1) % 3, (k + 2) % 3];
+    for (const sk of SIGNS) {
+      if (o.omit.includes((FACES[k * 2 + (sk > 0 ? 0 : 1)] ?? { name: "top" }).name))
+        continue;
+      const ring = [
+        [-1, -1],
+        [1, -1],
+        [1, 1],
+        [-1, 1]
+      ].map(([a, c]) => [corner(k, sk, l, a, m, c), k]);
+      poly(ring, unit(k, sk));
+    }
+  }
+  for (let m = 0;m < 3; m++) {
+    const [k, l] = [(m + 1) % 3, (m + 2) % 3];
+    for (const sk of SIGNS)
+      for (const sl of SIGNS) {
+        const lo = corner(k, sk, l, sl, m, -1);
+        const hi = corner(k, sk, l, sl, m, 1);
+        const n = normalize2([0, 1, 2].map((j) => j === k ? sk : j === l ? sl : 0));
+        poly([
+          [lo, k],
+          [hi, k],
+          [hi, l],
+          [lo, l]
+        ], n);
+      }
+  }
+  for (const sx of SIGNS)
+    for (const sy of SIGNS)
+      for (const sz of SIGNS) {
+        const s = [sx, sy, sz];
+        poly([
+          [s, 0],
+          [s, 1],
+          [s, 2]
+        ], normalize2([sx, sy, sz]));
+      }
+  return b.build();
+}
+
+// src/primitives/check.ts
+function invalid(cause, fix) {
+  throw new Ts23dError2("T3D_RECIPE_INVALID", { cause, fix });
+}
+var finite = (v) => v.every(Number.isFinite);
+function spanOf(what, origin, u, v) {
+  if (!finite(origin) || !finite(u) || !finite(v))
+    invalid(`${what}: origin/u/v has a NaN or Infinity`, "pass finite metre vectors");
+  const lu = length2(u);
+  const lv = length2(v);
+  if (lu < 0.000000001 || lv < 0.000000001)
+    invalid(`${what}: edge u (${lu} m) or v (${lv} m) has zero length`, "give u and v the face edges in metres, both non-zero (e.g. u: [4, 0, 0], v: [0, 0, 3])");
+  const c = cross2(u, v);
+  const lc = length2(c);
+  if (lc < 0.000001 * lu * lv)
+    invalid(`${what}: u and v are parallel, so the face has no area`, "make v perpendicular to u (u along the face, v up it)");
+  return { lu, lv, n: [c[0] / lc, c[1] / lc, c[2] / lc] };
+}
+function count(what, n, min, max) {
+  if (!Number.isInteger(n) || n < min || n > max)
+    invalid(`${what} is ${n}`, `use a whole number from ${min} to ${max}`);
+  return n;
+}
+function positive(what, n, example) {
+  if (!Number.isFinite(n) || n <= 0)
+    invalid(`${what} is ${n}`, `use a length > 0 m (${example})`);
+  return n;
+}
+
+// src/primitives/box.ts
+var FACES2 = [
+  { name: "front", n: [1, 0, 0], u: [0, 1, 0], v: [0, 0, 1] },
+  { name: "back", n: [-1, 0, 0], u: [0, -1, 0], v: [0, 0, 1] },
+  { name: "right", n: [0, -1, 0], u: [1, 0, 0], v: [0, 0, 1] },
+  { name: "left", n: [0, 1, 0], u: [-1, 0, 0], v: [0, 0, 1] },
+  { name: "top", n: [0, 0, 1], u: [1, 0, 0], v: [0, 1, 0] },
+  { name: "bottom", n: [0, 0, -1], u: [1, 0, 0], v: [0, -1, 0] }
+];
+function box2(o) {
+  const [w, d, h] = o.size;
+  const [cx, cy, cz] = o.at ?? [0, 0, 0];
+  const half = [w / 2, d / 2, h / 2];
+  const centre = [cx, cy, cz + h / 2];
+  const bevel = o.bevel ?? 0;
+  if (bevel !== 0) {
+    const limit = Math.min(w, d, h) / 2;
+    if (!(bevel > 0 && bevel < limit))
+      invalid(`box bevel ${bevel} m does not fit a ${w} × ${d} × ${h} m box`, `use 0 < bevel < ${limit} m (half the smallest size), e.g. ${Math.min(0.02, limit / 4)}`);
+    return bevelBox({
+      half,
+      centre,
+      bevel,
+      color: o.color,
+      strip: o.strip ?? "plain",
+      omit: o.omit ?? []
+    });
+  }
+  const rect = stripRect2(o.strip ?? "plain");
+  const b = new MeshBuilder2;
+  for (const f of FACES2) {
+    if (o.omit?.includes(f.name))
+      continue;
+    const extent = (axis) => Math.abs(axis[0]) * half[0] + Math.abs(axis[1]) * half[1] + Math.abs(axis[2]) * half[2];
+    const eu = extent(f.u);
+    const ev = extent(f.v);
+    const en = extent(f.n);
+    const ids = [
+      [-1, -1],
+      [1, -1],
+      [1, 1],
+      [-1, 1]
+    ].map(([su = 0, sv = 0]) => {
+      const p = [0, 1, 2].map((k) => (centre[k] ?? 0) + (f.n[k] ?? 0) * en + (f.u[k] ?? 0) * eu * su + (f.v[k] ?? 0) * ev * sv);
+      const uMetres = (su + 1) / 2 * eu * 2;
+      const vFrac = (sv + 1) / 2;
+      return b.vertex({
+        p,
+        n: f.n,
+        uv: [
+          rect.u0 + uMetres / rect.metres * (rect.u1 - rect.u0),
+          rect.v0 + vFrac * (rect.v1 - rect.v0)
+        ],
+        color: o.color
+      });
+    });
+    const [a = 0, c = 0, e = 0, g = 0] = ids;
+    b.quad(a, c, e, g);
+  }
+  return b.build();
+}
+
+// src/primitives/lathe-facets.ts
+function facets(o, put, tri, sideUv) {
+  const half = Math.PI / o.segments;
+  const corner = (s) => {
+    const t = s / o.segments * Math.PI * 2 - Math.PI / 2;
+    return [Math.cos(t), Math.sin(t)];
+  };
+  for (let i = 0;i + 1 < o.profile.length; i++) {
+    const [r0 = 0, z0 = 0] = o.profile[i] ?? [];
+    const [r1 = 0, z1 = 0] = o.profile[i + 1] ?? [];
+    for (let s = 0;s < o.segments; s++) {
+      const tm = (s + 0.5) / o.segments * Math.PI * 2 - Math.PI / 2;
+      const nx = (z1 - z0) * Math.cos(tm);
+      const ny = (z1 - z0) * Math.sin(tm);
+      const nz = -(r1 - r0) * Math.cos(half);
+      const l = Math.hypot(nx, ny, nz) || 1;
+      const n = [nx / l, ny / l, nz / l];
+      const [c0, s0] = corner(s);
+      const [c1, s1] = corner(s + 1);
+      const a = put([r0 * c0, r0 * s0, z0], n, sideUv(s, i, r0));
+      const bb = put([r0 * c1, r0 * s1, z0], n, sideUv(s + 1, i, r0));
+      const c = put([r1 * c1, r1 * s1, z1], n, sideUv(s + 1, i + 1, r1));
+      const d = put([r1 * c0, r1 * s0, z1], n, sideUv(s, i + 1, r1));
+      tri(a, bb, c);
+      tri(a, c, d);
+    }
+  }
+}
+
+// src/primitives/strip-uv.ts
+var HALF_TEXEL = 0.5 / TRIM_SHEET_SIZE2;
+var stripVMetres = (id) => DEFAULT_SHEET2.strips[id]?.scaleMetres ?? 1;
+var stripU = (rect, metres) => rect.u0 + metres / rect.metres * (rect.u1 - rect.u0);
+var stripV = (rect, frac) => rect.v0 + HALF_TEXEL + frac * (rect.v1 - rect.v0 - 2 * HALF_TEXEL);
+function mirroredV(rect, metres, vMetres) {
+  const t = metres / vMetres;
+  const m = t - 2 * Math.floor(t / 2);
+  return stripV(rect, m <= 1 ? m : 2 - m);
+}
+
+// src/primitives/lathe.ts
+var orient = (p, axis) => axis === "z" ? p : axis === "y" ? [p[0], p[2], p[1]] : [p[2], p[1], p[0]];
+function lathe2(o) {
+  const axis = o.axis ?? "z";
+  const [ox, oy, oz] = o.at ?? [0, 0, 0];
+  const rect = stripRect2(o.strip ?? "plain");
+  const b = new MeshBuilder2;
+  const mirrored = axis !== "z";
+  const tri = (x, y, z) => {
+    if (mirrored)
+      b.tri(x, z, y);
+    else
+      b.tri(x, y, z);
+  };
+  const ring = [];
+  const put = (p, n, uv) => {
+    const q = orient(p, axis);
+    return b.vertex({
+      p: [q[0] + ox, q[1] + oy, q[2] + oz],
+      n: orient(n, axis),
+      uv,
+      color: o.color
+    });
+  };
+  const metres = o.uv === "metres";
+  const vm = stripVMetres(o.strip ?? "plain");
+  const run = [0];
+  for (let i = 1;i < o.profile.length; i++) {
+    const [r0 = 0, z0 = 0] = o.profile[i - 1] ?? [];
+    const [r1 = 0, z1 = 0] = o.profile[i] ?? [];
+    run.push((run[i - 1] ?? 0) + Math.hypot(r1 - r0, z1 - z0));
+  }
+  const sideUv = (s, i, r) => metres ? [stripU(rect, Math.PI * 2 * r * s / o.segments), mirroredV(rect, run[i] ?? 0, vm)] : [
+    rect.u0 + s / o.segments * (rect.u1 - rect.u0),
+    rect.v0 + i / Math.max(1, o.profile.length - 1) * (rect.v1 - rect.v0)
+  ];
+  const capUv = (c, sn, r) => metres ? [stripU(rect, c * r), mirroredV(rect, (sn + 1) * r, vm)] : [
+    rect.u0 + (0.5 + c / 2) * (rect.u1 - rect.u0),
+    rect.v0 + (0.5 + sn / 2) * (rect.v1 - rect.v0)
+  ];
+  const creaseCos = Math.cos((o.creaseDeg ?? 50) * Math.PI / 180);
+  const emitRing = (i, dr, dz) => {
+    const [r, z] = o.profile[i] ?? [0, 0];
+    const len = Math.hypot(dr, dz) || 1;
+    const row = [];
+    for (let s = 0;s <= o.segments; s++) {
+      const t = s / o.segments * Math.PI * 2 - Math.PI / 2;
+      const c = Math.cos(t);
+      const sn = Math.sin(t);
+      row.push(put([r * c, r * sn, z], [dz / len * c, dz / len * sn, -dr / len], sideUv(s, i, r)));
+    }
+    return row;
+  };
+  const top = [];
+  if (o.faceted)
+    facets(o, put, tri, sideUv);
+  else
+    o.profile.forEach(([r, z], i) => {
+      const prev = o.profile[i - 1] ?? o.profile[i] ?? [r, z];
+      const next = o.profile[i + 1] ?? o.profile[i] ?? [r, z];
+      const ir = r - prev[0];
+      const iz = z - prev[1];
+      const or = next[0] - r;
+      const oz = next[1] - z;
+      const li = Math.hypot(ir, iz);
+      const lo = Math.hypot(or, oz);
+      if (li > 0.000000000001 && lo > 0.000000000001 && (ir * or + iz * oz) / (li * lo) < creaseCos) {
+        top.push(emitRing(i, ir, iz));
+        ring.push(emitRing(i, or, oz));
+        return;
+      }
+      const row = emitRing(i, next[0] - prev[0], next[1] - prev[1]);
+      top.push(row);
+      ring.push(row);
+    });
+  for (let i = 0;i + 1 < ring.length; i++) {
+    for (let s = 0;s < o.segments; s++) {
+      const a = ring[i]?.[s] ?? 0;
+      const bb = ring[i]?.[s + 1] ?? 0;
+      const c = top[i + 1]?.[s + 1] ?? 0;
+      const d = top[i + 1]?.[s] ?? 0;
+      tri(a, bb, c);
+      tri(a, c, d);
+    }
+  }
+  if (o.caps) {
+    const ends = [
+      { pt: o.profile[0], n: -1 },
+      { pt: o.profile[o.profile.length - 1], n: 1 }
+    ];
+    for (const { pt, n } of ends) {
+      if (!pt)
+        continue;
+      const centre = put([0, 0, pt[1]], [0, 0, n], capUv(0, 0, pt[0]));
+      const rim = [];
+      for (let s = 0;s <= o.segments; s++) {
+        const t = s / o.segments * Math.PI * 2 - Math.PI / 2;
+        rim.push(put([pt[0] * Math.cos(t), pt[0] * Math.sin(t), pt[1]], [0, 0, n], capUv(Math.cos(t), Math.sin(t), pt[0])));
+      }
+      for (let s = 0;s < o.segments; s++) {
+        const r0 = rim[s] ?? 0;
+        const r1 = rim[s + 1] ?? 0;
+        if (n > 0)
+          tri(centre, r0, r1);
+        else
+          tri(centre, r1, r0);
+      }
+    }
+  }
+  return b.build();
+}
+var cylinder2 = (o) => lathe2({
+  ...o,
+  profile: [
+    [o.radius, -o.length / 2],
+    [o.radius, o.length / 2]
+  ],
+  caps: true
+});
+
+// src/primitives/beam.ts
+function beam2(o) {
+  const dir = sub2(o.to, o.from);
+  const len = length2(dir);
+  const w = normalize2(dir);
+  const ref = o.up ?? (Math.abs(w[2]) > 0.95 ? [1, 0, 0] : [0, 0, 1]);
+  const u = normalize2(cross2(ref, w));
+  const v = cross2(w, u);
+  const local = o.segments && o.segments >= 3 ? lathe2({
+    profile: [
+      [o.width / 2, 0],
+      [o.width / 2, len]
+    ],
+    segments: o.segments,
+    color: o.color,
+    caps: o.caps ?? true,
+    ...o.strip ? { strip: o.strip } : {}
+  }) : box2({
+    size: [o.width, o.height ?? o.width, len],
+    ...o.caps === false ? { omit: ["top", "bottom"] } : {},
+    color: o.color,
+    ...o.strip ? { strip: o.strip } : {}
+  });
+  return applyAffine2(local, frame2(u, v, w, o.from));
+}
+// src/primitives/cell.ts
+var add3 = (a, b, s) => [
+  a[0] + b[0] * s,
+  a[1] + b[1] * s,
+  a[2] + b[2] * s
+];
+function cell2(o) {
+  const { lu, lv, n } = spanOf("cell", o.origin, o.u, o.v);
+  const d = o.inset ?? 0;
+  if (!Number.isFinite(d))
+    invalid(`cell inset is ${d}`, "use a finite depth in metres (0.1 = a 10 cm recess)");
+  if (d !== 0 && o.doubleSided)
+    invalid("cell: inset with doubleSided", "drop doubleSided for a recessed/raised panel, or set inset: 0");
+  const r = cellRect2(o.cell);
+  const e = HALF_TEXEL;
+  const rim = [
+    o.origin,
+    add3(o.origin, o.u, 1),
+    add3(add3(o.origin, o.u, 1), o.v, 1),
+    add3(o.origin, o.v, 1)
+  ];
+  const face = rim.map((p) => add3(p, n, -d));
+  const uvs = [
+    [r.u0 + e, r.v0 + e],
+    [r.u1 - e, r.v0 + e],
+    [r.u1 - e, r.v1 - e],
+    [r.u0 + e, r.v1 - e]
+  ];
+  const b = new MeshBuilder2;
+  for (const side of o.doubleSided ? [1, -1] : [1]) {
+    const nn = [n[0] * side, n[1] * side, n[2] * side];
+    const [i0 = 0, i1 = 0, i2 = 0, i3 = 0] = face.map((p, k) => b.vertex({ p, n: nn, uv: uvs[k] ?? [0, 0], color: o.color }));
+    if (side > 0)
+      b.quad(i0, i1, i2, i3);
+    else
+      b.quad(i0, i3, i2, i1);
+  }
+  if (d !== 0)
+    reveals(b, o, rim, face, n, d, [lu, lv, lu, lv]);
+  return b.build();
+}
+function reveals(b, o, rim, face, n, d, lens) {
+  const strip = o.reveal ?? "plain";
+  const rect = stripRect2(strip);
+  const fv = Math.min(1, Math.abs(d) / stripVMetres(strip));
+  const color = o.revealColor ?? o.color;
+  for (let i = 0;i < 4; i++) {
+    const a = rim[i] ?? n;
+    const c = rim[(i + 1) % 4] ?? n;
+    const ed = [c[0] - a[0], c[1] - a[1], c[2] - a[2]];
+    const s = Math.sign(d);
+    const nn = normalize2([
+      (n[1] * ed[2] - n[2] * ed[1]) * s,
+      (n[2] * ed[0] - n[0] * ed[2]) * s,
+      (n[0] * ed[1] - n[1] * ed[0]) * s
+    ]);
+    const len = lens[i] ?? 0;
+    const q = [a, c, face[(i + 1) % 4] ?? c, face[i] ?? a];
+    const uv = [
+      [stripU(rect, 0), stripV(rect, 0)],
+      [stripU(rect, len), stripV(rect, 0)],
+      [stripU(rect, len), stripV(rect, fv)],
+      [stripU(rect, 0), stripV(rect, fv)]
+    ];
+    const [j0 = 0, j1 = 0, j2 = 0, j3 = 0] = q.map((p, k) => b.vertex({ p, n: nn, uv: uv[k] ?? [0, 0], color }));
+    b.quad(j0, j1, j2, j3);
+  }
+}
+// src/primitives/erosion.ts
+var put = (h, dep, k, a) => {
+  h[k] = (h[k] ?? 0) + a;
+  dep[k] = (dep[k] ?? 0) + a;
+};
+function makeBrush(radius) {
+  const dx = [];
+  const dy = [];
+  const w = [];
+  for (let y = -radius;y <= radius; y++)
+    for (let x = -radius;x <= radius; x++) {
+      const d = Math.sqrt(x * x + y * y);
+      if (d < radius) {
+        dx.push(x);
+        dy.push(y);
+        w.push(radius - d);
+      }
+    }
+  const sum = w.reduce((s, v) => s + v, 0);
+  return {
+    dx: Int32Array.from(dx),
+    dy: Int32Array.from(dy),
+    w: Float64Array.from(w, (v) => v / sum)
+  };
+}
+function droplet(s, b, x0, y0) {
+  const { h, nx, ny } = s;
+  let x = x0;
+  let y = y0;
+  let dx = 0;
+  let dy = 0;
+  let speed = 1;
+  let water = 1;
+  let sediment = 0;
+  for (let step = 0;step < s.life; step++) {
+    const i = Math.floor(x);
+    const j = Math.floor(y);
+    const u = x - i;
+    const v = y - j;
+    const k = j * nx + i;
+    const a = h[k] ?? 0;
+    const bb = h[k + 1] ?? 0;
+    const c = h[k + nx] ?? 0;
+    const d = h[k + nx + 1] ?? 0;
+    const height = a * (1 - u) * (1 - v) + bb * u * (1 - v) + c * (1 - u) * v + d * u * v;
+    const gx = (bb - a) * (1 - v) + (d - c) * v;
+    const gy = (c - a) * (1 - u) + (d - bb) * u;
+    dx = dx * s.inertia - gx * (1 - s.inertia);
+    dy = dy * s.inertia - gy * (1 - s.inertia);
+    const len = Math.sqrt(dx * dx + dy * dy);
+    if (len === 0)
+      return;
+    dx /= len;
+    dy /= len;
+    x += dx;
+    y += dy;
+    s.flow[k] = (s.flow[k] ?? 0) + water;
+    if (x < 0 || y < 0 || x >= nx - 1 || y >= ny - 1)
+      return;
+    const dh = bilinear(h, nx, x, y) - height;
+    const cap = Math.max(-dh * speed * water * s.capK, s.minCap);
+    if (sediment > cap || dh > 0) {
+      const amount = dh > 0 ? Math.min(dh, sediment) : (sediment - cap) * s.depositK;
+      sediment -= amount;
+      put(h, s.dep, k, amount * (1 - u) * (1 - v));
+      put(h, s.dep, k + 1, amount * u * (1 - v));
+      put(h, s.dep, k + nx, amount * (1 - u) * v);
+      put(h, s.dep, k + nx + 1, amount * u * v);
+    } else {
+      const amount = Math.min((cap - sediment) * s.erodeK, -dh);
+      for (let n = 0;n < b.w.length; n++) {
+        const ci = i + (b.dx[n] ?? 0);
+        const cj = j + (b.dy[n] ?? 0);
+        if (ci < 0 || cj < 0 || ci >= nx || cj >= ny)
+          continue;
+        const cell = cj * nx + ci;
+        const take = Math.min(h[cell] ?? 0, amount * (b.w[n] ?? 0));
+        h[cell] = (h[cell] ?? 0) - take;
+        sediment += take;
+      }
+    }
+    speed = Math.sqrt(Math.max(0, speed * speed - dh * s.gravity));
+    water *= 1 - s.evap;
+  }
+}
+function bilinear(h, nx, x, y) {
+  const i = Math.floor(x);
+  const j = Math.floor(y);
+  const u = x - i;
+  const v = y - j;
+  const k = j * nx + i;
+  const a = h[k] ?? 0;
+  const b = h[k + 1] ?? 0;
+  const c = h[k + nx] ?? 0;
+  const d = h[k + nx + 1] ?? 0;
+  return a * (1 - u) * (1 - v) + b * u * (1 - v) + c * (1 - u) * v + d * u * v;
+}
+function hydraulicErosion2(g, rng, o = {}) {
+  const drops = count("erosion droplets", o.droplets ?? 70000, 0, 1e7);
+  const life = count("erosion lifetime", o.lifetime ?? 30, 1, 1000);
+  const radius = count("erosion radius", o.radius ?? 3, 1, 32);
+  const { nx, ny } = g;
+  let lo = Number.POSITIVE_INFINITY;
+  let hi = Number.NEGATIVE_INFINITY;
+  for (const v of g.z) {
+    lo = Math.min(lo, v);
+    hi = Math.max(hi, v);
+  }
+  const relief = hi - lo || 1;
+  const h = Float64Array.from(g.z, (v) => (v - lo) / relief);
+  const flow = new Float64Array(h.length);
+  const dep = new Float64Array(h.length);
+  const sim = {
+    ...{ h, flow, dep, nx, ny, life, inertia: o.inertia ?? 0.05, capK: o.capacity ?? 4 },
+    ...{ minCap: o.minCapacity ?? 0.01, erodeK: o.erode ?? 0.3, depositK: o.deposit ?? 0.3 },
+    ...{ evap: o.evaporate ?? 0.01, gravity: o.gravity ?? 4 }
+  };
+  const brush = makeBrush(radius);
+  for (let n = 0;n < drops; n++)
+    droplet(sim, brush, rng.next() * (nx - 2), rng.next() * (ny - 2));
+  const norm = (m) => {
+    let top = 0;
+    for (const v of m)
+      top = Math.max(top, v);
+    return top > 0 ? m.map((v) => Math.sqrt(v / top)) : m;
+  };
+  return { ...g, z: h.map((v) => lo + v * relief), flow: norm(flow), deposit: norm(dep) };
+}
+// src/primitives/heightfield.ts
+function heightfield2(o) {
+  const [x0, y0, x1, y1] = o.rect;
+  const [nx, ny] = o.cells;
+  const dx = (x1 - x0) / nx;
+  const dy = (y1 - y0) / ny;
+  const rect = stripRect2(o.strip ?? "plain");
+  const vm = stripVMetres(o.strip ?? "plain");
+  const b = new MeshBuilder2;
+  const ids = [];
+  for (let j = 0;j <= ny; j++) {
+    for (let i = 0;i <= nx; i++) {
+      const x = x0 + i * dx;
+      const y = y0 + j * dy;
+      const z = o.height(x, y);
+      const n = normalize2([
+        o.height(x - dx, y) - o.height(x + dx, y),
+        o.height(x, y - dy) - o.height(x, y + dy),
+        2 * Math.min(dx, dy)
+      ]);
+      const color = typeof o.color === "function" ? o.color(x, y, z) : o.color;
+      const u = (x - x0) / rect.metres;
+      ids.push(b.vertex({
+        p: [x, y, z],
+        n,
+        uv: [rect.u0 + u * (rect.u1 - rect.u0), mirroredV(rect, y - y0, vm)],
+        color
+      }));
+    }
+  }
+  const at = (i, j) => ids[j * (nx + 1) + i] ?? 0;
+  for (let j = 0;j < ny; j++)
+    for (let i = 0;i < nx; i++)
+      b.quad(at(i, j), at(i + 1, j), at(i + 1, j + 1), at(i, j + 1));
+  if (o.skirt !== undefined)
+    skirt(b, o, rect);
+  return b.build();
+}
+function skirt(b, o, rect) {
+  const [x0, y0, x1, y1] = o.rect;
+  const [nx, ny] = o.cells;
+  const base = o.skirt ?? 0;
+  const edges = [
+    [x0, y0, (x1 - x0) / nx, 0, nx, [0, -1, 0]],
+    [x1, y0, 0, (y1 - y0) / ny, ny, [1, 0, 0]],
+    [x1, y1, -(x1 - x0) / nx, 0, nx, [0, 1, 0]],
+    [x0, y1, 0, -(y1 - y0) / ny, ny, [-1, 0, 0]]
+  ];
+  const col = (x, y, z) => o.skirtColor ?? (typeof o.color === "function" ? o.color(x, y, z) : o.color);
+  const v = (x, y, z, n, u, color) => b.vertex({
+    p: [x, y, z],
+    n,
+    uv: [rect.u0 + u / rect.metres * (rect.u1 - rect.u0), z > base ? rect.v1 : rect.v0],
+    color
+  });
+  let run = 0;
+  for (const [sx, sy, dx, dy, n, nrm] of edges) {
+    const step = Math.hypot(dx, dy);
+    for (let k = 0;k < n; k++) {
+      const [ax, ay, bx, by] = [sx + dx * k, sy + dy * k, sx + dx * (k + 1), sy + dy * (k + 1)];
+      const az = o.height(ax, ay);
+      const bz = o.height(bx, by);
+      const ca = col(ax, ay, az);
+      const cb = col(bx, by, bz);
+      const ta = v(ax, ay, az, nrm, run, ca);
+      const tb = v(bx, by, bz, nrm, run + step, cb);
+      b.quad(v(ax, ay, base, nrm, run, ca), v(bx, by, base, nrm, run + step, cb), tb, ta);
+      run += step;
+    }
+  }
+}
+// src/primitives/triangulate.ts
+var area = (p) => p.reduce((s, a, i) => {
+  const b = p[(i + 1) % p.length] ?? a;
+  return s + a[0] * b[1] - b[0] * a[1];
+}, 0) / 2;
+var cross = (a, b, c) => (b[0] - a[0]) * (c[1] - a[1]) - (b[1] - a[1]) * (c[0] - a[0]);
+function inside(p, a, b, c) {
+  return cross(a, b, p) >= 0 && cross(b, c, p) >= 0 && cross(c, a, p) >= 0;
+}
+function triangulate2(poly) {
+  const idx = poly.map((_, i) => i);
+  if (area(poly) < 0)
+    idx.reverse();
+  const out = [];
+  let guard = idx.length * idx.length;
+  while (idx.length > 3 && guard-- > 0) {
+    for (let i = 0;i < idx.length; i++) {
+      const ia = idx[(i + idx.length - 1) % idx.length] ?? 0;
+      const ib = idx[i] ?? 0;
+      const ic = idx[(i + 1) % idx.length] ?? 0;
+      const a = poly[ia] ?? [0, 0];
+      const b = poly[ib] ?? [0, 0];
+      const c = poly[ic] ?? [0, 0];
+      if (cross(a, b, c) <= 0)
+        continue;
+      if (idx.some((j) => j !== ia && j !== ib && j !== ic && inside(poly[j] ?? [0, 0], a, b, c)))
+        continue;
+      out.push([ia, ib, ic]);
+      idx.splice(i, 1);
+      break;
+    }
+  }
+  if (idx.length === 3)
+    out.push([idx[0] ?? 0, idx[1] ?? 0, idx[2] ?? 0]);
+  return out;
+}
+
+// src/primitives/member.ts
+function section(kind, w) {
+  const h = w / 2;
+  const t = w * 0.15;
+  const ring = kind === "square" ? [
+    [-h, -h],
+    [h, -h],
+    [h, h],
+    [-h, h]
+  ] : [
+    [-h, -h],
+    [h, -h],
+    [h, -h + t],
+    [-h + t, -h + t],
+    [-h + t, h],
+    [-h, h]
+  ];
+  const lens = ring.map((a, i) => {
+    const b = ring[(i + 1) % ring.length] ?? a;
+    return Math.hypot(b[0] - a[0], b[1] - a[1]);
+  });
+  const total = lens.reduce((s, l) => s + l, 0);
+  let acc = 0;
+  const run = lens.map((l) => {
+    const r = acc / total;
+    acc += l;
+    return r;
+  });
+  return { ring, caps: triangulate2(ring), run, sideTris: ring.length * 2 };
+}
+function emitMember(mb, s, a, b, y, caps, color, rect) {
+  const d = [b[0] - a[0], b[1] - a[1], b[2] - a[2]];
+  const len = Math.sqrt(d[0] * d[0] + d[1] * d[1] + d[2] * d[2]);
+  const w = [d[0] / len, d[1] / len, d[2] / len];
+  const k = y[0] * w[0] + y[1] * w[1] + y[2] * w[2];
+  const yr = [y[0] - w[0] * k, y[1] - w[1] * k, y[2] - w[2] * k];
+  const yl = Math.sqrt(yr[0] * yr[0] + yr[1] * yr[1] + yr[2] * yr[2]);
+  const yy = [yr[0] / yl, yr[1] / yl, yr[2] / yl];
+  const x = [
+    yy[1] * w[2] - yy[2] * w[1],
+    yy[2] * w[0] - yy[0] * w[2],
+    yy[0] * w[1] - yy[1] * w[0]
+  ];
+  const at = (p, end) => [
+    end[0] + x[0] * p[0] + yy[0] * p[1],
+    end[1] + x[1] * p[0] + yy[1] * p[1],
+    end[2] + x[2] * p[0] + yy[2] * p[1]
+  ];
+  const n = s.ring.length;
+  const u1 = stripU(rect, len);
+  const u0 = stripU(rect, 0);
+  for (let i = 0;i < n; i++) {
+    const p = s.ring[i] ?? [0, 0];
+    const q = s.ring[(i + 1) % n] ?? p;
+    const ex = q[0] - p[0];
+    const ey = q[1] - p[1];
+    const el = Math.hypot(ex, ey);
+    const nx = ey / el;
+    const ny = -ex / el;
+    const nrm = [x[0] * nx + yy[0] * ny, x[1] * nx + yy[1] * ny, x[2] * nx + yy[2] * ny];
+    const v0 = stripV(rect, s.run[i] ?? 0);
+    const v1 = stripV(rect, i + 1 < n ? s.run[i + 1] ?? 1 : 1);
+    const i0 = mb.vertex({ p: at(p, a), n: nrm, uv: [u0, v0], color });
+    const i1 = mb.vertex({ p: at(q, a), n: nrm, uv: [u0, v1], color });
+    const i2 = mb.vertex({ p: at(q, b), n: nrm, uv: [u1, v1], color });
+    const i3 = mb.vertex({ p: at(p, b), n: nrm, uv: [u1, v0], color });
+    mb.quad(i0, i1, i2, i3);
+  }
+  if (!caps)
+    return;
+  for (const [end, sign] of [
+    [a, -1],
+    [b, 1]
+  ]) {
+    const nrm = [w[0] * sign, w[1] * sign, w[2] * sign];
+    const first = mb.vertex({
+      p: at(s.ring[0] ?? [0, 0], end),
+      n: nrm,
+      uv: [u0, stripV(rect, 0)],
+      color
+    });
+    for (let i = 1;i < n; i++) {
+      const p = s.ring[i] ?? [0, 0];
+      mb.vertex({ p: at(p, end), n: nrm, uv: [u0, stripV(rect, s.run[i] ?? 0)], color });
+    }
+    for (const [i, j, l] of s.caps) {
+      if (sign > 0)
+        mb.tri(first + i, first + j, first + l);
+      else
+        mb.tri(first + i, first + l, first + j);
+    }
+  }
+}
+
+// src/primitives/lattice.ts
+function lattice2(o) {
+  const d = [o.to[0] - o.from[0], o.to[1] - o.from[1], o.to[2] - o.from[2]];
+  const len = Math.hypot(d[0], d[1], d[2]);
+  if (!(len > 0.000001))
+    invalid("lattice: from and to coincide", "give the truss two distinct end points in metres");
+  const depth = positive("lattice depth", o.depth, "e.g. 2 for a 2 m deep girder");
+  const chord = positive("lattice chord", o.chord, "e.g. 0.2");
+  if (chord >= depth)
+    invalid(`lattice chord ${chord} m ≥ depth ${depth} m`, "make the chord member thinner than the depth");
+  const web = positive("lattice web", o.web ?? chord * 0.6, "e.g. 0.6 · chord");
+  const k = count("lattice bays", o.bays ?? Math.max(1, Math.round(len / depth)), 1, 2000);
+  const w = normalize2(d);
+  const upHint = o.up ?? (Math.abs(w[2]) > 0.95 ? [1, 0, 0] : [0, 0, 1]);
+  const dotU = upHint[0] * w[0] + upHint[1] * w[1] + upHint[2] * w[2];
+  const upR = [upHint[0] - w[0] * dotU, upHint[1] - w[1] * dotU, upHint[2] - w[2] * dotU];
+  if (Math.hypot(upR[0], upR[1], upR[2]) < 0.000001)
+    invalid("lattice: up is parallel to from → to", "pass an `up` perpendicular to the truss axis");
+  const up = normalize2(upR);
+  const side = [
+    w[1] * up[2] - w[2] * up[1],
+    w[2] * up[0] - w[0] * up[2],
+    w[0] * up[1] - w[1] * up[0]
+  ];
+  const dEnd = positive("lattice depthEnd", o.depthEnd ?? depth, "e.g. 1");
+  const wid = o.width === undefined ? 0 : positive("lattice width", o.width, "e.g. 2");
+  const wEnd = o.width === undefined ? 0 : positive("lattice widthEnd", o.widthEnd ?? wid, "e.g. 1");
+  const c0 = o.centred ? -0.5 : 0;
+  const line = (a, c) => (t) => {
+    const along = len * t;
+    const lat = a * (wid + (wEnd - wid) * t) / 2;
+    const h = (c0 + c) * (depth + (dEnd - depth) * t);
+    return [
+      o.from[0] + w[0] * along + side[0] * lat + up[0] * h,
+      o.from[1] + w[1] * along + side[1] * lat + up[1] * h,
+      o.from[2] + w[2] * along + side[2] * lat + up[2] * h
+    ];
+  };
+  const neg = (v) => [-v[0], -v[1], -v[2]];
+  const faces = o.width === undefined ? [[line(0, 0), line(0, 1), side]] : [
+    [line(-1, 0), line(-1, 1), neg(side)],
+    [line(1, 0), line(1, 1), side],
+    [line(-1, 1), line(1, 1), up],
+    [line(-1, 0), line(1, 0), neg(up)]
+  ];
+  const chords = o.width === undefined ? [line(0, 0), line(0, 1)] : [line(-1, 0), line(1, 0), line(-1, 1), line(1, 1)];
+  const rect = stripRect2(o.strip ?? "iron");
+  const sc = section(o.section ?? "square", chord);
+  const sw = section(o.section ?? "square", web);
+  const mb = new MeshBuilder2;
+  for (const c of chords)
+    emitMember(mb, sc, c(0), c(1), up, true, o.color, rect);
+  for (const [lo, hi, n] of faces)
+    for (const [ta, la, tb, lb] of webMembers(o.pattern ?? "warren", k))
+      emitMember(mb, sw, (la ? hi : lo)(ta), (lb ? hi : lo)(tb), n, false, o.color, rect);
+  return mb.build();
+}
+function webMembers(pattern, k) {
+  const out = [];
+  const t = (i) => i / k;
+  if (pattern !== "warren")
+    for (let i = 0;i <= k; i++)
+      out.push([t(i), false, t(i), true]);
+  for (let i = 0;i < k; i++) {
+    const down = [t(i), true, t(i + 1), false];
+    const rise = [t(i), false, t(i + 1), true];
+    const middle = k % 2 === 1 && i === (k - 1) / 2;
+    const left = i < k / 2;
+    if (pattern === "warren")
+      out.push(i % 2 === 0 ? rise : down);
+    else if (pattern === "x" || middle)
+      out.push(rise, down);
+    else if (pattern === "pratt")
+      out.push(left ? down : rise);
+    else
+      out.push(left ? rise : down);
+  }
+  return out;
+}
+// src/primitives/loft.ts
+function ringXY2(centre, rx, ry, segments, wobble, phase = 0) {
+  const out = [];
+  for (let k = 0;k < segments; k++) {
+    const a = phase + k / segments * Math.PI * 2;
+    const w = wobble ? wobble(a) : 1;
+    out.push([centre[0] + rx * Math.cos(a) * w, centre[1] + ry * Math.sin(a) * w, centre[2]]);
+  }
+  return out;
+}
+var invalid2 = (cause, fix) => new Ts23dError2("T3D_RECIPE_INVALID", { cause, fix });
+var centroid = (r) => {
+  let x = 0;
+  let y = 0;
+  let z = 0;
+  for (const p of r) {
+    x += p[0];
+    y += p[1];
+    z += p[2];
+  }
+  return [x / r.length, y / r.length, z / r.length];
+};
+function loft2(o) {
+  const R = o.rings.length;
+  if (R < 2)
+    throw invalid2(`loft has ${R} ring(s)`, "pass at least 2 rings (bottom → top)");
+  const N = o.rings[0]?.length ?? 0;
+  if (N < 3)
+    throw invalid2(`loft rings have ${N} vertices`, "give every ring at least 3 vertices");
+  for (const [i, r] of o.rings.entries()) {
+    if (r.length !== N) {
+      throw invalid2(`loft ring ${i} has ${r.length} vertices, ring 0 has ${N}`, "build every ring with the same vertex count (same `segments` in ringXY)");
+    }
+  }
+  const at = (i, k) => o.rings[i]?.[(k % N + N) % N] ?? [0, 0, 0];
+  const cents = o.rings.map(centroid);
+  const along = [0];
+  for (let i = 1;i < R; i++) {
+    const a = cents[i - 1] ?? [0, 0, 0];
+    const b = cents[i] ?? a;
+    along.push((along[i - 1] ?? 0) + Math.hypot(b[0] - a[0], b[1] - a[1], b[2] - a[2]));
+  }
+  const total = along[R - 1] || 1;
+  const raw = [];
+  let facing = 0;
+  for (let i = 0;i < R; i++) {
+    const c = cents[i] ?? [0, 0, 0];
+    const ax = cents[Math.min(R - 1, i + 1)] ?? c;
+    const bx = cents[Math.max(0, i - 1)] ?? c;
+    const axis = [ax[0] - bx[0], ax[1] - bx[1], ax[2] - bx[2]];
+    for (let k = 0;k < N; k++) {
+      const p = at(i, k);
+      const u0 = at(i, k - 1);
+      const u1 = at(i, k + 1);
+      const v0 = at(Math.max(0, i - 1), k);
+      const v1 = at(Math.min(R - 1, i + 1), k);
+      const tu = [u1[0] - u0[0], u1[1] - u0[1], u1[2] - u0[2]];
+      const tv = [v1[0] - v0[0], v1[1] - v0[1], v1[2] - v0[2]];
+      let n = [
+        tu[1] * tv[2] - tu[2] * tv[1],
+        tu[2] * tv[0] - tu[0] * tv[2],
+        tu[0] * tv[1] - tu[1] * tv[0]
+      ];
+      if (Math.hypot(n[0], n[1], n[2]) < 0.000000000001)
+        n = i === 0 ? [-axis[0], -axis[1], -axis[2]] : axis;
+      facing += n[0] * (p[0] - c[0]) + n[1] * (p[1] - c[1]) + n[2] * (p[2] - c[2]);
+      raw.push(n);
+    }
+  }
+  const flip = facing < 0 ? -1 : 1;
+  const rect = stripRect2(o.strip ?? "plain");
+  const du = rect.u1 - rect.u0;
+  const dv = rect.v1 - rect.v0;
+  const mode = o.uv ?? "length";
+  const color = (i, p) => typeof o.color === "function" ? o.color(o.rings[i] ?? [], i, p) : o.color;
+  const b = new MeshBuilder2;
+  for (let i = 0;i < R; i++) {
+    let around = 0;
+    for (let k = 0;k <= N; k++) {
+      const p = at(i, k);
+      if (k > 0) {
+        const q = at(i, k - 1);
+        around += Math.hypot(p[0] - q[0], p[1] - q[1], p[2] - q[2]);
+      }
+      const n = raw[i * N + k % N] ?? [0, 0, 1];
+      const l = (Math.hypot(n[0], n[1], n[2]) || 1) * flip;
+      const s = (along[i] ?? 0) / rect.metres;
+      const uv = mode === "row" ? [rect.u0 + around / rect.metres * du, rect.v0 + (along[i] ?? 0) / total * dv] : mode === "swap" ? [rect.u0 + k / N * du, rect.v0 + (along[i] ?? 0) / total * dv] : [rect.u0 + s * du, rect.v0 + k / N * dv];
+      b.vertex({ p, n: [n[0] / l, n[1] / l, n[2] / l], uv, color: color(i, p) });
+    }
+  }
+  for (let i = 0;i + 1 < R; i++) {
+    const r0 = i * (N + 1);
+    const r1 = r0 + N + 1;
+    for (let k = 0;k < N; k++) {
+      if (flip > 0)
+        b.quad(r0 + k, r0 + k + 1, r1 + k + 1, r1 + k);
+      else
+        b.quad(r0 + k, r1 + k, r1 + k + 1, r0 + k + 1);
+    }
+  }
+  const ends = [
+    [0, o.capStart === true],
+    [R - 1, o.capEnd === true]
+  ];
+  for (const [i, on] of ends) {
+    if (!on)
+      continue;
+    const c = cents[i] ?? [0, 0, 0];
+    const other = cents[i === 0 ? 1 : R - 2] ?? c;
+    const d = [c[0] - other[0], c[1] - other[1], c[2] - other[2]];
+    const l = Math.hypot(d[0], d[1], d[2]) || 1;
+    const nn = [d[0] / l, d[1] / l, d[2] / l];
+    const mid = b.vertex({ p: c, n: nn, uv: [rect.u0, rect.v0], color: color(i, c) });
+    for (let k = 0;k < N; k++) {
+      const p = at(i, k);
+      b.vertex({ p, n: nn, uv: [rect.u0, rect.v1], color: color(i, p) });
+    }
+    const e1 = at(i, 0);
+    const e2 = at(i, 1);
+    const cr = [
+      (e1[1] - c[1]) * (e2[2] - c[2]) - (e1[2] - c[2]) * (e2[1] - c[1]),
+      (e1[2] - c[2]) * (e2[0] - c[0]) - (e1[0] - c[0]) * (e2[2] - c[2]),
+      (e1[0] - c[0]) * (e2[1] - c[1]) - (e1[1] - c[1]) * (e2[0] - c[0])
+    ];
+    const ccw = cr[0] * nn[0] + cr[1] * nn[1] + cr[2] * nn[2] >= 0;
+    for (let k = 0;k < N; k++) {
+      const a = mid + 1 + k;
+      const z = mid + 1 + (k + 1) % N;
+      if (ccw)
+        b.tri(mid, a, z);
+      else
+        b.tri(mid, z, a);
+    }
+  }
+  return b.build();
+}
+// src/primitives/noise.ts
+var R = Math.SQRT1_2;
+var GX = [1, -1, 0, 0, R, -R, R, -R];
+var GY = [0, 0, 1, -1, R, R, -R, -R];
+function permutation(rng) {
+  const p = new Uint8Array(512);
+  for (let i = 0;i < 256; i++)
+    p[i] = i;
+  for (let i = 255;i > 0; i--) {
+    const j = rng.int(0, i);
+    const t = p[i] ?? 0;
+    p[i] = p[j] ?? 0;
+    p[j] = t;
+  }
+  for (let i = 0;i < 256; i++)
+    p[i + 256] = p[i] ?? 0;
+  return p;
+}
+var fade = (t) => t * t * t * (t * (t * 6 - 15) + 10);
+function gradientNoise22(rng) {
+  const p = permutation(rng);
+  const grad = (ix, iy, dx, dy) => {
+    const g = (p[(p[ix & 255] ?? 0) + (iy & 255)] ?? 0) & 7;
+    return (GX[g] ?? 0) * dx + (GY[g] ?? 0) * dy;
+  };
+  return (x, y) => {
+    const ix = Math.floor(x);
+    const iy = Math.floor(y);
+    const fx = x - ix;
+    const fy = y - iy;
+    const u = fade(fx);
+    const v = fade(fy);
+    const a = grad(ix, iy, fx, fy);
+    const b = grad(ix + 1, iy, fx - 1, fy);
+    const c = grad(ix, iy + 1, fx, fy - 1);
+    const d = grad(ix + 1, iy + 1, fx - 1, fy - 1);
+    const top = a + (b - a) * u;
+    return (top + (c + (d - c) * u - top) * v) * Math.SQRT2;
+  };
+}
+function valueNoise22(rng) {
+  const p = permutation(rng);
+  const vals = new Float64Array(256);
+  for (let i = 0;i < 256; i++)
+    vals[i] = rng.next() * 2 - 1;
+  const at = (ix, iy) => vals[p[(p[ix & 255] ?? 0) + (iy & 255)] ?? 0] ?? 0;
+  return (x, y) => {
+    const ix = Math.floor(x);
+    const iy = Math.floor(y);
+    const u = fade(x - ix);
+    const v = fade(y - iy);
+    const top = at(ix, iy) + (at(ix + 1, iy) - at(ix, iy)) * u;
+    const bot = at(ix, iy + 1) + (at(ix + 1, iy + 1) - at(ix, iy + 1)) * u;
+    return top + (bot - top) * v;
+  };
+}
+function fractal(n, o, shape) {
+  const s = 1 / (o.scale ?? 1);
+  const octaves = o.octaves ?? 5;
+  const lac = o.lacunarity ?? 2;
+  const gain = o.gain ?? 0.5;
+  return (x, y) => {
+    let sum = 0;
+    let amp = 1;
+    let norm = 0;
+    let f = s;
+    for (let i = 0;i < octaves; i++) {
+      sum += amp * shape(n(x * f + i * 17.31, y * f - i * 9.73));
+      norm += amp;
+      amp *= gain;
+      f *= lac;
+    }
+    return sum / norm;
+  };
+}
+var fbm2 = (n, o = {}) => fractal(n, o, (v) => v);
+var billow2 = (n, o = {}) => fractal(n, o, (v) => 2 * Math.abs(v) - 1);
+function ridged2(n, o = {}) {
+  const s = 1 / (o.scale ?? 1);
+  const octaves = o.octaves ?? 6;
+  const lac = o.lacunarity ?? 2;
+  const gain = o.gain ?? 0.5;
+  const offset = o.offset ?? 1;
+  return (x, y) => {
+    let sum = 0;
+    let norm = 0;
+    let amp = 1;
+    let weight = 1;
+    let f = s;
+    for (let i = 0;i < octaves; i++) {
+      const crest = offset - Math.abs(n(x * f + i * 17.31, y * f - i * 9.73));
+      const signal = crest * crest * weight;
+      weight = Math.min(1, Math.max(0, signal * 2));
+      sum += signal * amp;
+      norm += amp * offset * offset;
+      amp *= gain;
+      f *= lac;
+    }
+    return sum / norm;
+  };
+}
+var warp2 = (n, wx, wy, amount) => (x, y) => n(x + amount * wx(x, y), y + amount * wy(x, y));
+function terrace2(h, step, sharpness = 0.5) {
+  const k = Math.floor(h / step);
+  const t = h / step - k;
+  const s = Math.min(1, Math.max(0, sharpness));
+  const u = s >= 1 ? 0 : Math.min(1, Math.max(0, (t - s) / (1 - s)));
+  const riser = u * u * (3 - 2 * u);
+  return (k + t + (riser - t) * s) * step;
+}
+// src/primitives/planar.ts
+function planar2(o) {
+  const [a = [0, 0, 0], b = [1, 0, 0], c = [0, 1, 0]] = o.points;
+  const n = normalize2(cross2(sub2(b, a), sub2(c, a)));
+  const u = normalize2(sub2(b, a));
+  const v = cross2(n, u);
+  const flat = o.points.map((p) => [dot2(sub2(p, a), u), dot2(sub2(p, a), v)]);
+  const rect = stripRect2(o.strip ?? "plain");
+  const tris = triangulate2(flat);
+  const mb = new MeshBuilder2;
+  for (const side of o.doubleSided ? [1, -1] : [1]) {
+    const nn = [n[0] * side, n[1] * side, n[2] * side];
+    const ids = o.points.map((p, i) => {
+      const f = flat[i] ?? [0, 0];
+      return mb.vertex({
+        p,
+        n: nn,
+        uv: [
+          rect.u0 + f[0] / rect.metres * (rect.u1 - rect.u0),
+          rect.v0 + (f[1] / rect.metres % 1 + 1) % 1 * (rect.v1 - rect.v0)
+        ],
+        color: o.color
+      });
+    });
+    for (const [x, y, z] of tris) {
+      const [i0 = 0, i1 = 0, i2 = 0] = [ids[x], ids[y], ids[z]];
+      if (side > 0)
+        mb.tri(i0, i1, i2);
+      else
+        mb.tri(i0, i2, i1);
+    }
+  }
+  return mb.build();
+}
+// src/primitives/prism.ts
+var lift = (plane, p, d) => plane === "xz" ? [p[0], d, p[1]] : plane === "xy" ? [p[0], p[1], d] : [d, p[0], p[1]];
+function prism2(o) {
+  const plane = o.plane ?? "xy";
+  const d0 = o.centred === false ? 0 : -o.depth / 2;
+  const d1 = d0 + o.depth;
+  const rect = stripRect2(o.strip ?? "plain");
+  const uv = (u, v) => [
+    rect.u0 + u / rect.metres * (rect.u1 - rect.u0),
+    rect.v0 + (v % 1 + 1) % 1 * (rect.v1 - rect.v0)
+  ];
+  const b = new MeshBuilder2;
+  const n = o.profile.length;
+  const sign = o.profile.reduce((s, a, i) => {
+    const c = o.profile[(i + 1) % n] ?? a;
+    return s + a[0] * c[1] - c[0] * a[1];
+  }, 0) > 0 ? 1 : -1;
+  const hand = plane === "xz" ? -1 : 1;
+  let run = 0;
+  for (let i = 0;i < n; i++) {
+    const a = o.profile[i] ?? [0, 0];
+    const c = o.profile[(i + 1) % n] ?? a;
+    const e = [c[0] - a[0], c[1] - a[1]];
+    const len = Math.hypot(e[0], e[1]);
+    if (len < 0.000000001)
+      continue;
+    const n2 = [e[1] / len * sign, -e[0] / len * sign];
+    const nrm = normalize2(lift(plane, n2, 0));
+    const p = [lift(plane, a, d0), lift(plane, c, d0), lift(plane, c, d1), lift(plane, a, d1)];
+    const ids = p.map((q, k) => b.vertex({
+      p: q,
+      n: nrm,
+      uv: uv(run + (k === 1 || k === 2 ? len : 0), k >= 2 ? o.depth : 0),
+      color: o.color
+    }));
+    const [i0 = 0, i1 = 0, i2 = 0, i3 = 0] = ids;
+    if (sign * hand > 0)
+      b.quad(i0, i1, i2, i3);
+    else
+      b.quad(i0, i3, i2, i1);
+    run += len;
+  }
+  if (o.caps !== false) {
+    const tris = triangulate2(o.profile);
+    for (const [d, s] of [
+      [d0, -1],
+      [d1, 1]
+    ]) {
+      const nrm = normalize2(lift(plane, [0, 0], s));
+      const ids = o.profile.map((q) => b.vertex({ p: lift(plane, q, d), n: nrm, uv: uv(q[0], q[1]), color: o.color }));
+      for (const [x, y, z] of tris) {
+        const [a = 0, c = 0, e = 0] = [ids[x], ids[y], ids[z]];
+        if (s * hand > 0)
+          b.tri(a, c, e);
+        else
+          b.tri(a, e, c);
+      }
+    }
+  }
+  return b.build();
+}
+// src/primitives/sdf-ops.ts
+var clamp01 = (x) => x < 0 ? 0 : Math.min(x, 1);
+var shapes = {
+  sphere: (x, y, z, r) => Math.sqrt(x * x + y * y + z * z) - r,
+  ellipsoid(x, y, z, rx, ry, rz) {
+    const k0 = Math.sqrt((x / rx) ** 2 + (y / ry) ** 2 + (z / rz) ** 2);
+    const k1 = Math.sqrt((x / (rx * rx)) ** 2 + (y / (ry * ry)) ** 2 + (z / (rz * rz)) ** 2);
+    return k1 === 0 ? -Math.min(rx, ry, rz) : k0 * (k0 - 1) / k1;
+  },
+  roundBox(x, y, z, hx, hy, hz, r) {
+    const qx = Math.abs(x) - hx + r;
+    const qy = Math.abs(y) - hy + r;
+    const qz = Math.abs(z) - hz + r;
+    const ox = Math.max(qx, 0);
+    const oy = Math.max(qy, 0);
+    const oz = Math.max(qz, 0);
+    return Math.sqrt(ox * ox + oy * oy + oz * oz) + Math.min(Math.max(qx, qy, qz), 0) - r;
+  },
+  capsule(x, y, z, len, r) {
+    const t = len > 0 ? Math.min(Math.max(z, 0), len) : 0;
+    return Math.sqrt(x * x + y * y + (z - t) * (z - t)) - r;
+  },
+  cone(x, y, z, r1, r2, h) {
+    const hh = h / 2;
+    const qx = Math.sqrt(x * x + y * y);
+    const qy = z - hh;
+    const cax = qx - Math.min(qx, qy < 0 ? r1 : r2);
+    const cay = Math.abs(qy) - hh;
+    const k2x = r2 - r1;
+    const k2y = 2 * hh;
+    const t = clamp01(((r2 - qx) * k2x + (hh - qy) * k2y) / (k2x * k2x + k2y * k2y));
+    const cbx = qx - r2 + k2x * t;
+    const cby = qy - hh + k2y * t;
+    const s = cbx < 0 && cay < 0 ? -1 : 1;
+    return s * Math.sqrt(Math.min(cax * cax + cay * cay, cbx * cbx + cby * cby));
+  },
+  torus(x, y, z, R, r) {
+    const q = Math.sqrt(x * x + y * y) - R;
+    return Math.sqrt(q * q + z * z) - r;
+  }
+};
+var smoothWeight = (a, b, k) => k > 0 ? clamp01(0.5 + 0.5 * (b - a) / k) : a < b ? 1 : 0;
+var sd2 = {
+  sphere: (at, r) => (p) => shapes.sphere(p[0] - at[0], p[1] - at[1], p[2] - at[2], r),
+  ellipsoid: (at, radii) => (p) => shapes.ellipsoid(p[0] - at[0], p[1] - at[1], p[2] - at[2], radii[0], radii[1], radii[2]),
+  box: (at, size, round = 0) => (p) => shapes.roundBox(p[0] - at[0], p[1] - at[1], p[2] - at[2], size[0] / 2, size[1] / 2, size[2] / 2, round),
+  capsule(a, b, r) {
+    const bx = b[0] - a[0];
+    const by = b[1] - a[1];
+    const bz = b[2] - a[2];
+    const bb = bx * bx + by * by + bz * bz;
+    return (p) => {
+      const px = p[0] - a[0];
+      const py = p[1] - a[1];
+      const pz = p[2] - a[2];
+      const h = bb > 0 ? clamp01((px * bx + py * by + pz * bz) / bb) : 0;
+      return Math.sqrt((px - bx * h) ** 2 + (py - by * h) ** 2 + (pz - bz * h) ** 2) - r;
+    };
+  },
+  cone: (at, r1, r2, h) => (p) => shapes.cone(p[0] - at[0], p[1] - at[1], p[2] - at[2], r1, r2, h),
+  torus: (at, R, r) => (p) => shapes.torus(p[0] - at[0], p[1] - at[1], p[2] - at[2], R, r),
+  union: (...fs) => (p) => {
+    let d = Number.POSITIVE_INFINITY;
+    for (const f of fs)
+      d = Math.min(d, f(p));
+    return d;
+  },
+  intersect: (a, b) => (p) => Math.max(a(p), b(p)),
+  subtract: (a, b) => (p) => Math.max(a(p), -b(p)),
+  smoothUnion: (k, a, b) => (p) => {
+    const da = a(p);
+    const db = b(p);
+    const h = smoothWeight(da, db, k);
+    return db + (da - db) * h - k * h * (1 - h);
+  },
+  smoothSubtract: (k, a, b) => (p) => {
+    const da = a(p);
+    const db = -b(p);
+    const h = smoothWeight(-da, -db, k);
+    return da + (db - da) * (1 - h) + k * h * (1 - h);
+  },
+  displace: (f, noise, amount) => (p) => f(p) + amount * noise(p)
+};
+
+// src/primitives/sculpt-edit.ts
+var dims = (e) => {
+  if (typeof e.size === "number")
+    return [e.size, e.size, e.size];
+  const [a, b, c] = e.size;
+  return [a, b, c ?? b];
+};
+function sculptShape(e, i, mirrorAll) {
+  const [a, b, c] = dims(e);
+  const where = `sculpt edit ${i} (${e.shape})`;
+  if (![a, b, c].every((x) => Number.isFinite(x) && x > 0))
+    invalid(`${where}: size has a value ≤ 0`, "give every size component in metres, > 0");
+  if ((e.blend ?? 0) < 0 || !Number.isFinite(e.blend ?? 0))
+    invalid(`${where}: blend is ${e.blend}`, "use a blend radius ≥ 0 m (0.01 = 1 cm fillet)");
+  if (e.shape === "capsule" && !e.to)
+    invalid(`${where}: capsule needs \`to\``, "add to: [x, y, z], the far end");
+  const [rx, ry, rz] = (e.rotate ?? [0, 0, 0]).map((d) => d * Math.PI / 180);
+  const [cx, sx, cy, sy, cz, sz] = [
+    Math.cos(rx ?? 0),
+    Math.sin(rx ?? 0),
+    Math.cos(ry ?? 0),
+    Math.sin(ry ?? 0),
+    Math.cos(rz ?? 0),
+    Math.sin(rz ?? 0)
+  ];
+  const m = [
+    cz * cy,
+    cz * sy * sx - sz * cx,
+    cz * sy * cx + sz * sx,
+    sz * cy,
+    sz * sy * sx + cz * cx,
+    sz * sy * cx - cz * sx,
+    -sy,
+    cy * sx,
+    cy * cx
+  ];
+  const [m0 = 1, m1 = 0, m2 = 0, m3 = 0, m4 = 1, m5 = 0, m6 = 0, m7 = 0, m8 = 1] = m;
+  const [ox, oy, oz] = e.at;
+  const to = e.to ?? e.at;
+  const [dx, dy, dz] = [to[0] - ox, to[1] - oy, to[2] - oz];
+  const len = Math.sqrt(dx * dx + dy * dy + dz * dz);
+  const round = Math.min(e.round ?? 0, a / 2, b / 2, c / 2);
+  const kernel = e.shape === "sphere" ? (x, y, z) => shapes.sphere(x, y, z, a) : e.shape === "ellipsoid" ? (x, y, z) => shapes.ellipsoid(x, y, z, a, b, c) : e.shape === "roundBox" ? (x, y, z) => shapes.roundBox(x, y, z, a / 2, b / 2, c / 2, round) : e.shape === "cone" ? (x, y, z) => shapes.cone(x, y, z, a, b, c) : (x, y, z) => shapes.torus(x, y, z, a, b);
+  const rotated = e.rotate?.some((d) => d !== 0) ?? false;
+  const one = e.shape === "capsule" ? (px, py, pz) => {
+    const wx = px - ox;
+    const wy = py - oy;
+    const wz = pz - oz;
+    const t = len > 0 ? Math.min(1, Math.max(0, (wx * dx + wy * dy + wz * dz) / (len * len))) : 0;
+    return Math.sqrt((wx - dx * t) ** 2 + (wy - dy * t) ** 2 + (wz - dz * t) ** 2) - a;
+  } : rotated ? (px, py, pz) => {
+    const wx = px - ox;
+    const wy = py - oy;
+    const wz = pz - oz;
+    return kernel(m0 * wx + m3 * wy + m6 * wz, m1 * wx + m4 * wy + m7 * wz, m2 * wx + m5 * wy + m8 * wz);
+  } : (px, py, pz) => kernel(px - ox, py - oy, pz - oz);
+  if (!(e.mirror ?? mirrorAll))
+    return (p) => one(p[0], p[1], p[2]);
+  const { c: sc, r: sr, scale, inside } = shapeSphere(e);
+  const bound = (dist) => {
+    const out = dist - sr;
+    return out > 0 ? scale * out : inside ? out : Number.NEGATIVE_INFINITY;
+  };
+  return (p) => {
+    const dx0 = p[0] - sc[0];
+    const dz0 = p[2] - sc[2];
+    const near = Math.sqrt(dx0 * dx0 + (p[1] - sc[1]) ** 2 + dz0 * dz0);
+    const far = Math.sqrt(dx0 * dx0 + (p[1] + sc[1]) ** 2 + dz0 * dz0);
+    const [first, second, lb] = near <= far ? [p[1], -p[1], bound(far)] : [-p[1], p[1], bound(near)];
+    const v = one(p[0], first, p[2]);
+    return lb >= v ? v : Math.min(v, one(p[0], second, p[2]));
+  };
+}
+function shapeSphere(e) {
+  const [a, b, c] = dims(e);
+  const to = e.to ?? e.at;
+  const centre = e.shape === "capsule" ? [(e.at[0] + to[0]) / 2, (e.at[1] + to[1]) / 2, (e.at[2] + to[2]) / 2] : e.at;
+  const r = e.shape === "sphere" ? a : e.shape === "ellipsoid" ? Math.max(a, b, c) : e.shape === "roundBox" ? Math.hypot(a, b, c) / 2 : e.shape === "cone" ? c + Math.max(a, b) : e.shape === "torus" ? a + b : a + Math.hypot(to[0] - e.at[0], to[1] - e.at[1], to[2] - e.at[2]) / 2;
+  const ell = e.shape === "ellipsoid";
+  const lo = Math.min(a, b, c);
+  return { c: centre, r, scale: ell ? (lo / r) ** 2 : 1, inside: !ell };
+}
+function editBounds(e, mirrorAll) {
+  if ("group" in e)
+    return groupBounds(e, mirrorAll);
+  const { c: centre, r } = shapeSphere(e);
+  const g = r + (e.blend ?? 0);
+  const lo = [centre[0] - g, centre[1] - g, centre[2] - g];
+  const hi = [centre[0] + g, centre[1] + g, centre[2] + g];
+  if (e.mirror ?? mirrorAll) {
+    const [l, h] = [lo[1], hi[1]];
+    lo[1] = Math.min(l, -h);
+    hi[1] = Math.max(h, -l);
+  }
+  return [lo, hi];
+}
+function groupBounds(g, mirrorAll) {
+  const lo = [Infinity, Infinity, Infinity];
+  const hi = [-Infinity, -Infinity, -Infinity];
+  const k = g.blend ?? 0;
+  for (const e of g.group) {
+    if ((e.op ?? "add") !== "add")
+      continue;
+    const [a, b] = editBounds(e, g.mirror ?? mirrorAll);
+    for (let i = 0;i < 3; i++) {
+      lo[i] = Math.min(lo[i] ?? 0, (a[i] ?? 0) - k);
+      hi[i] = Math.max(hi[i] ?? 0, (b[i] ?? 0) + k);
+    }
+  }
+  return [lo, hi];
+}
+
+// src/primitives/sculpt-tree.ts
+var ADD = 0;
+var SUB = 1;
+var INTER = 2;
+var PAINT = 3;
+var OPS = { add: ADD, subtract: SUB, intersect: INTER, paint: PAINT };
+function compile(edits, base, mirror, path = "sculpt") {
+  if (!edits.some((e) => (e.op ?? "add") === "add"))
+    invalid(`${path} has no add edits, so nothing to carve from`, "make the first edit op: 'add'");
+  return edits.map((e, i) => {
+    const op = OPS[e.op ?? "add"];
+    const k = e.blend ?? 0;
+    const m = e.mirror ?? mirror;
+    if ("group" in e) {
+      const kids = compile(e.group, e.color ?? base, m, `${path} group ${i}`);
+      const b = enclose(kids);
+      return node(op, k, e.color ?? null, null, kids, e.color ?? base, 3, b.c, b.r, b.scale, b.inside, false, b.under);
+    }
+    const s = shapeSphere(e);
+    return node(op, k, e.color ?? null, sculptShape(e, i, m), null, base, 0, s.c, s.r, s.scale, s.inside, m, 0);
+  });
+}
+function node(op, k, color, shape, kids, base, rgb, c, r, scale, inside, mirror, under) {
+  return {
+    op,
+    k,
+    color,
+    shape,
+    kids,
+    base,
+    rgb: new Float64Array(rgb),
+    c,
+    r,
+    scale,
+    inside,
+    mirror,
+    under
+  };
+}
+function enclose(kids) {
+  const adds = kids.filter((n) => n.op === ADD);
+  const spheres = adds.flatMap((n) => n.mirror ? [n, { ...n, c: [n.c[0], -n.c[1], n.c[2]] }] : [n]);
+  const lo = [0, 1, 2].map((a) => Math.min(...spheres.map((n) => (n.c[a] ?? 0) - n.r)));
+  const hi = [0, 1, 2].map((a) => Math.max(...spheres.map((n) => (n.c[a] ?? 0) + n.r)));
+  const c = [
+    ((lo[0] ?? 0) + (hi[0] ?? 0)) / 2,
+    ((lo[1] ?? 0) + (hi[1] ?? 0)) / 2,
+    ((lo[2] ?? 0) + (hi[2] ?? 0)) / 2
+  ];
+  const r = Math.max(...spheres.map((n) => Math.hypot(n.c[0] - c[0], n.c[1] - c[1], n.c[2] - c[2]) + n.r));
+  return {
+    c,
+    r,
+    scale: Math.min(...adds.map((n) => n.scale)),
+    inside: adds.every((n) => n.inside),
+    mirror: false,
+    under: adds.reduce((u, n) => u + n.k / 4 + n.under, 0)
+  };
+}
+function lowerBound(n, p) {
+  const dx = p[0] - n.c[0];
+  const dz = p[2] - n.c[2];
+  let dy = p[1] - n.c[1];
+  let q = dx * dx + dy * dy + dz * dz;
+  if (n.mirror) {
+    dy = p[1] + n.c[1];
+    q = Math.min(q, dx * dx + dy * dy + dz * dz);
+  }
+  const out = Math.sqrt(q) - n.r;
+  if (out > 0)
+    return n.scale * out - n.under;
+  return n.inside ? out - n.under : Number.NEGATIVE_INFINITY;
+}
+var clamp012 = (x) => x < 0 ? 0 : Math.min(x, 1);
+var weight = (a, b, k) => k > 0 ? clamp012(0.5 + 0.5 * (b - a) / k) : a < b ? 1 : 0;
+var slack = (d) => 0.000000001 * (1 + Math.abs(d));
+function fold(nodes, p, rgb, base, sparse = true) {
+  let d = Number.POSITIVE_INFINITY;
+  if (rgb)
+    rgb.set(base);
+  for (const n of nodes) {
+    const k = n.k;
+    if (n.op === PAINT) {
+      if (!rgb || !n.color || !n.shape)
+        continue;
+      const kk = Math.max(k, 0.000000001);
+      if (sparse && lowerBound(n, p) > kk / 2 + slack(kk))
+        continue;
+      const w = 1 - clamp012(0.5 - n.shape(p) / kk);
+      if (w < 1)
+        mix(rgb, n.color, w);
+      continue;
+    }
+    const empty = d === Number.POSITIVE_INFINITY;
+    if (empty && n.op !== ADD)
+      continue;
+    if (sparse && !empty) {
+      if (n.op === ADD && lowerBound(n, p) > d + k + slack(d))
+        continue;
+      if (n.op === SUB && lowerBound(n, p) > k - d + slack(d))
+        continue;
+    }
+    const v = n.kids ? fold(n.kids, p, rgb ? n.rgb : null, n.base, sparse) : n.shape ? n.shape(p) : 0;
+    let w = 0;
+    if (empty)
+      d = v;
+    else if (n.op === ADD) {
+      w = weight(d, v, k);
+      if (w !== 1)
+        d = v + (d - v) * w - k * w * (1 - w);
+    } else {
+      const b = n.op === SUB ? -v : v;
+      w = weight(-d, -b, k);
+      if (w !== 1)
+        d = -(-b + (-d + b) * w - k * w * (1 - w));
+    }
+    if (!rgb || w >= 1)
+      continue;
+    if (n.kids) {
+      if (n.color || n.op === ADD)
+        mixArr(rgb, n.rgb, w);
+    } else if (n.color || n.op === ADD)
+      mix(rgb, n.color ?? base, w);
+  }
+  return d;
+}
+var mix = (rgb, c, w) => {
+  for (let j = 0;j < 3; j++)
+    rgb[j] = (c[j] ?? 0) + ((rgb[j] ?? 0) - (c[j] ?? 0)) * w;
+};
+var mixArr = (rgb, c, w) => {
+  for (let j = 0;j < 3; j++)
+    rgb[j] = (c[j] ?? 0) + ((rgb[j] ?? 0) - (c[j] ?? 0)) * w;
+};
+
+// src/primitives/sdf-grid.ts
+var MAX_POINTS = 1 << 24;
+var BLOCK = 4;
+function sampleGrid(raw, bounds, h, lipschitz, symmetricY = false) {
+  const [lo0, hi0] = bounds;
+  if (!Number.isFinite(h) || h <= 0)
+    invalid(`sdf resolution is ${h}`, "pass the cell edge in metres, e.g. ctx.pick([0.004, 0.012, 0.03])");
+  if (![0, 1, 2].every((k) => Number.isFinite(lo0[k] ?? Number.NaN) && (hi0[k] ?? 0) > (lo0[k] ?? 0)))
+    invalid(`sdf bounds [${lo0.join(", ")}] → [${hi0.join(", ")}] are empty or inverted`, "give bounds as [min, max] corners with max > min on every axis, in metres");
+  const m = Math.ceil(Math.max(Math.abs(lo0[1]), Math.abs(hi0[1])) / h);
+  const lo = symmetricY ? [lo0[0], -m * h, lo0[2]] : lo0;
+  const hi = symmetricY ? [hi0[0], m * h, hi0[2]] : hi0;
+  const size = (k) => Math.ceil(((hi[k] ?? 0) - (lo[k] ?? 0)) / h) + 3;
+  const [nx, ny, nz] = [size(0), symmetricY ? 2 * m + 3 : size(1), size(2)];
+  const yAt = (j) => symmetricY ? (j - m - 1) * h : lo[1] - h + j * h;
+  if (nx * ny * nz > MAX_POINTS) {
+    const vol = [0, 1, 2].reduce((v, k) => v * ((hi[k] ?? 0) - (lo[k] ?? 0)), 1);
+    invalid(`sdf grid ${nx}×${ny}×${nz} exceeds ${MAX_POINTS} points at ${h} m cells`, `use cells ≥ ${Math.cbrt(vol / MAX_POINTS).toPrecision(2)} m, or tighten the bounds`);
+  }
+  const cx = (lo[0] + hi[0]) / 2;
+  const cy = (lo[1] + hi[1]) / 2;
+  const cz = (lo[2] + hi[2]) / 2;
+  const [bx, by, bz] = [(hi[0] - lo[0]) / 2, (hi[1] - lo[1]) / 2, (hi[2] - lo[2]) / 2];
+  const field = (p) => {
+    const qx = Math.abs(p[0] - cx) - bx;
+    const qy = Math.abs(p[1] - cy) - by;
+    const qz = Math.abs(p[2] - cz) - bz;
+    const box = Math.hypot(Math.max(qx, 0), Math.max(qy, 0), Math.max(qz, 0)) + Math.min(Math.max(qx, qy, qz), 0);
+    const f = raw(p);
+    if (Number.isNaN(f))
+      invalid(`sdf field returned NaN at [${p.join(", ")}]`, "make the field return a finite distance everywhere in bounds");
+    return Math.max(f, box);
+  };
+  const origin = [lo[0] - h, symmetricY ? -(m + 1) * h : lo[1] - h, lo[2] - h];
+  const values = new Float32Array(nx * ny * nz);
+  const exact = new Uint8Array(nx * ny * nz);
+  const [kx, ky, kz] = [
+    Math.ceil((nx - 1) / BLOCK),
+    Math.ceil((ny - 1) / BLOCK),
+    Math.ceil((nz - 1) / BLOCK)
+  ];
+  const coarse = new Float32Array(kx * ky * kz);
+  const p = [0, 0, 0];
+  const floor = h * 0.01;
+  const reach = lipschitz * BLOCK * h * Math.sqrt(3) * 0.5 + h;
+  for (let k = 0;k < kz; k++)
+    for (let j = 0;j < ky; j++)
+      for (let i = 0;i < kx; i++) {
+        p[0] = origin[0] + (i + 0.5) * BLOCK * h;
+        p[1] = origin[1] + (j + 0.5) * BLOCK * h;
+        p[2] = origin[2] + (k + 0.5) * BLOCK * h;
+        const v = field(p);
+        coarse[i + kx * (j + ky * k)] = v;
+        if (Math.abs(v) > reach)
+          continue;
+        for (let z = k * BLOCK;z <= Math.min(nz - 1, (k + 1) * BLOCK); z++)
+          for (let y = j * BLOCK;y <= Math.min(ny - 1, (j + 1) * BLOCK); y++)
+            for (let x = i * BLOCK;x <= Math.min(nx - 1, (i + 1) * BLOCK); x++)
+              exact[x + nx * (y + ny * z)] = 1;
+      }
+  for (let z = 0;z < nz; z++)
+    for (let y = 0;y < ny; y++)
+      for (let x = 0;x < nx; x++) {
+        const id = x + nx * (y + ny * z);
+        if (exact[id]) {
+          p[0] = origin[0] + x * h;
+          p[1] = yAt(y);
+          p[2] = origin[2] + z * h;
+          const f = field(p);
+          values[id] = Math.abs(f) >= floor ? f : f < 0 ? -floor : floor;
+        } else {
+          const b = Math.min(kx - 1, Math.floor(x / BLOCK)) + kx * (Math.min(ky - 1, Math.floor(y / BLOCK)) + ky * Math.min(kz - 1, Math.floor(z / BLOCK)));
+          values[id] = coarse[b] ?? 1;
+        }
+      }
+  return { nx, ny, nz, origin, h, values, field };
+}
+
+// src/primitives/mc-table.ts
+var PACKED = ".083.019.183981.12a.08312a.92a029.2832a8a98.3b2.0b28b0.19023b.1b219b98b.3a1ba3.0a108a8ba.3" + "903b9ba9.98aa8b.478.430734.019847.419471731.12a847.34730412a.92a902847.2a9297273794.8473b2" + ".b47b24204.90184723b.47b94b9b2921.3a13ba784.1ba14b1047b4.47890b9bab03.47b4b99ba.954.954083" + ".054150.854835315.12a954.30812a495.52a542402.2a5325354348.95423b.0b208b495.05401523b.21525" + "828b485.a3ba13954.4950818a18ba.54050b5bab03.54858aa8b.978579.930953573.078017157.153357.97" + "8957a12.a12950530573.802825857a52.2a5253357.7957893b2.95797292027b.23b018178157.b21b17715." + "958857a13a3b.5705097b010aba0.ba0b03a50807570.ba57b5.a65.0835a6.9015a6.1831985a6.165261.165" + "126308.965906026.598582526328.23ba65.b08b20a65.01923b5a6.5a61929b298b.63b653513.08b0b50515" + "b6.3b6036065059.65969bb98.5a6478.43047365a.1905a6847.a65197173794.612651478.125526304347.8" + "47905065026.739794329596269.3b2784a65.5a647242027b.01947823b5a6.9219b294b7b45a6.8473b53515" + "b6.51b5b610b7b404b.059065036b63847.65969b4797b9.a4964a.4a649a083.a01a60640.83181686461a.14" + "9124264.308129249264.024426.832824426.a49a64b23.08228b49a4a6.3b201606461a.64161a48121b8b1." + "964936913b63.8b1810b61914641.3b6360064.648b68.7a678a89a.0730a709a67a.a671a7178180.a67a7117" + "3.126168189867.269291679093739.780706602.732672.23ba68a89867.20727b09767a9a7.1801781a767a2" + "3b.b21b17a61671.896867916b63136.091b67.7807063b0b60.7b6.76b.308b76.019b76.819831b76.a126b7" + ".12a3086b7.2902a96b7.6b72a3a83a98.723627.708760620.276237019.162186198876.a76a17137.a7617a" + "187108.03707a0a96a7.76a7a88a9.684b86.36b306046.86b846901.946963931b36.6846b82a1.12a30b06b0" + "46.4b846b0292a9.a93a32943b36463.823842462.042462.190234246438.194142246.8138618466a1.a10a0" + "6604.4634386a3039a93.a946a4.49576b.083495b76.50154076b.b76834354315.954a1276b.6b712a083495" + ".76b54a42a402.348354325a52b76.723762549.954086062687.362376150540.628687218485158.954a1617" + "6137.16a176107870954.40a4a503a6a737a.76a7a854a48a.6956b9b89.36b063056095.0b805b01556b.6b36" + "35531.12a95b9b8b56.0b306b09656912a.b85b56805a52025.6b36352a3a53.589528562382.956960062.158" + "180568382628.156216.13616a386569896.a10a06950560.03856a.a56.b5a75b.b5ab75830.5b75ab190.a75" + "ab7981831.b12b71751.08312717572b.9759279022b7.75272b592328982.25a235375.820852875a25.9015a" + "35373a2.982921872a25752.135375.087071175.903935537.987597.5845a8ab8.5045b05abb30.01984a8ab" + "a45.ab4a45b34941314.2512852b8458.04b0b345b2b151b.0250592b5458b85.9452b3.25a352345384.5a252" + "4420.3a235a385458019.5a2524192942.845853351.045105.845853905035.945.4b749b9ab.0834979b79ab" + ".1ab1b414074b.3143481a474bab4.4b79b492b912.9749b791b2b1083.b74b42240.b74b42834324.29a27923" + "7749.9a7974a27870207.37a3a274a1a040a.1a2874.491417713.491417081871.403743.487.9a8ab8.30939" + "bb9a.01a0a88ab.31ab3a.12b1b99b8.30939b1292b9.02b80b.32b.23828aa89.9a2092.23828a0181a8.1a2." + "138918.091.038.";
+var TRI = PACKED.split(".").map((c) => [...c].map((h) => Number.parseInt(h, 16)));
+
+// src/primitives/surface-nets.ts
+var CORNER = [0, 0, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 0, 0, 1, 1, 0, 1, 1, 1, 1, 0, 1, 1];
+var EDGE = [0, 1, 1, 2, 2, 3, 3, 0, 4, 5, 5, 6, 6, 7, 7, 4, 0, 4, 1, 5, 2, 6, 3, 7];
+function surfaceNets(g) {
+  const { nx, ny, nz, values: v, h, origin: o } = g;
+  const cells = new Int32Array((nx - 1) * (ny - 1) * (nz - 1)).fill(-1);
+  const pos = [];
+  const c = new Float64Array(8);
+  for (let z = 0;z < nz - 1; z++)
+    for (let y = 0;y < ny - 1; y++)
+      for (let x = 0;x < nx - 1; x++) {
+        let mask = 0;
+        for (let k = 0;k < 8; k++) {
+          const val = v[x + (CORNER[k * 3] ?? 0) + nx * (y + (CORNER[k * 3 + 1] ?? 0) + ny * (z + (CORNER[k * 3 + 2] ?? 0)))] ?? 1;
+          c[k] = val;
+          if (val < 0)
+            mask |= 1 << k;
+        }
+        if (mask === 0 || mask === 255)
+          continue;
+        let sx = 0;
+        let sy = 0;
+        let sz = 0;
+        let n = 0;
+        for (let e = 0;e < 12; e++) {
+          const a = EDGE[e * 2] ?? 0;
+          const b = EDGE[e * 2 + 1] ?? 0;
+          const va = c[a] ?? 0;
+          const vb = c[b] ?? 0;
+          if (va < 0 === vb < 0)
+            continue;
+          const t = va / (va - vb);
+          sx += (CORNER[a * 3] ?? 0) + t * ((CORNER[b * 3] ?? 0) - (CORNER[a * 3] ?? 0));
+          sy += (CORNER[a * 3 + 1] ?? 0) + t * ((CORNER[b * 3 + 1] ?? 0) - (CORNER[a * 3 + 1] ?? 0));
+          sz += (CORNER[a * 3 + 2] ?? 0) + t * ((CORNER[b * 3 + 2] ?? 0) - (CORNER[a * 3 + 2] ?? 0));
+          n++;
+        }
+        cells[x + (nx - 1) * (y + (ny - 1) * z)] = pos.length / 3;
+        pos.push(o[0] + (x + sx / n) * h, o[1] + (y + sy / n) * h, o[2] + (z + sz / n) * h);
+      }
+  const tris = [];
+  const cell = (x, y, z) => cells[x + (nx - 1) * (y + (ny - 1) * z)] ?? 0;
+  const P = (i, k) => pos[i * 3 + k] ?? 0;
+  const n1 = new Float64Array(3);
+  const n2 = new Float64Array(3);
+  const normal = (a, b, c, n) => {
+    const ex = P(b, 0) - P(a, 0);
+    const ey = P(b, 1) - P(a, 1);
+    const ez = P(b, 2) - P(a, 2);
+    const fx = P(c, 0) - P(a, 0);
+    const fy = P(c, 1) - P(a, 1);
+    const fz = P(c, 2) - P(a, 2);
+    const x = ey * fz - ez * fy;
+    const y = ez * fx - ex * fz;
+    const z = ex * fy - ey * fx;
+    const l = Math.sqrt(x * x + y * y + z * z) || 1;
+    n[0] = x / l;
+    n[1] = y / l;
+    n[2] = z / l;
+  };
+  const flatness = () => (n1[0] ?? 0) * (n2[0] ?? 0) + (n1[1] ?? 0) * (n2[1] ?? 0) + (n1[2] ?? 0) * (n2[2] ?? 0);
+  const quad = (a, b, cc, d, out) => {
+    const [q0, q1, q2, q3] = out ? [a, b, cc, d] : [a, d, cc, b];
+    normal(q0, q1, q2, n1);
+    normal(q0, q2, q3, n2);
+    const along02 = flatness();
+    normal(q0, q1, q3, n1);
+    normal(q1, q2, q3, n2);
+    if (along02 >= flatness())
+      tris.push(q0, q1, q2, q0, q2, q3);
+    else
+      tris.push(q0, q1, q3, q1, q2, q3);
+  };
+  for (let z = 1;z < nz - 1; z++)
+    for (let y = 1;y < ny - 1; y++)
+      for (let x = 1;x < nx - 1; x++) {
+        const inside = (v[x + nx * (y + ny * z)] ?? 1) < 0;
+        if (x < nx - 1 && inside !== (v[x + 1 + nx * (y + ny * z)] ?? 1) < 0)
+          quad(cell(x, y - 1, z - 1), cell(x, y, z - 1), cell(x, y, z), cell(x, y - 1, z), inside);
+        if (y < ny - 1 && inside !== (v[x + nx * (y + 1 + ny * z)] ?? 1) < 0)
+          quad(cell(x - 1, y, z - 1), cell(x - 1, y, z), cell(x, y, z), cell(x, y, z - 1), inside);
+        if (z < nz - 1 && inside !== (v[x + nx * (y + ny * (z + 1))] ?? 1) < 0)
+          quad(cell(x - 1, y - 1, z), cell(x, y - 1, z), cell(x, y, z), cell(x - 1, y, z), inside);
+      }
+  return { pos, tris };
+}
+function marchingCubes(g) {
+  const { nx, ny, nz, values: v, h, origin: o } = g;
+  const shared = new Map;
+  const pos = [];
+  const tris = [];
+  for (let z = 0;z < nz - 1; z++)
+    for (let y = 0;y < ny - 1; y++)
+      for (let x = 0;x < nx - 1; x++) {
+        let mask = 0;
+        for (let k = 0;k < 8; k++)
+          if ((v[x + (CORNER[k * 3] ?? 0) + nx * (y + (CORNER[k * 3 + 1] ?? 0) + ny * (z + (CORNER[k * 3 + 2] ?? 0)))] ?? 1) < 0)
+            mask |= 1 << k;
+        const list = TRI[mask] ?? [];
+        for (let t = 0;t < list.length; t += 3)
+          for (const j of [0, 2, 1]) {
+            const e = list[t + j] ?? 0;
+            const a = EDGE[e * 2] ?? 0;
+            const b = EDGE[e * 2 + 1] ?? 0;
+            const ax = x + (CORNER[a * 3] ?? 0);
+            const ay = y + (CORNER[a * 3 + 1] ?? 0);
+            const az = z + (CORNER[a * 3 + 2] ?? 0);
+            const bx = x + (CORNER[b * 3] ?? 0);
+            const by = y + (CORNER[b * 3 + 1] ?? 0);
+            const bz = z + (CORNER[b * 3 + 2] ?? 0);
+            const ia = ax + nx * (ay + ny * az);
+            const ib = bx + nx * (by + ny * bz);
+            const lowId = Math.min(ia, ib);
+            const key = lowId * 3 + (ax !== bx ? 0 : ay !== by ? 1 : 2);
+            let id = shared.get(key);
+            if (id === undefined) {
+              const va = v[ia] ?? 0;
+              const s = va / (va - (v[ib] ?? 0));
+              id = pos.length / 3;
+              pos.push(o[0] + (ax + s * (bx - ax)) * h, o[1] + (ay + s * (by - ay)) * h, o[2] + (az + s * (bz - az)) * h);
+              shared.set(key, id);
+            }
+            tris.push(id);
+          }
+      }
+  return { pos, tris };
+}
+
+// src/primitives/sdf.ts
+function sdf2(o) {
+  const lip = o.lipschitz ?? 1.25;
+  if (!(lip >= 1))
+    invalid(`sdf lipschitz is ${lip}`, "use ≥ 1 (1 = exact distance field)");
+  const g = sampleGrid(o.field, o.bounds, o.resolution, lip, o.symmetry === "y");
+  const raw = o.mesher === "cubes" ? marchingCubes(g) : surfaceNets(g);
+  if (raw.tris.length === 0)
+    invalid("sdf field has no surface inside its bounds (never crosses zero)", "return negative distances inside the shape, positive outside, and make bounds contain it");
+  const strip = o.strip ?? "plain";
+  const rect = stripRect2(strip);
+  const vm = stripVMetres(strip);
+  const e = g.h * 0.5;
+  const q = [0, 0, 0];
+  const at = (x, y, z) => {
+    q[0] = x;
+    q[1] = y;
+    q[2] = z;
+    return g.field(q);
+  };
+  const b = new MeshBuilder2;
+  for (let i = 0;i < raw.pos.length; i += 3) {
+    const x = raw.pos[i] ?? 0;
+    const y = raw.pos[i + 1] ?? 0;
+    const z = raw.pos[i + 2] ?? 0;
+    const gx = at(x + e, y, z) - at(x - e, y, z);
+    const gy = at(x, y + e, z) - at(x, y - e, z);
+    const gz = at(x, y, z + e) - at(x, y, z - e);
+    const gl = Math.sqrt(gx * gx + gy * gy + gz * gz);
+    const n = gl > 0 ? [gx / gl, gy / gl, gz / gl] : [0, 0, 1];
+    const ax = Math.abs(n[0]);
+    const ay = Math.abs(n[1]);
+    const az = Math.abs(n[2]);
+    const [s, t] = az >= ax && az >= ay ? [x, y] : ax >= ay ? [y, z] : [x, z];
+    const p = [x, y, z];
+    b.vertex({
+      p,
+      n,
+      uv: [stripU(rect, s), mirroredV(rect, t, vm)],
+      color: typeof o.color === "function" ? o.color(p, n) : o.color
+    });
+  }
+  for (let i = 0;i < raw.tris.length; i += 3)
+    b.tri(raw.tris[i] ?? 0, raw.tris[i + 1] ?? 0, raw.tris[i + 2] ?? 0);
+  return b.build();
+}
+
+// src/primitives/sculpt.ts
+function sculptField2(edits, o) {
+  if (edits.length === 0)
+    invalid("sculpt has no edits", "start with an { shape: 'sphere', op: 'add', ... } edit");
+  const nodes = compile(edits, o.color, o.mirror === "y");
+  const rgb = new Float64Array(3);
+  const adds = edits.filter((e) => (e.op ?? "add") === "add");
+  const lo = [Number.POSITIVE_INFINITY, Number.POSITIVE_INFINITY, Number.POSITIVE_INFINITY];
+  const hi = [Number.NEGATIVE_INFINITY, Number.NEGATIVE_INFINITY, Number.NEGATIVE_INFINITY];
+  for (const e of adds) {
+    const [a, b] = editBounds(e, o.mirror === "y");
+    for (let k = 0;k < 3; k++) {
+      lo[k] = Math.min(lo[k] ?? 0, a[k] ?? 0);
+      hi[k] = Math.max(hi[k] ?? 0, b[k] ?? 0);
+    }
+  }
+  return {
+    field: (p) => fold(nodes, p, null, o.color),
+    colorAt: (p) => {
+      fold(nodes, p, rgb, o.color);
+      return [rgb[0] ?? 0, rgb[1] ?? 0, rgb[2] ?? 0];
+    },
+    bounds: [
+      [lo[0] ?? 0, lo[1] ?? 0, lo[2] ?? 0],
+      [hi[0] ?? 0, hi[1] ?? 0, hi[2] ?? 0]
+    ]
+  };
+}
+function sculpt2(o) {
+  const s = sculptField2(o.edits, { color: o.color, ...o.mirror ? { mirror: o.mirror } : {} });
+  return sdf2({
+    field: s.field,
+    bounds: s.bounds,
+    resolution: o.resolution,
+    color: (p) => s.colorAt(p),
+    ...o.mesher ? { mesher: o.mesher } : {},
+    ...o.mirror === "y" ? { symmetry: "y" } : {},
+    ...o.strip ? { strip: o.strip } : {}
+  });
+}
+// src/primitives/transport.ts
+var sub = (a, b) => [a[0] - b[0], a[1] - b[1], a[2] - b[2]];
+var dot = (a, b) => a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
+var unit = (a) => {
+  const l = Math.hypot(a[0], a[1], a[2]) || 1;
+  return [a[0] / l, a[1] / l, a[2] / l];
+};
+var cross3 = (a, b) => [
+  a[1] * b[2] - a[2] * b[1],
+  a[2] * b[0] - a[0] * b[2],
+  a[0] * b[1] - a[1] * b[0]
+];
+var reflect = (v, axis, c) => {
+  const k = 2 / c * dot(axis, v);
+  return [v[0] - k * axis[0], v[1] - k * axis[1], v[2] - k * axis[2]];
+};
+function arcLengths2(path) {
+  if (path.length < 2) {
+    throw new Ts23dError2("T3D_RECIPE_INVALID", {
+      cause: `sweep path has ${path.length} point(s)`,
+      fix: "pass at least 2 path points (from → to); a single point has no direction to sweep along"
+    });
+  }
+  const s = [0];
+  for (let i = 1;i < path.length; i++) {
+    const d = Math.hypot(...sub(path[i] ?? [0, 0, 0], path[i - 1] ?? [0, 0, 0]));
+    if (d < 0.000000001) {
+      throw new Ts23dError2("T3D_RECIPE_INVALID", {
+        cause: `sweep path points ${i - 1} and ${i} coincide (zero-length segment)`,
+        fix: "make consecutive path points distinct — drop duplicates before sweeping"
+      });
+    }
+    s.push((s[i - 1] ?? 0) + d);
+  }
+  return s;
+}
+function transportFrames2(path) {
+  arcLengths2(path);
+  const last = path.length - 1;
+  const tangents = path.map((_, i) => unit(sub(path[Math.min(last, i + 1)] ?? [0, 0, 0], path[Math.max(0, i - 1)] ?? [0, 0, 0])));
+  const t0 = tangents[0] ?? [0, 0, 1];
+  const ref = Math.abs(t0[2]) > 0.9 ? [1, 0, 0] : [0, 0, 1];
+  const k = dot(ref, t0);
+  let n = unit([ref[0] - k * t0[0], ref[1] - k * t0[1], ref[2] - k * t0[2]]);
+  const out = [{ t: t0, n, b: cross3(t0, n) }];
+  for (let i = 1;i <= last; i++) {
+    const p0 = path[i - 1] ?? [0, 0, 0];
+    const p1 = path[i] ?? [0, 0, 0];
+    const ti = tangents[i - 1] ?? t0;
+    const tj = tangents[i] ?? t0;
+    const v1 = sub(p1, p0);
+    const c1 = dot(v1, v1);
+    const nL = reflect(n, v1, c1);
+    const tL = reflect(ti, v1, c1);
+    const v2 = sub(tj, tL);
+    const c2 = dot(v2, v2);
+    n = unit(c2 < 0.000000000001 ? nL : reflect(nL, v2, c2));
+    out.push({ t: tj, n, b: cross3(tj, n) });
+  }
+  return out;
+}
+
+// src/primitives/sweep.ts
+function section2(s) {
+  if (!Array.isArray(s)) {
+    const c = s;
+    if (c.segments < 3 || !(c.radius > 0)) {
+      throw new Ts23dError2("T3D_RECIPE_INVALID", {
+        cause: `sweep circle section has radius ${c.radius} and ${c.segments} segments`,
+        fix: "use radius > 0 and segments >= 3 (pick segments from ctx.lod: e.g. 8 / 5 / 3)"
+      });
+    }
+    const nrm = [];
+    for (let k = 0;k < c.segments; k++) {
+      const a = k / c.segments * Math.PI * 2;
+      nrm.push([Math.cos(a), Math.sin(a)]);
+    }
+    return { pts: nrm.map(([x, y]) => [x * c.radius, y * c.radius]), nrm };
+  }
+  const poly = s;
+  if (poly.length < 3) {
+    throw new Ts23dError2("T3D_RECIPE_INVALID", {
+      cause: `sweep section has ${poly.length} point(s)`,
+      fix: "pass a closed polygon of at least 3 points, or { radius, segments }"
+    });
+  }
+  const area = poly.reduce((a, p, i) => {
+    const q = poly[(i + 1) % poly.length] ?? p;
+    return a + p[0] * q[1] - q[0] * p[1];
+  }, 0);
+  const pts = area < 0 ? [...poly].reverse() : poly;
+  const nrm = pts.map((p, i) => {
+    const a = pts[(i + pts.length - 1) % pts.length] ?? p;
+    const b = pts[(i + 1) % pts.length] ?? p;
+    const e1 = Math.hypot(p[0] - a[0], p[1] - a[1]) || 1;
+    const e2 = Math.hypot(b[0] - p[0], b[1] - p[1]) || 1;
+    const x = (p[1] - a[1]) / e1 + (b[1] - p[1]) / e2;
+    const y = -(p[0] - a[0]) / e1 - (b[0] - p[0]) / e2;
+    const l = Math.hypot(x, y) || 1;
+    return [x / l, y / l];
+  });
+  return { pts, nrm };
+}
+function sweep2(o) {
+  const arc = arcLengths2(o.path);
+  const frames = transportFrames2(o.path);
+  const P = o.path.length;
+  if (o.scale && o.scale.length !== P) {
+    throw new Ts23dError2("T3D_RECIPE_INVALID", {
+      cause: `sweep has ${P} path points but ${o.scale.length} scales`,
+      fix: "pass exactly one scale per path point (or omit scale for a constant section)"
+    });
+  }
+  const sec = section2(o.section);
+  const S = sec.pts.length;
+  const total = arc[P - 1] ?? 1;
+  const rect = stripRect2(o.strip ?? "plain");
+  const du = (rect.u1 - rect.u0) / rect.metres;
+  const twist = (o.twist ?? 0) * Math.PI / 180;
+  const b = new MeshBuilder2;
+  const rim = new Float64Array(P * S * 3);
+  for (let i = 0;i < P; i++) {
+    const c = o.path[i] ?? [0, 0, 0];
+    const { t, n, b: bn } = frames[i] ?? { t: [0, 0, 1], n: [1, 0, 0], b: [0, 1, 0] };
+    const k = o.scale?.[i] ?? 1;
+    const i0 = Math.max(0, i - 1);
+    const i1 = Math.min(P - 1, i + 1);
+    const slope = ((o.scale?.[i1] ?? 1) - (o.scale?.[i0] ?? 1)) / ((arc[i1] ?? 0) - (arc[i0] ?? 0) || 1);
+    const rot = twist * (arc[i] ?? 0) / total;
+    const cr = Math.cos(rot);
+    const sr = Math.sin(rot);
+    const u = rect.u0 + (arc[i] ?? 0) * du;
+    for (let j = 0;j <= S; j++) {
+      const [px, py] = sec.pts[j % S] ?? [0, 0];
+      const [nx, ny] = sec.nrm[j % S] ?? [1, 0];
+      const x = (px * cr - py * sr) * k;
+      const y = (px * sr + py * cr) * k;
+      const mx = nx * cr - ny * sr;
+      const my = nx * sr + ny * cr;
+      const back = -slope * (px * nx + py * ny);
+      const qx = mx * n[0] + my * bn[0] + back * t[0];
+      const qy = mx * n[1] + my * bn[1] + back * t[1];
+      const qz = mx * n[2] + my * bn[2] + back * t[2];
+      const ql = Math.hypot(qx, qy, qz) || 1;
+      const p = [
+        c[0] + x * n[0] + y * bn[0],
+        c[1] + x * n[1] + y * bn[1],
+        c[2] + x * n[2] + y * bn[2]
+      ];
+      if (j < S)
+        rim.set(p, (i * S + j) * 3);
+      b.vertex({
+        p,
+        n: [qx / ql, qy / ql, qz / ql],
+        uv: [u, rect.v0 + j / S * (rect.v1 - rect.v0)],
+        color: o.color
+      });
+    }
+  }
+  for (let i = 0;i + 1 < P; i++) {
+    const r0 = i * (S + 1);
+    const r1 = r0 + S + 1;
+    for (let j = 0;j < S; j++)
+      b.quad(r0 + j, r0 + j + 1, r1 + j + 1, r1 + j);
+  }
+  const caps = o.caps === true ? ["start", "end"] : o.caps ? [o.caps] : [];
+  for (const end of caps) {
+    const i = end === "start" ? 0 : P - 1;
+    const f = frames[i]?.t ?? [0, 0, 1];
+    const sign = end === "start" ? -1 : 1;
+    const nn = [f[0] * sign, f[1] * sign, f[2] * sign];
+    const centre = b.vertex({
+      p: o.path[i] ?? [0, 0, 0],
+      n: nn,
+      uv: [rect.u0, rect.v0],
+      color: o.color
+    });
+    const first = centre + 1;
+    for (let j = 0;j < S; j++) {
+      const q = (i * S + j) * 3;
+      const p = [rim[q] ?? 0, rim[q + 1] ?? 0, rim[q + 2] ?? 0];
+      b.vertex({ p, n: nn, uv: [rect.u0, rect.v1], color: o.color });
+    }
+    for (let j = 0;j < S; j++) {
+      const a = first + j;
+      const c = first + (j + 1) % S;
+      if (sign > 0)
+        b.tri(centre, a, c);
+      else
+        b.tri(centre, c, a);
+    }
+  }
+  return b.build();
+}
+// src/primitives/terrain-grid.ts
+function terrainGrid2(o) {
+  const [x0, y0, x1, y1] = o.rect;
+  if (!(x1 > x0 && y1 > y0))
+    invalid(`terrain rect [${o.rect.join(", ")}] is empty`, "pass [minX, minY, maxX, maxY] with max > min");
+  const n = count("terrain cells", o.cells, 2, 4096);
+  const z = new Float64Array((n + 1) * (n + 1));
+  for (let j = 0;j <= n; j++)
+    for (let i = 0;i <= n; i++) {
+      const h = o.height(x0 + (x1 - x0) * i / n, y0 + (y1 - y0) * j / n);
+      if (!Number.isFinite(h))
+        invalid(`terrain height is ${h} at point (${i}, ${j})`, "return a finite height in metres");
+      z[j * (n + 1) + i] = h;
+    }
+  return { nx: n + 1, ny: n + 1, rect: o.rect, z };
+}
+function sampler2(g, map = g.z) {
+  const [x0, y0, x1, y1] = g.rect;
+  const sx = (g.nx - 1) / (x1 - x0);
+  const sy = (g.ny - 1) / (y1 - y0);
+  return (x, y) => {
+    const fx = Math.min(g.nx - 1, Math.max(0, (x - x0) * sx));
+    const fy = Math.min(g.ny - 1, Math.max(0, (y - y0) * sy));
+    const i = Math.min(g.nx - 2, Math.floor(fx));
+    const j = Math.min(g.ny - 2, Math.floor(fy));
+    const u = fx - i;
+    const v = fy - j;
+    const k = j * g.nx + i;
+    const a = map[k] ?? 0;
+    const b = map[k + 1] ?? 0;
+    const c = map[k + g.nx] ?? 0;
+    const d = map[k + g.nx + 1] ?? 0;
+    return a + (b - a) * u + (c + (d - c) * u - (a + (b - a) * u)) * v;
+  };
+}
+function slopeMap2(g) {
+  const [x0, y0, x1, y1] = g.rect;
+  const dx = (x1 - x0) / (g.nx - 1);
+  const dy = (y1 - y0) / (g.ny - 1);
+  const out = new Float64Array(g.z.length);
+  for (let j = 0;j < g.ny; j++)
+    for (let i = 0;i < g.nx; i++) {
+      const l = g.z[j * g.nx + Math.max(0, i - 1)] ?? 0;
+      const r = g.z[j * g.nx + Math.min(g.nx - 1, i + 1)] ?? 0;
+      const b = g.z[Math.max(0, j - 1) * g.nx + i] ?? 0;
+      const t = g.z[Math.min(g.ny - 1, j + 1) * g.nx + i] ?? 0;
+      const sx = (r - l) / (dx * (Math.min(g.nx - 1, i + 1) - Math.max(0, i - 1)));
+      const sy = (t - b) / (dy * (Math.min(g.ny - 1, j + 1) - Math.max(0, j - 1)));
+      out[j * g.nx + i] = Math.sqrt(sx * sx + sy * sy);
+    }
+  return out;
+}
+function thermalErosion2(g, o = {}) {
+  const talus = o.talus ?? 0.7;
+  const rate = Math.min(0.5, Math.max(0, o.rate ?? 0.4));
+  const iterations = count("thermal iterations", o.iterations ?? 30, 0, 1e4);
+  const [x0, , x1] = g.rect;
+  const cell = (x1 - x0) / (g.nx - 1);
+  const D = [-1, 0, 1, 0, 0, -1, 0, 1, -1, -1, 1, -1, -1, 1, 1, 1];
+  const limit = D.map((_, k) => k < 8 ? talus * cell : talus * cell * Math.SQRT2);
+  let z = Float64Array.from(g.z);
+  for (let it = 0;it < iterations; it++) {
+    const next = Float64Array.from(z);
+    for (let j = 1;j < g.ny - 1; j++)
+      for (let i = 1;i < g.nx - 1; i++) {
+        const k = j * g.nx + i;
+        const h = z[k] ?? 0;
+        let total = 0;
+        let most = 0;
+        for (let d = 0;d < 16; d += 2) {
+          const ex = h - (z[k + (D[d] ?? 0) + (D[d + 1] ?? 0) * g.nx] ?? 0) - (limit[d] ?? 0);
+          if (ex > 0) {
+            total += ex;
+            if (ex > most)
+              most = ex;
+          }
+        }
+        if (total <= 0)
+          continue;
+        const move = rate * most;
+        next[k] = (next[k] ?? 0) - move;
+        for (let d = 0;d < 16; d += 2) {
+          const n = k + (D[d] ?? 0) + (D[d + 1] ?? 0) * g.nx;
+          const ex = h - (z[n] ?? 0) - (limit[d] ?? 0);
+          if (ex > 0)
+            next[n] = (next[n] ?? 0) + move * ex / total;
+        }
+      }
+    z = next;
+  }
+  return { ...g, z };
+}
+
+// src/primitives/terrain-color.ts
+var ramp = (a, b, x) => {
+  const t = Math.min(1, Math.max(0, (x - a) / (b - a)));
+  return t * t * (3 - 2 * t);
+};
+function terrainColor2(g, o) {
+  const slope = sampler2(g, slopeMap2(g));
+  const flow = g.flow ? sampler2(g, g.flow) : () => 0;
+  const dep = g.deposit ? sampler2(g, g.deposit) : () => 0;
+  const P = o.palette;
+  const datum = o.datum ?? 0;
+  const rockS = o.rockSlope ?? 0.8;
+  const snowS = o.snowSlope ?? 1;
+  const jit = o.jitter ?? 60;
+  const c = [0, 0, 0];
+  const mix = (to, w) => {
+    for (let k = 0;k < 3; k++)
+      c[k] = (c[k] ?? 0) + ((to[k] ?? 0) - (c[k] ?? 0)) * w;
+  };
+  return (x, y, z) => {
+    const n = o.noise ? o.noise(x, y) : 0;
+    const alt = z + datum + n * jit;
+    const s = slope(x, y) * (1 + 0.15 * n);
+    c[0] = P.forest[0];
+    c[1] = P.forest[1];
+    c[2] = P.forest[2];
+    mix(P.grass, ramp(o.treeline - 80, o.treeline + 80, alt));
+    mix(P.scree, 0.85 * ramp(o.treeline + 350, o.treeline + 800, alt));
+    mix(P.grass, ramp(0.55, 0.8, s) * (1 - ramp(o.treeline - 80, o.treeline + 80, alt)) * 0.6);
+    mix(P.scree, ramp(0.4, 0.8, dep(x, y)) * ramp(0.2, 0.45, s) * (1 - ramp(rockS, rockS + 0.3, s)));
+    mix(P.wet, 0.7 * ramp(0.35, 0.8, flow(x, y)) * (1 - ramp(o.snowline - 100, o.snowline, alt)));
+    mix(P.rock, ramp(rockS - 0.15, rockS + 0.15, s));
+    mix(P.snow, ramp(o.snowline - 60, o.snowline + 120, alt) * (1 - ramp(snowS - 0.3, snowS + 0.2, s)));
+    return [c[0] ?? 0, c[1] ?? 0, c[2] ?? 0];
+  };
+}
+// src/primitives/font-5x7.ts
+var A = [14, 17, 17, 17, 31, 17, 17];
+var B = [30, 17, 17, 30, 17, 17, 30];
+var C = [14, 17, 16, 16, 16, 17, 14];
+var E = [31, 16, 16, 30, 16, 16, 31];
+var H = [17, 17, 17, 31, 17, 17, 17];
+var K = [17, 18, 20, 24, 20, 18, 17];
+var M = [17, 27, 21, 21, 17, 17, 17];
+var O = [14, 17, 17, 17, 17, 17, 14];
+var P = [30, 17, 17, 30, 16, 16, 16];
+var T = [31, 4, 4, 4, 4, 4, 4];
+var X = [17, 17, 10, 4, 10, 17, 17];
+var GLYPHS = {
+  " ": [0, 0, 0, 0, 0, 0, 0],
+  A,
+  B,
+  C,
+  D: [28, 18, 17, 17, 17, 18, 28],
+  E,
+  F: [31, 16, 16, 30, 16, 16, 16],
+  G: [14, 17, 16, 23, 17, 17, 15],
+  H,
+  I: [14, 4, 4, 4, 4, 4, 14],
+  J: [7, 2, 2, 2, 2, 18, 12],
+  K,
+  L: [16, 16, 16, 16, 16, 16, 31],
+  M,
+  N: [17, 17, 25, 21, 19, 17, 17],
+  O,
+  P,
+  Q: [14, 17, 17, 17, 21, 18, 13],
+  R: [30, 17, 17, 30, 20, 18, 17],
+  S: [15, 16, 16, 14, 1, 1, 30],
+  T,
+  U: [17, 17, 17, 17, 17, 17, 14],
+  V: [17, 17, 17, 17, 17, 10, 4],
+  W: [17, 17, 17, 21, 21, 21, 10],
+  X,
+  Y: [17, 17, 10, 4, 4, 4, 4],
+  Z: [31, 1, 2, 4, 8, 16, 31],
+  "0": [14, 17, 19, 21, 25, 17, 14],
+  "1": [4, 12, 4, 4, 4, 4, 14],
+  "2": [14, 17, 1, 2, 4, 8, 31],
+  "3": [31, 2, 4, 2, 1, 17, 14],
+  "4": [2, 6, 10, 18, 31, 2, 2],
+  "5": [31, 16, 30, 1, 1, 17, 14],
+  "6": [6, 8, 16, 30, 17, 17, 14],
+  "7": [31, 1, 2, 4, 8, 8, 8],
+  "8": [14, 17, 17, 14, 17, 17, 14],
+  "9": [14, 17, 17, 15, 1, 2, 12],
+  ".": [0, 0, 0, 0, 0, 12, 12],
+  ",": [0, 0, 0, 0, 12, 4, 8],
+  "-": [0, 0, 0, 31, 0, 0, 0],
+  "/": [0, 1, 2, 4, 8, 16, 0],
+  ":": [0, 12, 12, 0, 12, 12, 0],
+  "'": [12, 4, 8, 0, 0, 0, 0],
+  '"': [10, 10, 10, 0, 0, 0, 0],
+  "&": [12, 18, 20, 8, 21, 18, 13],
+  "!": [4, 4, 4, 4, 4, 0, 4],
+  "?": [14, 17, 1, 2, 4, 0, 4],
+  "#": [10, 10, 31, 10, 31, 10, 10],
+  "+": [0, 4, 4, 31, 4, 4, 0],
+  "=": [0, 0, 31, 0, 31, 0, 0],
+  "*": [0, 4, 21, 14, 21, 4, 0],
+  "(": [2, 4, 8, 8, 8, 4, 2],
+  ")": [8, 4, 2, 2, 2, 4, 8],
+  "%": [24, 25, 2, 4, 8, 19, 3],
+  "°": [12, 18, 18, 12, 0, 0, 0],
+  "№": [18, 26, 26, 22, 22, 18, 21],
+  А: A,
+  Б: [31, 16, 16, 30, 17, 17, 30],
+  В: B,
+  Г: [31, 16, 16, 16, 16, 16, 16],
+  Д: [6, 10, 10, 10, 10, 31, 17],
+  Е: E,
+  Ё: [10, 0, 31, 16, 30, 16, 31],
+  Ж: [21, 21, 21, 14, 21, 21, 21],
+  З: [14, 17, 1, 6, 1, 17, 14],
+  И: [17, 17, 19, 21, 25, 17, 17],
+  Й: [10, 4, 17, 19, 21, 25, 17],
+  К: K,
+  Л: [7, 9, 9, 9, 9, 9, 17],
+  М: M,
+  Н: H,
+  О: O,
+  П: [31, 17, 17, 17, 17, 17, 17],
+  Р: P,
+  С: C,
+  Т: T,
+  У: [17, 17, 17, 15, 1, 17, 14],
+  Ф: [4, 14, 21, 21, 21, 14, 4],
+  Х: X,
+  Ц: [18, 18, 18, 18, 18, 31, 1],
+  Ч: [17, 17, 17, 15, 1, 1, 1],
+  Ш: [21, 21, 21, 21, 21, 21, 31],
+  Щ: [21, 21, 21, 21, 21, 31, 1],
+  Ъ: [24, 8, 8, 14, 9, 9, 14],
+  Ы: [17, 17, 17, 29, 19, 19, 29],
+  Ь: [16, 16, 16, 30, 17, 17, 30],
+  Э: [14, 17, 1, 7, 1, 17, 14],
+  Ю: [18, 21, 21, 29, 21, 21, 18],
+  Я: [15, 17, 17, 15, 5, 9, 17]
+};
+var group = (c) => /[A-Z]/.test(c) ? 0 : /[0-9]/.test(c) ? 1 : /[А-ЯЁ]/.test(c) ? 3 : 2;
+var SUPPORTED_CHARS = Object.keys(GLYPHS).filter((c) => c !== " ").sort((a, b) => group(a) - group(b) || (a < b ? -1 : a > b ? 1 : 0)).join("").concat(" and space");
+
+// src/primitives/text-layout.ts
+var SPACE = 3;
+function rows(ch, font) {
+  const g = GLYPHS[ch] ?? GLYPHS[ch.toUpperCase()];
+  if (!g)
+    invalid(`text: no glyph for ${JSON.stringify(ch)} (U+${(ch.codePointAt(0) ?? 0).toString(16).toUpperCase().padStart(4, "0")})`, `use only these characters (lower case is set as upper case): ${SUPPORTED_CHARS}`);
+  if (ch === " ")
+    return { rows: g, width: SPACE };
+  return font === "block" ? { rows: g.map((r) => r << 1 | r), width: 6 } : { rows: g, width: 5 };
+}
+function widthPx(str, font, tracking) {
+  const chars = [...str];
+  return chars.reduce((w, ch) => w + rows(ch, font).width, 0) + Math.max(0, chars.length - 1) * tracking;
+}
+function measureText2(str, o) {
+  return widthPx(str, o.font ?? "5x7", o.tracking ?? 1) * o.height / 7;
+}
+function layout(str, font, tracking) {
+  const rects = [];
+  let pen = 0;
+  for (const ch of str) {
+    const g = rows(ch, font);
+    let open = new Map;
+    for (let r = 0;r <= 7; r++) {
+      const bits = g.rows[r] ?? 0;
+      const next = new Map;
+      let c = 0;
+      while (c < g.width) {
+        if (!(bits >> g.width - 1 - c & 1)) {
+          c++;
+          continue;
+        }
+        const start = c;
+        while (c < g.width && bits >> g.width - 1 - c & 1)
+          c++;
+        const key = `${start},${c}`;
+        next.set(key, open.get(key) ?? { c0: start, c1: c, r0: r });
+      }
+      for (const [key, run] of open)
+        if (!next.has(key))
+          rects.push({ c0: pen + run.c0, c1: pen + run.c1, r0: run.r0, r1: r });
+      open = next;
+    }
+    pen += g.width + tracking;
+  }
+  return { rects, width: Math.max(0, pen - tracking) };
+}
+
+// src/primitives/text.ts
+var LIFT = 0.002;
+function text2(str, o) {
+  if (!(Number.isFinite(o.height) && o.height > 0 && o.height < 1000))
+    invalid(`text height is ${o.height}`, "give the cap height in metres, > 0 (e.g. 0.3 for wagon lettering)");
+  const depth = o.depth ?? 0;
+  if (!(Number.isFinite(depth) && depth >= 0))
+    invalid(`text depth is ${depth}`, "use 0 (flush) or a raised thickness > 0 m");
+  const font = o.font ?? "5x7";
+  const tracking = o.tracking ?? 1;
+  let height = o.height;
+  if (o.maxWidth !== undefined) {
+    if (!(o.maxWidth > 0))
+      invalid(`text maxWidth is ${o.maxWidth}`, "give the panel width in metres, > 0");
+    const w = measureText2(str, { height, font, tracking });
+    if (w > o.maxWidth)
+      height *= o.maxWidth / w;
+  }
+  const along = normalize2(o.along ?? [0, 1, 0]);
+  const up0 = o.up ?? [0, 0, 1];
+  const k = up0[0] * along[0] + up0[1] * along[1] + up0[2] * along[2];
+  const upR = [up0[0] - along[0] * k, up0[1] - along[1] * k, up0[2] - along[2] * k];
+  if (Math.hypot(upR[0], upR[1], upR[2]) < 0.000000001)
+    invalid("text: up is parallel to along", "pass an `up` perpendicular to the reading direction");
+  const up = normalize2(upR);
+  const n = [
+    along[1] * up[2] - along[2] * up[1],
+    along[2] * up[0] - along[0] * up[2],
+    along[0] * up[1] - along[1] * up[0]
+  ];
+  const px = height / 7;
+  const { rects, width } = layout(str, font, tracking);
+  const start = o.align === "centre" ? -width * px / 2 : o.align === "right" ? -width * px : 0;
+  const rect = stripRect2(o.strip ?? "plain");
+  const b = new MeshBuilder2;
+  const at = (u, v, w) => [
+    o.origin[0] + along[0] * u + up[0] * v + n[0] * w,
+    o.origin[1] + along[1] * u + up[1] * v + n[1] * w,
+    o.origin[2] + along[2] * u + up[2] * v + n[2] * w
+  ];
+  const quad = (c, nrm, us, vs) => {
+    const ids = c.map((p, i) => b.vertex({
+      p,
+      n: nrm,
+      uv: [
+        stripU(rect, us[i] ?? 0),
+        stripV(rect, Math.min(1, Math.max(0, (vs[i] ?? 0) / height)))
+      ],
+      color: o.color
+    }));
+    const [a = n, e = n, f = n] = c;
+    const g = [0, 1, 2].map((j) => {
+      const [x, y] = [(j + 1) % 3, (j + 2) % 3];
+      return ((e[x] ?? 0) - (a[x] ?? 0)) * ((f[y] ?? 0) - (a[y] ?? 0)) - ((e[y] ?? 0) - (a[y] ?? 0)) * ((f[x] ?? 0) - (a[x] ?? 0));
+    });
+    const [i0 = 0, i1 = 0, i2 = 0, i3 = 0] = ids;
+    if ((g[0] ?? 0) * nrm[0] + (g[1] ?? 0) * nrm[1] + (g[2] ?? 0) * nrm[2] >= 0)
+      b.quad(i0, i1, i2, i3);
+    else
+      b.quad(i0, i3, i2, i1);
+  };
+  const neg = (v) => [-v[0], -v[1], -v[2]];
+  for (const piece of pieces(rects, px, start, o.surface)) {
+    const { u0, u1, v0, v1, s } = piece;
+    const lo = depth > 0 ? s : s + LIFT;
+    const hi = depth > 0 ? s + depth : lo;
+    quad([at(u0, v0, hi), at(u1, v0, hi), at(u1, v1, hi), at(u0, v1, hi)], n, [u0, u1, u1, u0], [v0, v0, v1, v1]);
+    if (depth <= 0)
+      continue;
+    quad([at(u0, v0, lo), at(u1, v0, lo), at(u1, v0, hi), at(u0, v0, hi)], neg(up), [u0, u1, u1, u0], [0, 0, depth, depth]);
+    quad([at(u1, v0, lo), at(u1, v1, lo), at(u1, v1, hi), at(u1, v0, hi)], along, [v0, v1, v1, v0], [0, 0, depth, depth]);
+    quad([at(u1, v1, lo), at(u0, v1, lo), at(u0, v1, hi), at(u1, v1, hi)], up, [u1, u0, u0, u1], [0, 0, depth, depth]);
+    quad([at(u0, v1, lo), at(u0, v0, lo), at(u0, v0, hi), at(u0, v1, hi)], neg(along), [v1, v0, v0, v1], [0, 0, depth, depth]);
+  }
+  return b.build();
+}
+function pieces(rects, px, start, surface) {
+  const out = [];
+  for (const r of rects) {
+    const v0 = (7 - r.r1) * px;
+    const v1 = (7 - r.r0) * px;
+    if (!surface) {
+      out.push({ u0: start + r.c0 * px, u1: start + r.c1 * px, v0, v1, s: 0 });
+      continue;
+    }
+    const lift = (c) => {
+      let top = Number.NEGATIVE_INFINITY;
+      for (const fu of [0.02, 0.5, 0.98])
+        for (const v of [v0 + 0.02 * px, (v0 + v1) / 2, v1 - 0.02 * px])
+          top = Math.max(top, surface(start + (c + fu) * px, v));
+      return top;
+    };
+    let c = r.c0;
+    while (c < r.c1) {
+      const s = lift(c);
+      let e = c + 1;
+      while (e < r.c1 && Math.abs(lift(e) - s) < 0.000001)
+        e++;
+      out.push({ u0: start + c * px, u1: start + e * px, v0, v1, s });
+      c = e;
+    }
+  }
+  return out;
+}
+// src/primitives/tiled.ts
+function tiled2(o) {
+  const { lu, lv, n } = spanOf("tiled", o.origin, o.u, o.v);
+  const strip = o.strip ?? "plain";
+  const segs = count("tiled segments", o.segments ?? 1, 1, 4096);
+  const vm = positive("tiled vMetres", o.vMetres ?? stripVMetres(strip), "e.g. 0.45 for brick");
+  const rect = stripRect2(strip);
+  const uOff = o.uOffset ?? 0;
+  const b = new MeshBuilder2;
+  const sides = o.doubleSided ? [1, -1] : [1];
+  let t = 0;
+  while (t < lv - 0.000000001) {
+    let local = (o.vOffset ?? 0) + t;
+    local -= Math.floor(local / vm) * vm;
+    if (vm - local < 0.000000001)
+      local = 0;
+    const step = Math.min(lv - t, vm - local);
+    const fv0 = local / vm;
+    const fv1 = (local + step) / vm;
+    for (const side of sides) {
+      const nn = [n[0] * side, n[1] * side, n[2] * side];
+      const first = row(b, o, nn, rect, uOff, lu, segs, t / lv, stripV(rect, fv0));
+      row(b, o, nn, rect, uOff, lu, segs, (t + step) / lv, stripV(rect, fv1));
+      for (let j = 0;j < segs; j++) {
+        const a = first + j;
+        const c = first + segs + 1 + j;
+        if (side > 0)
+          b.quad(a, a + 1, c + 1, c);
+        else
+          b.quad(a, c, c + 1, a + 1);
+      }
+    }
+    t += step;
+  }
+  return b.build();
+}
+function row(b, o, n, rect, uOff, lu, segs, fv, v) {
+  let first = -1;
+  for (let j = 0;j <= segs; j++) {
+    const fu = j / segs;
+    const id = b.vertex({
+      p: [
+        o.origin[0] + o.u[0] * fu + o.v[0] * fv,
+        o.origin[1] + o.u[1] * fu + o.v[1] * fv,
+        o.origin[2] + o.u[2] * fu + o.v[2] * fv
+      ],
+      n,
+      uv: [stripU(rect, uOff + lu * fu), v],
+      color: o.color
+    });
+    if (first < 0)
+      first = id;
+  }
+  return first;
+}
+// src/primitives/value-noise.ts
+function valueNoise3(rng, o = {}) {
+  const perm = new Uint8Array(512);
+  const vals = new Float64Array(256);
+  for (let i = 0;i < 256; i++) {
+    perm[i] = i;
+    vals[i] = rng.next() * 2 - 1;
+  }
+  for (let i = 255;i > 0; i--) {
+    const j = rng.int(0, i);
+    const t = perm[i] ?? 0;
+    perm[i] = perm[j] ?? 0;
+    perm[j] = t;
+  }
+  for (let i = 0;i < 256; i++)
+    perm[i + 256] = perm[i] ?? 0;
+  const at = (x, y, z) => vals[perm[(perm[(perm[x & 255] ?? 0) + (y & 255)] ?? 0) + (z & 255)] ?? 0] ?? 0;
+  const fade = (t) => t * t * t * (t * (t * 6 - 15) + 10);
+  const lerp = (a, b, t) => a + (b - a) * t;
+  const one = (x, y, z) => {
+    const xi = Math.floor(x);
+    const yi = Math.floor(y);
+    const zi = Math.floor(z);
+    const u = fade(x - xi);
+    const v = fade(y - yi);
+    const w = fade(z - zi);
+    const plane = (k) => lerp(lerp(at(xi, yi, k), at(xi + 1, yi, k), u), lerp(at(xi, yi + 1, k), at(xi + 1, yi + 1, k), u), v);
+    return lerp(plane(zi), plane(zi + 1), w);
+  };
+  const s = 1 / (o.scale ?? 1);
+  const octaves = o.octaves ?? 3;
+  return (p) => {
+    let sum = 0;
+    let amp = 1;
+    let norm = 0;
+    let f = s;
+    for (let i = 0;i < octaves; i++) {
+      sum += amp * one(p[0] * f, p[1] * f, p[2] * f);
+      norm += amp;
+      amp *= 0.5;
+      f *= 2;
+    }
+    return sum / norm;
+  };
+}
+export { box2, lathe2, cylinder2, beam2, cell2, hydraulicErosion2, heightfield2, triangulate2, lattice2, ringXY2, loft2, gradientNoise22, valueNoise22, fbm2, billow2, ridged2, warp2, terrace2, planar2, prism2, sd2, sdf2, sculptField2, sculpt2, arcLengths2, transportFrames2, sweep2, terrainGrid2, sampler2, slopeMap2, thermalErosion2, terrainColor2, measureText2, text2, tiled2, valueNoise3 };
+
+//# debugId=1A8BAFD57A1802CD64756E2164756E21
+//# sourceMappingURL=chunk-d1fv6hrm.js.map