plushies 0.1.0-alpha.0

package/dist/plushies.cjs

@@ -0,0 +1,2289 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __moduleCache = /* @__PURE__ */ new WeakMap;
+var __toCommonJS = (from) => {
+  var entry = __moduleCache.get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function")
+    __getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    }));
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+
+// src/index.ts
+var exports_src = {};
+__export(exports_src, {
+  resetEnvironment: () => resetEnvironment,
+  plushieOutline: () => plushieOutline,
+  fabricGrain: () => fabricGrain,
+  fabricFur: () => fabricFur,
+  createPlushie: () => createPlushie,
+  PLUSHIE_PINS: () => PLUSHIE_PINS,
+  PLUSHIE_NECKS: () => PLUSHIE_NECKS,
+  PLUSHIE_MOUTHS: () => PLUSHIE_MOUTHS,
+  PLUSHIE_MOUSTACHES: () => PLUSHIE_MOUSTACHES,
+  PLUSHIE_KINDS: () => PLUSHIE_KINDS,
+  PLUSHIE_HATS: () => PLUSHIE_HATS,
+  PLUSHIE_GLASSES: () => PLUSHIE_GLASSES,
+  PLUSHIE_FINISHES: () => PLUSHIE_FINISHES,
+  PLUSHIE_FABRICS: () => PLUSHIE_FABRICS,
+  PLUSHIE_EYES: () => PLUSHIE_EYES,
+  MAX_FUR_SHELLS: () => MAX_FUR_SHELLS,
+  DEFAULT_POSE: () => DEFAULT_POSE,
+  DEFAULT_OPTIONS: () => DEFAULT_OPTIONS,
+  ACCESSORY_COLORS: () => ACCESSORY_COLORS
+});
+module.exports = __toCommonJS(exports_src);
+function toRgb(three, color) {
+  if (typeof color !== "string") {
+    const rgb2 = [color[0], color[1], color[2]].map((v) => Number.isFinite(v) ? Math.max(0, Math.min(1, v)) : 0);
+    return rgb2;
+  }
+  const cached = COLORS.get(color);
+  if (cached)
+    return cached;
+  const rgb = parseColor(three, color) ?? unknownColor(three, color);
+  if (COLORS.size > 256)
+    COLORS.clear();
+  COLORS.set(color, rgb);
+  return rgb;
+}
+var COLORS = new Map;
+function toHex(three, color) {
+  if (color === undefined)
+    return;
+  if (/^#[0-9a-f]{6}$/i.test(color))
+    return color;
+  return "#" + toRgb(three, color).map((v) => Math.round(v * 255).toString(16).padStart(2, "0")).join("");
+}
+function unknownColor(three, color) {
+  console.warn(`plushies: unknown colour ${JSON.stringify(color)}, using ${DEFAULT_COLOR}`);
+  return parseColor(three, DEFAULT_COLOR);
+}
+var DEFAULT_COLOR = "#f2b33d";
+var NUM = "[+-]?(?:\\d+\\.?\\d*|\\.\\d+)(?:e[+-]?\\d+)?";
+var IS_NUMBER = new RegExp(`^${NUM}$`);
+var IS_PERCENT = new RegExp(`^${NUM}%$`);
+var IS_HUE = new RegExp(`^${NUM}(?:deg|grad|rad|turn)?$`);
+function cssHue(token) {
+  const v = parseFloat(token);
+  if (token.endsWith("turn"))
+    return v * 360;
+  if (token.endsWith("grad"))
+    return v * 0.9;
+  if (token.endsWith("rad"))
+    return v * 180 / Math.PI;
+  return v;
+}
+function parseRgbHsl(three, name, body) {
+  const legacy = body.includes(",");
+  let parts;
+  let alpha;
+  if (legacy) {
+    parts = body.split(",").map((p) => p.trim());
+    if (parts.length === 4)
+      alpha = parts.pop();
+  } else {
+    const [main, a, extra] = body.split("/").map((p) => p.trim());
+    if (extra !== undefined || a === "")
+      return null;
+    parts = main.split(/\s+/).filter(Boolean);
+    alpha = a;
+  }
+  if (parts.length !== 3)
+    return null;
+  if (alpha !== undefined && !IS_NUMBER.test(alpha) && !IS_PERCENT.test(alpha))
+    return null;
+  let rgb;
+  if (name.startsWith("rgb")) {
+    const pct = parts.map((p) => IS_PERCENT.test(p));
+    if (parts.some((p, i) => !pct[i] && !IS_NUMBER.test(p)))
+      return null;
+    if (legacy && pct.some((v) => v !== pct[0]))
+      return null;
+    rgb = parts.map((p, i) => pct[i] ? parseFloat(p) / 100 : parseFloat(p) / 255);
+  } else {
+    const [hue, ...sl] = parts;
+    if (!IS_HUE.test(hue))
+      return null;
+    if (sl.some((p) => !IS_PERCENT.test(p) && (legacy || !IS_NUMBER.test(p))))
+      return null;
+    const [s, l] = sl.map((p) => Math.max(0, Math.min(1, parseFloat(p) / 100)));
+    const h = (cssHue(hue) % 360 + 360) % 360 / 360;
+    const out = { r: 0, g: 0, b: 0 };
+    new three.Color().setHSL(h, s, l, three.SRGBColorSpace).getRGB(out, three.SRGBColorSpace);
+    rgb = [out.r, out.g, out.b];
+  }
+  if (rgb.some((v) => !Number.isFinite(v)))
+    return null;
+  return rgb.map((v) => Math.max(0, Math.min(1, v)));
+}
+function parseColor(three, input) {
+  const color = input.trim().toLowerCase();
+  const hex = /^#([0-9a-f]{3,8})$/.exec(color);
+  if (hex && (hex[1].length === 3 || hex[1].length === 4)) {
+    const h = hex[1];
+    return [0, 1, 2].map((i) => parseInt(h[i] + h[i], 16) / 255);
+  }
+  if (hex && (hex[1].length === 6 || hex[1].length === 8)) {
+    const h = hex[1];
+    return [0, 2, 4].map((i) => parseInt(h.slice(i, i + 2), 16) / 255);
+  }
+  if (hex)
+    return null;
+  const fn = /^(rgba?|hsla?)\(\s*([^()]*)\)$/.exec(color);
+  if (fn)
+    return parseRgbHsl(three, fn[1], fn[2]) ?? browserColor(color);
+  if (/^[a-z]+$/.test(color) && color in three.Color.NAMES) {
+    return parseColor(three, "#" + three.Color.NAMES[color].toString(16).padStart(6, "0"));
+  }
+  return browserColor(color);
+}
+var probe;
+function browserColor(color) {
+  if (probe === undefined) {
+    try {
+      const canvas = typeof OffscreenCanvas !== "undefined" ? new OffscreenCanvas(1, 1) : typeof document !== "undefined" ? Object.assign(document.createElement("canvas"), { width: 1, height: 1 }) : null;
+      probe = canvas?.getContext("2d", { willReadFrequently: true }) ?? null;
+    } catch {
+      probe = null;
+    }
+  }
+  if (!probe || typeof CSS === "undefined" || !CSS.supports("color", color))
+    return null;
+  probe.clearRect(0, 0, 1, 1);
+  probe.fillStyle = "#000";
+  probe.fillStyle = color;
+  probe.fillRect(0, 0, 1, 1);
+  const [r, g, b] = probe.getImageData(0, 0, 1, 1).data;
+  return [r, g, b].map((v) => v / 255);
+}
+function mulberry32(seed) {
+  let a = seed >>> 0;
+  return () => {
+    a = a + 1831565813 >>> 0;
+    let t = a;
+    t = Math.imul(t ^ t >>> 15, t | 1);
+    t ^= t + Math.imul(t ^ t >>> 7, t | 61);
+    return ((t ^ t >>> 14) >>> 0) / 4294967296;
+  };
+}
+function signedArea(poly) {
+  let a = 0;
+  for (let i = 0;i < poly.length; i++) {
+    const [x0, y0] = poly[i];
+    const [x1, y1] = poly[(i + 1) % poly.length];
+    a += x0 * y1 - x1 * y0;
+  }
+  return a / 2;
+}
+function centroid(poly) {
+  let cx = 0;
+  let cy = 0;
+  let a = 0;
+  for (let i = 0;i < poly.length; i++) {
+    const [x0, y0] = poly[i];
+    const [x1, y1] = poly[(i + 1) % poly.length];
+    const cross = x0 * y1 - x1 * y0;
+    a += cross;
+    cx += (x0 + x1) * cross;
+    cy += (y0 + y1) * cross;
+  }
+  return [cx / (3 * a), cy / (3 * a)];
+}
+function roundedPolygon(vertices, radius, steps = 14) {
+  const out = [];
+  const n = vertices.length;
+  for (let i = 0;i < n; i++) {
+    const p = vertices[i];
+    const prev = vertices[(i + n - 1) % n];
+    const next = vertices[(i + 1) % n];
+    const la = Math.hypot(prev[0] - p[0], prev[1] - p[1]);
+    const lb = Math.hypot(next[0] - p[0], next[1] - p[1]);
+    const a = [(prev[0] - p[0]) / la, (prev[1] - p[1]) / la];
+    const b = [(next[0] - p[0]) / lb, (next[1] - p[1]) / lb];
+    const angle = Math.acos(Math.max(-1, Math.min(1, a[0] * b[0] + a[1] * b[1])));
+    const t = Math.min(radius / Math.tan(angle / 2), la * 0.48, lb * 0.48);
+    const r = t * Math.tan(angle / 2);
+    const bis = [a[0] + b[0], a[1] + b[1]];
+    const bl = Math.hypot(bis[0], bis[1]) || 1;
+    const dist = r / Math.sin(angle / 2);
+    const c = [p[0] + bis[0] / bl * dist, p[1] + bis[1] / bl * dist];
+    const t1 = [p[0] + a[0] * t, p[1] + a[1] * t];
+    const t2 = [p[0] + b[0] * t, p[1] + b[1] * t];
+    const s = Math.atan2(t1[1] - c[1], t1[0] - c[0]);
+    let e = Math.atan2(t2[1] - c[1], t2[0] - c[0]);
+    let d = e - s;
+    while (d > Math.PI)
+      d -= Math.PI * 2;
+    while (d < -Math.PI)
+      d += Math.PI * 2;
+    e = s + d;
+    for (let k = 0;k <= steps; k++) {
+      const th = s + d * k / steps;
+      out.push([c[0] + Math.cos(th) * r, c[1] + Math.sin(th) * r]);
+    }
+  }
+  return out;
+}
+function smoothClosed(poly, iterations) {
+  let pts = poly;
+  for (let it = 0;it < iterations; it++) {
+    pts = pts.map((p, i) => {
+      const a = pts[(i + pts.length - 1) % pts.length];
+      const b = pts[(i + 1) % pts.length];
+      return [p[0] * 0.5 + (a[0] + b[0]) * 0.25, p[1] * 0.5 + (a[1] + b[1]) * 0.25];
+    });
+  }
+  return pts;
+}
+function resampleClosed(poly, n) {
+  const lengths = [0];
+  for (let i = 0;i < poly.length; i++) {
+    const a = poly[i];
+    const b = poly[(i + 1) % poly.length];
+    lengths.push(lengths[i] + Math.hypot(b[0] - a[0], b[1] - a[1]));
+  }
+  const total = lengths[poly.length];
+  const out = [];
+  let seg = 0;
+  for (let k = 0;k < n; k++) {
+    const target = k / n * total;
+    while (lengths[seg + 1] < target)
+      seg++;
+    const a = poly[seg];
+    const b = poly[(seg + 1) % poly.length];
+    const f = (target - lengths[seg]) / Math.max(0.000000001, lengths[seg + 1] - lengths[seg]);
+    out.push([a[0] + (b[0] - a[0]) * f, a[1] + (b[1] - a[1]) * f]);
+  }
+  return out;
+}
+function polar(n, r) {
+  return Array.from({ length: n }, (_, i) => {
+    const th = i / n * Math.PI * 2;
+    const rr = r(th);
+    return [Math.cos(th) * rr, Math.sin(th) * rr];
+  });
+}
+function regular(n, radius, phase) {
+  return Array.from({ length: n }, (_, i) => {
+    const th = phase + i / n * Math.PI * 2;
+    return [Math.cos(th) * radius, Math.sin(th) * radius];
+  });
+}
+function silhouette(kind, o) {
+  const round = Math.max(0, Math.min(1, o.roundness));
+  let poly;
+  switch (kind) {
+    case "square": {
+      const sq = [[-1, -1], [1, -1], [1, 1], [-1, 1]];
+      poly = roundedPolygon(sq, 0.12 + 0.62 * round);
+      break;
+    }
+    case "triangle":
+    case "polygon": {
+      const n = kind === "triangle" ? 3 : Math.max(3, Math.round(o.sides ?? 6));
+      const inradius = Math.cos(Math.PI / n);
+      poly = roundedPolygon(regular(n, 1, Math.PI / 2), inradius * (0.12 + 0.72 * round));
+      break;
+    }
+    case "star": {
+      const n = Math.max(3, Math.round(o.sides ?? 5));
+      const inner = Math.max(0.2, Math.min(0.9, o.starInner));
+      const pts = [];
+      for (let i = 0;i < n * 2; i++) {
+        const th = Math.PI / 2 + i / (n * 2) * Math.PI * 2;
+        const rr = i % 2 === 0 ? 1 : inner;
+        pts.push([Math.cos(th) * rr, Math.sin(th) * rr]);
+      }
+      poly = roundedPolygon(pts, 0.06 + 0.3 * round);
+      break;
+    }
+    case "heart": {
+      const raw = Array.from({ length: 240 }, (_, i) => {
+        const t = i / 240 * Math.PI * 2;
+        return [
+          16 * Math.sin(t) ** 3,
+          13 * Math.cos(t) - 5 * Math.cos(2 * t) - 2 * Math.cos(3 * t) - Math.cos(4 * t)
+        ];
+      });
+      poly = smoothClosed(raw, Math.round(20 + 180 * round));
+      break;
+    }
+    case "pill":
+      poly = roundedPolygon([[-0.62, -1], [0.62, -1], [0.62, 1], [-0.62, 1]], 0.61);
+      break;
+    case "cloud": {
+      const circles = [
+        [-0.62, -0.2, 0.42],
+        [-0.25, 0.18, 0.5],
+        [0.3, 0.22, 0.47],
+        [0.68, -0.12, 0.4],
+        [0.05, -0.28, 0.46]
+      ];
+      const raw = polar(360, (th) => {
+        const ux = Math.cos(th);
+        const uy = Math.sin(th);
+        let best = 0;
+        for (const [cx, cy, r] of circles) {
+          const b = ux * cx + uy * cy;
+          const disc = b * b - (cx * cx + cy * cy) + r * r;
+          if (disc >= 0)
+            best = Math.max(best, b + Math.sqrt(disc));
+        }
+        return best;
+      });
+      poly = smoothClosed(raw, Math.round(10 + 60 * round));
+      break;
+    }
+    case "blob": {
+      const rand = mulberry32(o.seed * 9973 + 17);
+      const waves = [2, 3, 4, 5].map((k) => ({
+        k,
+        amp: 0.2 / k * (0.5 + rand()),
+        phase: rand() * Math.PI * 2
+      }));
+      poly = polar(240, (th) => waves.reduce((r, w) => r + w.amp * Math.cos(w.k * th + w.phase), 1));
+      break;
+    }
+    case "egg":
+      poly = polar(240, () => 1).map(([x, y]) => [x * 0.8 * (1 - 0.14 * y), y]);
+      break;
+    case "drop": {
+      const raw = Array.from({ length: 240 }, (_, i) => {
+        const t = i / 240 * Math.PI * 2;
+        return [Math.sin(t) * Math.pow(Math.sin(t / 2), 1.3), Math.cos(t)];
+      });
+      poly = smoothClosed(raw, Math.round(4 + 60 * round));
+      break;
+    }
+    case "ghost": {
+      const raw = [];
+      for (let i = 0;i <= 60; i++) {
+        const th = i / 60 * Math.PI;
+        raw.push([Math.cos(th), 0.15 + Math.sin(th)]);
+      }
+      for (let i = 1;i <= 20; i++)
+        raw.push([-1, 0.15 - i / 20 * 1.05]);
+      for (let i = 0;i <= 90; i++) {
+        const x = -1 + i / 90 * 2;
+        raw.push([x, -0.9 - 0.14 * Math.abs(Math.sin((x + 1) / 2 * Math.PI * 3))]);
+      }
+      for (let i = 0;i < 20; i++)
+        raw.push([1, -0.9 + i / 20 * 1.05]);
+      poly = smoothClosed(raw, Math.round(8 + 30 * round));
+      break;
+    }
+    case "bean":
+      poly = polar(240, () => 1).map(([x, y]) => [x, 0.62 * y - 0.26 * Math.pow(Math.max(0, y), 6)]);
+      break;
+    case "flower": {
+      const petals = Math.max(3, Math.round(o.sides ?? 6));
+      poly = polar(360, (th) => 0.6 + 0.4 * Math.abs(Math.cos(petals * (th - Math.PI / 2) / 2)));
+      poly = smoothClosed(poly, Math.round(6 + 50 * round));
+      break;
+    }
+    case "diamond":
+      poly = roundedPolygon([[0, 1], [-0.78, 0], [0, -1], [0.78, 0]], 0.08 + 0.3 * round);
+      break;
+    case "squircle": {
+      const n = 2.2 + (1 - round) * 5;
+      poly = polar(240, (th) => Math.pow(Math.pow(Math.abs(Math.cos(th)), n) + Math.pow(Math.abs(Math.sin(th)), n), -1 / n));
+      break;
+    }
+    case "arch": {
+      const raw = [[-0.8, -1], [0.8, -1]];
+      for (let i = 0;i <= 40; i++) {
+        const th = i / 40 * Math.PI;
+        raw.push([Math.cos(th) * 0.8, 0.2 + Math.sin(th) * 0.8]);
+      }
+      poly = roundedPolygon(raw, 0.1 + 0.3 * round, 10);
+      break;
+    }
+    case "circle":
+    default:
+      poly = polar(240, () => 1);
+  }
+  if (signedArea(poly) < 0)
+    poly = poly.slice().reverse();
+  poly = resampleClosed(poly, 150);
+  let minX = Infinity;
+  let maxX = -Infinity;
+  let minY = Infinity;
+  let maxY = -Infinity;
+  for (const [x, y] of poly) {
+    minX = Math.min(minX, x);
+    maxX = Math.max(maxX, x);
+    minY = Math.min(minY, y);
+    maxY = Math.max(maxY, y);
+  }
+  const s = 2 / Math.max(maxX - minX, maxY - minY);
+  const mx = (minX + maxX) / 2;
+  const my = (minY + maxY) / 2;
+  return poly.map(([x, y]) => [(x - mx) * s, (y - my) * s]);
+}
+function distanceToOutline(x, y, poly) {
+  let best = Infinity;
+  for (let i = 0;i < poly.length; i++) {
+    const [ax, ay] = poly[i];
+    const [bx, by] = poly[(i + 1) % poly.length];
+    const dx = bx - ax;
+    const dy = by - ay;
+    const t = Math.max(0, Math.min(1, ((x - ax) * dx + (y - ay) * dy) / (dx * dx + dy * dy)));
+    best = Math.min(best, Math.hypot(ax + dx * t - x, ay + dy * t - y));
+  }
+  return best;
+}
+function inflate(three, outline, thickness) {
+  const N = outline.length;
+  const K = 18;
+  const center = centroid(outline);
+  const [cx, cy] = center;
+  let dmax = 0;
+  for (let i = 0;i < 64; i++) {
+    const th = i / 64 * Math.PI * 2;
+    const x = cx + Math.cos(th) * 0.15;
+    const y = cy + Math.sin(th) * 0.15;
+    dmax = Math.max(dmax, distanceToOutline(x, y, outline));
+  }
+  dmax = Math.max(dmax, distanceToOutline(cx, cy, outline));
+  const H = thickness;
+  const D = Math.min(dmax, H * 1.25);
+  const profile = (d) => {
+    const u = Math.min(1, Math.max(0, d / D));
+    return H * (0.84 * Math.sqrt(u * (2 - u)) + 0.16 * Math.min(1, d / dmax));
+  };
+  const ringS = (k) => 1 - Math.pow(1 - k / K, 1.8);
+  const xy = [[cx, cy]];
+  for (let k = 1;k <= K; k++) {
+    const s = ringS(k);
+    for (let i = 0;i < N; i++) {
+      xy.push([cx + (outline[i][0] - cx) * s, cy + (outline[i][1] - cy) * s]);
+    }
+  }
+  const idx = (k, i) => k === 0 ? 0 : 1 + (k - 1) * N + (i % N + N) % N;
+  let h = xy.map(([x, y], v) => v >= 1 + (K - 1) * N ? 0 : profile(distanceToOutline(x, y, outline)));
+  for (let it = 0;it < 6; it++) {
+    const next = h.slice();
+    let ring1 = 0;
+    for (let i = 0;i < N; i++)
+      ring1 += h[idx(1, i)];
+    next[0] = h[0] * 0.5 + ring1 / N * 0.5;
+    for (let k = 1;k < K; k++) {
+      for (let i = 0;i < N; i++) {
+        const v = idx(k, i);
+        const avg = (h[idx(k, i - 1)] + h[idx(k, i + 1)] + h[idx(k - 1, i)] + h[idx(k + 1, i)]) / 4;
+        next[v] = h[v] * 0.5 + avg * 0.5;
+      }
+    }
+    h = next;
+  }
+  const V = xy.length;
+  const backStart = V;
+  const backCount = 1 + (K - 1) * N;
+  const positions = new Float32Array((V + backCount) * 3);
+  for (let v = 0;v < V; v++) {
+    positions.set([xy[v][0], xy[v][1], h[v]], v * 3);
+  }
+  for (let v = 0;v < backCount; v++) {
+    positions.set([xy[v][0], xy[v][1], -h[v] * 0.9], (backStart + v) * 3);
+  }
+  const backIdx = (k, i) => k === K ? idx(K, i) : backStart + idx(k, i);
+  const index = [];
+  for (let i = 0;i < N; i++) {
+    index.push(0, idx(1, i), idx(1, i + 1));
+    index.push(backStart, backIdx(1, i + 1), backIdx(1, i));
+    for (let k = 1;k < K; k++) {
+      const a = idx(k, i);
+      const b = idx(k, i + 1);
+      const c = idx(k + 1, i + 1);
+      const d = idx(k + 1, i);
+      index.push(a, d, c, a, c, b);
+      const ba = backIdx(k, i);
+      const bb = backIdx(k, i + 1);
+      const bc = backIdx(k + 1, i + 1);
+      const bd = backIdx(k + 1, i);
+      index.push(ba, bc, bd, ba, bb, bc);
+    }
+  }
+  const geometry = new three.BufferGeometry;
+  geometry.setAttribute("position", new three.BufferAttribute(positions, 3));
+  geometry.setIndex(index);
+  geometry.computeVertexNormals();
+  return {
+    outline,
+    center,
+    heightAt: (x, y) => profile(distanceToOutline(x, y, outline)),
+    geometry
+  };
+}
+var FUR_SHELLS = 16;
+function furShells(three, base, shells = FUR_SHELLS) {
+  const pos = base.getAttribute("position");
+  const nor = base.getAttribute("normal");
+  const baseIndex = base.getIndex();
+  const count = pos.count;
+  const layers = shells + 1;
+  const positions = new Float32Array(count * layers * 3);
+  const normals = new Float32Array(count * layers * 3);
+  const shell = new Float32Array(count * layers);
+  for (let l = 0;l < layers; l++) {
+    positions.set(pos.array, l * count * 3);
+    normals.set(nor.array, l * count * 3);
+    shell.fill(l, l * count, (l + 1) * count);
+  }
+  const src = baseIndex ? Array.from(baseIndex.array) : Array.from({ length: count }, (_, i) => i);
+  const index = new Uint32Array(src.length * layers);
+  for (let l = 0;l < layers; l++) {
+    for (let i = 0;i < src.length; i++)
+      index[l * src.length + i] = src[i] + l * count;
+  }
+  const g = new three.BufferGeometry;
+  g.setAttribute("position", new three.BufferAttribute(positions, 3));
+  g.setAttribute("normal", new three.BufferAttribute(normals, 3));
+  g.setAttribute("shell", new three.BufferAttribute(shell, 1));
+  g.setIndex(new three.BufferAttribute(index, 1));
+  g.userData.indexPerLayer = src.length;
+  return g;
+}
+var RIG = {
+  sky: ["#fffaf2", 0.5],
+  ground: ["#6e655d", 0.5],
+  key: { dir: [-300, 420, 520], color: "#fff4e4", power: 0.78 },
+  rim: { dir: [380, 260, -420], color: "#ffffff", power: 0.8 },
+  fill: { dir: [420, -120, 400], color: "#e8eeff", power: 0.2 }
+};
+var FUR_VERTEX = `
+attribute float shell;
+uniform float uFur;
+uniform float uLayers;
+uniform vec3 uGravity;
+uniform float uRoot;
+uniform vec3 uColor;
+uniform vec3 uSheen;
+uniform vec3 uSky;
+uniform vec3 uGround;
+uniform vec3 uKeyDir;
+uniform vec3 uKeyColor;
+uniform vec3 uRimDir;
+uniform vec3 uRimColor;
+uniform vec3 uFillDir;
+uniform vec3 uFillColor;
+uniform float uSheenAmt;
+uniform float uMottle;
+uniform float uBias;
+varying float vShell;
+varying vec3 vBase;
+varying vec3 vBaseNormal;
+varying vec3 vLit;
+float mottleHash(vec3 p) {
+  p = fract(p * 0.1031);
+  p += dot(p, p.zyx + 31.32);
+  return fract((p.x + p.y) * p.z);
+}
+// Smooth 3D value noise — only evaluated per vertex, so it is cheap.
+float mottleNoise(vec3 p) {
+  vec3 i = floor(p);
+  vec3 f = fract(p);
+  f = f * f * (3.0 - 2.0 * f);
+  return mix(
+    mix(mix(mottleHash(i), mottleHash(i + vec3(1, 0, 0)), f.x),
+        mix(mottleHash(i + vec3(0, 1, 0)), mottleHash(i + vec3(1, 1, 0)), f.x), f.y),
+    mix(mix(mottleHash(i + vec3(0, 0, 1)), mottleHash(i + vec3(1, 0, 1)), f.x),
+        mix(mottleHash(i + vec3(0, 1, 1)), mottleHash(i + vec3(1, 1, 1)), f.x), f.y),
+    f.z);
+}
+void main() {
+  vShell = min(1.0, shell / uLayers);
+  vec3 n = normalize(normal);
+  vBase = position;
+  vBaseNormal = n;
+  vec3 p = position + n * uFur * vShell + uGravity * uFur * vShell * vShell;
+  vec4 mv = modelViewMatrix * vec4(p, 1.0);
+  vec4 shaded = mv;
+  // Slide along the view ray: same pixel on screen, nearer depth.
+  mv.xyz += normalize(-mv.xyz) * uBias;
+  gl_Position = projectionMatrix * mv;
+  mv = shaded;
+
+  // Shading in view space (normalMatrix stays right under squash).
+  vec3 N = normalize(normalMatrix * n);
+  vec3 V = normalize(-mv.xyz);
+  vec3 up = normalize((viewMatrix * vec4(0.0, 1.0, 0.0, 0.0)).xyz);
+  vec3 K = normalize((viewMatrix * vec4(uKeyDir, 0.0)).xyz);
+  vec3 R = normalize((viewMatrix * vec4(uRimDir, 0.0)).xyz);
+  vec3 F = normalize((viewMatrix * vec4(uFillDir, 0.0)).xyz);
+  vec3 ambient = mix(uGround, uSky, dot(N, up) * 0.5 + 0.5);
+  // Wrapped diffuse: light bleeds round the terminator the way it does
+  // through fibres, instead of a hard plastic falloff.
+  float key = max(0.0, (dot(N, K) + 0.4) / 1.4);
+  float rim = max(0.0, dot(N, R));
+  float fill = max(0.0, dot(N, F));
+  float grazing = pow(1.0 - max(0.0, dot(N, V)), 2.0);
+  float blotch = 1.0;
+  if (uMottle > 0.0) {
+    blotch = 1.0 + uMottle * (mottleNoise(position * 5.0) + 0.5 * mottleNoise(position * 13.0) - 0.75) * 1.6;
+  }
+  vec3 lit = uColor * blotch * (ambient + uKeyColor * key + uFillColor * fill)
+    + uSheenAmt * (uSheen * grazing * (0.35 + 0.5 * key)
+    + uRimColor * uSheen * rim * (0.35 + grazing));
+  // Roots sit in the shade of the strands around them.
+  vLit = lit * mix(uRoot, 1.08, pow(vShell, 0.7));
+}
+`;
+var FUR_FRAGMENT = `
+uniform float uFur;
+uniform float uStrand;
+varying float vShell;
+varying vec3 vBase;
+varying vec3 vBaseNormal;
+varying vec3 vLit;
+float plushHash(vec3 p) {
+  p = fract(p * 0.1031);
+  p += dot(p, p.zyx + 31.32);
+  return fract((p.x + p.y) * p.z);
+}
+// One jittered strand per lattice cell: (coverage of this pixel, strand height).
+// The strand is a cylinder along the surface normal, so its radius is measured
+// in the tangent plane — measured in 3D, every place where the surface crosses
+// a cell boundary would read as "between strands" and draw a bald contour line.
+// Its edge is blurred over one pixel (px = cells per pixel), not cut.
+vec2 plushStrand(vec3 q, float t, vec3 n, float px) {
+  vec3 c = floor(q);
+  vec3 f = fract(q) - 0.5;
+  f -= (vec3(plushHash(c + 1.7), plushHash(c + 4.3), plushHash(c + 7.9)) - 0.5) * 0.45;
+  f -= n * dot(f, n);
+  float h = 0.35 + 0.65 * plushHash(c);
+  if (t > h) return vec2(0.0);
+  float r = 0.62 * (1.0 - 0.85 * t / h);
+  return vec2(clamp((r - length(f)) / px + 0.5, 0.0, 1.0), h);
+}
+void main() {
+  vec3 q = vBase / uStrand;
+  // Strands narrower than a couple of pixels can't be drawn one by one — they
+  // would turn into per-pixel noise that crawls as the plush moves — so the
+  // pattern fades into its average: how much of each shell strands cover
+  // (fitted to plushStrand) and how tall they are there.
+  float px = max(max(length(dFdx(q)), length(dFdy(q))), 1e-4);
+  float fine = smoothstep(0.45, 1.1, px);
+  float tone;
+  float alpha = 1.0;
+  if (vShell > 0.0) {
+    if (uFur < 1e-4) discard;
+    vec3 n = normalize(vBaseNormal);
+    vec2 a = plushStrand(q, vShell, n, px);
+    vec2 b = plushStrand(q + vec3(0.5, 0.31, 0.77), vShell, n, px);
+    vec2 s = a.x > b.x ? a : b;
+    alpha = mix(s.x, exp(-pow(vShell / 0.48, 2.1)), fine);
+    if (alpha < 0.004) discard;
+    tone = 0.9 + 0.2 * mix(s.y, 0.74 + 0.24 * vShell * vShell, fine);
+  } else {
+    tone = 0.92 + 0.12 * mix(plushHash(floor(q * 1.7)), 0.5, fine);
+  }
+  gl_FragColor = linearToOutputTexel(vec4(vLit * tone, alpha));
+}
+`;
+function rigColor(three, hex, power) {
+  return new three.Color(hex).multiplyScalar(power);
+}
+function furMaterial(three, opts) {
+  const dir = (d) => new three.Vector3(d[0], d[1], d[2]).normalize();
+  const uniforms = {
+    uFur: { value: opts.length },
+    uStrand: { value: opts.strand },
+    uGravity: { value: new three.Vector3(0, -(opts.gravity ?? 0.35), 0) },
+    uRoot: { value: opts.root ?? 0.58 },
+    uLayers: { value: opts.layers ?? FUR_SHELLS },
+    uColor: { value: new three.Color("#ffffff") },
+    uSheen: { value: new three.Color("#ffffff") },
+    uSheenAmt: { value: opts.sheen ?? 1 },
+    uMottle: { value: opts.mottle ?? 0 },
+    uBias: opts.bias ?? { value: 0 },
+    uSky: { value: rigColor(three, RIG.sky[0], RIG.sky[1]) },
+    uGround: { value: rigColor(three, RIG.ground[0], RIG.ground[1]) },
+    uKeyDir: { value: dir(RIG.key.dir) },
+    uKeyColor: { value: rigColor(three, RIG.key.color, RIG.key.power) },
+    uRimDir: { value: dir(RIG.rim.dir) },
+    uRimColor: { value: rigColor(three, RIG.rim.color, RIG.rim.power) },
+    uFillDir: { value: dir(RIG.fill.dir) },
+    uFillColor: { value: rigColor(three, RIG.fill.color, RIG.fill.power) }
+  };
+  const material = new three.ShaderMaterial({
+    uniforms,
+    vertexShader: FUR_VERTEX,
+    fragmentShader: FUR_FRAGMENT,
+    transparent: true
+  });
+  return { material, uniforms };
+}
+function setFurColor(fur, color) {
+  const [r, g, b] = color;
+  fur.uniforms.uColor.value.setRGB(r, g, b, "srgb");
+  fur.uniforms.uSheen.value.setRGB(r + (1 - r) * 0.55, g + (1 - g) * 0.55, b + (1 - b) * 0.55, "srgb");
+}
+function canvasTexture(three, size, paint, color = true) {
+  const canvas = document.createElement("canvas");
+  canvas.width = size;
+  canvas.height = size;
+  paint(canvas.getContext("2d"), size);
+  const texture = new three.CanvasTexture(canvas);
+  texture.wrapS = three.RepeatWrapping;
+  texture.wrapT = three.RepeatWrapping;
+  if (color)
+    texture.colorSpace = three.SRGBColorSpace;
+  return texture;
+}
+function threadTexture(three) {
+  return canvasTexture(three, 64, (ctx, s) => {
+    ctx.fillStyle = "#ffffff";
+    ctx.fillRect(0, 0, s, s);
+    ctx.strokeStyle = "#7d7d7d";
+    ctx.lineWidth = 7;
+    for (let i = -2;i < 4; i++) {
+      ctx.beginPath();
+      ctx.moveTo(i * 22, 0);
+      ctx.lineTo(i * 22 + s, s);
+      ctx.stroke();
+    }
+  });
+}
+function grainTexture(three, seed) {
+  const rand = mulberry32(seed);
+  return canvasTexture(three, 128, (ctx, s) => {
+    const img = ctx.createImageData(s, s);
+    for (let i = 0;i < s * s; i++) {
+      const v = 110 + rand() * 145;
+      img.data.set([v, v, v, 255], i * 4);
+    }
+    ctx.putImageData(img, 0, 0);
+  }, false);
+}
+function stripeTexture(three, a, b) {
+  return canvasTexture(three, 128, (ctx, s) => {
+    ctx.fillStyle = a;
+    ctx.fillRect(0, 0, s, s);
+    ctx.fillStyle = b;
+    for (let i = -1;i < 3; i++) {
+      ctx.beginPath();
+      ctx.moveTo(i * 64, 0);
+      ctx.lineTo(i * 64 + 28, 0);
+      ctx.lineTo(i * 64 + 28 + s, s);
+      ctx.lineTo(i * 64 + s, s);
+      ctx.closePath();
+      ctx.fill();
+    }
+  });
+}
+function shadowTexture(three) {
+  return canvasTexture(three, 128, (ctx, s) => {
+    const g = ctx.createRadialGradient(s / 2, s / 2, 0, s / 2, s / 2, s / 2);
+    g.addColorStop(0, "rgba(0,0,0,0.9)");
+    g.addColorStop(0.45, "rgba(0,0,0,0.45)");
+    g.addColorStop(1, "rgba(0,0,0,0)");
+    ctx.fillStyle = g;
+    ctx.fillRect(0, 0, s, s);
+  });
+}
+var ENV_CACHE = new WeakMap;
+function resetEnvironment(renderer) {
+  ENV_CACHE.delete(renderer);
+}
+function studioEnvironment(three, renderer) {
+  if (!renderer)
+    return null;
+  try {
+    const cached = ENV_CACHE.get(renderer);
+    if (cached)
+      return cached;
+    const scene = new three.Scene;
+    scene.background = new three.Color("#5d5752");
+    const panel = (w, h, pos, color, power) => {
+      const mesh = new three.Mesh(new three.PlaneGeometry(w, h), new three.MeshBasicMaterial({
+        color: new three.Color(color).multiplyScalar(power),
+        side: three.DoubleSide
+      }));
+      mesh.position.set(...pos);
+      mesh.lookAt(0, 0, 0);
+      scene.add(mesh);
+    };
+    panel(5, 3.5, [-4, 5, 6], "#fff6ea", 5);
+    panel(3, 5, [6, 2, -3], "#ffffff", 3);
+    panel(8, 2, [0, -5, 3], "#b8a898", 0.9);
+    panel(3, 3, [5, 1, 5], "#eaf0ff", 1.2);
+    const pmrem = new three.PMREMGenerator(renderer);
+    const env = pmrem.fromScene(scene, 0.03).texture;
+    pmrem.dispose();
+    ENV_CACHE.set(renderer, env);
+    return env;
+  } catch {
+    return null;
+  }
+}
+function finishMaterial(k, color, finish = k.finish) {
+  const three = k.three;
+  switch (finish) {
+    case "gloss":
+      return plastic(k, color);
+    case "satin":
+      return new three.MeshPhysicalMaterial({
+        color,
+        roughness: 0.48,
+        clearcoat: 0.12,
+        clearcoatRoughness: 0.5,
+        envMap: k.env,
+        envMapIntensity: 0.55
+      });
+    case "matte":
+    case "felt":
+      return new three.MeshStandardMaterial({
+        color,
+        roughness: 0.92,
+        bumpMap: k.grain,
+        bumpScale: 0.6,
+        envMap: k.env,
+        envMapIntensity: 0.3
+      });
+  }
+}
+function bead(k, color, sx, sy, sz, finish = k.finish) {
+  if (finish === "felt") {
+    const geometry = new k.three.SphereGeometry(1, 32, 20);
+    geometry.scale(sx, sy, Math.max(sz, 0.012));
+    return k.fuzzy(geometry, color, 0.009);
+  }
+  return blob(k, finishMaterial(k, color, finish), sx, sy, sz);
+}
+function plastic(k, color, opts = {}) {
+  return new k.three.MeshPhysicalMaterial({
+    color,
+    roughness: opts.roughness ?? 0.18,
+    metalness: opts.metal ? 1 : 0,
+    clearcoat: opts.metal ? 0 : 1,
+    clearcoatRoughness: 0.08,
+    envMap: k.env,
+    envMapIntensity: opts.metal ? 1.3 : 1
+  });
+}
+function felt(k, color) {
+  return new k.three.MeshPhysicalMaterial({
+    color,
+    roughness: 0.92,
+    sheen: 1,
+    sheenRoughness: 0.5,
+    sheenColor: new k.three.Color(color).lerp(new k.three.Color("#ffffff"), 0.4),
+    bumpMap: k.grain,
+    bumpScale: 1.2,
+    envMap: k.env,
+    envMapIntensity: 0.5
+  });
+}
+function threadMaterial(k, color) {
+  return new k.three.MeshStandardMaterial({
+    color,
+    roughness: 0.75,
+    map: k.thread,
+    bumpMap: k.thread,
+    bumpScale: 2,
+    envMap: k.env,
+    envMapIntensity: 0.6
+  });
+}
+function blob(k, material, sx, sy, sz) {
+  const mesh = new k.three.Mesh(new k.three.SphereGeometry(1, 40, 28), material);
+  mesh.scale.set(sx, sy, sz);
+  return mesh;
+}
+function tube(k, points, radius, material, closed = false) {
+  const three = k.three;
+  if (closed) {
+    const [a, b] = [points[0], points[points.length - 1]];
+    if (Math.hypot(a[0] - b[0], a[1] - b[1], a[2] - b[2]) < 0.000001)
+      points = points.slice(0, -1);
+  }
+  const curve = new three.CatmullRomCurve3(points.map((p) => new three.Vector3(...p)), closed, "centripetal");
+  const geometry = new three.TubeGeometry(curve, Math.max(32, points.length * 6), radius, 12, closed);
+  const uv = geometry.getAttribute("uv");
+  const repeat = curve.getLength() / (radius * 5);
+  for (let i = 0;i < uv.count; i++)
+    uv.setX(i, uv.getX(i) * repeat);
+  const group = new three.Group;
+  group.add(new three.Mesh(geometry, material));
+  if (!closed) {
+    for (const p of [points[0], points[points.length - 1]]) {
+      const cap = new three.Mesh(new three.SphereGeometry(radius, 16, 12), material);
+      cap.position.set(...p);
+      group.add(cap);
+    }
+  }
+  return group;
+}
+function arc(cx, cy, r, from, to, n = 16) {
+  return Array.from({ length: n + 1 }, (_, i) => {
+    const t = (from + (to - from) * i / n) * Math.PI / 180;
+    return [cx + Math.cos(t) * r, cy + Math.sin(t) * r, 0];
+  });
+}
+function roundedRectPath(w, h, r) {
+  const pts = roundedPolygon([[-w / 2, -h / 2], [w / 2, -h / 2], [w / 2, h / 2], [-w / 2, h / 2]], r, 8);
+  return resampleClosed(pts, 48).map(([x, y]) => [x, y, 0]);
+}
+function buildEye(k, style, size, color) {
+  const three = k.three;
+  const group = new three.Group;
+  const lid = new three.Group;
+  group.add(lid);
+  let pupil = null;
+  let range = 0;
+  switch (style) {
+    case "dot": {
+      const r = 0.075 * size;
+      pupil = bead(k, color, r, r, r * 0.55);
+      range = r * 0.4;
+      break;
+    }
+    case "oval": {
+      const r = 0.062 * size;
+      pupil = bead(k, color, r * 0.8, r * 1.35, r * 0.55);
+      range = r * 0.4;
+      break;
+    }
+    case "googly": {
+      const r = 0.145 * size;
+      lid.add(bead(k, "#fbfaf6", r, r, r * 0.32));
+      const pr = r * 0.46;
+      pupil = bead(k, color, pr, pr, pr * 0.3);
+      pupil.position.z = r * 0.34;
+      range = (r - pr) * 0.85;
+      break;
+    }
+    case "ring": {
+      const r = 0.13 * size;
+      lid.add(tube(k, arc(0, 0, r, 0, 360, 40), 0.017 * size, threadMaterial(k, color), true));
+      const pr = r * 0.34;
+      pupil = bead(k, color, pr, pr, pr * 0.55);
+      range = r - pr - 0.03 * size;
+      break;
+    }
+    case "happy":
+      lid.add(tube(k, arc(0, -0.05 * size, 0.08 * size, 25, 155), 0.017 * size, threadMaterial(k, color)));
+      range = 0.012 * size;
+      break;
+    case "sleepy":
+      lid.add(tube(k, arc(0, 0.045 * size, 0.08 * size, 205, 335), 0.017 * size, threadMaterial(k, color)));
+      range = 0.012 * size;
+      break;
+    case "none":
+      break;
+  }
+  if (pupil)
+    lid.add(pupil);
+  return { group, eye: { lid, pupil: pupil ?? lid, range } };
+}
+function buildMouth(k, style, color) {
+  const three = k.three;
+  const group = new three.Group;
+  const stroke = 0.016;
+  switch (style) {
+    case "smile":
+      group.add(tube(k, arc(0, 0.06, 0.1, 215, 325), stroke, threadMaterial(k, color)));
+      break;
+    case "flat":
+      group.add(tube(k, [[-0.07, 0, 0], [0.07, 0, 0]], stroke, threadMaterial(k, color)));
+      break;
+    case "cat":
+      group.add(tube(k, arc(-0.045, 0.02, 0.045, 200, 340, 10), stroke, threadMaterial(k, color)));
+      group.add(tube(k, arc(0.045, 0.02, 0.045, 200, 340, 10), stroke, threadMaterial(k, color)));
+      break;
+    case "open": {
+      group.add(bead(k, color, 0.075, 0.095, 0.03));
+      const tongue = bead(k, "#e36a7a", 0.05, 0.035, 0.014, k.finish === "felt" ? "felt" : "matte");
+      tongue.position.set(0, -0.048, 0.022);
+      group.add(tongue);
+      break;
+    }
+    case "grin": {
+      const shape = new three.Shape;
+      shape.moveTo(-0.11, 0.02);
+      shape.lineTo(0.11, 0.02);
+      shape.absarc(0, 0.02, 0.11, 0, -Math.PI, true);
+      const geo = new three.ExtrudeGeometry(shape, {
+        depth: 0.012,
+        bevelEnabled: true,
+        bevelThickness: 0.012,
+        bevelSize: 0.012,
+        bevelSegments: 5,
+        curveSegments: 28
+      });
+      group.add(k.finish === "felt" ? k.fuzzy(geo, color, 0.009) : new three.Mesh(geo, finishMaterial(k, color)));
+      const tongue = bead(k, "#e36a7a", 0.055, 0.03, 0.01, k.finish === "felt" ? "felt" : "matte");
+      tongue.position.set(0, -0.055, 0.03);
+      group.add(tongue);
+      break;
+    }
+    case "none":
+      return null;
+  }
+  return group;
+}
+function buildGlasses(k, style, eyeX, size, color) {
+  if (style === "none")
+    return null;
+  const three = k.three;
+  const group = new three.Group;
+  const frame = finishMaterial(k, color, k.finish === "felt" ? "matte" : k.finish);
+  const t = 0.018;
+  const r = 0.17 * size;
+  const lensPath = style === "square" ? roundedRectPath(r * 2.15, r * 1.65, r * 0.45) : arc(0, 0, r, 0, 360, 48);
+  const sides = style === "monocle" ? [1] : [-1, 1];
+  for (const s of sides) {
+    const lens = tube(k, lensPath, t, frame, true);
+    lens.position.x = s * eyeX;
+    group.add(lens);
+    if (style === "shades") {
+      const glass = new three.Mesh(new three.CircleGeometry(r * 0.97, 48), new three.MeshPhysicalMaterial({
+        color: "#1b1a24",
+        roughness: k.finish === "gloss" ? 0.05 : 0.3,
+        transparent: true,
+        opacity: 0.88,
+        clearcoat: k.finish === "gloss" ? 1 : 0.3,
+        envMap: k.env,
+        envMapIntensity: k.finish === "gloss" ? 1.4 : 0.7
+      }));
+      glass.position.set(s * eyeX, 0, 0.004);
+      group.add(glass);
+    }
+    const edge = style === "square" ? r * 1.07 : r;
+    group.add(tube(k, [[s * (eyeX + edge), 0.02, 0], [s * (eyeX + edge + 0.05), 0.03, -0.06], [s * (eyeX + edge + 0.07), 0.03, -0.14]], t * 0.8, frame));
+  }
+  if (style === "monocle") {
+    group.add(tube(k, [[eyeX, -r, 0], [eyeX + 0.05, -r - 0.12, -0.02], [eyeX + 0.14, -r - 0.2, -0.06]], t * 0.45, plastic(k, "#caa24a", { metal: true, roughness: 0.3 })));
+  } else {
+    const inner = eyeX - (style === "square" ? r * 1.07 : r);
+    group.add(tube(k, arc(0, -0.01, inner, 30, 150, 12).map(([x, y]) => [x, y, 0]), t * 0.85, frame));
+  }
+  return group;
+}
+function buildHat(k, style, color, accent, fur) {
+  const three = k.three;
+  const group = new three.Group;
+  switch (style) {
+    case "top": {
+      const c = color ?? "#221f26";
+      const mat = felt(k, c);
+      const crown = new three.Mesh(new three.CylinderGeometry(0.28, 0.3, 0.42, 48), mat);
+      crown.position.y = 0.23;
+      const brim = new three.Mesh(new three.CylinderGeometry(0.5, 0.5, 0.03, 64), mat);
+      brim.position.y = 0.015;
+      const rim = new three.Mesh(new three.TorusGeometry(0.5, 0.022, 12, 64), mat);
+      rim.rotation.x = Math.PI / 2;
+      rim.position.y = 0.02;
+      const band = new three.Mesh(new three.CylinderGeometry(0.305, 0.31, 0.085, 48), felt(k, accent));
+      band.position.y = 0.09;
+      group.add(crown, brim, rim, band);
+      return { group, height: 0.44, crown: 0.3, brim: 0.5 };
+    }
+    case "beanie": {
+      const c = color ?? "#e0533d";
+      const dome = fur(new three.SphereGeometry(0.42, 48, 24, 0, Math.PI * 2, 0, Math.PI / 2), c, 0.03);
+      dome.scale.y = 0.9;
+      dome.position.y = 0.08;
+      const cuff = new three.Mesh(new three.CylinderGeometry(0.44, 0.44, 0.14, 48, 1), felt(k, c));
+      cuff.position.y = 0.07;
+      const pom = fur(new three.SphereGeometry(0.1, 32, 20), "#fbf6ec", 0.07);
+      pom.position.y = 0.08 + 0.42 * 0.9 + 0.06;
+      group.add(dome, cuff, pom);
+      return { group, height: 0.66, crown: 0.44, brim: 0.44 };
+    }
+    case "party": {
+      const a = color ?? accent;
+      const cone = new three.Mesh(new three.ConeGeometry(0.22, 0.55, 48, 1, true), new three.MeshPhysicalMaterial({
+        map: stripeTexture(three, a, "#fdf7ea"),
+        roughness: 0.55,
+        side: three.DoubleSide,
+        clearcoat: 0.3,
+        envMap: k.env,
+        envMapIntensity: 0.7
+      }));
+      cone.position.y = 0.275;
+      const pom = fur(new three.SphereGeometry(0.07, 28, 18), "#fdf7ea", 0.05);
+      pom.position.y = 0.58;
+      group.add(cone, pom);
+      return { group, height: 0.66, crown: 0.22, brim: 0.22 };
+    }
+    case "crown": {
+      const gold = plastic(k, color ?? "#e8b949", { metal: true, roughness: 0.28 });
+      gold.side = three.DoubleSide;
+      const geo = new three.CylinderGeometry(0.3, 0.28, 0.2, 80, 1, true);
+      const p = geo.getAttribute("position");
+      const points = 5;
+      for (let i = 0;i < p.count; i++) {
+        if (p.getY(i) > 0) {
+          const th = Math.atan2(p.getZ(i), p.getX(i));
+          const w = Math.abs(Math.cos(th * points / 2));
+          p.setY(i, 0.1 + 0.17 * Math.pow(w, 3));
+        }
+      }
+      geo.computeVertexNormals();
+      const band = new three.Mesh(geo, gold);
+      band.position.y = 0.1;
+      group.add(band);
+      for (let i = 0;i < points; i++) {
+        const th = i / points * Math.PI * 2;
+        const ball = blob(k, gold, 0.03, 0.03, 0.03);
+        ball.position.set(Math.cos(th) * 0.3, 0.38, Math.sin(th) * 0.3);
+        group.add(ball);
+      }
+      const jewel = blob(k, plastic(k, accent, { roughness: 0.05 }), 0.045, 0.045, 0.025);
+      jewel.position.set(0, 0.12, 0.3);
+      group.add(jewel);
+      return { group, height: 0.42, crown: 0.3, brim: 0.3 };
+    }
+    case "cowboy": {
+      const c = color ?? ACCESSORY_COLORS.hat.cowboy;
+      const mat = felt(k, c);
+      mat.side = three.DoubleSide;
+      const profile = [[0.29, 0], [0.295, 0.1], [0.285, 0.22], [0.26, 0.31], [0.2, 0.355], [0.1, 0.37], [0, 0.365]];
+      const crownGeo = new three.LatheGeometry(profile.map(([x, y]) => new three.Vector2(x, y)), 64);
+      const p = crownGeo.getAttribute("position");
+      for (let i = 0;i < p.count; i++) {
+        const y = p.getY(i);
+        if (y < 0.2)
+          continue;
+        const f = (y - 0.2) / 0.17;
+        p.setY(i, y - 0.075 * f * Math.exp(-((p.getX(i) / 0.08) ** 2)));
+        p.setX(i, p.getX(i) * (1 - 0.08 * f));
+      }
+      crownGeo.computeVertexNormals();
+      const crownMesh = new three.Mesh(crownGeo, mat);
+      const bend = (x, z) => 1.1 * Math.max(0, Math.abs(x) - 0.3) ** 2 - 0.05 * Math.max(0, Math.abs(z) - 0.3);
+      const brimMesh = new three.Mesh(brim(three, 0.27, 0.66, 0.52, 0, bend), mat);
+      const rim = tube(k, brimEdge(0.66, 0.52, 0, bend), 0.016, mat, true);
+      const band = new three.Mesh(new three.CylinderGeometry(0.296, 0.296, 0.055, 64, 1, true), felt(k, accent));
+      band.material.side = three.DoubleSide;
+      band.position.y = 0.045;
+      group.add(crownMesh, brimMesh, rim, band);
+      return { group, height: 0.38, crown: 0.3, brim: 0.66 };
+    }
+    case "cap": {
+      const c = color ?? ACCESSORY_COLORS.hat.cap;
+      const mat = felt(k, c);
+      const crownMesh = new three.Mesh(dome(three, 0.38, 0.78), mat);
+      mat.side = three.DoubleSide;
+      const billBend = (x, z) => -0.4 * Math.max(0, z - 0.28) - 0.25 * x * x * Math.min(1, Math.max(0, z - 0.2) * 4);
+      const bill = new three.Mesh(brim(three, 0.3, 0.34, 0.36, 0.27, billBend), mat);
+      const billRim = tube(k, brimEdge(0.34, 0.36, 0.27, billBend).filter(([, , z]) => z > 0.05), 0.012, mat);
+      const button = bead(k, c, 0.035, 0.022, 0.035, "matte");
+      button.position.y = 0.38 * 0.78;
+      const seams = new three.Group;
+      const thread = threadMaterial(k, new three.Color(c).multiplyScalar(0.7).getStyle());
+      for (const a of [-1, 0, 1]) {
+        const th = a * 0.9;
+        const pts = arc(0, 0, 0.385, 8, 88, 20).map(([u, v]) => [Math.sin(th) * u, v * 0.78, Math.cos(th) * u]);
+        seams.add(tube(k, pts, 0.006, thread));
+      }
+      group.add(crownMesh, bill, billRim, button, seams);
+      group.rotation.y = 0.75;
+      return { group, height: 0.32, crown: 0.38, brim: 0.38 };
+    }
+    case "hardhat":
+    case "fireman": {
+      const fire = style === "fireman";
+      const c = color ?? ACCESSORY_COLORS.hat[style];
+      const mat = plastic(k, c, { roughness: 0.28 });
+      mat.side = three.DoubleSide;
+      const shell = new three.Mesh(dome(three, 0.37, 0.88), mat);
+      const ridge = tube(k, arc(0, 0, 0.37, 30, 150, 24).map(([u, v]) => [0, v * 0.88, u]), 0.028, mat);
+      const bend = fire ? (_x, z) => -0.12 * Math.max(0, -z - 0.3) ** 1.2 : (_x, z) => -0.04 * Math.max(0, z - 0.3);
+      const [rx, rz, oz] = fire ? [0.5, 0.56, -0.12] : [0.45, 0.47, 0.07];
+      const brimMesh = new three.Mesh(brim(three, 0.36, rx, rz, oz, bend), mat);
+      brimMesh.position.y = 0.01;
+      const rim = tube(k, brimEdge(rx, rz, oz, bend), 0.016, mat, true);
+      rim.position.y = 0.01;
+      group.add(shell, ridge, brimMesh, rim);
+      if (fire) {
+        const shield = new three.Shape;
+        shield.moveTo(0.12, 0.04);
+        shield.absarc(0, 0.04, 0.12, 0, Math.PI, false);
+        shield.lineTo(-0.1, -0.08);
+        shield.quadraticCurveTo(0, -0.19, 0.1, -0.08);
+        shield.closePath();
+        const badge = puffy(k, shield, "#e8b949", 0.012, 0.012, "gloss");
+        badge.material.metalness = 1;
+        badge.position.set(0, 0.2, 0.36);
+        badge.rotation.x = -0.45;
+        const middle = blob(k, plastic(k, accent), 0.045, 0.045, 0.02);
+        middle.position.set(0, 0.215, 0.385);
+        middle.rotation.x = -0.45;
+        group.add(badge, middle);
+      }
+      return { group, height: 0.4, crown: 0.37, brim: 0.47 };
+    }
+    case "santa": {
+      const c = color ?? ACCESSORY_COLORS.hat.santa;
+      const h = 0.62;
+      const geo = new three.ConeGeometry(0.33, h, 40, 24, true);
+      geo.translate(0, h / 2, 0);
+      const p = geo.getAttribute("position");
+      for (let i = 0;i < p.count; i++) {
+        const t = Math.max(0, p.getY(i) / h);
+        p.setX(i, p.getX(i) + 0.34 * t ** 2.2);
+        p.setY(i, p.getY(i) - 0.2 * t ** 3);
+      }
+      geo.computeVertexNormals();
+      const cone = fur(geo, c, 0.025);
+      const cuff = fur(new three.TorusGeometry(0.335, 0.075, 18, 56), "#fbf6ec", 0.06);
+      cuff.rotation.x = Math.PI / 2;
+      cuff.position.y = 0.03;
+      const pom = fur(new three.SphereGeometry(0.085, 28, 18), "#fbf6ec", 0.07);
+      pom.position.set(0.34, h - 0.2 + 0.01, 0);
+      group.add(cone, cuff, pom);
+      return { group, height: 0.56, crown: 0.34, brim: 0.41 };
+    }
+    case "graduation": {
+      const c = color ?? ACCESSORY_COLORS.hat.graduation;
+      const mat = felt(k, c);
+      const skull = new three.Mesh(new three.CylinderGeometry(0.3, 0.31, 0.18, 48), mat);
+      skull.position.y = 0.09;
+      const board = new three.Mesh(new three.BoxGeometry(0.8, 0.03, 0.8), mat);
+      board.position.y = 0.195;
+      board.rotation.y = Math.PI / 4;
+      const button = bead(k, accent, 0.035, 0.02, 0.035, "matte");
+      button.position.y = 0.215;
+      const cord = taperedTube(k, [[0, 0.215, 0], [0.15, 0.214, 0.15], [0.27, 0.21, 0.27], [0.3, 0.16, 0.3], [0.31, 0.06, 0.31]], () => 0.009);
+      const cordMat = threadMaterial(k, accent);
+      const tassel = new three.Mesh(new three.CylinderGeometry(0.014, 0.038, 0.12, 16), cordMat);
+      tassel.position.set(0.31, 0, 0.31);
+      group.add(skull, board, button, new three.Mesh(cord, cordMat), tassel);
+      return { group, height: 0.24, crown: 0.31, brim: 0.31 };
+    }
+    case "fez": {
+      const c = color ?? ACCESSORY_COLORS.hat.fez;
+      const mat = felt(k, c);
+      const body = new three.Mesh(new three.CylinderGeometry(0.21, 0.27, 0.34, 48), mat);
+      body.position.y = 0.17;
+      const black = "#1d1b22";
+      const cordMat = threadMaterial(k, black);
+      const button = bead(k, black, 0.03, 0.015, 0.03, "matte");
+      button.position.y = 0.345;
+      const cord = taperedTube(k, [[0, 0.345, 0], [0.12, 0.35, 0.05], [0.21, 0.32, 0.09], [0.24, 0.24, 0.11]], () => 0.008);
+      const tassel = new three.Mesh(new three.CylinderGeometry(0.012, 0.04, 0.13, 16), cordMat);
+      tassel.position.set(0.245, 0.17, 0.115);
+      group.add(body, button, new three.Mesh(cord, cordMat), tassel);
+      return { group, height: 0.36, crown: 0.27, brim: 0.27 };
+    }
+    case "halo": {
+      const c = color ?? ACCESSORY_COLORS.hat.halo;
+      const ring = new three.Mesh(new three.TorusGeometry(0.3, 0.036, 20, 72), new three.MeshStandardMaterial({
+        color: c,
+        emissive: new three.Color(c),
+        emissiveIntensity: 0.55,
+        roughness: 0.35,
+        metalness: 0.2,
+        envMap: k.env,
+        envMapIntensity: 0.8
+      }));
+      ring.rotation.x = Math.PI / 2 - 0.3;
+      ring.position.y = 0.3;
+      group.add(ring);
+      return { group, height: 0.36, crown: 0.3, brim: 0.3 };
+    }
+    case "none":
+      return null;
+  }
+}
+function buildBowtie(k, color) {
+  const three = k.three;
+  const shape = new three.Shape;
+  shape.moveTo(0, 0.03);
+  shape.bezierCurveTo(-0.08, 0.06, -0.2, 0.15, -0.26, 0.11);
+  shape.bezierCurveTo(-0.3, 0.06, -0.3, -0.06, -0.26, -0.11);
+  shape.bezierCurveTo(-0.2, -0.15, -0.08, -0.06, 0, -0.03);
+  shape.bezierCurveTo(0.08, -0.06, 0.2, -0.15, 0.26, -0.11);
+  shape.bezierCurveTo(0.3, -0.06, 0.3, 0.06, 0.26, 0.11);
+  shape.bezierCurveTo(0.2, 0.15, 0.08, 0.06, 0, 0.03);
+  const geo = new three.ExtrudeGeometry(shape, {
+    depth: 0.02,
+    bevelEnabled: true,
+    bevelThickness: 0.03,
+    bevelSize: 0.022,
+    bevelSegments: 6,
+    curveSegments: 24
+  });
+  geo.center();
+  const group = new three.Group;
+  if (k.finish === "felt") {
+    group.add(k.fuzzy(geo, color, 0.01));
+  } else {
+    const cloth = k.finish === "gloss" ? new three.MeshPhysicalMaterial({
+      color,
+      roughness: 0.35,
+      sheen: 0.5,
+      sheenColor: new three.Color("#3a3a3a"),
+      clearcoat: 0.8,
+      clearcoatRoughness: 0.25,
+      envMap: k.env,
+      envMapIntensity: 1
+    }) : finishMaterial(k, color);
+    group.add(new three.Mesh(geo, cloth));
+  }
+  const knot = bead(k, color, 0.055, 0.065, 0.05);
+  knot.position.z = 0.02;
+  group.add(knot);
+  return group;
+}
+var ACCESSORY_COLORS = {
+  hat: {
+    top: "#221f26",
+    beanie: "#e0533d",
+    crown: "#e8b949",
+    cowboy: "#b07a45",
+    cap: "#2f6fd6",
+    hardhat: "#f5b80f",
+    fireman: "#c8261d",
+    santa: "#d22b2b",
+    graduation: "#1d1b22",
+    fez: "#b3202a",
+    halo: "#ffd659"
+  },
+  neck: { necktie: "#c43c3c" },
+  pin: { flower: "#fdf7ea", bow: "#e8436e", heart: "#e8436e", star: "#f5c518" }
+};
+function taperedTube(k, points, radius, segments = 48) {
+  const three = k.three;
+  const curve = new three.CatmullRomCurve3(points.map((p) => new three.Vector3(...p)), false, "centripetal");
+  const radial = 12;
+  const geometry = new three.TubeGeometry(curve, segments, 1, radial, false);
+  const position = geometry.getAttribute("position");
+  const c = new three.Vector3;
+  const v = new three.Vector3;
+  for (let i = 0;i <= segments; i++) {
+    const u = i / segments;
+    curve.getPointAt(u, c);
+    const r = radius(u);
+    for (let j = 0;j <= radial; j++) {
+      const n = i * (radial + 1) + j;
+      v.fromBufferAttribute(position, n).sub(c).multiplyScalar(r).add(c);
+      position.setXYZ(n, v.x, v.y, v.z);
+    }
+  }
+  return geometry;
+}
+function puffy(k, shape, color, depth, bevel, finish = k.finish) {
+  const geometry = new k.three.ExtrudeGeometry(shape, {
+    depth,
+    bevelEnabled: true,
+    bevelThickness: bevel,
+    bevelSize: bevel * 0.8,
+    bevelSegments: 5,
+    curveSegments: 24
+  });
+  geometry.center();
+  return finish === "felt" ? k.fuzzy(geometry, color, 0.008) : new k.three.Mesh(geometry, finishMaterial(k, color, finish));
+}
+function shapeFrom(three, points) {
+  const shape = new three.Shape;
+  points.forEach(([x, y], i) => i ? shape.lineTo(x, y) : shape.moveTo(x, y));
+  shape.closePath();
+  return shape;
+}
+function starShape(three, r, points = 5, inner = 0.48) {
+  const raw = Array.from({ length: points * 2 }, (_, i) => {
+    const th = Math.PI / 2 + i * Math.PI / points;
+    const rr = i % 2 ? r * inner : r;
+    return [Math.cos(th) * rr, Math.sin(th) * rr];
+  });
+  return shapeFrom(three, roundedPolygon(raw, r * 0.08, 4));
+}
+function heartShape(three, r) {
+  const pts = Array.from({ length: 64 }, (_, i) => {
+    const t = i / 64 * Math.PI * 2;
+    return [
+      16 * Math.sin(t) ** 3 / 17 * r,
+      (13 * Math.cos(t) - 5 * Math.cos(2 * t) - 2 * Math.cos(3 * t) - Math.cos(4 * t)) / 17 * r
+    ];
+  });
+  return shapeFrom(three, pts);
+}
+function bodyStrip(three, at, z, rows = 24, cols = 6, dy = () => 0) {
+  const positions = [];
+  const uvs = [];
+  for (let r = 0;r <= rows; r++) {
+    const t = r / rows;
+    const [x, y, w] = at(t);
+    for (let c = 0;c <= cols; c++) {
+      const s = c / cols * 2 - 1;
+      const px = x + s * w;
+      const py = y + dy(s, t);
+      positions.push(px, py, z(px, py));
+      uvs.push(c / cols, 1 - t);
+    }
+  }
+  const index = [];
+  for (let r = 0;r < rows; r++) {
+    for (let c = 0;c < cols; c++) {
+      const a = r * (cols + 1) + c;
+      const b = a + cols + 1;
+      index.push(a, b, a + 1, a + 1, b, b + 1);
+    }
+  }
+  const geometry = new three.BufferGeometry;
+  geometry.setAttribute("position", new three.Float32BufferAttribute(positions, 3));
+  geometry.setAttribute("uv", new three.Float32BufferAttribute(uvs, 2));
+  geometry.setIndex(index);
+  geometry.computeVertexNormals();
+  return geometry;
+}
+function dome(three, r, squash) {
+  const geometry = new three.SphereGeometry(r, 48, 20, 0, Math.PI * 2, 0, Math.PI / 2);
+  geometry.scale(1, squash, 1);
+  return geometry;
+}
+function brim(three, inner, rx, rz, offsetZ, bend) {
+  const geometry = new three.RingGeometry(inner, 1, 96, 8);
+  const position = geometry.getAttribute("position");
+  for (let i = 0;i < position.count; i++) {
+    const x0 = position.getX(i);
+    const y0 = position.getY(i);
+    const d = Math.hypot(x0, y0);
+    const f = (d - inner) / (1 - inner);
+    const a = Math.atan2(y0, x0);
+    const ex = Math.cos(a) * (inner + (rx - inner) * f);
+    const ez = Math.sin(a) * (inner + (rz - inner) * f) + offsetZ * f;
+    position.setXYZ(i, ex, bend(ex, ez), ez);
+  }
+  geometry.computeVertexNormals();
+  return geometry;
+}
+function brimEdge(rx, rz, offsetZ, bend, n = 96) {
+  return Array.from({ length: n }, (_, i) => {
+    const a = i / n * Math.PI * 2;
+    const x = Math.cos(a) * rx;
+    const z = Math.sin(a) * rz + offsetZ;
+    return [x, bend(x, z), z];
+  });
+}
+function buildMoustache(k, style, color) {
+  if (style === "none")
+    return null;
+  const three = k.three;
+  const group = new three.Group;
+  const material = finishMaterial(k, color, k.finish === "gloss" ? "satin" : k.finish);
+  const wrap = (geometry) => k.finish === "felt" ? k.fuzzy(geometry, color, 0.008) : new three.Mesh(geometry, material);
+  switch (style) {
+    case "curly": {
+      const half = [
+        [0.05, -0.008, 0.008],
+        [0.1, -0.016, 0.002],
+        [0.142, -0.004, -0.006],
+        [0.16, 0.026, -0.01],
+        [0.148, 0.05, -0.012],
+        [0.124, 0.046, -0.01],
+        [0.12, 0.03, -0.008]
+      ];
+      const path = [
+        ...half.map(([x, y, z]) => [-x, y, z]).reverse(),
+        [0, 0.002, 0.012],
+        ...half
+      ];
+      const radius = (u) => 0.007 + 0.03 * Math.pow(Math.max(0, 1 - Math.abs(2 * u - 1)), 0.9);
+      group.add(wrap(taperedTube(k, path, radius, 96)));
+      break;
+    }
+    case "walrus": {
+      const shape = new three.Shape;
+      shape.moveTo(0, 0.04);
+      shape.bezierCurveTo(-0.09, 0.07, -0.2, 0.04, -0.22, -0.075);
+      shape.bezierCurveTo(-0.15, -0.06, -0.07, -0.055, 0, -0.025);
+      shape.bezierCurveTo(0.07, -0.055, 0.15, -0.06, 0.22, -0.075);
+      shape.bezierCurveTo(0.2, 0.04, 0.09, 0.07, 0, 0.04);
+      const geometry = new three.ExtrudeGeometry(shape, {
+        depth: 0.02,
+        bevelEnabled: true,
+        bevelThickness: 0.022,
+        bevelSize: 0.016,
+        bevelSegments: 6,
+        curveSegments: 24
+      });
+      geometry.center();
+      group.add(k.fuzzy(geometry, color, 0.02));
+      break;
+    }
+    case "pencil":
+      for (const s of [-1, 1]) {
+        group.add(tube(k, [[s * 0.016, 0.004, 0], [s * 0.065, 0.012, 0], [s * 0.125, -0.004, 0]], 0.012, threadMaterial(k, color)));
+      }
+      break;
+  }
+  return group;
+}
+function buildNeck(k, style, color, accent, site) {
+  const three = k.three;
+  const group = new three.Group;
+  switch (style) {
+    case "necktie": {
+      const top = site.y;
+      const tip = Math.min(top - 0.24, Math.max(site.floor(0) + 0.04, top - 0.62));
+      const length = top - 0.05 - tip;
+      const blade = bodyStrip(three, (t) => [0, top - 0.05 - t * length, 0.042 + 0.05 * Math.min(1, t * 1.4)], (x, y) => site.front(x, y) + 0.035, 28, 6, (s, t) => -Math.max(0, (t - 0.86) / 0.14) * 0.07 * (1 - Math.abs(s)));
+      const cloth = k.finish === "felt" ? k.fuzzy(blade, color, 0.008) : new three.Mesh(blade, new three.MeshPhysicalMaterial({
+        map: stripeTexture(three, color, accent),
+        roughness: 0.5,
+        sheen: 0.4,
+        clearcoat: k.finish === "gloss" ? 0.6 : 0.1,
+        side: three.DoubleSide,
+        envMap: k.env,
+        envMapIntensity: 0.6
+      }));
+      group.add(cloth);
+      const knot = bead(k, color, 0.055, 0.05, 0.035);
+      knot.position.set(0, top - 0.02, site.front(0, top) + 0.06);
+      group.add(knot);
+      return group;
+    }
+    case "bowtie":
+    case "none":
+      return null;
+  }
+}
+function buildPin(k, style, color) {
+  const three = k.three;
+  const group = new three.Group;
+  switch (style) {
+    case "flower":
+      for (let i = 0;i < 5; i++) {
+        const th = i / 5 * Math.PI * 2 + Math.PI / 2;
+        const petal = bead(k, color, 0.06, 0.036, 0.022);
+        petal.position.set(Math.cos(th) * 0.058, Math.sin(th) * 0.058, 0);
+        petal.rotation.z = th;
+        group.add(petal);
+      }
+      {
+        const middle = bead(k, "#f5c518", 0.04, 0.04, 0.03);
+        middle.position.z = 0.016;
+        group.add(middle);
+      }
+      break;
+    case "bow": {
+      const bow = buildBowtie(k, color);
+      bow.scale.setScalar(0.5);
+      group.add(bow);
+      for (const s of [-1, 1]) {
+        const tail = tube(k, [[s * 0.012, -0.02, 0], [s * 0.04, -0.07, -0.005], [s * 0.065, -0.11, -0.01]], 0.016, finishMaterial(k, color, k.finish === "felt" ? "matte" : k.finish));
+        group.add(tail);
+      }
+      break;
+    }
+    case "heart":
+      group.add(puffy(k, heartShape(three, 0.12), color, 0.02, 0.022));
+      break;
+    case "star":
+      group.add(puffy(k, starShape(three, 0.13), color, 0.02, 0.02));
+      break;
+    case "badge": {
+      const rim = new three.Mesh(new three.TorusGeometry(0.105, 0.014, 12, 48), plastic(k, "#c9ccd3", { metal: true, roughness: 0.25 }));
+      const face = new three.Mesh(new three.CylinderGeometry(0.105, 0.105, 0.022, 48), plastic(k, color));
+      face.rotation.x = Math.PI / 2;
+      const star = puffy(k, starShape(three, 0.06), "#fdf7ea", 0.004, 0.006, "gloss");
+      star.position.z = 0.016;
+      group.add(rim, face, star);
+      break;
+    }
+    case "none":
+      return null;
+  }
+  return group;
+}
+var FABRICS = {
+  plush: { fur: 0.05, grain: 1, sheen: 1, mottle: 0, root: 0.58, gravity: 0.35 },
+  felt: { fur: 0.016, grain: 0.8, sheen: 0.3, mottle: 0.17, root: 0.8, gravity: 0.08 },
+  velvet: { fur: 0.012, grain: 0.9, sheen: 2.1, mottle: 0, root: 0.45, gravity: 0 },
+  shaggy: { fur: 0.11, grain: 1.7, sheen: 0.8, mottle: 0.06, root: 0.5, gravity: 0.7 },
+  fleece: { fur: 0.06, grain: 2.8, sheen: 0.45, mottle: 0.14, root: 0.55, gravity: -0.2 }
+};
+function applyDepthBias(material, bias) {
+  material.onBeforeCompile = (shader) => {
+    shader.uniforms.uBias = bias;
+    shader.vertexShader = shader.vertexShader.replace("#include <common>", `#include <common>
+uniform float uBias;`).replace("#include <project_vertex>", `#include <project_vertex>
+mvPosition.xyz += normalize(-mvPosition.xyz) * uBias;
+gl_Position = projectionMatrix * mvPosition;`);
+  };
+  material.customProgramCacheKey = () => "plushies-depth-bias";
+}
+var FACE_LIFT = {
+  triangle: 0.2,
+  heart: 0.14,
+  star: 0.06,
+  cloud: 0.04,
+  ghost: 0.1,
+  drop: -0.02,
+  arch: 0.08,
+  bean: -0.04
+};
+function insidePolygon(poly, x, y) {
+  let inside = false;
+  for (let i = 0, j = poly.length - 1;i < poly.length; j = i++) {
+    const [xi, yi] = poly[i];
+    const [xj, yj] = poly[j];
+    if (yi > y !== yj > y && x < (xj - xi) * (y - yi) / (yj - yi) + xi)
+      inside = !inside;
+  }
+  return inside;
+}
+function reach(poly, x, y, dx, dy, margin = 0) {
+  const l = Math.hypot(dx, dy);
+  let d = 0;
+  while (d < 3) {
+    const px = x + (d + 0.005) * dx / l;
+    const py = y + (d + 0.005) * dy / l;
+    if (!insidePolygon(poly, px, py) || distanceToOutline(px, py, poly) < margin)
+      break;
+    d += 0.005;
+  }
+  return d;
+}
+var HAT_TILT = 0.2;
+function hatTilt(outline) {
+  let top = 0;
+  outline.forEach((p, i) => {
+    if (p[1] + 0.001 * p[0] > outline[top][1] + 0.001 * outline[top][0])
+      top = i;
+  });
+  const n = outline.length;
+  const flat = (i) => outline[i][1] > outline[top][1] - 0.015;
+  let from = top;
+  let to = top;
+  for (let k = 0;k < n && flat((from - 1 + n) % n); k++)
+    from = (from - 1 + n) % n;
+  for (let k = 0;k < n && flat((to + 1) % n); k++)
+    to = (to + 1) % n;
+  top = (from + Math.round(((to - from) % n + n) % n / 2)) % n;
+  const walk = (dir) => {
+    let i = top;
+    let d = 0;
+    while (d < 0.15) {
+      const j = (i + dir + n) % n;
+      d += Math.hypot(outline[j][0] - outline[i][0], outline[j][1] - outline[i][1]);
+      i = j;
+    }
+    return outline[i];
+  };
+  const [a, b] = [walk(-1), walk(1)];
+  let tilt = Math.atan2(b[1] - a[1], b[0] - a[0]) - Math.PI;
+  if (tilt < -Math.PI)
+    tilt += Math.PI * 2;
+  return { tilt: tilt - HAT_TILT, at: outline[top] };
+}
+function seatHat(outline, tilt, at, crown, brim2, size) {
+  const right = [Math.cos(tilt), Math.sin(tilt)];
+  const up = [-Math.sin(tilt), Math.cos(tilt)];
+  const c = at[0] * right[0] + at[1] * right[1];
+  let inCrown = -Infinity;
+  let underBrim = -Infinity;
+  for (const [x, y] of outline) {
+    const l = Math.abs(x * right[0] + y * right[1] - c);
+    const h = x * up[0] + y * up[1];
+    if (l <= crown * size)
+      inCrown = Math.max(inCrown, h);
+    else if (l <= brim2 * size)
+      underBrim = Math.max(underBrim, h);
+  }
+  const base = Math.max(inCrown - 0.12 * size, underBrim - 0.02 * size);
+  return [right[0] * c + up[0] * base, right[1] * c + up[1] * base];
+}
+function buildRig(three, spec) {
+  const env = studioEnvironment(three, spec.renderer);
+  const strand = 0.0115 * spec.furGrain;
+  const bias = { value: 0 };
+  const furs = [];
+  const fuzzy = (geometry, color, length) => {
+    const fur = furMaterial(three, {
+      length,
+      strand: Math.min(strand, 0.0115) * 0.8,
+      gravity: 0.15,
+      root: 0.7,
+      layers: 10,
+      sheen: 0.6,
+      bias
+    });
+    setFurColor(fur, toRgb(three, color));
+    furs.push(fur);
+    const mesh = new three.Mesh(furShells(three, geometry, 10), fur.material);
+    mesh.renderOrder = 1;
+    return mesh;
+  };
+  const kit = {
+    three,
+    env,
+    thread: threadTexture(three),
+    grain: grainTexture(three, 7),
+    finish: spec.finish,
+    fuzzy
+  };
+  const outline = silhouette(spec.kind, spec.outline);
+  const body = inflate(three, outline, spec.thickness);
+  let minY = Infinity;
+  let maxX = 0;
+  for (const [x, y] of outline) {
+    minY = Math.min(minY, y);
+    maxX = Math.max(maxX, Math.abs(x));
+  }
+  const bottom = minY;
+  const perch = hatTilt(outline);
+  const outer = new three.Group;
+  const pivot = new three.Group;
+  pivot.position.y = bottom;
+  outer.add(pivot);
+  const inner = new three.Group;
+  inner.position.y = -bottom;
+  pivot.add(inner);
+  const bodyFur = furMaterial(three, {
+    length: spec.fabric.fur,
+    strand,
+    sheen: spec.fabric.sheen,
+    mottle: spec.fabric.mottle,
+    root: spec.fabric.root,
+    gravity: spec.fabric.gravity
+  });
+  const bodyMesh = new three.Mesh(furShells(three, body.geometry), bodyFur.material);
+  inner.add(bodyMesh);
+  const floaters = [];
+  const compensate = [];
+  const [cx, cy] = body.center;
+  const eyeY = cy + 0.12 + (FACE_LIFT[spec.kind] ?? 0) + spec.faceY;
+  const eyeX = 0.19 * spec.eyeSpacing * Math.max(0.8, spec.eyeSize);
+  const gap = 0.07;
+  const surface = (x, y) => body.heightAt(x, y) + gap;
+  const face = new three.Group;
+  face.position.set(cx, eyeY, 0);
+  inner.add(face);
+  const place = (object, x, y, lift = 0) => {
+    object.position.set(x - cx, y - eyeY, surface(x, y) + lift);
+    face.add(object);
+    floaters.push({ object, rest: object.position.z, lift: 1 });
+    compensate.push(object);
+  };
+  const eyes = [];
+  if (spec.eyes !== "none") {
+    for (const s of [-1, 1]) {
+      const { group, eye } = buildEye(kit, spec.eyes, spec.eyeSize, spec.featureColor);
+      place(group, cx + s * eyeX, eyeY);
+      eyes.push(eye);
+    }
+  }
+  const mouthY = eyeY - 0.2 - 0.04 * spec.eyeSize;
+  const mouth = buildMouth(kit, spec.mouth, spec.featureColor);
+  if (mouth)
+    place(mouth, cx, mouthY);
+  const moustache = buildMoustache(kit, spec.moustache, spec.moustacheColor);
+  if (moustache) {
+    const above = spec.mouth === "none" ? 0.03 : spec.mouth === "open" ? 0.11 : 0.075;
+    place(moustache, cx, mouthY + above, 0.015);
+  }
+  if (spec.cheeks) {
+    for (const s of [-1, 1]) {
+      const disc = new three.SphereGeometry(1, 32, 16);
+      disc.scale(0.085, 0.055, 0.022);
+      const cheek = fuzzy(disc, spec.cheekColor, 0.014);
+      const x = cx + s * (eyeX + 0.1);
+      place(cheek, x, eyeY - 0.13);
+    }
+  }
+  let glasses = null;
+  if (spec.glasses !== "none") {
+    glasses = buildGlasses(kit, spec.glasses, eyeX, Math.max(0.85, spec.eyeSize), spec.glassesColor);
+    if (glasses) {
+      place(glasses, cx, eyeY, 0.05);
+      face.updateWorldMatrix(true, true);
+      const toFace = face.matrixWorld.clone().invert();
+      const inFace = (object) => new three.Box3().setFromObject(object).applyMatrix4(toFace);
+      const lenses = inFace(glasses);
+      let front = -Infinity;
+      for (const child of face.children) {
+        if (child === glasses)
+          continue;
+        const box = inFace(child);
+        if (box.max.x < lenses.min.x || box.min.x > lenses.max.x)
+          continue;
+        if (box.max.y < lenses.min.y || box.min.y > lenses.max.y)
+          continue;
+        front = Math.max(front, box.max.z);
+      }
+      glasses.position.z += Math.max(0, front + 0.03 - lenses.min.z);
+      floaters[floaters.length - 1].rest = glasses.position.z;
+    }
+  }
+  const worn = [face];
+  if (spec.neck === "bowtie") {
+    const tie = buildBowtie(kit, spec.neckColor);
+    tie.scale.setScalar(0.85);
+    const y = bottom + 0.17;
+    tie.position.set(0, y, surface(0, y) + 0.04);
+    inner.add(tie);
+    worn.push(tie);
+    floaters.push({ object: tie, rest: tie.position.z, lift: 0.6 });
+  } else if (spec.neck !== "none") {
+    const y = Math.max(mouthY - 0.16, bottom + 0.3);
+    const neck = buildNeck(kit, spec.neck, spec.neckColor, spec.accent, {
+      y,
+      floor: (x) => y - reach(outline, x, y, 0, -1, 0.08),
+      front: (x, yy) => body.heightAt(x, yy)
+    });
+    if (neck) {
+      inner.add(neck);
+      worn.push(neck);
+      floaters.push({ object: neck, rest: 0, lift: 0.4 });
+    }
+  }
+  const pin = buildPin(kit, spec.pin, spec.pinColor);
+  if (pin) {
+    const head = spec.pin === "flower" || spec.pin === "bow" || spec.pin === "heart";
+    const angle = (head ? 130 : -35) * Math.PI / 180;
+    const dx = Math.cos(angle);
+    const dy = Math.sin(angle);
+    const r = reach(outline, cx, cy, dx, dy) * (head ? 0.74 : 0.6);
+    const x = cx + dx * r;
+    const y = cy + dy * r;
+    pin.position.set(x, y, surface(x, y) + 0.01);
+    const e = 0.02;
+    const n = new three.Vector3(-(body.heightAt(x + e, y) - body.heightAt(x - e, y)) / (2 * e), -(body.heightAt(x, y + e) - body.heightAt(x, y - e)) / (2 * e), 1).normalize();
+    n.lerp(new three.Vector3(0, 0, 1), 0.4).normalize();
+    pin.quaternion.setFromUnitVectors(new three.Vector3(0, 0, 1), n);
+    pin.rotateZ(head ? 0.35 : -0.2);
+    inner.add(pin);
+    worn.push(pin);
+    compensate.push(pin);
+    floaters.push({ object: pin, rest: pin.position.z, lift: 0.5 });
+  }
+  let hat = null;
+  let hatTop = perch.at[1];
+  let hatHalfWidth = 0;
+  const hatRest = [perch.at[0], perch.at[1]];
+  const hatParts = buildHat(kit, spec.hat, spec.hatColor, spec.accent, fuzzy);
+  if (hatParts) {
+    hat = new three.Group;
+    hat.name = "hat";
+    hat.add(hatParts.group);
+    hat.scale.setScalar(spec.hatSize);
+    [hatRest[0], hatRest[1]] = seatHat(outline, perch.tilt, perch.at, hatParts.crown, hatParts.brim, spec.hatSize);
+    hat.position.set(hatRest[0], hatRest[1], 0);
+    hat.rotation.z = perch.tilt;
+    inner.add(hat);
+    worn.push(hat);
+    hatTop = hatRest[1] + Math.cos(perch.tilt) * (hatParts.height + 0.1) * spec.hatSize;
+    hat.updateMatrixWorld(true);
+    const box = new three.Box3().setFromObject(hat);
+    hatHalfWidth = Math.max(-box.min.x, box.max.x);
+  }
+  const biased = new Set;
+  for (const root of worn) {
+    root?.traverse((child) => {
+      const material = child.material;
+      for (const m of Array.isArray(material) ? material : material ? [material] : []) {
+        if (!(m instanceof three.ShaderMaterial) && !biased.has(m)) {
+          biased.add(m);
+          applyDepthBias(m, bias);
+        }
+      }
+    });
+  }
+  let shadow = null;
+  if (spec.shadow) {
+    shadow = new three.Mesh(new three.PlaneGeometry(1, 1), new three.MeshBasicMaterial({
+      map: shadowTexture(three),
+      color: "#000000",
+      transparent: true,
+      depthWrite: false,
+      opacity: 0.4
+    }));
+    shadow.renderOrder = -1;
+    outer.add(shadow);
+  }
+  const shadowBottom = bottom - 0.14;
+  const fitTop = hatTop + 0.08 + spec.headroom * 2;
+  return {
+    outer,
+    pivot,
+    face,
+    eyes,
+    glasses,
+    hat,
+    hatRest,
+    floaters,
+    shadow,
+    bottom,
+    fitW: 2 * Math.max(maxX + 0.12, hatHalfWidth + 0.04),
+    fitH: fitTop - shadowBottom,
+    fitMid: (fitTop + shadowBottom) / 2,
+    furs,
+    bodyFur,
+    bodyGeometry: bodyMesh.geometry,
+    compensate,
+    bias
+  };
+}
+function addLights(three, root) {
+  root.add(new three.HemisphereLight("#fffaf2", "#6e655d", 1.25));
+  const key = new three.DirectionalLight("#fff4e4", 2.3);
+  key.position.set(-300, 420, 520);
+  const rim = new three.DirectionalLight("#ffffff", 2.4);
+  rim.position.set(380, 260, -420);
+  const fill = new three.DirectionalLight("#e8eeff", 0.55);
+  fill.position.set(420, -120, 400);
+  root.add(key, rim, fill);
+}
+var DEFAULT_POSE = {
+  width: 600,
+  height: 600,
+  pixelRatio: 1,
+  lookX: 0,
+  lookY: 0,
+  blink: 0,
+  squash: 0,
+  hop: 0,
+  lean: 0,
+  turn: 0,
+  float: 1,
+  color: "#f2b33d"
+};
+var DEFAULT_OPTIONS = {
+  kind: "circle",
+  roundness: 0.6,
+  starInner: 0.55,
+  seed: 1,
+  thickness: 0.42,
+  fabric: "plush",
+  finish: "satin",
+  eyes: "dot",
+  eyeSize: 1,
+  eyeSpacing: 1,
+  faceY: 0,
+  mouth: "none",
+  cheeks: false,
+  glasses: "none",
+  moustache: "none",
+  hat: "none",
+  hatSize: 1,
+  neck: "none",
+  pin: "none",
+  featureColor: "#18130f",
+  accentColor: "#5b6cff",
+  cheekColor: "#f08a9b",
+  headroom: 0.22,
+  shadow: true,
+  lights: true
+};
+var PLUSHIE_KINDS = [
+  "circle",
+  "square",
+  "triangle",
+  "heart",
+  "star",
+  "pill",
+  "cloud",
+  "polygon",
+  "blob",
+  "egg",
+  "drop",
+  "ghost",
+  "bean",
+  "flower",
+  "diamond",
+  "squircle",
+  "arch"
+];
+var PLUSHIE_FABRICS = ["plush", "felt", "velvet", "shaggy", "fleece"];
+var PLUSHIE_FINISHES = ["gloss", "satin", "matte", "felt"];
+var PLUSHIE_EYES = ["dot", "oval", "googly", "ring", "happy", "sleepy", "none"];
+var PLUSHIE_MOUTHS = ["none", "smile", "grin", "open", "flat", "cat"];
+var PLUSHIE_GLASSES = ["none", "round", "square", "monocle", "shades"];
+var PLUSHIE_HATS = [
+  "none",
+  "top",
+  "beanie",
+  "party",
+  "crown",
+  "cowboy",
+  "cap",
+  "hardhat",
+  "fireman",
+  "santa",
+  "graduation",
+  "fez",
+  "halo"
+];
+var PLUSHIE_NECKS = ["none", "bowtie", "necktie"];
+var PLUSHIE_PINS = ["none", "flower", "bow", "heart", "star", "badge"];
+var PLUSHIE_MOUSTACHES = ["none", "curly", "walrus", "pencil"];
+function fabricFur(fabric = "plush") {
+  return (FABRICS[fabric] ?? FABRICS.plush).fur;
+}
+function fabricGrain(fabric = "plush") {
+  return (FABRICS[fabric] ?? FABRICS.plush).grain;
+}
+function plushieOutline(kind = "circle", options = {}) {
+  const { roundness = 0.6, sides, starInner = 0.55, seed = 1 } = options;
+  return silhouette(kind, { roundness, sides, starInner, seed });
+}
+var MAX_FUR_SHELLS = FUR_SHELLS;
+var warned = new Set;
+function warnOnce(message) {
+  if (warned.has(message))
+    return;
+  warned.add(message);
+  console.warn(`plushies: ${message}`);
+}
+function oneOf(name, value, allowed, fallback) {
+  if (value === undefined)
+    return fallback;
+  if (allowed.includes(value))
+    return value;
+  warnOnce(`unknown ${name} ${JSON.stringify(value)}, using ${JSON.stringify(fallback)}`);
+  return fallback;
+}
+function flag(name, value, fallback) {
+  if (value === undefined)
+    return fallback;
+  if (typeof value === "boolean")
+    return value;
+  warnOnce(`${name} must be true or false, got ${JSON.stringify(value)}; using ${fallback}`);
+  return fallback;
+}
+function within(name, value, fallback, min, max) {
+  if (value === undefined)
+    return fallback;
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    warnOnce(`${name} must be a number, got ${String(value)}; using ${fallback}`);
+    return fallback;
+  }
+  if (value < min || value > max) {
+    warnOnce(`${name} ${value} is outside ${min}..${max}; clamping`);
+    return Math.max(min, Math.min(max, value));
+  }
+  return value;
+}
+function finitePose(next) {
+  let out = null;
+  for (const key of Object.keys(next)) {
+    const value = next[key];
+    if (value === undefined || typeof value === "number" && !Number.isFinite(value)) {
+      if (value !== undefined)
+        warnOnce(`pose ${key} must be a finite number, got ${String(value)}; ignored`);
+      out ??= { ...next };
+      delete out[key];
+    }
+  }
+  return out ?? next;
+}
+function createPlushie(three, options = {}) {
+  const {
+    kind: kindOption,
+    roundness: roundnessOption,
+    sides: sidesOption,
+    starInner: starInnerOption,
+    seed: seedOption,
+    thickness: thicknessOption,
+    fabric: fabricOption,
+    furGrain: furGrainOption,
+    finish: finishOption,
+    eyes: eyesOption,
+    eyeSize: eyeSizeOption,
+    eyeSpacing: eyeSpacingOption,
+    faceY: faceYOption,
+    mouth: mouthOption,
+    cheeks: cheeksOption,
+    glasses: glassesOption,
+    moustache: moustacheOption,
+    hat: hatOption,
+    hatSize: hatSizeOption,
+    bowtie: bowtieOption,
+    neck: neckOption,
+    pin: pinOption,
+    featureColor = "#18130f",
+    moustacheColor,
+    glassesColor,
+    hatColor,
+    neckColor,
+    bowtieColor,
+    pinColor,
+    accentColor = "#5b6cff",
+    cheekColor = "#f08a9b",
+    headroom: headroomOption,
+    shadow: shadowOption,
+    lights: lightsOption,
+    renderer,
+    ...initial
+  } = options;
+  const cheeks = flag("cheeks", cheeksOption, false);
+  const bowtie = flag("bowtie", bowtieOption, false);
+  const shadow = flag("shadow", shadowOption, true);
+  const lights = flag("lights", lightsOption, true);
+  const kind = oneOf("kind", kindOption, PLUSHIE_KINDS, "circle");
+  const roundness = within("roundness", roundnessOption, 0.6, 0, 1);
+  const sides = sidesOption === undefined ? undefined : Math.round(within("sides", sidesOption, 6, 3, 24));
+  const starInner = within("starInner", starInnerOption, 0.55, 0.2, 0.9);
+  const seed = within("seed", seedOption, 1, -1e9, 1e9);
+  const thickness = within("thickness", thicknessOption, 0.42, 0.05, 1.5);
+  const fabric = oneOf("fabric", fabricOption, PLUSHIE_FABRICS, "plush");
+  const furGrain = furGrainOption === undefined ? undefined : within("furGrain", furGrainOption, 1, 0.1, 6);
+  const finish = oneOf("finish", finishOption, PLUSHIE_FINISHES, "satin");
+  const eyes = oneOf("eyes", eyesOption, PLUSHIE_EYES, "dot");
+  const eyeSize = within("eyeSize", eyeSizeOption, 1, 0.1, 4);
+  const eyeSpacing = within("eyeSpacing", eyeSpacingOption, 1, 0, 4);
+  const faceY = within("faceY", faceYOption, 0, -1, 1);
+  const mouth = oneOf("mouth", mouthOption, PLUSHIE_MOUTHS, "none");
+  const glasses = oneOf("glasses", glassesOption, PLUSHIE_GLASSES, "none");
+  const moustache = oneOf("moustache", moustacheOption, PLUSHIE_MOUSTACHES, "none");
+  const hat = oneOf("hat", hatOption, PLUSHIE_HATS, "none");
+  const hatSize = within("hatSize", hatSizeOption, 1, 0.1, 4);
+  const neck = oneOf("neck", neckOption, PLUSHIE_NECKS, bowtie ? "bowtie" : "none");
+  const pin = oneOf("pin", pinOption, PLUSHIE_PINS, "none");
+  const headroom = within("headroom", headroomOption, 0.22, 0, 2);
+  const feature = toHex(three, featureColor);
+  const accent = toHex(three, accentColor);
+  const preset = FABRICS[fabric] ?? FABRICS.plush;
+  const spec = {
+    kind,
+    outline: { roundness, sides, starInner, seed },
+    thickness,
+    furGrain: furGrain ?? preset.grain,
+    fabric: preset,
+    finish,
+    eyes,
+    eyeSize,
+    eyeSpacing,
+    faceY: faceY * 0.5,
+    mouth,
+    cheeks,
+    glasses,
+    hat,
+    hatSize,
+    neck,
+    pin,
+    moustache,
+    featureColor: feature,
+    glassesColor: toHex(three, glassesColor) ?? feature,
+    hatColor: toHex(three, hatColor),
+    neckColor: toHex(three, neckColor ?? bowtieColor) ?? (neck === "bowtie" ? feature : ACCESSORY_COLORS.neck[neck] ?? accent),
+    pinColor: toHex(three, pinColor) ?? ACCESSORY_COLORS.pin[pin] ?? accent,
+    moustacheColor: toHex(three, moustacheColor) ?? feature,
+    accent,
+    cheekColor: toHex(three, cheekColor),
+    headroom,
+    shadow,
+    renderer
+  };
+  const object = new three.Group;
+  object.name = "Plushie";
+  if (lights)
+    addLights(three, object);
+  const rig = buildRig(three, spec);
+  object.add(rig.outer);
+  const pose = { ...DEFAULT_POSE, fur: preset.fur };
+  const start = finitePose(initial);
+  for (const key of Object.keys(start)) {
+    pose[key] = start[key];
+  }
+  applyPose(rig, pose, toRgb(three, pose.color));
+  return {
+    object,
+    pose,
+    set(next) {
+      Object.assign(pose, finitePose(next));
+      applyPose(rig, pose, toRgb(three, pose.color));
+    },
+    dispose() {
+      const env = studioEnvironment(three, renderer);
+      object.traverse((node) => {
+        const mesh = node;
+        mesh.geometry?.dispose();
+        const materials = Array.isArray(mesh.material) ? mesh.material : mesh.material ? [mesh.material] : [];
+        for (const material of materials) {
+          for (const value of Object.values(material)) {
+            if (value instanceof three.Texture && value !== env)
+              value.dispose();
+          }
+          material.dispose();
+        }
+      });
+      object.removeFromParent();
+    }
+  };
+}
+function applyPose(rig, p, color) {
+  const k = Math.min(p.width / rig.fitW, p.height / rig.fitH) * 0.96;
+  const hop = p.hop / k;
+  rig.outer.scale.setScalar(k);
+  rig.outer.position.y = -rig.fitMid * k;
+  const sq = Math.max(-0.95, Math.min(0.95, p.squash));
+  const sy = sq >= 0 ? 1 - 0.38 * sq : 1 + 0.32 * -sq;
+  const sx = 1 / Math.sqrt(sy);
+  const { pivot } = rig;
+  pivot.position.y = rig.bottom + hop;
+  pivot.scale.set(sx, sy, sx);
+  pivot.rotation.set(0, p.turn * Math.PI / 180, -p.lean * Math.PI / 180);
+  for (const object of rig.compensate) {
+    object.scale.x = object.scale.x / (object.userData.sx ?? 1);
+    object.scale.y = object.scale.y / (object.userData.sy ?? 1);
+    const cx = 1 + (1 / sx - 1) * 0.5;
+    const cy = 1 + (1 / sy - 1) * 0.5;
+    object.userData.sx = cx;
+    object.userData.sy = cy;
+    object.scale.x *= cx;
+    object.scale.y *= cy;
+  }
+  const float = p.float;
+  for (const f of rig.floaters) {
+    f.object.position.z = f.rest + (float - 1) * 0.05 * f.lift;
+  }
+  if (rig.hat) {
+    const lift = (float - 1) * 0.07 + Math.max(0, -sq) * 0.06;
+    rig.hat.position.y = rig.hatRest[1] + lift;
+    rig.hat.scale.x = rig.hat.scale.z / sx * (1 + (sx - 1) * 0.3);
+    rig.hat.scale.y = rig.hat.scale.z / sy * (1 + (sy - 1) * 0.3);
+  }
+  const lx = Math.max(-1.5, Math.min(1.5, p.lookX));
+  const ly = Math.max(-1.5, Math.min(1.5, p.lookY));
+  rig.face.rotation.set(ly * 0.16, lx * 0.24, 0);
+  const blink = Math.max(0, Math.min(1, p.blink));
+  for (const eye of rig.eyes) {
+    eye.lid.scale.y = 1 - 0.93 * blink;
+    if (eye.pupil) {
+      const pupilBase = eye.pupil.userData.base ?? [eye.pupil.position.x, eye.pupil.position.y];
+      eye.pupil.userData.base = pupilBase;
+      eye.pupil.position.x = pupilBase[0] + lx * eye.range;
+      eye.pupil.position.y = pupilBase[1] - ly * eye.range;
+    }
+  }
+  const fur = Math.max(0, p.fur);
+  rig.bias.value = (fur + 0.1) * k / 100;
+  rig.bodyFur.uniforms.uFur.value = fur;
+  const furPx = fur * k * p.pixelRatio;
+  const layers = Math.max(3, Math.min(FUR_SHELLS, Math.ceil(furPx / 0.8)));
+  rig.bodyFur.uniforms.uLayers.value = layers;
+  rig.bodyGeometry.setDrawRange(0, rig.bodyGeometry.userData.indexPerLayer * (layers + 1));
+  setFurColor(rig.bodyFur, color);
+  if (rig.shadow) {
+    const air = Math.max(0, hop);
+    const spread = 1 / (1 + air * 1.6);
+    rig.shadow.scale.set(rig.fitW * 0.78 * sx * spread, 0.2 * spread, 1);
+    rig.shadow.position.set(0, rig.bottom + 0.005, -0.25);
+    rig.shadow.material.opacity = 0.42 * spread;
+  }
+}