pollyroll 0.1.0

package/dist/render.cjs

@@ -0,0 +1,2515 @@
+'use strict';
+
+var chunkOEMS7CZP_cjs = require('./chunk-OEMS7CZP.cjs');
+
+// src/geometry/vec.ts
+var IDENTITY = [0, 0, 0, 1];
+function add(a, b) {
+  return [a[0] + b[0], a[1] + b[1], a[2] + b[2]];
+}
+function sub(a, b) {
+  return [a[0] - b[0], a[1] - b[1], a[2] - b[2]];
+}
+function scale(a, s) {
+  return [a[0] * s, a[1] * s, a[2] * s];
+}
+function dot(a, b) {
+  return a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
+}
+function cross(a, b) {
+  return [a[1] * b[2] - a[2] * b[1], a[2] * b[0] - a[0] * b[2], a[0] * b[1] - a[1] * b[0]];
+}
+function length(a) {
+  return Math.sqrt(dot(a, a));
+}
+function normalize(a) {
+  const len = length(a);
+  if (len <= 1e-12) return [0, 0, 0];
+  return [a[0] / len, a[1] / len, a[2] / len];
+}
+function quatMul(a, b) {
+  const [ax, ay, az, aw] = a;
+  const [bx, by, bz, bw] = b;
+  return [
+    aw * bx + ax * bw + ay * bz - az * by,
+    aw * by - ax * bz + ay * bw + az * bx,
+    aw * bz + ax * by - ay * bx + az * bw,
+    aw * bw - ax * bx - ay * by - az * bz
+  ];
+}
+function quatRotate(q, v) {
+  const u = [q[0], q[1], q[2]];
+  const t = scale(cross(u, v), 2);
+  return add(add(v, scale(t, q[3])), cross(u, t));
+}
+function quatFromMatrix(m) {
+  const [m00 = 0, m01 = 0, m02 = 0, m10 = 0, m11 = 0, m12 = 0, m20 = 0, m21 = 0, m22 = 0] = m;
+  const trace = m00 + m11 + m22;
+  let x;
+  let y;
+  let z;
+  let w;
+  if (trace > 0) {
+    const s = Math.sqrt(trace + 1) * 2;
+    w = s / 4;
+    x = (m21 - m12) / s;
+    y = (m02 - m20) / s;
+    z = (m10 - m01) / s;
+  } else if (m00 > m11 && m00 > m22) {
+    const s = Math.sqrt(1 + m00 - m11 - m22) * 2;
+    w = (m21 - m12) / s;
+    x = s / 4;
+    y = (m01 + m10) / s;
+    z = (m02 + m20) / s;
+  } else if (m11 > m22) {
+    const s = Math.sqrt(1 + m11 - m00 - m22) * 2;
+    w = (m02 - m20) / s;
+    x = (m01 + m10) / s;
+    y = s / 4;
+    z = (m12 + m21) / s;
+  } else {
+    const s = Math.sqrt(1 + m22 - m00 - m11) * 2;
+    w = (m10 - m01) / s;
+    x = (m02 + m20) / s;
+    y = (m12 + m21) / s;
+    z = s / 4;
+  }
+  const len = Math.sqrt(x * x + y * y + z * z + w * w);
+  x /= len;
+  y /= len;
+  z /= len;
+  w /= len;
+  let flip;
+  if (Math.abs(w) >= 1e-12) flip = w < 0;
+  else if (Math.abs(x) >= 1e-12) flip = x < 0;
+  else if (Math.abs(y) >= 1e-12) flip = y < 0;
+  else flip = z < 0;
+  return flip ? [-x, -y, -z, -w] : [x, y, z, w];
+}
+
+// src/geometry/polyhedra.ts
+var EPS = 1e-9;
+var PHI = (1 + Math.sqrt(5)) / 2;
+var INV_PHI = 1 / PHI;
+function signs(base) {
+  let out = [[]];
+  for (const c of base) {
+    const next = [];
+    for (const prefix of out) {
+      next.push([...prefix, c]);
+      if (c !== 0) next.push([...prefix, -c]);
+    }
+    out = next;
+  }
+  return out.map(([x = 0, y = 0, z = 0]) => [x, y, z]);
+}
+function d10Vertices() {
+  const r5 = Math.sqrt(5);
+  const c36 = (1 + r5) / 4;
+  const s36 = Math.sqrt(10 - 2 * r5) / 4;
+  const c72 = (r5 - 1) / 4;
+  const s72 = Math.sqrt(10 + 2 * r5) / 4;
+  const h = 1;
+  const r = 1;
+  const z = h * (1 - c36) / (1 + c36);
+  const upper = [
+    [1, 0],
+    [c72, s72],
+    [-c36, s36],
+    [-c36, -s36],
+    [c72, -s72]
+  ];
+  const lower = [
+    [c36, s36],
+    [-c72, s72],
+    [-1, 0],
+    [-c72, -s72],
+    [c36, -s36]
+  ];
+  return [
+    [0, h, 0],
+    [0, -h, 0],
+    ...upper.map(([c, s]) => [r * c, z, r * s]),
+    ...lower.map(([c, s]) => [r * c, -z, r * s])
+  ];
+}
+function rawVertices(type) {
+  switch (type) {
+    case "d4":
+      return [
+        [1, 1, 1],
+        [1, -1, -1],
+        [-1, 1, -1],
+        [-1, -1, 1]
+      ];
+    case "d6":
+      return signs([1, 1, 1]);
+    case "d8":
+      return [...signs([1, 0, 0]), ...signs([0, 1, 0]), ...signs([0, 0, 1])];
+    case "d10":
+      return d10Vertices();
+    case "d12":
+      return [
+        ...signs([1, 1, 1]),
+        ...signs([0, INV_PHI, PHI]),
+        ...signs([INV_PHI, PHI, 0]),
+        ...signs([PHI, 0, INV_PHI])
+      ];
+    case "d20":
+      return [...signs([0, 1, PHI]), ...signs([1, PHI, 0]), ...signs([PHI, 0, 1])];
+  }
+}
+var TARGET_RADIUS = {
+  d4: 0.75,
+  d6: Math.sqrt(3) / 2,
+  d8: 0.75,
+  d10: 0.75,
+  d12: 0.72,
+  d20: 0.8
+};
+function vertexAt(vertices, i) {
+  const v = vertices[i];
+  if (v === void 0) throw new RangeError(`vertex ${i} out of range`);
+  return v;
+}
+function orderFace(vertices, ids, n) {
+  let c = [0, 0, 0];
+  for (const i of ids) {
+    const v = vertexAt(vertices, i);
+    c = [c[0] + v[0], c[1] + v[1], c[2] + v[2]];
+  }
+  c = scale(c, 1 / ids.length);
+  const [start = 0, ...rest] = ids;
+  const r0 = sub(vertexAt(vertices, start), c);
+  const half = (d) => {
+    const side = dot(n, cross(r0, d));
+    return side > 1e-12 || side >= -1e-12 && dot(r0, d) > 0 ? 0 : 1;
+  };
+  const keyed = rest.map((i) => {
+    const d = sub(vertexAt(vertices, i), c);
+    return { i, d, h: half(d) };
+  });
+  keyed.sort((a, b) => a.h - b.h || -dot(n, cross(a.d, b.d)));
+  return [start, ...keyed.map((k) => k.i)];
+}
+function findFaces(vertices) {
+  let c = [0, 0, 0];
+  for (const v of vertices) c = [c[0] + v[0], c[1] + v[1], c[2] + v[2]];
+  c = scale(c, 1 / vertices.length);
+  const faces = [];
+  const normals = [];
+  const count = vertices.length;
+  for (let i = 0; i < count; i++) {
+    const vi = vertexAt(vertices, i);
+    for (let j = i + 1; j < count; j++) {
+      const vj = vertexAt(vertices, j);
+      for (let k = j + 1; k < count; k++) {
+        const vk = vertexAt(vertices, k);
+        let n = normalize(cross(sub(vj, vi), sub(vk, vi)));
+        if (n[0] === 0 && n[1] === 0 && n[2] === 0) continue;
+        if (dot(n, sub(c, vi)) > 0) n = scale(n, -1);
+        if (!vertices.every((v) => dot(n, sub(v, vi)) <= EPS)) continue;
+        const duplicate = normals.some(
+          (m) => Math.abs(m[0] - n[0]) < EPS && Math.abs(m[1] - n[1]) < EPS && Math.abs(m[2] - n[2]) < EPS
+        );
+        if (duplicate) continue;
+        const ids = [];
+        vertices.forEach((v, idx) => {
+          if (Math.abs(dot(n, sub(v, vi))) <= EPS) ids.push(idx);
+        });
+        faces.push(orderFace(vertices, ids, n));
+        normals.push(n);
+      }
+    }
+  }
+  return { faces, normals };
+}
+function build(type) {
+  const raw = rawVertices(type);
+  let rawRadius = 0;
+  for (const v of raw) rawRadius = Math.max(rawRadius, length(v));
+  const s = TARGET_RADIUS[type] / rawRadius;
+  const vertices = raw.map((v) => scale(v, s));
+  let radius = 0;
+  for (const v of vertices) radius = Math.max(radius, length(v));
+  const { faces, normals } = findFaces(vertices);
+  const readouts = type === "d4" ? vertices.map(normalize) : normals;
+  return { type, vertices, faces, normals, radius, readouts };
+}
+var cache = {};
+function getPolyhedron(type) {
+  let p = cache[type];
+  if (p === void 0) {
+    p = build(type);
+    cache[type] = p;
+  }
+  return p;
+}
+
+// src/geometry/labels.ts
+var EPS2 = 1e-9;
+function near(a, b) {
+  return Math.abs(a[0] - b[0]) < EPS2 && Math.abs(a[1] - b[1]) < EPS2 && Math.abs(a[2] - b[2]) < EPS2;
+}
+function shapeOf(set) {
+  if (set === "d100tens" || set === "d100ones") return "d10";
+  if (set === "dF") return "d6";
+  return set;
+}
+var D6_AXES = [
+  [[0, 1, 0], 1],
+  [[0, 0, 1], 2],
+  [[1, 0, 0], 3],
+  [[-1, 0, 0], 4],
+  [[0, 0, -1], 5],
+  [[0, -1, 0], 6]
+];
+function numberShape(shape) {
+  const readouts = getPolyhedron(shape).readouts;
+  if (shape === "d4") return readouts.map((_, i) => i + 1);
+  if (shape === "d6") {
+    return readouts.map((r) => {
+      const hit = D6_AXES.find(([axis]) => near(axis, r));
+      if (hit === void 0) throw new Error("d6 face normal is not axis-aligned");
+      return hit[1];
+    });
+  }
+  const high = shape === "d10" ? 9 : readouts.length + 1;
+  let next = shape === "d10" ? 0 : 1;
+  const numbers = readouts.map(() => -1);
+  readouts.forEach((r, i) => {
+    if (numbers[i] !== -1) return;
+    const j = readouts.findIndex((o) => near(o, [-r[0], -r[1], -r[2]]));
+    if (j < 0) throw new Error(`${shape} face ${i} has no opposite face`);
+    numbers[i] = next;
+    numbers[j] = high - next;
+    next++;
+  });
+  return numbers;
+}
+var numberCache = {};
+function readoutNumbers(shape) {
+  let numbers = numberCache[shape];
+  if (numbers === void 0) {
+    numbers = numberShape(shape);
+    numberCache[shape] = numbers;
+  }
+  return numbers;
+}
+function numberAt(set, readout) {
+  const n = readoutNumbers(shapeOf(set))[readout];
+  if (n === void 0) throw new RangeError(`${set} has no readout ${readout}`);
+  return n;
+}
+function labelText(set, readout) {
+  const n = numberAt(set, readout);
+  if (set === "d100tens") return n === 0 ? "00" : `${n}0`;
+  if (set === "dF") return n <= 2 ? "\u2212" : n <= 4 ? "" : "+";
+  return String(n);
+}
+function labelIndex(set, readout) {
+  const n = numberAt(set, readout);
+  if (set === "dF") return n - 1 >> 1;
+  return shapeOf(set) === "d10" ? n : n - 1;
+}
+function labelUnderline(set, readout) {
+  const text = labelText(set, readout);
+  const marked = set === "d10" || set === "d12" || set === "d20" || set === "d100ones";
+  return marked && (text === "6" || text === "9");
+}
+function readoutForValue(set, value) {
+  let target = value;
+  if (set === "d10") {
+    target = Number.isInteger(value) && value >= 1 && value <= 10 ? value % 10 : Number.NaN;
+  } else if (set === "dF") {
+    target = value === -1 ? 1 : value === 0 ? 3 : value === 1 ? 5 : Number.NaN;
+  }
+  const i = readoutNumbers(shapeOf(set)).indexOf(target);
+  if (i < 0) throw new RangeError(`${set} cannot show value ${value}`);
+  return i;
+}
+
+// src/geometry/mesh.ts
+var BEVEL = 0.08;
+var MESH_STRIDE = 9;
+var EPS3 = 1e-9;
+function at(list, i) {
+  const v = list[(i + list.length) % list.length];
+  if (v === void 0) throw new RangeError(`index ${i} out of range`);
+  return v;
+}
+function midpoint(a, b) {
+  return scale(add(a, b), 0.5);
+}
+function centroid(points) {
+  let c = [0, 0, 0];
+  for (const p of points) c = add(c, p);
+  return scale(c, 1 / points.length);
+}
+function insetFace(poly, f) {
+  const face = at(poly.faces, f);
+  const n = at(poly.normals, f);
+  const pts = face.map((i) => at(poly.vertices, i));
+  return pts.map((v, k) => {
+    const m1 = cross(n, normalize(sub(v, at(pts, k - 1))));
+    const m2 = cross(n, normalize(sub(at(pts, k + 1), v)));
+    return add(v, scale(add(m1, m2), BEVEL / (1 + dot(m1, m2))));
+  });
+}
+function inradius(c, pts) {
+  let r = Infinity;
+  pts.forEach((a, k) => {
+    const e = normalize(sub(at(pts, k + 1), a));
+    const d = sub(c, a);
+    r = Math.min(r, length(sub(d, scale(e, dot(d, e)))));
+  });
+  return r;
+}
+function labelFrame(center, side, upDir, n, cell) {
+  const up = normalize(upDir);
+  return { center, side, up, right: cross(up, n), cell };
+}
+function faceUp(c, pts) {
+  const dist = pts.map((p) => length(sub(p, c)));
+  const max = Math.max(...dist);
+  const min = Math.min(...dist);
+  if (pts.length === 4 && max - min <= EPS3) return sub(midpoint(at(pts, 0), at(pts, 1)), c);
+  const k = dist.findIndex((d) => d >= max - EPS3);
+  return sub(at(pts, k), c);
+}
+function build2(shape) {
+  const poly = getPolyhedron(shape);
+  const out = [];
+  const emit = (p, n, label) => {
+    out.push(p[0], p[1], p[2], n[0], n[1], n[2]);
+    if (label === null) {
+      out.push(-1, -1, -1);
+      return;
+    }
+    const d = sub(p, label.center);
+    out.push(
+      dot(d, label.right) / label.side + 0.5,
+      dot(d, label.up) / label.side + 0.5,
+      label.cell
+    );
+  };
+  const tri = (a, b, c, n, label) => {
+    emit(a, n, label);
+    emit(b, n, label);
+    emit(c, n, label);
+  };
+  const insets = poly.faces.map((_, f) => insetFace(poly, f));
+  poly.faces.forEach((face, f) => {
+    const n = at(poly.normals, f);
+    const pts = at(insets, f);
+    const c = centroid(pts);
+    const r = inradius(c, pts);
+    if (shape === "d4") {
+      pts.forEach((v, k) => {
+        const next = midpoint(v, at(pts, k + 1));
+        const prev = midpoint(at(pts, k - 1), v);
+        const label2 = labelFrame(
+          add(c, scale(sub(v, c), 0.36)),
+          1.1 * r,
+          sub(v, c),
+          n,
+          at(face, k)
+        );
+        tri(v, next, c, n, label2);
+        tri(v, c, prev, n, label2);
+      });
+      return;
+    }
+    const label = labelFrame(c, 1.45 * r, faceUp(c, pts), n, f);
+    pts.forEach((v, k) => tri(c, v, at(pts, k + 1), n, label));
+  });
+  const findEdge = (a, b) => {
+    for (let g = 0; g < poly.faces.length; g++) {
+      const face = at(poly.faces, g);
+      const k = face.indexOf(a);
+      if (k >= 0 && at(face, k + 1) === b) return [g, k];
+    }
+    throw new Error(`${shape} has no face with edge ${a} \u2192 ${b}`);
+  };
+  poly.faces.forEach((face, f) => {
+    const nf = at(poly.normals, f);
+    const pf = at(insets, f);
+    face.forEach((a, k) => {
+      const b = at(face, k + 1);
+      if (a > b) return;
+      const [g, j] = findEdge(b, a);
+      const ng = at(poly.normals, g);
+      const pg = at(insets, g);
+      const aF = at(pf, k);
+      const bF = at(pf, k + 1);
+      const bG = at(pg, j);
+      const aG = at(pg, j + 1);
+      emit(aF, nf, null);
+      emit(aG, ng, null);
+      emit(bG, ng, null);
+      emit(aF, nf, null);
+      emit(bG, ng, null);
+      emit(bF, nf, null);
+    });
+  });
+  poly.vertices.forEach((_, v) => {
+    const start = poly.faces.findIndex((face) => face.includes(v));
+    const ring = [];
+    let f = start;
+    do {
+      const face = at(poly.faces, f);
+      const k = face.indexOf(v);
+      ring.push([at(at(insets, f), k), at(poly.normals, f)]);
+      f = findEdge(v, at(face, k - 1))[0];
+    } while (f !== start && ring.length <= poly.faces.length);
+    const [p0, n0] = at(ring, 0);
+    for (let i = 1; i + 1 < ring.length; i++) {
+      const [p1, n1] = at(ring, i);
+      const [p2, n2] = at(ring, i + 1);
+      emit(p0, n0, null);
+      emit(p1, n1, null);
+      emit(p2, n2, null);
+    }
+  });
+  return { shape, data: new Float32Array(out), vertexCount: out.length / MESH_STRIDE };
+}
+var cache2 = {};
+function getDieMesh(shape) {
+  let mesh = cache2[shape];
+  if (mesh === void 0) {
+    mesh = build2(shape);
+    cache2[shape] = mesh;
+  }
+  return mesh;
+}
+
+// src/geometry/symmetry.ts
+var MATCH = 1e-6;
+function near2(a, b) {
+  for (let i = 0; i < a.length; i++) {
+    const x = a[i];
+    const y = b[i];
+    if (x === void 0 || y === void 0 || Math.abs(x - y) > MATCH) return false;
+  }
+  return a.length === b.length;
+}
+function frame(a, b) {
+  const e1 = normalize(a);
+  const e2 = normalize(sub(b, scale(e1, dot(b, e1))));
+  return [e1, e2, cross(e1, e2)];
+}
+function generate(type) {
+  const vertices = getPolyhedron(type).vertices;
+  const [v0] = vertices;
+  if (v0 === void 0) return [];
+  const v1 = vertices.find((v) => length(cross(v0, v)) > MATCH);
+  if (v1 === void 0) return [];
+  const len0 = length(v0);
+  const len1 = length(v1);
+  const d01 = dot(v0, v1);
+  const [a1, a2, a3] = frame(v0, v1);
+  const group = [];
+  vertices.forEach((vi, i) => {
+    if (Math.abs(length(vi) - len0) >= 1e-9) return;
+    vertices.forEach((vj, j) => {
+      if (i === j || Math.abs(length(vj) - len1) >= 1e-9) return;
+      if (Math.abs(dot(vi, vj) - d01) >= 1e-9) return;
+      const [b1, b2, b3] = frame(vi, vj);
+      const row = (r) => [
+        b1[r] * a1[0] + b2[r] * a2[0] + b3[r] * a3[0],
+        b1[r] * a1[1] + b2[r] * a2[1] + b3[r] * a3[1],
+        b1[r] * a1[2] + b2[r] * a2[2] + b3[r] * a3[2]
+      ];
+      const r0 = row(0);
+      const r1 = row(1);
+      const r2 = row(2);
+      const apply = (v) => [dot(r0, v), dot(r1, v), dot(r2, v)];
+      if (!vertices.every((v) => vertices.some((w) => near2(apply(v), w)))) return;
+      const q = quatFromMatrix([...r0, ...r1, ...r2]);
+      if (group.some((g) => near2(g, q))) return;
+      group.push(q);
+    });
+  });
+  return group;
+}
+var groupCache = {};
+function getRotationGroup(type) {
+  let group = groupCache[type];
+  if (group === void 0) {
+    group = generate(type);
+    groupCache[type] = group;
+  }
+  return group;
+}
+function findRemap(type, from, to) {
+  const readouts = getPolyhedron(type).readouts;
+  const a = readouts[from];
+  const b = readouts[to];
+  if (a !== void 0 && b !== void 0) {
+    const g = getRotationGroup(type).find((q) => near2(quatRotate(q, a), b));
+    if (g !== void 0) return g;
+  }
+  throw new Error(`${type}: no rotation maps readout ${from} to ${to}`);
+}
+
+// src/physics/body.ts
+function inertiaTensor(shape) {
+  const { vertices, faces } = getPolyhedron(shape);
+  const point = (i) => {
+    const v = vertices[i];
+    if (v === void 0) throw new RangeError(`vertex ${i} out of range`);
+    return v;
+  };
+  let cxx = 0;
+  let cyy = 0;
+  let czz = 0;
+  let cxy = 0;
+  let cxz = 0;
+  let cyz = 0;
+  let volume = 0;
+  for (const [first, ...rest] of faces) {
+    const a = point(first ?? 0);
+    for (let k = 0; k + 1 < rest.length; k++) {
+      const b = point(rest[k] ?? 0);
+      const c = point(rest[k + 1] ?? 0);
+      const det = dot(a, cross(b, c));
+      volume += det / 6;
+      const s = add(add(a, b), c);
+      const w = det / 120;
+      const pair = (i, j) => w * (a[i] * a[j] + b[i] * b[j] + c[i] * c[j] + s[i] * s[j]);
+      cxx += pair(0, 0);
+      cyy += pair(1, 1);
+      czz += pair(2, 2);
+      cxy += pair(0, 1);
+      cxz += pair(0, 2);
+      cyz += pair(1, 2);
+    }
+  }
+  const inv = volume > 1e-12 ? 1 / volume : 0;
+  cxx *= inv;
+  cyy *= inv;
+  czz *= inv;
+  cxy *= inv;
+  cxz *= inv;
+  cyz *= inv;
+  const trace = cxx + cyy + czz;
+  return new Float64Array([
+    trace - cxx,
+    -cxy,
+    -cxz,
+    -cxy,
+    trace - cyy,
+    -cyz,
+    -cxz,
+    -cyz,
+    trace - czz
+  ]);
+}
+var cache3 = {};
+function getBodyShape(shape) {
+  let body = cache3[shape];
+  if (body === void 0) {
+    const poly = getPolyhedron(shape);
+    const vertices = new Float64Array(poly.vertices.length * 3);
+    poly.vertices.forEach((v, i) => vertices.set(v, i * 3));
+    const [ixx = 0, , , , iyy = 0, , , , izz = 0] = inertiaTensor(shape);
+    const inverse = (m) => m > 1e-12 ? 1 / m : 0;
+    const invInertia = new Float64Array([inverse(ixx), inverse(iyy), inverse(izz)]);
+    body = { shape, vertices, radius: poly.radius, invInertia };
+    cache3[shape] = body;
+  }
+  return body;
+}
+
+// src/physics/flatten.ts
+var FLATTEN_STEPS = 24;
+var COS_HALF_DEGREE = 0.9999619230641713;
+function upReadout(shape, pose) {
+  const [, , , x = 0, y = 0, z = 0, w = 1] = pose;
+  const r0 = 2 * (x * y + z * w);
+  const r1 = 1 - 2 * (x * x + z * z);
+  const r2 = 2 * (y * z - x * w);
+  let best = 0;
+  let bestY = -Infinity;
+  getPolyhedron(shape).readouts.forEach((r, k) => {
+    const ry = r0 * r[0] + r1 * r[1] + r2 * r[2];
+    if (ry > bestY) {
+      bestY = ry;
+      best = k;
+    }
+  });
+  return best;
+}
+var SPACING = 0.8;
+var PASSES = 8;
+function separate(xz, radii, bounds) {
+  const clamp = (k) => {
+    const m = SPACING * (radii[k] ?? 0);
+    xz[2 * k] = Math.min(Math.max(xz[2 * k] ?? 0, bounds.minX + m), bounds.maxX - m);
+    xz[2 * k + 1] = Math.min(Math.max(xz[2 * k + 1] ?? 0, bounds.minZ + m), bounds.maxZ - m);
+  };
+  for (let pass = 0; pass < PASSES; pass++) {
+    for (let i = 0; i < radii.length; i++) {
+      for (let j = i + 1; j < radii.length; j++) {
+        const dx = (xz[2 * j] ?? 0) - (xz[2 * i] ?? 0);
+        const dz = (xz[2 * j + 1] ?? 0) - (xz[2 * i + 1] ?? 0);
+        const want = SPACING * ((radii[i] ?? 0) + (radii[j] ?? 0));
+        const d = Math.sqrt(dx * dx + dz * dz);
+        if (d >= want) continue;
+        const nx = d < 1e-9 ? 1 : dx / d;
+        const nz = d < 1e-9 ? 0 : dz / d;
+        const push = (want - d) / 2;
+        xz[2 * i] = (xz[2 * i] ?? 0) - nx * push;
+        xz[2 * i + 1] = (xz[2 * i + 1] ?? 0) - nz * push;
+        xz[2 * j] = (xz[2 * j] ?? 0) + nx * push;
+        xz[2 * j + 1] = (xz[2 * j + 1] ?? 0) + nz * push;
+        clamp(i);
+        clamp(j);
+      }
+    }
+  }
+}
+function flattenTail(shape, pose, x, z) {
+  const [px = 0, py = 0, pz = 0, qx = 0, qy = 0, qz = 0, qw = 1] = pose;
+  const q = [qx, qy, qz, qw];
+  const poly = getPolyhedron(shape);
+  const r = poly.readouts[upReadout(shape, pose)] ?? [0, 1, 0];
+  const [ux, uy, uz] = quatRotate(q, r);
+  if (uy >= COS_HALF_DEGREE && x === px && z === pz) return null;
+  const aw = 1 + uy;
+  const an = Math.sqrt(uz * uz + ux * ux + aw * aw);
+  const [fx, fy, fz, fw] = quatMul([-uz / an, 0, ux / an, aw / an], q);
+  const low = lowestY(poly.vertices, fx, fy, fz, fw);
+  const sign = qx * fx + qy * fy + qz * fz + qw * fw < 0 ? -1 : 1;
+  const out = new Float64Array(FLATTEN_STEPS * 7);
+  for (let k = 1; k <= FLATTEN_STEPS; k++) {
+    const t = k / FLATTEN_STEPS;
+    const s = 1 - t;
+    const cx = s * qx + t * sign * fx;
+    const cy = s * qy + t * sign * fy;
+    const cz = s * qz + t * sign * fz;
+    const cw = s * qw + t * sign * fw;
+    const n = Math.sqrt(cx * cx + cy * cy + cz * cz + cw * cw);
+    const i = (k - 1) * 7;
+    out[i] = s * px + t * x;
+    out[i + 1] = Math.max(
+      s * py - t * low,
+      -lowestY(poly.vertices, cx / n, cy / n, cz / n, cw / n)
+    );
+    out[i + 2] = s * pz + t * z;
+    out[i + 3] = cx / n;
+    out[i + 4] = cy / n;
+    out[i + 5] = cz / n;
+    out[i + 6] = cw / n;
+  }
+  return out;
+}
+function lowestY(vertices, x, y, z, w) {
+  const r0 = 2 * (x * y + z * w);
+  const r1 = 1 - 2 * (x * x + z * z);
+  const r2 = 2 * (y * z - x * w);
+  let low = Infinity;
+  for (const v of vertices) low = Math.min(low, r0 * v[0] + r1 * v[1] + r2 * v[2]);
+  return low;
+}
+
+// src/physics/throw.ts
+function clampInto(value, lo, hi) {
+  if (lo > hi) return (lo + hi) / 2;
+  return value < lo ? lo : value > hi ? hi : value;
+}
+function throwWave(rng, radii, bounds) {
+  let hx = 0;
+  let hz = 0;
+  let lenSq = 0;
+  do {
+    hx = 2 * rng.float() - 1;
+    hz = 2 * rng.float() - 1;
+    lenSq = hx * hx + hz * hz;
+  } while (!(lenSq > 0.04 && lenSq <= 1));
+  const hLen = Math.sqrt(lenSq);
+  hx /= hLen;
+  hz /= hLen;
+  const speed = 9 + 5 * rng.float();
+  const px = -hz;
+  const pz = hx;
+  const count = radii.length;
+  let cols = 0;
+  while (cols * cols < count) cols++;
+  const centerX = (bounds.minX + bounds.maxX) / 2;
+  const centerZ = (bounds.minZ + bounds.maxZ) / 2;
+  const back = 0.35 * Math.min((bounds.maxX - bounds.minX) / 2, (bounds.maxZ - bounds.minZ) / 2);
+  return radii.map((r, i) => {
+    const col = i % cols;
+    const row = Math.floor(i / cols);
+    const across = (col - (cols - 1) / 2) * 1.3;
+    const x = centerX - hx * back + px * across - hx * (row * 1.3) + (2 * rng.float() - 1) * 0.15;
+    const z = centerZ - hz * back + pz * across - hz * (row * 1.3) + (2 * rng.float() - 1) * 0.15;
+    const y = 2.2 + 0.6 * rng.float();
+    let ux = 0;
+    let uy = 0;
+    let uz = 0;
+    let uw = 0;
+    let uSq = 0;
+    do {
+      ux = 2 * rng.float() - 1;
+      uy = 2 * rng.float() - 1;
+      uz = 2 * rng.float() - 1;
+      uw = 2 * rng.float() - 1;
+      uSq = ux * ux + uy * uy + uz * uz + uw * uw;
+    } while (!(uSq > 1e-6 && uSq <= 1));
+    const uLen = Math.sqrt(uSq);
+    const along = speed * (0.85 + 0.3 * rng.float());
+    const lateral = (2 * rng.float() - 1) * 1.5;
+    const vy = -2 * rng.float();
+    const wx = (2 * rng.float() - 1) * 25;
+    const wy = (2 * rng.float() - 1) * 25;
+    const wz = (2 * rng.float() - 1) * 25;
+    return {
+      position: [
+        clampInto(x, bounds.minX + r, bounds.maxX - r),
+        y,
+        clampInto(z, bounds.minZ + r, bounds.maxZ - r)
+      ],
+      orientation: [ux / uLen, uy / uLen, uz / uLen, uw / uLen],
+      velocity: [hx * along + px * lateral, vy, hz * along + pz * lateral],
+      angularVelocity: [wx, wy, wz]
+    };
+  });
+}
+
+// src/physics/world.ts
+var DT = 1 / 120;
+var DEFAULT_CONFIG = {
+  gravity: -30,
+  restitution: 0.35,
+  friction: 0.6,
+  // Tuned on the settle-acceptance throws (10 mixed dice, seeds 0-49 and 50-249): the best settle
+  // rate in the allowed ranges with a median of about 250 steps.
+  linearDamping: 0.6,
+  angularDamping: 2,
+  iterations: 10
+};
+var MAX_BODIES = 30;
+var MAX_VERTICES = 20;
+var PLANES = 5;
+var MAX_CONTACTS = MAX_BODIES * PLANES * MAX_VERTICES + MAX_BODIES * (MAX_BODIES - 1) / 2;
+var BAUMGARTE = 0.2;
+var SLOP = 5e-3;
+var EPSILON = 1e-12;
+var C_N = 0;
+var C_T1 = 3;
+var C_T2 = 6;
+var C_TARGET = 9;
+var C_LAMBDA = 10;
+var C_MASS = 13;
+var C_ROWS = 16;
+var ROW = 12;
+var STRIDE = C_ROWS + 3 * ROW;
+var PLANE_SLOTS = MAX_BODIES * PLANES * MAX_VERTICES;
+var SLOTS = PLANE_SLOTS + MAX_BODIES * MAX_BODIES;
+function at2(a, i) {
+  const v = a[i];
+  return v === void 0 ? 0 : v;
+}
+function atInt(a, i) {
+  const v = a[i];
+  return v === void 0 ? 0 : v;
+}
+function checkHull(vertices) {
+  if (vertices.length > MAX_VERTICES * 3) {
+    throw new RangeError(`at most ${MAX_VERTICES} hull vertices per body`);
+  }
+}
+function clampNumber(value, min, max) {
+  if (!(value >= min)) return min;
+  return value > max ? max : value;
+}
+function createWorld(bounds, config) {
+  const cfg = { ...DEFAULT_CONFIG, ...config };
+  const { gravity, iterations } = cfg;
+  const restitution = clampNumber(cfg.restitution, 0, 1);
+  const friction = clampNumber(cfg.friction, 0, Infinity);
+  const linearFactor = 1 / (1 + clampNumber(cfg.linearDamping, 0, Infinity) * DT);
+  const angularFactor = 1 / (1 + clampNumber(cfg.angularDamping, 0, Infinity) * DT);
+  const biasRate = BAUMGARTE / DT;
+  const planeNormal = new Float64Array([0, 1, 0, 1, 0, 0, -1, 0, 0, 0, 0, 1, 0, 0, -1]);
+  const planeOffset = new Float64Array([0, bounds.minX, -bounds.maxX, bounds.minZ, -bounds.maxZ]);
+  const shapes = [];
+  const bodyInvInertia = new Float64Array(MAX_BODIES * 3);
+  const bodyRadius = new Float64Array(MAX_BODIES);
+  const pos = new Float64Array(MAX_BODIES * 3);
+  const vel = new Float64Array(MAX_BODIES * 3);
+  const quat = new Float64Array(MAX_BODIES * 4);
+  const omega = new Float64Array(MAX_BODIES * 3);
+  const rot = new Float64Array(MAX_BODIES * 9);
+  const invI = new Float64Array(MAX_BODIES * 9);
+  const worldVerts = new Float64Array(MAX_VERTICES * 3);
+  const contacts = new Float64Array(MAX_CONTACTS * STRIDE);
+  const contactA = new Int32Array(MAX_CONTACTS);
+  const contactB = new Int32Array(MAX_CONTACTS);
+  const contactSlot = new Int32Array(MAX_CONTACTS);
+  const slotLambda = new Float64Array(SLOTS * 3);
+  const slotStep = new Int32Array(SLOTS);
+  let stepNumber = 1;
+  let contactCount = 0;
+  let count = 0;
+  function checkIndex(i) {
+    if (!(i >= 0 && i < count)) throw new RangeError(`body ${i} out of range`);
+  }
+  function updateInertia(i) {
+    const x = at2(quat, i * 4);
+    const y = at2(quat, i * 4 + 1);
+    const z = at2(quat, i * 4 + 2);
+    const w = at2(quat, i * 4 + 3);
+    const r = i * 9;
+    rot[r] = 1 - 2 * (y * y + z * z);
+    rot[r + 1] = 2 * (x * y - z * w);
+    rot[r + 2] = 2 * (x * z + y * w);
+    rot[r + 3] = 2 * (x * y + z * w);
+    rot[r + 4] = 1 - 2 * (x * x + z * z);
+    rot[r + 5] = 2 * (y * z - x * w);
+    rot[r + 6] = 2 * (x * z - y * w);
+    rot[r + 7] = 2 * (y * z + x * w);
+    rot[r + 8] = 1 - 2 * (x * x + y * y);
+    const d0 = at2(bodyInvInertia, i * 3);
+    const d1 = at2(bodyInvInertia, i * 3 + 1);
+    const d2 = at2(bodyInvInertia, i * 3 + 2);
+    for (let row = 0; row < 3; row++) {
+      const a0 = at2(rot, r + row * 3);
+      const a1 = at2(rot, r + row * 3 + 1);
+      const a2 = at2(rot, r + row * 3 + 2);
+      for (let col = 0; col < 3; col++) {
+        invI[r + row * 3 + col] = a0 * d0 * at2(rot, r + col * 3) + a1 * d1 * at2(rot, r + col * 3 + 1) + a2 * d2 * at2(rot, r + col * 3 + 2);
+      }
+    }
+  }
+  function angularRow(body, rx, ry, rz, dx, dy, dz, offset) {
+    if (body < 0) {
+      for (let k = 0; k < 6; k++) contacts[offset + k] = 0;
+      return 0;
+    }
+    const cx = ry * dz - rz * dy;
+    const cy = rz * dx - rx * dz;
+    const cz = rx * dy - ry * dx;
+    const m = body * 9;
+    const ix = at2(invI, m) * cx + at2(invI, m + 1) * cy + at2(invI, m + 2) * cz;
+    const iy = at2(invI, m + 3) * cx + at2(invI, m + 4) * cy + at2(invI, m + 5) * cz;
+    const iz = at2(invI, m + 6) * cx + at2(invI, m + 7) * cy + at2(invI, m + 8) * cz;
+    contacts[offset] = cx;
+    contacts[offset + 1] = cy;
+    contacts[offset + 2] = cz;
+    contacts[offset + 3] = ix;
+    contacts[offset + 4] = iy;
+    contacts[offset + 5] = iz;
+    return cx * ix + cy * iy + cz * iz;
+  }
+  function rowVelocity(c, row) {
+    const base = c * STRIDE;
+    const dir = base + row * 3;
+    const r = base + C_ROWS + row * ROW;
+    const dx = at2(contacts, dir);
+    const dy = at2(contacts, dir + 1);
+    const dz = at2(contacts, dir + 2);
+    const b = atInt(contactB, c) * 3;
+    let v = dx * at2(vel, b) + dy * at2(vel, b + 1) + dz * at2(vel, b + 2) + at2(omega, b) * at2(contacts, r + 6) + at2(omega, b + 1) * at2(contacts, r + 7) + at2(omega, b + 2) * at2(contacts, r + 8);
+    const ai = atInt(contactA, c);
+    if (ai >= 0) {
+      const a = ai * 3;
+      v -= dx * at2(vel, a) + dy * at2(vel, a + 1) + dz * at2(vel, a + 2) + at2(omega, a) * at2(contacts, r) + at2(omega, a + 1) * at2(contacts, r + 1) + at2(omega, a + 2) * at2(contacts, r + 2);
+    }
+    return v;
+  }
+  function addContact(a, b, nx, ny, nz, rax, ray, raz, rbx, rby, rbz, depth, slot) {
+    const c = contactCount++;
+    contactA[c] = a;
+    contactB[c] = b;
+    contactSlot[c] = slot;
+    const warm = atInt(slotStep, slot) === stepNumber;
+    const base = c * STRIDE;
+    let t1x;
+    let t1y;
+    let t1z;
+    if (Math.abs(nx) >= 0.57735) {
+      const len = Math.sqrt(nx * nx + ny * ny);
+      t1x = ny / len;
+      t1y = -nx / len;
+      t1z = 0;
+    } else {
+      const len = Math.sqrt(ny * ny + nz * nz);
+      t1x = 0;
+      t1y = nz / len;
+      t1z = -ny / len;
+    }
+    const t2x = ny * t1z - nz * t1y;
+    const t2y = nz * t1x - nx * t1z;
+    const t2z = nx * t1y - ny * t1x;
+    contacts[base + C_N] = nx;
+    contacts[base + C_N + 1] = ny;
+    contacts[base + C_N + 2] = nz;
+    contacts[base + C_T1] = t1x;
+    contacts[base + C_T1 + 1] = t1y;
+    contacts[base + C_T1 + 2] = t1z;
+    contacts[base + C_T2] = t2x;
+    contacts[base + C_T2 + 1] = t2y;
+    contacts[base + C_T2 + 2] = t2z;
+    const linear = a >= 0 ? 2 : 1;
+    for (let row = 0; row < 3; row++) {
+      const dx = at2(contacts, base + row * 3);
+      const dy = at2(contacts, base + row * 3 + 1);
+      const dz = at2(contacts, base + row * 3 + 2);
+      const rowAt = base + C_ROWS + row * ROW;
+      const k = linear + angularRow(a, rax, ray, raz, dx, dy, dz, rowAt) + angularRow(b, rbx, rby, rbz, dx, dy, dz, rowAt + 6);
+      contacts[base + C_MASS + row] = k > EPSILON ? 1 / k : 0;
+      contacts[base + C_LAMBDA + row] = warm ? at2(slotLambda, slot * 3 + row) : 0;
+    }
+    const approach = rowVelocity(c, 0);
+    const bias = depth > SLOP ? biasRate * (depth - SLOP) : 0;
+    const bounce = approach < -1 ? -restitution * approach : 0;
+    contacts[base + C_TARGET] = bias > bounce ? bias : bounce;
+  }
+  function collide() {
+    contactCount = 0;
+    for (let i = 0; i < count; i++) {
+      const shape = shapes[i];
+      if (shape === void 0) continue;
+      const verts = shape.vertices;
+      const nv = verts.length / 3;
+      const m = i * 9;
+      const px = at2(pos, i * 3);
+      const py = at2(pos, i * 3 + 1);
+      const pz = at2(pos, i * 3 + 2);
+      for (let k = 0; k < nv; k++) {
+        const vx = at2(verts, k * 3);
+        const vy = at2(verts, k * 3 + 1);
+        const vz = at2(verts, k * 3 + 2);
+        worldVerts[k * 3] = at2(rot, m) * vx + at2(rot, m + 1) * vy + at2(rot, m + 2) * vz;
+        worldVerts[k * 3 + 1] = at2(rot, m + 3) * vx + at2(rot, m + 4) * vy + at2(rot, m + 5) * vz;
+        worldVerts[k * 3 + 2] = at2(rot, m + 6) * vx + at2(rot, m + 7) * vy + at2(rot, m + 8) * vz;
+      }
+      for (let p = 0; p < PLANES; p++) {
+        const nx = at2(planeNormal, p * 3);
+        const ny = at2(planeNormal, p * 3 + 1);
+        const nz = at2(planeNormal, p * 3 + 2);
+        const offset = at2(planeOffset, p);
+        for (let k = 0; k < nv; k++) {
+          const rx = at2(worldVerts, k * 3);
+          const ry = at2(worldVerts, k * 3 + 1);
+          const rz = at2(worldVerts, k * 3 + 2);
+          const separation = nx * (px + rx) + ny * (py + ry) + nz * (pz + rz) - offset;
+          if (separation < 0) {
+            const slot = (i * PLANES + p) * MAX_VERTICES + k;
+            addContact(-1, i, nx, ny, nz, 0, 0, 0, rx, ry, rz, -separation, slot);
+          }
+        }
+      }
+    }
+    for (let i = 0; i < count; i++) {
+      const ri = at2(bodyRadius, i);
+      for (let j = i + 1; j < count; j++) {
+        const rj = at2(bodyRadius, j);
+        const dx = at2(pos, j * 3) - at2(pos, i * 3);
+        const dy = at2(pos, j * 3 + 1) - at2(pos, i * 3 + 1);
+        const dz = at2(pos, j * 3 + 2) - at2(pos, i * 3 + 2);
+        const distSq = dx * dx + dy * dy + dz * dz;
+        const reach = ri + rj;
+        if (distSq >= reach * reach) continue;
+        const dist = Math.sqrt(distSq);
+        let nx = 0;
+        let ny = 1;
+        let nz = 0;
+        if (dist >= 1e-9) {
+          nx = dx / dist;
+          ny = dy / dist;
+          nz = dz / dist;
+        }
+        addContact(
+          i,
+          j,
+          nx,
+          ny,
+          nz,
+          nx * ri,
+          ny * ri,
+          nz * ri,
+          -nx * rj,
+          -ny * rj,
+          -nz * rj,
+          reach - dist,
+          PLANE_SLOTS + i * MAX_BODIES + j
+        );
+      }
+    }
+  }
+  function solve() {
+    for (let c = 0; c < contactCount; c++) {
+      const base = c * STRIDE;
+      const b = atInt(contactB, c) * 3;
+      const ai = atInt(contactA, c);
+      for (let row = 0; row < 3; row++) {
+        const lambda = at2(contacts, base + C_LAMBDA + row);
+        if (lambda === 0) continue;
+        const dir = base + row * 3;
+        const r = base + C_ROWS + row * ROW;
+        for (let k = 0; k < 3; k++) {
+          vel[b + k] = at2(vel, b + k) + at2(contacts, dir + k) * lambda;
+          omega[b + k] = at2(omega, b + k) + at2(contacts, r + 9 + k) * lambda;
+        }
+        if (ai >= 0) {
+          const a = ai * 3;
+          for (let k = 0; k < 3; k++) {
+            vel[a + k] = at2(vel, a + k) - at2(contacts, dir + k) * lambda;
+            omega[a + k] = at2(omega, a + k) - at2(contacts, r + 3 + k) * lambda;
+          }
+        }
+      }
+    }
+    for (let it = 0; it < iterations; it++) {
+      for (let c = 0; c < contactCount; c++) {
+        const base = c * STRIDE;
+        const b = atInt(contactB, c) * 3;
+        const ai = atInt(contactA, c);
+        const a = ai < 0 ? 0 : ai * 3;
+        let vbx = at2(vel, b);
+        let vby = at2(vel, b + 1);
+        let vbz = at2(vel, b + 2);
+        let wbx = at2(omega, b);
+        let wby = at2(omega, b + 1);
+        let wbz = at2(omega, b + 2);
+        let vax = 0;
+        let vay = 0;
+        let vaz = 0;
+        let wax = 0;
+        let way = 0;
+        let waz = 0;
+        if (ai >= 0) {
+          vax = at2(vel, a);
+          vay = at2(vel, a + 1);
+          vaz = at2(vel, a + 2);
+          wax = at2(omega, a);
+          way = at2(omega, a + 1);
+          waz = at2(omega, a + 2);
+        }
+        let limit = 0;
+        for (let row = 0; row < 3; row++) {
+          const dir = base + row * 3;
+          const r = base + C_ROWS + row * ROW;
+          const dx = at2(contacts, dir);
+          const dy = at2(contacts, dir + 1);
+          const dz = at2(contacts, dir + 2);
+          let v = dx * vbx + dy * vby + dz * vbz + wbx * at2(contacts, r + 6) + wby * at2(contacts, r + 7) + wbz * at2(contacts, r + 8);
+          if (ai >= 0) {
+            v -= dx * vax + dy * vay + dz * vaz + wax * at2(contacts, r) + way * at2(contacts, r + 1) + waz * at2(contacts, r + 2);
+          }
+          const old = at2(contacts, base + C_LAMBDA + row);
+          const mass = at2(contacts, base + C_MASS + row);
+          let next;
+          if (row === 0) {
+            next = old + mass * (at2(contacts, base + C_TARGET) - v);
+            if (next < 0) next = 0;
+            limit = friction * next;
+          } else {
+            next = old - mass * v;
+            if (next > limit) next = limit;
+            else if (next < -limit) next = -limit;
+          }
+          contacts[base + C_LAMBDA + row] = next;
+          const lambda = next - old;
+          vbx += dx * lambda;
+          vby += dy * lambda;
+          vbz += dz * lambda;
+          wbx += at2(contacts, r + 9) * lambda;
+          wby += at2(contacts, r + 10) * lambda;
+          wbz += at2(contacts, r + 11) * lambda;
+          if (ai >= 0) {
+            vax -= dx * lambda;
+            vay -= dy * lambda;
+            vaz -= dz * lambda;
+            wax -= at2(contacts, r + 3) * lambda;
+            way -= at2(contacts, r + 4) * lambda;
+            waz -= at2(contacts, r + 5) * lambda;
+          }
+        }
+        vel[b] = vbx;
+        vel[b + 1] = vby;
+        vel[b + 2] = vbz;
+        omega[b] = wbx;
+        omega[b + 1] = wby;
+        omega[b + 2] = wbz;
+        if (ai >= 0) {
+          vel[a] = vax;
+          vel[a + 1] = vay;
+          vel[a + 2] = vaz;
+          omega[a] = wax;
+          omega[a + 1] = way;
+          omega[a + 2] = waz;
+        }
+      }
+    }
+    for (let c = 0; c < contactCount; c++) {
+      const slot = atInt(contactSlot, c);
+      const base = c * STRIDE + C_LAMBDA;
+      slotLambda[slot * 3] = at2(contacts, base);
+      slotLambda[slot * 3 + 1] = at2(contacts, base + 1);
+      slotLambda[slot * 3 + 2] = at2(contacts, base + 2);
+      slotStep[slot] = stepNumber + 1;
+    }
+  }
+  return {
+    get count() {
+      return count;
+    },
+    add(shape, position, orientation, velocity, angularVelocity) {
+      if (count >= MAX_BODIES) throw new RangeError(`at most ${MAX_BODIES} bodies per world`);
+      const i = count;
+      const body = getBodyShape(shape);
+      checkHull(body.vertices);
+      shapes.push(body);
+      bodyInvInertia.set(body.invInertia, i * 3);
+      bodyRadius[i] = body.radius;
+      pos.set(position, i * 3);
+      vel.set(velocity, i * 3);
+      omega.set(angularVelocity, i * 3);
+      const [x, y, z, w] = orientation;
+      const len = Math.sqrt(x * x + y * y + z * z + w * w);
+      if (len > EPSILON) quat.set([x / len, y / len, z / len, w / len], i * 4);
+      else quat.set([0, 0, 0, 1], i * 4);
+      count++;
+      return i;
+    },
+    /** One fixed step of DT: semi-implicit Euler velocity update (gravity, damping), contacts,
+     *  sequential impulses, then position and first-order quaternion integration
+     *  q += ½·DT·(ω, 0) ⊗ q with renormalization. */
+    step() {
+      const gdt = gravity * DT;
+      for (let i = 0; i < count; i++) {
+        const v = i * 3;
+        vel[v + 1] = at2(vel, v + 1) + gdt;
+        for (let k = 0; k < 3; k++) {
+          vel[v + k] = at2(vel, v + k) * linearFactor;
+          omega[v + k] = at2(omega, v + k) * angularFactor;
+        }
+        updateInertia(i);
+      }
+      collide();
+      solve();
+      stepNumber++;
+      const half = 0.5 * DT;
+      for (let i = 0; i < count; i++) {
+        const v = i * 3;
+        pos[v] = at2(pos, v) + at2(vel, v) * DT;
+        pos[v + 1] = at2(pos, v + 1) + at2(vel, v + 1) * DT;
+        pos[v + 2] = at2(pos, v + 2) + at2(vel, v + 2) * DT;
+        const wx = at2(omega, v);
+        const wy = at2(omega, v + 1);
+        const wz = at2(omega, v + 2);
+        const q = i * 4;
+        const qx = at2(quat, q);
+        const qy = at2(quat, q + 1);
+        const qz = at2(quat, q + 2);
+        const qw = at2(quat, q + 3);
+        const nx = qx + half * (wx * qw + wy * qz - wz * qy);
+        const ny = qy + half * (-wx * qz + wy * qw + wz * qx);
+        const nz = qz + half * (wx * qy - wy * qx + wz * qw);
+        const nw = qw + half * (-wx * qx - wy * qy - wz * qz);
+        const len = Math.sqrt(nx * nx + ny * ny + nz * nz + nw * nw);
+        if (len > EPSILON) {
+          quat[q] = nx / len;
+          quat[q + 1] = ny / len;
+          quat[q + 2] = nz / len;
+          quat[q + 3] = nw / len;
+        } else {
+          quat[q] = 0;
+          quat[q + 1] = 0;
+          quat[q + 2] = 0;
+          quat[q + 3] = 1;
+        }
+      }
+    },
+    read(i, out, offset) {
+      checkIndex(i);
+      for (let k = 0; k < 3; k++) out[offset + k] = at2(pos, i * 3 + k);
+      for (let k = 0; k < 4; k++) out[offset + 3 + k] = at2(quat, i * 4 + k);
+    },
+    linearSpeedSq(i) {
+      checkIndex(i);
+      const x = at2(vel, i * 3);
+      const y = at2(vel, i * 3 + 1);
+      const z = at2(vel, i * 3 + 2);
+      return x * x + y * y + z * z;
+    },
+    angularSpeedSq(i) {
+      checkIndex(i);
+      const x = at2(omega, i * 3);
+      const y = at2(omega, i * 3 + 1);
+      const z = at2(omega, i * 3 + 2);
+      return x * x + y * y + z * z;
+    }
+  };
+}
+
+// src/physics/sim.ts
+var MAX_STEPS_PER_WAVE = 720;
+var SETTLE_LINEAR = 0.05;
+var SETTLE_ANGULAR = 0.1;
+var SETTLE_STEPS = 24;
+var FRAME = 7;
+var LINEAR_SQ = SETTLE_LINEAR * SETTLE_LINEAR;
+var ANGULAR_SQ = SETTLE_ANGULAR * SETTLE_ANGULAR;
+function simulate(input) {
+  const { shapes, waves, bounds } = input;
+  if (shapes.length !== waves.length) {
+    throw new RangeError("shapes and waves must have the same length");
+  }
+  const rng = chunkOEMS7CZP_cjs.createSeedRng(input.seed);
+  const world = createWorld(bounds);
+  const bodies = shapes.map((shape, i) => ({
+    shape,
+    wave: waves[i] ?? 0,
+    startStep: 0,
+    frames: new Float32Array(FRAME * 256),
+    length: 0,
+    index: -1
+  }));
+  const values = [];
+  for (const w of waves) if (!values.includes(w)) values.push(w);
+  values.sort((a, b) => a - b);
+  const present = [];
+  let totalSteps = 0;
+  let settled = true;
+  const record = (body) => {
+    if (body.length + FRAME > body.frames.length) {
+      const grown = new Float32Array(body.frames.length * 2);
+      grown.set(body.frames);
+      body.frames = grown;
+    }
+    world.read(body.index, body.frames, body.length);
+    body.length += FRAME;
+  };
+  for (const wave of values) {
+    const members = bodies.filter((b) => b.wave === wave);
+    const states = throwWave(
+      rng,
+      members.map((b) => getBodyShape(b.shape).radius),
+      bounds
+    );
+    states.forEach((s, k) => {
+      const body = members[k];
+      if (body === void 0) return;
+      body.index = world.add(body.shape, s.position, s.orientation, s.velocity, s.angularVelocity);
+      body.startStep = totalSteps;
+      present.push(body);
+      record(body);
+    });
+    let calm = 0;
+    let steps = 0;
+    while (calm < SETTLE_STEPS && steps < MAX_STEPS_PER_WAVE) {
+      world.step();
+      steps++;
+      totalSteps++;
+      let still = true;
+      for (const body of present) {
+        record(body);
+        if (world.linearSpeedSq(body.index) >= LINEAR_SQ || world.angularSpeedSq(body.index) >= ANGULAR_SQ) {
+          still = false;
+        }
+      }
+      calm = still ? calm + 1 : 0;
+    }
+    if (calm < SETTLE_STEPS) settled = false;
+  }
+  const thrown = bodies.filter((b) => b.index >= 0);
+  const poses = thrown.map((body) => {
+    const pose = new Float64Array(FRAME);
+    world.read(body.index, pose, 0);
+    return pose;
+  });
+  const xz = new Float64Array(poses.flatMap((p) => [p[0] ?? 0, p[2] ?? 0]));
+  separate(
+    xz,
+    thrown.map((b) => getBodyShape(b.shape).radius),
+    bounds
+  );
+  const ends = bodies.map((body) => {
+    const k = thrown.indexOf(body);
+    const pose = poses[k];
+    if (pose === void 0) return { up: 0, tail: null };
+    const tail = flattenTail(body.shape, pose, xz[2 * k] ?? 0, xz[2 * k + 1] ?? 0);
+    return { up: upReadout(body.shape, pose), tail };
+  });
+  const extra = ends.some((e) => e.tail !== null) ? FLATTEN_STEPS : 0;
+  const tracks = bodies.map((body, i) => {
+    const frames = new Float32Array(body.length + extra * FRAME);
+    frames.set(body.frames.subarray(0, body.length));
+    const tail = ends[i]?.tail;
+    for (let k = 0; k < extra; k++) {
+      const at4 = body.length + k * FRAME;
+      if (tail) frames.set(tail.subarray(k * FRAME, (k + 1) * FRAME), at4);
+      else frames.copyWithin(at4, body.length - FRAME, body.length);
+    }
+    return {
+      shape: body.shape,
+      wave: body.wave,
+      startStep: body.startStep,
+      frames,
+      upReadout: ends[i]?.up ?? 0
+    };
+  });
+  return { totalSteps: totalSteps + extra, tracks, settled };
+}
+var FNV_OFFSET = 2166136261;
+var FNV_PRIME = 16777619;
+function fnvByte(hash, byte) {
+  return Math.imul(hash ^ byte, FNV_PRIME) >>> 0;
+}
+function trackHash(result) {
+  let hash = FNV_OFFSET;
+  for (const track of result.tracks) {
+    const f = track.frames;
+    const words = new Uint32Array(f.buffer, f.byteOffset, f.length);
+    for (const word of words) {
+      hash = fnvByte(hash, word & 255);
+      hash = fnvByte(hash, word >>> 8 & 255);
+      hash = fnvByte(hash, word >>> 16 & 255);
+      hash = fnvByte(hash, word >>> 24);
+    }
+  }
+  return hash.toString(16).padStart(8, "0");
+}
+
+// src/physics/plan.ts
+var MAX_BODIES2 = 30;
+function slots(event) {
+  const out = [];
+  for (let i = 0; i < event.dice.length; i++) {
+    const d = event.dice[i];
+    if (d === void 0) break;
+    const { type, value, wave } = d;
+    if (type === "d100") {
+      if (out.length + 2 > MAX_BODIES2) break;
+      let tens = null;
+      let ones = null;
+      if (value !== null) {
+        ones = value % 10;
+        tens = value === 100 ? 0 : (value - ones) / 10;
+      }
+      out.push({ die: i, labelSet: "d100tens", wave, value: tens });
+      out.push({ die: i, labelSet: "d100ones", wave, value: ones });
+    } else {
+      if (out.length + 1 > MAX_BODIES2) break;
+      out.push({ die: i, labelSet: type, wave, value });
+    }
+  }
+  return out;
+}
+function planRoll(event, bounds) {
+  const list = slots(event);
+  const shapes = list.map((s) => shapeOf(s.labelSet));
+  const result = simulate({ seed: event.seed, shapes, waves: list.map((s) => s.wave), bounds });
+  const bodies = list.map((slot, k) => {
+    const track = result.tracks[k];
+    if (track === void 0) throw new Error(`missing track ${k}`);
+    const remap = slot.value === null ? IDENTITY : findRemap(track.shape, readoutForValue(slot.labelSet, slot.value), track.upReadout);
+    return {
+      die: slot.die,
+      labelSet: slot.labelSet,
+      shape: track.shape,
+      wave: track.wave,
+      startStep: track.startStep,
+      frames: track.frames,
+      remap,
+      upReadout: track.upReadout,
+      value: slot.value
+    };
+  });
+  return {
+    totalSteps: result.totalSteps,
+    settled: result.settled,
+    hash: trackHash(result),
+    bodies
+  };
+}
+
+// src/skins/patterns.ts
+var NOISE = `uvec3 pcg3(uvec3 v) {
+  v = v * 1664525u + 1013904223u;
+  v.x += v.y * v.z; v.y += v.z * v.x; v.z += v.x * v.y;
+  v ^= v >> 16u;
+  v.x += v.y * v.z; v.y += v.z * v.x; v.z += v.x * v.y;
+  return v;
+}
+vec3 hash3(vec3 c) {
+  return vec3(pcg3(uvec3(c + 4096.0))) / 4294967296.0;
+}
+float vnoise(vec3 p) {
+  vec3 i = floor(p);
+  vec3 f = fract(p);
+  f = f * f * (3.0 - 2.0 * f);
+  vec2 e = vec2(1.0, 0.0);
+  return mix(
+    mix(mix(hash3(i).x, hash3(i + e.xyy).x, f.x), mix(hash3(i + e.yxy).x, hash3(i + e.xxy).x, f.x), f.y),
+    mix(mix(hash3(i + e.yyx).x, hash3(i + e.xyx).x, f.x), mix(hash3(i + e.yxx).x, hash3(i + e.xxx).x, f.x), f.y),
+    f.z);
+}
+float fbm(vec3 p) {
+  float s = 0.0;
+  float w = 0.5;
+  for (int k = 0; k < 4; k++) {
+    s += w * vnoise(p);
+    p = p * 2.03 + 1.7;
+    w *= 0.5;
+  }
+  return s;
+}
+`;
+var SIGNATURE = "vec3 pattern(vec3 p, vec3 n, vec3 a, vec3 b) {";
+var PATTERNS = {
+  none: `${SIGNATURE} return a; }`,
+  gradient: `${SIGNATURE} return mix(a, b, smoothstep(-0.8, 0.8, p.y)); }`,
+  speckle: `${SIGNATURE}
+  vec3 q = p * 14.0;
+  vec3 h = hash3(floor(q));
+  float d = length(fract(q) - 0.25 - 0.5 * h);
+  return mix(a, b, step(h.x, 0.5) * (1.0 - smoothstep(0.12, 0.2, d)));
+}`,
+  marble: `${SIGNATURE}
+  float t = fbm(p * 2.5);
+  float v = abs(fract(p.x * 0.9 + p.y * 0.6 + 2.5 * t) - 0.5) * 2.0;
+  return mix(mix(a, b, 0.5 * t), b, 1.0 - smoothstep(0.0, 0.12, v));
+}`,
+  wood: `${SIGNATURE}
+  float ring = fract(length(p.xz) * 9.0 + 2.0 * fbm(p * vec3(2.0, 0.4, 2.0)));
+  float grain = vnoise(p * vec3(40.0, 2.0, 40.0));
+  return mix(a, b, clamp(ring * ring + 0.2 * grain, 0.0, 1.0));
+}`,
+  swirl: `${SIGNATURE}
+  float t = atan(p.z, p.x) * 0.4774648 + length(p.xz) * 2.5 + p.y * 0.6;
+  return mix(a, b, smoothstep(0.3, 0.7, abs(fract(t) - 0.5) * 2.0));
+}`
+};
+
+// src/skins/presets.ts
+var classic = {
+  material: "plastic",
+  color: "#f4f1ea",
+  labelColor: "#1a1a1a",
+  labelStyle: "printed"
+};
+var obsidian = {
+  material: "stone",
+  color: ["#0b0b0f", "#2c2c36"],
+  labelColor: "#d9b45a",
+  pattern: "marble",
+  labelStyle: "engraved"
+};
+var brass = {
+  material: "metal",
+  color: ["#b8893a", "#8a6526"],
+  labelColor: "#1b1209",
+  pattern: "gradient",
+  labelStyle: "engraved"
+};
+var oak = {
+  material: "wood",
+  color: ["#a87444", "#6b4424"],
+  labelColor: "#f6ead6",
+  pattern: "wood",
+  labelStyle: "engraved"
+};
+var sapphire = {
+  material: "glass",
+  color: "#1d4fd6",
+  labelColor: "#ffffff",
+  labelStyle: "printed"
+};
+var ruby = {
+  material: "gem",
+  color: ["#8c0a22", "#b5142f"],
+  labelColor: "#ffe7a3",
+  pattern: "swirl",
+  labelStyle: "printed"
+};
+var emerald = {
+  material: { metalness: 0, roughness: 0.05, clearcoat: 1, transmission: 0.75, tint: 0.95 },
+  color: ["#003d1a", "#00873f"],
+  labelColor: "#fff4c8",
+  pattern: "gradient",
+  labelStyle: "printed"
+};
+var amethyst = {
+  material: "gem",
+  color: ["#5b1a8c", "#8a3fc0"],
+  labelColor: "#f3e8ff",
+  pattern: "swirl",
+  labelStyle: "printed"
+};
+var topaz = {
+  material: "gem",
+  color: ["#b9770e", "#e6b04a"],
+  labelColor: "#3a1e05",
+  pattern: "gradient",
+  labelStyle: "printed"
+};
+var aquamarine = {
+  material: { metalness: 0, roughness: 0.05, clearcoat: 1, transmission: 1, tint: 0.6 },
+  color: "#5fc4d8",
+  labelColor: "#0b2f6b",
+  labelStyle: "printed"
+};
+var smoke = {
+  material: { metalness: 0, roughness: 0.05, clearcoat: 1, transmission: 0.6, tint: 0.35 },
+  color: ["#1e150f", "#3a2c20"],
+  labelColor: "#ffffff",
+  pattern: "gradient",
+  labelStyle: "printed"
+};
+var skinRegistry = /* @__PURE__ */ new Map([
+  ["classic", classic],
+  ["obsidian", obsidian],
+  ["brass", brass],
+  ["oak", oak],
+  ["sapphire", sapphire],
+  ["ruby", ruby],
+  ["emerald", emerald],
+  ["amethyst", amethyst],
+  ["topaz", topaz],
+  ["aquamarine", aquamarine],
+  ["smoke", smoke]
+]);
+function resolveSkin(ref) {
+  if (typeof ref === "object") return ref;
+  return (ref === void 0 ? void 0 : skinRegistry.get(ref)) ?? classic;
+}
+function defineSkin(base, overrides) {
+  return { ...resolveSkin(base), ...overrides };
+}
+function registerSkin(name, skin) {
+  if (name === "") throw new TypeError("skin name must not be empty");
+  skinRegistry.set(name, skin);
+}
+
+// src/render/shaders.ts
+var ATLAS_COLUMNS = 20;
+var ATLAS_ROWS = 9;
+var LIGHT_DIR = [-0.5, 0.7071, -0.5];
+var DIE_VERTEX = `#version 300 es
+layout(location=0) in vec3 aPos;
+layout(location=1) in vec3 aNormal;
+layout(location=2) in vec3 aLabel;
+layout(location=3) in vec4 aInst;
+layout(location=4) in vec4 aQuat;
+uniform mat4 uVP;
+uniform float uScale;
+out vec3 vObj;
+out vec3 vObjN;
+out vec3 vN;
+out vec3 vW;
+out vec2 vUV;
+flat out vec2 vCell;
+vec3 rot(vec4 q, vec3 v) {
+  vec3 t = 2.0 * cross(q.xyz, v);
+  return v + q.w * t + cross(q.xyz, t);
+}
+void main() {
+  vObj = aPos;
+  vObjN = aNormal;
+  vN = rot(aQuat, aNormal);
+  vW = (rot(aQuat, aPos) + aInst.xyz) * uScale;
+  vUV = aLabel.xy;
+  vCell = aLabel.z < 0.0 || aInst.w < 0.0 ? vec2(-1.0) : vec2(aLabel.z, aInst.w);
+  gl_Position = uVP * vec4(vW, 1.0);
+}
+`;
+var bump = (h, shade) => `vec3 r1 = cross(dpy, N);
+    vec3 r2 = cross(N, dpx);
+    float det = dot(dpx, r1);
+    N = normalize(abs(det) * N - sign(det) * ${h} * (da.x * r1 + da.y * r2));
+    base = mix(base, uLabel, a) * (1.0 ${shade} 0.15 * a);`;
+var LABEL = {
+  printed: "base = mix(base, uLabel, a);",
+  engraved: bump("-0.02", "-"),
+  embossed: bump("0.02", "+")
+};
+var GLASS = `float x = min((0.8 - uGlass.x) * 2.5, 1.5);
+  float fr = 0.04 + 0.96 * pow(1.0 - nv, 5.0);
+  float path = 1.0 - nv;
+  vec3 tint = pow(max(base, vec3(1e-4)), vec3(uGlass.y + (1.0 + uGlass.y / 1.5) * path));
+  vec3 g = env(refract(-V, N, 1.0 / 1.5), 0.0) * tint * mix(4.0, 3.0, x);
+  if (gl_FrontFacing) {
+    vec3 hl = (spec(N, V, LIGHT_DIR, vec3(0.04), 0.18 - 0.06 * uGlass.z) * 2.0
+      + spec(N, V, LIGHT_DIR, vec3(0.04), 0.4)) * LIGHT * nl
+      + fr * env(R, 0.0) * 2.0 + vec3(pow(path, 3.0) * mix(1.6, 0.8, x));
+    vec3 h = hash3(floor(vObj * 10.0));
+    vec3 Rj = reflect(-V, normalize(N + (h - 0.5) * 0.8));
+    hl += uGlass.z * step(0.8, h.x) * pow(max(dot(Rj, LIGHT_DIR), 0.0), 12.0) * 6.0;
+    g += hl;
+    al = max(mix(mix(0.12, 0.35, x), mix(0.85, 0.9, x), path), clamp(dot(hl, vec3(0.5)), 0.0, 1.0));
+  } else {
+    al = mix(mix(0.6, 0.8, x), mix(0.85, 0.95, x), path);
+  }
+  c = mix(g, c, lab);
+  al = mix(al, 1.0, lab);`;
+function dieFragment(label, transparent, pattern) {
+  const flat = label === "printed";
+  return `#version 300 es
+precision highp float;
+in vec3 vObj;
+in vec3 vObjN;
+in vec3 vN;
+in vec3 vW;
+in vec2 vUV;
+flat in vec2 vCell;
+uniform vec3 uCam;
+uniform vec3 uBase;
+uniform vec3 uBase2;
+uniform vec3 uLabel;
+uniform vec3 uMat;
+uniform vec3 uGlass;
+uniform float uAlpha;
+uniform sampler2D uAtlas;
+out vec4 oColor;
+const float PI = 3.14159265;
+const vec3 LIGHT_DIR = vec3(${LIGHT_DIR.join(", ")});
+const vec3 LIGHT = vec3(3.2);
+const vec3 SKY = vec3(0.42, 0.44, 0.48);
+const vec3 GROUND = vec3(0.26, 0.24, 0.22);
+const float EXPOSURE = 0.55;
+${NOISE}
+${pattern}
+vec3 hemi(vec3 d) {
+  return mix(GROUND, SKY, d.y * 0.5 + 0.5);
+}
+vec3 env(vec3 d, float r) {
+  return mix(mix(GROUND, SKY, smoothstep(-0.2, 0.2, d.y)), hemi(d), r);
+}
+vec3 fresnel(vec3 f0, float c) {
+  return f0 + (1.0 - f0) * pow(1.0 - c, 5.0);
+}
+vec3 spec(vec3 N, vec3 V, vec3 L, vec3 f0, float r) {
+  vec3 H = normalize(V + L);
+  float nl = max(dot(N, L), 0.001);
+  float nv = max(dot(N, V), 0.001);
+  float nh = max(dot(N, H), 0.0);
+  float a = r * r;
+  float a2 = a * a;
+  float d = nh * nh * (a2 - 1.0) + 1.0;
+  float D = a2 / (PI * d * d);
+  float k = (r + 1.0) * (r + 1.0) / 8.0;
+  float G = nv / (nv * (1.0 - k) + k) * nl / (nl * (1.0 - k) + k);
+  return D * G * fresnel(f0, max(dot(V, H), 0.0)) / (4.0 * nv * nl);
+}
+void main() {
+  vec3 base = pattern(vObj, normalize(vObjN), uBase, uBase2);
+  vec3 N = normalize(vN);
+  if (!gl_FrontFacing) N = -N;
+  // Sample and differentiate in uniform control flow; apply inside the branch.
+  vec2 uv = clamp(vUV, 0.0, 1.0);
+  vec2 cell = max(vCell, 0.0);
+  float a = texture(uAtlas, vec2((cell.x + uv.x) / ${ATLAS_COLUMNS}.0, (cell.y + 1.0 - uv.y) / ${ATLAS_ROWS}.0)).r;
+  ${flat ? "" : "vec3 dpx = dFdx(vW);\n  vec3 dpy = dFdy(vW);\n  vec2 da = vec2(dFdx(a), dFdy(a));"}
+  float lab = 0.0;
+  if (vCell.x >= 0.0 && uv == vUV && gl_FrontFacing) {
+    lab = a;
+    ${LABEL[label]}
+  }
+  // Label fill is dielectric paint: on metal it stays dark instead of mirroring the environment.
+  float m = uMat.x * (1.0 - min(2.0 * lab, 1.0));
+  float r = uMat.y;
+  float cc = uMat.z;
+  vec3 V = normalize(uCam); // orthographic: one view direction everywhere
+  vec3 R = reflect(-V, N);
+  float nl = max(dot(N, LIGHT_DIR), 0.0);
+  float nv = max(dot(N, V), 0.001);
+  vec3 f0 = mix(vec3(0.04), base, m);
+  vec3 F = fresnel(f0, max(dot(V, normalize(V + LIGHT_DIR)), 0.0));
+  vec3 c = ((1.0 - F) * (1.0 - m) * base / PI + spec(N, V, LIGHT_DIR, f0, r)) * LIGHT * nl;
+  vec3 Fa = fresnel(f0, nv) * (1.0 - r * 0.5);
+  c += (1.0 - Fa) * (1.0 - m) * base * hemi(N) + Fa * env(R, r);
+  if (cc > 0.0) {
+    float fc = 0.04 + 0.96 * pow(1.0 - nv, 5.0);
+    c = c * (1.0 - cc * fc) + cc * (spec(N, V, LIGHT_DIR, vec3(0.04), 0.15) * LIGHT * nl + fc * env(R, 0.15));
+  }
+  c *= 1.0 - 0.7 * lab * uMat.x;
+  float al = 1.0;
+  ${transparent ? GLASS : ""}
+  c *= EXPOSURE;
+  c = clamp(c * (2.51 * c + 0.03) / (c * (2.43 * c + 0.59) + 0.14), 0.0, 1.0);
+  c = pow(c, vec3(1.0 / 2.2));
+  al *= uAlpha;
+  oColor = vec4(c * al, al);
+}
+`;
+}
+var SHADOW_VERTEX = `#version 300 es
+layout(location=0) in vec2 aCorner;
+layout(location=1) in vec4 aShadow;
+uniform mat4 uVP;
+out vec2 vC;
+out float vA;
+void main() {
+  vC = aCorner;
+  vA = aShadow.w;
+  gl_Position = uVP * vec4(aShadow.x + aCorner.x * aShadow.z, 0.001, aShadow.y + aCorner.y * aShadow.z, 1.0);
+}
+`;
+var SHADOW_FRAGMENT = `#version 300 es
+precision highp float;
+in vec2 vC;
+in float vA;
+uniform float uAlpha;
+out vec4 oColor;
+void main() {
+  float a = vA * uAlpha * (1.0 - smoothstep(0.0, 1.0, length(vC)));
+  oColor = vec4(0.0, 0.0, 0.0, a);
+}
+`;
+
+// src/render/atlas.ts
+var CELL = 128;
+var PAD = 8;
+var ATLAS_MAX_LEVEL = Math.log2(PAD);
+var INK_HEIGHT = 0.8 * CELL;
+var INK_WIDTH = CELL - 2 * PAD;
+var PROBE = 100;
+var LABEL_SETS = [
+  "d4",
+  "d6",
+  "d8",
+  "d10",
+  "d12",
+  "d20",
+  "d100tens",
+  "d100ones",
+  "dF"
+];
+var SENTINEL = "10px serif";
+function pickFont(ctx, fonts) {
+  for (const font of fonts) {
+    ctx.font = SENTINEL;
+    const sentinel = ctx.font;
+    ctx.font = `bold ${PROBE}px ${font}`;
+    if (ctx.font !== sentinel) return font;
+  }
+  return "system-ui";
+}
+function buildAtlas(requested, labels = {}, fallback = "system-ui") {
+  const canvas = document.createElement("canvas");
+  canvas.width = ATLAS_COLUMNS * CELL;
+  canvas.height = ATLAS_ROWS * CELL;
+  const ctx = canvas.getContext("2d");
+  if (ctx === null) return null;
+  const font = pickFont(ctx, [requested, fallback, "system-ui"]);
+  ctx.fillStyle = "#fff";
+  ctx.textAlign = "center";
+  ctx.textBaseline = "alphabetic";
+  LABEL_SETS.forEach((set, row) => {
+    const count = getPolyhedron(shapeOf(set)).readouts.length;
+    for (let i = 0; i < count; i++) {
+      const custom = labels[set]?.[labelIndex(set, i)];
+      const text = custom ?? labelText(set, i);
+      if (text === "") continue;
+      const underline = custom === void 0 && labelUnderline(set, i);
+      ctx.font = `bold ${PROBE}px ${font}`;
+      const probe = ctx.measureText(text);
+      const blockH = probe.actualBoundingBoxAscent + probe.actualBoundingBoxDescent + (underline ? 0.16 * PROBE : 0);
+      const inkW = probe.actualBoundingBoxLeft + probe.actualBoundingBoxRight;
+      if (blockH <= 0 || inkW <= 0) continue;
+      const size = PROBE * Math.min(INK_HEIGHT / blockH, INK_WIDTH / inkW);
+      ctx.font = `bold ${size}px ${font}`;
+      const m = ctx.measureText(text);
+      const ascent = m.actualBoundingBoxAscent;
+      const descent = m.actualBoundingBoxDescent;
+      const height = ascent + descent + (underline ? 0.16 * size : 0);
+      const cx = (i + 0.5) * CELL + (m.actualBoundingBoxLeft - m.actualBoundingBoxRight) / 2;
+      const baseline = (row + 0.5) * CELL - height / 2 + ascent;
+      ctx.fillText(text, cx, baseline);
+      if (underline) {
+        const half = Math.max(m.actualBoundingBoxLeft + m.actualBoundingBoxRight, 0.4 * size) / 2;
+        ctx.fillRect(cx - half, baseline + descent + 0.08 * size, 2 * half, 0.08 * size);
+      }
+    }
+  });
+  return canvas;
+}
+
+// src/render/camera.ts
+var CAMERA_DISTANCE = 14;
+var INSET_X = 0.6;
+var INSET_Z = 0.6;
+var HALF_Z = 5.1;
+var AREA_PER_DIE = 5;
+var POSITION = Object.freeze([
+  0,
+  CAMERA_DISTANCE,
+  0
+]);
+var TOP = 20;
+var BOTTOM = -1;
+function viewProjection(aspect, out) {
+  out.fill(0);
+  out[0] = 1 / (aspect * HALF_Z);
+  out[6] = -2 / (TOP - BOTTOM);
+  out[9] = -1 / HALF_Z;
+  out[14] = (TOP + BOTTOM) / (TOP - BOTTOM);
+  out[15] = 1;
+  return out;
+}
+function cameraPosition() {
+  return POSITION;
+}
+function positive(name, value) {
+  if (!Number.isFinite(value) || value <= 0) {
+    throw new RangeError(`${name} must be a positive finite number, got ${value}`);
+  }
+}
+function trayBounds(aspect, dieScale) {
+  positive("aspect", aspect);
+  positive("dieScale", dieScale);
+  const halfX = aspect * HALF_Z;
+  const ceil = (v) => Math.ceil(v * 4) / 4 + 0;
+  const floor = (v) => Math.floor(v * 4) / 4 + 0;
+  return {
+    minX: Math.min(ceil(-halfX / dieScale + INSET_X), -2),
+    maxX: Math.max(floor(halfX / dieScale - INSET_X), 2),
+    minZ: ceil(-HALF_Z / dieScale + INSET_Z),
+    maxZ: floor(HALF_Z / dieScale - INSET_Z)
+  };
+}
+function fitScale(requested, bodyCount, aspect) {
+  let s = requested;
+  for (let k = 1; s > 0.5; k++) {
+    const b = trayBounds(aspect, s);
+    if ((b.maxX - b.minX) * (b.maxZ - b.minZ) >= bodyCount * AREA_PER_DIE) break;
+    s = Math.max((requested * 20 - k) / 20, 0.5);
+  }
+  return s;
+}
+
+// src/render/gl.ts
+var PollyrollShaderError = class extends Error {
+  log;
+  constructor(message, log) {
+    super(message);
+    this.name = "PollyrollShaderError";
+    this.log = log;
+  }
+};
+function compile(gl, type, source) {
+  const shader = gl.createShader(type);
+  if (shader === null) throw new PollyrollShaderError("cannot create shader", "");
+  gl.shaderSource(shader, source);
+  gl.compileShader(shader);
+  if (!gl.getShaderParameter(shader, gl.COMPILE_STATUS)) {
+    const log = gl.getShaderInfoLog(shader) ?? "";
+    gl.deleteShader(shader);
+    throw new PollyrollShaderError("shader compile failed", log);
+  }
+  return shader;
+}
+function createProgram(gl, vertex, fragment) {
+  const vs = compile(gl, gl.VERTEX_SHADER, vertex);
+  let fs;
+  try {
+    fs = compile(gl, gl.FRAGMENT_SHADER, fragment);
+  } catch (error) {
+    gl.deleteShader(vs);
+    throw error;
+  }
+  const program = gl.createProgram();
+  gl.attachShader(program, vs);
+  gl.attachShader(program, fs);
+  gl.linkProgram(program);
+  gl.detachShader(program, vs);
+  gl.detachShader(program, fs);
+  gl.deleteShader(vs);
+  gl.deleteShader(fs);
+  if (!gl.getProgramParameter(program, gl.LINK_STATUS)) {
+    const log = gl.getProgramInfoLog(program) ?? "";
+    gl.deleteProgram(program);
+    throw new PollyrollShaderError("shader link failed", log);
+  }
+  return program;
+}
+function createBuffer(gl, data) {
+  const buffer = gl.createBuffer();
+  gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
+  if (typeof data === "number") gl.bufferData(gl.ARRAY_BUFFER, data, gl.DYNAMIC_DRAW);
+  else gl.bufferData(gl.ARRAY_BUFFER, data, gl.STATIC_DRAW);
+  return buffer;
+}
+function attrib(gl, location, size, stride, offset, divisor) {
+  gl.enableVertexAttribArray(location);
+  gl.vertexAttribPointer(location, size, gl.FLOAT, false, stride * 4, offset * 4);
+  gl.vertexAttribDivisor(location, divisor);
+}
+
+// src/render/tray.ts
+var FADE_MS = 300;
+var INST = 8;
+var FRAME2 = 7;
+var SHADOW_X = 0.5 / LIGHT_DIR[1];
+var SHADOW_Z = 0.5 / LIGHT_DIR[1];
+var materialPresets = {
+  plastic: { metalness: 0, roughness: 0.35, clearcoat: 0.3, transmission: 0, tint: 0, sparkle: 0 },
+  metal: { metalness: 1, roughness: 0.3, clearcoat: 0, transmission: 0, tint: 0, sparkle: 0 },
+  wood: { metalness: 0, roughness: 0.7, clearcoat: 0.1, transmission: 0, tint: 0, sparkle: 0 },
+  stone: { metalness: 0, roughness: 0.45, clearcoat: 0.6, transmission: 0, tint: 0, sparkle: 0 },
+  glass: { metalness: 0, roughness: 0.05, clearcoat: 1, transmission: 0.8, tint: 0.6, sparkle: 0 },
+  gem: { metalness: 0, roughness: 0.08, clearcoat: 1, transmission: 0.4, tint: 0.9, sparkle: 1 }
+};
+for (const m of Object.values(materialPresets)) Object.freeze(m);
+Object.freeze(materialPresets);
+var DIE_UNIFORMS = [
+  "uVP",
+  "uScale",
+  "uCam",
+  "uBase",
+  "uBase2",
+  "uLabel",
+  "uMat",
+  "uGlass",
+  "uAlpha",
+  "uAtlas"
+];
+var MAX_ANISOTROPY = 4;
+var colorCtx;
+var colors = /* @__PURE__ */ new Map();
+function linearColor(css) {
+  let c = colors.get(css);
+  if (c === void 0) {
+    colorCtx ??= document.createElement("canvas").getContext("2d");
+    let text = "#000000";
+    if (colorCtx !== null) {
+      colorCtx.fillStyle = "#000";
+      colorCtx.fillStyle = css;
+      text = String(colorCtx.fillStyle);
+    }
+    const srgb = text.startsWith("#") ? [1, 3, 5].map((i) => parseInt(text.slice(i, i + 2), 16)) : (text.match(/[\d.]+/g) ?? []).map(Number);
+    c = [0, 1, 2].map((i) => Math.pow((srgb[i] ?? 0) / 255, 2.2));
+    colors.set(css, c);
+  }
+  return c;
+}
+function skinGpu(skin) {
+  const m = typeof skin.material === "object" ? skin.material : materialPresets[skin.material];
+  const transparent = (m.transmission ?? 0) > 0;
+  const [a, b] = typeof skin.color === "string" ? [skin.color, skin.color] : skin.color;
+  const p = skin.pattern ?? "none";
+  const pattern = typeof p === "object" ? p.glsl : PATTERNS[p];
+  const label = skin.labelStyle ?? "engraved";
+  return {
+    key: `${label}|${transparent}|${pattern}`,
+    fragment: dieFragment(label, transparent, pattern),
+    transparent,
+    font: skin.font,
+    u: new Float32Array([
+      ...linearColor(a),
+      ...linearColor(b),
+      ...linearColor(skin.labelColor),
+      m.metalness,
+      m.roughness,
+      m.clearcoat ?? 0,
+      m.transmission ?? 0,
+      m.tint ?? 0,
+      m.sparkle ?? 0
+    ])
+  };
+}
+function at3(f, i) {
+  return f[i] ?? 0;
+}
+function writePose(b, s, row, out, o) {
+  const f = b.frames;
+  const last = f.length / FRAME2 - 1;
+  const fl = Math.floor(s);
+  let i0 = fl - b.startStep;
+  let t = s - fl;
+  if (i0 >= last) {
+    i0 = last;
+    t = 0;
+  }
+  const a = i0 * FRAME2;
+  const c = (i0 < last ? i0 + 1 : i0) * FRAME2;
+  for (let k = 0; k < 3; k++) out[o + k] = at3(f, a + k) + (at3(f, c + k) - at3(f, a + k)) * t;
+  out[o + 3] = row;
+  const sign = at3(f, a + 3) * at3(f, c + 3) + at3(f, a + 4) * at3(f, c + 4) + at3(f, a + 5) * at3(f, c + 5) + at3(f, a + 6) * at3(f, c + 6) < 0 ? -t : t;
+  const u = 1 - t;
+  let x = at3(f, a + 3) * u + at3(f, c + 3) * sign;
+  let y = at3(f, a + 4) * u + at3(f, c + 4) * sign;
+  let z = at3(f, a + 5) * u + at3(f, c + 5) * sign;
+  let w = at3(f, a + 6) * u + at3(f, c + 6) * sign;
+  const len = Math.sqrt(x * x + y * y + z * z + w * w) || 1;
+  x /= len;
+  y /= len;
+  z /= len;
+  w /= len;
+  const r = b.remap;
+  out[o + 4] = w * r[0] + x * r[3] + y * r[2] - z * r[1];
+  out[o + 5] = w * r[1] - x * r[2] + y * r[3] + z * r[0];
+  out[o + 6] = w * r[2] + x * r[1] - y * r[0] + z * r[3];
+  out[o + 7] = w * r[3] - x * r[0] - y * r[1] - z * r[2];
+}
+function createDiceTray(target, opts = {}) {
+  const own = !(target instanceof HTMLCanvasElement);
+  const canvas = own ? document.createElement("canvas") : target;
+  if (own) {
+    canvas.style.cssText = "position:absolute;inset:0;width:100%;height:100%;pointer-events:none";
+    target.appendChild(canvas);
+  }
+  let dieScale = opts.dieScale ?? 2;
+  const shadows = opts.shadows ?? true;
+  const maxDpr = opts.maxDpr ?? 2;
+  const fadeAfterMs = opts.fadeAfterMs ?? null;
+  const gl = canvas.getContext("webgl2", {
+    alpha: true,
+    premultipliedAlpha: true,
+    antialias: true
+  });
+  const labelFont = opts.labelFont ?? "system-ui";
+  let atlasFont = resolveSkin(opts.skin).font ?? labelFont;
+  let atlas = gl === null ? null : buildAtlas(atlasFont, opts.labels, labelFont);
+  let traySkin = opts.skin;
+  let lostSkin = null;
+  let roll = null;
+  let pending = null;
+  let disposed = false;
+  let lost = false;
+  let frame2 = 0;
+  let fadeTimer;
+  let fadeStart = -1;
+  let alpha = 1;
+  let aspect = 1;
+  const vp = new Float32Array(16);
+  const shadowData = new Float32Array(MAX_BODIES2 * 4);
+  const instances = /* @__PURE__ */ new Map();
+  const programs = /* @__PURE__ */ new Map();
+  const meshes = /* @__PURE__ */ new Map();
+  const sets = /* @__PURE__ */ new Map();
+  let shadowGpu = null;
+  let atlasTex = null;
+  function program(g, key, fragment) {
+    let p = programs.get(key);
+    if (p === void 0) {
+      const shadow = key === "shadow";
+      const prog = shadow ? createProgram(g, SHADOW_VERTEX, SHADOW_FRAGMENT) : createProgram(g, DIE_VERTEX, fragment);
+      const u = /* @__PURE__ */ new Map();
+      for (const name of shadow ? ["uVP", "uAlpha"] : DIE_UNIFORMS) {
+        u.set(name, g.getUniformLocation(prog, name));
+      }
+      p = { program: prog, u };
+      programs.set(key, p);
+    }
+    return p;
+  }
+  function setGpu(g, set) {
+    let s = sets.get(set);
+    if (s === void 0) {
+      const shape = shapeOf(set);
+      let mesh = meshes.get(shape);
+      if (mesh === void 0) {
+        mesh = createBuffer(g, getDieMesh(shape).data);
+        meshes.set(shape, mesh);
+      }
+      const vao = g.createVertexArray();
+      g.bindVertexArray(vao);
+      g.bindBuffer(g.ARRAY_BUFFER, mesh);
+      attrib(g, 0, 3, MESH_STRIDE, 0, 0);
+      attrib(g, 1, 3, MESH_STRIDE, 3, 0);
+      attrib(g, 2, 3, MESH_STRIDE, 6, 0);
+      const buf = createBuffer(g, MAX_BODIES2 * INST * 4);
+      attrib(g, 3, 4, INST, 0, 1);
+      attrib(g, 4, 4, INST, 4, 1);
+      g.bindVertexArray(null);
+      s = { vao, buf };
+      sets.set(set, s);
+    }
+    return s;
+  }
+  function shadowRes(g) {
+    if (shadowGpu === null) {
+      const vao = g.createVertexArray();
+      g.bindVertexArray(vao);
+      const quad = createBuffer(g, new Float32Array([-1, -1, 1, -1, -1, 1, 1, 1]));
+      attrib(g, 0, 2, 2, 0, 0);
+      const buf = createBuffer(g, MAX_BODIES2 * 4 * 4);
+      attrib(g, 1, 4, 4, 0, 1);
+      g.bindVertexArray(null);
+      shadowGpu = { vao, quad, buf };
+    }
+    return shadowGpu;
+  }
+  function atlasTexture(g) {
+    if (atlasTex === null) {
+      atlasTex = g.createTexture();
+      g.bindTexture(g.TEXTURE_2D, atlasTex);
+      g.pixelStorei(g.UNPACK_PREMULTIPLY_ALPHA_WEBGL, true);
+      if (atlas === null) {
+        g.texImage2D(g.TEXTURE_2D, 0, g.R8, 1, 1, 0, g.RED, g.UNSIGNED_BYTE, new Uint8Array(1));
+      } else {
+        g.texImage2D(g.TEXTURE_2D, 0, g.R8, g.RED, g.UNSIGNED_BYTE, atlas);
+      }
+      g.pixelStorei(g.UNPACK_PREMULTIPLY_ALPHA_WEBGL, false);
+      g.texParameteri(g.TEXTURE_2D, g.TEXTURE_MAX_LEVEL, ATLAS_MAX_LEVEL);
+      g.generateMipmap(g.TEXTURE_2D);
+      g.texParameteri(g.TEXTURE_2D, g.TEXTURE_MIN_FILTER, g.LINEAR_MIPMAP_LINEAR);
+      const aniso = g.getExtension("EXT_texture_filter_anisotropic");
+      if (aniso !== null) {
+        const max = Number(g.getParameter(aniso.MAX_TEXTURE_MAX_ANISOTROPY_EXT)) || 1;
+        g.texParameterf(
+          g.TEXTURE_2D,
+          aniso.TEXTURE_MAX_ANISOTROPY_EXT,
+          Math.min(max, MAX_ANISOTROPY)
+        );
+      }
+      g.texParameteri(g.TEXTURE_2D, g.TEXTURE_MAG_FILTER, g.LINEAR);
+      g.texParameteri(g.TEXTURE_2D, g.TEXTURE_WRAP_S, g.CLAMP_TO_EDGE);
+      g.texParameteri(g.TEXTURE_2D, g.TEXTURE_WRAP_T, g.CLAMP_TO_EDGE);
+    }
+    return atlasTex;
+  }
+  function atlasFor(g, font) {
+    if (font === atlasFont) return;
+    atlasFont = font;
+    atlas = buildAtlas(font, opts.labels, labelFont);
+    if (atlasTex !== null) g.deleteTexture(atlasTex);
+    atlasTex = null;
+  }
+  function compiles(g, s) {
+    try {
+      program(g, s.key, s.fragment);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  function dropGpu(g, remove) {
+    if (remove) {
+      for (const p of programs.values()) g.deleteProgram(p.program);
+      for (const b of meshes.values()) g.deleteBuffer(b);
+      for (const s of sets.values()) {
+        g.deleteVertexArray(s.vao);
+        g.deleteBuffer(s.buf);
+      }
+      if (shadowGpu !== null) {
+        g.deleteVertexArray(shadowGpu.vao);
+        g.deleteBuffer(shadowGpu.quad);
+        g.deleteBuffer(shadowGpu.buf);
+      }
+      if (atlasTex !== null) g.deleteTexture(atlasTex);
+    }
+    programs.clear();
+    meshes.clear();
+    sets.clear();
+    shadowGpu = null;
+    atlasTex = null;
+  }
+  function render() {
+    const g = gl;
+    if (g === null || lost || disposed) return;
+    g.viewport(0, 0, canvas.width, canvas.height);
+    g.clearColor(0, 0, 0, 0);
+    g.depthMask(true);
+    g.clear(g.COLOR_BUFFER_BIT | g.DEPTH_BUFFER_BIT);
+    const r = roll;
+    if (r === null) return;
+    viewProjection(aspect, vp);
+    const s = r.step;
+    const scale2 = r.scale;
+    let ns = 0;
+    for (let i = 0; i < r.groups.length; i++) {
+      const grp = r.groups[i];
+      if (grp === void 0) continue;
+      let n = 0;
+      for (let k2 = 0; k2 < grp.bodies.length; k2++) {
+        const b = grp.bodies[k2];
+        if (b === void 0 || b.startStep > s) continue;
+        const o = n * INST;
+        writePose(b, s, b.value === null ? -1 : grp.row, grp.data, o);
+        const h = at3(grp.data, o + 1) * scale2;
+        const fade = 1 - h / 4;
+        shadowData[ns * 4] = at3(grp.data, o) * scale2 + h * SHADOW_X;
+        shadowData[ns * 4 + 1] = at3(grp.data, o + 2) * scale2 + h * SHADOW_Z;
+        shadowData[ns * 4 + 2] = 1.3 * grp.radius * scale2;
+        shadowData[ns * 4 + 3] = 0.45 * (fade < 0 ? 0 : fade > 1 ? 1 : fade);
+        n++;
+        ns++;
+      }
+      grp.count = n;
+    }
+    g.enable(g.BLEND);
+    g.blendFunc(g.ONE, g.ONE_MINUS_SRC_ALPHA);
+    if (shadows && ns > 0) {
+      const p2 = program(g, "shadow", SHADOW_FRAGMENT);
+      const res = shadowRes(g);
+      g.disable(g.DEPTH_TEST);
+      g.disable(g.CULL_FACE);
+      g.useProgram(p2.program);
+      g.uniformMatrix4fv(p2.u.get("uVP") ?? null, false, vp);
+      g.uniform1f(p2.u.get("uAlpha") ?? null, alpha);
+      g.bindBuffer(g.ARRAY_BUFFER, res.buf);
+      g.bufferSubData(g.ARRAY_BUFFER, 0, shadowData, 0, ns * 4);
+      g.bindVertexArray(res.vao);
+      g.drawArraysInstanced(g.TRIANGLE_STRIP, 0, 4, ns);
+    }
+    const k = r.skin;
+    const p = program(g, k.key, k.fragment);
+    const u = p.u;
+    const f = k.u;
+    const cam = cameraPosition();
+    g.enable(g.DEPTH_TEST);
+    g.enable(g.CULL_FACE);
+    g.cullFace(g.BACK);
+    atlasFor(g, k.font ?? labelFont);
+    g.useProgram(p.program);
+    g.activeTexture(g.TEXTURE0);
+    g.bindTexture(g.TEXTURE_2D, atlasTexture(g));
+    g.uniform1i(u.get("uAtlas") ?? null, 0);
+    g.uniformMatrix4fv(u.get("uVP") ?? null, false, vp);
+    g.uniform1f(u.get("uScale") ?? null, scale2);
+    g.uniform3f(u.get("uCam") ?? null, cam[0], cam[1], cam[2]);
+    g.uniform3f(u.get("uBase") ?? null, at3(f, 0), at3(f, 1), at3(f, 2));
+    g.uniform3f(u.get("uBase2") ?? null, at3(f, 3), at3(f, 4), at3(f, 5));
+    g.uniform3f(u.get("uLabel") ?? null, at3(f, 6), at3(f, 7), at3(f, 8));
+    g.uniform3f(u.get("uMat") ?? null, at3(f, 9), at3(f, 10), at3(f, 11));
+    g.uniform3f(u.get("uGlass") ?? null, at3(f, 12), at3(f, 13), at3(f, 14));
+    g.uniform1f(u.get("uAlpha") ?? null, alpha);
+    if (k.transparent) {
+      g.depthMask(false);
+      g.cullFace(g.FRONT);
+      drawDice(g, r, true);
+      g.depthMask(true);
+      g.cullFace(g.BACK);
+      drawDice(g, r, false);
+    } else {
+      drawDice(g, r, true);
+    }
+    g.bindVertexArray(null);
+  }
+  function drawDice(g, r, upload) {
+    for (let i = 0; i < r.groups.length; i++) {
+      const grp = r.groups[i];
+      if (grp === void 0 || grp.count === 0) continue;
+      const res = setGpu(g, grp.set);
+      if (upload) {
+        g.bindBuffer(g.ARRAY_BUFFER, res.buf);
+        g.bufferSubData(g.ARRAY_BUFFER, 0, grp.data, 0, grp.count * INST);
+      }
+      g.bindVertexArray(res.vao);
+      g.drawArraysInstanced(g.TRIANGLES, 0, getDieMesh(shapeOf(grp.set)).vertexCount, grp.count);
+    }
+  }
+  function resolvePending() {
+    const p = pending;
+    pending = null;
+    if (p !== null) p.resolve(p.summary);
+  }
+  function loop() {
+    if (frame2 === 0 && !lost && !disposed) frame2 = requestAnimationFrame(tick);
+  }
+  function stop() {
+    if (frame2 !== 0) cancelAnimationFrame(frame2);
+    frame2 = 0;
+    clearTimeout(fadeTimer);
+    fadeTimer = void 0;
+    fadeStart = -1;
+    alpha = 1;
+  }
+  function settle(r) {
+    r.step = r.plan.totalSteps;
+    r.done = true;
+    render();
+    resolvePending();
+    if (fadeAfterMs === null) return;
+    fadeTimer = setTimeout(() => {
+      fadeTimer = void 0;
+      fadeStart = performance.now();
+      loop();
+    }, fadeAfterMs);
+  }
+  function tick() {
+    frame2 = 0;
+    const r = roll;
+    if (r === null) return;
+    const now = performance.now();
+    if (!r.done) {
+      const s = (now - r.t0) / 1e3 / DT;
+      if (s >= r.plan.totalSteps) {
+        settle(r);
+        return;
+      }
+      r.step = s < 0 ? 0 : s;
+    } else if (fadeStart >= 0) {
+      alpha = 1 - (now - fadeStart) / FADE_MS;
+      if (alpha <= 0) {
+        tray.clear();
+        return;
+      }
+    } else {
+      return;
+    }
+    render();
+    frame2 = requestAnimationFrame(tick);
+  }
+  function fit() {
+    const cw = canvas.clientWidth;
+    const ch = canvas.clientHeight;
+    if (cw <= 0 || ch <= 0) {
+      aspect = 1;
+      return;
+    }
+    aspect = cw / ch;
+    const dpr = Math.min(devicePixelRatio, maxDpr);
+    const w = Math.max(1, Math.round(cw * dpr));
+    const h = Math.max(1, Math.round(ch * dpr));
+    if (canvas.width !== w || canvas.height !== h) {
+      canvas.width = w;
+      canvas.height = h;
+    }
+  }
+  function reduced() {
+    const mode = opts.reducedMotion ?? "auto";
+    return mode === "always" || mode === "auto" && matchMedia("(prefers-reduced-motion: reduce)").matches;
+  }
+  const onLost = (e) => {
+    e.preventDefault();
+    lost = true;
+    if (frame2 !== 0) cancelAnimationFrame(frame2);
+    frame2 = 0;
+    if (gl !== null) dropGpu(gl, false);
+    resolvePending();
+  };
+  const onRestored = () => {
+    lost = false;
+    const g = gl;
+    const r = roll;
+    if (g !== null) {
+      const want = lostSkin;
+      lostSkin = null;
+      if (want !== null && compiles(g, want.gpu)) {
+        traySkin = want.ref;
+        if (r !== null && r.eventSkin === void 0) r.skin = want.gpu;
+      }
+      if (r !== null && !compiles(g, r.skin)) {
+        r.skin = skinGpu(resolveSkin(traySkin));
+        if (!compiles(g, r.skin)) r.skin = skinGpu(resolveSkin(void 0));
+      }
+    }
+    if (r !== null && (!r.done || fadeStart >= 0)) loop();
+    else render();
+  };
+  let observer = null;
+  const tray = {
+    supported: gl !== null,
+    async playRoll(event) {
+      const summary = chunkOEMS7CZP_cjs.evaluate(event);
+      if (disposed || gl === null) return summary;
+      const skin = skinGpu(resolveSkin(event.skin ?? traySkin));
+      if (!lost) program(gl, skin.key, skin.fragment);
+      stop();
+      resolvePending();
+      fit();
+      const scale2 = fitScale(dieScale, slots(event).length, aspect);
+      const plan = planRoll(event, trayBounds(aspect, scale2));
+      const groups = [];
+      LABEL_SETS.forEach((set, row) => {
+        const bodies = plan.bodies.filter((b) => b.labelSet === set);
+        if (bodies.length === 0) return;
+        const radius = getPolyhedron(shapeOf(set)).radius;
+        let data = instances.get(set);
+        if (data === void 0) {
+          data = new Float32Array(MAX_BODIES2 * INST);
+          instances.set(set, data);
+        }
+        groups.push({ set, row, bodies, radius, data, count: 0 });
+      });
+      const r = {
+        plan,
+        groups,
+        eventSkin: event.skin,
+        skin,
+        scale: scale2,
+        t0: performance.now(),
+        step: 0,
+        done: false
+      };
+      roll = r;
+      const done = new Promise((resolve) => {
+        pending = { resolve, summary };
+      });
+      if (reduced() || lost) settle(r);
+      else loop();
+      return done;
+    },
+    setSkin(skin) {
+      if (gl !== null && !disposed) {
+        const s = skinGpu(resolveSkin(skin));
+        if (lost) {
+          lostSkin = { ref: skin, gpu: s };
+          return;
+        }
+        program(gl, s.key, s.fragment);
+        const r = roll;
+        if (r !== null && r.eventSkin === void 0) {
+          r.skin = s;
+          if (frame2 === 0) render();
+        }
+      }
+      traySkin = skin;
+    },
+    setDieScale(scale2) {
+      if (!Number.isFinite(scale2) || scale2 <= 0) {
+        throw new RangeError(`dieScale must be a positive finite number, got ${scale2}`);
+      }
+      dieScale = scale2;
+    },
+    clear() {
+      stop();
+      roll = null;
+      resolvePending();
+      render();
+    },
+    resize() {
+      fit();
+      render();
+    },
+    dispose() {
+      if (disposed) return;
+      stop();
+      roll = null;
+      resolvePending();
+      disposed = true;
+      canvas.removeEventListener("webglcontextlost", onLost);
+      canvas.removeEventListener("webglcontextrestored", onRestored);
+      observer?.disconnect();
+      observer = null;
+      if (gl !== null) dropGpu(gl, !lost && !gl.isContextLost());
+      if (own) canvas.remove();
+    }
+  };
+  if (gl !== null) {
+    canvas.addEventListener("webglcontextlost", onLost);
+    canvas.addEventListener("webglcontextrestored", onRestored);
+    observer = new ResizeObserver(() => tray.resize());
+    observer.observe(canvas);
+    fit();
+    render();
+  }
+  return tray;
+}
+
+exports.PollyrollShaderError = PollyrollShaderError;
+exports.amethyst = amethyst;
+exports.aquamarine = aquamarine;
+exports.brass = brass;
+exports.classic = classic;
+exports.createDiceTray = createDiceTray;
+exports.defineSkin = defineSkin;
+exports.emerald = emerald;
+exports.materialPresets = materialPresets;
+exports.oak = oak;
+exports.obsidian = obsidian;
+exports.registerSkin = registerSkin;
+exports.ruby = ruby;
+exports.sapphire = sapphire;
+exports.smoke = smoke;
+exports.topaz = topaz;