axstack 0.36.0 → 0.37.0

package/skills/axstack-anatomy/kit/turn-fixed.mjs

@@ -0,0 +1,3800 @@
+const T3_ROOT = Math.sqrt(1.6);
+const T3_TAU = Math.PI * 2;
+const T3_RAD = Math.PI / 180;
+const T3_LB = [0, 0.2, 0.42, 0.62];
+const T3_EB = [0.25, 0.5, 0.75];
+const T3_SOFT = 0.035;
+const T3_LEVELS = 32;
+const T3_Q = 64;
+const t3State = { detail: 1, exact: false };
+
+function t3Num(v) {
+  if (t3State.exact) return String(Math.round(v * 1e6) / 1e6);
+  let t = Math.round(v * 100);
+  if (t === 0) return "0";
+  let sign = "";
+  if (t < 0) {
+    sign = "-";
+    t = -t;
+  }
+  const whole = Math.floor(t / 100);
+  const part = t - whole * 100;
+  if (part === 0) return sign + whole;
+  if (part < 10) return sign + whole + ".0" + part;
+  return sign + whole + "." + (part % 10 === 0 ? part / 10 : part);
+}
+
+function t3Fix(v, scale) {
+  const t = Math.round(v * scale) / scale;
+  return t === 0 ? "0" : String(t);
+}
+
+const t3Arena = { on: false, f: null };
+
+function t3Token(get, count, closed) {
+  const f = t3Arena.f;
+  const at = f.arenaN;
+  let arena = f.arena;
+  if (!arena || arena.length < 2 * (at + count)) {
+    const next = new Float64Array(Math.max(512, 2 * (at + count) * 2));
+    if (arena) next.set(arena.subarray(0, 2 * at));
+    arena = f.arena = next;
+  }
+  const unit = t3State.exact ? 1e6 : 100;
+  for (let i = 0; i < count; i++) {
+    arena[2 * (at + i)] = Math.round(get(2 * i) * unit) / unit;
+    arena[2 * (at + i) + 1] = Math.round(get(2 * i + 1) * unit) / unit;
+  }
+  f.arenaN = at + count;
+  return "\u0001" + String.fromCharCode(at & 0xffff, at >>> 16, count, closed ? 1 : 0);
+}
+
+function t3Matrix(f, role, a, b, c, d, e, g) {
+  const list = f.tm || (f.tm = []);
+  const m = list[role] || (list[role] = new Float64Array(6));
+  m[0] = Math.round(a * 1e5) / 1e5;
+  m[1] = Math.round(b * 1e5) / 1e5;
+  m[2] = Math.round(c * 1e5) / 1e5;
+  m[3] = Math.round(d * 1e5) / 1e5;
+  m[4] = Math.round(e * 100) / 100;
+  m[5] = Math.round(g * 100) / 100;
+  return "\u0002";
+}
+
+function t3Path(buf, count, closed) {
+  if (count < 2) return "";
+  if (t3Arena.on) return t3Token((i) => buf[i], count, closed);
+  let s = "M" + t3Num(buf[0]) + " " + t3Num(buf[1]);
+  for (let i = 1; i < count; i++) s += "L" + t3Num(buf[2 * i]) + " " + t3Num(buf[2 * i + 1]);
+  return closed ? s + "Z" : s;
+}
+
+const t3Step = (a, b, x) => {
+  const t = Math.min(1, Math.max(0, (x - a) / (b - a)));
+  return t * t * (3 - 2 * t);
+};
+
+function t3Level(score, bands) {
+  let u = 0;
+  for (let i = 0; i < bands.length; i++) u += t3Step(bands[i] - T3_SOFT, bands[i] + T3_SOFT, score);
+  return Math.round(u * T3_Q);
+}
+
+function t3Grow(f, name, size, Kind) {
+  if (!f[name] || f[name].length < size) f[name] = new Kind(Math.max(size, f[name] ? f[name].length * 2 : 16));
+  return f[name];
+}
+
+function t3Box(buf, count, box) {
+  let x0 = Infinity;
+  let y0 = Infinity;
+  let x1 = -Infinity;
+  let y1 = -Infinity;
+  for (let i = 0; i < count; i++) {
+    const x = buf[2 * i];
+    const y = buf[2 * i + 1];
+    if (x < x0) x0 = x;
+    if (x > x1) x1 = x;
+    if (y < y0) y0 = y;
+    if (y > y1) y1 = y;
+  }
+  box[0] = x0;
+  box[1] = y0;
+  box[2] = x1;
+  box[3] = y1;
+}
+
+function t3Unit(v) {
+  const l = Math.hypot(v[0], v[1], v[2]) || 1;
+  return [v[0] / l, v[1] / l, v[2] / l];
+}
+
+function t3Rot(axis, degrees) {
+  const [x, y, z] = t3Unit(axis);
+  const c = Math.cos(degrees * T3_RAD);
+  const s = Math.sin(degrees * T3_RAD);
+  const C = 1 - c;
+  return new Float64Array([c + x * x * C, x * y * C - z * s, x * z * C + y * s, y * x * C + z * s, c + y * y * C, y * z * C - x * s, z * x * C - y * s, z * y * C + x * s, c + z * z * C]);
+}
+
+function t3Mul(A, B) {
+  const out = new Float64Array(9);
+  for (let r = 0; r < 3; r++) for (let c = 0; c < 3; c++) out[r * 3 + c] = A[r * 3] * B[c] + A[r * 3 + 1] * B[3 + c] + A[r * 3 + 2] * B[6 + c];
+  return out;
+}
+
+const t3Apply = (R, v) => [R[0] * v[0] + R[1] * v[1] + R[2] * v[2], R[3] * v[0] + R[4] * v[1] + R[5] * v[2], R[6] * v[0] + R[7] * v[1] + R[8] * v[2]];
+
+const T3_EYE = new Float64Array([1, 0, 0, 0, 1, 0, 0, 0, 1]);
+
+function t3Camera(P, pose) {
+  const a = (P.azimuth ?? 45) * T3_RAD;
+  const e = (P.elevation ?? 30) * T3_RAD;
+  const k = P.scale * T3_ROOT;
+  const sa = Math.sin(a);
+  const ca = Math.cos(a);
+  const se = Math.sin(e);
+  const ce = Math.cos(e);
+  const cam = { m: new Float64Array(6), ox: 0, oy: 0, V: [0, 0, 0], L: [0, 0, 0], k, turn: 0, R: T3_EYE, t: [0, 0, 0], lx: 0, ly: 1, sa, ca, se, ce, origin: P.origin };
+  const lw = Math.hypot(sa, ca, 1.2);
+  if (pose && pose.R && !(pose.turn !== undefined && pose.root)) {
+    const R = pose.R;
+    const t = pose.t ?? [0, 0, 0];
+    const r0 = [sa * k, -ca * k, 0];
+    const r1 = [ca * se * k, sa * se * k, -ce * k];
+    for (let c = 0; c < 3; c++) {
+      cam.m[c] = r0[0] * R[c] + r0[1] * R[3 + c] + r0[2] * R[6 + c];
+      cam.m[3 + c] = r1[0] * R[c] + r1[1] * R[3 + c] + r1[2] * R[6 + c];
+    }
+    cam.ox = P.origin[0] + r0[0] * t[0] + r0[1] * t[1] + r0[2] * t[2];
+    cam.oy = P.origin[1] + r1[0] * t[0] + r1[1] * t[1] + r1[2] * t[2];
+    const V = [ca * ce, sa * ce, se];
+    const L = [-sa / lw, ca / lw, 1.2 / lw];
+    for (let c = 0; c < 3; c++) {
+      cam.V[c] = R[c] * V[0] + R[3 + c] * V[1] + R[6 + c] * V[2];
+      cam.L[c] = R[c] * L[0] + R[3 + c] * L[1] + R[6 + c] * L[2];
+    }
+    cam.R = R;
+    cam.t = t;
+  } else {
+    const turn = pose ? pose.turn ?? 0 : 0;
+    const pivot = pose && pose.pivot ? pose.pivot : [0, 0];
+    const b = a - turn * T3_RAD;
+    const sb = Math.sin(b);
+    const cb = Math.cos(b);
+    cam.m[0] = sb * k;
+    cam.m[1] = -cb * k;
+    cam.m[2] = 0;
+    cam.m[3] = cb * se * k;
+    cam.m[4] = sb * se * k;
+    cam.m[5] = -ce * k;
+    cam.ox = P.origin[0] + (pivot[0] * sa - pivot[1] * ca) * k;
+    cam.oy = P.origin[1] + (pivot[0] * ca + pivot[1] * sa) * se * k;
+    cam.V = [cb * ce, sb * ce, se];
+    cam.L = [-sb / lw, cb / lw, 1.2 / lw];
+    cam.turn = turn;
+    const c = Math.cos(turn * T3_RAD);
+    const s = Math.sin(turn * T3_RAD);
+    cam.R = new Float64Array([c, -s, 0, s, c, 0, 0, 0, 1]);
+    cam.t = [pivot[0], pivot[1], 0];
+  }
+  const lh = Math.hypot(cam.L[0], cam.L[1]) || 1;
+  cam.lx = cam.L[0] / lh;
+  cam.ly = cam.L[1] / lh;
+  return cam;
+}
+
+function t3Quat(q) {
+  const l = Math.hypot(q[0], q[1], q[2], q[3]) || 1;
+  const x = q[0] / l;
+  const y = q[1] / l;
+  const z = q[2] / l;
+  const w = q[3] / l;
+  return new Float64Array([1 - 2 * (y * y + z * z), 2 * (x * y - z * w), 2 * (x * z + y * w), 2 * (x * y + z * w), 1 - 2 * (x * x + z * z), 2 * (y * z - x * w), 2 * (x * z - y * w), 2 * (y * z + x * w), 1 - 2 * (x * x + y * y)]);
+}
+
+function t3FreeRot(v) {
+  if (v.R) return v.R instanceof Float64Array ? v.R : Float64Array.from(v.R);
+  if (v.q) return t3Quat(v.q);
+  if (v.axis) return t3Rot(v.axis, v.angle ?? 0);
+  return T3_EYE;
+}
+
+function t3Poses(groups, values) {
+  const get = (name) => (values instanceof Map ? values.get(name) : values ? values[name] : undefined) ?? 0;
+  const list = [];
+  for (let index = 0; index < groups.length; index++) {
+    const g = groups[index];
+    const v = get(g.name);
+    let parent = g.parent === undefined || g.parent === null || g.parent < 0 ? null : list[g.parent];
+    let po = parent ? groups[g.parent].origin : [0, 0, 0];
+    let R = T3_EYE;
+    let t = [g.origin[0] - po[0], g.origin[1] - po[1], g.origin[2] - po[2]];
+    if (g.kind === "turn") R = t3Rot([0, 0, 1], v);
+    else if (g.kind === "hinge") R = t3Rot(g.axis, v);
+    else if (g.kind === "slide") {
+      const d = t3Unit(g.direction);
+      t[0] += d[0] * v;
+      t[1] += d[1] * v;
+      t[2] += d[2] * v;
+    } else if (g.kind === "free" && v && typeof v === "object") {
+      R = t3FreeRot(v);
+      if (v.world) {
+        parent = null;
+        po = [0, 0, 0];
+        t = [g.origin[0], g.origin[1], g.origin[2]];
+      }
+      if (v.t) {
+        t[0] += v.t[0];
+        t[1] += v.t[1];
+        t[2] += v.t[2];
+      }
+    }
+    if (!parent) {
+      const pose = { R, t, value: v };
+      if (g.kind === "turn") Object.assign(pose, { turn: v, pivot: [g.origin[0], g.origin[1]], root: true });
+      list.push(pose);
+      continue;
+    }
+    const tw = t3Apply(parent.R, t);
+    list.push({ R: t3Mul(parent.R, R), t: [tw[0] + parent.t[0], tw[1] + parent.t[1], tw[2] + parent.t[2]], value: v });
+  }
+  return list;
+}
+
+function t3PosesMap(groups, values) {
+  const list = t3Poses(groups, values);
+  return new Map(groups.map((g, index) => [g.name, list[index]]));
+}
+
+function t3Roles(part) {
+  const roles = [];
+  const spec = part.spec;
+  const details = part.details ?? {};
+  const add = (name, type, extra = {}) => roles.push({ name, type, ...extra });
+  const tone = part.tone ?? "hi";
+  const crease = part.crease ?? "faint";
+  const fadedSlots = (prefix, count, cls, lineTone) => {
+    for (let j = 0; j < count; j++) add(`${prefix}${j}`, "slot", { cls, tone: lineTone });
+  };
+  const planes = () => (part.planes ?? []).forEach((_, j) => add(`plane${j}`, "plane"));
+  const dots = () => (part.dots ?? []).forEach((dot, j) => add(`c${j}`, "dot", { tone: dot.tone ?? "mid", size: dot.size ?? 0.5 }));
+  const sheets = (top) => {
+    for (let t = 0; t < 4; t++) add(`s${t}`, "path", { cls: "iso-shade", shade: t });
+    if (top) add("s4", "path", { cls: "iso-top" });
+  };
+  const inner = () => {
+    if ((details.seams && details.seams.length) || (details.ribs && details.ribs.seams)) add("inner", "path", { cls: "iso-line", tone: "faint" });
+  };
+  const ribs = () => {
+    if (details.ribs) fadedSlots("r", spec.slots?.ribs ?? 6, "iso-line", details.ribs.tone ?? "lo");
+  };
+  if (part.kind === "prism") {
+    add("fill", "path", { cls: "iso-fill" });
+    const faces = spec.ring.length / 2 + (spec.up ? 0 : 2);
+    for (let j = 0; j < faces; j++) add(`f${j}`, "face");
+    if (spec.up) add("top", "xform", { cls: "iso-top" });
+    if (crease !== "none") add("crease", "path", { cls: "iso-line iso-crease", tone: crease });
+    if (spec.bevel && crease !== "none") fadedSlots("v", spec.slots?.bevel ?? 6, "iso-line iso-bevel", crease);
+    if (details.seams && details.seams.length) add("inner", "path", { cls: "iso-line", tone: "faint" });
+    planes();
+    add("edge", "path", { cls: "iso-line iso-edge", tone });
+    dots();
+  } else if (part.kind === "round" || part.kind === "lathe") {
+    add("fill", "path", { cls: "iso-fill" });
+    sheets(true);
+    const ends = part.kind === "round" ? spec.ends : spec.caps.map((cap) => (cap ? "flat" : "open"));
+    ends.forEach((end, j) => end === "flat" && add(`k${j}`, "face"));
+    if (crease !== "none") add("crease", "path", { cls: "iso-line iso-crease", tone: crease });
+    inner();
+    ribs();
+    planes();
+    add("edge", "path", { cls: "iso-line iso-edge", tone });
+    dots();
+  } else if (part.kind === "ball") {
+    add("fill", "path", { cls: "iso-fill" });
+    sheets(false);
+    spec.flats.forEach((_, j) => add(`f${j}`, "face"));
+    if (crease !== "none") add("crease", "path", { cls: "iso-line iso-crease", tone: crease });
+    planes();
+    add("edge", "path", { cls: "iso-line iso-edge", tone });
+    dots();
+  } else if (part.kind === "tube") {
+    add("body", "path", { cls: "tb-body" });
+    if (spec.wide) {
+      add("shine", "path", { cls: "tb-shine" });
+      add("shade", "path", { cls: "tb-shade" });
+    }
+    if (spec.rings) fadedSlots("r", spec.slots?.ribs ?? 6, "tb-ring", spec.rings.tone ?? "lo");
+    add("edges", "path", { cls: "iso-line tb-edge", tone });
+  } else if (part.kind === "item") {
+    return roles;
+  } else if (part.kind === "fixed") {
+    add("move", "self");
+    ribs();
+    planes();
+    dots();
+  }
+  return roles;
+}
+
+function t3Planes(list) {
+  return (list ?? []).map((plane) => ({ o: plane.o, u: plane.u, v: plane.v, n: plane.n, fade: plane.fade ?? [0.04, 0.3], billboard: Boolean(plane.billboard) }));
+}
+
+function t3Dots(list) {
+  return (list ?? []).map((dot) => ({ p: dot.p, n: dot.n ?? null, size: dot.size ?? 0.5, fade: dot.fade ?? [0.04, 0.42] }));
+}
+
+function t3PreparePrism(run, part) {
+  const spec = part.spec;
+  const n = spec.ring.length / 2;
+  run.n = n;
+  run.up = Boolean(spec.up);
+  const ring = Float64Array.from(spec.ring);
+  run.ring = ring;
+  const nx = new Float64Array(n);
+  const ny = new Float64Array(n);
+  for (let i = 0; i < n; i++) {
+    const j = (i + 1) % n;
+    const dx = ring[2 * j] - ring[2 * i];
+    const dy = ring[2 * j + 1] - ring[2 * i + 1];
+    const l = Math.hypot(dx, dy) || 1;
+    nx[i] = dy / l;
+    ny[i] = -dx / l;
+  }
+  run.nx = nx;
+  run.ny = ny;
+  const F = spec.up ? { o: [0, 0, 0], a: [0, 0, 1], u: [1, 0, 0], v: [0, 1, 0] } : spec.F;
+  run.F = F;
+  run.s0 = spec.up ? spec.z0 : spec.s0;
+  run.s1 = spec.up ? spec.z1 : spec.s1;
+  const lo = new Float64Array(3 * n);
+  const hi = new Float64Array(3 * n);
+  const N3 = new Float64Array(3 * n);
+  for (let i = 0; i < n; i++) {
+    const x = ring[2 * i];
+    const y = ring[2 * i + 1];
+    for (let c = 0; c < 3; c++) {
+      const base = F.o[c] + F.u[c] * x + F.v[c] * y;
+      lo[3 * i + c] = base + F.a[c] * run.s0;
+      hi[3 * i + c] = base + F.a[c] * run.s1;
+      N3[3 * i + c] = F.u[c] * nx[i] + F.v[c] * ny[i];
+    }
+  }
+  run.lo = lo;
+  run.hi = hi;
+  run.N3 = N3;
+  run.sharp = new Uint8Array(n);
+  for (let i = 0; i < n; i++) {
+    const p = (i - 1 + n) % n;
+    run.sharp[i] = nx[p] * nx[i] + ny[p] * ny[i] < Math.cos(0.35) ? 1 : 0;
+  }
+  if (spec.bevel) {
+    const inset = new Float64Array(2 * n);
+    for (let i = 0; i < n; i++) {
+      const p = (i - 1 + n) % n;
+      const mx = nx[p] + nx[i];
+      const my = ny[p] + ny[i];
+      const l = Math.hypot(mx, my) || 1;
+      inset[2 * i] = ring[2 * i] - (mx / l) * spec.bevel;
+      inset[2 * i + 1] = ring[2 * i + 1] - (my / l) * spec.bevel;
+    }
+    run.inset = inset;
+  }
+  run.seams = part.details && part.details.seams ? part.details.seams.slice() : null;
+  run.cut = spec.cuts && spec.cuts.length ? spec.cuts : null;
+}
+
+function t3Axes(run, part) {
+  if (run.kind === "ball") return run.flats.map((flat) => flat.n);
+  if (run.kind === "tube") return run.tips.slice();
+  if (run.kind === "prism") {
+    const out = [run.F.a];
+    for (let i = 0; i < run.n; i++) {
+      const n = [run.N3[3 * i], run.N3[3 * i + 1], run.N3[3 * i + 2]];
+      if (out.every((m) => Math.abs(m[0] * n[0] + m[1] * n[1] + m[2] * n[2]) < 0.9995)) out.push(n);
+    }
+    return out;
+  }
+  if (run.F) return [run.F.a];
+  if (part.spec && part.spec.F) return [part.spec.F.a];
+  return [];
+}
+
+function t3Cloud(run, part) {
+  const out = [];
+  const ring = (F, s, r, count) => {
+    for (let j = 0; j < count; j++) {
+      const c = Math.cos((j / count) * T3_TAU);
+      const n = Math.sin((j / count) * T3_TAU);
+      out.push(F.o[0] + F.a[0] * s + r * (c * F.u[0] + n * F.v[0]), F.o[1] + F.a[1] * s + r * (c * F.u[1] + n * F.v[1]), F.o[2] + F.a[2] * s + r * (c * F.u[2] + n * F.v[2]));
+    }
+  };
+  if (run.kind === "prism") {
+    for (let i = 0; i < 3 * run.n; i++) out.push(run.lo[i]);
+    for (let i = 0; i < 3 * run.n; i++) out.push(run.hi[i]);
+  } else if (run.kind === "round") {
+    ring(run.F, run.s0, run.r0, 24);
+    ring(run.F, run.s1, run.r1, 24);
+    for (const [end, s, r] of [[0, run.s0, run.r0], [1, run.s1, run.r1]]) {
+      if (run.ends[end] !== "dome") continue;
+      const sign = end ? 1 : -1;
+      for (const b of [0.5, 1.0, 1.35]) ring(run.F, s + sign * r * Math.sin(b), r * Math.cos(b), 6);
+      out.push(run.F.o[0] + run.F.a[0] * (s + sign * r), run.F.o[1] + run.F.a[1] * (s + sign * r), run.F.o[2] + run.F.a[2] * (s + sign * r));
+    }
+  } else if (run.kind === "ball") {
+    const golden = Math.PI * (3 - Math.sqrt(5));
+    for (let i = 0; i < 64; i++) {
+      const y = 1 - (2 * (i + 0.5)) / 64;
+      const rad = Math.sqrt(1 - y * y);
+      const w = [Math.cos(golden * i) * rad, Math.sin(golden * i) * rad, y];
+      const p = [run.c[0] + run.r * w[0], run.c[1] + run.r * w[1], run.c[2] + run.r * w[2]];
+      let inside = true;
+      for (const flat of run.flats) if ((p[0] - run.c[0]) * flat.n[0] + (p[1] - run.c[1]) * flat.n[1] + (p[2] - run.c[2]) * flat.n[2] > flat.d + 1e-9) inside = false;
+      if (inside) out.push(p[0], p[1], p[2]);
+    }
+    for (const flat of run.flats)
+      for (let j = 0; j < 12; j++) {
+        const c = Math.cos((j / 12) * T3_TAU) * flat.rho;
+        const n = Math.sin((j / 12) * T3_TAU) * flat.rho;
+        out.push(run.c[0] + flat.n[0] * flat.d + c * flat.u[0] + n * flat.v[0], run.c[1] + flat.n[1] * flat.d + c * flat.u[1] + n * flat.v[1], run.c[2] + flat.n[2] * flat.d + c * flat.u[2] + n * flat.v[2]);
+      }
+  } else if (run.kind === "lathe") {
+    const lv = run.levels;
+    const step = Math.max(4, Math.floor(lv.length / 4 / 8)) * 4;
+    for (let i = 0; i < lv.length; i += step) ring(run.F, lv[i], lv[i + 1], 8);
+    ring(run.F, lv[lv.length - 4], lv[lv.length - 3], 8);
+  } else if (run.kind === "tube") {
+    const b = run.body;
+    const stride = Math.max(1, Math.floor(b.count / 8));
+    for (let i = 0; i < b.count; i += stride) {
+      const T = t3Unit([b.D3[3 * i], b.D3[3 * i + 1], b.D3[3 * i + 2]]);
+      const [u, v] = t3Basis(T);
+      ring({ o: [b.P3[3 * i], b.P3[3 * i + 1], b.P3[3 * i + 2]], a: T, u, v }, 0, run.r, 8);
+    }
+  } else if (part.cloud) for (const v of part.cloud) out.push(v);
+  return Float64Array.from(out);
+}
+
+function t3Unpack(value, grouped) {
+  if (!value) return new Float64Array(0);
+  if (typeof value !== "string") return Float64Array.from(value);
+  const text = atob(value);
+  const bytes = new Uint8Array(text.length);
+  for (let i = 0; i < text.length; i++) bytes[i] = text.charCodeAt(i);
+  const view = new DataView(bytes.buffer);
+  const size = grouped ? 10 : 8;
+  const stride = grouped ? 6 : 5;
+  const count = bytes.length / size;
+  const out = new Float64Array(count * stride);
+  for (let e = 0; e < count; e++) {
+    let o = e * size;
+    const at = e * stride;
+    out[at] = view.getUint16(o);
+    out[at + 1] = view.getUint16(o + 2);
+    o += 4;
+    if (grouped) {
+      out[at + 2] = view.getUint16(o) - 1;
+      o += 2;
+    }
+    let x = (view.getUint16(o) / 65535) * 2 - 1;
+    let y = (view.getUint16(o + 2) / 65535) * 2 - 1;
+    const z = 1 - Math.abs(x) - Math.abs(y);
+    if (z < 0) {
+      const ox = (1 - Math.abs(y)) * (x >= 0 ? 1 : -1);
+      const oy = (1 - Math.abs(x)) * (y >= 0 ? 1 : -1);
+      x = ox;
+      y = oy;
+    }
+    const l = Math.hypot(x, y, z) || 1;
+    out[at + stride - 3] = x / l;
+    out[at + stride - 2] = y / l;
+    out[at + stride - 1] = z / l;
+  }
+  return out;
+}
+
+function t3Prepare(data, { unit = 1 } = {}) {
+  const P = data.P;
+  const runs = data.parts.map((part, index) => {
+    const run = { index, name: part.name, kind: part.kind, group: part.group ?? -1, layer: part.layer, part, roles: t3Roles(part), planes: t3Planes(part.planes), dots: t3Dots(part.dots), unit };
+    run.role = Object.fromEntries(run.roles.map((role, j) => [role.name, j]));
+    if (part.kind === "prism") t3PreparePrism(run, part);
+    else if (part.kind === "round") t3PrepareRound(run, part, P, unit);
+    else if (part.kind === "ball") t3PrepareBall(run, part, P, unit);
+    else if (part.kind === "lathe") t3PrepareLathe(run, part, P, unit);
+    else if (part.kind === "tube") t3PrepareTube(run, part, data);
+    else if (part.kind === "item") {
+      run.version = 0;
+      run.itemBox = new Float64Array([1e9, 1e9, -1e9, -1e9]);
+      run.itemHull = new Float64Array(0);
+    } else if (part.kind === "fixed") {
+      run.anchor = part.spec.anchor;
+      run.home = part.spec.home;
+      run.box0 = part.spec.box;
+      run.hull0 = Float64Array.from(part.spec.hull);
+      run.F = part.spec.F ?? null;
+      run.ribs = part.details && part.details.ribs ? part.details.ribs : null;
+    }
+    run.slots = part.spec.slots ?? {};
+    run.cloud = t3Cloud(run, part);
+    run.axes = t3Axes(run, part);
+    const cn = run.cloud.length / 3;
+    run.centroid = [0, 0, 0];
+    for (let i = 0; i < cn; i++) for (let c = 0; c < 3; c++) run.centroid[c] += run.cloud[3 * i + c] / Math.max(1, cn);
+    return run;
+  });
+  const layers = data.layers.map((layer, index) => {
+    const parts = Int32Array.from(layer.parts);
+    const local = new Map();
+    parts.forEach((global, at) => local.set(global, at));
+    const planar = t3Unpack(data.planes && data.planes[layer.name], false);
+    const dynamic = Int32Array.from((data.dynamic && data.dynamic[layer.name]) ?? []);
+    const free = Int32Array.from((data.free && data.free[layer.name]) ?? []);
+    const framed = t3Unpack(data.framed && data.framed[layer.name], true);
+    const groupPairs = [];
+    const raw = (data.groupPairs && data.groupPairs[layer.name]) ?? [];
+    const members = new Map();
+    for (const global of parts) {
+      const g = runs[global].group;
+      if (!members.has(g)) members.set(g, []);
+      members.get(g).push(global);
+    }
+    for (let p = 0; p < raw.length; p += 6) groupPairs.push({ a: Int32Array.from(members.get(raw[p]) ?? []), b: Int32Array.from(members.get(raw[p + 1]) ?? []), frame: raw[p + 2], n: [raw[p + 3], raw[p + 4], raw[p + 5]], boxA: new Float64Array(4), boxB: new Float64Array(4) });
+    const looseAt = new Uint8Array(parts.length);
+    for (const global of free) looseAt[local.get(global)] = 1;
+    return { index, name: layer.name, parts, local, rest: Int32Array.from(layer.rest ?? layer.parts), planar, framed, groupPairs, dynamic, free, looseAt, warm: new Map() };
+  });
+  return { P, data, unit, groups: data.groups, runs, layers };
+}
+
+function t3Frame(run) {
+  const count = run.roles.length;
+  return { d: new Array(count).fill(""), q: new Int32Array(count), w: new Float64Array(count).fill(-1), t: new Array(count).fill(""), o: new Float64Array(count).fill(1), box: new Float64Array(4), hull: new Float64Array(64), hullN: 0, cx: new Float64Array(count), cy: new Float64Array(count), quads: null, quadN: 0 };
+}
+
+const t3Buf = { a: new Float64Array(1024), b: new Float64Array(1024), c: new Float64Array(1024) };
+
+function t3Scratch(name, size) {
+  if (t3Buf[name].length < size) t3Buf[name] = new Float64Array(size * 2);
+  return t3Buf[name];
+}
+
+function t3SetHull(f, buf, count) {
+  const hull = t3Grow(f, "hull", 2 * count, Float64Array);
+  for (let i = 0; i < 2 * count; i++) hull[i] = buf[i];
+  f.hullN = count;
+}
+
+function t3Faded(f, run, prefix, lines, count) {
+  if (!f.fade) f.fade = {};
+  const detail = t3State.detail;
+  if (detail < 1) for (let i = 0; i < count; i++) lines.alpha[i] *= detail;
+  if (detail < 0.01) count = 0;
+  f.fade[prefix] = { key: lines.key.slice(0, count), alpha: lines.alpha.slice(0, count) };
+  const slots = run.slots[prefix === "v" ? "bevel" : "ribs"] ?? 6;
+  const levels = run._levels ?? (run._levels = new Array(T3_LEVELS + 1));
+  for (let l = 0; l <= T3_LEVELS; l++) levels[l] = "";
+  for (let i = 0; i < count; i++) {
+    const alpha = lines.alpha[i];
+    const level = Math.min(T3_LEVELS, Math.round(alpha * T3_LEVELS));
+    if (level <= 0) continue;
+    levels[level] += lines.d[i];
+  }
+  const present = [];
+  for (let l = T3_LEVELS; l >= 1; l--) if (levels[l]) present.push([l, levels[l]]);
+  while (present.length > slots) {
+    let best = 1;
+    let gap = Infinity;
+    for (let i = 1; i < present.length; i++) {
+      const g = present[i - 1][0] - present[i][0];
+      if (g < gap) {
+        gap = g;
+        best = i;
+      }
+    }
+    const [a, da] = present[best - 1];
+    const [b, db] = present[best];
+    present.splice(best - 1, 2, [(a + b) / 2, da + db]);
+  }
+  for (let j = 0; j < slots; j++) {
+    const role = run.role[`${prefix}${j}`];
+    if (role === undefined) continue;
+    if (j < present.length) {
+      f.d[role] = present[j][1];
+      f.o[role] = present[j][0] / T3_LEVELS;
+    } else {
+      f.d[role] = "";
+      f.o[role] = 0;
+    }
+  }
+  return present.length;
+}
+
+const t3Lines = { d: [], alpha: [], key: [] };
+const t3None = { d: [], alpha: [], key: [] };
+
+function t3EmitPrism(run, cam, f) {
+  const n = run.n;
+  const m = cam.m;
+  const ox = cam.ox;
+  const oy = cam.oy;
+  const V = cam.V;
+  const L = cam.L;
+  const lo = run.lo;
+  const hi = run.hi;
+  const N3 = run.N3;
+  const bot = t3Scratch("a", 2 * n);
+  const top = t3Scratch("b", 2 * n);
+  for (let i = 0; i < n; i++) {
+    const a = 3 * i;
+    bot[2 * i] = ox + m[0] * lo[a] + m[1] * lo[a + 1] + m[2] * lo[a + 2];
+    bot[2 * i + 1] = oy + m[3] * lo[a] + m[4] * lo[a + 1] + m[5] * lo[a + 2];
+    top[2 * i] = ox + m[0] * hi[a] + m[1] * hi[a + 1] + m[2] * hi[a + 2];
+    top[2 * i + 1] = oy + m[3] * hi[a] + m[4] * hi[a + 1] + m[5] * hi[a + 2];
+  }
+  const F = run.F;
+  const aV = F.a[0] * V[0] + F.a[1] * V[1] + F.a[2] * V[2];
+  const near = aV >= 0 ? top : bot;
+  const far = aV >= 0 ? bot : top;
+  const facing = run._facing ?? (run._facing = new Float64Array(n));
+  for (let i = 0; i < n; i++) facing[i] = N3[3 * i] * V[0] + N3[3 * i + 1] * V[1] + N3[3 * i + 2] * V[2];
+  const on = (i) => facing[((i % n) + n) % n] > 1e-9;
+  let i0 = -1;
+  for (let i = 0; i < n; i++)
+    if (on(i) && !on(i - 1)) {
+      i0 = i;
+      break;
+    }
+  const sil = t3Scratch("c", 4 * n + 8);
+  const silAt = run._silAt ?? (run._silAt = new Int32Array(2 * n + 4));
+  let count = 0;
+  let i1 = i0;
+  const nearSet = aV >= 0 ? hi : lo;
+  const farSet = aV >= 0 ? lo : hi;
+  if (i0 < 0) {
+    for (let i = 0; i < n; i++) {
+      sil[2 * count] = near[2 * i];
+      sil[2 * count + 1] = near[2 * i + 1];
+      silAt[count] = i;
+      count++;
+    }
+  } else {
+    while (on(i1)) i1++;
+    for (let j = i0; j <= i1; j++) {
+      const i = j % n;
+      sil[2 * count] = far[2 * i];
+      sil[2 * count + 1] = far[2 * i + 1];
+      silAt[count] = -1 - i;
+      count++;
+    }
+    for (let j = i1; j <= i0 + n; j++) {
+      const i = j % n;
+      sil[2 * count] = near[2 * i];
+      sil[2 * count + 1] = near[2 * i + 1];
+      silAt[count] = i;
+      count++;
+    }
+    if (count > 2 && Math.abs(sil[0] - sil[2 * count - 2]) < 1e-9 && Math.abs(sil[1] - sil[2 * count - 1]) < 1e-9) count--;
+  }
+  const outline = t3Path(sil, count, true);
+  f.d[run.role.fill] = outline;
+  if (run.cut) {
+    const inPlane = (index) => {
+      const at = silAt[index];
+      const set = at < 0 ? farSet : nearSet;
+      const v = at < 0 ? -1 - at : at;
+      return run.cut.some((cut) => Math.abs(cut.n[0] * set[3 * v] + cut.n[1] * set[3 * v + 1] + cut.n[2] * set[3 * v + 2] - cut.d) < 1e-3);
+    };
+    const flags = new Uint8Array(count);
+    const onSame = (i, j) => {
+      const at = (index) => {
+        const a = silAt[index];
+        const set = a < 0 ? farSet : nearSet;
+        const v = a < 0 ? -1 - a : a;
+        return [set[3 * v], set[3 * v + 1], set[3 * v + 2]];
+      };
+      const p = at(i);
+      const q = at(j);
+      return run.cut.some((cut) => Math.abs(cut.n[0] * p[0] + cut.n[1] * p[1] + cut.n[2] * p[2] - cut.d) < 1e-3 && Math.abs(cut.n[0] * q[0] + cut.n[1] * q[1] + cut.n[2] * q[2] - cut.d) < 1e-3);
+    };
+    for (let j = 0; j < count; j++) flags[j] = inPlane(j) && onSame(j, (j + 1) % count) ? 1 : 0;
+    f.d[run.role.edge] = t3Broken(sil, count, flags);
+  } else f.d[run.role.edge] = outline;
+  t3Box(sil, count, f.box);
+  t3SetHull(f, sil, count);
+  const quad = new Float64Array(8);
+  for (let i = 0; i < n; i++) {
+    const role = run.role[`f${i}`];
+    if (!(facing[i] > 1e-6)) {
+      f.d[role] = "";
+      continue;
+    }
+    const j = (i + 1) % n;
+    quad[0] = top[2 * i];
+    quad[1] = top[2 * i + 1];
+    quad[2] = top[2 * j];
+    quad[3] = top[2 * j + 1];
+    quad[4] = bot[2 * j];
+    quad[5] = bot[2 * j + 1];
+    quad[6] = bot[2 * i];
+    quad[7] = bot[2 * i + 1];
+    f.d[role] = t3Path(quad, 4, true);
+    let score;
+    if (run.up) {
+      score = (run.nx[i] * cam.lx + run.ny[i] * cam.ly + 1) / 2;
+      f.q[role] = t3Level(score, T3_EB);
+    } else {
+      score = N3[3 * i] * L[0] + N3[3 * i + 1] * L[1] + N3[3 * i + 2] * L[2];
+      f.q[role] = t3Level(score, T3_LB);
+    }
+    const e1 = Math.hypot(quad[2] - quad[0], quad[3] - quad[1]);
+    const e2 = Math.hypot(quad[6] - quad[0], quad[7] - quad[1]);
+    const area = Math.abs((quad[2] - quad[0]) * (quad[7] - quad[1]) - (quad[3] - quad[1]) * (quad[6] - quad[0]));
+    const wide = area / (Math.max(e1, e2) || 1);
+    f.w[role] = wide < 0.4 ? Math.round(wide * 100) / 100 : -1;
+  }
+  if (run.up) {
+    const z = run.s1;
+    f.t[run.role.top] = t3Arena.on ? t3Matrix(f, run.role.top, m[0], m[3], m[1], m[4], ox + m[2] * z, oy + m[5] * z) : `matrix(${t3Fix(m[0], 1e5)} ${t3Fix(m[3], 1e5)} ${t3Fix(m[1], 1e5)} ${t3Fix(m[4], 1e5)} ${t3Fix(ox + m[2] * z, 100)} ${t3Fix(oy + m[5] * z, 100)})`;
+  } else {
+    for (let side = 0; side < 2; side++) {
+      const role = run.role[`f${n + side}`];
+      const sign = side ? 1 : -1;
+      const face = sign * aV;
+      if (!(face > 1e-6)) {
+        f.d[role] = "";
+        continue;
+      }
+      const ring = side ? top : bot;
+      f.d[role] = t3Path(ring, n, true);
+      f.q[role] = t3Level(sign * (F.a[0] * L[0] + F.a[1] * L[1] + F.a[2] * L[2]), T3_LB);
+      let minor = Infinity;
+      let x0 = Infinity;
+      let x1 = -Infinity;
+      for (let i = 0; i < n; i++) {
+        const j = (i + 1) % n;
+        const ex = ring[2 * j] - ring[2 * i];
+        const ey = ring[2 * j + 1] - ring[2 * i + 1];
+        const l = Math.hypot(ex, ey);
+        if (l < 1e-9) continue;
+        let lo2 = Infinity;
+        let hi2 = -Infinity;
+        for (let q = 0; q < n; q++) {
+          const v = ((ring[2 * q] - ring[2 * i]) * ey - (ring[2 * q + 1] - ring[2 * i + 1]) * ex) / l;
+          if (v < lo2) lo2 = v;
+          if (v > hi2) hi2 = v;
+        }
+        minor = Math.min(minor, hi2 - lo2);
+        x0 = Math.min(x0, lo2);
+        x1 = Math.max(x1, hi2);
+      }
+      f.w[role] = minor < 0.4 ? Math.round(minor * 100) / 100 : -1;
+    }
+  }
+  if (run.role.crease !== undefined) {
+    let crease = "";
+    if (run.up) {
+      if (i0 >= 0) {
+        const buf = t3Scratch("a", 0);
+        let c = 0;
+        const rim = t3Scratch("c", 2 * n + 4);
+        for (let j = i0; j <= i1; j++) {
+          const i = j % n;
+          rim[2 * c] = top[2 * i];
+          rim[2 * c + 1] = top[2 * i + 1];
+          c++;
+        }
+        crease = t3Path(rim, c, false);
+        void buf;
+      }
+    } else {
+      const capOn = [-aV > 1e-6, aV > 1e-6];
+      const seg = new Float64Array(4);
+      for (let i = 0; i < n; i++) {
+        const p = (i - 1 + n) % n;
+        if (run.sharp[i] && facing[i] > 1e-6 && facing[p] > 1e-6) {
+          seg[0] = bot[2 * i];
+          seg[1] = bot[2 * i + 1];
+          seg[2] = top[2 * i];
+          seg[3] = top[2 * i + 1];
+          crease += t3Path(seg, 2, false);
+        }
+      }
+      for (let side = 0; side < 2; side++) {
+        if (!capOn[side] || i0 < 0) continue;
+        const ring = side ? top : bot;
+        const rim = t3Scratch("c", 2 * n + 4);
+        let c = 0;
+        for (let j = i0; j <= i1; j++) {
+          const i = j % n;
+          rim[2 * c] = ring[2 * i];
+          rim[2 * c + 1] = ring[2 * i + 1];
+          c++;
+        }
+        crease += t3Path(rim, c, false);
+      }
+    }
+    f.d[run.role.crease] = crease;
+  }
+  if (run.inset && run.role.v0 !== undefined && t3State.detail < 0.01) f.levels = t3Faded(f, run, "v", t3None, 0);
+  else if (run.inset && run.role.v0 !== undefined) {
+    const lines = t3Lines;
+    lines.d.length = 0;
+    lines.alpha.length = 0;
+  lines.key.length = 0;
+    lines.key.length = 0;
+    const capSide = aV >= 0 ? 1 : 0;
+    const s = capSide ? run.s1 : run.s0;
+    const capAlpha = run.up ? 1 : t3Step(0.02, 0.2, Math.abs(aV));
+    const ins = t3Scratch("c", 2 * n);
+    for (let i = 0; i < n; i++) {
+      const x = run.inset[2 * i];
+      const y = run.inset[2 * i + 1];
+      const px = F.o[0] + F.a[0] * s + F.u[0] * x + F.v[0] * y;
+      const py = F.o[1] + F.a[1] * s + F.u[1] * x + F.v[1] * y;
+      const pz = F.o[2] + F.a[2] * s + F.u[2] * x + F.v[2] * y;
+      ins[2 * i] = ox + m[0] * px + m[1] * py + m[2] * pz;
+      ins[2 * i + 1] = oy + m[3] * px + m[4] * py + m[5] * pz;
+    }
+    const rim = capSide ? top : bot;
+    const seg = new Float64Array(4);
+    for (let i = 0; i < n; i++) {
+      const p = (i - 1 + n) % n;
+      const ai = capAlpha * t3Step(0, 0.14, facing[i]);
+      const ap = capAlpha * t3Step(0, 0.14, facing[p]);
+      if (ai > 0.01) {
+        const j = (i + 1) % n;
+        seg[0] = ins[2 * i];
+        seg[1] = ins[2 * i + 1];
+        seg[2] = ins[2 * j];
+        seg[3] = ins[2 * j + 1];
+        lines.d.push(t3Path(seg, 2, false));
+        lines.alpha.push(ai);
+        lines.key.push(2 * i);
+      }
+      const corner = ai * (1 - ap) + ap * (1 - ai);
+      if (corner > 0.01) {
+        seg[0] = ins[2 * i];
+        seg[1] = ins[2 * i + 1];
+        seg[2] = rim[2 * i];
+        seg[3] = rim[2 * i + 1];
+        lines.d.push(t3Path(seg, 2, false));
+        lines.alpha.push(corner);
+        lines.key.push(2 * i + 1);
+      }
+    }
+    f.levels = t3Faded(f, run, "v", lines, lines.d.length);
+  }
+  if (run.seams && run.role.inner !== undefined) {
+    let inner = "";
+    if (i0 >= 0) {
+      const rim = t3Scratch("c", 2 * n + 4);
+      for (const s of run.seams) {
+        let c = 0;
+        for (let j = i0; j <= i1; j++) {
+          const i = j % n;
+          const x = run.ring[2 * i];
+          const y = run.ring[2 * i + 1];
+          const px = F.o[0] + F.a[0] * s + F.u[0] * x + F.v[0] * y;
+          const py = F.o[1] + F.a[1] * s + F.u[1] * x + F.v[1] * y;
+          const pz = F.o[2] + F.a[2] * s + F.u[2] * x + F.v[2] * y;
+          rim[2 * c] = ox + m[0] * px + m[1] * py + m[2] * pz;
+          rim[2 * c + 1] = oy + m[3] * px + m[4] * py + m[5] * pz;
+          c++;
+        }
+        inner += t3Path(rim, c, false);
+      }
+    }
+    f.d[run.role.inner] = inner;
+  }
+}
+
+function t3Broken(buf, count, skip) {
+  let start = -1;
+  for (let j = 0; j < count; j++)
+    if (skip[(j - 1 + count) % count] && !skip[j]) {
+      start = j;
+      break;
+    }
+  if (start < 0) return skip[0] ? "" : t3Path(buf, count, true);
+  let out = "";
+  let run = [];
+  for (let step = 0; step < count; step++) {
+    const j = (start + step) % count;
+    if (skip[j]) {
+      if (run.length) {
+        run.push((j + 0) % count);
+        out += t3PathOf(run.map((i) => [buf[2 * i], buf[2 * i + 1]]), false);
+        run = [];
+      }
+      continue;
+    }
+    run.push(j);
+  }
+  if (run.length) {
+    run.push((start + count) % count);
+    out += t3PathOf(run.map((i) => [buf[2 * i], buf[2 * i + 1]]), false);
+  }
+  return out;
+}
+
+function t3EmitPlanes(run, cam, f, sx = 0, sy = 0) {
+  const m = cam.m;
+  const V = cam.V;
+  for (let j = 0; j < run.planes.length; j++) {
+    const plane = run.planes[j];
+    const role = run.role[`plane${j}`];
+    const o = plane.o;
+    const X = cam.ox - sx + m[0] * o[0] + m[1] * o[1] + m[2] * o[2];
+    const Y = cam.oy - sy + m[3] * o[0] + m[4] * o[1] + m[5] * o[2];
+    const facing = plane.n[0] * V[0] + plane.n[1] * V[1] + plane.n[2] * V[2];
+    const alpha = Math.round(t3Step(plane.fade[0], plane.fade[1], facing) * 100) / 100;
+    f.o[role] = alpha;
+    if (plane.billboard) {
+      f.t[role] = t3Arena.on ? t3Matrix(f, role, 1, 0, 0, 1, X, Y) : `translate(${t3Num(X)} ${t3Num(Y)})`;
+      continue;
+    }
+    const u = plane.u;
+    const v = plane.v;
+    const a = m[0] * u[0] + m[1] * u[1] + m[2] * u[2];
+    const b = m[3] * u[0] + m[4] * u[1] + m[5] * u[2];
+    const c = m[0] * v[0] + m[1] * v[1] + m[2] * v[2];
+    const d = m[3] * v[0] + m[4] * v[1] + m[5] * v[2];
+    f.t[role] = t3Arena.on ? t3Matrix(f, role, a, b, c, d, X, Y) : `matrix(${t3Fix(a, 1e5)} ${t3Fix(b, 1e5)} ${t3Fix(c, 1e5)} ${t3Fix(d, 1e5)} ${t3Fix(X, 100)} ${t3Fix(Y, 100)})`;
+  }
+}
+
+function t3EmitDots(run, cam, f, sx = 0, sy = 0) {
+  const m = cam.m;
+  const V = cam.V;
+  for (let j = 0; j < run.dots.length; j++) {
+    const dot = run.dots[j];
+    const role = run.role[`c${j}`];
+    const p = dot.p;
+    f.cx[role] = cam.ox - sx + m[0] * p[0] + m[1] * p[1] + m[2] * p[2];
+    f.cy[role] = cam.oy - sy + m[3] * p[0] + m[4] * p[1] + m[5] * p[2];
+    const alpha = (dot.n ? t3Step(dot.fade[0], dot.fade[1], dot.n[0] * V[0] + dot.n[1] * V[1] + dot.n[2] * V[2]) : 1) * t3State.detail;
+    f.o[role] = alpha < 0.005 ? 0 : Math.round(alpha * 100) / 100;
+  }
+}
+
+function t3EmitFixed(run, cam, f) {
+  const a = run.anchor;
+  const m = cam.m;
+  const X = cam.ox + m[0] * a[0] + m[1] * a[1] + m[2] * a[2];
+  const Y = cam.oy + m[3] * a[0] + m[4] * a[1] + m[5] * a[2];
+  const dx = X - run.home[0];
+  const dy = Y - run.home[1];
+  const rx = Math.round(dx * 100) / 100;
+  const ry = Math.round(dy * 100) / 100;
+  f.t[run.role.move] = t3Arena.on ? t3Matrix(f, run.role.move, 1, 0, 0, 1, rx, ry) : rx || ry ? `translate(${t3Num(rx)} ${t3Num(ry)})` : "";
+  f.shiftX = rx;
+  f.shiftY = ry;
+  const b = run.box0;
+  f.box[0] = b[0] + rx;
+  f.box[1] = b[1] + ry;
+  f.box[2] = b[2] + rx;
+  f.box[3] = b[3] + ry;
+  const count = run.hull0.length / 2;
+  const hull = t3Grow(f, "hull", 2 * count, Float64Array);
+  for (let i = 0; i < count; i++) {
+    hull[2 * i] = run.hull0[2 * i] + rx;
+    hull[2 * i + 1] = run.hull0[2 * i + 1] + ry;
+  }
+  f.hullN = count;
+  if (run.ribs && run.F) t3EmitRibs(run, cam, f, run.F, run.ribs, rx, ry);
+  t3EmitPlanes(run, cam, f, rx, ry);
+  t3EmitDots(run, cam, f, rx, ry);
+}
+
+function t3EmitRibs(run, cam, f, F, ribs, sx, sy) {
+  if (t3State.detail < 0.01) {
+    f.levels = t3Faded(f, run, "r", t3None, 0);
+    return;
+  }
+  const m = cam.m;
+  const V = cam.V;
+  const lines = t3Lines;
+  lines.d.length = 0;
+  lines.alpha.length = 0;
+  lines.key.length = 0;
+  const { s0, s1, count, phase = 0, twist = 0, fade = [0.1, 0.55] } = ribs;
+  const r0 = ribs.r0 ?? ribs.r;
+  const r1 = ribs.r1 ?? r0;
+  const slope = (r1 - r0) / (s1 - s0 || 1);
+  const norm = Math.hypot(1, slope);
+  const aV = F.a[0] * V[0] + F.a[1] * V[1] + F.a[2] * V[2];
+  const uV = F.u[0] * V[0] + F.u[1] * V[1] + F.u[2] * V[2];
+  const vV = F.v[0] * V[0] + F.v[1] * V[1] + F.v[2] * V[2];
+  const seg = new Float64Array(4);
+  const at = (s, r, t, out, index) => {
+    const c = Math.cos(t);
+    const n = Math.sin(t);
+    const px = F.o[0] + F.a[0] * s + r * (c * F.u[0] + n * F.v[0]);
+    const py = F.o[1] + F.a[1] * s + r * (c * F.u[1] + n * F.v[1]);
+    const pz = F.o[2] + F.a[2] * s + r * (c * F.u[2] + n * F.v[2]);
+    out[index] = cam.ox - sx + m[0] * px + m[1] * py + m[2] * pz;
+    out[index + 1] = cam.oy - sy + m[3] * px + m[4] * py + m[5] * pz;
+  };
+  for (let i = 0; i < count; i++) {
+    const t = phase + (i / count) * T3_TAU;
+    const tm = t + twist / 2;
+    const facing = (Math.cos(tm) * uV + Math.sin(tm) * vV - slope * aV) / norm;
+    const alpha = t3Step(fade[0], fade[1], facing);
+    if (alpha * T3_LEVELS < 0.5) continue;
+    at(s0, r0, t, seg, 0);
+    at(s1, r1, t + twist, seg, 2);
+    lines.d.push(t3Path(seg, 2, false));
+    lines.alpha.push(alpha);
+    lines.key.push(i);
+  }
+  f.levels = t3Faded(f, run, "r", lines, lines.d.length);
+}
+
+
+function t3Geo(F, cam) {
+  const m = cam.m;
+  const V = cam.V;
+  const L = cam.L;
+  const dot = (a, b) => a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
+  const lin = (w) => [m[0] * w[0] + m[1] * w[1] + m[2] * w[2], m[3] * w[0] + m[4] * w[1] + m[5] * w[2]];
+  const O = [cam.ox + m[0] * F.o[0] + m[1] * F.o[1] + m[2] * F.o[2], cam.oy + m[3] * F.o[0] + m[4] * F.o[1] + m[5] * F.o[2]];
+  const aV = dot(F.a, V);
+  const uV = dot(F.u, V);
+  const vV = dot(F.v, V);
+  const aL = dot(F.a, L);
+  const uL = dot(F.u, L);
+  const vL = dot(F.v, L);
+  return { O, SA: lin(F.a), SU: lin(F.u), SV: lin(F.v), aV, aL, view: { a: aV, flat: Math.hypot(uV, vV), phi: Math.atan2(vV, uV) }, light: { a: aL, flat: Math.hypot(uL, vL), phi: Math.atan2(vL, uL) } };
+}
+
+function t3At(geo, s, r, t, buf, index) {
+  const c = Math.cos(t);
+  const n = Math.sin(t);
+  buf[index] = geo.O[0] + s * geo.SA[0] + r * (c * geo.SU[0] + n * geo.SV[0]);
+  buf[index + 1] = geo.O[1] + s * geo.SA[1] + r * (c * geo.SU[1] + n * geo.SV[1]);
+}
+
+function t3Arcs(nr, na, view, light) {
+  const cuts = [];
+  if (Math.abs(nr) > 1e-9) {
+    const visibleCut = -(na * view.a) / (nr * view.flat);
+    if (visibleCut > -1 && visibleCut < 1) {
+      const d = Math.acos(visibleCut);
+      cuts.push(view.phi - d, view.phi + d);
+    }
+    for (let b = 0; b < T3_LB.length; b++) {
+      const c = (T3_LB[b] - na * light.a) / (nr * light.flat);
+      if (c > -1 && c < 1) {
+        const d = Math.acos(c);
+        cuts.push(light.phi - d, light.phi + d);
+      }
+    }
+  }
+  for (let i = 0; i < cuts.length; i++) {
+    const w = ((cuts[i] % T3_TAU) + T3_TAU) % T3_TAU;
+    cuts[i] = Math.round(w * 1e9) / 1e9;
+  }
+  cuts.sort((a, b) => a - b);
+  const sorted = [];
+  for (let i = 0; i < cuts.length; i++) if (!sorted.length || cuts[i] !== sorted[sorted.length - 1]) sorted.push(cuts[i]);
+  const label = (angle) => {
+    const facing = nr * view.flat * Math.cos(angle - view.phi) + na * view.a;
+    if (facing <= 1e-9) return -1;
+    const score = nr * light.flat * Math.cos(angle - light.phi) + na * light.a;
+    let tone = 0;
+    while (tone < T3_LB.length && score >= T3_LB[tone]) tone++;
+    return tone;
+  };
+  if (!sorted.length) {
+    const tone = label(0);
+    return tone < 0 ? [] : [{ tone, from: 0, to: T3_TAU, full: true }];
+  }
+  const merged = [];
+  for (let index = 0; index < sorted.length; index++) {
+    const from = sorted[index];
+    const to = index + 1 < sorted.length ? sorted[index + 1] : sorted[0] + T3_TAU;
+    const tone = label((from + to) / 2);
+    const last = merged[merged.length - 1];
+    if (last && last.tone === tone && Math.abs(last.to - from) < 1e-9) last.to = to;
+    else merged.push({ tone, from, to });
+  }
+  if (merged.length > 1 && merged[0].tone === merged[merged.length - 1].tone && Math.abs(merged[merged.length - 1].to - T3_TAU - merged[0].from) < 1e-9) {
+    const last = merged.pop();
+    merged[0].from = last.from - T3_TAU;
+  }
+  const out = [];
+  for (const arc of merged) if (arc.tone >= 0) out.push(arc);
+  return out;
+}
+
+function t3Strip(geo, s0, r0, s1, r1, from, to, step) {
+  const count = Math.max(1, Math.ceil((to - from) / step));
+  const buf = t3Scratch("c", 4 * count + 8);
+  for (let j = 0; j <= count; j++) {
+    const t = from + ((to - from) * j) / count;
+    t3At(geo, s0, r0, t, buf, 2 * j);
+    t3At(geo, s1, r1, t, buf, 2 * (2 * count + 1 - j));
+  }
+  return t3Path(t3Oriented(buf, 2 * count + 2), 2 * count + 2, true);
+}
+
+function t3Oriented(buf, count) {
+  let area = 0;
+  for (let i = 0; i < count; i++) {
+    const j = (i + 1) % count;
+    area += buf[2 * i] * buf[2 * j + 1] - buf[2 * j] * buf[2 * i + 1];
+  }
+  if (area >= 0) return buf;
+  for (let i = 0, j = count - 1; i < j; i++, j--) {
+    const x = buf[2 * i];
+    const y = buf[2 * i + 1];
+    buf[2 * i] = buf[2 * j];
+    buf[2 * i + 1] = buf[2 * j + 1];
+    buf[2 * j] = x;
+    buf[2 * j + 1] = y;
+  }
+  return buf;
+}
+
+function t3Hull(points) {
+  const sorted = points.slice().sort((a, b) => a[0] - b[0] || a[1] - b[1]);
+  if (sorted.length < 3) return sorted;
+  const cross = (o, a, b) => (a[0] - o[0]) * (b[1] - o[1]) - (a[1] - o[1]) * (b[0] - o[0]);
+  const lower = [];
+  for (const p of sorted) {
+    while (lower.length >= 2 && cross(lower[lower.length - 2], lower[lower.length - 1], p) <= 1e-12) lower.pop();
+    lower.push(p);
+  }
+  const upper = [];
+  for (let i = sorted.length - 1; i >= 0; i--) {
+    const p = sorted[i];
+    while (upper.length >= 2 && cross(upper[upper.length - 2], upper[upper.length - 1], p) <= 1e-12) upper.pop();
+    upper.push(p);
+  }
+  return lower.slice(0, -1).concat(upper.slice(0, -1));
+}
+
+function t3PathOf(points, closed) {
+  if (points.length < 2) return "";
+  if (t3Arena.on) return t3Token((i) => points[i >> 1][i & 1], points.length, closed);
+  let s = "M" + t3Num(points[0][0]) + " " + t3Num(points[0][1]);
+  for (let i = 1; i < points.length; i++) s += "L" + t3Num(points[i][0]) + " " + t3Num(points[i][1]);
+  return closed ? s + "Z" : s;
+}
+
+function t3Basis(w) {
+  const helper = Math.abs(w[2]) > 0.9 ? [1, 0, 0] : [0, 0, 1];
+  const u = t3Unit([helper[1] * w[2] - helper[2] * w[1], helper[2] * w[0] - helper[0] * w[2], helper[0] * w[1] - helper[1] * w[0]]);
+  return [u, [w[1] * u[2] - w[2] * u[1], w[2] * u[0] - w[0] * u[2], w[0] * u[1] - w[1] * u[0]]];
+}
+
+function t3Meet(A, a, B, b) {
+  const ab = A[0] * B[0] + A[1] * B[1] + A[2] * B[2];
+  const det = 1 - ab * ab;
+  if (det < 1e-12) return [];
+  const alpha = (a - b * ab) / det;
+  const beta = (b - a * ab) / det;
+  const base = [A[0] * alpha + B[0] * beta, A[1] * alpha + B[1] * beta, A[2] * alpha + B[2] * beta];
+  const rest = 1 - (base[0] * base[0] + base[1] * base[1] + base[2] * base[2]);
+  if (rest < 0) return [];
+  const cr = [A[1] * B[2] - A[2] * B[1], A[2] * B[0] - A[0] * B[2], A[0] * B[1] - A[1] * B[0]];
+  const k = Math.sqrt(rest / det);
+  return [
+    [base[0] + cr[0] * k, base[1] + cr[1] * k, base[2] + cr[2] * k],
+    [base[0] - cr[0] * k, base[1] - cr[1] * k, base[2] - cr[2] * k],
+  ];
+}
+
+const t3Tables = new Map();
+function t3Table(count) {
+  let table = t3Tables.get(count);
+  if (!table) {
+    table = new Float64Array(2 * count);
+    for (let j = 0; j < count; j++) {
+      table[2 * j] = Math.cos((j / count) * T3_TAU);
+      table[2 * j + 1] = Math.sin((j / count) * T3_TAU);
+    }
+    t3Tables.set(count, table);
+  }
+  return table;
+}
+
+function t3Dome(cam, C, e, r, count, sheets) {
+  const m = cam.m;
+  const V = cam.V;
+  const L = cam.L;
+  const Sx = cam.ox + m[0] * C[0] + m[1] * C[1] + m[2] * C[2];
+  const Sy = cam.oy + m[3] * C[0] + m[4] * C[1] + m[5] * C[2];
+  const flat = (n) => [Sx + r * (m[0] * n[0] + m[1] * n[1] + m[2] * n[2]), Sy + r * (m[3] * n[0] + m[4] * n[1] + m[5] * n[2])];
+  const dot = (a, b) => a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
+  const table = t3Table(count);
+  const circle = (W, value, keep) => {
+    const [U, Q] = t3Basis(W);
+    const rad = Math.sqrt(Math.max(0, 1 - value * value));
+    const out = [];
+    for (let j = 0; j < count; j++) {
+      const cs = table[2 * j] * rad;
+      const sn = table[2 * j + 1] * rad;
+      const n = [W[0] * value + U[0] * cs + Q[0] * sn, W[1] * value + U[1] * cs + Q[1] * sn, W[2] * value + U[2] * cs + Q[2] * sn];
+      if (keep(n)) out.push(n);
+    }
+    return out;
+  };
+  const rim = circle(V, 0, (n) => dot(n, e) >= -1e-9).map((n) => [flat(n), dot(n, L)]);
+  const base = circle(e, 0, (n) => dot(n, V) >= -1e-9).map((n) => [flat(n), dot(n, L)]);
+  const corners = t3Meet(V, 0, e, 0).map((n) => [flat(n), dot(n, L)]);
+  for (let tone = 0; tone < 5; tone++) {
+    const tau = tone === 0 ? -Infinity : T3_LB[tone - 1];
+    const candidates = [];
+    for (const list of [rim, base, corners]) for (const [p, lit] of list) if (lit >= tau - 1e-9) candidates.push(p);
+    if (tone > 0) {
+      for (const n of circle(L, tau, (n) => dot(n, V) >= -1e-9 && dot(n, e) >= -1e-9)) candidates.push(flat(n));
+      for (const n of t3Meet(L, tau, V, 0)) if (dot(n, e) >= -1e-9) candidates.push(flat(n));
+      for (const n of t3Meet(L, tau, e, 0)) if (dot(n, V) >= -1e-9) candidates.push(flat(n));
+    }
+    if (candidates.length < 3) continue;
+    const region = t3Hull(candidates);
+    if (region.length >= 3) sheets[tone] += t3PathOf(region, true);
+  }
+}
+
+function t3BoxOf(pts, box) {
+  let x0 = Infinity;
+  let y0 = Infinity;
+  let x1 = -Infinity;
+  let y1 = -Infinity;
+  for (const [x, y] of pts) {
+    if (x < x0) x0 = x;
+    if (x > x1) x1 = x;
+    if (y < y0) y0 = y;
+    if (y > y1) y1 = y;
+  }
+  box[0] = x0;
+  box[1] = y0;
+  box[2] = x1;
+  box[3] = y1;
+}
+
+function t3Thin(points, most) {
+  if (points.length <= most) return points;
+  const n = points.length;
+  const picks = [];
+  for (let i = 0; i < most; i++) picks.push(Math.floor((i * n) / most));
+  const thin = picks.map((i) => points[i]);
+  let err = 0;
+  for (let j = 0; j < most; j++) {
+    const a = thin[j];
+    const b = thin[(j + 1) % most];
+    const dx = b[0] - a[0];
+    const dy = b[1] - a[1];
+    const l = Math.hypot(dx, dy) || 1;
+    const end = j + 1 < most ? picks[j + 1] : picks[0] + n;
+    for (let i = picks[j] + 1; i < end; i++) {
+      const p = points[i % n];
+      const out = ((p[0] - a[0]) * dy - (p[1] - a[1]) * dx) / l;
+      if (Math.abs(out) > err) err = Math.abs(out);
+    }
+  }
+  return t3Grown(thin, err);
+}
+
+function t3Grown(poly, by) {
+  if (!(by > 0)) return poly;
+  let area = 0;
+  for (let i = 0; i < poly.length; i++) {
+    const a = poly[i];
+    const b = poly[(i + 1) % poly.length];
+    area += a[0] * b[1] - b[0] * a[1];
+  }
+  const sign = area >= 0 ? 1 : -1;
+  const n = poly.length;
+  const normals = poly.map((a, i) => {
+    const b = poly[(i + 1) % n];
+    const l = Math.hypot(b[0] - a[0], b[1] - a[1]) || 1;
+    return [(sign * (b[1] - a[1])) / l, (-sign * (b[0] - a[0])) / l];
+  });
+  return poly.map((p, i) => {
+    const na = normals[(i - 1 + n) % n];
+    const nb = normals[i];
+    const mx = na[0] + nb[0];
+    const my = na[1] + nb[1];
+    const dd = (mx * mx + my * my) / 2 || 1;
+    return [p[0] + (mx * by) / dd, p[1] + (my * by) / dd];
+  });
+}
+
+function t3HullOut(f, points, most = 32) {
+  const thin = t3Thin(points, most);
+  const hull = t3Grow(f, "hull", 2 * thin.length, Float64Array);
+  for (let i = 0; i < thin.length; i++) {
+    hull[2 * i] = thin[i][0];
+    hull[2 * i + 1] = thin[i][1];
+  }
+  f.hullN = thin.length;
+}
+
+function t3SupportHull(geo, cam, components, dirs) {
+  const table = t3Table(dirs);
+  const pts = [];
+  const { O, SA, SU, SV } = geo;
+  for (let j = 0; j < dirs; j++) {
+    const dx = table[2 * j];
+    const dy = table[2 * j + 1];
+    const pa = SA[0] * dx + SA[1] * dy;
+    const pu = SU[0] * dx + SU[1] * dy;
+    const pv = SV[0] * dx + SV[1] * dy;
+    const w = Math.hypot(pu, pv);
+    let best = -Infinity;
+    let px = 0;
+    let py = 0;
+    for (let c = 0; c < components.length; c += 3) {
+      const kind = components[c];
+      const s = components[c + 1];
+      const r = components[c + 2];
+      if (kind === 0) {
+        const value = s * pa + r * w;
+        if (value > best) {
+          best = value;
+          const cs = w > 1e-12 ? pu / w : 1;
+          const sn = w > 1e-12 ? pv / w : 0;
+          px = O[0] + s * SA[0] + r * (cs * SU[0] + sn * SV[0]);
+          py = O[1] + s * SA[1] + r * (cs * SU[1] + sn * SV[1]);
+        }
+      } else {
+        const rk = r * cam.k;
+        const value = s * pa + rk;
+        if (value > best) {
+          best = value;
+          px = O[0] + s * SA[0] + rk * dx;
+          py = O[1] + s * SA[1] + rk * dy;
+        }
+      }
+    }
+    const last = pts[pts.length - 1];
+    if (!last || Math.abs(last[0] - px) + Math.abs(last[1] - py) > 0.02) pts.push([px, py]);
+  }
+  if (pts.length > 2) {
+    const a = pts[0];
+    const b = pts[pts.length - 1];
+    if (Math.abs(a[0] - b[0]) + Math.abs(a[1] - b[1]) <= 0.02) pts.pop();
+  }
+  return pts;
+}
+
+function t3ArcPoints(geo, s, r, from, to, k, out, cut = false) {
+  const count = Math.max(2, Math.ceil((Math.abs(to - from) * 48) / T3_TAU), Math.ceil((Math.abs(to - from) * Math.max(r, 1e-6) * k) / 1.5));
+  for (let j = 0; j <= count; j++) {
+    const t = from + ((to - from) * j) / count;
+    const c = Math.cos(t);
+    const n = Math.sin(t);
+    const p = [geo.O[0] + s * geo.SA[0] + r * (c * geo.SU[0] + n * geo.SV[0]), geo.O[1] + s * geo.SA[1] + r * (c * geo.SU[1] + n * geo.SV[1])];
+    if (cut) p.cut = true;
+    out.push(p);
+  }
+}
+
+function t3RoundOutline(run, geo, cam) {
+  const k = cam.k;
+  const { s0, s1, r0, r1, ends } = run;
+  const domes = (ends[0] === "dome" ? 1 : 0) + (ends[1] === "dome" ? 1 : 0);
+  if (domes === 2) {
+    const c0 = [geo.O[0] + s0 * geo.SA[0], geo.O[1] + s0 * geo.SA[1]];
+    const c1 = [geo.O[0] + s1 * geo.SA[0], geo.O[1] + s1 * geo.SA[1]];
+    const rk = r0 * k;
+    const dx = c1[0] - c0[0];
+    const dy = c1[1] - c0[1];
+    const l = Math.hypot(dx, dy);
+    const count = Math.max(24, Math.ceil((Math.PI * rk) / 1.5));
+    const out = [];
+    if (l < 1e-6) {
+      for (let j = 0; j < 2 * count; j++) {
+        const t = (j / (2 * count)) * T3_TAU;
+        out.push([c1[0] + rk * Math.cos(t), c1[1] + rk * Math.sin(t)]);
+      }
+      return out;
+    }
+    const beta = Math.atan2(dy, dx);
+    for (let j = 0; j <= count; j++) {
+      const t = beta - Math.PI / 2 + (Math.PI * j) / count;
+      out.push([c1[0] + rk * Math.cos(t), c1[1] + rk * Math.sin(t)]);
+    }
+    for (let j = 0; j <= count; j++) {
+      const t = beta + Math.PI / 2 + (Math.PI * j) / count;
+      out.push([c0[0] + rk * Math.cos(t), c0[1] + rk * Math.sin(t)]);
+    }
+    return out;
+  }
+  if (domes === 1) {
+    const pts = [];
+    for (const [end, s, r] of [[0, s0, r0], [1, s1, r1]]) {
+      t3ArcPoints(geo, s, r, 0, T3_TAU, k, pts);
+      if (ends[end] !== "dome") continue;
+      const sign = end ? 1 : -1;
+      const c = [geo.O[0] + s * geo.SA[0], geo.O[1] + s * geo.SA[1]];
+      const rk = r * k;
+      const beta = Math.atan2(sign * geo.SA[1], sign * geo.SA[0]);
+      const count = Math.max(24, Math.ceil((Math.PI * rk) / 1.5));
+      for (let j = 0; j <= count; j++) {
+        const t = beta - Math.PI / 2 + (Math.PI * j) / count;
+        pts.push([c[0] + rk * Math.cos(t), c[1] + rk * Math.sin(t)]);
+      }
+    }
+    return t3Hull(pts);
+  }
+  const view = geo.view;
+  const out = [];
+  let c;
+  if (view.flat < 1e-9) c = run.na * view.a > 0 ? -2 : 2;
+  else c = -(run.na * view.a) / (run.nr * view.flat);
+  if (c <= -1 || c >= 1) {
+    const side = c <= -1;
+    const capFirst = -geo.aV > 0;
+    const keepFirst = side ? !capFirst : capFirst;
+    const s = keepFirst ? s0 : s1;
+    const r = keepFirst ? r0 : r1;
+    t3ArcPoints(geo, s, r, 0, T3_TAU, k, out, run.cutS !== null && Math.abs(run.cutS - s) < 1e-6);
+    out.pop();
+    return out;
+  }
+  const d = Math.acos(c);
+  const lo = view.phi - d;
+  const hi = view.phi + d;
+  const cut0 = run.cutS !== null && Math.abs(run.cutS - s0) < 1e-6;
+  const cut1 = run.cutS !== null && Math.abs(run.cutS - s1) < 1e-6;
+  if (-geo.aV > 0) t3ArcPoints(geo, s0, r0, hi, lo + T3_TAU, k, out, cut0);
+  else t3ArcPoints(geo, s0, r0, lo, hi, k, out, cut0);
+  const tail = [];
+  if (geo.aV > 0) t3ArcPoints(geo, s1, r1, hi, lo + T3_TAU, k, tail, cut1);
+  else t3ArcPoints(geo, s1, r1, lo, hi, k, tail, cut1);
+  const first = out[out.length - 1];
+  const a = tail[0];
+  const b = tail[tail.length - 1];
+  if (Math.hypot(a[0] - first[0], a[1] - first[1]) > Math.hypot(b[0] - first[0], b[1] - first[1])) tail.reverse();
+  for (const p of tail) out.push(p);
+  return out;
+}
+
+function t3LatheMid(a, b) {
+  const h = b.s - a.s;
+  const ga = -a.na / a.nr;
+  const gb = -b.na / b.nr;
+  const nr = a.nr + b.nr;
+  const na = a.na + b.na;
+  const l = Math.hypot(nr, na) || 1;
+  return { s: (a.s + b.s) / 2, r: (a.r + b.r) / 2 + (h * (ga - gb)) / 8, nr: nr / l, na: na / l };
+}
+
+function t3LatheOutline(run, geo, cam) {
+  const k = cam.k;
+  const view = geo.view;
+  const lv = run.levels;
+  const pts = [];
+  const cut = (L) => (view.flat < 1e-9 ? Infinity : -(L.na * view.a) / (L.nr * view.flat));
+  const inside = (L) => L.r <= 1e-9 || Math.abs(cut(L)) < 1;
+  const sides = (L) => {
+    if (L.r <= 1e-9) {
+      const p = [geo.O[0] + L.s * geo.SA[0], geo.O[1] + L.s * geo.SA[1]];
+      return [p, p];
+    }
+    const c = Math.max(-1, Math.min(1, cut(L)));
+    const d = Math.acos(c);
+    return [view.phi - d, view.phi + d].map((t) => {
+      const cs = Math.cos(t);
+      const sn = Math.sin(t);
+      return [geo.O[0] + L.s * geo.SA[0] + L.r * (cs * geo.SU[0] + sn * geo.SV[0]), geo.O[1] + L.s * geo.SA[1] + L.r * (cs * geo.SU[1] + sn * geo.SV[1])];
+    });
+  };
+  const span = (a, b) => {
+    const pa = sides(a);
+    const pb = sides(b);
+    return Math.max(Math.hypot(pa[0][0] - pb[0][0], pa[0][1] - pb[0][1]), Math.hypot(pa[1][0] - pb[1][0], pa[1][1] - pb[1][1]));
+  };
+  const refine = (a, b, depth) => {
+    if (depth >= 10 || span(a, b) < 1.2) return;
+    const mid = t3LatheMid(a, b);
+    refine(a, mid, depth + 1);
+    pts.push(...sides(mid));
+    refine(mid, b, depth + 1);
+  };
+  let previous = null;
+  for (let i = 0; i < lv.length; i += 4) {
+    const L = { s: lv[i], r: lv[i + 1], nr: lv[i + 2], na: lv[i + 3] };
+    if (inside(L)) pts.push(...sides(L));
+    if (previous) {
+      const pin = inside(previous);
+      const lin = inside(L);
+      if (pin && lin) refine(previous, L, 0);
+      else if (pin !== lin) {
+        let a = pin ? previous : L;
+        let b = pin ? L : previous;
+        const start = a;
+        for (let it = 0; it < 14; it++) {
+          const mid = t3LatheMid(a.s < b.s ? a : b, a.s < b.s ? b : a);
+          if (inside(mid)) a = mid;
+          else b = mid;
+        }
+        pts.push(...sides(a));
+        refine(start.s < a.s ? start : a, start.s < a.s ? a : start, 0);
+      }
+    }
+    previous = L;
+  }
+  for (const i of [0, lv.length - 4]) if (lv[i + 1] > 1e-9) t3ArcPoints(geo, lv[i], lv[i + 1], 0, T3_TAU, k, pts);
+  return t3Hull(pts);
+}
+
+function t3SeamArc(geo, s, r, slope, k, trim = 0.3) {
+  const view = geo.view;
+  const norm = Math.hypot(1, slope);
+  let lo;
+  let hi;
+  if (view.flat < 1e-9) {
+    if (!((-slope * view.a) / norm > 0)) return "";
+    lo = view.phi;
+    hi = view.phi + T3_TAU;
+  } else {
+    const cc = (slope * view.a) / view.flat;
+    if (cc >= 1) return "";
+    if (cc <= -1) {
+      lo = view.phi;
+      hi = view.phi + T3_TAU;
+    } else {
+      const d = Math.acos(cc);
+      lo = view.phi - d;
+      hi = view.phi + d;
+    }
+  }
+  const full = hi - lo >= T3_TAU - 1e-9;
+  const buf = t3Scratch("c", 2 * 520);
+  if (!full) {
+    const span = hi - lo;
+    const cutAt = (from, sign) => {
+      t3At(geo, s, r, from, buf, 0);
+      const px = buf[0];
+      const py = buf[1];
+      let a = 0;
+      let b = span * 0.25;
+      t3At(geo, s, r, from + sign * b, buf, 0);
+      if (Math.hypot(buf[0] - px, buf[1] - py) <= trim) return b;
+      for (let it = 0; it < 18; it++) {
+        const mid = (a + b) / 2;
+        t3At(geo, s, r, from + sign * mid, buf, 0);
+        if (Math.hypot(buf[0] - px, buf[1] - py) < trim) a = mid;
+        else b = mid;
+      }
+      return (a + b) / 2;
+    };
+    const d0 = cutAt(lo, 1);
+    const d1 = cutAt(hi, -1);
+    lo += d0;
+    hi -= d1;
+  }
+  const count = Math.min(512, Math.max(4, Math.ceil(((hi - lo) * r * k) / 1.5)));
+  for (let j = 0; j <= count; j++) t3At(geo, s, r, lo + ((hi - lo) * j) / count, buf, 2 * j);
+  return t3Path(buf, full ? count : count + 1, full);
+}
+
+function t3RibLines(geo, F, cam, ribs, sx, sy) {
+  const lines = t3Lines;
+  lines.d.length = 0;
+  lines.alpha.length = 0;
+  lines.key.length = 0;
+  const { s0, s1, count, phase = 0, twist = 0, fade = [0.1, 0.55] } = ribs;
+  const r0 = ribs.r0 ?? ribs.r;
+  const r1 = ribs.r1 ?? r0;
+  const slope = (r1 - r0) / (s1 - s0 || 1);
+  const norm = Math.hypot(1, slope);
+  const view = geo.view;
+  const seg = new Float64Array(4);
+  for (let i = 0; i < count; i++) {
+    const t = phase + (i / count) * T3_TAU;
+    const tm = t + twist / 2;
+    const facing = (view.flat * Math.cos(tm - view.phi) - slope * view.a) / norm;
+    const alpha = t3Step(fade[0], fade[1], facing);
+    if (alpha * T3_LEVELS < 0.5) continue;
+    t3At(geo, s0, r0, t, seg, 0);
+    t3At(geo, s1, r1, t + twist, seg, 2);
+    seg[0] -= sx;
+    seg[1] -= sy;
+    seg[2] -= sx;
+    seg[3] -= sy;
+    lines.d.push(t3Path(seg, 2, false));
+    lines.alpha.push(alpha);
+    lines.key.push(i);
+  }
+  return lines;
+}
+
+function t3PrepareRound(run, part, P, unit) {
+  const spec = part.spec;
+  const k = P.scale * T3_ROOT;
+  run.F = spec.F;
+  run.s0 = spec.s0;
+  run.s1 = spec.s1;
+  run.r0 = spec.r0;
+  run.r1 = spec.r1;
+  run.ends = spec.ends;
+  const g = (spec.r1 - spec.r0) / (spec.s1 - spec.s0 || 1);
+  const norm = Math.hypot(1, g);
+  run.nr = 1 / norm;
+  run.na = -g / norm;
+  run.g = g;
+  const rmax = Math.max(spec.r0, spec.r1);
+  const around = T3_TAU * rmax * k * unit;
+  run.fine = Math.max(around < 30 ? 16 : 24, Math.min(96, Math.ceil(around / 2.2)));
+  run.dirs = Math.max(around < 30 ? 16 : 32, Math.min(256, Math.ceil(around / 1.5)));
+  run.capCount = Math.max(around < 30 ? 16 : 24, Math.min(160, Math.ceil(around / 1.5)));
+  run.domeCount = Math.max(around < 30 ? 12 : 16, Math.min(48, Math.round(run.fine * 0.75)));
+  const comps = [];
+  for (const [end, s, r] of [[0, spec.s0, spec.r0], [1, spec.s1, spec.r1]]) comps.push(spec.ends[end] === "dome" ? 1 : 0, s, r);
+  run.components = comps;
+  const details = part.details ?? {};
+  run.seams = (details.seams ?? []).map((s) => ({ s, r: spec.r0 + g * (s - spec.s0), slope: g }));
+  run.ribs = details.ribs ? { ...details.ribs, r0: details.ribs.r0 ?? spec.r0 + g * (details.ribs.s0 - spec.s0), r1: details.ribs.r1 ?? spec.r0 + g * (details.ribs.s1 - spec.s0) } : null;
+  run.cutS = null;
+  for (const cut of spec.cuts ?? []) {
+    const along = cut.n[0] * spec.F.a[0] + cut.n[1] * spec.F.a[1] + cut.n[2] * spec.F.a[2];
+    const sCut = (cut.d - (cut.n[0] * spec.F.o[0] + cut.n[1] * spec.F.o[1] + cut.n[2] * spec.F.o[2])) / along;
+    if (Math.abs(sCut - spec.s0) < 1e-6 || Math.abs(sCut - spec.s1) < 1e-6) run.cutS = sCut;
+  }
+}
+
+function t3EmitRound(run, cam, f) {
+  const geo = t3Geo(run.F, cam);
+  const k = cam.k;
+  const step = T3_TAU / run.fine;
+  const sheets = ["", "", "", "", ""];
+  const { s0, s1, r0, r1 } = run;
+  for (const arc of t3Arcs(run.nr, run.na, geo.view, geo.light)) sheets[arc.tone] += t3Strip(geo, s0, r0, s1, r1, arc.from, arc.to, step);
+  const F = run.F;
+  for (let end = 0; end < 2; end++) {
+    if (run.ends[end] !== "dome") continue;
+    const s = end ? s1 : s0;
+    const sign = end ? 1 : -1;
+    const C = [F.o[0] + F.a[0] * s, F.o[1] + F.a[1] * s, F.o[2] + F.a[2] * s];
+    t3Dome(cam, C, [F.a[0] * sign, F.a[1] * sign, F.a[2] * sign], end ? r1 : r0, run.domeCount, sheets);
+  }
+  for (let t = 0; t < 5; t++) f.d[run.role[`s${t}`]] = sheets[t];
+  const pts = t3RoundOutline(run, geo, cam);
+  const outline = t3PathOf(pts, true);
+  f.d[run.role.fill] = outline;
+  if (run.cutS !== null) {
+    const buf = new Float64Array(2 * pts.length);
+    const skip = new Uint8Array(pts.length);
+    pts.forEach((p, j) => {
+      buf[2 * j] = p[0];
+      buf[2 * j + 1] = p[1];
+    });
+    for (let j = 0; j < pts.length; j++) skip[j] = pts[j].cut && pts[(j + 1) % pts.length].cut ? 1 : 0;
+    f.d[run.role.edge] = t3Broken(buf, pts.length, skip);
+  } else f.d[run.role.edge] = outline;
+  t3BoxOf(pts, f.box);
+  t3HullOut(f, pts);
+  const view = geo.view;
+  let crease = "";
+  for (let end = 0; end < 2; end++) {
+    if (run.ends[end] !== "flat") continue;
+    const role = run.role[`k${end}`];
+    const sign = end ? 1 : -1;
+    const s = end ? s1 : s0;
+    const r = end ? r1 : r0;
+    const face = sign * geo.aV;
+    if (!(face > 1e-9)) {
+      f.d[role] = "";
+      continue;
+    }
+    const n = run.capCount;
+    const buf = t3Scratch("c", 2 * n);
+    const table = t3Table(n);
+    for (let j = 0; j < n; j++) {
+      const c = table[2 * j];
+      const q = table[2 * j + 1];
+      buf[2 * j] = geo.O[0] + s * geo.SA[0] + r * (c * geo.SU[0] + q * geo.SV[0]);
+      buf[2 * j + 1] = geo.O[1] + s * geo.SA[1] + r * (c * geo.SU[1] + q * geo.SV[1]);
+    }
+    f.d[role] = t3Path(buf, n, true);
+    f.q[role] = t3Level(sign * geo.aL, T3_LB);
+    const minor = 2 * r * k * Math.abs(face);
+    f.w[role] = minor < 0.4 ? Math.round(minor * 100) / 100 : -1;
+    if (run.role.crease === undefined) continue;
+    let lo;
+    let hi;
+    if (view.flat < 1e-9) {
+      if (!(run.na * view.a > 1e-9)) continue;
+      lo = 0;
+      hi = T3_TAU;
+    } else {
+      const cc = -(run.na * view.a) / (run.nr * view.flat);
+      if (cc >= 1) continue;
+      if (cc <= -1) {
+        lo = view.phi;
+        hi = view.phi + T3_TAU;
+      } else {
+        const d = Math.acos(cc);
+        lo = view.phi - d;
+        hi = view.phi + d;
+      }
+    }
+    const count = Math.min(400, Math.max(4, Math.ceil(((hi - lo) * r * k) / 1.5)));
+    const arc = t3Scratch("c", 2 * count + 2);
+    for (let j = 0; j <= count; j++) t3At(geo, s, r, lo + ((hi - lo) * j) / count, arc, 2 * j);
+    crease += t3Path(arc, count + 1, false);
+  }
+  if (run.role.crease !== undefined) f.d[run.role.crease] = crease;
+  if (run.role.inner !== undefined) {
+    let inner = "";
+    for (const seam of run.seams) inner += t3SeamArc(geo, seam.s, seam.r, seam.slope, k);
+    if (run.ribs && run.ribs.seams) {
+      const rs = run.ribs;
+      const slope = (rs.r1 - rs.r0) / (rs.s1 - rs.s0 || 1);
+      if (rs.seams !== "last") inner += t3SeamArc(geo, rs.s0, rs.r0, slope, k);
+      if (rs.seams !== "first") inner += t3SeamArc(geo, rs.s1, rs.r1, slope, k);
+    }
+    f.d[run.role.inner] = inner;
+  }
+  if (run.ribs) {
+    const lines = t3State.detail < 0.01 ? t3None : t3RibLines(geo, run.F, cam, run.ribs, 0, 0);
+    f.levels = t3Faded(f, run, "r", lines, lines.d.length);
+  }
+}
+
+function t3PrepareBall(run, part, P, unit) {
+  const spec = part.spec;
+  const k = P.scale * T3_ROOT;
+  run.c = spec.c;
+  run.r = spec.r;
+  run.flats = spec.flats.map((flat) => {
+    const n = t3Unit(flat.n);
+    const rho = Math.sqrt(Math.max(0, spec.r * spec.r - flat.d * flat.d));
+    const [u, v] = t3Basis(n);
+    return { n, d: flat.d, rho, u, v };
+  });
+  run.limb = Math.max(32, Math.min(160, Math.ceil((T3_TAU * spec.r * k * unit) / 1.5)));
+  run.rimCount = run.flats.map((flat) => Math.max(20, Math.min(120, Math.ceil((T3_TAU * flat.rho * k * unit) / 1.5))));
+}
+
+function t3ClipConvex(subject, clip) {
+  if (subject.length < 3 || clip.length < 3) return [];
+  let area = 0;
+  for (let i = 0; i < clip.length; i++) {
+    const a = clip[i];
+    const b = clip[(i + 1) % clip.length];
+    area += a[0] * b[1] - b[0] * a[1];
+  }
+  const sign = area >= 0 ? 1 : -1;
+  let out = subject;
+  for (let i = 0; i < clip.length && out.length; i++) {
+    const a = clip[i];
+    const b = clip[(i + 1) % clip.length];
+    const side = (p) => sign * ((b[0] - a[0]) * (p[1] - a[1]) - (b[1] - a[1]) * (p[0] - a[0]));
+    const input = out;
+    out = [];
+    for (let j = 0; j < input.length; j++) {
+      const p = input[j];
+      const q = input[(j + 1) % input.length];
+      const sp = side(p);
+      const sq = side(q);
+      if (sp >= 0) out.push(p);
+      if ((sp >= 0) !== (sq >= 0)) {
+        const t = sp / (sp - sq);
+        out.push([p[0] + (q[0] - p[0]) * t, p[1] + (q[1] - p[1]) * t]);
+      }
+    }
+  }
+  return out;
+}
+
+function t3EmitBall(run, cam, f) {
+  const m = cam.m;
+  const V = cam.V;
+  const L = cam.L;
+  const { c, r, flats } = run;
+  const Cx = cam.ox + m[0] * c[0] + m[1] * c[1] + m[2] * c[2];
+  const Cy = cam.oy + m[3] * c[0] + m[4] * c[1] + m[5] * c[2];
+  const dot = (a, b) => a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
+  const flat = (w) => [Cx + r * (m[0] * w[0] + m[1] * w[1] + m[2] * w[2]), Cy + r * (m[3] * w[0] + m[4] * w[1] + m[5] * w[2])];
+  const inside = (w, skip = -1) => {
+    for (let i = 0; i < flats.length; i++) if (i !== skip && dot(w, flats[i].n) * r > flats[i].d + 1e-7) return false;
+    return true;
+  };
+  const [U, W] = t3Basis(V);
+  const n = run.limb;
+  const table = t3Table(n);
+  const limb = [];
+  for (let j = 0; j < n; j++) limb.push([U[0] * table[2 * j] + W[0] * table[2 * j + 1], U[1] * table[2 * j] + W[1] * table[2 * j + 1], U[2] * table[2 * j] + W[2] * table[2 * j + 1]]);
+  const sil = [];
+  for (const w of limb) if (inside(w)) sil.push(flat(w));
+  const rims = flats.map((cut, ci) => {
+    const count = run.rimCount[ci];
+    const t = t3Table(count);
+    const list = [];
+    for (let j = 0; j < count; j++) {
+      const w = [(cut.n[0] * cut.d + cut.rho * (cut.u[0] * t[2 * j] + cut.v[0] * t[2 * j + 1])) / r, (cut.n[1] * cut.d + cut.rho * (cut.u[1] * t[2 * j] + cut.v[1] * t[2 * j + 1])) / r, (cut.n[2] * cut.d + cut.rho * (cut.u[2] * t[2 * j] + cut.v[2] * t[2 * j + 1])) / r];
+      list.push({ w, keep: inside(w, ci), p: flat(w) });
+    }
+    return list;
+  });
+  flats.forEach((cut, ci) => {
+    for (const w of t3Meet(V, 0, cut.n, cut.d / r)) if (inside(w, ci)) sil.push(flat(w));
+    rims[ci].forEach(({ keep, p }) => keep && sil.push(p));
+  });
+  const hull = t3Hull(sil);
+  const outline = t3PathOf(hull, true);
+  f.d[run.role.fill] = outline;
+  f.d[run.role.edge] = outline;
+  f.d[run.role.s0] = outline;
+  const capOf = (threshold) => {
+    const points = [];
+    for (const w of limb) if (dot(w, L) >= threshold && inside(w)) points.push(flat(w));
+    const radius = Math.sqrt(Math.max(0, 1 - threshold * threshold));
+    const [LU, LW] = t3Basis(L);
+    for (let j = 0; j < n; j++) {
+      const w = [L[0] * threshold + radius * (LU[0] * table[2 * j] + LW[0] * table[2 * j + 1]), L[1] * threshold + radius * (LU[1] * table[2 * j] + LW[1] * table[2 * j + 1]), L[2] * threshold + radius * (LU[2] * table[2 * j] + LW[2] * table[2 * j + 1])];
+      if (dot(w, V) >= -1e-9) points.push(flat(w));
+    }
+    if (dot(L, V) > threshold) points.push(flat(V));
+    for (const w of t3Meet(L, threshold, V, 0)) if (inside(w)) points.push(flat(w));
+    flats.forEach((cut, ci) => {
+      for (const w of t3Meet(V, 0, cut.n, cut.d / r)) if (inside(w, ci) && dot(w, L) >= threshold) points.push(flat(w));
+      for (const w of t3Meet(L, threshold, cut.n, cut.d / r)) if (inside(w, ci) && dot(w, V) >= -1e-9) points.push(flat(w));
+      for (const { w, keep, p } of rims[ci]) if (keep && dot(w, L) >= threshold && dot(w, V) >= -1e-9) points.push(p);
+    });
+    if (points.length < 3) return "";
+    const region = t3ClipConvex(t3Hull(points), hull);
+    return region.length >= 3 ? t3PathOf(region, true) : "";
+  };
+  f.d[run.role.s1] = capOf(T3_LB[1]);
+  f.d[run.role.s2] = capOf(T3_LB[2]);
+  f.d[run.role.s3] = capOf(T3_LB[3]);
+  let crease = "";
+  flats.forEach((cut, ci) => {
+    const role = run.role[`f${ci}`];
+    const face = dot(cut.n, V);
+    if (!(face > 1e-9)) {
+      f.d[role] = "";
+      return;
+    }
+    const pts = t3ClipConvex(rims[ci].map(({ p }) => p), hull);
+    f.d[role] = t3PathOf(pts, true);
+    f.q[role] = t3Level(dot(cut.n, L), T3_LB);
+    const minor = 2 * cut.rho * cam.k * face;
+    f.w[role] = minor < 0.4 ? Math.round(minor * 100) / 100 : -1;
+    const list = rims[ci];
+    const seen = list.map(({ w, keep }) => keep && dot(w, V) > 0);
+    const start = seen.indexOf(false);
+    if (start < 0) {
+      crease += t3PathOf(list.map(({ p }) => p), true);
+      return;
+    }
+    let cur = null;
+    for (let s = 1; s <= list.length; s++) {
+      const i = (start + s) % list.length;
+      if (seen[i]) (cur ??= []).push(list[i].p);
+      else if (cur) {
+        if (cur.length > 1) crease += t3PathOf(cur, false);
+        cur = null;
+      }
+    }
+    if (cur && cur.length > 1) crease += t3PathOf(cur, false);
+  });
+  if (run.role.crease !== undefined) f.d[run.role.crease] = crease;
+  let x0 = Infinity;
+  let y0 = Infinity;
+  let x1 = -Infinity;
+  let y1 = -Infinity;
+  for (const [x, y] of hull) {
+    if (x < x0) x0 = x;
+    if (x > x1) x1 = x;
+    if (y < y0) y0 = y;
+    if (y > y1) y1 = y;
+  }
+  f.box[0] = x0;
+  f.box[1] = y0;
+  f.box[2] = x1;
+  f.box[3] = y1;
+  t3HullOut(f, hull);
+}
+
+function t3PrepareLathe(run, part, P, unit) {
+  const spec = part.spec;
+  const k = P.scale * T3_ROOT;
+  run.F = spec.F;
+  run.levels = spec.levels;
+  run.caps = spec.caps;
+  let rmax = 0;
+  for (let i = 0; i < spec.levels.length; i += 4) rmax = Math.max(rmax, spec.levels[i + 1]);
+  run.fine = Math.max(24, Math.min(96, Math.ceil((T3_TAU * rmax * k * unit) / 2.2)));
+  run.dirs = Math.max(32, Math.min(256, Math.ceil((T3_TAU * rmax * k * unit) / 1.5)));
+  run.capCount = Math.max(24, Math.min(160, Math.ceil((T3_TAU * rmax * k * unit) / 1.5)));
+  const comps = [];
+  for (let i = 0; i < spec.levels.length; i += 4) comps.push(0, spec.levels[i], spec.levels[i + 1]);
+  run.components = comps;
+  const details = part.details ?? {};
+  run.seams = (details.seams ?? []).map((seam) => (typeof seam === "number" ? t3LatheSeam(spec.levels, seam) : seam));
+  run.ribs = details.ribs ?? null;
+}
+
+function t3LatheSeam(levels, s) {
+  for (let i = 0; i + 4 < levels.length; i += 4) {
+    const sa = levels[i];
+    const sb = levels[i + 4];
+    if ((s - sa) * (s - sb) <= 0 && sa !== sb) {
+      const t = (s - sa) / (sb - sa);
+      const r = levels[i + 1] + (levels[i + 5] - levels[i + 1]) * t;
+      const slope = (levels[i + 5] - levels[i + 1]) / (sb - sa);
+      return { s, r, slope };
+    }
+  }
+  return { s, r: levels[1], slope: 0 };
+}
+
+function t3LatheSheets(levels, geo, step, buckets) {
+  const at = (L, t) => {
+    const c = Math.cos(t);
+    const n = Math.sin(t);
+    return [geo.O[0] + L.s * geo.SA[0] + L.r * (c * geo.SU[0] + n * geo.SV[0]), geo.O[1] + L.s * geo.SA[1] + L.r * (c * geo.SU[1] + n * geo.SV[1])];
+  };
+  const arcPoints = (L, from, to) => {
+    const count = Math.max(1, Math.ceil((to - from) / step));
+    const out = new Array(count + 1);
+    for (let index = 0; index <= count; index++) out[index] = at(L, from + ((to - from) * index) / count);
+    return out;
+  };
+  const oriented = (points) => {
+    let area = 0;
+    for (let i = 0; i < points.length; i++) {
+      const a = points[i];
+      const b = points[(i + 1) % points.length];
+      area += a[0] * b[1] - b[0] * a[1];
+    }
+    return area < 0 ? points.reverse() : points;
+  };
+  const centreOf = (arc, reference) => {
+    let mid = (arc.from + arc.to) / 2 - reference;
+    mid = ((mid % T3_TAU) + T3_TAU) % T3_TAU;
+    return mid;
+  };
+  const present = [false, false, false, false, false];
+  for (const L of levels) {
+    const groups = [null, null, null, null, null];
+    for (const arc of L.arcs) {
+      if (!groups[arc.tone]) groups[arc.tone] = [];
+      groups[arc.tone].push(arc);
+      present[arc.tone] = true;
+    }
+    for (const list of groups) if (list && list.length > 1) list.sort((x, y) => centreOf(x, geo.light.phi) - centreOf(y, geo.light.phi));
+    L.groups = groups;
+  }
+  const align = (reference, arc) => {
+    const out = { ...arc };
+    const centre = (reference.from + reference.to) / 2;
+    while ((out.from + out.to) / 2 - centre > Math.PI) {
+      out.from -= T3_TAU;
+      out.to -= T3_TAU;
+    }
+    while (centre - (out.from + out.to) / 2 > Math.PI) {
+      out.from += T3_TAU;
+      out.to += T3_TAU;
+    }
+    return out;
+  };
+  const overlap = (x, y) => Math.min(x.to, y.to) - Math.max(x.from, y.from);
+  const sheet = (tone, run) => {
+    const chains = run[0].groups[tone].map((arc) => [arc]);
+    for (let q = 1; q < run.length; q++) {
+      const next = run[q].groups[tone];
+      const used = new Uint8Array(next.length);
+      for (const chain of chains) {
+        const prev = chain[q - 1];
+        let best = -1;
+        let score = -Infinity;
+        for (let j = 0; j < next.length; j++) {
+          if (used[j]) continue;
+          const value = overlap(prev, align(prev, next[j]));
+          if (value > score) {
+            score = value;
+            best = j;
+          }
+        }
+        used[best] = 1;
+        chain.push(align(prev, next[best]));
+      }
+    }
+    chains.forEach((chain) => {
+      const last = run.length - 1;
+      const points = arcPoints(run[0], chain[0].from, chain[0].to);
+      for (let q = 1; q < last; q++) points.push(at(run[q], chain[q].to));
+      points.push(...arcPoints(run[last], chain[last].from, chain[last].to).reverse());
+      for (let q = last - 1; q >= 1; q--) points.push(at(run[q], chain[q].from));
+      buckets[tone] += t3PathOf(oriented(points), true);
+    });
+  };
+  const strip = (tone, a, b) => {
+    const below = a.groups[tone] ?? [];
+    const above = b.groups[tone] ?? [];
+    const whole = (arc) => arc.to - arc.from >= T3_TAU - 1e-6;
+    const seat = (ring, arc) => {
+      const gap = T3_TAU - (arc.to - arc.from);
+      return { from: arc.from - gap / 2, to: arc.to + gap / 2 };
+    };
+    const quad = (lo, hi) => {
+      if (whole(hi) && !whole(lo)) hi = seat(hi, lo);
+      else if (whole(lo) && !whole(hi)) lo = seat(lo, hi);
+      const points = [...arcPoints(a, lo.from, lo.to), ...arcPoints(b, hi.from, hi.to).reverse()];
+      buckets[tone] += t3PathOf(oriented(points), true);
+    };
+    const links = below.map(() => []);
+    const back = above.map(() => []);
+    below.forEach((lo, i) =>
+      above.forEach((hi, j) => {
+        if (overlap(lo, align(lo, hi)) > -0.05) {
+          links[i].push(j);
+          back[j].push(i);
+        }
+      }),
+    );
+    const doneLo = new Uint8Array(below.length);
+    const doneHi = new Uint8Array(above.length);
+    const share = (span, parts, flip) => {
+      if (whole(span)) {
+        const base = parts[0].from;
+        const sorted = parts.map((arc) => {
+          const shift = T3_TAU * Math.floor((arc.from - base) / T3_TAU);
+          return { from: arc.from - shift, to: arc.to - shift };
+        }).sort((x, y) => x.from - y.from);
+        const n = sorted.length;
+        const cuts = sorted.map((arc, q) => {
+          const next = q + 1 < n ? sorted[q + 1].from : sorted[0].from + T3_TAU;
+          return (arc.to + next) / 2;
+        });
+        sorted.forEach((arc, q) => {
+          const piece = { from: q ? cuts[q - 1] : cuts[n - 1] - T3_TAU, to: cuts[q] };
+          if (flip) quad(arc, piece);
+          else quad(piece, arc);
+        });
+        return;
+      }
+      const sorted = parts.map((arc) => align(span, arc)).sort((x, y) => x.from - y.from);
+      const cuts = [span.from];
+      for (let q = 1; q < sorted.length; q++) cuts.push(Math.min(span.to, Math.max(span.from, (sorted[q - 1].to + sorted[q].from) / 2)));
+      cuts.push(span.to);
+      sorted.forEach((arc, q) => {
+        const piece = { from: cuts[q], to: cuts[q + 1] };
+        if (flip) quad(arc, piece);
+        else quad(piece, arc);
+      });
+    };
+    for (let j = 0; j < above.length; j++) {
+      if (back[j].length < 2 || back[j].some((i) => links[i].length !== 1)) continue;
+      share(above[j], back[j].map((i) => below[i]), false);
+      doneHi[j] = 1;
+      for (const i of back[j]) doneLo[i] = 1;
+    }
+    for (let i = 0; i < below.length; i++) {
+      if (doneLo[i] || links[i].length < 2 || links[i].some((j) => back[j].length !== 1)) continue;
+      share(below[i], links[i].map((j) => above[j]), true);
+      doneLo[i] = 1;
+      for (const j of links[i]) doneHi[j] = 1;
+    }
+    for (let i = 0; i < below.length; i++) {
+      if (doneLo[i]) continue;
+      const lo = below[i];
+      let best = -1;
+      let score = -Infinity;
+      for (const j of links[i]) {
+        if (doneHi[j]) continue;
+        const value = overlap(lo, align(lo, above[j]));
+        if (value > score) {
+          score = value;
+          best = j;
+        }
+      }
+      if (best >= 0) {
+        doneHi[best] = 1;
+        quad(lo, align(lo, above[best]));
+      } else {
+        const centre = (lo.from + lo.to) / 2;
+        quad(lo, { from: centre, to: centre });
+      }
+    }
+    for (let j = 0; j < above.length; j++) {
+      if (doneHi[j]) continue;
+      const centre = (above[j].from + above[j].to) / 2;
+      quad({ from: centre, to: centre }, above[j]);
+    }
+  };
+  for (let tone = 0; tone < 5; tone++) {
+    if (!present[tone]) continue;
+    for (let q = 1; q < levels.length; q++) strip(tone, levels[q - 1], levels[q]);
+  }
+  void sheet;
+}
+
+function t3EmitLathe(run, cam, f) {
+  const geo = t3Geo(run.F, cam);
+  const k = cam.k;
+  const step = T3_TAU / run.fine;
+  const sheets = ["", "", "", "", ""];
+  const lv = run.levels;
+  const levelAt = (s, r, nr, na) => ({ s, r, nr, na, arcs: t3Arcs(nr, na, geo.view, geo.light) });
+  const same = (a, b) => {
+    if (a.arcs.length !== b.arcs.length) return false;
+    for (let i = 0; i < a.arcs.length; i++) if (a.arcs[i].tone !== b.arcs[i].tone || Boolean(a.arcs[i].full) !== Boolean(b.arcs[i].full)) return false;
+    return true;
+  };
+  const reach = (a, b) => Math.hypot((b.s - a.s) * Math.hypot(geo.SA[0], geo.SA[1]), (b.r - a.r) * k) + Math.abs(b.r - a.r) * k;
+  const levels = [];
+  const wrap = (x, ref) => x + T3_TAU * Math.round((ref - x) / T3_TAU);
+  const close = (a, mid, b) => {
+    const r = Math.max(a.r, b.r) * k;
+    for (let i = 0; i < mid.arcs.length; i++) {
+      const m = mid.arcs[i];
+      if (m.full) continue;
+      for (const key of ["from", "to"]) {
+        const x = m[key];
+        const guess = (wrap(a.arcs[i][key], x) + wrap(b.arcs[i][key], x)) / 2;
+        if (Math.abs(guess - x) * r > 0.25) return false;
+      }
+    }
+    return true;
+  };
+  const refine = (a, b, depth) => {
+    if (depth >= 8 || reach(a, b) < 0.1) {
+      levels.push(b);
+      return;
+    }
+    const m = t3LatheMid(a, b);
+    const mid = levelAt(m.s, m.r, m.nr, m.na);
+    if (same(a, b) && same(a, mid) && close(a, mid, b)) {
+      levels.push(b);
+      return;
+    }
+    refine(a, mid, depth + 1);
+    refine(mid, b, depth + 1);
+  };
+  let previous = levelAt(lv[0], lv[1], lv[2], lv[3]);
+  levels.push(previous);
+  for (let i = 4; i < lv.length; i += 4) {
+    const next = levelAt(lv[i], lv[i + 1], lv[i + 2], lv[i + 3]);
+    refine(previous, next, 0);
+    previous = next;
+  }
+  t3LatheSheets(levels, geo, step, sheets);
+  for (let t = 0; t < 5; t++) f.d[run.role[`s${t}`]] = sheets[t];
+  const pts = t3LatheOutline(run, geo, cam);
+  const outline = t3PathOf(pts, true);
+  f.d[run.role.fill] = outline;
+  f.d[run.role.edge] = outline;
+  t3BoxOf(pts, f.box);
+  t3HullOut(f, pts);
+  let crease = "";
+  const view = geo.view;
+  const ends = [[0, lv[0], lv[1], -1, 4], [1, lv[lv.length - 4], lv[lv.length - 3], 1, lv.length - 8]];
+  for (const [end, s, r, sign, near] of ends) {
+    const role = run.role[`k${end}`];
+    if (role === undefined) continue;
+    const face = sign * geo.aV;
+    if (!(face > 1e-9) || r <= 1e-9) {
+      f.d[role] = "";
+      continue;
+    }
+    const n = run.capCount;
+    const buf = t3Scratch("c", 2 * n);
+    const table = t3Table(n);
+    for (let j = 0; j < n; j++) {
+      const c = table[2 * j];
+      const q = table[2 * j + 1];
+      buf[2 * j] = geo.O[0] + s * geo.SA[0] + r * (c * geo.SU[0] + q * geo.SV[0]);
+      buf[2 * j + 1] = geo.O[1] + s * geo.SA[1] + r * (c * geo.SU[1] + q * geo.SV[1]);
+    }
+    f.d[role] = t3Path(buf, n, true);
+    f.q[role] = t3Level(sign * geo.aL, T3_LB);
+    const minor = 2 * r * k * Math.abs(face);
+    f.w[role] = minor < 0.4 ? Math.round(minor * 100) / 100 : -1;
+    if (run.role.crease === undefined) continue;
+    const nr = lv[near + 2];
+    const na = lv[near + 3];
+    let lo;
+    let hi;
+    if (view.flat < 1e-9) {
+      if (!(na * view.a > 1e-9)) continue;
+      lo = 0;
+      hi = T3_TAU;
+    } else {
+      const cc = -(na * view.a) / (nr * view.flat);
+      if (cc >= 1) continue;
+      if (cc <= -1) {
+        lo = view.phi;
+        hi = view.phi + T3_TAU;
+      } else {
+        const d = Math.acos(cc);
+        lo = view.phi - d;
+        hi = view.phi + d;
+      }
+    }
+    const count = Math.min(400, Math.max(4, Math.ceil(((hi - lo) * r * k) / 1.5)));
+    const arc = t3Scratch("c", 2 * count + 2);
+    for (let j = 0; j <= count; j++) t3At(geo, s, r, lo + ((hi - lo) * j) / count, arc, 2 * j);
+    crease += t3Path(arc, count + 1, false);
+  }
+  if (run.role.crease !== undefined) f.d[run.role.crease] = crease;
+  if (run.role.inner !== undefined) {
+    let inner = "";
+    for (const seam of run.seams) inner += t3SeamArc(geo, seam.s, seam.r, seam.slope, k);
+    f.d[run.role.inner] = inner;
+  }
+  if (run.ribs) {
+    const lines = t3State.detail < 0.01 ? t3None : t3RibLines(geo, run.F, cam, run.ribs, 0, 0);
+    f.levels = t3Faded(f, run, "r", lines, lines.d.length);
+  }
+}
+
+const T3_SHINE = (() => {
+  const l = Math.hypot(-0.55, -0.835);
+  return [-0.55 / l, -0.835 / l];
+})();
+
+function t3RouteOf(flat) {
+  const n = flat.length / 3;
+  const along = new Float64Array(n);
+  for (let i = 1; i < n; i++) along[i] = along[i - 1] + Math.hypot(flat[3 * i] - flat[3 * i - 3], flat[3 * i + 1] - flat[3 * i - 2], flat[3 * i + 2] - flat[3 * i - 1]);
+  return { flat, n, along, total: along[n - 1] };
+}
+
+function t3PointAlong(route, at) {
+  const { flat, n, along } = route;
+  if (at <= 0) return [flat[0], flat[1], flat[2]];
+  if (at >= along[n - 1]) return [flat[3 * n - 3], flat[3 * n - 2], flat[3 * n - 1]];
+  let lo = 0;
+  let hi = n - 1;
+  while (hi - lo > 1) {
+    const mid = (lo + hi) >> 1;
+    if (along[mid] <= at) lo = mid;
+    else hi = mid;
+  }
+  const span = along[hi] - along[lo] || 1;
+  const t = (at - along[lo]) / span;
+  return [flat[3 * lo] + (flat[3 * hi] - flat[3 * lo]) * t, flat[3 * lo + 1] + (flat[3 * hi + 1] - flat[3 * lo + 1]) * t, flat[3 * lo + 2] + (flat[3 * hi + 2] - flat[3 * lo + 2]) * t];
+}
+
+function t3Cut(route, from, to) {
+  const { flat, n, along } = route;
+  const out = [];
+  for (let i = 1; i < n; i++) {
+    const start = along[i - 1];
+    const end = along[i];
+    if (end >= from && start <= to) {
+      const length = end - start || 1;
+      const t0 = Math.max(0, (from - start) / length);
+      const t1 = Math.min(1, (to - start) / length);
+      const at = (t) => [flat[3 * i - 3] + (flat[3 * i] - flat[3 * i - 3]) * t, flat[3 * i - 2] + (flat[3 * i + 1] - flat[3 * i - 2]) * t, flat[3 * i - 1] + (flat[3 * i + 2] - flat[3 * i - 1]) * t];
+      if (!out.length) out.push(at(t0));
+      out.push(at(t1));
+    }
+  }
+  return out;
+}
+
+function t3TangentAlong(route, at) {
+  const a = t3PointAlong(route, Math.max(0, at - 0.6));
+  const b = t3PointAlong(route, Math.min(route.total, at + 0.6));
+  return t3Unit([b[0] - a[0], b[1] - a[1], b[2] - a[2]]);
+}
+
+const t3RouteCache = new WeakMap();
+
+function t3PrepareTube(run, part, data) {
+  const spec = part.spec;
+  const source = data.routes[spec.route];
+  let route = t3RouteCache.get(source);
+  if (!route) {
+    route = t3RouteOf(source.points);
+    t3RouteCache.set(source, route);
+  }
+  const total = route.total;
+  const r = source.r;
+  const step = Math.max(0.05, Math.min(source.spacing, total / 4) * 0.5);
+  const lead = 0.5;
+  run.r = r;
+  run.wide = Boolean(source.wide);
+  run.hue = source.hue ?? null;
+  const partOf = (start, end) => {
+    const points = t3Cut(route, Math.max(0, start), Math.min(total, end));
+    let walked = Math.max(0, start);
+    const count = points.length;
+    const P3 = new Float64Array(3 * count);
+    const D3 = new Float64Array(3 * count);
+    for (let i = 0; i < count; i++) {
+      if (i > 0) walked += Math.hypot(points[i][0] - points[i - 1][0], points[i][1] - points[i - 1][1], points[i][2] - points[i - 1][2]);
+      const a = t3PointAlong(route, Math.max(0, Math.min(total, walked - step)));
+      const b = t3PointAlong(route, Math.max(0, Math.min(total, walked + step)));
+      for (let c = 0; c < 3; c++) {
+        P3[3 * i + c] = points[i][c];
+        D3[3 * i + c] = b[c] - a[c];
+      }
+    }
+    return { count, P3, D3 };
+  };
+  const openStart = spec.open0 && spec.from > 0;
+  const openEnd = spec.open1 && spec.to < total;
+  run.body = partOf(openStart ? spec.from - lead : spec.from, openEnd ? spec.to + lead : spec.to);
+  run.stripe = openStart || openEnd ? partOf(openStart ? spec.from - 2 * lead : spec.from, openEnd ? spec.to + 2 * lead : spec.to) : run.body;
+  const ends = [!spec.open0 && (spec.from <= 1e-6 || spec.gap0), !spec.open1 && (spec.to >= total - 1e-6 || spec.gap1)];
+  run.capped = [ends[0] && (spec.gap0 || spec.caps[0]), ends[1] && (spec.gap1 || spec.caps[1])];
+  const P3 = run.body.P3;
+  const last = run.body.count - 1;
+  const vec = (i, j) => t3Unit([P3[3 * i] - P3[3 * j], P3[3 * i + 1] - P3[3 * j + 1], P3[3 * i + 2] - P3[3 * j + 2]]);
+  run.tips = [vec(1, 0), vec(last, last - 1)];
+  run.rings = null;
+  if (source.rings) {
+    const { pitch = 3, twist = 0, cross = false, fade = [0.1, 0.55], phase = 0, steps = 16 } = source.rings;
+    const lo = openStart ? spec.from - 2 * lead : spec.from;
+    const hi = openEnd ? spec.to + 2 * lead : spec.to;
+    const margin = twist ? 0 : Math.min(pitch * 0.35, (hi - lo) / 2);
+    const from = Math.max(lo, !openStart ? lo + margin : lo);
+    const to = Math.min(hi, !openEnd ? hi - margin : hi);
+    const segments = [];
+    if (to > from) {
+      const hands = twist ? (cross ? [1, -1] : [1]) : [0];
+      const reach = Math.abs(twist) * r;
+      const first = Math.ceil((from - reach - phase) / pitch);
+      const lastIndex = Math.floor((to + reach - phase) / pitch);
+      const surface = (t, theta) => {
+        const at = Math.max(0, Math.min(total, t));
+        return { c: t3PointAlong(route, at), T: t3TangentAlong(route, at), theta };
+      };
+      for (let index = first; index <= lastIndex; index++) {
+        const station = phase + index * pitch;
+        for (const hand of hands) {
+          const samples = [];
+          for (let k = 0; k <= steps; k++) {
+            const theta = (k / steps) * Math.PI;
+            const t = station + hand * twist * r * (k / steps - 0.5);
+            samples.push({ t, theta });
+          }
+          for (let k = 0; k < steps; k++) {
+            let a = samples[k];
+            let b = samples[k + 1];
+            if ((a.t < from && b.t < from) || (a.t > to && b.t > to)) continue;
+            const clipTo = (x, y, edge) => ({ t: edge, theta: x.theta + ((y.theta - x.theta) * (edge - x.t)) / (y.t - x.t || 1e-9) });
+            if (a.t < from) a = clipTo(a, b, from);
+            if (b.t < from) b = clipTo(b, a, from);
+            if (a.t > to) a = clipTo(a, b, to);
+            if (b.t > to) b = clipTo(b, a, to);
+            segments.push([surface(a.t, a.theta), surface(b.t, b.theta)]);
+          }
+        }
+      }
+    }
+    run.rings = { segments, fade, tone: source.rings.tone ?? "lo" };
+  }
+}
+
+function t3Sides(part, cam, r) {
+  const m = cam.m;
+  const k = cam.k;
+  const n = part.count;
+  const out = { n, flat: new Float64Array(2 * n), left: new Float64Array(2 * n), right: new Float64Array(2 * n), shineA: new Float64Array(2 * n), shineB: new Float64Array(2 * n), shadeA: new Float64Array(2 * n), shadeB: new Float64Array(2 * n), frames: [] };
+  const half = r * k;
+  for (let i = 0; i < n; i++) {
+    const x = part.P3[3 * i];
+    const y = part.P3[3 * i + 1];
+    const z = part.P3[3 * i + 2];
+    const px = cam.ox + m[0] * x + m[1] * y + m[2] * z;
+    const py = cam.oy + m[3] * x + m[4] * y + m[5] * z;
+    const dx = m[0] * part.D3[3 * i] + m[1] * part.D3[3 * i + 1] + m[2] * part.D3[3 * i + 2];
+    const dy = m[3] * part.D3[3 * i] + m[4] * part.D3[3 * i + 1] + m[5] * part.D3[3 * i + 2];
+    const l = Math.hypot(dx, dy) || 1;
+    const nx = -dy / l;
+    const ny = dx / l;
+    out.flat[2 * i] = px;
+    out.flat[2 * i + 1] = py;
+    out.frames.push({ p: [px, py], nx, ny, half });
+    out.left[2 * i] = px + nx * half;
+    out.left[2 * i + 1] = py + ny * half;
+    out.right[2 * i] = px - nx * half;
+    out.right[2 * i + 1] = py - ny * half;
+    const toward = nx * T3_SHINE[0] + ny * T3_SHINE[1];
+    const shineAt = half * 0.44 * toward;
+    const shineHalf = half * 0.24;
+    out.shineA[2 * i] = px + nx * (shineAt + shineHalf);
+    out.shineA[2 * i + 1] = py + ny * (shineAt + shineHalf);
+    out.shineB[2 * i] = px + nx * (shineAt - shineHalf);
+    out.shineB[2 * i + 1] = py + ny * (shineAt - shineHalf);
+    const shadeAt = -half * 0.62 * toward;
+    const shadeHalf = half * 0.2;
+    out.shadeA[2 * i] = px + nx * (shadeAt + shadeHalf);
+    out.shadeA[2 * i + 1] = py + ny * (shadeAt + shadeHalf);
+    out.shadeB[2 * i] = px + nx * (shadeAt - shadeHalf);
+    out.shadeB[2 * i + 1] = py + ny * (shadeAt - shadeHalf);
+  }
+  return out;
+}
+
+const t3Pts = (buf, n) => {
+  const out = new Array(n);
+  for (let i = 0; i < n; i++) out[i] = [buf[2 * i], buf[2 * i + 1]];
+  return out;
+};
+
+function t3TubeCap(cam, centre, tangent, radius, inward) {
+  const V = cam.V;
+  const m = cam.m;
+  let n1 = [tangent[1] * V[2] - tangent[2] * V[1], tangent[2] * V[0] - tangent[0] * V[2], tangent[0] * V[1] - tangent[1] * V[0]];
+  if (Math.hypot(n1[0], n1[1], n1[2]) < 1e-6) {
+    const helper = Math.abs(tangent[2]) > 0.9 ? [1, 0, 0] : [0, 0, 1];
+    n1 = [helper[1] * tangent[2] - helper[2] * tangent[1], helper[2] * tangent[0] - helper[0] * tangent[2], helper[0] * tangent[1] - helper[1] * tangent[0]];
+  }
+  n1 = t3Unit(n1);
+  const n2 = t3Unit([tangent[1] * n1[2] - tangent[2] * n1[1], tangent[2] * n1[0] - tangent[0] * n1[2], tangent[0] * n1[1] - tangent[1] * n1[0]]);
+  const steps = 28;
+  const proj = (p) => [cam.ox + m[0] * p[0] + m[1] * p[1] + m[2] * p[2], cam.oy + m[3] * p[0] + m[4] * p[1] + m[5] * p[2]];
+  const ring = new Array(steps);
+  for (let index = 0; index < steps; index++) {
+    const angle = (index / steps) * T3_TAU;
+    const cs = radius * Math.cos(angle);
+    const sn = radius * Math.sin(angle);
+    ring[index] = proj([centre[0] + n1[0] * cs + n2[0] * sn, centre[1] + n1[1] * cs + n2[1] * sn, centre[2] + n1[2] * cs + n2[2] * sn]);
+  }
+  const C = proj(centre);
+  const probe = proj([centre[0] + n2[0], centre[1] + n2[1], centre[2] + n2[2]]);
+  const along = (probe[0] - C[0]) * inward[0] + (probe[1] - C[1]) * inward[1];
+  const from = along > 0 ? steps / 2 : 0;
+  const half = (start) => Array.from({ length: steps / 2 + 1 }, (_, index) => ring[(start + index) % steps]);
+  return { ring, arc: half(from), inner: half((from + steps / 2) % steps) };
+}
+
+function t3StripeEnd(half, centre, nx, ny, from, to) {
+  const offset = (p) => (p[0] - centre[0]) * nx + (p[1] - centre[1]) * ny;
+  const values = half.map(offset);
+  const lo = Math.min(from, to);
+  const hi = Math.max(from, to);
+  const points = [];
+  const cross = (k, level) => {
+    const t = (level - values[k]) / (values[k + 1] - values[k] || 1e-9);
+    return [half[k][0] + (half[k + 1][0] - half[k][0]) * t, half[k][1] + (half[k + 1][1] - half[k][1]) * t];
+  };
+  for (let k = 0; k < half.length; k++) {
+    if (values[k] >= lo && values[k] <= hi) points.push(half[k]);
+    if (k < half.length - 1) for (const level of [lo, hi]) if ((values[k] - level) * (values[k + 1] - level) < 0) points.push(cross(k, level));
+  }
+  return points
+    .map((p) => [p, offset(p)])
+    .sort((x, y) => (from > to ? y[1] - x[1] : x[1] - y[1]))
+    .map(([p]) => p);
+}
+
+function t3EmitTube(run, cam, f) {
+  const r = run.r;
+  const sides = t3Sides(run.body, cam, r);
+  const bands = run.stripe === run.body ? sides : t3Sides(run.stripe, cam, r);
+  const n = sides.n;
+  const left = t3Pts(sides.left, n);
+  const right = t3Pts(sides.right, n);
+  const loop = left.concat(right.slice().reverse());
+  let area = 0;
+  for (let i = 0; i < loop.length; i++) {
+    const a = loop[i];
+    const b = loop[(i + 1) % loop.length];
+    area += a[0] * b[1] - b[0] * a[1];
+  }
+  const sign = Math.sign(area);
+  let body = t3PathOf(loop, true);
+  let edges = t3PathOf(left, false) + t3PathOf(right, false);
+  const tips = [null, null];
+  const last = n - 1;
+  const quads = [];
+  for (let i = 0; i < last; i++) quads.push([left[i], left[i + 1], right[i + 1], right[i]]);
+  for (const side of [0, 1]) {
+    if (!run.capped[side]) continue;
+    const at = side ? last : 0;
+    const other = side ? last - 1 : 1;
+    const tangent = run.tips[side];
+    const outward = side ? tangent : [-tangent[0], -tangent[1], -tangent[2]];
+    const inward = [sides.flat[2 * other] - sides.flat[2 * at], sides.flat[2 * other + 1] - sides.flat[2 * at + 1]];
+    const centre = [run.body.P3[3 * at], run.body.P3[3 * at + 1], run.body.P3[3 * at + 2]];
+    const { ring, arc, inner } = t3TubeCap(cam, centre, tangent, r, inward);
+    let ringArea = 0;
+    for (let i = 0; i < ring.length; i++) {
+      const a = ring[i];
+      const b = ring[(i + 1) % ring.length];
+      ringArea += a[0] * b[1] - b[0] * a[1];
+    }
+    body += t3PathOf(Math.sign(ringArea) === sign ? ring : ring.slice().reverse(), true);
+    edges += t3PathOf(arc, false);
+    const V = cam.V;
+    const open = outward[0] * V[0] + outward[1] * V[1] + outward[2] * V[2] > 0;
+    if (open) edges += t3PathOf(inner, false);
+    tips[side] = { half: open ? inner : arc, frame: sides.frames[at] };
+    quads.push(ring);
+  }
+  f.d[run.role.body] = body;
+  f.d[run.role.edges] = edges;
+  if (run.wide) {
+    const toward = (frame) => frame.nx * T3_SHINE[0] + frame.ny * T3_SHINE[1];
+    const shineOffsets = (frame) => [frame.half * 0.44 * toward(frame) + frame.half * 0.24, frame.half * 0.44 * toward(frame) - frame.half * 0.24];
+    const shadeOffsets = (frame) => [-frame.half * 0.62 * toward(frame) + frame.half * 0.2, -frame.half * 0.62 * toward(frame) - frame.half * 0.2];
+    const bn = bands.n;
+    const band = (A, B, offsets) => {
+      const head = tips[1] ? t3StripeEnd(tips[1].half, tips[1].frame.p, tips[1].frame.nx, tips[1].frame.ny, offsets(tips[1].frame)[0], offsets(tips[1].frame)[1]) : [];
+      const tail = tips[0] ? t3StripeEnd(tips[0].half, tips[0].frame.p, tips[0].frame.nx, tips[0].frame.ny, offsets(tips[0].frame)[1], offsets(tips[0].frame)[0]) : [];
+      return t3PathOf([...t3Pts(A, bn), ...head, ...t3Pts(B, bn).reverse(), ...tail], true);
+    };
+    f.d[run.role.shine] = band(bands.shineA, bands.shineB, shineOffsets);
+    f.d[run.role.shade] = band(bands.shadeA, bands.shadeB, shadeOffsets);
+  }
+  if (run.rings) {
+    const lines = t3Lines;
+    lines.d.length = 0;
+    lines.alpha.length = 0;
+  lines.key.length = 0;
+    lines.key.length = 0;
+    const V = cam.V;
+    const m = cam.m;
+    const seg = new Float64Array(4);
+    const surface = (sample, out, index) => {
+      const T = sample.T;
+      let n1 = [T[1] * V[2] - T[2] * V[1], T[2] * V[0] - T[0] * V[2], T[0] * V[1] - T[1] * V[0]];
+      const l1 = Math.hypot(n1[0], n1[1], n1[2]);
+      if (l1 < 1e-6) return null;
+      n1 = [n1[0] / l1, n1[1] / l1, n1[2] / l1];
+      let n2 = t3Unit([T[1] * n1[2] - T[2] * n1[1], T[2] * n1[0] - T[0] * n1[2], T[0] * n1[1] - T[1] * n1[0]]);
+      if (n2[0] * V[0] + n2[1] * V[1] + n2[2] * V[2] < 0) n2 = [-n2[0], -n2[1], -n2[2]];
+      const cs = Math.cos(sample.theta);
+      const sn = Math.sin(sample.theta);
+      const normal = [n1[0] * cs + n2[0] * sn, n1[1] * cs + n2[1] * sn, n1[2] * cs + n2[2] * sn];
+      const p = [sample.c[0] + normal[0] * r, sample.c[1] + normal[1] * r, sample.c[2] + normal[2] * r];
+      out[index] = cam.ox + m[0] * p[0] + m[1] * p[1] + m[2] * p[2];
+      out[index + 1] = cam.oy + m[3] * p[0] + m[4] * p[1] + m[5] * p[2];
+      return normal[0] * V[0] + normal[1] * V[1] + normal[2] * V[2];
+    };
+    const fade = run.rings.fade;
+    let index = -1;
+    for (const [a, b] of run.rings.segments) {
+      index++;
+      const fa = surface(a, seg, 0);
+      const fb = surface(b, seg, 2);
+      if (fa === null || fb === null) continue;
+      const alpha = fade ? t3Step(fade[0], fade[1], (fa + fb) / 2) : 1;
+      if (alpha * T3_LEVELS < 0.5) continue;
+      lines.d.push(t3Path(seg, 2, false));
+      lines.alpha.push(alpha);
+      lines.key.push(index);
+    }
+    f.levels = t3Faded(f, run, "r", lines, lines.d.length);
+  }
+  const all = left.concat(right);
+  t3BoxOf(all, f.box);
+  for (const q of quads) for (const p of q) {
+    if (p[0] < f.box[0]) f.box[0] = p[0];
+    if (p[1] < f.box[1]) f.box[1] = p[1];
+    if (p[0] > f.box[2]) f.box[2] = p[0];
+    if (p[1] > f.box[3]) f.box[3] = p[1];
+  }
+  const list = f.quadList && f.quadList.length === quads.length ? f.quadList : (f.quadList = quads.map(() => [new Float64Array(0), 0]));
+  for (let qi = 0; qi < quads.length; qi++) {
+    const q = quads[qi];
+    let entry = list[qi];
+    if (entry[0].length < 2 * q.length) entry[0] = new Float64Array(2 * q.length);
+    const buf = entry[0];
+    for (let i = 0; i < q.length; i++) {
+      buf[2 * i] = q[i][0];
+      buf[2 * i + 1] = q[i][1];
+    }
+    entry[1] = q.length;
+  }
+  f.quadN = quads.length;
+  f.quads = f.quadList;
+  f.hullN = 0;
+}
+
+function t3Emit(run, cam, out) {
+  const f = out ?? t3Frame(run);
+  if (t3Arena.on) {
+    t3Arena.f = f;
+    f.arenaN = 0;
+  }
+  if (run.kind === "prism") t3EmitPrism(run, cam, f);
+  else if (run.kind === "round") t3EmitRound(run, cam, f);
+  else if (run.kind === "ball") t3EmitBall(run, cam, f);
+  else if (run.kind === "lathe") t3EmitLathe(run, cam, f);
+  else if (run.kind === "tube") {
+    t3EmitTube(run, cam, f);
+    return f;
+  } else if (run.kind === "fixed") {
+    t3EmitFixed(run, cam, f);
+    return f;
+  } else if (run.kind === "item") {
+    f.box[0] = run.itemBox[0];
+    f.box[1] = run.itemBox[1];
+    f.box[2] = run.itemBox[2];
+    f.box[3] = run.itemBox[3];
+    const count = run.itemHull.length / 2;
+    const hull = t3Grow(f, "hull", 2 * Math.max(1, count), Float64Array);
+    for (let i = 0; i < 2 * count; i++) hull[i] = run.itemHull[i];
+    f.hullN = count;
+    return f;
+  }
+  t3EmitPlanes(run, cam, f);
+  t3EmitDots(run, cam, f);
+  return f;
+}
+
+function t3Overlap(a, b, pad) {
+  return a[0] < b[2] - pad && b[0] < a[2] - pad && a[1] < b[3] - pad && b[1] < a[3] - pad;
+}
+
+function t3Apart(A, an, B, bn, pad) {
+  for (let pass = 0; pass < 2; pass++) {
+    const P = pass ? B : A;
+    const pn = pass ? bn : an;
+    for (let i = 0; i < pn; i++) {
+      const j = (i + 1) % pn;
+      const nx = P[2 * j + 1] - P[2 * i + 1];
+      const ny = P[2 * i] - P[2 * j];
+      const l = Math.hypot(nx, ny);
+      if (l < 1e-9) continue;
+      let a0 = Infinity;
+      let a1 = -Infinity;
+      for (let q = 0; q < an; q++) {
+        const v = (A[2 * q] * nx + A[2 * q + 1] * ny) / l;
+        if (v < a0) a0 = v;
+        if (v > a1) a1 = v;
+      }
+      let b0 = Infinity;
+      let b1 = -Infinity;
+      for (let q = 0; q < bn; q++) {
+        const v = (B[2 * q] * nx + B[2 * q + 1] * ny) / l;
+        if (v < b0) b0 = v;
+        if (v > b1) b1 = v;
+      }
+      if (a1 < b0 + pad || b1 < a0 + pad) return true;
+    }
+  }
+  return false;
+}
+
+function t3Disjoint(fa, fb, pad) {
+  const qa = fa.quadN ? fa.quads : null;
+  const qb = fb.quadN ? fb.quads : null;
+  if (!qa && !qb) return t3Apart(fa.hull, fa.hullN, fb.hull, fb.hullN, pad);
+  const listA = qa ? fa.quadList : [[fa.hull, fa.hullN]];
+  const listB = qb ? fb.quadList : [[fb.hull, fb.hullN]];
+  for (const [A, an] of listA) for (const [B, bn] of listB) if (!t3Apart(A, an, B, bn, pad)) return false;
+  return true;
+}
+
+function t3Support(cloud, R, t, dir, world) {
+  let best = -Infinity;
+  let at = 0;
+  const n = cloud.length / 3;
+  const dx = R[0] * dir[0] + R[3] * dir[1] + R[6] * dir[2];
+  const dy = R[1] * dir[0] + R[4] * dir[1] + R[7] * dir[2];
+  const dz = R[2] * dir[0] + R[5] * dir[1] + R[8] * dir[2];
+  for (let i = 0; i < n; i++) {
+    const v = cloud[3 * i] * dx + cloud[3 * i + 1] * dy + cloud[3 * i + 2] * dz;
+    if (v > best) {
+      best = v;
+      at = i;
+    }
+  }
+  const x = cloud[3 * at];
+  const y = cloud[3 * at + 1];
+  const z = cloud[3 * at + 2];
+  world[0] = R[0] * x + R[1] * y + R[2] * z + t[0];
+  world[1] = R[3] * x + R[4] * y + R[5] * z + t[1];
+  world[2] = R[6] * x + R[7] * y + R[8] * z + t[2];
+  return best + dir[0] * t[0] + dir[1] * t[1] + dir[2] * t[2];
+}
+
+function t3Gjk(cloudA, camA, cloudB, camB, warm, rounds = 8, hints = null) {
+  let w = warm && (warm[0] || warm[1] || warm[2]) ? [warm[0], warm[1], warm[2]] : null;
+  const a = [0, 0, 0];
+  const b = [0, 0, 0];
+  if (!w) {
+    t3Support(cloudA, camA.R, camA.t, [1, 0, 0], a);
+    t3Support(cloudB, camB.R, camB.t, [-1, 0, 0], b);
+    w = [b[0] - a[0], b[1] - a[1], b[2] - a[2]];
+  }
+  let margin = -Infinity;
+  let best = w;
+  const step = (limit) => {
+    for (let it = 0; it < limit; it++) {
+      const l = Math.hypot(w[0], w[1], w[2]);
+      if (l < 1e-12) break;
+      const n = [w[0] / l, w[1] / l, w[2] / l];
+      const hiA = t3Support(cloudA, camA.R, camA.t, n, a);
+      const loB = -t3Support(cloudB, camB.R, camB.t, [-n[0], -n[1], -n[2]], b);
+      const value = loB - hiA;
+      if (value > margin) {
+        margin = value;
+        best = n;
+      }
+      const s = [b[0] - a[0], b[1] - a[1], b[2] - a[2]];
+      const ds = [w[0] - s[0], w[1] - s[1], w[2] - s[2]];
+      const dd = ds[0] * ds[0] + ds[1] * ds[1] + ds[2] * ds[2];
+      if (dd < 1e-14) break;
+      const tt = Math.max(0, Math.min(1, (w[0] * ds[0] + w[1] * ds[1] + w[2] * ds[2]) / dd));
+      w = [w[0] - ds[0] * tt, w[1] - ds[1] * tt, w[2] - ds[2] * tt];
+    }
+  };
+  step(rounds);
+  if (margin < 0) step(24);
+  if (margin < 0.05 && hints) {
+    if (hints.centroids) {
+      const [ca, cb] = hints.centroids;
+      const wa = [camA.R[0] * ca[0] + camA.R[1] * ca[1] + camA.R[2] * ca[2] + camA.t[0], camA.R[3] * ca[0] + camA.R[4] * ca[1] + camA.R[5] * ca[2] + camA.t[1], camA.R[6] * ca[0] + camA.R[7] * ca[1] + camA.R[8] * ca[2] + camA.t[2]];
+      const wb = [camB.R[0] * cb[0] + camB.R[1] * cb[1] + camB.R[2] * cb[2] + camB.t[0], camB.R[3] * cb[0] + camB.R[4] * cb[1] + camB.R[5] * cb[2] + camB.t[1], camB.R[6] * cb[0] + camB.R[7] * cb[1] + camB.R[8] * cb[2] + camB.t[2]];
+      const n = t3Unit([wb[0] - wa[0], wb[1] - wa[1], wb[2] - wa[2]]);
+      const hiA = t3Support(cloudA, camA.R, camA.t, n, a);
+      const loB = -t3Support(cloudB, camB.R, camB.t, [-n[0], -n[1], -n[2]], b);
+      if (loB - hiA > margin) {
+        margin = loB - hiA;
+        best = n;
+      }
+    }
+    for (const [axis, cam] of hints) {
+      const R = cam.R;
+      const w0 = [R[0] * axis[0] + R[1] * axis[1] + R[2] * axis[2], R[3] * axis[0] + R[4] * axis[1] + R[5] * axis[2], R[6] * axis[0] + R[7] * axis[1] + R[8] * axis[2]];
+      for (const sign of [1, -1]) {
+        const n = [w0[0] * sign, w0[1] * sign, w0[2] * sign];
+        const hiA = t3Support(cloudA, camA.R, camA.t, n, a);
+        const loB = -t3Support(cloudB, camB.R, camB.t, [-n[0], -n[1], -n[2]], b);
+        if (loB - hiA > margin) {
+          margin = loB - hiA;
+          best = n;
+        }
+      }
+    }
+  }
+  const l = Math.hypot(best[0], best[1], best[2]) || 1;
+  return { n: [best[0] / l, best[1] / l, best[2] / l], margin };
+}
+
+function t3Order(layer, frames, cams, previous, stats, scene) {
+  const parts = layer.parts;
+  const count = parts.length;
+  const local = layer.local;
+  const rank = layer._rank ?? (layer._rank = new Int32Array(count));
+  if (previous) for (let at = 0; at < count; at++) rank[local.get(previous[at])] = at;
+  else for (let at = 0; at < count; at++) rank[local.get(layer.rest[at])] = at;
+  let groupEdges = 0;
+  if (layer.groupPairs) for (const gp of layer.groupPairs) groupEdges += gp.a.length * gp.b.length;
+  const maxEdges = layer.planar.length / 5 + (layer.framed ? layer.framed.length / 6 : 0) + groupEdges + layer.dynamic.length / 2 + (layer.free ? layer.free.length * count : 0) + 1;
+  const head = layer._head ?? (layer._head = new Int32Array(count));
+  const next = layer._next && layer._next.length >= maxEdges ? layer._next : (layer._next = new Int32Array(maxEdges));
+  const to = layer._to && layer._to.length >= maxEdges ? layer._to : (layer._to = new Int32Array(maxEdges));
+  const live = layer._live && layer._live.length >= maxEdges ? layer._live : (layer._live = new Uint8Array(maxEdges));
+  const indeg = layer._indeg ?? (layer._indeg = new Int32Array(count));
+  head.fill(-1);
+  indeg.fill(0);
+  let edges = 0;
+  const addEdge = (back, front) => {
+    to[edges] = front;
+    next[edges] = head[back];
+    live[edges] = 1;
+    head[back] = edges;
+    indeg[front]++;
+    edges++;
+  };
+  const runs = scene ? scene.runs : null;
+  const groupOf = (global) => (runs ? runs[global].group : -1);
+  const planar = layer.planar;
+  for (let p = 0; p < planar.length; p += 5) {
+    const i = planar[p];
+    const j = planar[p + 1];
+    const fi = frames[i];
+    const fj = frames[j];
+    if (!t3Overlap(fi.box, fj.box, -0.05)) continue;
+    const g = groupOf(i);
+    const V = g >= 0 ? cams[g].V : cams.world.V;
+    const s = planar[p + 2] * V[0] + planar[p + 3] * V[1] + planar[p + 4] * V[2];
+    if (s < 1e-7 && s > -1e-7) continue;
+    const li = local.get(i);
+    const lj = local.get(j);
+    if (s > 0) addEdge(li, lj);
+    else addEdge(lj, li);
+  }
+  const framed = layer.framed;
+  if (framed)
+    for (let p = 0; p < framed.length; p += 6) {
+      const i = framed[p];
+      const j = framed[p + 1];
+      if (!t3Overlap(frames[i].box, frames[j].box, -0.05)) continue;
+      const g = framed[p + 2];
+      const V = g >= 0 ? cams[g].V : cams.world.V;
+      const s = framed[p + 3] * V[0] + framed[p + 4] * V[1] + framed[p + 5] * V[2];
+      if (s < 1e-7 && s > -1e-7) continue;
+      const li = local.get(i);
+      const lj = local.get(j);
+      if (s > 0) addEdge(li, lj);
+      else addEdge(lj, li);
+    }
+  if (layer.groupPairs)
+    for (const gp of layer.groupPairs) {
+      const union = (list, box) => {
+        box[0] = Infinity;
+        box[1] = Infinity;
+        box[2] = -Infinity;
+        box[3] = -Infinity;
+        for (let q = 0; q < list.length; q++) {
+          const b = frames[list[q]].box;
+          if (b[0] < box[0]) box[0] = b[0];
+          if (b[1] < box[1]) box[1] = b[1];
+          if (b[2] > box[2]) box[2] = b[2];
+          if (b[3] > box[3]) box[3] = b[3];
+        }
+      };
+      union(gp.a, gp.boxA);
+      union(gp.b, gp.boxB);
+      if (!t3Overlap(gp.boxA, gp.boxB, -0.05)) continue;
+      const V = gp.frame >= 0 ? cams[gp.frame].V : cams.world.V;
+      const s = gp.n[0] * V[0] + gp.n[1] * V[1] + gp.n[2] * V[2];
+      if (s < 1e-7 && s > -1e-7) continue;
+      for (let x = 0; x < gp.a.length; x++) {
+        const i = gp.a[x];
+        const bi = frames[i].box;
+        if (!t3Overlap(bi, gp.boxB, -0.05)) continue;
+        for (let y = 0; y < gp.b.length; y++) {
+          const j = gp.b[y];
+          if (!t3Overlap(bi, frames[j].box, -0.05)) continue;
+          if (s > 0) addEdge(local.get(i), local.get(j));
+          else addEdge(local.get(j), local.get(i));
+        }
+      }
+    }
+  const dynamic = layer.dynamic;
+  let unseparated = 0;
+  let solved = 0;
+  const rel = layer.rel ?? (layer.rel = new Map());
+  const cross = (i, j) => {
+    const ri = runs[i];
+    const rj = runs[j];
+    const ci = ri.group >= 0 ? cams[ri.group] : cams.world;
+    const cj = rj.group >= 0 ? cams[rj.group] : cams.world;
+    const A = ci.R;
+    const B = cj.R;
+    const dx = cj.t[0] - ci.t[0];
+    const dy = cj.t[1] - ci.t[1];
+    const dz = cj.t[2] - ci.t[2];
+    const key = i * 65536 + j;
+    let memo = rel.get(key);
+    if (!memo) {
+      memo = { pose: new Float64Array(12), n: [0, 0, 0], margin: -Infinity, fresh: false, vi: -1, vj: -1 };
+      rel.set(key, memo);
+    }
+    const pose = memo.pose;
+    const vi = ri.version ?? 0;
+    const vj = rj.version ?? 0;
+    let same = memo.fresh && memo.vi === vi && memo.vj === vj;
+    memo.vi = vi;
+    memo.vj = vj;
+    let at = 0;
+    for (let c = 0; c < 3; c++)
+      for (let r = 0; r < 3; r++) {
+        const v = A[c] * B[r] + A[3 + c] * B[3 + r] + A[6 + c] * B[6 + r];
+        if (same && Math.abs(pose[at] - v) > 1e-12) same = false;
+        pose[at++] = v;
+      }
+    for (let c = 0; c < 3; c++) {
+      const v = A[c] * dx + A[3 + c] * dy + A[6 + c] * dz;
+      if (same && Math.abs(pose[at] - v) > 1e-9) same = false;
+      pose[at++] = v;
+    }
+    let nx;
+    let ny;
+    let nz;
+    if (same) {
+      const n = memo.n;
+      nx = A[0] * n[0] + A[1] * n[1] + A[2] * n[2];
+      ny = A[3] * n[0] + A[4] * n[1] + A[5] * n[2];
+      nz = A[6] * n[0] + A[7] * n[1] + A[8] * n[2];
+    } else {
+      const n = memo.n;
+      const warm = memo.fresh ? [A[0] * n[0] + A[1] * n[1] + A[2] * n[2], A[3] * n[0] + A[4] * n[1] + A[5] * n[2], A[6] * n[0] + A[7] * n[1] + A[8] * n[2]] : null;
+      const hints = [...ri.axes.map((axis) => [axis, ci]), ...rj.axes.map((axis) => [axis, cj]), [[0, 0, 1], cams.world]];
+      hints.centroids = [ri.centroid, rj.centroid];
+      const hit = t3Gjk(ri.cloud, ci, rj.cloud, cj, warm, 8, hints);
+      solved++;
+      nx = hit.n[0];
+      ny = hit.n[1];
+      nz = hit.n[2];
+      n[0] = A[0] * nx + A[3] * ny + A[6] * nz;
+      n[1] = A[1] * nx + A[4] * ny + A[7] * nz;
+      n[2] = A[2] * nx + A[5] * ny + A[8] * nz;
+      memo.margin = hit.margin;
+      memo.fresh = true;
+    }
+    if (memo.margin < -0.08) unseparated++;
+    const V = cams.world.V;
+    return nx * V[0] + ny * V[1] + nz * V[2];
+  };
+  for (let p = 0; p < dynamic.length; p += 2) {
+    const i = dynamic[p];
+    const j = dynamic[p + 1];
+    if (!t3Overlap(frames[i].box, frames[j].box, -0.05)) continue;
+    const s = cross(i, j);
+    if (s < 1e-7 && s > -1e-7) continue;
+    const li = local.get(i);
+    const lj = local.get(j);
+    if (s > 0) addEdge(li, lj);
+    else addEdge(lj, li);
+  }
+  const loose = layer.free;
+  if (loose && loose.length) {
+    const isLoose = layer.looseAt;
+    for (let a = 0; a < loose.length; a++) {
+      const i = loose[a];
+      const gi = runs[i].group;
+      const bi = frames[i].box;
+      for (let b = 0; b < count; b++) {
+        const j = parts[b];
+        if (j === i || runs[j].group === gi) continue;
+        if (isLoose[b] && j < i) continue;
+        if (!t3Overlap(bi, frames[j].box, -0.05)) continue;
+        const s = cross(i, j);
+        if (s < 1e-7 && s > -1e-7) continue;
+        const li = local.get(i);
+        if (s > 0) addEdge(li, b);
+        else addEdge(b, li);
+      }
+    }
+  }
+  const heap = layer._heap ?? (layer._heap = new Int32Array(count));
+  const done = layer._done ?? (layer._done = new Uint8Array(count));
+  done.fill(0);
+  let size = 0;
+  const less = (a, b) => rank[a] < rank[b];
+  const push = (v) => {
+    let i = size++;
+    heap[i] = v;
+    while (i > 0) {
+      const p = (i - 1) >> 1;
+      if (!less(heap[i], heap[p])) break;
+      const tmp = heap[i];
+      heap[i] = heap[p];
+      heap[p] = tmp;
+      i = p;
+    }
+  };
+  const pop = () => {
+    const top = heap[0];
+    heap[0] = heap[--size];
+    let i = 0;
+    for (;;) {
+      const l = 2 * i + 1;
+      const r = l + 1;
+      let s = i;
+      if (l < size && less(heap[l], heap[s])) s = l;
+      if (r < size && less(heap[r], heap[s])) s = r;
+      if (s === i) break;
+      const tmp = heap[i];
+      heap[i] = heap[s];
+      heap[s] = tmp;
+      i = s;
+    }
+    return top;
+  };
+  for (let v = 0; v < count; v++) if (indeg[v] === 0) push(v);
+  const out = new Int32Array(count);
+  let placed = 0;
+  let forced = 0;
+  let refined = 0;
+  let tested = false;
+  const mark = layer._mark && layer._mark.length >= count ? layer._mark : (layer._mark = new Uint8Array(count));
+  const via = layer._via && layer._via.length >= count ? layer._via : (layer._via = new Int32Array(count));
+  const iter = layer._iter && layer._iter.length >= count ? layer._iter : (layer._iter = new Int32Array(count));
+  const stack = layer._stack && layer._stack.length >= count ? layer._stack : (layer._stack = new Int32Array(count));
+  const checked = layer._checked && layer._checked.length >= maxEdges ? layer._checked : (layer._checked = new Uint8Array(maxEdges));
+  checked.fill(0, 0, edges);
+  const breakCycle = () => {
+    mark.fill(0, 0, count);
+    for (let root = 0; root < count; root++) {
+      if (done[root] || mark[root]) continue;
+      let top = 0;
+      stack[top++] = root;
+      mark[root] = 1;
+      iter[root] = head[root];
+      while (top) {
+        const v = stack[top - 1];
+        let e = iter[v];
+        while (e >= 0 && (!live[e] || done[to[e]] || mark[to[e]] === 2)) e = next[e];
+        if (e < 0) {
+          mark[v] = 2;
+          top--;
+          continue;
+        }
+        iter[v] = next[e];
+        const w = to[e];
+        if (mark[w] === 1) {
+          let dropped = false;
+          let x = v;
+          let edge = e;
+          for (;;) {
+            if (!checked[edge]) {
+              checked[edge] = 1;
+              const a = x;
+              const b = to[edge];
+              if (t3Disjoint(frames[parts[a]], frames[parts[b]], 0.1)) {
+                live[edge] = 0;
+                indeg[b]--;
+                refined++;
+                dropped = true;
+                if (indeg[b] === 0) push(b);
+              }
+            }
+            if (x === w) break;
+            edge = via[x];
+            let from = -1;
+            for (let s = 0; s < top; s++) if (stack[s] === x) from = s > 0 ? stack[s - 1] : -1;
+            if (from < 0) break;
+            x = from;
+          }
+          return dropped ? 1 : 0;
+        }
+        via[w] = e;
+        mark[w] = 1;
+        iter[w] = head[w];
+        stack[top++] = w;
+      }
+    }
+    return -1;
+  };
+  while (placed < count) {
+    if (size === 0) {
+      let broken = 0;
+      for (let tries = 0; tries < 64 && size === 0; tries++) {
+        const result = breakCycle();
+        if (result <= 0) break;
+        broken++;
+      }
+      if (size) continue;
+      void broken;
+      void tested;
+      let pick = -1;
+      for (let v = 0; v < count; v++) if (!done[v] && (pick < 0 || indeg[v] < indeg[pick] || (indeg[v] === indeg[pick] && rank[v] < rank[pick]))) pick = v;
+      forced++;
+      indeg[pick] = 0;
+      push(pick);
+    }
+    const v = pop();
+    if (done[v]) continue;
+    done[v] = 1;
+    out[placed++] = parts[v];
+    for (let e = head[v]; e >= 0; e = next[e]) {
+      if (!live[e]) continue;
+      const w = to[e];
+      if (done[w]) continue;
+      if (--indeg[w] === 0) push(w);
+    }
+  }
+  if (stats) {
+    stats.edges = (stats.edges ?? 0) + edges;
+    stats.forced = (stats.forced ?? 0) + forced;
+    stats.refined = (stats.refined ?? 0) + refined;
+    stats.unseparated = (stats.unseparated ?? 0) + unseparated;
+    stats.solved = (stats.solved ?? 0) + solved;
+  }
+  return out;
+}
+
+function t3Keep(values) {
+  const n = values.length;
+  const tails = [];
+  const tailAt = [];
+  const back = new Int32Array(n).fill(-1);
+  for (let i = 0; i < n; i++) {
+    let lo = 0;
+    let hi = tails.length;
+    while (lo < hi) {
+      const mid = (lo + hi) >> 1;
+      if (tails[mid] < values[i]) lo = mid + 1;
+      else hi = mid;
+    }
+    tails[lo] = values[i];
+    tailAt[lo] = i;
+    back[i] = lo > 0 ? tailAt[lo - 1] : -1;
+  }
+  const keep = new Uint8Array(n);
+  let k = tails.length ? tailAt[tails.length - 1] : -1;
+  while (k >= 0) {
+    keep[k] = 1;
+    k = back[k];
+  }
+  return keep;
+}
+
+function t3Cams(scene, values) {
+  const poses = t3Poses(scene.groups, values);
+  const cams = poses.map((pose) => t3Camera(scene.P, pose));
+  cams.world = t3Camera(scene.P, null);
+  cams.poses = poses;
+  return cams;
+}
+
+function t3Mount(stage, data, { onHold = null, onFrame = null, follow = null, painter = "svg", numeric = painter === "canvas", canvasLayers = null, shift = false } = {}) {
+  const canvasSet = painter === "canvas" ? new Set(canvasLayers ?? data.layers.map((layer) => layer.name)) : new Set();
+  const dom = canvasSet.size < data.layers.length;
+  const domLayer = data.layers.map((layer) => !canvasSet.has(layer.name));
+  const layerEls = new Map([...stage.querySelectorAll("svg[data-live]")].map((svg) => [svg.dataset.live, svg]));
+  const first = layerEls.values().next().value;
+  const viewWidth = first && first.viewBox && first.viewBox.baseVal ? first.viewBox.baseVal.width : 0;
+  const unitOf = () => {
+    const width = first ? first.getBoundingClientRect().width : 0;
+    return viewWidth && width ? Math.round((width / viewWidth) * 100) / 100 : 1;
+  };
+  let unit = unitOf();
+  let scene = t3Prepare(data, { unit });
+  const runs = () => scene.runs;
+  const count = data.parts.length;
+  const nodes = new Array(count);
+  const bound = new Array(count);
+  const cache = new Array(count);
+  const containers = new Map();
+  for (const [name, svg] of layerEls) containers.set(name, svg.querySelector(".iso-parts") ?? svg);
+  for (const run of scene.runs) {
+    const layer = data.layers[run.layer];
+    const container = containers.get(layer.name);
+    const node = container ? container.querySelector(`[data-p="${run.index}"]`) : null;
+    nodes[run.index] = node;
+    const map = {};
+    if (node) {
+      map.move = node;
+      node.querySelectorAll("[data-r]").forEach((el) => (map[el.getAttribute("data-r")] = el));
+    }
+    bound[run.index] = run.roles.map((role) => map[role.name] ?? null);
+    cache[run.index] = run.roles.map(() => ({ d: null, q: null, b: null, f: null, w: null, t: null, o: null, cx: null, cy: null }));
+  }
+  const frames = scene.runs.map((run) => t3Frame(run));
+  const values = Object.fromEntries(data.groups.map((g) => [g.name, data.values ? data.values[g.name] ?? 0 : 0]));
+  let lastPoses = null;
+  let cams = null;
+  const orders = scene.layers.map((layer) => Int32Array.from(layer.rest));
+  const changes = [];
+  const stats = { ms: 0, writes: 0, moved: 0, forced: 0, refined: 0, unseparated: 0, emitted: 0 };
+  let writes = 0;
+  const write = (index) => {
+    const run = scene.runs[index];
+    const f = frames[index];
+    const els = bound[index];
+    const memo = cache[index];
+    for (let r = 0; r < run.roles.length; r++) {
+      const el = els[r];
+      if (!el) continue;
+      const role = run.roles[r];
+      const c = memo[r];
+      const type = role.type;
+      if (type === "path" || type === "face" || type === "slot") {
+        const d = f.d[r];
+        if (c.d !== d) {
+          el.setAttribute("d", d);
+          c.d = d;
+          writes++;
+        }
+        if (type === "face") {
+          const q = f.q[r];
+          if (c.q !== q) {
+            const band = Math.min(3, Math.floor(q / T3_Q));
+            const mix = (q - T3_Q * band) / T3_Q;
+            if (c.b !== band) {
+              el.setAttribute("data-b", String(band));
+              c.b = band;
+              writes++;
+            }
+            if (c.f !== mix) {
+              if (mix) el.style.setProperty("--f", String(mix));
+              else el.style.removeProperty("--f");
+              c.f = mix;
+              writes++;
+            }
+            c.q = q;
+          }
+          const w = f.w[r];
+          if (c.w !== w) {
+            if (w < 0) el.style.removeProperty("stroke-width");
+            else el.style.strokeWidth = String(w);
+            c.w = w;
+            writes++;
+          }
+        } else if (type === "slot") {
+          const o = f.o[r];
+          if (c.o !== o) {
+            el.setAttribute("opacity", String(Math.round(o * 1000) / 1000));
+            c.o = o;
+            writes++;
+          }
+        }
+      } else if (type === "xform" || type === "self" || type === "plane") {
+        const t = f.t[r];
+        if (c.t !== t) {
+          if (t) el.setAttribute("transform", t);
+          else el.removeAttribute("transform");
+          c.t = t;
+          writes++;
+        }
+        if (type === "plane") {
+          const o = f.o[r];
+          if (c.o !== o) {
+            el.setAttribute("opacity", String(o));
+            c.o = o;
+            writes++;
+          }
+        }
+      } else if (type === "dot") {
+        const x = Math.round(f.cx[r] * 100) / 100;
+        const y = Math.round(f.cy[r] * 100) / 100;
+        const o = f.o[r];
+        if (c.cx !== x) {
+          el.setAttribute("cx", String(x));
+          c.cx = x;
+          writes++;
+        }
+        if (c.cy !== y) {
+          el.setAttribute("cy", String(y));
+          c.cy = y;
+          writes++;
+        }
+        if (c.o !== o) {
+          el.setAttribute("fill-opacity", String(o));
+          c.o = o;
+          writes++;
+        }
+      }
+    }
+  };
+  const samePose = (a, b) => {
+    if (!a || !b) return false;
+    for (let i = 0; i < 9; i++) if (a.R[i] !== b.R[i]) return false;
+    return a.t[0] === b.t[0] && a.t[1] === b.t[1] && a.t[2] === b.t[2];
+  };
+  let lastUnit = unit;
+  let moved = 0;
+  let snapshotNext = false;
+  const emittedList = [];
+  const shiftOn = Boolean(shift);
+  const emitAt = shiftOn ? new Array(count) : null;
+  const shiftable = (run) => run.kind === "prism" || run.kind === "round" || run.kind === "ball" || run.kind === "lathe";
+  const sameView = (base, cam) => {
+    const m = cam.m;
+    const b = base.m;
+    for (let i = 0; i < 6; i++) if (m[i] !== b[i]) return false;
+    return true;
+  };
+  const keepEmit = (run, cam, f) => {
+    let base = emitAt[run.index];
+    if (!base) base = emitAt[run.index] = { m: new Float64Array(6), ox: 0, oy: 0, box: new Float64Array(4), hull: new Float64Array(0), hullN: 0 };
+    base.m.set(cam.m);
+    base.ox = cam.ox;
+    base.oy = cam.oy;
+    base.box.set(f.box);
+    if (base.hull.length < 2 * f.hullN) base.hull = new Float64Array(2 * f.hullN);
+    for (let i = 0; i < 2 * f.hullN; i++) base.hull[i] = f.hull[i];
+    base.hullN = f.hullN;
+  };
+  const shiftFrame = (f, base, dx, dy) => {
+    f.box[0] = base.box[0] + dx;
+    f.box[1] = base.box[1] + dy;
+    f.box[2] = base.box[2] + dx;
+    f.box[3] = base.box[3] + dy;
+    const hull = t3Grow(f, "hull", 2 * base.hullN, Float64Array);
+    for (let i = 0; i < base.hullN; i++) {
+      hull[2 * i] = base.hull[2 * i] + dx;
+      hull[2 * i + 1] = base.hull[2 * i + 1] + dy;
+    }
+    f.hullN = base.hullN;
+    f.sx = dx;
+    f.sy = dy;
+  };
+  const writeShift = (index, dx, dy) => {
+    const node = nodes[index];
+    if (!node) return;
+    const text = dx || dy ? `translate(${Math.round(dx * 100) / 100} ${Math.round(dy * 100) / 100})` : "";
+    if (node.__shift === text) return;
+    if (text) node.setAttribute("transform", text);
+    else node.removeAttribute("transform");
+    node.__shift = text;
+    writes++;
+  };
+  const render = () => {
+    const t0 = performance.now();
+    writes = 0;
+    moved = 0;
+    stats.orderMs = 0;
+    t3Arena.on = false;
+    const snapshotting = snapshotNext;
+    snapshotNext = false;
+    cams = t3Cams(scene, values);
+    t3State.detail = detail;
+    const poses = cams.poses;
+    const fresh = lastUnit !== unit || !lastPoses;
+    let emitted = 0;
+    emittedList.length = 0;
+    let shifted = 0;
+    for (const run of scene.runs) {
+      const g = run.group;
+      const changed = fresh || (g >= 0 ? !samePose(poses[g], lastPoses[g]) : false);
+      if (!changed) continue;
+      const domRun = snapshotting || domLayer[run.layer];
+      const cam = g >= 0 ? cams[g] : cams.world;
+      const f = frames[run.index];
+      const base = shiftOn && !fresh && !snapshotting ? emitAt[run.index] : null;
+      if (base && sameView(base, cam)) {
+        const dx = cam.ox - base.ox;
+        const dy = cam.oy - base.oy;
+        shiftFrame(f, base, dx, dy);
+        if (domRun) writeShift(run.index, dx, dy);
+        emittedList.push(run.index);
+        shifted++;
+        continue;
+      }
+      t3Arena.on = Boolean(numeric) && !domRun;
+      t3Emit(run, cam, f);
+      if (f.sx || f.sy) {
+        f.sx = 0;
+        f.sy = 0;
+      }
+      if (shiftOn && shiftable(run)) keepEmit(run, cam, f);
+      if (domRun) {
+        write(run.index);
+        if (shiftOn && shiftable(run)) writeShift(run.index, 0, 0);
+      }
+      emittedList.push(run.index);
+      emitted++;
+    }
+    stats.shifted = shifted;
+    lastPoses = poses;
+    lastUnit = unit;
+    t3Arena.on = false;
+    t3Arena.f = null;
+    const t1 = performance.now();
+    stats.emitMs = t1 - t0;
+    const orderStats = { forced: 0, refined: 0, unseparated: 0, edges: 0 };
+    scene.layers.forEach((layer, index) => {
+      const previous = orders[index];
+      const tOrder = performance.now();
+      const order = t3Order(layer, frames, cams, previous, orderStats, scene);
+      stats.orderMs += performance.now() - tOrder;
+      let same = true;
+      for (let j = 0; j < order.length; j++)
+        if (order[j] !== previous[j]) {
+          same = false;
+          break;
+        }
+      if (snapshotting && !domLayer[index]) {
+        const container = containers.get(layer.name);
+        if (container) for (const global of order) if (nodes[global]) container.appendChild(nodes[global]);
+        orders[index] = order;
+        return;
+      }
+      if (same) return;
+      if (!domLayer[index]) {
+        orders[index] = order;
+        return;
+      }
+      const container = containers.get(layer.name);
+      const position = new Map();
+      previous.forEach((global, at) => position.set(global, at));
+      const keep = t3Keep(Array.from(order, (global) => position.get(global)));
+      let after = null;
+      const shifted = [];
+      for (let j = order.length - 1; j >= 0; j--) {
+        const node = nodes[order[j]];
+        if (!keep[j] && node && container) {
+          container.insertBefore(node, after);
+          moved++;
+          shifted.push(scene.runs[order[j]].name);
+        }
+        if (node) after = node;
+      }
+      orders[index] = order;
+      if (shifted.length) changes.push({ layer: layer.name, moved: shifted });
+    });
+    stats.ms = performance.now() - t0;
+    stats.writes = writes;
+    stats.moved = moved;
+    stats.forced = orderStats.forced;
+    stats.refined = orderStats.refined;
+    stats.unseparated = orderStats.unseparated;
+    stats.emitted = emitted;
+    t3State.detail = 1;
+    if (onFrame) onFrame(controller);
+    return { ...stats };
+  };
+  let detail = 1;
+  const set = (next, options) => {
+    if (options && options.detail !== undefined) {
+      const value = Math.max(0, Math.min(1, options.detail));
+      if (value !== detail) {
+        detail = value;
+        lastPoses = null;
+      }
+    }
+    if (typeof next === "number") {
+      const g = data.groups.find((group) => group.kind === "turn");
+      if (g) values[g.name] = next;
+    } else if (next) for (const [name, value] of Object.entries(next)) values[name] = value;
+    if (follow) Object.assign(values, follow({ ...values }));
+    return render();
+  };
+  const itemRuns = new Map();
+  let unwrap = new Map();
+  const angleAt = (clientX, clientY, z = 0, groupName) => {
+    const svg = first;
+    const box = svg.getBoundingClientRect();
+    const vb = svg.viewBox.baseVal;
+    const x = vb.x + ((clientX - box.left) / box.width) * vb.width;
+    const y = vb.y + ((clientY - box.top) / box.height) * vb.height;
+    const c = t3Camera(scene.P, null);
+    const p = (x - c.ox) / c.k;
+    const q = (y - c.oy + z * c.ce * c.k) / (c.se * c.k);
+    const wx = p * c.sa + q * c.ca;
+    const wy = -p * c.ca + q * c.sa;
+    const group = data.groups.find((g) => g.name === groupName) ?? data.groups.find((g) => g.kind === "turn");
+    const pivot = group ? group.origin : [0, 0, 0];
+    const raw = (Math.atan2(wy - pivot[1], wx - pivot[0]) * 180) / Math.PI;
+    const key = group ? group.name : "";
+    const last = unwrap.get(key);
+    let angle = raw;
+    if (last !== undefined) angle = last + ((((raw - last) % 360) + 540) % 360) - 180;
+    unwrap.set(key, angle);
+    return angle;
+  };
+  const observer = typeof ResizeObserver === "function" && first
+    ? new ResizeObserver(() => {
+        if (!dom || !first.isConnected) return;
+        const next = unitOf();
+        if (Math.abs(next - unit) < 0.05) return;
+        unit = next;
+        scene = t3Prepare(data, { unit });
+        render();
+      })
+    : null;
+  if (observer) observer.observe(first);
+  if (follow) Object.assign(values, follow({ ...values }));
+  const controller = {
+    set,
+    render,
+    painter,
+    emitted: () => emittedList,
+    snapshot: () => {
+      snapshotNext = true;
+      lastPoses = null;
+      render();
+      lastPoses = null;
+      render();
+      return [...containers.values()];
+    },
+    numeric: Boolean(numeric) && canvasSet.size > 0,
+    canvasLayers: [...canvasSet],
+    setUnit: (next) => {
+      if (Math.abs(next - unit) < 1e-6) return null;
+      unit = next;
+      scene = t3Prepare(data, { unit });
+      return render();
+    },
+    angleAt,
+    get values() {
+      return { ...values };
+    },
+    cover: (names, options) => t3Cover(controller, names, options),
+    order: (name) => {
+      const index = name === undefined ? 0 : scene.layers.findIndex((layer) => layer.name === name);
+      return index < 0 ? [] : Array.from(orders[index], (global) => scene.runs[global].name);
+    },
+    orderIndex: (name) => {
+      const index = name === undefined ? 0 : scene.layers.findIndex((layer) => layer.name === name);
+      return index < 0 ? null : orders[index];
+    },
+    events: () => changes.splice(0, changes.length),
+    stats: () => ({ ...stats }),
+    frames: () => frames,
+    cams: () => cams,
+    scene: () => scene,
+    pose: (name) => t3PoseOf(scene, cams, name),
+    detach: (name) => {
+      const index = scene.groups.findIndex((g) => g.name === name);
+      const pose = t3PoseOf(scene, cams, name);
+      const o = scene.groups[index].origin;
+      return { world: true, R: pose.R, t: [pose.t[0] - o[0], pose.t[1] - o[1], pose.t[2] - o[2]] };
+    },
+    anchor: (name, point, direction) => t3Anchor(scene, cams, name, point, direction),
+    item: (name, { cloud, box, hull }) => {
+      const run = itemRuns.get(name) ?? scene.runs.find((r) => r.name === name);
+      if (!run) return null;
+      itemRuns.set(name, run);
+      run.cloud = cloud instanceof Float64Array ? cloud : Float64Array.from(cloud);
+      run.version = (run.version ?? 0) + 1;
+      run.itemBox.set(box);
+      run.itemHull = hull instanceof Float64Array ? hull : Float64Array.from(hull);
+      const n = run.cloud.length / 3;
+      run.centroid = [0, 0, 0];
+      for (let i = 0; i < n; i++) for (let c = 0; c < 3; c++) run.centroid[c] += run.cloud[3 * i + c] / Math.max(1, n);
+      t3Emit(run, null, frames[run.index]);
+      return nodes[run.index];
+    },
+    node: (name) => {
+      const run = scene.runs.find((r) => r.name === name);
+      return run ? nodes[run.index] : null;
+    },
+    destroy: () => {
+      if (observer) observer.disconnect();
+      if (typeof window !== "undefined" && window.__isoTurn && window.__isoTurn.controller === controller) delete window.__isoTurn;
+    },
+  };
+  const hold = () => {
+    if (onHold) onHold();
+  };
+  if (typeof window !== "undefined") {
+    window.__isoTurn = {
+      controller,
+      set(next) {
+        hold();
+        return set(next);
+      },
+      get() {
+        hold();
+        return { ...values };
+      },
+      order(name) {
+        hold();
+        return controller.order(name);
+      },
+      events() {
+        hold();
+        return controller.events();
+      },
+      stats() {
+        hold();
+        return controller.stats();
+      },
+      layers() {
+        hold();
+        return scene.layers.map((layer) => layer.name);
+      },
+    };
+  }
+  render();
+  return controller;
+}
+
+function t3Enclose(points, edges) {
+  const hull = t3Hull(points);
+  const n = hull.length;
+  if (n < 3) return [];
+  let area = 0;
+  for (let i = 0; i < n; i++) area += hull[i][0] * hull[(i + 1) % n][1] - hull[(i + 1) % n][0] * hull[i][1];
+  const sign = area >= 0 ? 1 : -1;
+  let lines = [];
+  for (let i = 0; i < n; i++) {
+    const p = hull[i];
+    const q = hull[(i + 1) % n];
+    const dx = q[0] - p[0];
+    const dy = q[1] - p[1];
+    const l = Math.hypot(dx, dy);
+    if (l < 1e-9) continue;
+    const nx = (sign * dy) / l;
+    const ny = (-sign * dx) / l;
+    lines.push([nx, ny, -(nx * p[0] + ny * p[1])]);
+  }
+  const meet = (A, B) => {
+    const det = A[0] * B[1] - A[1] * B[0];
+    if (Math.abs(det) < 1e-12) return null;
+    return [(-A[2] * B[1] + B[2] * A[1]) / det, (-A[0] * B[2] + B[0] * A[2]) / det];
+  };
+  while (lines.length > edges) {
+    let best = -1;
+    let cost = Infinity;
+    const m = lines.length;
+    for (let i = 0; i < m; i++) {
+      const prev = lines[(i - 1 + m) % m];
+      const self = lines[i];
+      const next = lines[(i + 1) % m];
+      const turn = prev[0] * next[1] - prev[1] * next[0];
+      if (sign * turn <= 1e-9) continue;
+      const apex = meet(prev, next);
+      const a = meet(prev, self);
+      const b = meet(self, next);
+      if (!apex || !a || !b) continue;
+      const added = Math.abs((a[0] - apex[0]) * (b[1] - apex[1]) - (a[1] - apex[1]) * (b[0] - apex[0])) / 2;
+      if (added < cost) {
+        cost = added;
+        best = i;
+      }
+    }
+    if (best < 0) break;
+    lines.splice(best, 1);
+  }
+  return lines;
+}
+
+function t3Cover(controller, names, { polygons = 6, edges = 10, pad = 0.3, layers = null } = {}) {
+  const uCoverEdge = new Float32Array(polygons * edges * 3);
+  const uCoverCount = new Float32Array(polygons);
+  const scene = controller.scene();
+  const frames = controller.frames();
+  const sets = Array.isArray(names) ? (names.length && Array.isArray(names[0]) ? names : [names]) : [[names]];
+  const candidates = [];
+  const taken = new Set();
+  for (const list of sets) {
+    const targets = scene.runs.filter((run) => list.includes(run.name));
+    if (!targets.length) continue;
+    const box = [Infinity, Infinity, -Infinity, -Infinity];
+    for (const run of targets) {
+      const b = frames[run.index].box;
+      box[0] = Math.min(box[0], b[0]);
+      box[1] = Math.min(box[1], b[1]);
+      box[2] = Math.max(box[2], b[2]);
+      box[3] = Math.max(box[3], b[3]);
+    }
+    const home = targets[0].layer;
+    scene.layers.forEach((layer, index) => {
+      const order = controller.orderIndex(layer.name);
+      if (!order) return;
+      let from = 0;
+      if (index === home) {
+        for (let at = 0; at < order.length; at++) if (targets.some((run) => run.index === order[at])) from = at + 1;
+      } else if (!(layers && layers.includes(layer.name)) || index < home) return;
+      for (let at = from; at < order.length; at++) {
+        const run = scene.runs[order[at]];
+        if (list.includes(run.name) || taken.has(run.index)) continue;
+        const f = frames[run.index];
+        const b = f.box;
+        if (!(b[0] < box[2] + pad && box[0] < b[2] + pad && b[1] < box[3] + pad && box[1] < b[3] + pad)) continue;
+        if (!targets.some((target) => !t3Disjoint(frames[target.index], f, -pad))) continue;
+        taken.add(run.index);
+        const share = (Math.min(b[2], box[2]) - Math.max(b[0], box[0])) * (Math.min(b[3], box[3]) - Math.max(b[1], box[1]));
+        candidates.push({ run, f, share });
+      }
+    });
+  }
+  candidates.sort((a, b) => b.share - a.share);
+  const parts = [];
+  let slot = 0;
+  for (const { run, f } of candidates) {
+    if (slot >= polygons) break;
+    const points = [];
+    if (f.quadN) for (const [buf, count] of f.quadList) for (let i = 0; i < count; i++) points.push([buf[2 * i], buf[2 * i + 1]]);
+    else for (let i = 0; i < f.hullN; i++) points.push([f.hull[2 * i], f.hull[2 * i + 1]]);
+    const lines = t3Enclose(points, edges);
+    if (!lines.length) continue;
+    lines.forEach((line, e) => {
+      const at = (slot * edges + e) * 3;
+      uCoverEdge[at] = line[0];
+      uCoverEdge[at + 1] = line[1];
+      uCoverEdge[at + 2] = line[2] - pad;
+    });
+    uCoverCount[slot] = lines.length;
+    parts.push(run.name);
+    slot++;
+  }
+  return { uCoverEdge, uCoverCount, dropped: Math.max(0, candidates.length - slot), parts };
+}
+
+function t3PoseOf(scene, cams, name) {
+  const index = scene.groups.findIndex((g) => g.name === name);
+  const cam = index >= 0 && cams ? cams[index] : null;
+  return { R: cam ? Array.from(cam.R) : Array.from(T3_EYE), t: cam ? [cam.t[0], cam.t[1], cam.t[2]] : [0, 0, 0] };
+}
+
+function t3Anchor(scene, cams, name, point, direction) {
+  const index = name === null || name === undefined ? -1 : scene.groups.findIndex((g) => g.name === name);
+  const cam = index >= 0 ? cams[index] : cams.world;
+  const o = index >= 0 ? scene.groups[index].origin : [0, 0, 0];
+  const R = cam.R;
+  const q = [point[0] - o[0], point[1] - o[1], point[2] - o[2]];
+  const world = [R[0] * q[0] + R[1] * q[1] + R[2] * q[2] + cam.t[0], R[3] * q[0] + R[4] * q[1] + R[5] * q[2] + cam.t[1], R[6] * q[0] + R[7] * q[1] + R[8] * q[2] + cam.t[2]];
+  const w = cams.world;
+  const screen = [w.ox + w.m[0] * world[0] + w.m[1] * world[1] + w.m[2] * world[2], w.oy + w.m[3] * world[0] + w.m[4] * world[1] + w.m[5] * world[2]];
+  const out = { world, screen };
+  if (direction) out.direction = [R[0] * direction[0] + R[1] * direction[1] + R[2] * direction[2], R[3] * direction[0] + R[4] * direction[1] + R[5] * direction[2], R[6] * direction[0] + R[7] * direction[1] + R[8] * direction[2]];
+  return out;
+}
+
+function t3FloorOf(scene, name, R = T3_EYE) {
+  const index = scene.groups.findIndex((g) => g.name === name);
+  let low = Infinity;
+  for (const run of scene.runs) {
+    if (run.group !== index) continue;
+    const c = run.cloud;
+    for (let i = 0; i < c.length; i += 3) {
+      const z = R[6] * c[i] + R[7] * c[i + 1] + R[8] * c[i + 2];
+      if (z < low) low = z;
+    }
+  }
+  return low;
+}
+
+function t3Compose(A, B) {
+  return Array.from(t3Mul(A, B));
+}
+
+function t3PoseUniforms(controller, group, prefix = "uGroup") {
+  const scene = controller.scene();
+  const index = scene.groups.findIndex((g) => g.name === group);
+  const cams = controller.cams();
+  const cam = index >= 0 && cams ? cams[index] : null;
+  const R = cam ? cam.R : T3_EYE;
+  const t = cam ? cam.t : [0, 0, 0];
+  const o = index >= 0 ? scene.groups[index].origin : [0, 0, 0];
+  const T = [t[0] - (R[0] * o[0] + R[1] * o[1] + R[2] * o[2]), t[1] - (R[3] * o[0] + R[4] * o[1] + R[5] * o[2]), t[2] - (R[6] * o[0] + R[7] * o[1] + R[8] * o[2])];
+  return { [`${prefix}X`]: [R[0], R[3], R[6]], [`${prefix}Y`]: [R[1], R[4], R[7]], [`${prefix}Z`]: [R[2], R[5], R[8]], [`${prefix}T`]: T };
+}
+
+const T3_MAT_KEYS = ["paper", "face", "top", "shade-0", "shade-1", "shade-2", "shade-3", "lit-top", "lit-shade", "hi", "mid", "lo", "faint", "dot", "lit"];
+const T3_MAT_TUBE = ["body", "shine", "shade", "edge"];
+
+const T3_MATERIALS = {
+  gold: {
+    light: ["#d3bb88", "#e4d2a8", "#f1e5c6", "#a1844f", "#bc9f69", "#d3bb88", "#e4d2a8", "#f8efd8", "#dfcb9c", "#4b3920", "#86693f", "#a98c5b", "#c1a676", "#4a381f", "#2a1d0c", "#cdb07a", "#f3e8cc", "#8e7044", "#4b3920"],
+    dark: ["#3f3521", "#4b3f28", "#5a4c31", "#2b2416", "#352c1b", "#3f3521", "#4b3f28", "#6a5a3b", "#4f4329", "#e6d2a3", "#8a7550", "#5e4e33", "#463a26", "#e6d2a3", "#fff3d6", "#4a3e27", "#8c7853", "#251f13", "#e6d2a3"],
+  },
+  chrome: {
+    light: ["#8e959c", "#c3c8cd", "#f7f8f9", "#a2a9b0", "#6f767d", "#454b52", "#cacfd4", "#ffffff", "#bcc2c8", "#202428", "#585e65", "#878d94", "#a9afb5", "#2a2e33", "#000000", "#8b9299", "#fbfcfd", "#3c4248", "#202428"],
+    dark: ["#2a2e32", "#4a5056", "#6e757c", "#2e3236", "#24272b", "#1a1d20", "#4a5056", "#848b92", "#3a3f44", "#dfe3e7", "#7c838a", "#4d5359", "#363b40", "#e4e7ea", "#ffffff", "#34393e", "#9aa1a8", "#16191b", "#dfe3e7"],
+  },
+  steel: {
+    light: ["#b8bdc1", "#cdd1d4", "#e5e8ea", "#8f959b", "#a4aaaf", "#b8bdc1", "#cdd1d4", "#f1f3f4", "#c6cacd", "#2b2f33", "#6b7177", "#959ba1", "#aeb3b8", "#33373b", "#000000", "#b3b8bd", "#eef0f2", "#7d8389", "#2b2f33"],
+    dark: ["#2c3034", "#34393d", "#3e4348", "#1f2225", "#25292c", "#2c3034", "#34393d", "#4a5056", "#33383c", "#d0d4d8", "#727980", "#4a5056", "#33383d", "#d8dce0", "#ffffff", "#30353a", "#5c6369", "#1a1d20", "#d0d4d8"],
+  },
+  gunmetal: {
+    light: ["#444a51", "#50575e", "#5f666e", "#2f3439", "#393f45", "#444a51", "#50575e", "#6d757d", "#4b5258", "#0f1113", "#1d2125", "#272b30", "#30353a", "#b0b5ba", "#000000", "#3d4349", "#6e757c", "#24282c", "#0f1113"],
+    dark: ["#1d2125", "#22272b", "#2a2f34", "#15181b", "#191c20", "#1d2125", "#22272b", "#323840", "#20252a", "#a9b0b7", "#5c636a", "#3a4046", "#2a2f34", "#b8bec4", "#ffffff", "#1f2327", "#3a4046", "#111316", "#a9b0b7"],
+  },
+  rubber: {
+    light: ["#2a2b2e", "#34363a", "#46484d", "#1b1c1e", "#222326", "#2a2b2e", "#34363a", "#55575c", "#2f3134", "#070708", "#111214", "#18191b", "#1f2023", "#6a6c70", "#000000", "#27282b", "#5b5d62", "#121314", "#050506"],
+    dark: ["#121213", "#161618", "#1c1c1f", "#0c0c0d", "#0f0f10", "#121213", "#161618", "#232327", "#141416", "#8c8e92", "#4a4c50", "#2c2d30", "#1f2023", "#9a9ca0", "#ffffff", "#131315", "#2b2c30", "#0a0a0b", "#8c8e92"],
+  },
+  brass: {
+    light: ["#bd9646", "#d2ad5b", "#e6c87e", "#8a6a2c", "#a47f38", "#bd9646", "#d2ad5b", "#f0d796", "#c8a252", "#3f2e0e", "#765a24", "#9a7a3c", "#b08c46", "#3a2a0c", "#1f1606", "#b8913f", "#efd795", "#7d5f26", "#3f2e0e"],
+    dark: ["#3d3017", "#49391c", "#574523", "#2a210f", "#332813", "#3d3017", "#49391c", "#66522b", "#45371b", "#e9cf8a", "#8e7438", "#5e4c25", "#44371c", "#e9cf8a", "#fff0c8", "#433419", "#8a6f36", "#21190b", "#e9cf8a"],
+  },
+  copper: {
+    light: ["#b3633e", "#c9784f", "#df9670", "#7c4128", "#9a5132", "#b3633e", "#c9784f", "#eaa985", "#be6d46", "#3a1a0c", "#6e3820", "#925037", "#a65d3f", "#3a1a0c", "#1c0b04", "#ad5f3b", "#f0b896", "#6e3720", "#3a1a0c"],
+    dark: ["#3d1f13", "#492617", "#582e1c", "#2a160d", "#331a10", "#3d1f13", "#492617", "#673722", "#432215", "#eaa985", "#8f5236", "#5f3624", "#45271a", "#eaa985", "#ffe0cc", "#42221a", "#8a4c31", "#1f0f08", "#eaa985"],
+  },
+};
+
+function t3MaterialCss() {
+  const rules = [];
+  const block = (values) => T3_MAT_KEYS.map((key, i) => `--anatomy-${key}:${values[i]}`).concat(T3_MAT_TUBE.map((key, i) => `--mat-${key}:${values[T3_MAT_KEYS.length + i]}`)).join(";");
+  for (const [name, { light, dark }] of Object.entries(T3_MATERIALS)) {
+    rules.push(`[data-mat="${name}"]{${block(dark)}}`);
+    rules.push(`.iso[data-theme="light"] [data-mat="${name}"]{${block(light)}}`);
+    rules.push(`.iso[data-theme="dark"] [data-mat="${name}"]{${block(dark)}}`);
+  }
+  rules.push("[data-mat] .tb-body{fill:var(--mat-body)}");
+  rules.push("[data-mat] .tb-shine{fill:var(--mat-shine)}");
+  rules.push("[data-mat] .tb-shade{fill:var(--mat-shade)}");
+  rules.push("[data-mat] .tb-edge{stroke:var(--mat-edge)}");
+  return rules.join("\n");
+}
+
+function t3Css() {
+  const rules = [];
+  const ramp = "--tn-0:var(--anatomy-shade-0);--tn-1:var(--anatomy-shade-1);--tn-2:var(--anatomy-shade-2);--tn-3:var(--anatomy-shade-3);--tn-4:var(--anatomy-top)";
+  rules.push(`.iso-live{${ramp}}`);
+  rules.push(`.iso-live [data-mat]{${ramp}}`);
+  rules.push(".iso-live [data-lit]{--tn-0:var(--anatomy-lit-shade);--tn-1:var(--anatomy-lit-shade);--tn-2:var(--anatomy-lit-shade);--tn-3:var(--anatomy-lit-shade);--tn-4:var(--anatomy-lit-top)}");
+  const colour = "color-mix(in srgb,var(--ta) calc(100% - var(--f,0) * 100%),var(--tb))";
+  rules.push(`.iso-tn{stroke-width:.4;stroke-linejoin:round;--ta:var(--tn-0);--tb:var(--tn-1);fill:${colour};stroke:${colour}}`);
+  for (let i = 1; i < 4; i++) rules.push(`.iso-tn[data-b="${i}"]{--ta:var(--tn-${i});--tb:var(--tn-${i + 1})}`);
+  rules.push(t3MaterialCss());
+  for (const hue of ["red", "green", "blue"]) rules.push(`.tb[data-hue="${hue}"]{--tb-ink:var(--anatomy-${hue})}`);
+  rules.push(".tb[data-hue] .tb-body{fill:color-mix(in srgb,var(--tb-ink) 54%,var(--anatomy-shade-2))}");
+  rules.push(".tb[data-hue] .tb-shine{fill:color-mix(in srgb,var(--tb-ink) 16%,var(--anatomy-top))}");
+  rules.push(".tb[data-hue] .tb-shade{fill:color-mix(in srgb,var(--tb-ink) 30%,var(--anatomy-hi))}");
+  rules.push(".tb[data-hue] .tb-edge{stroke:color-mix(in srgb,var(--tb-ink) 38%,var(--anatomy-hi))}");
+  rules.push(".tb[data-hue][data-mat] .tb-body{fill:color-mix(in srgb,var(--tb-ink) 62%,var(--mat-body))}");
+  rules.push(".tb[data-hue][data-mat] .tb-shine{fill:color-mix(in srgb,var(--tb-ink) 22%,var(--mat-shine))}");
+  rules.push(".tb[data-hue][data-mat] .tb-shade{fill:color-mix(in srgb,var(--tb-ink) 46%,var(--mat-shade))}");
+  rules.push(".tb[data-hue][data-mat] .tb-edge{stroke:color-mix(in srgb,var(--tb-ink) 30%,var(--mat-edge))}");
+  rules.push(".iso-turn{position:relative}");
+  rules.push(".iso-turn>.iso-layer{position:absolute;inset:0;width:100%;height:100%;pointer-events:none}");
+  return rules.join("\n");
+}
+
+export const TURN = { materials: Object.keys(T3_MATERIALS), materialCss: t3MaterialCss, rotation: (axis, degrees) => Array.from(t3Rot(axis, degrees)), quat: (q) => Array.from(t3Quat(q)), compose: t3Compose, floorOf: t3FloorOf, anchor: t3Anchor, camera: t3Camera, poses: t3PosesMap, prepare: t3Prepare, emit: t3Emit, order: t3Order, mount: t3Mount, cover: t3Cover, poseUniforms: t3PoseUniforms, css: t3Css, frame: t3Frame, cams: t3Cams, gjk: t3Gjk, hintsOf: (ri, ci, rj, cj, world) => Object.assign([...ri.axes.map((axis) => [axis, ci]), ...rj.axes.map((axis) => [axis, cj]), [[0, 0, 1], world]], { centroids: [ri.centroid, rj.centroid] }), disjoint: t3Disjoint, levels: T3_LEVELS, q: T3_Q, exact: (on) => { t3State.exact = Boolean(on); } };
+export const TURN_CSS = t3Css();