@developerz.ai/ts23d 0.0.0-stage → 0.2.0

package/dist/chunk-8j4c28jt.js

@@ -0,0 +1,4085 @@
+import {
+  Ts23dError2,
+  notImplemented2,
+  BUDGETS2,
+  defineFamily2,
+  MeshBuilder2,
+  triangleCount2,
+  boundsOf2,
+  translate2,
+  merge2,
+  place2,
+  sub2,
+  dot2,
+  cross2,
+  normalize2
+} from "./chunk-hg7pf34j.js";
+import {
+  split2,
+  parseWhyte2
+} from "./chunk-dxvypr7y.js";
+import {
+  hex2,
+  DEFAULT_SHEET2,
+  stripRect2
+} from "./chunk-y63c6zcv.js";
+import {
+  box2,
+  lathe2,
+  cylinder2,
+  beam2,
+  triangulate2,
+  ringXY2,
+  loft2,
+  planar2,
+  sd2,
+  sdf2,
+  sculptField2,
+  arcLengths2,
+  transportFrames2,
+  sweep2
+} from "./chunk-d1fv6hrm.js";
+import {
+  bakeAo2
+} from "./chunk-drna2rny.js";
+
+// src/kinds/faces.ts
+var EPS = 0.000000001;
+function clipPoly(poly, f) {
+  const out = [];
+  const n = poly.length;
+  for (let i = 0;i < n; i++) {
+    const a = poly[i];
+    const b = poly[(i + 1) % n];
+    if (a === undefined || b === undefined)
+      continue;
+    const fa = f(a);
+    const fb = f(b);
+    if (fa <= EPS)
+      out.push(a);
+    if (fa <= EPS !== fb <= EPS) {
+      const t = fa / (fa - fb);
+      out.push(a.map((v, k) => v + ((b[k] ?? v) - v) * t));
+    }
+  }
+  return dedupe(out);
+}
+function dedupe(poly) {
+  const out = [];
+  for (const p of poly) {
+    const q = out.at(-1);
+    if (!q || p.some((v, k) => Math.abs(v - (q[k] ?? 0)) > 0.0000001))
+      out.push(p);
+  }
+  const first = out[0];
+  const last = out.at(-1);
+  if (out.length > 1 && first && last && first.every((v, k) => Math.abs(v - (last[k] ?? 0)) < 0.0000001))
+    out.pop();
+  return out;
+}
+var area2 = (poly) => poly.reduce((s, a, i) => {
+  const b = poly[(i + 1) % poly.length] ?? a;
+  return s + a[0] * b[1] - b[0] * a[1];
+}, 0) / 2;
+var stripScale = (strip) => DEFAULT_SHEET2.strips[strip]?.scaleMetres ?? 1;
+function emitFace(b, o) {
+  if (o.points.length < 3)
+    return 0;
+  const n = normalize2(o.normal);
+  const points = dot2(newell(o.points), n) < 0 ? [...o.points].reverse() : o.points;
+  const vDir = normalize2(sub2(o.up, scaleV(n, dot2(o.up, n))));
+  const uDir = cross2(vDir, n);
+  const rect = stripRect2(o.strip);
+  const scale = stripScale(o.strip);
+  const vOf = (p) => dot2(sub2(p, o.vOrigin), vDir);
+  const vs = points.map(vOf);
+  const lo = Math.min(...vs);
+  const hi = Math.max(...vs);
+  if (hi - lo < 0.000001)
+    return 0;
+  const colour = (p) => typeof o.color === "function" ? o.color(p) : o.color;
+  const bands = [];
+  if (o.banded === false)
+    bands.push([lo, hi]);
+  else {
+    for (let k = Math.floor(lo / scale + 0.000000001);k * scale < hi - 0.000000001; k++) {
+      bands.push([k * scale, (k + 1) * scale]);
+    }
+  }
+  let tris = 0;
+  for (const [v0, v1] of bands) {
+    const span = v1 - v0;
+    const poly = clipPoly(clipPoly(points, (p) => v0 - vOf(p)), (p) => vOf(p) - v1);
+    if (poly.length < 3)
+      continue;
+    const ids = poly.map((p) => {
+      const f = Math.min(1, Math.max(0, (vOf(p) - v0) / span));
+      return b.vertex({
+        p,
+        n,
+        uv: [
+          rect.u0 + dot2(p, uDir) / rect.metres * (rect.u1 - rect.u0),
+          rect.v0 + f * (rect.v1 - rect.v0)
+        ],
+        color: colour(p)
+      });
+    });
+    const first = ids[0] ?? 0;
+    for (let i = 1;i + 1 < ids.length; i++)
+      b.tri(first, ids[i] ?? 0, ids[i + 1] ?? 0);
+    tris += ids.length - 2;
+  }
+  return tris;
+}
+function newell(poly) {
+  const n = [0, 0, 0];
+  for (let i = 0;i < poly.length; i++) {
+    const a = poly[i] ?? [0, 0, 0];
+    const b = poly[(i + 1) % poly.length] ?? a;
+    n[0] += (a[1] - b[1]) * (a[2] + b[2]);
+    n[1] += (a[2] - b[2]) * (a[0] + b[0]);
+    n[2] += (a[0] - b[0]) * (a[1] + b[1]);
+  }
+  return n;
+}
+var scaleV = (v, s) => [v[0] * s, v[1] * s, v[2] * s];
+
+// src/kinds/mass.ts
+function mass2(o, lod = 0) {
+  const [w, d, h] = o.size;
+  if (!(w > 0 && d > 0 && h > 0))
+    throw new Ts23dError2("T3D_RECIPE_INVALID", {
+      cause: `mass size is [${o.size.join(", ")}]`,
+      fix: "give width (X), depth (Y) and height (Z) in metres, all > 0"
+    });
+  const [cx, cy, z0] = o.at ?? [0, 0, 0];
+  const [x0, x1, y0, y1, z1] = [cx - w / 2, cx + w / 2, cy - d / 2, cy + d / 2, z0 + h];
+  const b = new MeshBuilder2;
+  const strip = o.strip ?? "brick";
+  const origin = [0, 0, o.courseOrigin ?? 0];
+  const sides = [
+    [
+      "front",
+      [1, 0, 0],
+      [
+        [x1, y0, z0],
+        [x1, y1, z0],
+        [x1, y1, z1],
+        [x1, y0, z1]
+      ]
+    ],
+    [
+      "back",
+      [-1, 0, 0],
+      [
+        [x0, y1, z0],
+        [x0, y0, z0],
+        [x0, y0, z1],
+        [x0, y1, z1]
+      ]
+    ],
+    [
+      "left",
+      [0, 1, 0],
+      [
+        [x1, y1, z0],
+        [x0, y1, z0],
+        [x0, y1, z1],
+        [x1, y1, z1]
+      ]
+    ],
+    [
+      "right",
+      [0, -1, 0],
+      [
+        [x0, y0, z0],
+        [x1, y0, z0],
+        [x1, y0, z1],
+        [x0, y0, z1]
+      ]
+    ]
+  ];
+  for (const [name, normal, points] of sides) {
+    if (o.omit?.includes(name))
+      continue;
+    emitFace(b, {
+      points,
+      normal,
+      up: [0, 0, 1],
+      vOrigin: origin,
+      color: o.color,
+      strip,
+      banded: lod < 2
+    });
+  }
+  for (const [name, z, s] of [
+    ["top", z1, 1],
+    ["bottom", z0, -1]
+  ]) {
+    if (o.omit?.includes(name))
+      continue;
+    emitFace(b, {
+      points: [
+        [x0, y0, z],
+        [x1, y0, z],
+        [x1, y1, z],
+        [x0, y1, z]
+      ],
+      normal: [0, 0, s],
+      up: [0, 1, 0],
+      vOrigin: [cx, y0, z],
+      color: o.color,
+      strip: "plain",
+      banded: false
+    });
+  }
+  return b.build();
+}
+
+// src/kinds/openings.ts
+var YAW = {
+  front: 0,
+  left: Math.PI / 2,
+  back: Math.PI,
+  right: -Math.PI / 2
+};
+var onWall = (size, y, z, color, strip) => box2({ size, at: [size[0] / 2, y, z], color, omit: ["back"], ...strip ? { strip } : {} });
+function opening2(o, lod = 0) {
+  const { width: w, height: h } = o;
+  if (!(w > 0.2 && h > 0.2 && Number.isFinite(w) && Number.isFinite(h)))
+    throw new Ts23dError2("T3D_RECIPE_INVALID", {
+      cause: `${o.kind} opening is ${w} × ${h} m`,
+      fix: "give a clear width and height > 0.2 m (sash ≈ 0.9 × 1.6, door ≈ 0.9 × 2.1)"
+    });
+  const r = o.depth ?? 0.12;
+  const s = o.surround ?? 0.1;
+  const trim = o.trim ?? [0.78, 0.75, 0.68];
+  const door = o.kind === "door";
+  const parts = [];
+  parts.push(door ? onWall([0.05, w, h], 0, 0, o.frame, "wood") : onWall([0.02, w, h], 0, 0, o.glass, "glass"));
+  if (lod < 2) {
+    const lintel = o.lintel ?? true;
+    const reveal = (size, y, z) => mass2({
+      size,
+      at: [size[0] / 2, y, z],
+      color: o.wall,
+      strip: o.wallStrip ?? "plain",
+      courseOrigin: -o.at[2],
+      omit: ["back"]
+    }, lod);
+    for (const side of [-1, 1])
+      parts.push(reveal([r, s, h], side * (w / 2 + s / 2), 0));
+    if (lintel)
+      parts.push(onWall([r + 0.03, w + 2 * s + 0.2, 0.22], 0, h, trim, "stone"));
+    else
+      parts.push(reveal([r, w + 2 * s, s], 0, h));
+    if (!door && (o.sill ?? true))
+      parts.push(onWall([r + 0.07, w + 2 * s + 0.12, 0.07], 0, -0.07, trim, "stone"));
+    if (!door)
+      parts.push(...sash(o, w, h, lod));
+    else if (lod === 0)
+      parts.push(...panels(o, w, h));
+  }
+  return place2(merge2(parts), { yaw: YAW[o.facing], at: o.at });
+}
+function sash(o, w, h, lod) {
+  const f = 0.06;
+  const d = 0.05;
+  const out = [
+    onWall([d, f, h], -(w / 2 - f / 2), 0, o.frame),
+    onWall([d, f, h], w / 2 - f / 2, 0, o.frame),
+    onWall([d, w - 2 * f, f], 0, 0, o.frame),
+    onWall([d, w - 2 * f, f], 0, h - f, o.frame)
+  ];
+  if (lod > 0)
+    return out;
+  const [across, up] = o.panes ?? [2, 2];
+  const bar = 0.03;
+  for (let i = 1;i < across; i++)
+    out.push(onWall([d * 0.8, bar, h - 2 * f], -w / 2 + f + (w - 2 * f) * i / across, f, o.frame));
+  for (let j = 1;j < up; j++)
+    out.push(onWall([d * 0.8, w - 2 * f, bar], 0, f + (h - 2 * f) * j / up - bar / 2, o.frame));
+  return out;
+}
+function panels(o, w, h) {
+  const out = [];
+  const pw = (w - 0.36) / 2;
+  const tone = [o.frame[0] * 0.85, o.frame[1] * 0.85, o.frame[2] * 0.85];
+  for (const y of [-1, 1])
+    for (const [z0, ph] of [
+      [0.15, h * 0.38],
+      [0.15 + h * 0.38 + 0.15, h - 0.45 - h * 0.38]
+    ])
+      out.push(box2({
+        size: [0.02, pw, ph],
+        at: [0.06, y * (pw / 2 + 0.06), z0],
+        color: tone,
+        omit: ["back"]
+      }));
+  out.push(box2({ size: [0.06, 0.06, 0.06], at: [0.08, w / 2 - 0.12, h * 0.48], color: [0.7, 0.6, 0.3] }));
+  return out;
+}
+
+// src/kinds/building.ts
+var OPENINGS = new Set(["win", "door", "arch", "shop"]);
+function facade2(ctx, o) {
+  const [w, d] = o.footprint;
+  const ratio = o.windowRatio ?? 0.6;
+  const depth = 0.08;
+  for (const side of o.sides) {
+    const along = side === "front" || side === "back" ? d : w;
+    for (let f = 0;f < o.floors; f++) {
+      const line = f === 0 && o.ground ? o.ground : o.grammar;
+      const z = o.at[2] + f * o.floorHeight;
+      split2(line, along).forEach((slot, i) => {
+        if (!OPENINGS.has(slot.symbol) || slot.size < 0.2)
+          return;
+        const isDoor = slot.symbol === "door" || slot.symbol === "shop";
+        const h = isDoor ? o.floorHeight * 0.85 : o.floorHeight * ratio;
+        const sill = isDoor ? 0 : (o.floorHeight - h) / 2;
+        const c = slot.start + slot.size / 2 - along / 2;
+        const inset = slot.size * 0.85;
+        const pos = side === "front" ? [o.at[0] + w / 2, o.at[1] + c, z + sill] : side === "back" ? [o.at[0] - w / 2, o.at[1] - c, z + sill] : side === "left" ? [o.at[0] - c, o.at[1] + d / 2, z + sill] : [o.at[0] + c, o.at[1] - d / 2, z + sill];
+        const name = `${o.prefix}_${side}_${f}_${i}`;
+        if (o.kit) {
+          const k = o.kit;
+          ctx.part(name, opening2({
+            kind: isDoor ? "door" : "window",
+            width: Math.max(0.3, inset - 0.2),
+            height: h - (isDoor ? 0.25 : 0.2),
+            at: pos,
+            facing: side,
+            glass: o.glass,
+            frame: o.frame ?? [0.92, 0.9, 0.85],
+            wall: k.wall,
+            ...k.trim ? { trim: k.trim } : {},
+            ...k.depth !== undefined ? { depth: k.depth } : {},
+            ...k.panes ? { panes: k.panes } : {},
+            ...k.strip ? { wallStrip: k.strip } : {}
+          }, ctx.lod));
+          return;
+        }
+        const size = side === "front" || side === "back" ? [depth, inset, h] : [inset, depth, h];
+        ctx.part(name, box2({
+          size,
+          at: pos,
+          color: isDoor ? o.frame ?? o.glass : o.glass,
+          strip: "glass",
+          omit: ["bottom"]
+        }));
+      });
+    }
+  }
+}
+function setbacks2(ctx, o) {
+  let z = 0;
+  o.tiers.forEach((t, i) => {
+    const h = t.floors * o.floorHeight;
+    ctx.part(`${o.prefix}_${i}`, box2({
+      size: [t.footprint[0], t.footprint[1], h],
+      at: [0, 0, z],
+      color: o.color,
+      strip: "stone",
+      omit: i === 0 ? ["bottom"] : []
+    }));
+    if (o.detail)
+      facade2(ctx, {
+        prefix: `${o.prefix}_${i}_win`,
+        at: [0, 0, z],
+        footprint: t.footprint,
+        floors: t.floors,
+        floorHeight: o.floorHeight,
+        grammar: o.grammar,
+        sides: ["front", "back", "left", "right"],
+        glass: o.glass
+      });
+    z += h;
+  });
+  return z;
+}
+// src/kinds/head-geom.ts
+var DEG = 180 / Math.PI;
+function alongX(d, roll = 0) {
+  const yaw = Math.atan2(d[1], d[0]);
+  const pitch = -Math.atan2(d[2], Math.hypot(d[0], d[1]));
+  return [roll, pitch * DEG, yaw * DEG];
+}
+function alongZ(d) {
+  const len = Math.hypot(d[0], d[1], d[2]) || 1;
+  const tilt = Math.acos(Math.max(-1, Math.min(1, d[2] / len)));
+  return [0, tilt * DEG, Math.atan2(d[1], d[0]) * DEG];
+}
+var unit = (d) => {
+  const l = Math.hypot(d[0], d[1], d[2]) || 1;
+  return [d[0] / l, d[1] / l, d[2] / l];
+};
+var along = (a, d, t) => [
+  a[0] + d[0] * t,
+  a[1] + d[1] * t,
+  a[2] + d[2] * t
+];
+
+// src/kinds/head-beard.ts
+var RAD = Math.PI / 180;
+function browEdits(p, l) {
+  const h = p.brow.hair ?? 0;
+  if (h <= 0)
+    return [];
+  const [ex, ey] = l.eye;
+  const r = l.eyeR;
+  const lift = [p.brow.ridge * 0.55 + 0.012, 0, p.brow.ridge * 0.8 + 0.018];
+  const inner = [ex + r * 0.75 + lift[0], 0.035, l.browZ - p.brow.scowl + lift[2]];
+  const outer = [
+    ex + r * 0.1 + lift[0] * 0.6,
+    ey + r * 1.25,
+    l.browZ + p.brow.scowl * 0.5 + lift[2] * 0.7
+  ];
+  const mid = [
+    (inner[0] + outer[0]) / 2,
+    inner[1] + (outer[1] - inner[1]) * 0.55,
+    (inner[2] + outer[2]) / 2 + 0.014
+  ];
+  return [
+    {
+      group: [
+        { shape: "capsule", at: inner, to: mid, size: h },
+        { shape: "capsule", at: mid, to: outer, size: h * 0.65, blend: 0.006 }
+      ],
+      color: p.colors.hair,
+      blend: 0.006
+    }
+  ];
+}
+var below = (p, deg) => {
+  const n = [-Math.sin(deg * RAD), 0, Math.cos(deg * RAD)];
+  return {
+    shape: "roundBox",
+    at: [p[0] - n[0], p[1], p[2] - n[2]],
+    size: [4, 4, 2],
+    rotate: [0, -deg, 0],
+    op: "intersect",
+    blend: 0.02
+  };
+};
+function beardEdits(p, l) {
+  if (p.beard === "none")
+    return [];
+  const h = p.colors.hair;
+  const light = [h[0] * 1.35, h[1] * 1.35, h[2] * 1.35];
+  const [ax, ay, az] = l.angle;
+  const ch = l.chin;
+  const mw = p.mouth.width;
+  const lipT = p.mouth.lips;
+  const full = p.beard !== "goatee";
+  const mass = full ? {
+    shape: "ellipsoid",
+    at: [(ax + ch[0]) / 2 + 0.03, 0, (az + ch[2]) / 2 + 0.01],
+    size: [(ch[0] - ax) / 2 + 0.08, ay + 0.065, 0.17]
+  } : { shape: "ellipsoid", at: [ch[0] + 0.01, 0, ch[2] + 0.02], size: [0.09, mw * 0.9, 0.11] };
+  const out = [
+    {
+      group: [
+        mass,
+        {
+          shape: "ellipsoid",
+          at: [ch[0] + 0.025, 0, ch[2] - 0.03],
+          size: [0.08, full ? 0.13 : 0.08, 0.1],
+          blend: 0.04
+        },
+        below([l.mouthX, 0, l.mouthZ + 0.03], full ? 28 : 0),
+        {
+          shape: "ellipsoid",
+          at: [l.mouthX + 0.02, 0, l.mouthZ - lipT * 0.3],
+          size: [0.07, mw * 1.05, lipT * 2.3],
+          op: "subtract",
+          blend: 0.012
+        },
+        ...[-0.05, 0.05].map((y) => ({
+          shape: "capsule",
+          at: [ch[0] + 0.12, y, l.mouthZ - 0.06],
+          to: [ch[0] + 0.06, y * 1.3, ch[2] - 0.14],
+          size: 0.008,
+          op: "subtract",
+          blend: 0.012,
+          mirror: false
+        }))
+      ],
+      color: h,
+      blend: 0.012
+    }
+  ];
+  if (p.beard === "braided")
+    out.push({
+      shape: "capsule",
+      at: [ch[0] + 0.03, 0.035, ch[2] - 0.08],
+      to: [ch[0] + 0.01, 0.045, ch[2] - 0.34],
+      size: 0.032,
+      color: light,
+      blend: 0.02
+    });
+  const root = [l.mouthX + 0.02, 0.012, l.mouthZ + lipT * 1.9];
+  const bend = [l.mouthX - 0.005, mw * 0.85, l.mouthZ + lipT * 0.6];
+  const tip = along(bend, unit([-0.4, 0.5, -1]), 0.05);
+  out.push({
+    group: [
+      { shape: "capsule", at: root, to: bend, size: 0.024 },
+      { shape: "capsule", at: bend, to: tip, size: 0.016, blend: 0.01 }
+    ],
+    color: light,
+    blend: 0.008
+  });
+  return out;
+}
+
+// src/kinds/head-torso.ts
+var sub = (a, b) => [a[0] - b[0], a[1] - b[1], a[2] - b[2]];
+var mid = (a, b) => [(a[0] + b[0]) / 2, (a[1] + b[1]) / 2, (a[2] + b[2]) / 2];
+var dist = (a, b) => Math.hypot(...sub(a, b));
+var PLINTH = 0.17;
+function frameOf(p, l) {
+  const m = p.bust.mass ?? 0.5;
+  const b = l.base + 0.06 + 0.1 * m;
+  const nz = b + 0.6;
+  return {
+    cx: l.cranium.at[0] + p.jaw.muzzle * 0.3,
+    s: p.bust.shoulders,
+    b,
+    floor: l.base,
+    nz,
+    m,
+    n: p.neck.radius,
+    trapZ: nz + 0.12 + (l.hinge[1] - 0.2 - nz - 0.12) * m,
+    cutZ: l.base + PLINTH + 0.06 + 0.1 * m
+  };
+}
+function torsoForms(f, g = 0) {
+  const { cx, s, b, m, n } = f;
+  const grow = (r) => [r[0] + g, r[1] + g, r[2] + g];
+  const top = [cx - 0.12, n * 0.5, f.trapZ];
+  const acromion = [cx - 0.05, s * 0.78, b + 0.62 + 0.05 * m];
+  return [
+    {
+      shape: "ellipsoid",
+      at: [cx - 0.05, 0, b + 0.36],
+      size: grow([0.25 + 0.07 * m, s * 0.66, 0.38])
+    },
+    {
+      shape: "ellipsoid",
+      at: [cx + 0.1 + 0.05 * m, s * 0.27, b + 0.46 + 0.02 * m],
+      size: grow([0.09 + 0.06 * m, s * 0.27, 0.11 + 0.03 * m]),
+      rotate: [-12, 0, 16],
+      blend: 0.05
+    },
+    {
+      shape: "ellipsoid",
+      at: [cx - 0.03, s * 0.8, b + 0.5 + 0.03 * m],
+      size: grow([0.13 + 0.06 * m, 0.11 + 0.05 * m, 0.16 + 0.05 * m]),
+      rotate: [-18, 0, 0],
+      blend: 0.08
+    },
+    {
+      shape: "ellipsoid",
+      at: mid(top, acromion),
+      size: [dist(top, acromion) / 2 + 0.08 + g, 0.11 + 0.12 * m + g, 0.05 + 0.1 * m + g],
+      rotate: alongX(sub(acromion, top)),
+      blend: 0.08 + 0.08 * m
+    },
+    {
+      shape: "capsule",
+      at: [cx - 0.04, s * 0.8, b + 0.55],
+      to: [cx - 0.02, s * 0.9, b + 0.05],
+      size: 0.12 + 0.05 * m + g,
+      blend: 0.06
+    },
+    {
+      shape: "capsule",
+      at: [cx + 0.2 + 0.04 * m, 0.045, f.nz - 0.03],
+      to: [cx + 0, s * 0.68, b + 0.6 + 0.04 * m],
+      size: 0.02 + 0.006 * (1 - m) + g,
+      blend: 0.035
+    },
+    {
+      shape: "ellipsoid",
+      at: [cx - 0.1, s * 0.55, b + 0.3],
+      size: grow([0.17 + 0.05 * m, 0.12 + 0.1 * m, 0.2]),
+      blend: 0.08
+    },
+    {
+      shape: "ellipsoid",
+      at: [cx - 0.18, 0, f.nz + 0.04 + 0.08 * m],
+      size: grow([0.12 + 0.06 * m, s * 0.32, 0.16 + 0.12 * m]),
+      blend: 0.1
+    }
+  ];
+}
+function cutField(f) {
+  const rz = 0.64;
+  const ry = f.s * 1.08;
+  const cz = f.cutZ + rz;
+  const e = sd2.ellipsoid([f.cx, 0, cz], [1.6, ry, rz]);
+  const box = sd2.box([f.cx, 0, cz + 1], [3.2, ry * 2, 2]);
+  return (q) => Math.min(e(q), box(q));
+}
+function bustCut(f, g = 0) {
+  const rz = 0.64;
+  const ry = f.s * 1.08 + g;
+  const cz = f.cutZ + rz - g;
+  return {
+    group: [
+      { shape: "ellipsoid", at: [f.cx, 0, cz], size: [1.6, ry, rz] },
+      { shape: "roundBox", at: [f.cx, 0, cz + 1], size: [3.2, ry * 2, 2] }
+    ],
+    op: "intersect",
+    blend: 0.012
+  };
+}
+function bodyEdits(p, f, color) {
+  const { cx, b, m, nz } = f;
+  const shade = p.colors.shade;
+  return [
+    {
+      group: [
+        ...torsoForms(f),
+        {
+          shape: "sphere",
+          at: [cx + 0.24 + 0.04 * m, 0, nz - 0.04],
+          size: 0.035,
+          op: "subtract",
+          blend: 0.04,
+          color: shade
+        },
+        {
+          shape: "capsule",
+          at: [cx + 0.26 + 0.06 * m, 0, b + 0.5],
+          to: [cx + 0.26 + 0.05 * m, 0, b + 0.22],
+          size: 0.01 + 0.006 * m,
+          op: "subtract",
+          blend: 0.04,
+          color: shade
+        },
+        bustCut(f)
+      ],
+      color
+    }
+  ];
+}
+var cylinder = (at, r, z0, z1) => ({
+  group: [
+    { shape: "capsule", at: [at[0], at[1], z0 - r], to: [at[0], at[1], z1 + r], size: r },
+    {
+      shape: "roundBox",
+      at: [at[0], at[1], (z0 + z1) / 2],
+      size: [4, 4, z1 - z0],
+      op: "intersect"
+    }
+  ]
+});
+function plinthEdits(p, f, minT = 0) {
+  const c = p.colors.plinth ?? [0.16, 0.15, 0.15];
+  const light = [c[0] * 1.35, c[1] * 1.35, c[2] * 1.35];
+  const x = f.cx - 0.04;
+  const R = 0.3 + 0.08 * f.s;
+  if (minT > 0.07)
+    return [
+      { ...cylinder([x, 0, 0], R * 1.05, f.floor - 0.1, f.cutZ + 0.02), color: c, mirror: false }
+    ];
+  const disc = f.floor + 0.07;
+  return [
+    { ...cylinder([x, 0, 0], R, f.floor - 0.1, disc), color: c, mirror: false },
+    {
+      shape: "torus",
+      at: [x, 0, disc],
+      size: [R - 0.03, 0.025],
+      color: light,
+      blend: 0.01,
+      mirror: false
+    },
+    {
+      ...cylinder([x, 0, 0], R * 0.62, disc, f.cutZ + 0.02),
+      color: c,
+      blend: 0.02,
+      mirror: false
+    }
+  ];
+}
+
+// src/kinds/head-armour.ts
+var RAD2 = Math.PI / 180;
+var shade = (c, k) => [c[0] * k, c[1] * k, c[2] * k];
+var above = (p, deg) => {
+  const n = [0, -Math.sin(deg * RAD2), Math.cos(deg * RAD2)];
+  return {
+    shape: "roundBox",
+    at: [p[0] + n[0], p[1] + n[1], p[2] + n[2]],
+    size: [4, 4, 2],
+    rotate: [deg, 0, 0],
+    op: "intersect"
+  };
+};
+var slab = (p, deg, t) => ({
+  shape: "roundBox",
+  at: p,
+  size: [4, 4, t],
+  rotate: [deg, 0, 0],
+  op: "intersect"
+});
+var ell = (at, r, g, roll) => ({
+  shape: "ellipsoid",
+  at,
+  size: [r[0] + g, r[1] + g, r[2] + g],
+  rotate: [roll, 0, 0]
+});
+function plate(at, r, roll, cut, tilt, c, t) {
+  return [
+    {
+      group: [
+        ell(at, r, 0, roll),
+        ...t < Math.min(...r) * 0.6 ? [{ ...ell(at, r, -t, roll), op: "subtract" }] : [],
+        above(cut, tilt)
+      ],
+      color: c,
+      blend: 0.006
+    },
+    {
+      group: [
+        ell(at, r, 0.022, roll),
+        ...t < Math.min(...r) * 0.6 ? [{ ...ell(at, r, -t * 0.8, roll), op: "subtract" }] : [],
+        slab(cut, tilt, 0.05)
+      ],
+      color: shade(c, 1.3),
+      blend: 0.006
+    }
+  ];
+}
+function armour(p, f, cell = 0) {
+  const t = Math.max(0.085, cell * 2.5);
+  const c = p.colors;
+  const { cx, s, b, nz } = f;
+  const metal = c.metal;
+  const out = [];
+  const cap = [cx - 0.04, s * 0.8, b + 0.66];
+  for (let k = 1;k >= 0; k--) {
+    const at = [cap[0], cap[1] + k * 0.07 * s, cap[2] - k * 0.17];
+    const r = k === 0 ? [0.27, 0.29, 0.25] : [0.23, 0.25, 0.19];
+    const tilt = -(38 + k * 14);
+    const cut = [at[0], at[1], at[2] - r[2] * 0.45];
+    out.push(...plate(at, r, -25 - k * 10, cut, tilt, shade(metal, 1 - k * 0.15), t));
+    for (let j = 0;j < 4; j++) {
+      const x = at[0] + (j - 1.5) * 0.12;
+      out.push({
+        shape: "sphere",
+        at: [x, at[1] + r[1] * 0.62, cut[2] + 0.02 - r[1] * 0.62 * Math.tan(-tilt * RAD2) * 0.4],
+        size: 0.017,
+        color: shade(metal, 1.35),
+        blend: 0.004
+      });
+    }
+  }
+  const crest = [cap[0], cap[1] - 0.03, cap[2] + 0.25];
+  out.push({
+    shape: "ellipsoid",
+    at: crest,
+    size: [0.25, 0.028, 0.07],
+    rotate: [-22, 0, 0],
+    color: shade(metal, 0.75),
+    blend: 0.02
+  });
+  for (let k = 0;k < 3; k++)
+    out.push({
+      shape: "cone",
+      at: [crest[0] - 0.14 + k * 0.14, crest[1] + 0.01, crest[2] + 0.02 - Math.abs(k - 1) * 0.03],
+      size: [0.075, 0.012, 0.36 - Math.abs(k - 1) * 0.12],
+      rotate: alongZ(unit([(k - 1) * 0.3, 0.55, 1])),
+      color: c.teeth,
+      blend: 0.015
+    });
+  const band = [cx, 0, b + 0.36];
+  out.push({
+    group: [{ group: torsoForms(f, 0.03) }, slab(band, 50, 0.15), bustCut(f)],
+    color: c.leather,
+    blend: 0.006,
+    mirror: false
+  }, {
+    group: [
+      { group: torsoForms(f, 0.055) },
+      bustCut(f),
+      {
+        shape: "roundBox",
+        at: [cx + 0.3, 0.02, b + 0.38],
+        size: [0.3, 0.14, 0.14],
+        rotate: [50, 0, 0],
+        op: "intersect"
+      },
+      {
+        shape: "ellipsoid",
+        at: [cx + 0.42, 0.02, b + 0.38],
+        size: [0.1, 0.04, 0.04],
+        op: "subtract"
+      }
+    ],
+    color: shade(metal, 0.8),
+    blend: 0.004,
+    mirror: false
+  });
+  const fur = c.fur ?? c.leather;
+  const R = f.n + 0.08;
+  for (let row = 0;row < 3; row++)
+    for (let i = 0;i < 8; i++) {
+      const a = (-80 + i * 22 + row * 11) * RAD2;
+      const rr = R + row * 0.07;
+      const root = [
+        cx - 0.1 - Math.abs(Math.cos(a)) * rr * 0.9,
+        Math.abs(Math.sin(a)) * rr + 0.02,
+        nz + 0.16 - row * 0.05
+      ];
+      const dir = unit([-0.7, Math.abs(Math.sin(a)) * 0.8, -0.55 - (i + row) % 2 * 0.3]);
+      out.push({
+        shape: "cone",
+        at: root,
+        size: [0.075 - row * 0.008, 0.012, 0.16 + (i + row) % 3 * 0.04],
+        rotate: alongZ(dir),
+        color: (i + row) % 2 ? fur : shade(fur, 0.72),
+        blend: 0.035
+      });
+    }
+  return out;
+}
+
+// src/kinds/head-garb.ts
+var shade2 = (c, k) => [c[0] * k, c[1] * k, c[2] * k];
+function vest(p, f) {
+  const c = p.colors;
+  const { cx, s, b, nz, n } = f;
+  const scarf = c.scarf ?? c.cloth;
+  const hood = c.cape ?? shade2(c.cloth, 0.8);
+  const out = [
+    {
+      group: [
+        { group: torsoForms(f, 0.032) },
+        {
+          shape: "ellipsoid",
+          at: [cx + 0.32, 0, nz + 0.01],
+          size: [0.2, 0.07, 0.11],
+          op: "subtract",
+          blend: 0.01
+        },
+        bustCut(f)
+      ],
+      color: c.cloth,
+      blend: 0.006
+    },
+    {
+      group: [
+        { group: torsoForms(f, 0.065) },
+        {
+          shape: "roundBox",
+          at: [cx + 0.4, 0, b + 0.3],
+          size: [0.5, 0.3, 1],
+          rotate: [0, -8, 0],
+          round: 0.08,
+          op: "subtract",
+          blend: 0.02
+        },
+        {
+          shape: "sphere",
+          at: [cx - 0.03, s * 0.98, b + 0.42],
+          size: 0.17,
+          op: "subtract",
+          blend: 0.02
+        },
+        bustCut(f)
+      ],
+      color: c.leather,
+      blend: 0.006
+    },
+    {
+      group: [
+        { group: torsoForms(f, 0.088) },
+        {
+          shape: "roundBox",
+          at: [cx, 0, b + 0.38],
+          size: [4, 4, 0.08],
+          rotate: [-48, 0, 0],
+          op: "intersect"
+        },
+        bustCut(f)
+      ],
+      color: shade2(c.leather, 0.65),
+      blend: 0.004,
+      mirror: false
+    },
+    {
+      group: [
+        { group: torsoForms(f, 0.105) },
+        {
+          shape: "roundBox",
+          at: [cx + 0.3, -0.06, b + 0.32],
+          size: [0.3, 0.1, 0.1],
+          rotate: [-48, 0, 0],
+          op: "intersect"
+        },
+        {
+          shape: "roundBox",
+          at: [cx + 0.4, -0.06, b + 0.32],
+          size: [0.16, 0.05, 0.05],
+          rotate: [-48, 0, 0],
+          op: "subtract"
+        }
+      ],
+      color: c.metal,
+      blend: 0.003,
+      mirror: false
+    },
+    {
+      group: [
+        {
+          shape: "torus",
+          at: [cx - 0.1, 0, nz + 0.03],
+          size: [n + 0.12, 0.06],
+          rotate: [0, -28, 0]
+        },
+        {
+          shape: "roundBox",
+          at: [cx - 1.04, 0, nz],
+          size: [2, 4, 4],
+          op: "intersect",
+          blend: 0.04
+        }
+      ],
+      color: hood,
+      blend: 0.03
+    },
+    {
+      group: [
+        { shape: "ellipsoid", at: [cx - 0.33, 0, nz - 0.04], size: [0.13, s * 0.5, 0.25] },
+        {
+          shape: "cone",
+          at: [cx - 0.36, 0, nz - 0.12],
+          size: [0.1, 0.015, 0.34],
+          rotate: alongZ(unit([-0.35, 0, -1])),
+          blend: 0.05
+        },
+        {
+          shape: "ellipsoid",
+          at: [cx - 0.3, 0, nz + 0.12],
+          size: [0.08, s * 0.36, 0.1],
+          op: "subtract",
+          blend: 0.02,
+          color: shade2(hood, 0.35)
+        }
+      ],
+      color: hood,
+      blend: 0.04,
+      mirror: false
+    },
+    {
+      shape: "torus",
+      at: [cx - 0.04, 0, nz + 0.17],
+      size: [n + 0.05, 0.065],
+      rotate: [0, -12, 0],
+      color: scarf,
+      blend: 0.02
+    }
+  ];
+  const knot = [cx + n * 0.8, n + 0.04, nz + 0.13];
+  out.push({
+    shape: "ellipsoid",
+    at: knot,
+    size: [0.05, 0.06, 0.05],
+    color: shade2(scarf, 0.85),
+    blend: 0.02,
+    mirror: false
+  });
+  for (const [dy, len, tw] of [
+    [0.3, 0.2, 0.045],
+    [0.6, 0.16, 0.04]
+  ]) {
+    const dir = unit([0.3, dy, -1]);
+    out.push({
+      shape: "cone",
+      at: [knot[0] + 0.01, knot[1] + dy * 0.04, knot[2] - 0.02],
+      size: [tw, tw * 0.7, len],
+      rotate: alongZ(dir),
+      color: dy > 0.5 ? scarf : shade2(scarf, 0.8),
+      blend: 0.015,
+      mirror: false
+    });
+  }
+  return out;
+}
+
+// src/kinds/head-bust.ts
+function hood(p, cx, nz) {
+  const c = p.colors;
+  return [
+    {
+      shape: "torus",
+      at: [cx - 0.08, 0, nz + 0.04],
+      size: [p.neck.radius + 0.13, 0.11],
+      color: c.cloth,
+      blend: 0.05
+    },
+    {
+      shape: "ellipsoid",
+      at: [cx - 0.36, 0, nz + 0.14],
+      size: [0.16, 0.3, 0.2],
+      color: c.cloth,
+      blend: 0.08
+    },
+    {
+      shape: "cone",
+      at: [cx - 0.42, 0, nz + 0.1],
+      size: [0.12, 0.02, 0.32],
+      rotate: [0, -165, 0],
+      color: c.cloth,
+      blend: 0.05
+    },
+    {
+      shape: "roundBox",
+      at: [cx + 0.1, 0.32, nz - 0.02],
+      size: [0.04, 0.1, 0.08],
+      round: 0.01,
+      rotate: [20, 0, 0],
+      color: c.leather,
+      blend: 0.005,
+      mirror: false
+    },
+    {
+      shape: "capsule",
+      at: [cx + 0.18, 0.12, nz - 0.02],
+      to: [cx + 0.26, 0.05, nz - 0.32],
+      size: 0.018,
+      color: c.leather,
+      blend: 0.01
+    }
+  ];
+}
+function tunic(p, f) {
+  const c = p.colors;
+  const { cx, s, b, nz } = f;
+  const shell = (g) => ({ group: torsoForms(f, g) });
+  const torso = sculptField2(torsoForms(f), { color: c.cloth, mirror: "y" }).field;
+  const front = (z) => {
+    let x = cx + 0.7;
+    for (let i = 0;i < 300 && torso([x, 0, z]) > 0; i++)
+      x -= 0.004;
+    return x;
+  };
+  const n = p.neck.radius;
+  const axis = (z) => [cx - 0.08, 0, z];
+  const mantle = (g) => ({
+    shape: "ellipsoid",
+    at: [cx - 0.1, 0, b + 0.45],
+    size: [0.42 + g, s + 0.06 + g, 0.3 + g]
+  });
+  const opening = {
+    shape: "ellipsoid",
+    at: [cx + 0.38, 0, nz - 0.1],
+    size: [0.3, s * 0.45, 0.5],
+    op: "subtract",
+    blend: 0.02
+  };
+  const brooch = (y) => ({
+    group: [
+      mantle(0.03),
+      { shape: "sphere", at: [cx + 0.17, y, b + 0.5], size: 0.065, op: "intersect" }
+    ],
+    color: c.metal,
+    blend: 0.004
+  });
+  return [
+    {
+      group: [
+        mantle(0),
+        { shape: "roundBox", at: [0, 0, b + 0.3 + 1], size: [4, 4, 2], op: "intersect" },
+        opening,
+        bustCut(f)
+      ],
+      color: c.cape ?? c.leather,
+      blend: 0.01
+    },
+    brooch(s * 0.4),
+    {
+      group: [
+        { shape: "capsule", at: axis(nz - 0.06), to: axis(nz + 0.1), size: n + 0.08 },
+        {
+          shape: "capsule",
+          at: axis(nz - 0.2),
+          to: axis(nz + 0.3),
+          size: n + 0.02,
+          op: "subtract"
+        },
+        {
+          shape: "ellipsoid",
+          at: [cx + 0.2, 0, nz + 0.12],
+          size: [0.12, 0.08, 0.14],
+          op: "subtract",
+          blend: 0.02
+        }
+      ],
+      color: c.leather,
+      blend: 0.015
+    },
+    {
+      group: [
+        shell(0.012),
+        { shape: "roundBox", at: [cx + 0.3, 0, b + 0.2], size: [0.4, 0.07, 0.6], op: "intersect" }
+      ],
+      color: c.leather,
+      blend: 0.004,
+      mirror: false
+    },
+    ...[0.5, 0.38, 0.26].map((z) => ({
+      shape: "sphere",
+      at: [front(b + z) + 0.014, 0, b + z],
+      size: 0.028,
+      color: c.metal,
+      blend: 0.004,
+      mirror: false
+    }))
+  ];
+}
+function bustEdits(p, l, cell = 0) {
+  const c = p.colors;
+  const f = frameOf(p, l);
+  const style = p.bust.style;
+  const bare = style === "pauldrons" || style === "vest";
+  const e = [
+    ...bodyEdits(p, f, bare ? c.skin : c.cloth),
+    {
+      shape: "ellipsoid",
+      at: [f.cx - 0.09, 0, f.nz + 0.06],
+      size: [f.n * 1.02, f.n * 1.02, 0.12],
+      color: c.skin,
+      blend: 0.04
+    }
+  ];
+  if (style === "pauldrons")
+    e.push(...armour(p, f, cell));
+  else if (style === "hood")
+    e.push(...hood(p, f.cx, f.nz));
+  else if (style === "vest")
+    e.push(...vest(p, f));
+  else
+    e.push(...tunic(p, f));
+  e.push(...plinthEdits(p, f, cell * 1.5));
+  e.push({ shape: "roundBox", at: [0, 0, f.floor - 1], size: [4, 4, 2], op: "subtract" });
+  return e;
+}
+
+// src/kinds/head-extras.ts
+var RAD3 = Math.PI / 180;
+function earEdits(p, l, minThick = 0) {
+  const { length, width, sweep, lift, shape } = p.ears;
+  const cx = l.cranium.at[0];
+  const ry = l.cranium.r[1];
+  const root = [cx + 0.02, ry * 0.9, l.eye[2] - 0.05];
+  const d = unit([-Math.sin(sweep * RAD3), Math.cos(sweep * RAD3), Math.tan(lift * RAD3)]);
+  const rot = alongX(d, shape === "pointed" ? -10 : 0);
+  const thick = Math.max(0.022 + width * 0.06, minThick);
+  const front = [Math.cos(sweep * RAD3), Math.sin(sweep * RAD3), 0];
+  const shade = p.colors.shade;
+  if (shape === "round") {
+    const at = along(root, d, 0.03);
+    const rot2 = [0, -lift, 90 + sweep];
+    return [
+      { shape: "ellipsoid", at, size: [width / 2, thick, length / 2], rotate: rot2, blend: 0.02 },
+      {
+        shape: "ellipsoid",
+        at: along(along(at, d, thick * 0.6), front, 0.004),
+        size: [width * 0.3, thick * 0.55, length * 0.3],
+        rotate: rot2,
+        op: "subtract",
+        blend: 0.012,
+        color: shade
+      },
+      {
+        shape: "ellipsoid",
+        at: [at[0], at[1] + thick * 0.4, at[2] - length * 0.33],
+        size: [width * 0.24, thick * 0.9, length * 0.16],
+        blend: 0.015
+      }
+    ];
+  }
+  return [
+    {
+      shape: "ellipsoid",
+      at: along(root, d, length * 0.3),
+      size: [length * 0.36, thick, width * 0.5],
+      rotate: rot,
+      blend: 0.03
+    },
+    {
+      shape: "ellipsoid",
+      at: along(root, d, length * 0.68),
+      size: [length * 0.34, thick * 0.75, width * 0.22],
+      rotate: rot,
+      blend: 0.04
+    },
+    {
+      shape: "ellipsoid",
+      at: along(along(root, d, length * 0.42), front, thick * 0.85),
+      size: [length * 0.36, thick * 0.6, width * 0.3],
+      rotate: rot,
+      op: "subtract",
+      blend: 0.015,
+      color: shade
+    },
+    { shape: "sphere", at: root, size: 0.04, blend: 0.03 }
+  ];
+}
+function tuskEdits(p, l, minR = 0) {
+  const t = p.tusks;
+  if (!t)
+    return [];
+  const out = [];
+  let at = [l.mouthX - 0.03 + p.jaw.underbite * 0.5, t.spread, l.mouthZ - 0.02];
+  let dir = unit([0.25, t.flare * 0.5, 1]);
+  const seg = t.length / 3;
+  for (let i = 0;i < 3; i++) {
+    const r0 = Math.max(t.radius * (1 - i / 3.4), minR);
+    const r1 = Math.max(t.radius * (1 - (i + 1) / 3.4), minR * 0.6);
+    out.push({
+      shape: "cone",
+      at,
+      size: [r0, Math.max(r1, 0.004), seg * 1.05],
+      rotate: alongZ(dir),
+      color: p.colors.teeth,
+      blend: i === 0 ? 0.02 : 0.004
+    });
+    at = along(at, dir, seg);
+    dir = unit([dir[0] - 0.22, dir[1] + t.flare * 0.15, dir[2]]);
+  }
+  return out;
+}
+function paintEdits(p, l) {
+  const c = p.colors.paint;
+  if (!c)
+    return [];
+  const [ex, ey, ez] = l.eye;
+  const band = (at, r, mirror = true, tilt = 0) => ({
+    shape: "ellipsoid",
+    at,
+    size: r,
+    rotate: [tilt, 0, 0],
+    op: "paint",
+    color: c,
+    blend: 0.006,
+    mirror
+  });
+  const chinZ = (l.mouthZ + l.chin[2]) / 2 - 0.02;
+  return [
+    band([ex + 0.1, ey - 0.035, ez - 0.13], [0.45, 0.016, 0.09], true, -8),
+    band([ex + 0.1, ey + 0.035, ez - 0.12], [0.45, 0.016, 0.085], true, -8),
+    band([l.cranium.at[0], 0, l.browZ + 0.14], [0.6, 0.028, 0.13], false),
+    band([l.chin[0], 0, chinZ], [0.4, 0.012, 0.06], false),
+    band([l.chin[0], 0.055, chinZ], [0.4, 0.012, 0.05])
+  ];
+}
+function wartEdits(p, l, rng) {
+  const cx = l.cranium.at[0];
+  const [rx, ry, rz] = l.cranium.r;
+  return Array.from({ length: p.warts }, () => {
+    const yaw = rng.range(-1.2, 1.2);
+    const el = rng.range(-0.1, 0.9);
+    const at = [
+      cx + rx * Math.cos(el) * Math.cos(yaw),
+      ry * Math.cos(el) * Math.sin(yaw),
+      l.cranium.at[2] + rz * Math.sin(el)
+    ];
+    return {
+      shape: "sphere",
+      at,
+      size: rng.range(0.008, 0.016),
+      color: p.colors.shade,
+      blend: 0.01,
+      mirror: false
+    };
+  });
+}
+
+// src/kinds/head-mouth.ts
+function mouthEdits(p, l, teeth = true) {
+  const c = p.colors;
+  const lipT = p.mouth.lips;
+  const mw = p.mouth.width;
+  const g = p.mouth.grin;
+  const out = [
+    {
+      shape: "ellipsoid",
+      at: [l.mouthX - 0.01, 0, l.mouthZ + lipT * 0.7],
+      size: [0.032, mw, lipT],
+      color: c.lips,
+      blend: 0.03
+    },
+    {
+      shape: "ellipsoid",
+      at: [l.mouthX - 0.015 + p.jaw.underbite * 0.7, 0, l.mouthZ - lipT * 0.8],
+      size: [0.034 + p.jaw.underbite * 0.3, mw * 0.85, lipT * (1.1 + p.jaw.underbite * 4)],
+      color: c.lips,
+      blend: 0.03
+    }
+  ];
+  if (g < 0.4 || !teeth) {
+    out.push({
+      shape: "capsule",
+      at: [l.mouthX + 0.05, 0, l.mouthZ],
+      to: [l.mouthX - 0.03 - 0.02 * g, mw * 0.98, l.mouthZ + 0.012 + g * 0.05 - p.brow.scowl * 0.4],
+      size: 0.006 + g * 0.022,
+      op: "subtract",
+      blend: 0.012,
+      color: c.mouth
+    });
+    return out;
+  }
+  const h = 0.035 + g * 0.05;
+  const z0 = l.mouthZ + h * 0.45;
+  const back = mw * 0.55;
+  out.push({
+    group: [
+      { shape: "ellipsoid", at: [l.mouthX - back, 0, z0], size: [back + 0.06, mw, h] },
+      {
+        shape: "ellipsoid",
+        at: [l.mouthX - back + 0.02, 0, z0 + h * 0.7],
+        size: [back + 0.12, mw * 1.1, h * 0.9],
+        op: "subtract"
+      }
+    ],
+    op: "subtract",
+    blend: 0.012,
+    color: c.mouth
+  });
+  if (teeth)
+    out.push({
+      shape: "ellipsoid",
+      at: [l.mouthX - back * 0.9, 0, l.mouthZ - h * 0.4],
+      size: [back * 0.9, mw * 0.62, h * 0.45],
+      color: [0.42, 0.12, 0.12],
+      blend: 0.01
+    });
+  out.push({
+    shape: "ellipsoid",
+    at: [l.mouthX - 0.06, mw * 0.95, z0 + h * 0.6],
+    size: [0.05, 0.045, 0.04 + g * 0.01],
+    rotate: [-30, 0, 0],
+    blend: 0.035
+  });
+  const n = teeth ? 3 : 0;
+  for (let i = 0;i < n; i++) {
+    const a = (0.25 + i) * 0.36;
+    const y = Math.sin(a) * mw * 0.82;
+    const x = l.mouthX - 0.03 - (1 - Math.cos(a)) * back * 1.3;
+    const lo = z0 - h * Math.sqrt(Math.max(0, 1 - (y / mw) ** 2));
+    const hi = z0 + h * 0.7 - h * 0.9 * Math.sqrt(Math.max(0, 1 - (y / (mw * 1.1)) ** 2));
+    const len = 0.03 + g * 0.008 - i * 0.004;
+    const r = 0.014 + g * 0.004 - i * 0.0015;
+    out.push({
+      shape: "cone",
+      at: [x, y, hi + 0.008],
+      size: [r, 0.003, len],
+      rotate: alongZ([0.15, 0, -1]),
+      color: c.teeth,
+      blend: 0.004
+    }, {
+      shape: "cone",
+      at: [x - 0.006, y * 0.97, lo - 0.008],
+      size: [r * 0.85, 0.003, len * 0.6],
+      rotate: alongZ([0.1, 0, 1]),
+      color: c.teeth,
+      blend: 0.004
+    });
+  }
+  return out;
+}
+
+// src/kinds/head-face.ts
+function primaryEdits(l) {
+  const [cx, , cz] = l.cranium.at;
+  const [rx, ry, rz] = l.cranium.r;
+  return [
+    { shape: "ellipsoid", at: [cx, 0, cz], size: [rx, ry, rz] },
+    {
+      shape: "ellipsoid",
+      at: [l.faceX - 0.19, 0, l.eye[2] - 0.03],
+      size: [0.2, ry * 0.86, 0.24],
+      blend: 0.08
+    }
+  ];
+}
+function skullEdits(p, l, cell = 0) {
+  const fine = cell < 0.03;
+  const tipR = Math.max(p.nose.tip, cell * 0.6);
+  const c = p.colors;
+  const cx = l.cranium.at[0];
+  const [ex, ey, ez] = l.eye;
+  const r = l.eyeR;
+  const mw = p.mouth.width;
+  const [ax, ay, az] = l.angle;
+  const [hx, hz] = l.hinge;
+  const chin = l.chin;
+  const tipX = l.faceX + 0.06 + p.nose.length * 0.25 + p.nose.bridge + p.jaw.muzzle * 0.5;
+  const tipZ = l.noseZ + 0.035 - p.nose.hook;
+  const bIn = [ex + r * 0.75, 0.03, l.browZ - p.brow.scowl];
+  const bOut = [ex + r * 0.05, ey + r * 1.3, l.browZ + p.brow.scowl * 0.5];
+  const e = [
+    ...primaryEdits(l),
+    {
+      shape: "ellipsoid",
+      at: [ex - 0.03, (ey + 0.06) * p.cheeks.width, ez - r - 0.065 * p.cheeks.size],
+      size: [0.075 * p.cheeks.size, 0.07 * p.cheeks.size, 0.055 * p.cheeks.size],
+      rotate: [0, 0, 25],
+      blend: 0.08
+    },
+    {
+      shape: "capsule",
+      at: [ex - r * 0.2, (ey + 0.05) * p.cheeks.width, ez - r - 0.03],
+      to: [cx + 0.06, l.cranium.r[1] * 0.92, ez - 0.07],
+      size: 0.028 * p.cheeks.size,
+      blend: 0.05
+    },
+    {
+      shape: "ellipsoid",
+      at: [l.faceX - 0.13 + p.jaw.muzzle * 0.6, 0, l.noseZ + 0.01],
+      size: [0.15, 0.2 * p.cheeks.width, 0.13],
+      blend: 0.08
+    },
+    {
+      shape: "ellipsoid",
+      at: [l.mouthX - 0.13, 0, l.mouthZ + 0.02],
+      size: [0.14, Math.max(mw * 1.15, 0.13), 0.12 + p.jaw.drop * 0.2],
+      blend: 0.07
+    },
+    {
+      shape: "roundBox",
+      at: [(ax + chin[0]) / 2 + 0.01, 0, (az + chin[2]) / 2 + 0.03],
+      size: [chin[0] - ax + 0.04, ay * 1.75, 0.16 + p.jaw.drop * 0.5],
+      round: 0.07,
+      rotate: [0, Math.atan2(az - chin[2], chin[0] - ax) * (180 / Math.PI) * 0.6, 0],
+      blend: 0.08
+    },
+    {
+      shape: "capsule",
+      at: [hx - 0.04, ay * 0.85, hz],
+      to: [ax, ay, az],
+      size: 0.055,
+      blend: 0.07
+    },
+    { shape: "sphere", at: [ax + 0.02, ay * 0.95, az], size: 0.065, blend: 0.07 },
+    {
+      shape: "roundBox",
+      at: chin,
+      size: [0.13 * p.jaw.chin, 0.18 * p.jaw.chin, 0.14 * p.jaw.chin],
+      round: 0.06 * p.jaw.chin,
+      blend: 0.06
+    },
+    {
+      shape: "capsule",
+      at: [cx + 0.02, 0, ez - 0.22],
+      to: [cx - 0.05, 0, l.base + 0.45],
+      size: p.neck.radius,
+      blend: 0.1
+    },
+    {
+      shape: "capsule",
+      at: [cx - 0.03, l.cranium.r[1] * 0.68, ez - 0.28],
+      to: [cx + p.neck.radius * 0.6, 0.05, l.base + 0.74],
+      size: p.neck.radius * 0.26,
+      blend: 0.05
+    },
+    {
+      shape: "ellipsoid",
+      at: [(bIn[0] + bOut[0]) / 2, (bIn[1] + bOut[1]) / 2, (bIn[2] + bOut[2]) / 2],
+      size: [
+        Math.hypot(bOut[0] - bIn[0], bOut[1] - bIn[1], bOut[2] - bIn[2]) / 2 + p.brow.ridge * 0.6,
+        p.brow.ridge * 1.25,
+        p.brow.ridge * 0.85
+      ],
+      rotate: alongX([bOut[0] - bIn[0], bOut[1] - bIn[1], bOut[2] - bIn[2]]),
+      blend: 0.05
+    },
+    {
+      shape: "sphere",
+      at: [bIn[0] - 0.01, 0, bIn[2] - p.brow.ridge * 0.15],
+      size: p.brow.ridge * 1.05,
+      blend: 0.05
+    },
+    { shape: "sphere", at: l.eye, size: r * 1.12, op: "subtract", blend: r * 0.5, color: c.shade }
+  ];
+  const lid = (deg, upper) => {
+    const t = deg * Math.PI / 180;
+    const n = upper ? [-Math.sin(t), 0, Math.cos(t)] : [Math.sin(t), 0, Math.cos(t)];
+    const k = upper ? 1 : -1;
+    return {
+      group: [
+        { shape: "sphere", at: l.eye, size: r * (upper ? 1.14 : 1.1) },
+        {
+          shape: "roundBox",
+          at: [ex + n[0] * k, ey, ez + n[2] * k],
+          size: [4, 4, 2],
+          rotate: [0, upper ? -deg : deg, 0],
+          op: "intersect"
+        }
+      ],
+      blend: r * 0.22
+    };
+  };
+  e.push(lid(p.eyes.lid, true), lid(p.eyes.lowerLid, false));
+  const long = p.nose.bridge > 0.06 ? 0.65 : 1;
+  const wing = Math.min(1.4, Math.max(0.55, p.nose.width / 0.065)) * long;
+  const rootR = Math.max(0.02 + p.nose.width * 0.6, cell * 0.65);
+  const wingX = Math.min(tipX - p.nose.tip * 1.2, l.faceX + 0.1 + p.jaw.muzzle * 0.5);
+  const noseRoot = [ex + r * 0.4, 0, ez - r * 0.4];
+  const noseDir = [tipX - noseRoot[0], 0, tipZ + 0.01 - noseRoot[2]];
+  const midNose = [
+    (ex + r * 0.6 + tipX) / 2,
+    0,
+    (ez - 0.02 + tipZ) / 2 + p.nose.hook * 0.3 + 0.01
+  ];
+  e.push({
+    shape: "cone",
+    at: noseRoot,
+    size: [rootR, tipR * 0.85, Math.hypot(...noseDir)],
+    rotate: alongZ(noseDir),
+    blend: 0.045
+  }, {
+    shape: "sphere",
+    at: midNose,
+    size: (rootR + tipR) / 2 * 0.85 + Math.max(0, p.nose.hook) * 0.12,
+    blend: 0.05
+  }, { shape: "sphere", at: [tipX, 0, tipZ], size: tipR, blend: 0.035 }, ...p.nose.hook > 0.04 ? [
+    {
+      shape: "cone",
+      at: [tipX, 0, tipZ],
+      size: [tipR * 0.9, 0.01, p.nose.tip + p.nose.hook * 1.2],
+      rotate: alongZ([0.6, 0, -1]),
+      blend: 0.03
+    }
+  ] : [], {
+    shape: "ellipsoid",
+    at: [wingX, p.nose.width, l.noseZ + 0.02],
+    size: [0.045 * wing, 0.035 * wing, 0.032 * wing],
+    blend: 0.025
+  }, {
+    shape: "ellipsoid",
+    at: [Math.min(tipX - p.nose.tip * 0.6, wingX + 0.035), p.nose.width * 0.55, l.noseZ + 0.005],
+    size: [0.022 * wing, 0.014 * wing, 0.012 * wing],
+    op: "subtract",
+    blend: 0.008,
+    color: c.mouth
+  });
+  e.push(...mouthEdits(p, l, fine));
+  const fold = unit([-0.02, mw - p.nose.width, l.mouthZ - l.noseZ]);
+  e.push({
+    shape: "ellipsoid",
+    at: [tipX - p.nose.tip * 1.5 - 0.035, p.nose.width + 0.05, l.noseZ - 0.035],
+    size: [0.08, 0.006, 0.006],
+    rotate: alongX(fold),
+    op: "subtract",
+    blend: 0.03,
+    color: c.shade
+  });
+  const [, , cz] = l.cranium.at;
+  const [crx, , crz] = l.cranium.r;
+  for (let i = 0;i < (p.wrinkles ?? 0); i++) {
+    const z = l.browZ + 0.07 + i * 0.05;
+    const x = cx + crx * Math.sqrt(Math.max(0, 1 - ((z - cz) / crz) ** 2)) + 0.005;
+    e.push({
+      shape: "ellipsoid",
+      at: [x, 0.06, z - 0.008],
+      size: [0.05, 0.08 - i * 0.012, 0.005],
+      rotate: [-14, -12, 0],
+      op: "paint",
+      blend: 0.01,
+      color: c.shade
+    });
+  }
+  return e;
+}
+
+// src/kinds/head-hair.ts
+var RAD4 = Math.PI / 180;
+function hairEdits(p, l) {
+  const h = p.colors.hair;
+  const [cx, , cz] = l.cranium.at;
+  const [rx, ry, rz] = l.cranium.r;
+  const top = l.crown;
+  switch (p.hair) {
+    case "topknot": {
+      const root = [cx - 0.14, 0, top - 0.03];
+      const rise = [cx - 0.2, 0, top + 0.13];
+      const fall = [cx - 0.38, 0, top + 0.02];
+      const tip = [cx - rx - 0.08, 0, cz - 0.12];
+      const seg = (a, b, r0, r1) => ({
+        shape: "cone",
+        at: a,
+        size: [r0, r1, Math.hypot(b[0] - a[0], b[1] - a[1], b[2] - a[2])],
+        rotate: alongZ([b[0] - a[0], b[1] - a[1], b[2] - a[2]]),
+        blend: 0.03
+      });
+      const ring = (at, deg) => ({
+        shape: "torus",
+        at,
+        size: [0.07, 0.018],
+        rotate: [0, deg, 0],
+        color: p.colors.metal,
+        blend: 0.004
+      });
+      return [
+        {
+          group: [
+            seg(root, rise, 0.085, 0.075),
+            seg(rise, fall, 0.08, 0.07),
+            seg(fall, tip, 0.07, 0.015)
+          ],
+          color: h,
+          blend: 0.02
+        },
+        ring([root[0] - 0.02, 0, root[2] + 0.06], -15),
+        ring([root[0] - 0.04, 0, root[2] + 0.11], -25)
+      ];
+    }
+    case "mohawk":
+      return Array.from({ length: 6 }, (_, i) => {
+        const a = (-20 + i * 26) * RAD4;
+        return {
+          shape: "ellipsoid",
+          at: [cx + Math.sin(a) * rx * 0.95, 0, cz + Math.cos(a) * rz * 0.97],
+          size: [0.06, 0.035, 0.09],
+          rotate: [0, a * 180 / Math.PI - 15, 0],
+          color: h,
+          blend: 0.03
+        };
+      });
+    case "swept": {
+      const C = [cx - 0.04, 0, cz + 0.04];
+      const R = [rx + 0.035, ry + 0.04, rz + 0.02];
+      const on = (az, el, lift = 0) => [
+        C[0] + (R[0] + lift) * Math.cos(el * RAD4) * Math.cos(az * RAD4),
+        C[1] + (R[1] + lift) * Math.cos(el * RAD4) * Math.sin(az * RAD4),
+        C[2] + (R[2] + lift) * Math.sin(el * RAD4)
+      ];
+      const light = [h[0] * 1.45, h[1] * 1.45, h[2] * 1.45];
+      const cone = (a, b, r0, r1) => ({
+        shape: "cone",
+        at: a,
+        size: [r0, r1, Math.hypot(b[0] - a[0], b[1] - a[1], b[2] - a[2])],
+        rotate: alongZ([b[0] - a[0], b[1] - a[1], b[2] - a[2]])
+      });
+      const lock = (az, el, len, r, i) => {
+        const a = on(az, el, -0.005);
+        const m = on(az + len * 0.3, el - len * 0.45, -0.012);
+        const b = on(az + len * 0.6, el - len, -0.045);
+        return {
+          group: [cone(a, m, r, r * 0.75), cone(m, b, r * 0.75, r * 0.15)],
+          color: i % 2 ? h : light,
+          blend: 0.035,
+          ...az === 0 ? { mirror: false } : {}
+        };
+      };
+      return [
+        {
+          group: [
+            { shape: "ellipsoid", at: C, size: R },
+            {
+              shape: "ellipsoid",
+              at: [l.faceX + 0.12, 0, l.eye[2] - 0.08],
+              size: [0.34, ry * 0.92, 0.36],
+              op: "subtract",
+              blend: 0.03
+            },
+            {
+              shape: "ellipsoid",
+              at: [cx + 0.02, ry, l.eye[2] - 0.08],
+              size: [0.13, 0.25, 0.16],
+              op: "subtract",
+              blend: 0.03
+            }
+          ],
+          color: h,
+          blend: 0.012
+        },
+        lock(0, 44, 50, 0.07, 1),
+        lock(22, 46, 50, 0.07, 0),
+        lock(45, 40, 45, 0.068, 1),
+        lock(70, 34, 40, 0.06, 0),
+        lock(95, 30, 35, 0.055, 1),
+        lock(120, 30, 30, 0.05, 0)
+      ];
+    }
+    case "tufts": {
+      const out = [];
+      const spots = [
+        [10, 78, 0.26],
+        [-25, 70, 0.22],
+        [40, 62, 0.22],
+        [150, 55, 0.2],
+        [115, 30, 0.2],
+        [100, 16, 0.18],
+        [-120, 40, 0.18]
+      ];
+      for (const [az, el, len] of spots) {
+        const a = az * RAD4;
+        const e = el * RAD4;
+        const n = [Math.cos(e) * Math.cos(a), Math.cos(e) * Math.sin(a), Math.sin(e)];
+        const root = [cx - 0.04 + rx * 0.97 * n[0], ry * 0.97 * n[1], cz + rz * 0.97 * n[2]];
+        const d1 = [n[0] - 0.6, n[1] * 1.3, n[2] * 0.6 + 0.25];
+        const l1 = Math.hypot(...d1);
+        const mid = [
+          root[0] + d1[0] / l1 * len * 0.55,
+          root[1] + d1[1] / l1 * len * 0.55,
+          root[2] + d1[2] / l1 * len * 0.55
+        ];
+        const d2 = [d1[0] - 0.5, d1[1] * 1.6, -0.9];
+        out.push({
+          group: [
+            { shape: "cone", at: root, size: [0.026, 0.014, len * 0.58], rotate: alongZ(d1) },
+            {
+              shape: "cone",
+              at: mid,
+              size: [0.015, 0.004, len * 0.6],
+              rotate: alongZ(d2),
+              blend: 0.008
+            }
+          ],
+          color: h,
+          blend: 0.012,
+          mirror: az !== 10 && az !== -25 && az !== -120
+        });
+      }
+      return out;
+    }
+    case "braids":
+      return [
+        { ...capOf(l, h) },
+        {
+          shape: "capsule",
+          at: [cx - 0.2, ry * 0.7, cz - 0.1],
+          to: [cx - 0.1, ry * 0.8, cz - 0.6],
+          size: 0.035,
+          color: h,
+          blend: 0.02
+        }
+      ];
+    default:
+      return [];
+  }
+}
+var capOf = (l, h) => ({
+  shape: "ellipsoid",
+  at: [l.cranium.at[0] - 0.07, 0, l.cranium.at[2] + 0.09],
+  size: [l.cranium.r[0] + 0.02, l.cranium.r[1] + 0.025, l.cranium.r[2]],
+  color: h,
+  blend: 0.02
+});
+
+// src/kinds/head-layout.ts
+function headLayout(p) {
+  const L = p.eyes.line;
+  const crH = p.cranium.height;
+  const rx = p.cranium.depth / 2;
+  const ry = p.cranium.width / 2;
+  const rz = crH * 0.8;
+  const cx = -0.02 - p.jaw.muzzle * 0.4;
+  const cz = L + crH * 0.2;
+  const faceX = cx + rx * 0.97;
+  const jut = p.jaw.muzzle;
+  const eyeR = p.eyes.radius;
+  const eye = [faceX - eyeR - p.brow.overhang, p.eyes.spacing, L];
+  const noseZ = L - p.nose.length;
+  const mouthZ = noseZ - 0.1 - p.jaw.drop * 0.3;
+  const chinZ = -p.jaw.drop;
+  const mouthX = faceX - 0.01 + jut + p.jaw.underbite * 0.3;
+  return {
+    cranium: { at: [cx, 0, cz], r: [rx, ry, rz] },
+    faceX,
+    eye,
+    eyeR,
+    browZ: L + eyeR * 0.9 + p.brow.ridge * 0.6,
+    noseZ,
+    mouthZ,
+    mouthX,
+    chin: [faceX - 0.07 + jut + p.jaw.underbite, 0, chinZ + 0.07 * p.jaw.chin],
+    hinge: [cx + 0.04, L - 0.09],
+    angle: [cx - 0.02, p.jaw.width, 0.15 - p.jaw.drop * 0.6],
+    crown: cz + rz,
+    base: -0.85 - p.jaw.drop * 0.5
+  };
+}
+
+// src/kinds/head-rim.ts
+function grad(f, p, e, out) {
+  const q = [p[0], p[1], p[2]];
+  const at = (dx, dy, dz) => {
+    q[0] = p[0] + dx;
+    q[1] = p[1] + dy;
+    q[2] = p[2] + dz;
+    return f(q);
+  };
+  out[0] = (at(e, 0, 0) - at(-e, 0, 0)) / (2 * e);
+  out[1] = (at(0, e, 0) - at(0, -e, 0)) / (2 * e);
+  out[2] = (at(0, 0, e) - at(0, 0, -e)) / (2 * e);
+  return f(p);
+}
+function project(f, p, e, onlyOutside) {
+  const g = [0, 0, 0];
+  const v = grad(f, p, e, g);
+  if (onlyOutside && v <= 0)
+    return;
+  const gg = g[0] * g[0] + g[1] * g[1] + g[2] * g[2];
+  if (gg < 0.000000000001)
+    return;
+  for (let k = 0;k < 3; k++)
+    p[k] = (p[k] ?? 0) - v * (g[k] ?? 0) / gg;
+}
+function sharpenRim(m, skull, side, part, res) {
+  const positions = new Float32Array(m.positions);
+  const normals = new Float32Array(m.normals);
+  const e = res * 0.25;
+  const gs = [0, 0, 0];
+  const gc = [0, 0, 0];
+  for (let i = 0;i < positions.length; i += 3) {
+    const p = [positions[i] ?? 0, positions[i + 1] ?? 0, positions[i + 2] ?? 0];
+    if (Math.abs(side(p)) > res * 2)
+      continue;
+    const c = grad(side, p, e, gc);
+    const s = grad(skull, p, e, gs);
+    if (Math.abs(s) > res * 2)
+      continue;
+    if (part(p) < Math.max(s, c) - res * 0.5)
+      continue;
+    const n = [normals[i] ?? 0, normals[i + 1] ?? 0, normals[i + 2] ?? 0];
+    const ls = Math.hypot(...gs) || 1;
+    const lc = Math.hypot(...gc) || 1;
+    const onSkin = (n[0] * gs[0] + n[1] * gs[1] + n[2] * gs[2]) / ls >= (n[0] * gc[0] + n[1] * gc[1] + n[2] * gc[2]) / lc;
+    for (let k = 0;k < 4; k++) {
+      if (onSkin) {
+        project(skull, p, e, false);
+        project(side, p, e, true);
+      } else {
+        project(side, p, e, false);
+        project(skull, p, e, true);
+      }
+    }
+    const other = onSkin ? side(p) : skull(p);
+    if (other > -res * 0.6)
+      for (let k = 0;k < 6; k++) {
+        project(skull, p, e, false);
+        project(side, p, e, false);
+      }
+    positions[i] = p[0];
+    positions[i + 1] = p[1];
+    positions[i + 2] = p[2];
+    if (onSkin) {
+      grad(skull, p, e, gs);
+      const l = Math.hypot(...gs) || 1;
+      normals[i] = gs[0] / l;
+      normals[i + 1] = gs[1] / l;
+      normals[i + 2] = gs[2] / l;
+    }
+  }
+  return { ...m, positions, normals };
+}
+function creaseNormals(m, minDot = 0.2) {
+  const P = m.positions;
+  const acc = new Float64Array(P.length);
+  for (let t = 0;t < m.indices.length; t += 3) {
+    const a = (m.indices[t] ?? 0) * 3;
+    const b = (m.indices[t + 1] ?? 0) * 3;
+    const c = (m.indices[t + 2] ?? 0) * 3;
+    const ux = (P[b] ?? 0) - (P[a] ?? 0);
+    const uy = (P[b + 1] ?? 0) - (P[a + 1] ?? 0);
+    const uz = (P[b + 2] ?? 0) - (P[a + 2] ?? 0);
+    const vx = (P[c] ?? 0) - (P[a] ?? 0);
+    const vy = (P[c + 1] ?? 0) - (P[a + 1] ?? 0);
+    const vz = (P[c + 2] ?? 0) - (P[a + 2] ?? 0);
+    const n = [uy * vz - uz * vy, uz * vx - ux * vz, ux * vy - uy * vx];
+    for (const v of [a, b, c])
+      for (let k = 0;k < 3; k++)
+        acc[v + k] = (acc[v + k] ?? 0) + (n[k] ?? 0);
+  }
+  const normals = new Float32Array(m.normals);
+  for (let i = 0;i < normals.length; i += 3) {
+    const l = Math.hypot(acc[i] ?? 0, acc[i + 1] ?? 0, acc[i + 2] ?? 0);
+    if (l < 0.00000000000000000001)
+      continue;
+    const f = [(acc[i] ?? 0) / l, (acc[i + 1] ?? 0) / l, (acc[i + 2] ?? 0) / l];
+    const d = (normals[i] ?? 0) * (f[0] ?? 0) + (normals[i + 1] ?? 0) * (f[1] ?? 0) + (normals[i + 2] ?? 0) * (f[2] ?? 0);
+    if (d >= minDot)
+      continue;
+    normals[i] = f[0] ?? 0;
+    normals[i + 1] = f[1] ?? 0;
+    normals[i + 2] = f[2] ?? 0;
+  }
+  return { ...m, normals };
+}
+
+// src/kinds/head-tone.ts
+function toned(field, colorAt, o) {
+  const k = o.strength ?? 1;
+  const d = o.reach;
+  const e = d * 0.25;
+  return (q) => {
+    const c = colorAt(q);
+    const [x, y, z] = q;
+    const gx = field([x + e, y, z]) - field([x - e, y, z]);
+    const gy = field([x, y + e, z]) - field([x, y - e, z]);
+    const gz = field([x, y, z + e]) - field([x, y, z - e]);
+    const gl = Math.hypot(gx, gy, gz) || 1;
+    const n = [gx / gl, gy / gl, gz / gl];
+    let occ = 0;
+    for (let i = 1;i <= 3; i++) {
+      const t = d * i / 3;
+      occ += Math.max(0, t - field([x + n[0] * t, y + n[1] * t, z + n[2] * t])) / t / i;
+    }
+    const cav = Math.min(1, occ * 2.5) * k;
+    const up = n[2] * k;
+    const lift = up > 0 ? 1 + up * 0.22 : 1 + up * 0.3;
+    const warm = up > 0 ? [1 + up * 0.12, 1 + up * 0.05, 1 - up * 0.15] : [1 + up * 0.1, 1, 1 - up * 0.12];
+    const dark = 1 - cav * 0.55;
+    const lum = (c[0] + c[1] + c[2]) / 3;
+    const sat = 1 + cav * 0.35;
+    return [
+      clamp((lum + (c[0] - lum) * sat) * dark * lift * warm[0]),
+      clamp((lum + (c[1] - lum) * sat) * dark * lift * warm[1]),
+      clamp((lum + (c[2] - lum) * sat) * dark * lift * warm[2])
+    ];
+  };
+}
+var clamp = (v) => Math.min(Math.max(v, 0), 1);
+
+// src/kinds/head-mesh.ts
+var REACH = 0.05;
+var PLINTH2 = [0.16, 0.15, 0.15];
+function jawRegion(p, l) {
+  const chin = l.chin;
+  const reach = Math.max(p.mouth.width * 1.08, (p.tusks?.spread ?? 0) + p.mouth.width * 0.5);
+  const centre = [l.mouthX - 0.15, 0, l.mouthZ];
+  const radii = [Math.max(0.27, l.mouthX - chin[0] + 0.2), reach, l.mouthZ - chin[2] + 0.1];
+  const e = sd2.ellipsoid(centre, radii);
+  return { field: (q) => Math.max(q[2] - l.mouthZ, e(q)), centre, radii };
+}
+var unionBounds = (a, b) => b ? [
+  [Math.min(a[0][0], b[0][0]), Math.min(a[0][1], b[0][1]), Math.min(a[0][2], b[0][2])],
+  [Math.max(a[1][0], b[1][0]), Math.max(a[1][1], b[1][1]), Math.max(a[1][2], b[1][2])]
+] : [a[0], a[1]];
+function regionGroup(l, r, grow) {
+  const cx = r.centre[0];
+  const [rx, ry, rz] = r.radii;
+  return {
+    group: [
+      { shape: "ellipsoid", at: r.centre, size: [rx + grow, ry + grow, rz + grow] },
+      {
+        shape: "roundBox",
+        at: [cx, 0, l.mouthZ + grow - 1],
+        size: [4, 4, 2],
+        op: "intersect"
+      }
+    ],
+    mirror: false,
+    blend: 0
+  };
+}
+function headAndJaw(p, l, set, res) {
+  const opts = { color: p.colors.skin, mirror: "y" };
+  const region = jawRegion(p, l);
+  const cut = region.field;
+  const lap = res * 0.75;
+  const proud = res * 0.03;
+  const ears = set.ears.length > 0 ? [{ group: set.ears, blend: 0.02 }] : [];
+  const tusks = set.tusks.length > 0 ? [{ group: set.tusks, blend: 0.01 }] : [];
+  const h = sculptField2([...set.skull, ...ears, { ...regionGroup(l, region, 0), op: "subtract" }], opts);
+  const jRaw = sculptField2([...set.skull, { ...regionGroup(l, region, lap), op: "intersect" }, ...tusks], opts);
+  const jField = (q) => jRaw.field(q) - proud;
+  const mouth = p.colors.mouth;
+  const skull = sculptField2(set.skull, opts).field;
+  const extra = (e) => e.length > 0 ? ((f) => (q) => Math.min(skull(q), f(q)))(sculptField2(e, opts).field) : skull;
+  const headTone = extra(set.ears);
+  const jawTone = extra(set.tusks);
+  const deep = -Math.max(res * 4, 0.03);
+  const paint = (colorAt) => (q) => Math.abs(cut(q)) < res * 1.5 && skull(q) < deep ? mouth : colorAt(q);
+  const [ec, er] = [region.centre, region.radii];
+  const jb = [
+    [ec[0] - er[0] - lap, -er[1] - lap, ec[2] - er[2] - lap],
+    [ec[0] + er[0] + lap, er[1] + lap, ec[2] + lap + 0.01]
+  ];
+  const tb = set.tusks.length > 0 ? sculptField2(set.tusks, opts).bounds : undefined;
+  const head = sdf2({
+    field: h.field,
+    bounds: h.bounds,
+    resolution: res,
+    color: toned(headTone, paint(h.colorAt), { reach: REACH }),
+    symmetry: "y"
+  });
+  const jaw = sdf2({
+    field: jField,
+    bounds: unionBounds(jb, tb),
+    resolution: res,
+    color: toned(jawTone, paint(jRaw.colorAt), { reach: REACH }),
+    symmetry: "y"
+  });
+  if (res > 0.03)
+    return { head: creaseNormals(head), jaw: creaseNormals(jaw) };
+  const jawSkull = (q) => skull(q) - proud;
+  return {
+    head: creaseNormals(head),
+    jaw: creaseNormals(sharpenRim(jaw, jawSkull, (q) => cut(q) - lap, jField, res))
+  };
+}
+function onCut(cut, q, n, res) {
+  if (Math.abs(cut(q)) > res * 0.8)
+    return false;
+  const e = res * 0.5;
+  const g = [
+    cut([q[0] + e, q[1], q[2]]) - cut([q[0] - e, q[1], q[2]]),
+    cut([q[0], q[1] + e, q[2]]) - cut([q[0], q[1] - e, q[2]]),
+    cut([q[0], q[1], q[2] + e]) - cut([q[0], q[1], q[2] - e])
+  ];
+  const l = Math.hypot(g[0], g[1], g[2]) || 1;
+  return (g[0] * n[0] + g[1] * n[1] + g[2] * n[2]) / l > 0.85;
+}
+function bustMesh(p, set, res) {
+  const s = sculptField2(set.bust, { color: p.colors.skin, mirror: "y" });
+  const tone = toned(s.field, s.colorAt, { reach: REACH * 1.4 });
+  const cut = set.bustCut;
+  const base = p.colors.plinth ?? PLINTH2;
+  const face = [base[0] * 1.3, base[1] * 1.3, base[2] * 1.3];
+  return sdf2({
+    field: s.field,
+    bounds: s.bounds,
+    resolution: res,
+    color: cut ? (q, n) => onCut(cut, q, n, res) ? face : tone(q) : tone,
+    symmetry: "y"
+  });
+}
+function eyeMesh(p, r, res) {
+  const c = p.colors;
+  const iris = Math.cos(0.62);
+  const limbus = Math.cos(0.7);
+  const pupil = Math.cos(0.3);
+  return sdf2({
+    field: (q) => Math.hypot(q[0], q[1], q[2]) - r,
+    bounds: [
+      [-r * 1.3, -r * 1.3, -r * 1.3],
+      [r * 1.3, r * 1.3, r * 1.3]
+    ],
+    resolution: res,
+    color: (q) => {
+      const cos = q[0] / (Math.hypot(q[0], q[1], q[2]) || 1);
+      if (cos > pupil)
+        return c.pupil;
+      if (cos > iris)
+        return c.iris;
+      if (cos > limbus)
+        return [c.iris[0] * 0.45, c.iris[1] * 0.45, c.iris[2] * 0.45];
+      return c.sclera;
+    }
+  });
+}
+
+// src/kinds/head-params.ts
+var bad = (cause, fix) => {
+  throw new Ts23dError2("T3D_RECIPE_INVALID", { cause, fix });
+};
+function numbers(o, path, out) {
+  if (typeof o === "number")
+    out.push([path, o]);
+  else if (o && typeof o === "object" && !Array.isArray(o))
+    for (const [k, v] of Object.entries(o))
+      numbers(v, path ? `${path}.${k}` : k, out);
+}
+var SIGNED = new Set([
+  "brow.scowl",
+  "jaw.underbite",
+  "nose.hook",
+  "ears.lift",
+  "ears.sweep",
+  "nose.bridge"
+]);
+var ZERO_OK = new Set([
+  "mouth.grin",
+  "warts",
+  "jaw.drop",
+  "jaw.muzzle",
+  "brow.overhang",
+  "brow.hair",
+  "bust.mass",
+  "wrinkles"
+]);
+function checkHead2(p) {
+  if (!(p.height >= 0.05 && p.height <= 3))
+    bad(`head height ${p.height} m`, "give height in metres, chin to crown: human 0.23, orc ≈ 0.3");
+  const flat = [];
+  numbers({ ...p, colors: undefined, height: undefined }, "", flat);
+  for (const [k, v] of flat) {
+    if (!Number.isFinite(v))
+      bad(`head param ${k} is ${v}`, "use finite numbers (head units)");
+    if (SIGNED.has(k))
+      continue;
+    if (v < 0 || v === 0 && !ZERO_OK.has(k))
+      bad(`head param ${k} is ${v}`, `make ${k} > 0 (head units: 1 = chin to crown)`);
+  }
+  const e = p.eyes;
+  if (e.line < 0.3 || e.line > 0.7)
+    bad(`eyes.line ${e.line}`, "keep the eye line between 0.3 and 0.7 of the head height");
+  if (e.spacing < e.radius * 1.1)
+    bad(`eyes.spacing ${e.spacing} < eyes.radius ${e.radius} × 1.1: the eyeballs overlap`, "raise eyes.spacing (centre to midline) or shrink eyes.radius");
+  if (e.lid <= e.lowerLid * -1 || e.lid > 80)
+    bad(`eye lids ${e.lid}°/${e.lowerLid}° leave no opening`, "use lid in (−lowerLid, 80] degrees");
+  if (p.mouth.grin > 1)
+    bad(`mouth.grin ${p.mouth.grin}`, "grin runs 0 (closed) … 1 (wide)");
+  if (p.tusks && p.tusks.length > 0.6)
+    bad(`tusks.length ${p.tusks.length}`, "tusks longer than 0.6 head units read as horns");
+  return p;
+}
+
+// src/kinds/head-presets.ts
+var human = {
+  height: 0.23,
+  cranium: { width: 0.66, depth: 0.86, height: 0.5 },
+  brow: { ridge: 0.035, overhang: 0.03, scowl: 0.012, hair: 0.018 },
+  cheeks: { size: 1, width: 1 },
+  jaw: { muzzle: 0, width: 0.22, chin: 1.05, underbite: 0, drop: 0 },
+  nose: { length: 0.18, width: 0.06, tip: 0.036, hook: 0, bridge: 0 },
+  ears: { shape: "round", length: 0.27, width: 0.15, sweep: 12, lift: 0 },
+  eyes: { radius: 0.052, spacing: 0.135, line: 0.5, lid: 20, lowerLid: 30 },
+  mouth: { width: 0.1, lips: 0.018, grin: 0 },
+  tusks: null,
+  neck: { radius: 0.27 },
+  bust: { shoulders: 0.95, style: "tunic" },
+  hair: "swept",
+  beard: "short",
+  warts: 0,
+  colors: {
+    skin: hex2("#d9a07a"),
+    shade: hex2("#a8644a"),
+    lips: hex2("#b86b5c"),
+    sclera: hex2("#ece6dc"),
+    iris: hex2("#3d6e9e"),
+    pupil: hex2("#141414"),
+    teeth: hex2("#ece2c8"),
+    mouth: hex2("#4a1a18"),
+    hair: hex2("#5a3a22"),
+    cloth: hex2("#2e4f8a"),
+    cape: hex2("#7a2420"),
+    leather: hex2("#6b4428"),
+    metal: hex2("#c9a24a")
+  }
+};
+var orc = {
+  height: 0.3,
+  cranium: { width: 0.7, depth: 0.74, height: 0.31 },
+  brow: { ridge: 0.075, overhang: 0.06, scowl: 0.04 },
+  cheeks: { size: 1.3, width: 1.15 },
+  jaw: { muzzle: 0.1, width: 0.4, chin: 1.3, underbite: 0.1, drop: 0.1 },
+  nose: { length: 0.15, width: 0.1, tip: 0.042, hook: -0.01, bridge: -0.05 },
+  ears: { shape: "pointed", length: 0.38, width: 0.19, sweep: 30, lift: 10 },
+  eyes: { radius: 0.054, spacing: 0.155, line: 0.56, lid: 10, lowerLid: 22 },
+  mouth: { width: 0.17, lips: 0.034, grin: 0 },
+  tusks: { length: 0.22, radius: 0.055, spread: 0.15, flare: 0.35 },
+  neck: { radius: 0.38 },
+  bust: { shoulders: 1, style: "pauldrons", mass: 1 },
+  hair: "topknot",
+  beard: "none",
+  warts: 6,
+  colors: {
+    skin: hex2("#5c8034"),
+    shade: hex2("#33501e"),
+    lips: hex2("#4f6f30"),
+    sclera: hex2("#8a5a1a"),
+    iris: hex2("#ffb030"),
+    pupil: hex2("#140a06"),
+    teeth: hex2("#e2d6b0"),
+    mouth: hex2("#2a0e0c"),
+    hair: hex2("#231a14"),
+    cloth: hex2("#6b2a20"),
+    leather: hex2("#5a3a22"),
+    metal: hex2("#55524d"),
+    fur: hex2("#5e4a34"),
+    paint: hex2("#8a1c12")
+  }
+};
+var goblin = {
+  height: 0.19,
+  cranium: { width: 0.66, depth: 0.84, height: 0.5 },
+  brow: { ridge: 0.032, overhang: 0.02, scowl: 0.03 },
+  cheeks: { size: 1.05, width: 1.05 },
+  jaw: { muzzle: 0.05, width: 0.19, chin: 0.72, underbite: 0, drop: 0 },
+  nose: { length: 0.2, width: 0.06, tip: 0.046, hook: 0.065, bridge: 0.13 },
+  ears: { shape: "pointed", length: 0.66, width: 0.3, sweep: 24, lift: 6 },
+  eyes: { radius: 0.08, spacing: 0.155, line: 0.5, lid: 30, lowerLid: 20 },
+  mouth: { width: 0.21, lips: 0.014, grin: 0.8 },
+  tusks: null,
+  neck: { radius: 0.14 },
+  bust: { shoulders: 0.52, style: "vest", mass: 0 },
+  hair: "tufts",
+  beard: "none",
+  warts: 4,
+  wrinkles: 3,
+  colors: {
+    skin: hex2("#9cb84a"),
+    shade: hex2("#6a8a2c"),
+    lips: hex2("#7a8e36"),
+    sclera: hex2("#f0e6a0"),
+    iris: hex2("#e0a020"),
+    pupil: hex2("#120c04"),
+    teeth: hex2("#e8dcae"),
+    mouth: hex2("#3a1010"),
+    hair: hex2("#c8c0b0"),
+    cloth: hex2("#b8a47c"),
+    cape: hex2("#4e5e3a"),
+    leather: hex2("#6b4428"),
+    metal: hex2("#a88a4a"),
+    scarf: hex2("#9a3a24")
+  }
+};
+var dwarf = {
+  ...human,
+  height: 0.24,
+  cranium: { width: 0.74, depth: 0.86, height: 0.48 },
+  brow: { ridge: 0.05, overhang: 0.05, scowl: 0.02, hair: 0.024 },
+  cheeks: { size: 1.25, width: 1.1 },
+  jaw: { muzzle: 0.02, width: 0.27, chin: 1.2, underbite: 0, drop: 0.02 },
+  nose: { length: 0.2, width: 0.08, tip: 0.06, hook: 0.02, bridge: 0.02 },
+  eyes: { radius: 0.045, spacing: 0.14, line: 0.52, lid: 10, lowerLid: 24 },
+  neck: { radius: 0.34 },
+  bust: { shoulders: 1.1, style: "tunic" },
+  hair: "braids",
+  beard: "braided",
+  colors: { ...human.colors, skin: hex2("#d49470"), hair: hex2("#8a3f1c"), cloth: hex2("#4a5a2a") }
+};
+var elf = {
+  ...human,
+  height: 0.235,
+  cranium: { width: 0.62, depth: 0.86, height: 0.52 },
+  brow: { ridge: 0.025, overhang: 0.02, scowl: -0.01, hair: 0.012 },
+  cheeks: { size: 1.1, width: 1.05 },
+  jaw: { muzzle: 0, width: 0.19, chin: 0.85, underbite: 0, drop: 0 },
+  nose: { length: 0.18, width: 0.045, tip: 0.028, hook: 0, bridge: 0.01 },
+  ears: { shape: "pointed", length: 0.42, width: 0.16, sweep: 40, lift: 24 },
+  eyes: { radius: 0.05, spacing: 0.13, line: 0.5, lid: 14, lowerLid: 22 },
+  bust: { shoulders: 0.85, style: "tunic" },
+  hair: "swept",
+  beard: "none",
+  colors: {
+    ...human.colors,
+    skin: hex2("#e8c0a0"),
+    hair: hex2("#e0d090"),
+    iris: hex2("#3a8a5a"),
+    cloth: hex2("#2a6a4a")
+  }
+};
+var HEADS2 = { human, orc, goblin, dwarf, elf };
+
+// src/kinds/head.ts
+function headParams2(o = {}) {
+  const r = o.race ?? "human";
+  const base = typeof r === "string" ? HEADS2[r] : r;
+  if (!base)
+    throw new Ts23dError2("T3D_RECIPE_INVALID", {
+      cause: `unknown head race '${String(r)}'`,
+      fix: `use one of ${Object.keys(HEADS2).join(", ")} or pass a HeadParams object`
+    });
+  const out = { ...base };
+  for (const [k, v] of Object.entries(o.params ?? {})) {
+    const was = out[k];
+    out[k] = v && typeof v === "object" && !Array.isArray(v) && was && typeof was === "object" ? { ...was, ...v } : v;
+  }
+  return checkHead2(out);
+}
+function seatEyes(p, l) {
+  const f = sculptField2(primaryEdits(l), { color: p.colors.skin }).field;
+  const [, ey, ez] = l.eye;
+  let x = l.faceX + 0.4;
+  for (let i = 0;i < 400 && f([x, ey, ez]) > 0; i++)
+    x -= 0.002;
+  const r = l.eyeR;
+  return { ...l, eye: [x - r * 0.7 - p.brow.overhang * 0.3, ey, ez] };
+}
+var BUST_CELL = 1.6;
+var HEAD_RES2 = [0.02, 0.045, 0.14];
+function headEdits2(p, rng, lod = 0) {
+  const l = seatEyes(p, headLayout(p));
+  const res = HEAD_RES2[lod];
+  const warts = lod < 2 ? wartEdits(p, l, rng) : [];
+  const hair = lod < 2 || p.hair !== "tufts" ? hairEdits(p, l) : [];
+  return {
+    layout: l,
+    skull: [
+      ...skullEdits(p, l, res),
+      ...hair,
+      ...browEdits(p, l),
+      ...beardEdits(p, l),
+      ...warts,
+      ...paintEdits(p, l)
+    ],
+    ears: earEdits(p, l, res * 0.7),
+    tusks: tuskEdits(p, l, res * 0.45),
+    bust: bustEdits(p, l, res * BUST_CELL),
+    bustCut: cutField(frameOf(p, l))
+  };
+}
+function head2(ctx, o = {}) {
+  const p = headParams2(o);
+  const set = headEdits2(p, ctx.rng.fork("head"), ctx.lod);
+  const l = set.layout;
+  const H = p.height;
+  const res = HEAD_RES2[ctx.lod];
+  const { head: hm, jaw: jm } = headAndJaw(p, l, set, res);
+  const bm = bustMesh(p, set, res * BUST_CELL);
+  const eye = eyeMesh(p, l.eyeR, l.eyeR / ctx.pick([7, 3.5, 2.2]));
+  const [ox, oy, oz] = o.at ?? [0, 0, 0];
+  const toWorld = (m, at = [0, 0, 0]) => place2(m, { scale: H, at: [ox + at[0] * H, oy + at[1] * H, oz + (at[2] - l.base) * H] });
+  const ex = l.eye[0] + (ctx.lod > 0 ? res * 0.4 : 0);
+  const [, ey, ez] = l.eye;
+  const world = {
+    bust: toWorld(bm),
+    head: toWorld(hm),
+    jaw: toWorld(jm),
+    eye_l: toWorld(eye, [ex, ey, ez]),
+    eye_r: toWorld(eye, [ex, -ey, ez])
+  };
+  const occ = (skip) => merge2(Object.values(world).filter((m) => m !== skip));
+  const occHead = occ(world.jaw);
+  const occJaw = occ(world.head);
+  const ao = (m, by = occHead) => ctx.lod < 2 ? bakeAo2(m, { samples: ctx.pick([16, 10, 8]), radius: 0.12 * H / 0.23, strength: 0.55 }, by) : m;
+  const pre = o.prefix ? `${o.prefix}_` : "";
+  const pivot = (x, y, z) => [
+    ox + x * H,
+    oy + y * H,
+    oz + (z - l.base) * H
+  ];
+  const local = (m, at, by) => place2(ao(m, by), { at: [-at[0], -at[1], -at[2]] });
+  const hinge = pivot(l.hinge[0], 0, l.hinge[1]);
+  const eyeL = pivot(ex, ey, ez);
+  const eyeR = pivot(ex, -ey, ez);
+  const names = {
+    bust: `${pre}bust`,
+    head: `${pre}head`,
+    jaw: `${pre}jaw`,
+    eyeL: `${pre}eye_l`,
+    eyeR: `${pre}eye_r`
+  };
+  ctx.part(names.bust, ao(world.bust));
+  ctx.part(names.head, ao(world.head));
+  const sway = o.jawSway ?? 0;
+  ctx.part(names.jaw, local(world.jaw, hinge, occJaw), {
+    at: hinge,
+    ...sway > 0 ? { motion: { kind: "sway", axis: [0, 1, 0], degrees: sway, hz: 0.5 }, clearOf: [names.head] } : {}
+  });
+  ctx.part(names.eyeL, local(world.eye_l, eyeL), { at: eyeL });
+  ctx.part(names.eyeR, local(world.eye_r, eyeR), { at: eyeR });
+  return { parts: names, height: (l.crown - l.base) * H, params: p };
+}
+// src/kinds/hull-lines.ts
+var bad2 = (cause, fix) => new Ts23dError2("T3D_RECIPE_INVALID", { cause, fix });
+function validateHull(o) {
+  const dims = [o.length, o.beam, o.draft, o.freeboard];
+  if (!dims.every((v) => v > 0 && Number.isFinite(v)))
+    throw bad2(`hull length/beam/draft/freeboard = ${dims.join(" / ")}`, "give all four in metres, > 0 (a harbour tug: 30 / 9 / 4 / 1.2)");
+  if (o.beam > o.length * 0.8)
+    throw bad2(`hull beam ${o.beam} is over 0.8 × length ${o.length}`, "check the numbers: length/beam is 2.5–4 for tugs, 6–9 for ships");
+  const n = o.fullness ?? 3;
+  if (!(n >= 1.2 && n <= 8))
+    throw bad2(`hull fullness is ${n}`, "use 1.5 (soft V) … 5 (barge)");
+  const tw = o.transomWidth ?? 0.75;
+  if (!(tw > 0 && tw <= 1))
+    throw bad2(`hull transomWidth is ${tw}`, "use a share 0.3–1 of the half-beam");
+}
+var smooth = (t) => t <= 0 ? 0 : t >= 1 ? 1 : t * t * (3 - 2 * t);
+function hullLines2(o) {
+  validateHull(o);
+  const L = o.length;
+  const half = L / 2;
+  const [sb, ss] = o.sheer ?? [0.035 * L, 0.012 * L];
+  const round = (o.stern ?? "round") === "round";
+  const tw = o.transomWidth ?? 0.75;
+  const pe = o.entrance ?? 2;
+  const n = o.fullness ?? 3;
+  const flare = o.flare ?? 0.06;
+  const dead = Math.tan((o.deadriseDeg ?? 5) * Math.PI / 180);
+  const xf = 0.1 * L;
+  const xa = -0.15 * L;
+  const kf = 0.22 * L;
+  const ka = -0.25 * L;
+  const deck = (x) => {
+    const u = x / half;
+    return o.freeboard + (u > 0 ? sb : ss) * u * u;
+  };
+  const plan = (x) => {
+    if (x > xf)
+      return 1 - ((x - xf) / (half - xf)) ** pe;
+    if (x < xa) {
+      const v = Math.min(1, (xa - x) / (xa + half));
+      return round ? Math.sqrt(Math.max(0, 1 - v * v)) : 1 - (1 - tw) * v * v;
+    }
+    return 1;
+  };
+  const halfBreadth = (x) => o.beam / 2 * Math.max(0, plan(x));
+  const counter = round ? 0.35 * o.freeboard : 0.15 * o.freeboard;
+  const keel = (x) => {
+    if (x > kf) {
+      const u = Math.min(1, (x - kf) / (half - kf));
+      return -o.draft + (deck(half) + o.draft) * u ** 2;
+    }
+    if (x < ka) {
+      const v = Math.min(1, (ka - x) / (ka + half));
+      return -o.draft + (counter + o.draft) * v ** 1.6;
+    }
+    return -o.draft;
+  };
+  const section = (x, theta) => {
+    const f = plan(x);
+    const ns = 1.2 + (n - 1.2) * smooth(f / 0.8);
+    const s = Math.sin(theta) ** (2 / ns);
+    const c = Math.cos(theta) ** (2 / ns);
+    const zk = keel(x);
+    const zd = deck(x);
+    const zf = 1 - c;
+    const y = halfBreadth(x) * (1 - flare + flare * zf * zf) * s;
+    return [y, zk + (zd - zk) * zf + dead * y * c];
+  };
+  return { L, halfBreadth, deck, keel, section };
+}
+function thetaAt(lines, x, z) {
+  let lo = 0;
+  let hi = Math.PI / 2;
+  if (lines.section(x, lo)[1] >= z)
+    return lo;
+  if (lines.section(x, hi)[1] <= z)
+    return hi;
+  for (let i = 0;i < 40; i++) {
+    const mid = (lo + hi) / 2;
+    if (lines.section(x, mid)[1] < z)
+      lo = mid;
+    else
+      hi = mid;
+  }
+  return (lo + hi) / 2;
+}
+
+// src/kinds/hull-skin.ts
+var sub3 = (a, b) => [a[0] - b[0], a[1] - b[1], a[2] - b[2]];
+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]
+];
+function normalsOf(g) {
+  const R = g.length;
+  const out = g.map((row, i) => row.map((p, j) => {
+    const r = (k) => g[Math.max(0, Math.min(R - 1, k))] ?? row;
+    const ti = sub3(r(i + 1)[j] ?? p, r(i - 1)[j] ?? p);
+    const tj = sub3(row[Math.min(row.length - 1, j + 1)] ?? p, row[Math.max(0, j - 1)] ?? p);
+    const n = cross3(tj, ti);
+    const l = Math.hypot(...n);
+    return l < 0.000000001 ? [0, 0, 0] : [n[0] / l, n[1] / l, n[2] / l];
+  }));
+  for (let i = 0;i < R; i++) {
+    const row = out[i] ?? [];
+    row.forEach((n, j) => {
+      if (n[0] || n[1] || n[2])
+        return;
+      for (let d = 1;d < R; d++) {
+        const m = out[i - d]?.[j] ?? out[i + d]?.[j];
+        if (m && (m[0] || m[1] || m[2])) {
+          row[j] = m;
+          return;
+        }
+      }
+    });
+  }
+  return out;
+}
+function emitBand(b, g, nrm, j0, j1, color, mirror) {
+  const rect = stripRect2("plain");
+  for (const side of mirror ? [1, -1] : [1]) {
+    const ids = g.map((row, i) => row.slice(j0, j1 + 1).map((p, k) => {
+      const n = nrm[i]?.[j0 + k] ?? [0, 0, 1];
+      return b.vertex({
+        p: [p[0], p[1] * side, p[2]],
+        n: [n[0], n[1] * side, n[2]],
+        uv: [
+          rect.u0 + p[0] / rect.metres,
+          rect.v0 + k / Math.max(1, j1 - j0) * (rect.v1 - rect.v0)
+        ],
+        color
+      });
+    }));
+    for (let i = 0;i + 1 < ids.length; i++) {
+      for (let k = 0;k < j1 - j0; k++) {
+        const a = ids[i]?.[k] ?? 0;
+        const c = ids[i]?.[k + 1] ?? 0;
+        const e = ids[i + 1]?.[k + 1] ?? 0;
+        const d = ids[i + 1]?.[k] ?? 0;
+        if (side > 0)
+          b.quad(a, c, e, d);
+        else
+          b.quad(a, d, e, c);
+      }
+    }
+  }
+}
+
+// src/kinds/hull.ts
+var deckBand = (o, lod) => lod === 2 ? o.beam : stripScale("wood");
+function deckMesh(o, ln, xs, inset, lod) {
+  const b = new MeshBuilder2;
+  const rect = stripRect2("wood");
+  const w = deckBand(o, lod);
+  const camber = o.camber ?? o.beam / 50;
+  const yd = (x) => Math.max(0, ln.halfBreadth(x) - inset);
+  for (let y0 = -Math.ceil(o.beam / 2 / w) * w;y0 < o.beam / 2; y0 += w) {
+    const at = (x, y) => {
+      const h = yd(x);
+      const c = Math.max(-h, Math.min(h, y));
+      return [x, c, ln.deck(x) + (h > 0 ? camber * (1 - (c / h) ** 2) : 0)];
+    };
+    for (let i = 0;i + 1 < xs.length; i++) {
+      const x0 = xs[i] ?? 0;
+      const x1 = xs[i + 1] ?? 0;
+      const q = [at(x0, y0), at(x0, y0 + w), at(x1, y0 + w), at(x1, y0)];
+      if (Math.abs((q[1]?.[1] ?? 0) - (q[0]?.[1] ?? 0)) + Math.abs((q[2]?.[1] ?? 0) - (q[3]?.[1] ?? 0)) < 0.000001)
+        continue;
+      const ids = q.map((p) => b.vertex({
+        p,
+        n: [0, 0, 1],
+        uv: [rect.u0 + p[0] / rect.metres, rect.v0 + (p[1] - y0) / w * (rect.v1 - rect.v0)],
+        color: o.colors.deck
+      }));
+      b.quad(ids[0] ?? 0, ids[3] ?? 0, ids[2] ?? 0, ids[1] ?? 0);
+    }
+  }
+  return b.build();
+}
+function hullMesh2(o, lod = 0) {
+  const ln = hullLines2(o);
+  const half = o.length / 2;
+  const stations = [36, 18, 8][lod] ?? 8;
+  const na = [6, 3, 2][lod] ?? 2;
+  const nc = [4, 2, 1][lod] ?? 1;
+  const xs = Array.from({ length: stations + 1 }, (_, i) => -half + o.length * (1 - Math.cos(Math.PI * i / stations)) / 2);
+  const boot = o.bootTop ?? 0.3;
+  const hb = o.bulwark ?? 0;
+  const tb = 0.12;
+  const grid = xs.map((x) => {
+    const tw = thetaAt(ln, x, 0);
+    const tbt = thetaAt(ln, x, boot);
+    const row = [];
+    const seg = (t0, t1, k, first) => {
+      for (let i = first ? 0 : 1;i <= k; i++) {
+        const [y, z] = ln.section(x, t0 + (t1 - t0) * i / k);
+        row.push([x, y, z]);
+      }
+    };
+    seg(0, tw, na, true);
+    seg(tw, tbt, 1, false);
+    seg(tbt, Math.PI / 2, nc, false);
+    return row;
+  });
+  const nrm = normalsOf(grid);
+  for (const row of nrm) {
+    const n = row[0];
+    if (n) {
+      const l = Math.hypot(n[0], n[2]) || 1;
+      row[0] = [n[0] / l, 0, n[2] / l];
+    }
+  }
+  const b = new MeshBuilder2;
+  const c = o.colors;
+  emitBand(b, grid, nrm, 0, na, c.bottom, true);
+  emitBand(b, grid, nrm, na, na + 1, c.boot ?? [0.06, 0.06, 0.06], true);
+  emitBand(b, grid, nrm, na + 1, na + 1 + nc, c.topsides, true);
+  const parts = [b.build()];
+  if (hb > 0)
+    parts.push(bulwarks(o, ln, xs, hb, tb));
+  if (o.fender && lod < 2)
+    parts.push(...fenders(o.fender, ln, xs, lod));
+  if ((o.stern ?? "round") === "transom") {
+    const x = xs[0] ?? -half;
+    const star = (grid[0] ?? []).map((p) => p);
+    if (hb > 0)
+      star.push([x, ln.halfBreadth(x), ln.deck(x) + hb]);
+    const port = [...star].reverse().map((p) => [p[0], -p[1], p[2]]);
+    const yd = ln.halfBreadth(x);
+    const arc = [];
+    const w = deckBand(o, lod);
+    for (let y = Math.ceil(o.beam / 2 / w) * w;y > -o.beam / 2; y -= w) {
+      if (hb === 0 && Math.abs(y) < yd - 0.000000001)
+        arc.push([x, y, ln.deck(x) + (o.camber ?? o.beam / 50) * (1 - (y / yd) ** 2)]);
+    }
+    parts.push(transom(dedupe([...port.slice(0, -1), ...star, ...arc]), c.topsides));
+  }
+  const at = o.at ?? [0, 0, 0];
+  return {
+    shell: translate2(merge2(parts), at),
+    deck: translate2(deckMesh(o, ln, xs, hb > 0 ? tb : 0, lod), at),
+    lines: ln
+  };
+}
+function bulwarks(o, ln, xs, hb, tb) {
+  const g = xs.map((x) => {
+    const y = ln.halfBreadth(x);
+    const z = ln.deck(x);
+    const yi = Math.max(0, y - tb);
+    return [
+      [x, y, z],
+      [x, y, z + hb],
+      [x, yi, z + hb],
+      [x, yi, z]
+    ];
+  });
+  const b = new MeshBuilder2;
+  const top = o.colors.bulwark ?? o.colors.topsides;
+  for (const [j0, color] of [
+    [0, o.colors.topsides],
+    [1, top],
+    [2, top]
+  ]) {
+    const sliced = g.map((row) => row.slice(j0, j0 + 2));
+    emitBand(b, sliced, normalsOf(sliced), 0, 1, color, true);
+  }
+  return b.build();
+}
+function fenders(f, ln, xs, lod) {
+  const r = f.radius ?? 0.15;
+  return [1, -1].map((side) => sweep2({
+    section: { radius: r, segments: lod === 0 ? 8 : 5 },
+    path: xs.map((x) => [x, side * (ln.halfBreadth(x) + r * 0.4), ln.deck(x) - r * 1.2]),
+    color: f.color,
+    caps: true
+  }));
+}
+function transom(points, color) {
+  const b = new MeshBuilder2;
+  const rect = stripRect2("plain");
+  const ids = points.map((p) => b.vertex({ p, n: [-1, 0, 0], uv: [rect.u0 + p[1] / rect.metres, rect.v0], color }));
+  for (const [i, j, k] of triangulate2(points.map((p) => [p[1], p[2]])))
+    b.tri(ids[i] ?? 0, ids[k] ?? 0, ids[j] ?? 0);
+  return b.build();
+}
+function hull2(ctx, o) {
+  const name = o.name ?? "hull";
+  const m = hullMesh2(o, ctx.lod);
+  ctx.part(name, m.shell);
+  ctx.part(`${name}_deck`, m.deck);
+  return m.lines;
+}
+// src/kinds/planned.ts
+function creature2(_ctx, _o) {
+  notImplemented2("creature (SDF-skinned skeleton)", "docs/idea/07-what-fits.md");
+}
+// src/kinds/roof-chimney.ts
+function chimney(c, heightAt, at, lod) {
+  const [w, d] = c.size ?? [0.9, 0.6];
+  const cx = at[0] + c.at[0];
+  const cy = at[1] + c.at[1];
+  const corners = [
+    [cx - w / 2, cy - d / 2],
+    [cx + w / 2, cy - d / 2],
+    [cx + w / 2, cy + d / 2],
+    [cx - w / 2, cy + d / 2]
+  ];
+  const exit = Math.max(...corners.map(([x, y]) => heightAt(x, y)));
+  const top = exit + (c.height ?? 0.9);
+  const z0 = at[2];
+  const strip = c.strip ?? "brick";
+  const b = new MeshBuilder2;
+  corners.forEach(([x0, y0], i) => {
+    const [x1, y1] = corners[(i + 1) % 4] ?? [x0, y0];
+    emitFace(b, {
+      points: [
+        [x0, y0, z0],
+        [x1, y1, z0],
+        [x1, y1, top],
+        [x0, y0, top]
+      ],
+      normal: [y1 - y0, -(x1 - x0), 0],
+      up: [0, 0, 1],
+      vOrigin: [0, 0, z0],
+      color: c.color,
+      strip,
+      banded: lod < 2
+    });
+  });
+  emitFace(b, {
+    points: corners.map(([x, y]) => [x, y, top]),
+    normal: [0, 0, 1],
+    up: [0, 1, 0],
+    vOrigin: [cx, cy, top],
+    color: c.color,
+    strip: "plain",
+    banded: false
+  });
+  const parts = [b.build()];
+  if (lod < 2) {
+    const k = 0.06;
+    const cap = [c.color[0] * 0.85, c.color[1] * 0.85, c.color[2] * 0.85];
+    parts.push(box2({ size: [w + 2 * k, d + 2 * k, 0.1], at: [cx, cy, top - 0.22], color: cap }));
+    parts.push(box2({ size: [w + k, d + k, 0.07], at: [cx, cy, top - 0.07], color: cap }));
+  }
+  if (lod === 0) {
+    const n = c.pots ?? Math.max(1, Math.round(w / 0.4));
+    const pot = c.potColor ?? [0.62, 0.32, 0.2];
+    for (let i = 0;i < n; i++) {
+      const x = cx - w / 2 + w * (i + 0.5) / n;
+      parts.push(lathe2({
+        profile: [
+          [0.13, 0],
+          [0.1, 0.36],
+          [0.125, 0.4],
+          [0.125, 0.46]
+        ],
+        segments: 8,
+        caps: true,
+        at: [x, cy, top - 0.02],
+        color: pot
+      }));
+    }
+  }
+  return merge2(parts);
+}
+
+// src/kinds/roof-shape.ts
+var RAD5 = Math.PI / 180;
+var FRAMES = {
+  front: [
+    [0, 1],
+    [-1, 0]
+  ],
+  back: [
+    [0, -1],
+    [1, 0]
+  ],
+  left: [
+    [-1, 0],
+    [0, -1]
+  ],
+  right: [
+    [1, 0],
+    [0, 1]
+  ]
+};
+var bad3 = (cause, fix) => new Ts23dError2("T3D_RECIPE_INVALID", { cause, fix });
+function validateRoof(o) {
+  const [w, d] = o.footprint;
+  if (!(w > 0 && d > 0 && Number.isFinite(w) && Number.isFinite(d)))
+    throw bad3(`roof footprint is [${w}, ${d}]`, "pass the wall-line [width X, depth Y] in metres, both > 0");
+  const maxPitch = o.type === "mansard" || o.type === "gambrel" ? 85 : 75;
+  if (!(o.pitchDeg >= 3 && o.pitchDeg <= maxPitch))
+    throw bad3(`${o.type} roof pitchDeg is ${o.pitchDeg}`, `use 3–${maxPitch}° (slate ≥ 20°, tile 30–45°, sheet metal ≥ 3°); for a flat roof use a box`);
+  const t = o.thickness ?? 0.18;
+  if (!(t > 0 && t < 1))
+    throw bad3(`roof thickness is ${t}`, "use 0.1–0.3 m (rafter + battens + slate)");
+  const ov = o.overhang ?? 0.35;
+  if (!(ov >= 0 && ov < 3) || !((o.rake ?? ov) >= 0))
+    throw bad3(`roof overhang is ${ov}`, "use 0–1.5 m past the wall line (0 for a party wall)");
+  if (o.type === "mansard" || o.type === "gambrel") {
+    const up = o.upperPitchDeg ?? (o.type === "mansard" ? 20 : 30);
+    if (!(up > 0 && up < o.pitchDeg))
+      throw bad3(`${o.type} upperPitchDeg ${up} is not below pitchDeg ${o.pitchDeg}`, "the upper slope must be shallower than the lower one (mansard 70°/20°, gambrel 60°/30°)");
+    const k = o.knee ?? 0.3;
+    if (!(k > 0 && k < 1))
+      throw bad3(`${o.type} knee is ${k}`, "use a fraction 0.15–0.6 of the half-span");
+  }
+}
+function underPlanes(o, L, D) {
+  const tp = Math.tan(o.pitchDeg * RAD5);
+  const side = (s, c = 0, k = s) => [
+    { c: c + D * k, ga: 0, gb: -s },
+    { c: c + D * k, ga: 0, gb: s }
+  ];
+  const ends = (s, c = 0, k = s) => [
+    { c: c + L * k, ga: -s, gb: 0 },
+    { c: c + L * k, ga: s, gb: 0 }
+  ];
+  switch (o.type) {
+    case "gable":
+      return side(tp);
+    case "shed":
+      return [{ c: D * tp, ga: 0, gb: tp }];
+    case "hip":
+      return [...side(tp), ...ends(tp)];
+    case "pyramid": {
+      const h = Math.min(L, D) * tp;
+      return [...side(h / D), ...ends(h / L)];
+    }
+    case "gambrel":
+    case "mansard": {
+      const t2 = Math.tan((o.upperPitchDeg ?? (o.type === "mansard" ? 20 : 30)) * RAD5);
+      const r = (o.knee ?? (o.type === "mansard" ? 0.3 : 0.45)) * Math.min(L, D);
+      const upper = (half) => r * tp + (half - r) * t2 - half * t2;
+      const lower = [...side(tp), ...o.type === "mansard" ? ends(tp) : []];
+      const top = [
+        ...side(t2, upper(D), t2),
+        ...o.type === "mansard" ? ends(t2, upper(L), t2) : []
+      ];
+      return [...lower, ...top];
+    }
+  }
+}
+function roofShape(o) {
+  validateRoof(o);
+  const [w, d] = o.footprint;
+  const ridge = o.ridge ?? (w >= d ? "x" : "y");
+  const low = o.type === "shed" ? o.low ?? "front" : ridge === "x" ? "right" : "front";
+  const [ex, ey] = FRAMES[low];
+  const L = (Math.abs(ex[0]) > 0.5 ? w : d) / 2;
+  const D = (Math.abs(ex[0]) > 0.5 ? d : w) / 2;
+  const ov = o.overhang ?? 0.35;
+  const t = o.thickness ?? 0.18;
+  const under = underPlanes(o, L, D);
+  const top = under.map((p) => ({ ...p, c: p.c + t * Math.hypot(1, p.ga, p.gb) }));
+  const hipped = o.type === "hip" || o.type === "pyramid" || o.type === "mansard";
+  const A = hipped ? 4 * (L + D + ov) : L + (o.rake ?? ov);
+  const B = D + ov;
+  const g0 = under[0] ?? { c: 0, ga: 0, gb: 1 };
+  const zEave = -ov * Math.hypot(g0.ga, g0.gb);
+  let outline = [
+    [-A, -B],
+    [A, -B],
+    [A, B],
+    [-A, B]
+  ];
+  for (const p of under)
+    outline = clipPoly(outline, (q) => zEave - zAt(p, q));
+  return { L, D, under, top, outline, ex, ey, thickness: t };
+}
+var zAt = (p, q) => p.c + p.ga * q[0] + p.gb * q[1];
+var envelope = (planes, q) => Math.min(...planes.map((p) => zAt(p, q)));
+function facets(planes, outline) {
+  const out = [];
+  planes.forEach((p, i) => {
+    let cell = [...outline];
+    planes.forEach((q, j) => {
+      if (j !== i && cell.length >= 3)
+        cell = clipPoly(cell, (r) => zAt(p, r) - zAt(q, r));
+    });
+    if (cell.length >= 3 && Math.abs(area2(cell)) > 0.000001)
+      out.push([p, cell]);
+  });
+  return out;
+}
+var toWorld = (s, q, z, at) => [
+  at[0] + s.ex[0] * q[0] + s.ey[0] * q[1],
+  at[1] + s.ex[1] * q[0] + s.ey[1] * q[1],
+  at[2] + z
+];
+var toLocal = (s, x, y, at) => {
+  const dx = x - at[0];
+  const dy = y - at[1];
+  return [dx * s.ex[0] + dy * s.ex[1], dx * s.ey[0] + dy * s.ey[1]];
+};
+function roofHeightAt2(o, x, y) {
+  const s = roofShape(o);
+  return o.at[2] + envelope(s.top, toLocal(s, x, y, o.at));
+}
+function ridgeHeight2(o) {
+  const s = roofShape(o);
+  let z = -Infinity;
+  for (const [p, cell] of facets(s.top, s.outline))
+    for (const q of cell)
+      z = Math.max(z, zAt(p, q));
+  return o.at[2] + z;
+}
+
+// src/kinds/roof.ts
+var W = (s, q, z, at) => toWorld(s, q, z, at);
+var dirW = (s, a, b, z) => [
+  s.ex[0] * a + s.ey[0] * b,
+  s.ex[1] * a + s.ey[1] * b,
+  z
+];
+var onOutline = (outline, q) => outline.some((a, i) => {
+  const b = outline[(i + 1) % outline.length] ?? a;
+  const ex = b[0] - a[0];
+  const ey = b[1] - a[1];
+  const l2 = ex * ex + ey * ey || 1;
+  const t = Math.max(0, Math.min(1, ((q[0] - a[0]) * ex + (q[1] - a[1]) * ey) / l2));
+  return Math.hypot(a[0] + ex * t - q[0], a[1] + ey * t - q[1]) < 0.000001;
+});
+function slopes(b, s, planes, o, face) {
+  const cells = facets(planes, s.outline);
+  for (const [p, cell] of cells) {
+    const pts = cell.map((q) => W(s, q, zAt(p, q), o.at));
+    const low = pts.reduce((m, q) => q[2] < m[2] ? q : m, pts[0] ?? o.at);
+    const k = face.down ? -1 : 1;
+    emitFace(b, {
+      points: pts,
+      normal: dirW(s, -p.ga * k, -p.gb * k, k),
+      up: [0, 0, 1],
+      vOrigin: low,
+      color: face.color,
+      strip: face.strip,
+      banded: face.banded
+    });
+  }
+  return cells;
+}
+function fascia(b, s, o, trim, verts) {
+  const n = s.outline.length;
+  for (let i = 0;i < n; i++) {
+    const a = s.outline[i] ?? [0, 0];
+    const c = s.outline[(i + 1) % n] ?? a;
+    const ex = c[0] - a[0];
+    const ey = c[1] - a[1];
+    const len2 = ex * ex + ey * ey;
+    if (len2 < 0.000000000001)
+      continue;
+    const ts = [0, 1];
+    for (const q of verts) {
+      const t = ((q[0] - a[0]) * ex + (q[1] - a[1]) * ey) / len2;
+      const off = Math.abs((q[0] - a[0]) * ey - (q[1] - a[1]) * ex) / Math.sqrt(len2);
+      if (t > 0.000001 && t < 1 - 0.000001 && off < 0.000001)
+        ts.push(t);
+    }
+    ts.sort((x, y) => x - y);
+    const out = dirW(s, ey, -ex, 0);
+    for (let k = 0;k + 1 < ts.length; k++) {
+      const q0 = [a[0] + ex * (ts[k] ?? 0), a[1] + ey * (ts[k] ?? 0)];
+      const q1 = [a[0] + ex * (ts[k + 1] ?? 1), a[1] + ey * (ts[k + 1] ?? 1)];
+      if (Math.hypot(q1[0] - q0[0], q1[1] - q0[1]) < 0.000001)
+        continue;
+      emitFace(b, {
+        points: [
+          W(s, q0, envelope(s.under, q0), o.at),
+          W(s, q1, envelope(s.under, q1), o.at),
+          W(s, q1, envelope(s.top, q1), o.at),
+          W(s, q0, envelope(s.top, q0), o.at)
+        ],
+        normal: out,
+        up: [0, 0, 1],
+        vOrigin: o.at,
+        color: trim,
+        strip: "plain"
+      });
+    }
+  }
+}
+function gableWalls(b, s, o, banded) {
+  const wall = o.wall ?? { color: [0.8, 0.76, 0.68] };
+  const lines = [
+    [[s.L, -s.D], [s.L, s.D], dirW(s, 1, 0, 0)],
+    [[-s.L, s.D], [-s.L, -s.D], dirW(s, -1, 0, 0)],
+    [[s.L, s.D], [-s.L, s.D], dirW(s, 0, 1, 0)],
+    [[-s.L, -s.D], [s.L, -s.D], dirW(s, 0, -1, 0)]
+  ];
+  for (const [q0, q1, out] of lines) {
+    const at = (t) => [q0[0] + (q1[0] - q0[0]) * t, q0[1] + (q1[1] - q0[1]) * t];
+    const ts = new Set([0, 1]);
+    s.under.forEach((p, i) => {
+      s.under.forEach((q, j) => {
+        if (j <= i)
+          return;
+        const d0 = zAt(p, q0) - zAt(q, q0);
+        const d1 = zAt(p, q1) - zAt(q, q1);
+        if (Math.abs(d0 - d1) < 0.000000000001)
+          return;
+        const t = d0 / (d0 - d1);
+        if (t > 0.000001 && t < 1 - 0.000001 && Math.abs(envelope(s.under, at(t)) - zAt(p, at(t))) < 0.0000001)
+          ts.add(t);
+      });
+    });
+    const prof = [...ts].sort((x, y) => x - y).map((t) => [at(t), envelope(s.under, at(t))]);
+    if (Math.max(...prof.map(([, z]) => z)) < 0.01)
+      continue;
+    const pts = [W(s, q0, 0, o.at)];
+    for (const [q, z] of prof)
+      pts.push(W(s, q, Math.max(0, z), o.at));
+    pts.push(W(s, q1, 0, o.at));
+    emitFace(b, {
+      points: pts,
+      normal: out,
+      up: [0, 0, 1],
+      vOrigin: o.at,
+      color: wall.color,
+      strip: wall.strip ?? "plain",
+      banded
+    });
+  }
+}
+function caps(s, o, cells, trim, lod) {
+  const seen = new Set;
+  const out = [];
+  const r = Math.max(0.06, s.thickness * 0.5);
+  for (const [p, cell] of cells) {
+    cell.forEach((q0, i) => {
+      const q1 = cell[(i + 1) % cell.length] ?? q0;
+      const mid = [(q0[0] + q1[0]) / 2, (q0[1] + q1[1]) / 2];
+      if (onOutline(s.outline, mid) || Math.hypot(q1[0] - q0[0], q1[1] - q0[1]) < 0.001)
+        return;
+      const key = [q0, q1].map((q) => `${q[0].toFixed(4)},${q[1].toFixed(4)}`).sort().join("|");
+      if (seen.has(key))
+        return;
+      seen.add(key);
+      const lift = r * 0.3;
+      out.push(beam2({
+        from: W(s, q0, zAt(p, q0) + lift, o.at),
+        to: W(s, q1, zAt(p, q1) + lift, o.at),
+        width: r * 2,
+        segments: lod === 0 ? 8 : 5,
+        color: trim,
+        strip: "plain"
+      }));
+    });
+  }
+  return out;
+}
+function roofMesh2(o, lod = 0) {
+  const s = roofShape(o);
+  const trim = o.trim ?? [o.color[0] * 0.55, o.color[1] * 0.55, o.color[2] * 0.55];
+  const strip = o.strip ?? "slate";
+  const b = new MeshBuilder2;
+  const extra = [];
+  if (lod === 2) {
+    slopes(b, s, s.under, o, { down: false, color: o.color, strip, banded: false });
+  } else {
+    const top = slopes(b, s, s.top, o, { down: false, color: o.color, strip, banded: true });
+    const under = slopes(b, s, s.under, o, {
+      down: true,
+      color: trim,
+      strip: "wood",
+      banded: lod === 0
+    });
+    const verts = [...top, ...under].flatMap(([, cell]) => cell);
+    fascia(b, s, o, trim, verts);
+    if (o.caps !== false)
+      extra.push(...caps(s, o, top, trim, lod));
+  }
+  gableWalls(b, s, o, lod < 2);
+  for (const c of o.chimneys ?? []) {
+    extra.push(chimney(c, (x, y) => roofHeightAt2(o, x, y), o.at, lod));
+  }
+  return merge2([b.build(), ...extra]);
+}
+function roof2(ctx, o) {
+  ctx.part(o.name ?? "roof", roofMesh2(o, ctx.lod));
+  return roofInfo2(o);
+}
+function roofInfo2(o) {
+  const s = roofShape(o);
+  const eave = Math.min(...s.outline.map((q) => envelope(s.under, q)));
+  return {
+    ridge: ridgeHeight2(o),
+    eave: o.at[2] + eave,
+    heightAt: (x, y) => roofHeightAt2(o, x, y)
+  };
+}
+// src/kinds/vegetation-fronds.ts
+function tri(mb, a, b, c, col, tipCol) {
+  const e1 = [b[0] - a[0], b[1] - a[1], b[2] - a[2]];
+  const e2 = [c[0] - a[0], c[1] - a[1], c[2] - a[2]];
+  const n = [
+    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 l = Math.hypot(n[0], n[1], n[2]) || 1;
+  for (const s of [1, -1]) {
+    const nn = [n[0] / l * s, n[1] / l * s, n[2] / l * s];
+    const i = mb.vertex({ p: a, n: nn, uv: [0, 0], color: col });
+    const j = mb.vertex({ p: b, n: nn, uv: [0, 0], color: col });
+    const k = mb.vertex({ p: c, n: nn, uv: [0, 0], color: tipCol });
+    if (s > 0)
+      mb.tri(i, j, k);
+    else
+      mb.tri(i, k, j);
+  }
+}
+function frondLeaflets(stems, level, leaf, perSide, shade, rng) {
+  const mb = new MeshBuilder2;
+  for (const st of stems) {
+    if (st.level !== level)
+      continue;
+    const arc = arcLengths2(st.pts);
+    const frames = transportFrames2(st.pts);
+    const k = 1 + rng.range(-leaf.colorVar, leaf.colorVar);
+    const step = st.length * 0.9 / perSide;
+    for (let i = 0;i < perSide; i++) {
+      const u = 0.1 + 0.9 * (i + 0.5) / perSide;
+      const s = u * st.length;
+      let j = 0;
+      while (j < arc.length - 2 && (arc[j + 1] ?? 0) < s)
+        j++;
+      const a = st.pts[j] ?? [0, 0, 0];
+      const b = st.pts[j + 1] ?? a;
+      const f = (s - (arc[j] ?? 0)) / ((arc[j + 1] ?? 1) - (arc[j] ?? 0) || 1);
+      const fr = frames[j] ?? { t: [1, 0, 0], n: [0, 0, 1], b: [0, 1, 0] };
+      const r = (st.radii[j] ?? 0) * (1 - f) + (st.radii[j + 1] ?? 0) * f;
+      const c = [
+        a[0] + (b[0] - a[0]) * f,
+        a[1] + (b[1] - a[1]) * f,
+        a[2] + (b[2] - a[2]) * f
+      ];
+      const len = st.length * leaf.width * Math.sin(Math.PI * (0.12 + 0.88 * u)) ** 0.6;
+      const ao = 0.6 + 0.4 * Math.min(1, Math.hypot(c[0] - shade.centre[0], c[1] - shade.centre[1]) / shade.radius);
+      const col = [
+        leaf.color[0] * k * ao * 0.75,
+        leaf.color[1] * k * ao * 0.75,
+        leaf.color[2] * k * ao * 0.75
+      ];
+      const tipCol = [col[0] * 1.45, col[1] * 1.35, col[2] * 1.2];
+      for (const side of [1, -1]) {
+        const o = [fr.b[0] * side, fr.b[1] * side, fr.b[2] * side];
+        const root = (d) => [
+          c[0] + o[0] * r + fr.t[0] * d,
+          c[1] + o[1] * r + fr.t[1] * d,
+          c[2] + o[2] * r + fr.t[2] * d
+        ];
+        const tip = [
+          c[0] + (o[0] * 0.8 + fr.t[0] * 0.45 - fr.n[0] * 0.35) * len,
+          c[1] + (o[1] * 0.8 + fr.t[1] * 0.45 - fr.n[1] * 0.35) * len,
+          c[2] + (o[2] * 0.8 + fr.t[2] * 0.45 - fr.n[2] * 0.35) * len - 0.2 * len
+        ];
+        tri(mb, root(-step * 0.35), root(step * 0.35), tip, col, tipCol);
+      }
+    }
+  }
+  return mb.build();
+}
+function fruit(trunk, at, o, rng) {
+  const j = Math.max(0, Math.min(trunk.pts.length - 1, Math.round(at * (trunk.pts.length - 1))));
+  const c = trunk.pts[j] ?? [0, 0, 0];
+  const rt = trunk.radii[j] ?? 0.2;
+  const profile = [0, 1, 2, 3, 4].map((i) => {
+    const a = -Math.PI / 2 + i / 4 * Math.PI;
+    return [Math.max(0.0001, Math.cos(a)) * o.radius, Math.sin(a) * o.radius];
+  });
+  const out = [];
+  for (let i = 0;i < o.count; i++) {
+    const a = i / o.count * Math.PI * 2 + rng.range(-0.3, 0.3);
+    const d = rt + o.radius * 0.6;
+    const dz = rng.range(-1, 0.5) * o.radius;
+    out.push(lathe2({
+      profile,
+      segments: 6,
+      caps: false,
+      at: [c[0] + Math.cos(a) * d, c[1] + Math.sin(a) * d, c[2] + dz],
+      color: o.color
+    }));
+  }
+  return merge2(out);
+}
+
+// src/kinds/vegetation-impostor.ts
+function coarseTrunk(trunk, p, apex) {
+  const n = trunk.pts.length - 1;
+  const idx = [...new Set([0, Math.round(n / 3), Math.round(2 * n / 3), n])];
+  const pts = idx.map((i) => trunk.pts[i] ?? [0, 0, 0]);
+  const radii = idx.map((i) => trunk.radii[i] ?? 0.1);
+  const last = pts.length - 1;
+  const tip = pts[last] ?? [0, 0, 1];
+  if (apex !== null && apex > tip[2] + 0.000001) {
+    pts.push([tip[0], tip[1], apex]);
+    radii.push(0);
+  } else
+    radii[last] = 0;
+  return sweep2({
+    section: { radius: 1, segments: 5 },
+    path: pts,
+    scale: radii,
+    color: p.bark,
+    strip: "wood",
+    caps: apex === null ? "end" : false
+  });
+}
+function blob(stems, p, rng) {
+  const trunk = stems[0];
+  if (!trunk)
+    return { trunk: new MeshBuilder2().build(), leaves: new MeshBuilder2().build() };
+  const tip = trunk.pts[trunk.pts.length - 1] ?? [0, 0, 1];
+  const margin = p.leaves.size * 0.6;
+  let z0 = Infinity;
+  let z1 = tip[2];
+  for (const s of stems)
+    for (const q of s.level > 0 ? s.pts : []) {
+      z0 = Math.min(z0, q[2] - margin * (1 + (p.leaves.hang ?? 0) * 2));
+      z1 = Math.max(z1, q[2] + margin);
+    }
+  if (!Number.isFinite(z0))
+    z0 = tip[2] * 0.5;
+  const BINS = 6;
+  const r = new Array(BINS).fill(0.2);
+  for (const s of stems)
+    for (const q of s.level > 0 ? s.pts : []) {
+      const b = Math.min(BINS - 1, Math.max(0, Math.floor((q[2] - z0) / (z1 - z0) * BINS)));
+      r[b] = Math.max(r[b] ?? 0, Math.hypot(q[0] - tip[0], q[1] - tip[1]) + margin);
+    }
+  const profile = [[0, z0]];
+  for (let b = 0;b < BINS; b++)
+    profile.push([r[b] ?? 0.2, z0 + (b + 0.5) / BINS * (z1 - z0)]);
+  profile.push([0, z1]);
+  const leaves = lathe2({ profile, segments: 10, color: p.leaves.color, at: [tip[0], tip[1], 0] });
+  const [cr, cg, cb] = p.leaves.color;
+  for (let i = 0;i < leaves.colors.length / 3; i++) {
+    const t = ((leaves.positions[i * 3 + 2] ?? 0) - z0) / (z1 - z0);
+    const k = (0.55 + 0.5 * t) * (1 + rng.range(-0.08, 0.08));
+    leaves.colors.set([cr * k, cg * k, cb * k], i * 3);
+  }
+  return { trunk: coarseTrunk(trunk, p, z1), leaves };
+}
+function frondCards(stems, p, level) {
+  const trunk = stems[0];
+  const mb = new MeshBuilder2;
+  if (!trunk)
+    return { trunk: mb.build(), leaves: mb.build() };
+  const top = trunk.pts[trunk.pts.length - 1] ?? [0, 0, 1];
+  const fronds = stems.filter((s) => s.level === level);
+  const every = Math.max(1, Math.ceil(fronds.length / 12));
+  const [cr, cg, cb] = p.leaves.color;
+  for (const [fi, st] of fronds.entries()) {
+    if (fi % every !== 0)
+      continue;
+    const n = st.pts.length - 1;
+    const pts = [top, st.pts[Math.round(n / 2)] ?? top, st.pts[n] ?? top];
+    const fr = transportFrames2(pts);
+    const w = [0.25, 1, 0.35].map((k) => k * st.length * p.leaves.width);
+    for (const side of [1, -1]) {
+      const edge = pts.map((c, j) => {
+        const f = fr[j];
+        const ww = (w[j] ?? 0) * side;
+        if (!f)
+          return c;
+        return [
+          c[0] + (f.b[0] * 0.85 - f.n[0] * 0.45 * side) * ww,
+          c[1] + (f.b[1] * 0.85 - f.n[1] * 0.45 * side) * ww,
+          c[2] + (f.b[2] * 0.85 - f.n[2] * 0.45 * side) * ww
+        ];
+      });
+      for (let j = 0;j < 2; j++) {
+        const q = [pts[j], pts[j + 1], edge[j + 1], edge[j]];
+        const [a, b, c] = [q[0] ?? top, q[1] ?? top, q[2] ?? top];
+        const e1 = [b[0] - a[0], b[1] - a[1], b[2] - a[2]];
+        const e2 = [c[0] - a[0], c[1] - a[1], c[2] - a[2]];
+        const nx = (e1[1] ?? 0) * (e2[2] ?? 0) - (e1[2] ?? 0) * (e2[1] ?? 0);
+        const ny = (e1[2] ?? 0) * (e2[0] ?? 0) - (e1[0] ?? 0) * (e2[2] ?? 0);
+        const nz = (e1[0] ?? 0) * (e2[1] ?? 0) - (e1[1] ?? 0) * (e2[0] ?? 0);
+        const l = Math.hypot(nx, ny, nz) || 1;
+        for (const s of [1, -1]) {
+          const nn = [nx / l * s, ny / l * s, nz / l * s];
+          const ids = q.map((v, k) => {
+            const sh = k < 2 ? 0.7 : 1;
+            return mb.vertex({ p: v, n: nn, uv: [0, 0], color: [cr * sh, cg * sh, cb * sh] });
+          });
+          const [i0 = 0, i1 = 0, i2 = 0, i3 = 0] = s > 0 ? ids : [...ids].reverse();
+          mb.quad(i0, i1, i2, i3);
+        }
+      }
+    }
+  }
+  return { trunk: coarseTrunk(trunk, p, null), leaves: mb.build() };
+}
+
+// src/kinds/vegetation-params.ts
+var OUTLINES = {
+  oval: [
+    [0, 0],
+    [0.25, -0.4],
+    [0.65, -0.5],
+    [1, 0],
+    [0.65, 0.5],
+    [0.25, 0.4]
+  ],
+  lobed: [
+    [0, 0],
+    [0.3, -0.45],
+    [0.5, -0.3],
+    [0.75, -0.5],
+    [1, 0],
+    [0.75, 0.5],
+    [0.5, 0.3],
+    [0.3, 0.45]
+  ],
+  tuft: [
+    [0, 0],
+    [0.35, -0.5],
+    [0.45, -0.15],
+    [0.75, -0.4],
+    [1, 0],
+    [0.75, 0.4],
+    [0.45, 0.15],
+    [0.35, 0.5]
+  ],
+  strand: [
+    [0, 0],
+    [0.1, -0.5],
+    [1, 0],
+    [0.1, 0.5]
+  ]
+};
+function shapeRatio(shape, r) {
+  const x = Math.min(1, Math.max(0, r));
+  switch (shape) {
+    case "conical":
+      return 0.2 + 0.8 * x;
+    case "spherical":
+      return 0.2 + 0.8 * Math.sin(Math.PI * x);
+    case "hemispherical":
+      return 0.2 + 0.8 * Math.sin(Math.PI / 2 * x);
+    case "cylindrical":
+      return 1;
+    case "tapered":
+      return 0.5 + 0.5 * x;
+    case "flame":
+      return x <= 0.7 ? 0.15 + 0.85 * x / 0.7 : 0.15 + 0.85 * (1 - x) / 0.3;
+  }
+}
+
+// src/kinds/vegetation-leaves.ts
+var unit2 = (a) => {
+  const l = Math.hypot(a[0], a[1], a[2]) || 1;
+  return [a[0] / l, a[1] / l, a[2] / l];
+};
+function crownShade(stems, level) {
+  let r = 0.1;
+  let z0 = Infinity;
+  let z1 = -Infinity;
+  const t = stems[0]?.pts;
+  const c = t?.[t.length - 1] ?? [0, 0, 0];
+  for (const s of stems) {
+    if (s.level < level)
+      continue;
+    for (const p of s.pts) {
+      r = Math.max(r, Math.hypot(p[0] - c[0], p[1] - c[1]));
+      z0 = Math.min(z0, p[2]);
+      z1 = Math.max(z1, p[2]);
+    }
+  }
+  return { centre: c, radius: r, zMin: z0, zMax: Math.max(z1, z0 + 0.1) };
+}
+function card(leaf, base, dir, side, len, shade, rng) {
+  const outline = OUTLINES[leaf.shape === "frond" ? "oval" : leaf.shape];
+  const w = len * leaf.width;
+  const points = outline.map(([u, v]) => [
+    base[0] + dir[0] * u * len + side[0] * v * w,
+    base[1] + dir[1] * u * len + side[1] * v * w,
+    base[2] + dir[2] * u * len + side[2] * v * w
+  ]);
+  const m = planar2({ points, color: leaf.color, doubleSided: true });
+  const k = 1 + rng.range(-leaf.colorVar, leaf.colorVar);
+  const hue = rng.range(-leaf.colorVar, leaf.colorVar) * 0.6;
+  const radial = Math.hypot(base[0] - shade.centre[0], base[1] - shade.centre[1]) / shade.radius;
+  const up = (base[2] - shade.zMin) / (shade.zMax - shade.zMin);
+  const ao = 0.5 + 0.35 * Math.min(1, radial) ** 0.8 + 0.2 * Math.max(0, Math.min(1, up));
+  const [r, g, b] = leaf.color;
+  for (let i = 0;i < m.colors.length / 3; i++) {
+    const u = outline[i % outline.length]?.[0] ?? 0;
+    const s = ao * k * (0.7 + 0.4 * u);
+    m.colors[i * 3] = r * s * (1 + hue);
+    m.colors[i * 3 + 1] = g * s;
+    m.colors[i * 3 + 2] = b * s * (1 - hue);
+  }
+  return m;
+}
+function aim(radial, along, leaf, rng) {
+  const hang = leaf.hang ?? 0;
+  const flat = leaf.flat ?? 0;
+  const lift = rng.range(-0.3, 0.5);
+  const out = unit2([
+    radial[0] * 0.9 + along[0] * 0.7,
+    radial[1] * 0.9 + along[1] * 0.7,
+    radial[2] * 0.9 + along[2] * 0.7 + lift
+  ]);
+  const d0 = unit2([out[0] * (1 - hang), out[1] * (1 - hang), out[2] * (1 - hang) - hang]);
+  const dir = unit2([d0[0], d0[1], d0[2] * (1 - flat)]);
+  const level = unit2([-dir[1], dir[0], 0]);
+  const s1 = unit2([
+    dir[1] * radial[2] - dir[2] * radial[1],
+    dir[2] * radial[0] - dir[0] * radial[2],
+    dir[0] * radial[1] - dir[1] * radial[0]
+  ]);
+  const s0 = Math.hypot(...s1) < 0.5 ? level : s1;
+  const side = unit2([
+    s0[0] + (level[0] - s0[0]) * flat,
+    s0[1] + (level[1] - s0[1]) * flat,
+    s0[2] + (level[2] - s0[2]) * flat
+  ]);
+  const roll = rng.range(-0.7, 0.7) * (1 - flat);
+  const t = [
+    dir[1] * side[2] - dir[2] * side[1],
+    dir[2] * side[0] - dir[0] * side[2],
+    dir[0] * side[1] - dir[1] * side[0]
+  ];
+  const c = Math.cos(roll);
+  const s = Math.sin(roll);
+  return { dir, side: [side[0] * c + t[0] * s, side[1] * c + t[1] * s, side[2] * c + t[2] * s] };
+}
+function leafCards(stems, level, ringSegments, leaf, shade, rng) {
+  const out = [];
+  for (const st of stems) {
+    if (st.level !== level)
+      continue;
+    const frames = transportFrames2(st.pts);
+    const res = st.pts.length - 1;
+    for (let i = 0;i < leaf.perStem; i++) {
+      const from = leaf.from ?? 0.3;
+      const t = from + (1 - from) * (i + 1) / leaf.perStem;
+      const j = Math.max(1, Math.min(res, Math.round(t * res)));
+      const f = frames[j];
+      const c = st.pts[j];
+      if (!f || !c)
+        continue;
+      const a = rng.int(0, ringSegments - 1) / ringSegments * Math.PI * 2;
+      const radial = [
+        Math.cos(a) * f.n[0] + Math.sin(a) * f.b[0],
+        Math.cos(a) * f.n[1] + Math.sin(a) * f.b[1],
+        Math.cos(a) * f.n[2] + Math.sin(a) * f.b[2]
+      ];
+      const r = st.radii[j] ?? 0;
+      const base = [c[0] + radial[0] * r, c[1] + radial[1] * r, c[2] + radial[2] * r];
+      const { dir, side } = aim(radial, f.t, leaf, rng);
+      out.push(card(leaf, base, dir, side, leaf.size * rng.range(0.8, 1.2), shade, rng));
+    }
+  }
+  return merge2(out);
+}
+function clusterCards(stems, level, leaf, shade, rng) {
+  const out = [];
+  for (const st of stems) {
+    if (st.level !== level)
+      continue;
+    const tip = st.pts[st.pts.length - 1] ?? st.surface;
+    const p0 = st.pts[0] ?? st.surface;
+    const along = unit2([tip[0] - p0[0], tip[1] - p0[1], tip[2] - p0[2]]);
+    const radial = unit2([st.surface[0] - p0[0], st.surface[1] - p0[1], st.surface[2] - p0[2]]);
+    const { dir, side } = aim(radial, along, leaf, rng);
+    const len = st.length * 1.1 + leaf.size;
+    out.push(card(leaf, st.surface, dir, side, len, shade, rng));
+  }
+  return merge2(out);
+}
+
+// src/kinds/vegetation-mesh.ts
+var RADIAL = [
+  [8, 6, 5],
+  [6, 4, 4],
+  [4, 3, 3],
+  [3, 3, 3]
+];
+var radialSegments = (level, lod) => RADIAL[Math.min(3, level)]?.[lod] ?? 3;
+function coarsen(st, step) {
+  const pts = [];
+  const radii = [];
+  const last = st.pts.length - 1;
+  for (let i = 0;i <= last; i += step) {
+    pts.push(st.pts[i] ?? [0, 0, 0]);
+    radii.push(st.radii[i] ?? 0);
+  }
+  if (last % step !== 0) {
+    pts.push(st.pts[last] ?? [0, 0, 0]);
+    radii.push(st.radii[last] ?? 0);
+  }
+  return { pts, radii };
+}
+function stemsMesh(stems, lo, hi, lod, color) {
+  const out = [];
+  for (const st of stems) {
+    if (st.level < lo || st.level > hi)
+      continue;
+    const { pts, radii } = coarsen(st, lod === 0 ? 1 : 2);
+    out.push(sweep2({
+      section: { radius: 1, segments: radialSegments(st.level, lod) },
+      path: pts,
+      scale: radii,
+      color,
+      strip: "wood"
+    }));
+  }
+  return merge2(out);
+}
+var mix = (a, b, t) => [
+  a[0] + (b[0] - a[0]) * t,
+  a[1] + (b[1] - a[1]) * t,
+  a[2] + (b[2] - a[2]) * t
+];
+function barkTint(m, p, top, rng) {
+  const hi = p.barkTop ?? p.bark;
+  for (let i = 0;i < m.colors.length / 3; i++) {
+    const z = m.positions[i * 3 + 2] ?? 0;
+    const t = Math.min(1, Math.max(0, (z / Math.max(0.1, top) - 0.3) / 0.4));
+    let c = mix(p.bark, hi, t * t * (3 - 2 * t));
+    if (p.barkMarks && rng.next() < p.barkMarks.amount)
+      c = mix(c, p.barkMarks.color, 0.85);
+    const k = 1 + rng.range(-0.06, 0.06);
+    m.colors.set([c[0] * k, c[1] * k, c[2] * k], i * 3);
+  }
+  return m;
+}
+function trunkMesh(trunk, p, lod, radiusScale, rng) {
+  const { pts, radii } = coarsen(trunk, lod === 0 ? 1 : 2);
+  const m = sweep2({
+    section: { radius: 1, segments: radialSegments(0, lod) },
+    path: pts,
+    scale: radii.map((r) => r * radiusScale),
+    color: p.bark,
+    strip: "wood",
+    caps: p.impostor === "cards" ? "end" : false
+  });
+  return barkTint(m, p, pts[pts.length - 1]?.[2] ?? 1, rng);
+}
+function axisAt(trunk, z) {
+  for (let i = 1;i < trunk.pts.length; i++) {
+    const a = trunk.pts[i - 1] ?? [0, 0, 0];
+    const b = trunk.pts[i] ?? a;
+    if (b[2] >= z || i === trunk.pts.length - 1) {
+      const f = Math.min(1, Math.max(0, (z - a[2]) / (b[2] - a[2] || 1)));
+      return [a[0] + (b[0] - a[0]) * f, a[1] + (b[1] - a[1]) * f, z];
+    }
+  }
+  return [0, 0, z];
+}
+function rootsMesh(trunk, p, lod, radiusScale, rng) {
+  const r0 = (trunk.radii[0] ?? 0.2) * radiusScale;
+  const lobes = p.roots ?? 0;
+  const phase = rng.range(0, Math.PI * 2);
+  const levels = [
+    { z: -0.1, k: 1.7, amp: 0.7 },
+    { z: 0.5 * r0, k: 1.3, amp: 0.4 },
+    { z: 1.3 * r0, k: 1.04, amp: 0.15 },
+    { z: 2.4 * r0, k: 0.9, amp: 0 }
+  ];
+  const segs = lod === 0 ? 16 : 10;
+  const rings = levels.map(({ z, k, amp }) => {
+    const c = axisAt(trunk, z);
+    const lobe = (a) => 1 + amp * Math.max(0, Math.cos(lobes * (a - phase))) ** 2;
+    return ringXY2(c, r0 * k, r0 * k, segs, lobe);
+  });
+  const m = loft2({ rings, color: p.bark, strip: "wood" });
+  return barkTint(m, p, trunk.pts[trunk.pts.length - 1]?.[2] ?? 1, rng);
+}
+function fitFactors(meshes, target) {
+  const lo = [Infinity, Infinity, Infinity];
+  const hi = [-Infinity, -Infinity, -Infinity];
+  for (const m of meshes) {
+    if (m.indices.length === 0)
+      continue;
+    const b = boundsOf2(m);
+    for (let k = 0;k < 3; k++) {
+      lo[k] = Math.min(lo[k] ?? 0, b.min[k] ?? 0);
+      hi[k] = Math.max(hi[k] ?? 0, b.max[k] ?? 0);
+    }
+  }
+  const f = (k) => target[k] / Math.max(0.000001, (hi[k] ?? 1) - (lo[k] ?? 0));
+  return [f(0), f(1), f(2)];
+}
+function scaleMesh(m, s) {
+  const positions = new Float32Array(m.positions.length);
+  const normals = new Float32Array(m.normals.length);
+  for (let i = 0;i < positions.length; i += 3) {
+    positions[i] = (m.positions[i] ?? 0) * s[0];
+    positions[i + 1] = (m.positions[i + 1] ?? 0) * s[1];
+    positions[i + 2] = (m.positions[i + 2] ?? 0) * s[2];
+    const nx = (m.normals[i] ?? 0) / s[0];
+    const ny = (m.normals[i + 1] ?? 0) / s[1];
+    const nz = (m.normals[i + 2] ?? 0) / s[2];
+    const l = Math.hypot(nx, ny, nz) || 1;
+    normals[i] = nx / l;
+    normals[i + 1] = ny / l;
+    normals[i + 2] = nz / l;
+  }
+  return { ...m, positions, normals };
+}
+
+// src/kinds/vegetation-presets.ts
+var oak2 = {
+  shape: "hemispherical",
+  baseSize: 0.3,
+  ratioPower: 1.15,
+  taper: 0.3,
+  levels: [
+    { branches: 0, length: 0.55, downAngle: 0, curveVar: 5, segments: 8 },
+    {
+      branches: 8,
+      length: 0.95,
+      downAngle: 58,
+      downAngleV: -18,
+      curve: -8,
+      curveVar: 16,
+      segments: 7
+    },
+    { branches: 6, length: 0.55, downAngle: 50, curve: 12, curveVar: 18, start: 0.2, segments: 4 },
+    { branches: 5, length: 0.5, downAngle: 45, curveVar: 14, start: 0.15, segments: 2 }
+  ],
+  bark: hex2("#4a4036"),
+  barkTop: hex2("#5a5045"),
+  leaves: {
+    shape: "lobed",
+    size: 1.7,
+    width: 0.8,
+    perStem: 5,
+    color: hex2("#3d6022"),
+    colorVar: 0.16
+  },
+  roots: 5,
+  impostor: "blob",
+  typical: { height: 22, spread: 22, dbh: 1.3 }
+};
+var pine2 = {
+  shape: "cylindrical",
+  baseSize: 0.6,
+  ratioPower: 1.2,
+  taper: 0.12,
+  levels: [
+    { branches: 0, length: 0.94, downAngle: 0, curveVar: 3, segments: 10 },
+    {
+      branches: 13,
+      length: 0.34,
+      downAngle: 94,
+      downAngleV: -14,
+      curve: 16,
+      curveVar: 14,
+      segments: 5
+    },
+    { branches: 5, length: 0.42, downAngle: 60, curve: 18, curveVar: 14, start: 0.3, segments: 3 }
+  ],
+  bark: hex2("#4a3a30"),
+  barkTop: hex2("#c0652c"),
+  leaves: {
+    shape: "tuft",
+    size: 2.1,
+    width: 0.95,
+    perStem: 5,
+    from: 0.5,
+    flat: 0.8,
+    color: hex2("#24422e"),
+    colorVar: 0.1
+  },
+  roots: 4,
+  impostor: "blob",
+  typical: { height: 25, spread: 9, dbh: 0.6 }
+};
+var palm2 = {
+  shape: "cylindrical",
+  baseSize: 0.95,
+  ratioPower: 1.1,
+  taper: 0.7,
+  lean: 12,
+  levels: [
+    { branches: 0, length: 1, downAngle: 0, curve: 24, curveVar: 1.5, segments: 12 },
+    {
+      branches: 22,
+      length: 0.26,
+      downAngle: 115,
+      downAngleV: -85,
+      rotate: 137.5,
+      curve: -55,
+      curveVar: 4,
+      segments: 8
+    }
+  ],
+  bark: hex2("#6b5d4a"),
+  barkTop: hex2("#8a7a62"),
+  leaves: {
+    shape: "frond",
+    size: 0,
+    width: 0.2,
+    perStem: 26,
+    color: hex2("#4f7a2a"),
+    colorVar: 0.12
+  },
+  roots: 9,
+  fruit: { count: 7, radius: 0.13, color: hex2("#5f6a22") },
+  impostor: "cards",
+  typical: { height: 20, spread: 9, dbh: 0.35 }
+};
+var birch2 = {
+  shape: "flame",
+  baseSize: 0.3,
+  ratioPower: 1.4,
+  taper: 0.1,
+  levels: [
+    { branches: 0, length: 1, downAngle: 0, curveVar: 3, segments: 10 },
+    {
+      branches: 22,
+      length: 0.32,
+      downAngle: 45,
+      downAngleV: 10,
+      curve: -25,
+      curveVar: 8,
+      segments: 4
+    },
+    { branches: 5, length: 0.55, downAngle: 30, curve: -45, curveVar: 10, start: 0.2, segments: 3 }
+  ],
+  bark: hex2("#d9d6cc"),
+  barkMarks: { color: hex2("#24221f"), amount: 0.12 },
+  leaves: {
+    shape: "oval",
+    size: 0.8,
+    width: 0.7,
+    perStem: 4,
+    color: hex2("#6f9a32"),
+    colorVar: 0.15
+  },
+  impostor: "blob",
+  typical: { height: 18, spread: 8, dbh: 0.4 }
+};
+var willow2 = {
+  shape: "hemispherical",
+  baseSize: 0.25,
+  ratioPower: 1.7,
+  taper: 0.35,
+  levels: [
+    { branches: 0, length: 0.55, downAngle: 0, curveVar: 5, segments: 6 },
+    {
+      branches: 8,
+      length: 0.95,
+      downAngle: 42,
+      curve: 40,
+      curveBack: -70,
+      curveVar: 8,
+      segments: 6
+    },
+    { branches: 7, length: 0.55, downAngle: 35, curve: -80, curveVar: 8, start: 0.3, segments: 4 }
+  ],
+  bark: hex2("#4f463a"),
+  leaves: {
+    shape: "strand",
+    size: 2.6,
+    width: 0.22,
+    perStem: 4,
+    color: hex2("#8aa83e"),
+    colorVar: 0.12,
+    hang: 0.92
+  },
+  roots: 6,
+  impostor: "blob",
+  typical: { height: 12, spread: 14, dbh: 0.8 }
+};
+var SPECIES2 = { oak: oak2, pine: pine2, palm: palm2, birch: birch2, willow: willow2 };
+
+// src/kinds/vegetation-skeleton.ts
+var deg = Math.PI / 180;
+var unit3 = (a) => {
+  const l = Math.hypot(a[0], a[1], a[2]) || 1;
+  return [a[0] / l, a[1] / l, a[2] / l];
+};
+function rotate(v, k, a) {
+  const c = Math.cos(a);
+  const s = Math.sin(a);
+  const d = (k[0] * v[0] + k[1] * v[1] + k[2] * v[2]) * (1 - c);
+  return [
+    v[0] * c + (k[1] * v[2] - k[2] * v[1]) * s + k[0] * d,
+    v[1] * c + (k[2] * v[0] - k[0] * v[2]) * s + k[1] * d,
+    v[2] * c + (k[0] * v[1] - k[1] * v[0]) * s + k[2] * d
+  ];
+}
+function upAxis(dir) {
+  const k = [dir[1], -dir[0], 0];
+  return Math.hypot(k[0], k[1]) < 0.0001 ? [0, 1, 0] : unit3(k);
+}
+function path(start, dir0, len, lv, trunk, rng) {
+  const res = Math.max(1, lv.segments);
+  const step = len / res;
+  const pts = [start];
+  let dir = dir0;
+  let p = start;
+  for (let i = 0;i < res; i++) {
+    const half = lv.curveBack !== undefined && i >= res / 2;
+    const bend = half ? (lv.curveBack ?? 0) / Math.ceil(res / 2) : (lv.curve ?? 0) / (lv.curveBack !== undefined ? Math.max(1, Math.floor(res / 2)) : res);
+    const wob = lv.curveVar ?? 0;
+    if (trunk)
+      dir = rotate(dir, [0, 1, 0], -(bend + rng.range(-wob, wob)) * deg);
+    else {
+      dir = rotate(dir, upAxis(dir), (bend + rng.range(-wob, wob)) * deg);
+      dir = rotate(dir, [0, 0, 1], rng.range(-wob, wob) * deg);
+    }
+    dir = unit3(dir);
+    p = [p[0] + dir[0] * step, p[1] + dir[1] * step, p[2] + dir[2] * step];
+    pts.push(p);
+  }
+  return pts;
+}
+function grow(p, size, rng) {
+  const t0 = p.levels[0];
+  if (!t0)
+    return [];
+  const L0 = size.height * t0.length;
+  const r0 = size.dbh / 2;
+  const lean = (p.lean ?? 0) * deg;
+  const trunkPts = path([0, 0, -0.05], [Math.sin(lean), 0, Math.cos(lean)], L0, t0, true, rng);
+  const arc0 = arcLengths2(trunkPts);
+  const bh = 1.3;
+  const trunkR = arc0.map((s) => {
+    const f = Math.max(0, (s - bh) / Math.max(0.1, L0 - bh));
+    return r0 * (1 - (1 - p.taper) * f);
+  });
+  const stems = [
+    {
+      level: 0,
+      pts: trunkPts,
+      radii: trunkR,
+      length: L0,
+      parent: -1,
+      surface: [0, 0, 0],
+      maxLength: L0
+    }
+  ];
+  for (let si = 0;si < stems.length; si++) {
+    const par = stems[si];
+    const lv = par ? p.levels[par.level + 1] : undefined;
+    if (!par || !lv)
+      continue;
+    const arc = arcLengths2(par.pts);
+    const frames = transportFrames2(par.pts);
+    const s0 = (par.level === 0 ? p.baseSize : lv.start ?? 0.1) * par.length;
+    const s1 = par.length * 0.97;
+    const fill = par.level === 0 ? 1 : Math.min(1, par.length / par.maxLength);
+    const n = par.level === 0 ? lv.branches : Math.round(lv.branches * (0.25 + 0.75 * fill));
+    let phi = rng.range(0, 360);
+    for (let i = 0;i < n; i++) {
+      const s = s0 + (s1 - s0) * (i + rng.range(0.15, 0.85)) / Math.max(1, n);
+      let j = 0;
+      while (j < arc.length - 2 && (arc[j + 1] ?? 0) < s)
+        j++;
+      const a = par.pts[j] ?? [0, 0, 0];
+      const b = par.pts[j + 1] ?? a;
+      const f = (s - (arc[j] ?? 0)) / ((arc[j + 1] ?? 1) - (arc[j] ?? 0) || 1);
+      const c = [
+        a[0] + (b[0] - a[0]) * f,
+        a[1] + (b[1] - a[1]) * f,
+        a[2] + (b[2] - a[2]) * f
+      ];
+      const rp = (par.radii[j] ?? 0) * (1 - f) + (par.radii[j + 1] ?? 0) * f;
+      const T = unit3([b[0] - a[0], b[1] - a[1], b[2] - a[2]]);
+      const fr = frames[j] ?? { n: [1, 0, 0], b: [0, 1, 0] };
+      phi += (lv.rotate ?? 137.5) + rng.range(-10, 10);
+      const cp = Math.cos(phi * deg);
+      const sp = Math.sin(phi * deg);
+      const raw = [
+        cp * fr.n[0] + sp * fr.b[0],
+        cp * fr.n[1] + sp * fr.b[1],
+        cp * fr.n[2] + sp * fr.b[2]
+      ];
+      const tdot = raw[0] * T[0] + raw[1] * T[1] + raw[2] * T[2];
+      const np = unit3([raw[0] - tdot * T[0], raw[1] - tdot * T[1], raw[2] - tdot * T[2]]);
+      const zone = (s - s0) / Math.max(0.000001, s1 - s0);
+      const down = (lv.downAngle + (lv.downAngleV ?? 0) * zone + rng.range(-5, 5)) * deg;
+      const dir = unit3([
+        T[0] * Math.cos(down) + np[0] * Math.sin(down),
+        T[1] * Math.cos(down) + np[1] * Math.sin(down),
+        T[2] * Math.cos(down) + np[2] * Math.sin(down)
+      ]);
+      const vary = 1 + rng.range(-(lv.lengthVar ?? 0.15), lv.lengthVar ?? 0.15);
+      const maxLength = lv.length * par.length;
+      const base = par.level === 0 ? maxLength * shapeRatio(p.shape, (par.length - s) / Math.max(0.000001, par.length - s0)) : lv.length * (par.length - 0.6 * s);
+      const len = Math.max(0.15, base * vary);
+      const r0c = par.radii[0] ?? rp;
+      const rc = Math.max(0.006, Math.min(0.8 * rp, r0c * (len / par.length) ** p.ratioPower));
+      const start = [
+        c[0] + np[0] * (rp - rc),
+        c[1] + np[1] * (rp - rc),
+        c[2] + np[2] * (rp - rc)
+      ];
+      const pts = path(start, dir, len, lv, false, rng);
+      stems.push({
+        level: par.level + 1,
+        pts,
+        radii: pts.map((_, k) => rc * (1 - 0.75 * k / Math.max(1, pts.length - 1))),
+        length: len,
+        parent: si,
+        surface: [c[0] + np[0] * rp, c[1] + np[1] * rp, c[2] + np[2] * rp],
+        maxLength
+      });
+    }
+  }
+  return stems;
+}
+
+// src/kinds/vegetation.ts
+function treeParams2(o) {
+  const s = o.species ?? "oak";
+  const base = typeof s === "string" ? SPECIES2[s] : s;
+  if (!base) {
+    throw new Ts23dError2("T3D_RECIPE_INVALID", {
+      cause: `unknown tree species '${String(s)}'`,
+      fix: `use one of ${Object.keys(SPECIES2).join(", ")} or pass a TreeParams object (spread a preset and override)`
+    });
+  }
+  return { ...base, ...o.params };
+}
+function tree2(ctx, o) {
+  const p = treeParams2(o);
+  if (!(o.height > 0) || p.levels.length < 2 || p.levels.length > 4) {
+    throw new Ts23dError2("T3D_RECIPE_INVALID", {
+      cause: `tree height ${o.height} m with ${p.levels.length} branch levels`,
+      fix: "height must be > 0 and levels must hold the trunk plus 1–3 branch levels"
+    });
+  }
+  const k = o.height / p.typical.height;
+  const spread = o.spread ?? p.typical.spread * k;
+  const dbh = o.dbh ?? p.typical.dbh * k;
+  const pre = o.prefix ? `${o.prefix}_` : "";
+  const parts = {
+    trunk: `${pre}trunk`,
+    crown: `${pre}crown`,
+    branches: `${pre}branches`,
+    leaves: `${pre}leaves`,
+    roots: `${pre}roots`
+  };
+  const rng = ctx.rng.fork(`tree:${o.prefix ?? ""}:${o.seed ?? 0}`);
+  const stems = grow(p, { height: o.height, dbh }, rng.fork("skeleton"));
+  const trunkStem = stems[0];
+  if (!trunkStem)
+    return { parts, height: o.height, spread, dbh };
+  const deepest = p.levels.length - 1;
+  const lod = ctx.lod;
+  const top = trunkStem.pts[trunkStem.pts.length - 1]?.[2] ?? o.height;
+  const shade = crownShade(stems, 1);
+  let trunk;
+  let roots = null;
+  let branches = null;
+  let leaves;
+  if (lod === 2) {
+    const imp = p.impostor === "cards" ? frondCards(stems, p, 1) : blob(stems, p, rng.fork("impostor"));
+    trunk = () => barkTint(imp.trunk, p, top, rng.fork("bark"));
+    leaves = imp.leaves;
+  } else {
+    const hi = lod === 0 || deepest < 2 ? deepest : deepest - 1;
+    trunk = (r) => trunkMesh(trunkStem, p, lod, r, rng.fork("bark"));
+    if (p.roots)
+      roots = (r) => rootsMesh(trunkStem, p, lod, r, rng.fork("roots"));
+    const wood = [
+      barkTint(stemsMesh(stems, 1, hi, lod, p.bark), p, top, rng.fork("bark:branches"))
+    ];
+    if (p.fruit && lod === 0)
+      wood.push(fruit(trunkStem, p.baseSize - 0.01, p.fruit, rng.fork("fruit")));
+    branches = merge2(wood);
+    const lr = rng.fork("leaves");
+    leaves = p.leaves.shape === "frond" ? frondLeaflets(stems, deepest, p.leaves, lod === 0 ? p.leaves.perStem : Math.ceil(p.leaves.perStem / 2), shade, lr) : hi === deepest ? leafCards(stems, deepest, radialSegments(deepest, lod), p.leaves, shade, lr) : clusterCards(stems, deepest, p.leaves, shade, lr);
+  }
+  const s = fitFactors([trunk(1), branches, leaves, roots?.(1) ?? null].filter((m) => m !== null), [spread, spread, o.height]);
+  const fit = (m) => scaleMesh(m, s);
+  const base = trunkStem.pts[Math.round(p.baseSize * (trunkStem.pts.length - 1))] ?? [0, 0, 0];
+  const pivot = [base[0] * s[0], base[1] * s[1], base[2] * s[2]];
+  const back = [-pivot[0], -pivot[1], -pivot[2]];
+  ctx.part(parts.trunk, fit(trunk(1 / s[1])));
+  if (roots)
+    ctx.part(parts.roots, fit(roots(1 / s[1])));
+  ctx.group(parts.crown, {
+    at: pivot,
+    motion: { kind: "sway", axis: [1, 0, 0], degrees: 2, hz: 0.4 },
+    clearOf: roots ? [parts.trunk, parts.roots] : [parts.trunk]
+  });
+  if (branches && triangleCount2(branches) > 0)
+    ctx.part(parts.branches, translate2(fit(branches), back), { parent: parts.crown });
+  ctx.part(parts.leaves, translate2(fit(leaves), back), { parent: parts.crown });
+  return { parts, height: o.height, spread, dbh };
+}
+function treeReal2(o) {
+  const pre = o.prefix ? `${o.prefix}_` : "";
+  const src = o.source ? { source: o.source } : {};
+  return {
+    length: o.spread,
+    width: o.spread,
+    height: o.height,
+    measures: [
+      {
+        label: "trunk diameter at breast height",
+        value: o.dbh,
+        axis: "y",
+        parts: [`${pre}trunk`],
+        ...src
+      },
+      {
+        label: "total height",
+        value: o.height,
+        axis: "z",
+        parts: [`${pre}trunk`, `${pre}crown`, `${pre}branches`, `${pre}leaves`, `${pre}roots`],
+        ...src
+      }
+    ]
+  };
+}
+var trees2 = defineFamily2({
+  kind: "vegetation",
+  tags: ["vegetation", "tree"],
+  budget: BUDGETS2.tree,
+  defaults: { species: "oak", height: 22 },
+  build: (ctx, p) => {
+    tree2(ctx, p);
+  }
+});
+// src/kinds/vehicle.ts
+var segs = (ctx, hi) => [hi, Math.max(8, hi / 2), 6][ctx.lod] ?? 6;
+function axle2(ctx, o) {
+  ctx.group(o.name, { at: o.at, motion: { kind: "spin", axis: [0, 1, 0], rps: o.rps } });
+  for (const [s, y] of [
+    ["l", o.gauge / 2],
+    ["r", -o.gauge / 2]
+  ]) {
+    ctx.part(`${o.name}_wheel_${s}`, cylinder2({
+      radius: o.radius,
+      length: o.width,
+      segments: segs(ctx, 24),
+      axis: "y",
+      at: [0, y, 0],
+      color: o.color,
+      strip: "iron"
+    }), { parent: o.name });
+  }
+}
+function whyteAxles2(arrangement, o) {
+  const groups = parseWhyte2(arrangement);
+  const out = [];
+  let x = 0;
+  for (const g of groups) {
+    const r = g.role === "driving" ? o.driving : g.role === "leading" ? o.leading : o.trailing;
+    for (let i = 0;i < g.count / 2; i++) {
+      out.push({ role: g.role, x: x + r, radius: r });
+      x += r * 2 + o.spacing;
+    }
+  }
+  const mid = x / 2;
+  return out.map((a) => ({ ...a, x: mid - a.x }));
+}
+function trackRun2(ctx, o) {
+  const pitch = o.length / o.wheels;
+  for (let i = 0;i < o.wheels; i++) {
+    const x = -o.length / 2 + pitch * (i + 0.5);
+    ctx.part(`road_wheel_${o.side}_${i}`, cylinder2({
+      radius: o.radius,
+      length: o.width * 0.8,
+      segments: segs(ctx, 20),
+      axis: "y",
+      at: [0, 0, 0],
+      color: o.color,
+      strip: "iron"
+    }), { at: [x, o.y, o.radius + 0.06], motion: { kind: "spin", axis: [0, 1, 0], rps: -0.6 } });
+  }
+  const t = 0.06;
+  ctx.part(`track_${o.side}_bottom`, box2({
+    size: [o.length + o.radius, o.width, t],
+    at: [0, o.y, 0],
+    color: o.track,
+    strip: "iron"
+  }));
+  ctx.part(`track_${o.side}_top`, box2({
+    size: [o.length, o.width, t],
+    at: [0, o.y, o.radius * 2 + 0.06],
+    color: o.track,
+    strip: "iron"
+  }));
+}
+function propeller2(ctx, o) {
+  ctx.group(o.name, {
+    at: o.at,
+    ...o.parent ? { parent: o.parent } : {},
+    motion: { kind: "spin", axis: [1, 0, 0], rps: 6 }
+  });
+  ctx.part(`${o.name}_hub`, cylinder2({
+    radius: o.radius * 0.12,
+    length: o.radius * 0.3,
+    segments: segs(ctx, 12),
+    axis: "x",
+    color: o.color
+  }), { parent: o.name });
+  const blade = box2({ size: [0.03, o.radius * 0.12, o.radius], color: o.color });
+  for (let i = 0;i < o.blades; i++) {
+    ctx.part(`${o.name}_blade_${i}`, place2(blade, { roll: i / o.blades * Math.PI * 2 }), {
+      parent: o.name
+    });
+  }
+}
+export { mass2, opening2, facade2, setbacks2, checkHead2, HEADS2, headParams2, HEAD_RES2, headEdits2, head2, hullLines2, hullMesh2, hull2, creature2, roofHeightAt2, ridgeHeight2, roofMesh2, roof2, roofInfo2, oak2, pine2, palm2, birch2, willow2, SPECIES2, treeParams2, tree2, treeReal2, trees2, axle2, whyteAxles2, trackRun2, propeller2 };
+
+//# debugId=AF041752F55E532164756E2164756E21
+//# sourceMappingURL=chunk-8j4c28jt.js.map