badgecraft 0.3.0

package/dist/chunk-RRYBMB25.js

@@ -0,0 +1,3410 @@
+// src/util.ts
+function stableStringify(value) {
+  if (value === null || typeof value !== "object") return JSON.stringify(value) ?? "undefined";
+  if (Array.isArray(value)) return `[${value.map(stableStringify).join(",")}]`;
+  const obj = value;
+  const keys = Object.keys(obj).filter((k) => obj[k] !== void 0 && typeof obj[k] !== "function").sort();
+  return `{${keys.map((k) => `${JSON.stringify(k)}:${stableStringify(obj[k])}`).join(",")}}`;
+}
+function hashString(str, seed = 0) {
+  let h1 = 3735928559 ^ seed;
+  let h2 = 1103547991 ^ seed;
+  for (let i = 0; i < str.length; i++) {
+    const ch = str.charCodeAt(i);
+    h1 = Math.imul(h1 ^ ch, 2654435761);
+    h2 = Math.imul(h2 ^ ch, 1597334677);
+  }
+  h1 = Math.imul(h1 ^ h1 >>> 16, 2246822507) ^ Math.imul(h2 ^ h2 >>> 13, 3266489909);
+  h2 = Math.imul(h2 ^ h2 >>> 16, 2246822507) ^ Math.imul(h1 ^ h1 >>> 13, 3266489909);
+  return (4294967296 * (2097151 & h2) + (h1 >>> 0)).toString(36);
+}
+var clamp = (v, lo, hi) => v < lo ? lo : v > hi ? hi : v;
+
+// src/environment.ts
+var environments = {
+  studio: {
+    top: "#727984",
+    horizon: "#20232a",
+    bottom: "#101116",
+    intensity: 1,
+    // Product-photo softboxes separated by dark space: the gaps give polished
+    // metal its contrast, while the wide key still lights coloured enamel.
+    lights: [
+      { azimuth: -12, elevation: 8, size: [90, 65], intensity: 0.22, color: "#ffffff", softness: 1 },
+      { azimuth: -36, elevation: 38, size: [58, 65], intensity: 4.5, color: "#fff8ef", softness: 0.45 },
+      { azimuth: 48, elevation: 12, size: [16, 85], intensity: 3.2, color: "#e9f1ff", softness: 0.35 },
+      { azimuth: 0, elevation: 72, size: [135, 24], intensity: 3.8, color: "#ffffff", softness: 0.5 },
+      { azimuth: -120, elevation: 20, size: [24, 65], intensity: 1.8, color: "#ffffff", softness: 0.4 },
+      { azimuth: 135, elevation: 30, size: 34, shape: "circle", intensity: 2, color: "#fff2dd", softness: 0.6 }
+    ]
+  },
+  soft: {
+    top: "#c9ccd2",
+    horizon: "#8a8c91",
+    bottom: "#3a3a3d",
+    intensity: 1,
+    lights: [
+      { azimuth: 0, elevation: 25, size: [160, 70], intensity: 1.2, color: "#ffffff", softness: 1 },
+      { azimuth: -60, elevation: 45, size: [80, 60], intensity: 2, color: "#fffaf0", softness: 1 }
+    ]
+  },
+  sunset: {
+    top: "#3b3f7a",
+    horizon: "#e0806a",
+    bottom: "#1a1012",
+    intensity: 1,
+    lights: [
+      { azimuth: -55, elevation: 12, size: 26, shape: "circle", intensity: 14, color: "#ffb46b", softness: 0.6 },
+      { azimuth: 0, elevation: 15, size: [120, 40], intensity: 0.9, color: "#ffc7a8", softness: 1 },
+      { azimuth: 70, elevation: 40, size: [60, 40], intensity: 1.6, color: "#8fa6ff", softness: 0.8 }
+    ]
+  },
+  night: {
+    top: "#101218",
+    horizon: "#07080b",
+    bottom: "#020203",
+    intensity: 1,
+    lights: [
+      { azimuth: -30, elevation: 40, size: [30, 22], intensity: 9, color: "#ffffff", softness: 0.35 },
+      { azimuth: 115, elevation: 25, size: [16, 60], intensity: 5, color: "#dfe8ff", softness: 0.3 },
+      { azimuth: -135, elevation: 15, size: [14, 50], intensity: 4, color: "#ffffff", softness: 0.3 },
+      { azimuth: 0, elevation: 10, size: [90, 30], intensity: 0.45, color: "#ffffff", softness: 1 }
+    ]
+  },
+  neon: {
+    top: "#1a1030",
+    horizon: "#101018",
+    bottom: "#050508",
+    intensity: 1,
+    lights: [
+      { azimuth: -45, elevation: 25, size: [20, 80], intensity: 6, color: "#ff3fa4", softness: 0.4 },
+      { azimuth: 45, elevation: 25, size: [20, 80], intensity: 6, color: "#2fd8ff", softness: 0.4 },
+      { azimuth: 0, elevation: 60, size: [120, 18], intensity: 3, color: "#b98cff", softness: 0.6 },
+      { azimuth: 0, elevation: 10, size: [100, 40], intensity: 0.8, color: "#ffffff", softness: 1 }
+    ]
+  }
+};
+function resolveEnvironment(input) {
+  if (!input) input = "studio";
+  if (typeof input === "string") {
+    const spec2 = Object.prototype.hasOwnProperty.call(environments, input) ? environments[input] : void 0;
+    if (spec2) return { kind: "procedural", spec: spec2, key: `preset:${input}` };
+    return { kind: "image", spec: { url: input }, key: `url:${input}|1` };
+  }
+  const finite = (value, fallback, lo, hi) => typeof value === "number" && Number.isFinite(value) ? clamp(value, lo, hi) : fallback;
+  const intensity = finite(input.intensity, 1, 0, 1e4);
+  if ("url" in input) {
+    const spec2 = { url: input.url, intensity };
+    return { kind: "image", spec: spec2, key: `url:${spec2.url}|${intensity}` };
+  }
+  const spec = {
+    ...input,
+    intensity,
+    lights: input.lights?.map((light) => {
+      const size = light.size ?? 30;
+      const dimensions = Array.isArray(size) ? size : [size, size];
+      return {
+        ...light,
+        azimuth: finite(light.azimuth, 0, -Infinity, Infinity) % 360,
+        elevation: finite(light.elevation, 0, -90, 90),
+        intensity: finite(light.intensity, 1, 0, 1e4),
+        softness: finite(light.softness, 0.5, 0, 1),
+        size: dimensions.map((value) => finite(value, 30, 1e-3, 170))
+      };
+    })
+  };
+  return { kind: "procedural", spec, key: `proc:${stableStringify(spec)}` };
+}
+
+// src/materials.ts
+var BASE = {
+  color: "#ffffff",
+  useSvgColor: false,
+  metalness: 0,
+  roughness: 0.4,
+  clearcoat: 0,
+  clearcoatRoughness: 0.05,
+  ior: 1.5,
+  iridescence: 0,
+  iridescenceThickness: 450,
+  flakes: 0,
+  flakeScale: 220,
+  brushed: 0,
+  brushDirection: "circular",
+  emissive: 0
+};
+var metal = (color, roughness, extra = {}) => ({
+  color,
+  metalness: 1,
+  roughness,
+  ...extra
+});
+var materials = {
+  gold: metal("#f7dc8f", 0.24),
+  "rose-gold": metal("#f6b99c", 0.22),
+  "white-gold": metal("#efe7d2", 0.2),
+  "matte-gold": metal("#f0d284", 0.48),
+  "brushed-gold": metal("#f7dc8f", 0.34, { brushed: 0.7, brushDirection: "circular" }),
+  silver: metal("#f1f0ee", 0.24),
+  "brushed-silver": metal("#e9e9ea", 0.3, { brushed: 0.7, brushDirection: "circular" }),
+  platinum: metal("#d8d3cb", 0.22),
+  chrome: metal("#e6e9ec", 0.04),
+  copper: metal("#f2a27c", 0.24),
+  bronze: metal("#d69a5c", 0.32),
+  brass: metal("#e9c46f", 0.26),
+  titanium: metal("#b9b2a9", 0.3),
+  gunmetal: metal("#6b6d73", 0.28),
+  "black-chrome": metal("#3c3d42", 0.1),
+  enamel: { useSvgColor: true, metalness: 0, roughness: 0.28, clearcoat: 1, clearcoatRoughness: 0.09 },
+  "matte-enamel": { useSvgColor: true, metalness: 0, roughness: 0.62, clearcoat: 0.15, clearcoatRoughness: 0.4 },
+  candy: { useSvgColor: true, metalness: 0.85, roughness: 0.3, clearcoat: 1, clearcoatRoughness: 0.04 },
+  glitter: {
+    useSvgColor: true,
+    metalness: 0.2,
+    roughness: 0.35,
+    clearcoat: 1,
+    clearcoatRoughness: 0.04,
+    flakes: 0.9,
+    flakeScale: 260
+  },
+  pearl: {
+    color: "#f4eee6",
+    metalness: 0.15,
+    roughness: 0.28,
+    clearcoat: 1,
+    clearcoatRoughness: 0.05,
+    iridescence: 0.7,
+    iridescenceThickness: 560
+  },
+  holographic: metal("#f2f2f4", 0.18, { iridescence: 1, iridescenceThickness: 420, flakes: 0.4 }),
+  onyx: { color: "#191b20", metalness: 0, roughness: 0.28, clearcoat: 1, clearcoatRoughness: 0.1 },
+  obsidian: { color: "#0e0e10", metalness: 0, roughness: 0.2, clearcoat: 1, clearcoatRoughness: 0.03 }
+};
+var defaultSlotMaterials = {
+  metal: "gold",
+  enamel: "enamel",
+  base: "onyx",
+  accent: "silver"
+};
+function resolveMaterial(input, slot) {
+  const value = input ?? defaultSlotMaterials[slot];
+  let spec;
+  if (typeof value === "string") {
+    spec = materials[value] ?? materials[defaultSlotMaterials[slot]];
+  } else {
+    const { preset, ...rest } = value;
+    spec = { ...preset ? materials[preset] : {}, ...stripUndefined(rest) };
+  }
+  const out = { ...BASE, ...stripUndefined(spec) };
+  const ranges = {
+    metalness: [0, 1],
+    roughness: [0, 1],
+    clearcoat: [0, 1],
+    clearcoatRoughness: [0, 1],
+    ior: [1, 3],
+    iridescence: [0, 1],
+    iridescenceThickness: [100, 1200],
+    flakes: [0, 1],
+    flakeScale: [1, 1e4],
+    brushed: [0, 1],
+    emissive: [0, 1]
+  };
+  for (const key of Object.keys(ranges)) {
+    const [lo, hi] = ranges[key];
+    out[key] = Number.isFinite(out[key]) ? clamp(out[key], lo, hi) : BASE[key];
+  }
+  if (spec.useSvgColor === void 0 && slot === "enamel" && !spec.color) out.useSvgColor = true;
+  return out;
+}
+function stripUndefined(obj) {
+  const out = {};
+  for (const key of Object.keys(obj)) if (obj[key] !== void 0) out[key] = obj[key];
+  return out;
+}
+
+// src/options.ts
+var defaults = {
+  mode: "auto",
+  color: "#ffffff",
+  rim: 0.03,
+  outline: "auto",
+  autoOutline: 0.012,
+  fillHoles: true,
+  relief: {
+    depth: 0.05,
+    thickness: 0.03,
+    floor: 0.3,
+    profile: "round",
+    bevel: 0.02,
+    edge: 0.014,
+    enamelLevel: 0.16,
+    enamelDome: 0.12,
+    domeWidth: 0.05,
+    smoothing: 0.9,
+    ao: 0.45
+  },
+  exposure: 1,
+  toneMapping: "neutral",
+  interaction: "tilt",
+  tiltMax: 18,
+  pose: { pitch: -5, yaw: -8, roll: 0 },
+  idle: "none",
+  lockedColor: "#3a3a3c",
+  shadow: 0.35,
+  padding: 0.06
+};
+var PROFILE = { round: 0, soft: 1, chamfer: 2 };
+var TONE = { neutral: 0, aces: 1, agx: 2, none: 3 };
+var num = (v, fallback, lo = -Infinity, hi = Infinity) => typeof v === "number" && Number.isFinite(v) ? clamp(v, lo, hi) : fallback;
+function resolveOptions(o) {
+  const r = { ...defaults.relief, ...stripUndefined2(o.relief ?? {}) };
+  const frame = o.frame == null ? null : typeof o.frame === "string" ? { shape: o.frame } : { shape: "circle", ...o.frame };
+  if (frame) {
+    frame.padding = num(frame.padding, 0.22, 0, 0.45);
+    frame.innerRing = num(frame.innerRing, 0, 0, 0.3);
+  }
+  const bake2 = {
+    depth: num(r.depth, defaults.relief.depth, 1e-3, 0.5),
+    mode: o.mode ?? defaults.mode,
+    color: o.color ?? defaults.color,
+    frame,
+    rim: num(o.rim, defaults.rim, 0, 0.3),
+    outline: o.outline === void 0 || o.outline === "auto" ? "auto" : num(o.outline, 0, 0, 0.3),
+    autoOutline: defaults.autoOutline,
+    fillHoles: o.fillHoles ?? defaults.fillHoles,
+    floor: num(r.floor, defaults.relief.floor, 0, 0.95),
+    profile: PROFILE[r.profile] ?? 0,
+    bevel: num(r.bevel, defaults.relief.bevel, 1e-3, 0.5),
+    edge: num(r.edge, defaults.relief.edge, 1e-3, 0.2),
+    enamelLevel: num(r.enamelLevel, defaults.relief.enamelLevel, 0, 1),
+    enamelDome: num(r.enamelDome, defaults.relief.enamelDome, -1, 1),
+    domeWidth: num(r.domeWidth, defaults.relief.domeWidth, 1e-3, 0.5),
+    smoothing: num(r.smoothing, defaults.relief.smoothing, 0, 8)
+  };
+  const render = {
+    materials: [
+      resolveMaterial(o.metal, "metal"),
+      resolveMaterial(o.enamel, "enamel"),
+      resolveMaterial(o.base, "base"),
+      resolveMaterial(o.accent, "accent")
+    ],
+    environment: resolveEnvironment(o.environment),
+    envRotation: num(o.environmentRotation, 0) % 360 * Math.PI / 180,
+    thickness: num(r.thickness, defaults.relief.thickness, 0, 0.5),
+    edge: bake2.edge,
+    ao: num(r.ao, defaults.relief.ao, 0, 1),
+    exposure: num(o.exposure, defaults.exposure, 0, 16),
+    toneMapping: TONE[o.toneMapping ?? defaults.toneMapping] ?? 0,
+    interaction: o.interaction ?? defaults.interaction,
+    tiltMax: num(o.tiltMax, defaults.tiltMax, 0, 80),
+    pose: {
+      pitch: num(o.pose?.pitch, defaults.pose.pitch, -89, 89),
+      yaw: num(o.pose?.yaw, defaults.pose.yaw, -180, 180),
+      roll: num(o.pose?.roll, defaults.pose.roll, -180, 180)
+    },
+    idle: o.idle ?? defaults.idle,
+    locked: !!o.locked,
+    lockedColor: o.lockedColor ?? defaults.lockedColor,
+    shadow: num(o.shadow, defaults.shadow, 0, 1),
+    padding: num(o.padding, defaults.padding, 0, 0.4)
+  };
+  const quality = typeof o.quality !== "number" || !Number.isFinite(o.quality) ? "auto" : clamp(Math.round(o.quality), 64, 2048);
+  return {
+    bake: bake2,
+    bakeKey: stableStringify(bake2),
+    render,
+    renderKey: stableStringify(render),
+    quality
+  };
+}
+function stripUndefined2(obj) {
+  const out = {};
+  for (const k of Object.keys(obj)) if (obj[k] !== void 0) out[k] = obj[k];
+  return out;
+}
+
+// src/svg/frames.ts
+var f = (n) => Math.round(n * 1e3) / 1e3;
+function roundedPolygon(points, radius) {
+  const n = points.length;
+  let d = "";
+  for (let i = 0; i < n; i++) {
+    const p = points[i];
+    const prev = points[(i - 1 + n) % n];
+    const next = points[(i + 1) % n];
+    const lenPrev = Math.hypot(prev[0] - p[0], prev[1] - p[1]);
+    const lenNext = Math.hypot(next[0] - p[0], next[1] - p[1]);
+    const r = Math.min(radius, lenPrev / 2, lenNext / 2);
+    const a = [p[0] + (prev[0] - p[0]) / lenPrev * r, p[1] + (prev[1] - p[1]) / lenPrev * r];
+    const b = [p[0] + (next[0] - p[0]) / lenNext * r, p[1] + (next[1] - p[1]) / lenNext * r];
+    d += `${i === 0 ? "M" : "L"}${f(a[0])} ${f(a[1])}Q${f(p[0])} ${f(p[1])} ${f(b[0])} ${f(b[1])}`;
+  }
+  return `${d}Z`;
+}
+function regular(count, radius, startDeg, corner, cx = 50, cy = 50) {
+  const pts = [];
+  for (let i = 0; i < count; i++) {
+    const a = (startDeg + 360 / count * i) * Math.PI / 180;
+    pts.push([cx + Math.cos(a) * radius, cy + Math.sin(a) * radius]);
+  }
+  return roundedPolygon(pts, corner);
+}
+function star(points, outer, inner, corner) {
+  const pts = [];
+  for (let i = 0; i < points * 2; i++) {
+    const r = i % 2 === 0 ? outer : inner;
+    const a = (-90 + 180 / points * i) * Math.PI / 180;
+    pts.push([50 + Math.cos(a) * r, 50 + Math.sin(a) * r]);
+  }
+  return roundedPolygon(pts, corner);
+}
+var framePaths = {
+  circle: "M50 3A47 47 0 1 1 50 97A47 47 0 1 1 50 3Z",
+  hexagon: regular(6, 48, -90, 9),
+  octagon: regular(8, 48, -67.5, 6),
+  shield: "M14 13Q50 1 86 13L86 47C86 72 70 88 50 97C30 88 14 72 14 47Z",
+  square: roundedPolygon(
+    [
+      [5, 5],
+      [95, 5],
+      [95, 95],
+      [5, 95]
+    ],
+    16
+  ),
+  diamond: regular(4, 48, -90, 8),
+  star: star(5, 49, 27, 5)
+};
+
+// src/color.ts
+var probe;
+function normalizeWithCanvas(color) {
+  if (probe === void 0) {
+    probe = typeof document !== "undefined" ? document.createElement("canvas").getContext("2d") : null;
+  }
+  if (!probe) return null;
+  probe.fillStyle = "#000000";
+  probe.fillStyle = color;
+  const a = String(probe.fillStyle);
+  probe.fillStyle = "#ffffff";
+  probe.fillStyle = color;
+  const b = String(probe.fillStyle);
+  if (a !== b) return null;
+  if (!/^#|^rgba?\(/i.test(a)) {
+    probe.clearRect(0, 0, 1, 1);
+    probe.fillRect(0, 0, 1, 1);
+    const p = probe.getImageData(0, 0, 1, 1).data;
+    return `rgb(${p[0]},${p[1]},${p[2]})`;
+  }
+  return a;
+}
+function parseColor(color, fallback = [1, 1, 1]) {
+  if (!color) return fallback;
+  let c = color.trim();
+  const normalized = /^#|^rgba?\(/i.test(c) ? c : normalizeWithCanvas(c);
+  if (!normalized) return fallback;
+  c = normalized;
+  if (c[0] === "#") {
+    let hex = c.slice(1);
+    if (!/^(?:[\da-f]{3,4}|[\da-f]{6}|[\da-f]{8})$/i.test(hex)) return fallback;
+    if (hex.length === 3 || hex.length === 4) hex = [...hex.slice(0, 3)].map((h) => h + h).join("");
+    if (hex.length >= 6) {
+      const v = parseInt(hex.slice(0, 6), 16);
+      if (!Number.isNaN(v)) return [(v >> 16 & 255) / 255, (v >> 8 & 255) / 255, (v & 255) / 255];
+    }
+    return fallback;
+  }
+  const m = c.match(/rgba?\(([^)]+)\)/i);
+  if (m) {
+    const parts = m[1].split(/[\s,/]+/).filter(Boolean);
+    const ch = parts.slice(0, 3).map((p) => p.endsWith("%") ? parseFloat(p) / 100 : parseFloat(p) / 255);
+    if (ch.length === 3 && ch.every((v) => Number.isFinite(v))) return ch.map((v) => Math.max(0, Math.min(1, v)));
+  }
+  return fallback;
+}
+function srgbToLinear(c) {
+  return c <= 0.04045 ? c / 12.92 : Math.pow((c + 0.055) / 1.055, 2.4);
+}
+function linearRgb(color, fallback) {
+  const [r, g, b] = parseColor(color, fallback);
+  return [srgbToLinear(r), srgbToLinear(g), srgbToLinear(b)];
+}
+
+// src/bake/edt.ts
+var INF = 1e20;
+function scratch(n) {
+  return { f: new Float64Array(n), z: new Float64Array(n + 1), v: new Int32Array(n) };
+}
+function edt1d(grid, offset, stride, length, s, arg) {
+  const { f: f2, z, v } = s;
+  v[0] = 0;
+  z[0] = -INF;
+  z[1] = INF;
+  f2[0] = grid[offset];
+  for (let q = 1, k = 0; q < length; q++) {
+    f2[q] = grid[offset + q * stride];
+    const q2 = q * q;
+    let sq;
+    do {
+      const r = v[k];
+      sq = (f2[q] - f2[r] + q2 - r * r) / (q - r) / 2;
+    } while (sq <= z[k] && --k > -1);
+    k++;
+    v[k] = q;
+    z[k] = sq;
+    z[k + 1] = INF;
+  }
+  for (let q = 0, k = 0; q < length; q++) {
+    while (z[k + 1] < q) k++;
+    const r = v[k];
+    const qr = q - r;
+    grid[offset + q * stride] = f2[r] + qr * qr;
+    if (arg) arg[offset + q * stride] = r;
+  }
+}
+function edt2dNearest(grid, width, height) {
+  const s = scratch(Math.max(width, height));
+  const rowOf = new Int32Array(width * height);
+  const colOf = new Int32Array(width * height);
+  for (let x = 0; x < width; x++) edt1d(grid, x, width, height, s, rowOf);
+  for (let y = 0; y < height; y++) edt1d(grid, y * width, 1, width, s, colOf);
+  const nearest = new Int32Array(width * height);
+  for (let y = 0; y < height; y++) {
+    const row = y * width;
+    for (let x = 0; x < width; x++) {
+      const sx = colOf[row + x];
+      const sy = rowOf[row + sx];
+      nearest[row + x] = sy * width + sx;
+    }
+  }
+  return nearest;
+}
+function edgeOffset(nx, ny, a) {
+  let gx = Math.abs(nx);
+  let gy = Math.abs(ny);
+  if (gx < gy) {
+    const t = gx;
+    gx = gy;
+    gy = t;
+  }
+  if (gy < 1e-6) return 0.5 - a;
+  const a1 = 0.5 * gy / gx;
+  if (a < a1) return 0.5 * (gx + gy) - Math.sqrt(2 * gx * gy * a);
+  if (a < 1 - a1) return (0.5 - a) * gx;
+  return -0.5 * (gx + gy) + Math.sqrt(2 * gx * gy * (1 - a));
+}
+function signedDistance(coverage, width, height, options = {}) {
+  const insideOnly = options.insideOnly ?? false;
+  const refineSq = (options.refineWithin ?? Infinity) ** 2;
+  const wideSq = Math.min(refineSq, 2304);
+  const n = width * height;
+  const grid = new Float32Array(n);
+  const ex = new Float32Array(n);
+  const ey = new Float32Array(n);
+  const nx = new Float32Array(n);
+  const ny = new Float32Array(n);
+  let seeds = 0;
+  const at = (x, y) => coverage[(y < 0 ? 0 : y >= height ? height - 1 : y) * width + (x < 0 ? 0 : x >= width ? width - 1 : x)];
+  for (let y = 0; y < height; y++) {
+    const interiorRow = y > 0 && y < height - 1;
+    for (let x = 0; x < width; x++) {
+      const i = y * width + x;
+      const a = coverage[i];
+      let boundary;
+      if (a > 0 && a < 1) boundary = true;
+      else if (interiorRow && x > 0 && x < width - 1) {
+        const l = coverage[i - 1];
+        const r = coverage[i + 1];
+        const u = coverage[i - width];
+        const d = coverage[i + width];
+        boundary = a <= 0 ? l >= 1 || r >= 1 || u >= 1 || d >= 1 : l <= 0 || r <= 0 || u <= 0 || d <= 0;
+      } else {
+        boundary = a <= 0 ? Math.max(at(x - 1, y), at(x + 1, y), at(x, y - 1), at(x, y + 1)) >= 1 : Math.min(at(x - 1, y), at(x + 1, y), at(x, y - 1), at(x, y + 1)) <= 0;
+      }
+      if (!boundary) {
+        grid[i] = INF;
+        continue;
+      }
+      grid[i] = 0;
+      seeds++;
+      const gx = at(x + 1, y - 1) + 2 * at(x + 1, y) + at(x + 1, y + 1) - at(x - 1, y - 1) - 2 * at(x - 1, y) - at(x - 1, y + 1);
+      const gy = at(x - 1, y + 1) + 2 * at(x, y + 1) + at(x + 1, y + 1) - at(x - 1, y - 1) - 2 * at(x, y - 1) - at(x + 1, y - 1);
+      const gl = Math.hypot(gx, gy);
+      if (gl > 1e-4) {
+        const ux = gx / gl;
+        const uy = gy / gl;
+        nx[i] = ux;
+        ny[i] = uy;
+        const off = edgeOffset(ux, uy, a);
+        ex[i] = x + ux * off;
+        ey[i] = y + uy * off;
+      } else {
+        ex[i] = x;
+        ey[i] = y;
+      }
+    }
+  }
+  const sd = new Float32Array(n);
+  if (seeds === 0) {
+    const v = coverage[0] >= 0.5 ? width + height : -(width + height);
+    sd.fill(v);
+    return sd;
+  }
+  const isSeed = new Uint8Array(n);
+  for (let i = 0; i < n; i++) isSeed[i] = grid[i] === 0 ? 1 : 0;
+  const nearest = edt2dNearest(grid, width, height);
+  for (let y = 0; y < height; y++) {
+    for (let x = 0; x < width; x++) {
+      const i = y * width + x;
+      if (insideOnly && coverage[i] <= 0) continue;
+      const c = nearest[i];
+      if (grid[i] > refineSq) {
+        const d2 = Math.sqrt(grid[i]);
+        sd[i] = coverage[i] >= 0.5 ? d2 : -d2;
+        continue;
+      }
+      const R = grid[i] < wideSq ? 2 : 1;
+      const cx = c % width;
+      const cy = (c - cx) / width;
+      let s = c;
+      let best = Infinity;
+      for (let oy = -R; oy <= R; oy++) {
+        const yy = cy + oy;
+        if (yy < 0 || yy >= height) continue;
+        for (let ox = -R; ox <= R; ox++) {
+          const xx = cx + ox;
+          if (xx < 0 || xx >= width) continue;
+          const q = yy * width + xx;
+          if (!isSeed[q]) continue;
+          const qx = x - ex[q];
+          const qy = y - ey[q];
+          const d2 = qx * qx + qy * qy;
+          if (d2 < best) {
+            best = d2;
+            s = q;
+          }
+        }
+      }
+      const dx = x - ex[s];
+      const dy = y - ey[s];
+      const d = Math.sqrt(best);
+      const along = dx * nx[s] + dy * ny[s];
+      const inside = d < 1.5 && (nx[s] !== 0 || ny[s] !== 0) ? along >= 0 : coverage[i] >= 0.5;
+      sd[i] = inside ? d : -d;
+    }
+  }
+  return sd;
+}
+function insideDistance(coverage, width, height, refineWithin) {
+  const sd = signedDistance(coverage, width, height, { insideOnly: true, refineWithin });
+  for (let i = 0; i < sd.length; i++) sd[i] = coverage[i] > 0 ? Math.max(0, sd[i]) : 0;
+  return sd;
+}
+
+// src/bake/filters.ts
+function gaussianBlur(src, width, height, sigma) {
+  if (sigma <= 0.01) return src.slice();
+  const radius = Math.max(1, Math.ceil(sigma * 3));
+  const kernel = new Float32Array(radius * 2 + 1);
+  let sum = 0;
+  for (let i = -radius; i <= radius; i++) {
+    const w = Math.exp(-i * i / (2 * sigma * sigma));
+    kernel[i + radius] = w;
+    sum += w;
+  }
+  for (let i = 0; i < kernel.length; i++) kernel[i] /= sum;
+  const tmp = new Float32Array(width * height);
+  const out = new Float32Array(width * height);
+  const taps = kernel.length;
+  for (let y = 0; y < height; y++) {
+    const row = y * width;
+    for (let x = 0; x < width; x++) {
+      let acc = 0;
+      if (x >= radius && x < width - radius) {
+        const start = row + x - radius;
+        for (let k = 0; k < taps; k++) acc += src[start + k] * kernel[k];
+      } else {
+        for (let k = -radius; k <= radius; k++) {
+          const xx = x + k < 0 ? 0 : x + k >= width ? width - 1 : x + k;
+          acc += src[row + xx] * kernel[k + radius];
+        }
+      }
+      tmp[row + x] = acc;
+    }
+  }
+  for (let k = -radius; k <= radius; k++) {
+    const w = kernel[k + radius];
+    for (let y = 0; y < height; y++) {
+      const yy = y + k < 0 ? 0 : y + k >= height ? height - 1 : y + k;
+      const srcRow = yy * width;
+      const dstRow = y * width;
+      for (let x = 0; x < width; x++) out[dstRow + x] += tmp[srcRow + x] * w;
+    }
+  }
+  return out;
+}
+function boxBlurPass(src, dst, width, height, r) {
+  const tmp = new Float32Array(width * height);
+  const inv = 1 / (2 * r + 1);
+  for (let y = 0; y < height; y++) {
+    const row = y * width;
+    let acc = src[row] * (r + 1);
+    for (let k = 1; k <= r; k++) acc += src[row + Math.min(k, width - 1)];
+    for (let x = 0; x < width; x++) {
+      tmp[row + x] = acc * inv;
+      const add = src[row + Math.min(x + r + 1, width - 1)];
+      const sub = src[row + Math.max(x - r, 0)];
+      acc += add - sub;
+    }
+  }
+  for (let x = 0; x < width; x++) {
+    let acc = tmp[x] * (r + 1);
+    for (let k = 1; k <= r; k++) acc += tmp[Math.min(k, height - 1) * width + x];
+    for (let y = 0; y < height; y++) {
+      dst[y * width + x] = acc * inv;
+      const add = tmp[Math.min(y + r + 1, height - 1) * width + x];
+      const sub = tmp[Math.max(y - r, 0) * width + x];
+      acc += add - sub;
+    }
+  }
+}
+function fastBlur(src, width, height, sigma) {
+  if (sigma < 2) return gaussianBlur(src, width, height, sigma);
+  const n = 3;
+  const wIdeal = Math.sqrt(12 * sigma * sigma / n + 1);
+  let wl = Math.floor(wIdeal);
+  if (wl % 2 === 0) wl--;
+  const wu = wl + 2;
+  const m = Math.round((12 * sigma * sigma - n * wl * wl - 4 * n * wl - 3 * n) / (-4 * wl - 4));
+  let a = src.slice();
+  let b = new Float32Array(width * height);
+  for (let i = 0; i < n; i++) {
+    const size = i < m ? wl : wu;
+    boxBlurPass(a, b, width, height, size - 1 >> 1);
+    const t = a;
+    a = b;
+    b = t;
+  }
+  return a;
+}
+function maskedBlur(value, mask, width, height, sigma) {
+  const n = width * height;
+  const weighted = new Float32Array(n);
+  for (let i = 0; i < n; i++) weighted[i] = value[i] * mask[i];
+  const num2 = fastBlur(weighted, width, height, sigma);
+  const den = fastBlur(mask, width, height, sigma);
+  const out = new Float32Array(n);
+  for (let i = 0; i < n; i++) out[i] = den[i] > 1e-4 ? num2[i] / den[i] : value[i];
+  return out;
+}
+function sampleBilinear(src, width, height, x, y) {
+  x = x < 0 ? 0 : x > width - 1 ? width - 1 : x;
+  y = y < 0 ? 0 : y > height - 1 ? height - 1 : y;
+  const x0 = Math.floor(x);
+  const y0 = Math.floor(y);
+  const x1 = x0 + 1 < width ? x0 + 1 : x0;
+  const y1 = y0 + 1 < height ? y0 + 1 : y0;
+  const fx = x - x0;
+  const fy = y - y0;
+  const a = src[y0 * width + x0];
+  const b = src[y0 * width + x1];
+  const c = src[y1 * width + x0];
+  const d = src[y1 * width + x1];
+  return (a + (b - a) * fx) * (1 - fy) + (c + (d - c) * fx) * fy;
+}
+
+// src/bake/bake.ts
+var TUBE_ASPECT = 0.6;
+function profileCurve(t, kind) {
+  if (t <= 0) return 0;
+  if (t >= 1) return 1;
+  if (kind === 0) {
+    const u = 1 - t;
+    return Math.sqrt(1 - u * u);
+  }
+  if (kind === 1) return Math.sin(t * Math.PI / 2);
+  return t;
+}
+function channel(src, c, n) {
+  const out = new Float32Array(n);
+  for (let i = 0; i < n; i++) out[i] = src[i * 4 + c] / 255;
+  return out;
+}
+function fillHoles(union, size) {
+  const n = size * size;
+  const outside = new Uint8Array(n);
+  const stack = new Int32Array(n);
+  let sp = 0;
+  const seed = (i) => {
+    if (!outside[i] && union[i] < 0.5) {
+      outside[i] = 1;
+      stack[sp++] = i;
+    }
+  };
+  for (let x = 0; x < size; x++) {
+    seed(x);
+    seed((size - 1) * size + x);
+  }
+  for (let y = 0; y < size; y++) {
+    seed(y * size);
+    seed(y * size + size - 1);
+  }
+  while (sp > 0) {
+    const i = stack[--sp];
+    const x = i % size;
+    if (x > 0) seed(i - 1);
+    if (x < size - 1) seed(i + 1);
+    if (i >= size) seed(i - size);
+    if (i < n - size) seed(i + size);
+  }
+  const out = new Float32Array(n);
+  for (let i = 0; i < n; i++) {
+    if (outside[i]) {
+      out[i] = union[i];
+      continue;
+    }
+    const x = i % size;
+    const touchesOutside = x > 0 && outside[i - 1] || x < size - 1 && outside[i + 1] || i >= size && outside[i - size] || i < n - size && outside[i + size];
+    out[i] = touchesOutside ? union[i] : 1;
+  }
+  return out;
+}
+function localHalfWidth(dist, mask, wire, size, bevelPx) {
+  const n = size * size;
+  const out = new Float32Array(n);
+  const wireCap = size * 0.15;
+  const step = 0.75;
+  for (let y = 0; y < size; y++) {
+    for (let x = 0; x < size; x++) {
+      const i = y * size + x;
+      if (mask[i] <= 0.01) continue;
+      const d0 = dist[i];
+      const cap = wire[i] >= mask[i] * 0.5 ? wireCap : bevelPx * 1.05;
+      const gx = (dist[x < size - 1 ? i + 1 : i] - dist[x > 0 ? i - 1 : i]) * 0.5;
+      const gy = (dist[y < size - 1 ? i + size : i] - dist[y > 0 ? i - size : i]) * 0.5;
+      const gl = Math.hypot(gx, gy);
+      if (gl < 0.2) {
+        out[i] = d0;
+        continue;
+      }
+      const ux = gx / gl * step;
+      const uy = gy / gl * step;
+      let px = x;
+      let py = y;
+      let prev = d0;
+      let best = d0;
+      const maxSteps = Math.ceil(cap / step) + 2;
+      for (let s = 0; s < maxSteps && best < cap; s++) {
+        px += ux;
+        py += uy;
+        const v = sampleBilinear(dist, size, size, px, py);
+        if (v <= prev + 1e-3) break;
+        prev = v;
+        best = v;
+      }
+      out[i] = best;
+    }
+  }
+  return out;
+}
+function bake(input) {
+  const { size, params } = input;
+  const n = size * size;
+  const kind = params.profile;
+  const rimPx = params.rim * size;
+  const bevelPx = Math.max(1, params.bevel * size);
+  const edgePx = Math.max(1, params.edge * size);
+  const domePx = Math.max(1, params.domeWidth * size);
+  const floor = params.floor;
+  const wire = channel(input.roles, 0, n);
+  const raisedF = channel(input.roles, 1, n);
+  const inset = channel(input.roles, 2, n);
+  const flat = channel(input.slotsA, 0, n);
+  const accent = channel(input.slotsA, 1, n);
+  const base = channel(input.slotsA, 2, n);
+  const metal2 = channel(input.slotsB, 0, n);
+  const enamel = channel(input.slotsB, 1, n);
+  const union = new Float32Array(n);
+  for (let i = 0; i < n; i++) union[i] = Math.min(1, wire[i] + raisedF[i] + inset[i] + flat[i]);
+  const silhouette = params.fillHoles ? fillHoles(union, size) : union;
+  const backplate = new Float32Array(n);
+  for (let i = 0; i < n; i++) backplate[i] = Math.max(0, silhouette[i] - union[i]);
+  const sd = signedDistance(silhouette, size, size, { refineWithin: Math.max(edgePx, rimPx) * 2 + 8 });
+  if (rimPx > 0.5) {
+    for (let i = 0; i < n; i++) {
+      if (silhouette[i] <= 0) continue;
+      const band = Math.min(silhouette[i], Math.max(0, Math.min(1, rimPx + 0.5 - sd[i])));
+      if (band <= 0) continue;
+      const keep = 1 - band;
+      wire[i] = Math.max(wire[i], band);
+      raisedF[i] *= keep;
+      inset[i] *= keep;
+      flat[i] *= keep;
+      backplate[i] *= keep;
+      metal2[i] = Math.max(metal2[i], band);
+      enamel[i] *= keep;
+      base[i] *= keep;
+      accent[i] *= keep;
+    }
+  }
+  const up = new Float32Array(n);
+  for (let i = 0; i < n; i++) up[i] = Math.min(1, wire[i] + raisedF[i]);
+  const dUp = insideDistance(up, size, size, size * 0.16);
+  const dIn = maskedBlur(insideDistance(inset, size, size, domePx * 1.5), inset, size, size, Math.max(1, domePx * 0.3));
+  const wLocal = maskedBlur(localHalfWidth(dUp, up, wire, size, bevelPx), up, size, size, 3 * size / 512);
+  const ridge = [];
+  for (let i = 0; i < n; i++) {
+    if (wire[i] > 0.5 && dUp[i] > 0.75 * wLocal[i] && wLocal[i] > 0.5) ridge.push(wLocal[i]);
+  }
+  ridge.sort((a, b) => a - b);
+  const wMedian = ridge.length > 8 ? ridge[ridge.length >> 1] : 0;
+  const tubeScale = wMedian > 0 ? TUBE_ASPECT * wMedian / size / Math.max(0.05, 1 - floor) : Infinity;
+  const heightScale = Math.max(params.depth * 0.2, Math.min(params.depth, tubeScale));
+  const tubeRef = wMedian > 0 ? heightScale * size * Math.max(0.05, 1 - floor) / TUBE_ASPECT : Infinity;
+  let h = new Float32Array(n);
+  let covered = 0;
+  for (let i = 0; i < n; i++) {
+    if (silhouette[i] <= 0) continue;
+    covered += silhouette[i];
+    const e = sd[i] <= 0 ? 0 : profileCurve(sd[i] / edgePx, 0);
+    const body = floor * e;
+    const cu = up[i];
+    const ci = inset[i];
+    const cf = flat[i] + backplate[i];
+    const total = cu + ci + cf;
+    if (total < 1e-4) {
+      h[i] = body;
+      continue;
+    }
+    let acc = cf * body;
+    if (cu > 0) {
+      const wf = Math.min(1, wire[i] / Math.max(cu, 1e-4));
+      const wl = Math.max(0.75, wLocal[i]);
+      const wEff = Math.max(0.75, wf * wl + (1 - wf) * Math.min(bevelPx, wl));
+      const t = dUp[i] / wEff;
+      const rise = wf * Math.min(1, wl / tubeRef) + (1 - wf);
+      acc += cu * (body + (1 - body) * rise * profileCurve(t, kind));
+    }
+    if (ci > 0) {
+      const t = Math.min(1, dIn[i] / domePx);
+      const dome = 1 - (1 - t) * (1 - t);
+      acc += ci * (body + e * (params.enamelLevel + params.enamelDome * dome));
+    }
+    h[i] = acc / total;
+  }
+  const scale = size / 512;
+  h = gaussianBlur(h, size, size, params.smoothing * scale);
+  const near = fastBlur(h, size, size, Math.max(1, size * 8e-3));
+  const far = fastBlur(h, size, size, Math.max(2, size * 0.03));
+  const surface = new Float32Array(n * 4);
+  const cavity = new Float32Array(n);
+  for (let y = 0; y < size; y++) {
+    for (let x = 0; x < size; x++) {
+      const i = y * size + x;
+      const gx = (h[x < size - 1 ? i + 1 : i] - h[x > 0 ? i - 1 : i]) * 0.5;
+      const gy = (h[y < size - 1 ? i + size : i] - h[y > 0 ? i - size : i]) * 0.5;
+      surface[i * 4] = h[i];
+      surface[i * 4 + 1] = gx;
+      surface[i * 4 + 2] = gy;
+      surface[i * 4 + 3] = sd[i];
+      cavity[i] = Math.min(1, Math.max(0, near[i] - h[i]) * 2.2 + Math.max(0, far[i] - h[i]) * 1.1);
+    }
+  }
+  const albedo = new Uint8Array(n * 4);
+  const seeds = new Float32Array(n);
+  let seedCount = 0;
+  for (let i = 0; i < n; i++) {
+    const opaque = input.albedo[i * 4 + 3] >= 128;
+    seeds[i] = opaque ? 0 : INF;
+    if (opaque) seedCount++;
+  }
+  const nearest = seedCount > 0 ? edt2dNearest(seeds, size, size) : null;
+  for (let i = 0; i < n; i++) {
+    const src = input.albedo[i * 4 + 3] >= 128 || !nearest ? i : nearest[i];
+    if (nearest || input.albedo[i * 4 + 3] > 0) {
+      albedo[i * 4] = input.albedo[src * 4];
+      albedo[i * 4 + 1] = input.albedo[src * 4 + 1];
+      albedo[i * 4 + 2] = input.albedo[src * 4 + 2];
+    } else {
+      albedo[i * 4] = albedo[i * 4 + 1] = albedo[i * 4 + 2] = 255;
+    }
+    albedo[i * 4 + 3] = Math.round(cavity[i] * 255);
+  }
+  const weights = new Uint8Array(n * 4);
+  for (let i = 0; i < n; i++) {
+    const m = metal2[i];
+    const en = enamel[i];
+    const b = base[i] + backplate[i];
+    const a = accent[i];
+    const sum = m + en + b + a;
+    if (sum > 1e-3) {
+      const inv = 255 / sum;
+      weights[i * 4] = Math.round(m * inv);
+      weights[i * 4 + 1] = Math.round(en * inv);
+      weights[i * 4 + 2] = Math.round(b * inv);
+      weights[i * 4 + 3] = Math.round(a * inv);
+    } else if (silhouette[i] > 0) {
+      weights[i * 4 + 2] = 255;
+    }
+  }
+  return { size, surface, albedo, weights, heightScale, coverage: covered / n };
+}
+
+// src/bake/worker-code.generated.ts
+var worker_code_generated_default = '"use strict";(()=>{function An(a){return{f:new Float64Array(a),z:new Float64Array(a+1),v:new Int32Array(a)}}function cn(a,n,e,t,c,u){let{f:m,z:f,v:s}=c;s[0]=0,f[0]=-1e20,f[1]=1e20,m[0]=a[n];for(let l=1,r=0;l<t;l++){m[l]=a[n+l*e];let b=l*l,x;do{let d=s[r];x=(m[l]-m[d]+b-d*d)/(l-d)/2}while(x<=f[r]&&--r>-1);r++,s[r]=l,f[r]=x,f[r+1]=1e20}for(let l=0,r=0;l<t;l++){for(;f[r+1]<l;)r++;let b=s[r],x=l-b;a[n+l*e]=m[b]+x*x,u&&(u[n+l*e]=b)}}function nn(a,n,e){let t=An(Math.max(n,e)),c=new Int32Array(n*e),u=new Int32Array(n*e);for(let f=0;f<n;f++)cn(a,f,n,e,t,c);for(let f=0;f<e;f++)cn(a,f*n,1,n,t,u);let m=new Int32Array(n*e);for(let f=0;f<e;f++){let s=f*n;for(let l=0;l<n;l++){let r=u[s+l],b=c[s+r];m[s+l]=b*n+r}}return m}function Mn(a,n,e){let t=Math.abs(a),c=Math.abs(n);if(t<c){let m=t;t=c,c=m}if(c<1e-6)return .5-e;let u=.5*c/t;return e<u?.5*(t+c)-Math.sqrt(2*t*c*e):e<1-u?(.5-e)*t:-.5*(t+c)+Math.sqrt(2*t*c*(1-e))}function tn(a,n,e,t={}){let c=t.insideOnly??!1,u=(t.refineWithin??1/0)**2,m=Math.min(u,2304),f=n*e,s=new Float32Array(f),l=new Float32Array(f),r=new Float32Array(f),b=new Float32Array(f),x=new Float32Array(f),d=0,A=(y,I)=>a[(I<0?0:I>=e?e-1:I)*n+(y<0?0:y>=n?n-1:y)];for(let y=0;y<e;y++){let I=y>0&&y<e-1;for(let i=0;i<n;i++){let F=y*n+i,B=a[F],O;if(B>0&&B<1)O=!0;else if(I&&i>0&&i<n-1){let U=a[F-1],W=a[F+1],D=a[F-n],j=a[F+n];O=B<=0?U>=1||W>=1||D>=1||j>=1:U<=0||W<=0||D<=0||j<=0}else O=B<=0?Math.max(A(i-1,y),A(i+1,y),A(i,y-1),A(i,y+1))>=1:Math.min(A(i-1,y),A(i+1,y),A(i,y-1),A(i,y+1))<=0;if(!O){s[F]=1e20;continue}s[F]=0,d++;let E=A(i+1,y-1)+2*A(i+1,y)+A(i+1,y+1)-A(i-1,y-1)-2*A(i-1,y)-A(i-1,y+1),q=A(i-1,y+1)+2*A(i,y+1)+A(i+1,y+1)-A(i-1,y-1)-2*A(i,y-1)-A(i+1,y-1),v=Math.hypot(E,q);if(v>1e-4){let U=E/v,W=q/v;b[F]=U,x[F]=W;let D=Mn(U,W,B);l[F]=i+U*D,r[F]=y+W*D}else l[F]=i,r[F]=y}}let k=new Float32Array(f);if(d===0){let y=a[0]>=.5?n+e:-(n+e);return k.fill(y),k}let P=new Uint8Array(f);for(let y=0;y<f;y++)P[y]=s[y]===0?1:0;let _=nn(s,n,e);for(let y=0;y<e;y++)for(let I=0;I<n;I++){let i=y*n+I;if(c&&a[i]<=0)continue;let F=_[i];if(s[i]>u){let R=Math.sqrt(s[i]);k[i]=a[i]>=.5?R:-R;continue}let B=s[i]<m?2:1,O=F%n,E=(F-O)/n,q=F,v=1/0;for(let R=-B;R<=B;R++){let K=E+R;if(!(K<0||K>=e))for(let Q=-B;Q<=B;Q++){let V=O+Q;if(V<0||V>=n)continue;let C=K*n+V;if(!P[C])continue;let X=I-l[C],N=y-r[C],Y=X*X+N*N;Y<v&&(v=Y,q=C)}}let U=I-l[q],W=y-r[q],D=Math.sqrt(v),j=U*b[q]+W*x[q],S=D<1.5&&(b[q]!==0||x[q]!==0)?j>=0:a[i]>=.5;k[i]=S?D:-D}return k}function on(a,n,e,t){let c=tn(a,n,e,{insideOnly:!0,refineWithin:t});for(let u=0;u<c.length;u++)c[u]=a[u]>0?Math.max(0,c[u]):0;return c}function en(a,n,e,t){if(t<=.01)return a.slice();let c=Math.max(1,Math.ceil(t*3)),u=new Float32Array(c*2+1),m=0;for(let r=-c;r<=c;r++){let b=Math.exp(-r*r/(2*t*t));u[r+c]=b,m+=b}for(let r=0;r<u.length;r++)u[r]/=m;let f=new Float32Array(n*e),s=new Float32Array(n*e),l=u.length;for(let r=0;r<e;r++){let b=r*n;for(let x=0;x<n;x++){let d=0;if(x>=c&&x<n-c){let A=b+x-c;for(let k=0;k<l;k++)d+=a[A+k]*u[k]}else for(let A=-c;A<=c;A++){let k=x+A<0?0:x+A>=n?n-1:x+A;d+=a[b+k]*u[A+c]}f[b+x]=d}}for(let r=-c;r<=c;r++){let b=u[r+c];for(let x=0;x<e;x++){let A=(x+r<0?0:x+r>=e?e-1:x+r)*n,k=x*n;for(let P=0;P<n;P++)s[k+P]+=f[A+P]*b}}return s}function Fn(a,n,e,t,c){let u=new Float32Array(e*t),m=1/(2*c+1);for(let f=0;f<t;f++){let s=f*e,l=a[s]*(c+1);for(let r=1;r<=c;r++)l+=a[s+Math.min(r,e-1)];for(let r=0;r<e;r++){u[s+r]=l*m;let b=a[s+Math.min(r+c+1,e-1)],x=a[s+Math.max(r-c,0)];l+=b-x}}for(let f=0;f<e;f++){let s=u[f]*(c+1);for(let l=1;l<=c;l++)s+=u[Math.min(l,t-1)*e+f];for(let l=0;l<t;l++){n[l*e+f]=s*m;let r=u[Math.min(l+c+1,t-1)*e+f],b=u[Math.max(l-c,0)*e+f];s+=r-b}}}function g(a,n,e,t){if(t<2)return en(a,n,e,t);let c=3,u=Math.sqrt(12*t*t/c+1),m=Math.floor(u);m%2===0&&m--;let f=m+2,s=Math.round((12*t*t-c*m*m-4*c*m-3*c)/(-4*m-4)),l=a.slice(),r=new Float32Array(n*e);for(let b=0;b<c;b++){let x=b<s?m:f;Fn(l,r,n,e,x-1>>1);let d=l;l=r,r=d}return l}function rn(a,n,e,t,c){let u=e*t,m=new Float32Array(u);for(let r=0;r<u;r++)m[r]=a[r]*n[r];let f=g(m,e,t,c),s=g(n,e,t,c),l=new Float32Array(u);for(let r=0;r<u;r++)l[r]=s[r]>1e-4?f[r]/s[r]:a[r];return l}function ln(a,n,e,t,c){t=t<0?0:t>n-1?n-1:t,c=c<0?0:c>e-1?e-1:c;let u=Math.floor(t),m=Math.floor(c),f=u+1<n?u+1:u,s=m+1<e?m+1:m,l=t-u,r=c-m,b=a[m*n+u],x=a[m*n+f],d=a[s*n+u],A=a[s*n+f];return(b+(x-b)*l)*(1-r)+(d+(A-d)*l)*r}var fn=.6;function un(a,n){if(a<=0)return 0;if(a>=1)return 1;if(n===0){let e=1-a;return Math.sqrt(1-e*e)}return n===1?Math.sin(a*Math.PI/2):a}function L(a,n,e){let t=new Float32Array(e);for(let c=0;c<e;c++)t[c]=a[c*4+n]/255;return t}function dn(a,n){let e=n*n,t=new Uint8Array(e),c=new Int32Array(e),u=0,m=s=>{!t[s]&&a[s]<.5&&(t[s]=1,c[u++]=s)};for(let s=0;s<n;s++)m(s),m((n-1)*n+s);for(let s=0;s<n;s++)m(s*n),m(s*n+n-1);for(;u>0;){let s=c[--u],l=s%n;l>0&&m(s-1),l<n-1&&m(s+1),s>=n&&m(s-n),s<e-n&&m(s+n)}let f=new Float32Array(e);for(let s=0;s<e;s++){if(t[s]){f[s]=a[s];continue}let l=s%n,r=l>0&&t[s-1]||l<n-1&&t[s+1]||s>=n&&t[s-n]||s<e-n&&t[s+n];f[s]=r?a[s]:1}return f}function In(a,n,e,t,c){let u=t*t,m=new Float32Array(u),f=t*.15,s=.75;for(let l=0;l<t;l++)for(let r=0;r<t;r++){let b=l*t+r;if(n[b]<=.01)continue;let x=a[b],d=e[b]>=n[b]*.5?f:c*1.05,A=(a[r<t-1?b+1:b]-a[r>0?b-1:b])*.5,k=(a[l<t-1?b+t:b]-a[l>0?b-t:b])*.5,P=Math.hypot(A,k);if(P<.2){m[b]=x;continue}let _=A/P*s,y=k/P*s,I=r,i=l,F=x,B=x,O=Math.ceil(d/s)+2;for(let E=0;E<O&&B<d;E++){I+=_,i+=y;let q=ln(a,t,t,I,i);if(q<=F+.001)break;F=q,B=q}m[b]=B}return m}function mn(a){let{size:n,params:e}=a,t=n*n,c=e.profile,u=e.rim*n,m=Math.max(1,e.bevel*n),f=Math.max(1,e.edge*n),s=Math.max(1,e.domeWidth*n),l=e.floor,r=L(a.roles,0,t),b=L(a.roles,1,t),x=L(a.roles,2,t),d=L(a.slotsA,0,t),A=L(a.slotsA,1,t),k=L(a.slotsA,2,t),P=L(a.slotsB,0,t),_=L(a.slotsB,1,t),y=new Float32Array(t);for(let o=0;o<t;o++)y[o]=Math.min(1,r[o]+b[o]+x[o]+d[o]);let I=e.fillHoles?dn(y,n):y,i=new Float32Array(t);for(let o=0;o<t;o++)i[o]=Math.max(0,I[o]-y[o]);let F=tn(I,n,n,{refineWithin:Math.max(f,u)*2+8});if(u>.5)for(let o=0;o<t;o++){if(I[o]<=0)continue;let p=Math.min(I[o],Math.max(0,Math.min(1,u+.5-F[o])));if(p<=0)continue;let M=1-p;r[o]=Math.max(r[o],p),b[o]*=M,x[o]*=M,d[o]*=M,i[o]*=M,P[o]=Math.max(P[o],p),_[o]*=M,k[o]*=M,A[o]*=M}let B=new Float32Array(t);for(let o=0;o<t;o++)B[o]=Math.min(1,r[o]+b[o]);let O=on(B,n,n,n*.16),E=rn(on(x,n,n,s*1.5),x,n,n,Math.max(1,s*.3)),q=rn(In(O,B,r,n,m),B,n,n,3*n/512),v=[];for(let o=0;o<t;o++)r[o]>.5&&O[o]>.75*q[o]&&q[o]>.5&&v.push(q[o]);v.sort((o,p)=>o-p);let U=v.length>8?v[v.length>>1]:0,W=U>0?fn*U/n/Math.max(.05,1-l):1/0,D=Math.max(e.depth*.2,Math.min(e.depth,W)),j=U>0?D*n*Math.max(.05,1-l)/fn:1/0,S=new Float32Array(t),R=0;for(let o=0;o<t;o++){if(I[o]<=0)continue;R+=I[o];let p=F[o]<=0?0:un(F[o]/f,0),M=l*p,H=B[o],w=x[o],Z=d[o]+i[o],T=H+w+Z;if(T<1e-4){S[o]=M;continue}let z=Z*M;if(H>0){let G=Math.min(1,r[o]/Math.max(H,1e-4)),$=Math.max(.75,q[o]),yn=Math.max(.75,G*$+(1-G)*Math.min(m,$)),bn=O[o]/yn,xn=G*Math.min(1,$/j)+(1-G);z+=H*(M+(1-M)*xn*un(bn,c))}if(w>0){let G=Math.min(1,E[o]/s),$=1-(1-G)*(1-G);z+=w*(M+p*(e.enamelLevel+e.enamelDome*$))}S[o]=z/T}let K=n/512;S=en(S,n,n,e.smoothing*K);let Q=g(S,n,n,Math.max(1,n*.008)),V=g(S,n,n,Math.max(2,n*.03)),C=new Float32Array(t*4),X=new Float32Array(t);for(let o=0;o<n;o++)for(let p=0;p<n;p++){let M=o*n+p,H=(S[p<n-1?M+1:M]-S[p>0?M-1:M])*.5,w=(S[o<n-1?M+n:M]-S[o>0?M-n:M])*.5;C[M*4]=S[M],C[M*4+1]=H,C[M*4+2]=w,C[M*4+3]=F[M],X[M]=Math.min(1,Math.max(0,Q[M]-S[M])*2.2+Math.max(0,V[M]-S[M])*1.1)}let N=new Uint8Array(t*4),Y=new Float32Array(t),sn=0;for(let o=0;o<t;o++){let p=a.albedo[o*4+3]>=128;Y[o]=p?0:1e20,p&&sn++}let h=sn>0?nn(Y,n,n):null;for(let o=0;o<t;o++){let p=a.albedo[o*4+3]>=128||!h?o:h[o];h||a.albedo[o*4+3]>0?(N[o*4]=a.albedo[p*4],N[o*4+1]=a.albedo[p*4+1],N[o*4+2]=a.albedo[p*4+2]):N[o*4]=N[o*4+1]=N[o*4+2]=255,N[o*4+3]=Math.round(X[o]*255)}let J=new Uint8Array(t*4);for(let o=0;o<t;o++){let p=P[o],M=_[o],H=k[o]+i[o],w=A[o],Z=p+M+H+w;if(Z>.001){let T=255/Z;J[o*4]=Math.round(p*T),J[o*4+1]=Math.round(M*T),J[o*4+2]=Math.round(H*T),J[o*4+3]=Math.round(w*T)}else I[o]>0&&(J[o*4+2]=255)}return{size:n,surface:C,albedo:N,weights:J,heightScale:D,coverage:R/t}}var an=self;an.onmessage=a=>{let{id:n,input:e}=a.data;try{let t=mn(e);an.postMessage({id:n,out:t},[t.surface.buffer,t.albedo.buffer,t.weights.buffer])}catch(t){an.postMessage({id:n,error:t instanceof Error?t.message:String(t)})}};})();\n';
+
+// src/bake/client.ts
+var MAX_WORKERS = 3;
+var workers = [];
+var workerUrl = null;
+var workersUnavailable = false;
+var nextId = 1;
+function runOnMainThread(job) {
+  try {
+    job.resolve(bake(job.input));
+  } catch (error) {
+    job.reject(error instanceof Error ? error : new Error(String(error)));
+  }
+}
+function disablePool() {
+  workersUnavailable = true;
+  const orphaned = workers.flatMap((w) => [...w.jobs.values()]);
+  for (const w of workers) w.worker.terminate();
+  workers = [];
+  if (workerUrl) URL.revokeObjectURL(workerUrl);
+  workerUrl = null;
+  orphaned.forEach(runOnMainThread);
+}
+function spawn() {
+  try {
+    if (!workerUrl) workerUrl = URL.createObjectURL(new Blob([worker_code_generated_default], { type: "text/javascript" }));
+    const entry = { worker: new Worker(workerUrl), jobs: /* @__PURE__ */ new Map() };
+    entry.worker.onmessage = (event) => {
+      const { id, out, error } = event.data;
+      const job = entry.jobs.get(id);
+      if (!job) return;
+      entry.jobs.delete(id);
+      if (out) job.resolve(out);
+      else job.reject(new Error(error ?? "bake failed"));
+    };
+    entry.worker.onerror = (event) => {
+      event.preventDefault();
+      disablePool();
+    };
+    return entry;
+  } catch {
+    disablePool();
+    return null;
+  }
+}
+function pickWorker() {
+  if (workersUnavailable || typeof Worker === "undefined" || typeof Blob === "undefined") return null;
+  const limit = Math.min(MAX_WORKERS, Math.max(1, (navigator.hardwareConcurrency || 2) - 1));
+  const idle = workers.find((w) => w.jobs.size === 0);
+  if (idle) return idle;
+  if (workers.length < limit) {
+    const fresh = spawn();
+    if (fresh) {
+      workers.push(fresh);
+      return fresh;
+    }
+  }
+  return workers.reduce((a, w) => !a || w.jobs.size < a.jobs.size ? w : a, null);
+}
+function bakeAsync(input) {
+  return new Promise((resolve, reject) => {
+    const job = { input, resolve, reject };
+    const entry = pickWorker();
+    if (!entry) {
+      setTimeout(() => runOnMainThread(job), 0);
+      return;
+    }
+    const id = nextId++;
+    entry.jobs.set(id, job);
+    const copy = {
+      ...input,
+      roles: input.roles.slice(),
+      slotsA: input.slotsA.slice(),
+      slotsB: input.slotsB.slice(),
+      albedo: input.albedo.slice()
+    };
+    try {
+      entry.worker.postMessage({ id, input: copy }, [
+        copy.roles.buffer,
+        copy.slotsA.buffer,
+        copy.slotsB.buffer,
+        copy.albedo.buffer
+      ]);
+    } catch {
+      disablePool();
+    }
+  });
+}
+
+// src/svg/prepare.ts
+var SVG_NS = "http://www.w3.org/2000/svg";
+var XLINK_NS = "http://www.w3.org/1999/xlink";
+var SHAPES = /* @__PURE__ */ new Set(["path", "rect", "circle", "ellipse", "line", "polyline", "polygon", "text", "tspan", "textPath", "image"]);
+var NON_RENDERED = "defs,clipPath,mask,pattern,marker,symbol,linearGradient,radialGradient,filter,foreignObject,style,title,desc,metadata,script";
+function ensureNamespaces(source) {
+  return source.replace(/<svg\b[^>]*>/i, (tag) => {
+    let out = tag;
+    if (!/\sxmlns\s*=/.test(out)) out = out.replace(/<svg/i, `<svg xmlns="${SVG_NS}"`);
+    if (/xlink:/.test(source) && !/xmlns:xlink\s*=/.test(out)) out = out.replace(/<svg/i, `<svg xmlns:xlink="${XLINK_NS}"`);
+    return out;
+  });
+}
+function parseSvg(source) {
+  const doc = new DOMParser().parseFromString(ensureNamespaces(source), "image/svg+xml");
+  const root = doc.documentElement;
+  if (!root || root.localName !== "svg" || root.namespaceURI !== SVG_NS || doc.getElementsByTagName("parsererror").length > 0) {
+    throw new Error("badgecraft: the input is not a valid SVG document");
+  }
+  for (const el of [root, ...root.querySelectorAll("*")]) {
+    if (el.namespaceURI !== SVG_NS || ["script", "foreignObject", "animate", "animateMotion", "animateTransform", "set", "discard"].includes(el.localName)) {
+      el.remove();
+      continue;
+    }
+    for (const attr of [...el.attributes]) {
+      if (/^on/i.test(attr.localName)) el.removeAttributeNode(attr);
+      else if (attr.localName === "href") {
+        const value = attr.value.trim();
+        const embeddedImage = el.localName === "image" && /^data:image\//i.test(value);
+        if (!value.startsWith("#") && !embeddedImage) el.removeAttributeNode(attr);
+      }
+    }
+  }
+  return root;
+}
+function readViewBox(svg) {
+  const vb = svg.getAttribute("viewBox");
+  if (vb) {
+    const p = vb.trim().split(/[\s,]+/).map(Number);
+    if (p.length === 4 && p.every(Number.isFinite) && p[2] > 0 && p[3] > 0) return p;
+  }
+  const w = svg.getAttribute("width");
+  const h = svg.getAttribute("height");
+  if (w && h && !w.includes("%") && !h.includes("%")) {
+    const pw = parseFloat(w);
+    const ph = parseFloat(h);
+    if (pw > 0 && ph > 0) return [0, 0, pw, ph];
+  }
+  return null;
+}
+function hrefOf(el) {
+  return el.getAttribute("href") ?? el.getAttributeNS(XLINK_NS, "href");
+}
+function inlineUses(root) {
+  for (let pass = 0; pass < 4; pass++) {
+    const uses = [...root.getElementsByTagNameNS(SVG_NS, "use")].filter((u) => !u.closest(NON_RENDERED));
+    if (uses.length === 0) return;
+    for (const use of uses) {
+      const href = hrefOf(use);
+      const target = href?.startsWith("#") ? [...root.querySelectorAll("[id]")].find((el) => el.id === href.slice(1)) : null;
+      if (!target || target.contains(use)) {
+        use.remove();
+        continue;
+      }
+      const doc = use.ownerDocument;
+      const x = use.getAttribute("x") ?? "0";
+      const y = use.getAttribute("y") ?? "0";
+      const group = doc.createElementNS(SVG_NS, "g");
+      for (const attr of [...use.attributes]) {
+        if (["href", "xlink:href", "x", "y", "width", "height", "transform"].includes(attr.name)) continue;
+        group.setAttribute(attr.name, attr.value);
+      }
+      const transform = `${use.getAttribute("transform") ?? ""} translate(${x} ${y})`.trim();
+      group.setAttribute("transform", transform);
+      if (target.localName === "symbol") {
+        const inner = doc.createElementNS(SVG_NS, "svg");
+        inner.setAttribute("width", use.getAttribute("width") ?? target.getAttribute("width") ?? "100%");
+        inner.setAttribute("height", use.getAttribute("height") ?? target.getAttribute("height") ?? "100%");
+        for (const name of ["viewBox", "preserveAspectRatio"]) {
+          const v = target.getAttribute(name);
+          if (v) inner.setAttribute(name, v);
+        }
+        inner.setAttribute("overflow", "visible");
+        for (const child of [...target.childNodes]) inner.appendChild(child.cloneNode(true));
+        group.appendChild(inner);
+      } else {
+        const copy = target.cloneNode(true);
+        copy.removeAttribute("id");
+        group.appendChild(copy);
+      }
+      use.replaceWith(group);
+    }
+  }
+}
+function composeFrame(user, userBox, frame) {
+  const doc = user.ownerDocument;
+  const root = doc.createElementNS(SVG_NS, "svg");
+  root.setAttribute("viewBox", "0 0 100 100");
+  const d = frame.path ?? framePaths[frame.shape ?? "circle"] ?? framePaths.circle;
+  const plate = doc.createElementNS(SVG_NS, "path");
+  plate.setAttribute("d", d);
+  plate.setAttribute("fill", "#000");
+  plate.setAttribute("data-relief", "flat");
+  plate.setAttribute("data-material", frame.material ?? "base");
+  plate.setAttribute("data-mb-frame", "");
+  root.appendChild(plate);
+  if (frame.innerRing && frame.innerRing > 0) {
+    const width = frame.innerRing * 100;
+    const s = 0.84;
+    const ring = doc.createElementNS(SVG_NS, "path");
+    ring.setAttribute("d", d);
+    ring.setAttribute("fill", "none");
+    ring.setAttribute("stroke", "#fff");
+    ring.setAttribute("stroke-width", String(width / s));
+    ring.setAttribute("stroke-linejoin", "round");
+    ring.setAttribute("transform", `translate(50 50) scale(${s}) translate(-50 -50)`);
+    ring.setAttribute("data-material", "metal");
+    ring.setAttribute("data-mb-frame", "");
+    root.appendChild(ring);
+  }
+  const pad = Math.min(0.45, Math.max(0, frame.padding ?? 0.22)) * 100;
+  const inner = doc.createElementNS(SVG_NS, "svg");
+  for (const attr of [...user.attributes]) {
+    if (/^(xmlns(:.*)?|width|height|x|y|viewBox|preserveAspectRatio|version|baseProfile)$/.test(attr.name)) continue;
+    inner.setAttribute(attr.name, attr.value);
+  }
+  inner.setAttribute("x", String(pad));
+  inner.setAttribute("y", String(pad));
+  inner.setAttribute("width", String(100 - 2 * pad));
+  inner.setAttribute("height", String(100 - 2 * pad));
+  inner.setAttribute("viewBox", userBox.join(" "));
+  inner.setAttribute("preserveAspectRatio", "xMidYMid meet");
+  inner.setAttribute("overflow", "visible");
+  while (user.firstChild) inner.appendChild(user.firstChild);
+  root.appendChild(inner);
+  return root;
+}
+function attrUp(el, name) {
+  return el.closest(`[${name}]`)?.getAttribute(name) ?? null;
+}
+var defaultSlot = { wire: "metal", raised: "metal", inset: "enamel", flat: "base" };
+var SLOTS = /* @__PURE__ */ new Set(["metal", "enamel", "base", "accent"]);
+function slotFor(el, specific, role) {
+  const v = el.getAttribute(specific) ?? attrUp(el, specific) ?? attrUp(el, "data-material");
+  return v && SLOTS.has(v) ? v : defaultSlot[role];
+}
+function paintVisible(paint, opacity) {
+  if (!paint || paint === "none") return false;
+  if (/^rgba\(.*,\s*0\)$/.test(paint) || paint === "transparent") return false;
+  return parseFloat(opacity || "1") > 4e-3;
+}
+function passColor(kind, g) {
+  const on = (b) => b ? "ff" : "00";
+  if (kind === "roles") return `#${on(g.role === "wire")}${on(g.role === "raised")}${on(g.role === "inset")}`;
+  if (kind === "slotsA") return `#${on(g.role === "flat")}${on(g.slot === "accent")}${on(g.slot === "base")}`;
+  return `#${on(g.slot === "metal")}${on(g.slot === "enamel")}00`;
+}
+function buildPass(root, infos, kind, outlinePx) {
+  const clone = root.cloneNode(true);
+  const doc = clone.ownerDocument;
+  const tagged = clone.querySelectorAll("[data-mb-i]");
+  const solidFilters = /* @__PURE__ */ new Map();
+  const solidFilter = (color) => {
+    let id = solidFilters.get(color);
+    if (!id) {
+      id = `mb-solid-${color.slice(1)}`;
+      solidFilters.set(color, id);
+    }
+    return `url(#${id})`;
+  };
+  for (const el of tagged) {
+    const info = infos[Number(el.getAttribute("data-mb-i"))];
+    el.removeAttribute("data-mb-i");
+    let css = el.getAttribute("style") ?? "";
+    if (css && !css.trim().endsWith(";")) css += ";";
+    if (info.hidden) {
+      el.setAttribute("style", `${css}display:none !important;`);
+      continue;
+    }
+    if (kind === "albedo") {
+      css += "filter:none !important;mix-blend-mode:normal !important;";
+      if (info.shape) {
+        if (!info.fill && !info.image) css += "fill:none !important;";
+        if (!info.stroke || info.stroke.slot === "metal") css += "stroke:none !important;";
+        if (info.image && !info.fill) css += "display:none !important;";
+      }
+      el.setAttribute("style", css);
+      continue;
+    }
+    css += "opacity:1 !important;filter:none !important;mix-blend-mode:normal !important;";
+    if (info.shape) {
+      css += "fill-opacity:1 !important;stroke-opacity:1 !important;marker:none !important;";
+      if (info.image) {
+        css += info.fill ? `filter:${solidFilter(passColor(kind, info.fill))} !important;` : "display:none !important;";
+      } else {
+        css += info.fill ? `fill:${passColor(kind, info.fill)} !important;` : "fill:none !important;";
+        if (info.stroke) css += `stroke:${passColor(kind, info.stroke)} !important;`;
+        else if (info.outline) {
+          css += `stroke:${passColor(kind, info.outline)} !important;stroke-width:${outlinePx}px !important;vector-effect:non-scaling-stroke !important;stroke-linejoin:round !important;stroke-linecap:round !important;stroke-dasharray:none !important;`;
+        } else css += "stroke:none !important;";
+      }
+    }
+    el.setAttribute("style", css);
+  }
+  const rootCss = clone.getAttribute("style") ?? "";
+  clone.setAttribute("style", `${rootCss}${rootCss && !rootCss.trim().endsWith(";") ? ";" : ""}background:none !important;`);
+  if (solidFilters.size > 0) {
+    const defs = doc.createElementNS(SVG_NS, "defs");
+    for (const [color, id] of solidFilters) {
+      const filter = doc.createElementNS(SVG_NS, "filter");
+      filter.setAttribute("id", id);
+      filter.setAttribute("color-interpolation-filters", "sRGB");
+      const flood = doc.createElementNS(SVG_NS, "feFlood");
+      flood.setAttribute("flood-color", color);
+      const comp = doc.createElementNS(SVG_NS, "feComposite");
+      comp.setAttribute("in2", "SourceAlpha");
+      comp.setAttribute("operator", "in");
+      filter.append(flood, comp);
+      defs.appendChild(filter);
+    }
+    clone.insertBefore(defs, clone.firstChild);
+  }
+  return new XMLSerializer().serializeToString(clone);
+}
+function prepareSvg(source, options, size) {
+  if (typeof document === "undefined") throw new Error("badgecraft: SVG preparation needs a browser DOM");
+  let root = document.importNode(parseSvg(source), true);
+  const host = document.createElement("div");
+  host.setAttribute("aria-hidden", "true");
+  host.style.cssText = "position:fixed;left:-10000px;top:-10000px;width:64px;height:64px;overflow:hidden;opacity:0;pointer-events:none;contain:strict;";
+  host.style.color = options.color;
+  const shadow = host.attachShadow({ mode: "open" });
+  (document.body ?? document.documentElement).appendChild(host);
+  try {
+    inlineUses(root);
+    shadow.appendChild(root);
+    let box = readViewBox(root);
+    if (!box) {
+      const bb = root.getBBox?.();
+      box = bb && bb.width > 0 && bb.height > 0 ? [bb.x, bb.y, bb.width, bb.height] : [0, 0, 100, 100];
+    }
+    if (options.frame) {
+      const framed = composeFrame(root, box, options.frame);
+      root.replaceWith(framed);
+      root = framed;
+      box = [0, 0, 100, 100];
+    }
+    const all = [...root.querySelectorAll("*")].filter((el) => !el.closest(NON_RENDERED));
+    const hiddenCache = /* @__PURE__ */ new Map();
+    const isHidden = (el) => {
+      if (!el || el === root.parentNode) return false;
+      const cached = hiddenCache.get(el);
+      if (cached !== void 0) return cached;
+      const cs = getComputedStyle(el);
+      const hidden = cs.display === "none" || parseFloat(cs.opacity || "1") <= 4e-3 || el !== root && isHidden(el.parentElement);
+      hiddenCache.set(el, hidden);
+      return hidden;
+    };
+    const raws = all.map((el) => {
+      const shape = SHAPES.has(el.localName);
+      const image = el.localName === "image";
+      const hidden = isHidden(el) || shape && getComputedStyle(el).visibility === "hidden";
+      let hasFill = false;
+      let hasStroke = false;
+      let fillPaint = "";
+      if (shape && !hidden) {
+        const cs = getComputedStyle(el);
+        hasFill = image || el.localName !== "line" && paintVisible(cs.fill, cs.fillOpacity);
+        hasStroke = !image && paintVisible(cs.stroke, cs.strokeOpacity) && parseFloat(cs.strokeWidth) > 0;
+        fillPaint = cs.fill;
+      }
+      return { el, hidden, shape, image, hasFill, hasStroke, fillPaint, frame: !!el.closest("[data-mb-frame]") };
+    });
+    const art = raws.filter((r) => r.shape && !r.hidden && !r.frame);
+    const hasStrokes = art.some((r) => r.hasStroke && attrUp(r.el, "data-stroke-relief") !== "none");
+    const fillColors = new Set(art.filter((r) => r.hasFill && !r.image).map((r) => r.fillPaint));
+    const hasImages = art.some((r) => r.image);
+    const mode = options.mode !== "auto" ? options.mode : hasStrokes || hasImages || fillColors.size > 1 || [...fillColors].some((paint) => paint.startsWith("url(")) ? "cloisonne" : "embossed";
+    const outline = options.outline === "auto" ? mode === "cloisonne" && !hasStrokes && fillColors.size > 1 ? options.autoOutline : 0 : Math.max(0, options.outline);
+    const infos = raws.map((r) => {
+      const info = { hidden: r.hidden, shape: r.shape, image: r.image, fill: null, stroke: null, outline: null };
+      if (r.hidden || !r.shape) return info;
+      if (r.hasFill) {
+        const relief = attrUp(r.el, "data-relief") ?? (mode === "embossed" ? "raised" : "inset");
+        if (relief === "raised" || relief === "inset" || relief === "flat") {
+          info.fill = { role: relief, slot: slotFor(r.el, "data-fill-material", relief) };
+        }
+      }
+      if (r.hasStroke) {
+        const relief = attrUp(r.el, "data-stroke-relief") ?? "raised";
+        const role = relief === "raised" ? "wire" : relief === "inset" || relief === "flat" ? relief : null;
+        if (role) info.stroke = { role, slot: slotFor(r.el, "data-stroke-material", role) };
+      } else if (outline > 0 && info.fill && info.fill.role === "inset" && !r.image && !r.frame) {
+        info.outline = { role: "wire", slot: slotFor(r.el, "data-stroke-material", "wire") };
+      }
+      return info;
+    });
+    all.forEach((el, i) => el.setAttribute("data-mb-i", String(i)));
+    const margin = 0.03 + outline * 0.6;
+    const [bx, by, bw, bh] = box;
+    const side = Math.max(bw, bh) * (1 + 2 * margin);
+    root.setAttribute("viewBox", `${bx + bw / 2 - side / 2} ${by + bh / 2 - side / 2} ${side} ${side}`);
+    root.setAttribute("width", String(size));
+    root.setAttribute("height", String(size));
+    root.setAttribute("preserveAspectRatio", "xMidYMid meet");
+    root.removeAttribute("x");
+    root.removeAttribute("y");
+    if (!root.getAttribute("color")) root.setAttribute("color", options.color);
+    const outlinePx = outline * size;
+    return {
+      roles: buildPass(root, infos, "roles", outlinePx),
+      slotsA: buildPass(root, infos, "slotsA", outlinePx),
+      slotsB: buildPass(root, infos, "slotsB", outlinePx),
+      albedo: buildPass(root, infos, "albedo", outlinePx),
+      mode,
+      outline
+    };
+  } finally {
+    host.remove();
+  }
+}
+
+// src/svg/rasterize.ts
+function loadImage(url) {
+  return new Promise((resolve, reject) => {
+    const img = new Image();
+    img.decoding = "async";
+    img.onload = () => resolve(img);
+    img.onerror = () => reject(new Error("badgecraft: the browser could not render the SVG"));
+    img.src = url;
+  });
+}
+async function rasterizeSvg(svg, size, background) {
+  const url = URL.createObjectURL(new Blob([svg], { type: "image/svg+xml;charset=utf-8" }));
+  try {
+    const img = await loadImage(url);
+    const canvas = document.createElement("canvas");
+    canvas.width = size;
+    canvas.height = size;
+    const ctx = canvas.getContext("2d", { willReadFrequently: true });
+    if (!ctx) throw new Error("badgecraft: 2D canvas unavailable");
+    if (background) {
+      ctx.fillStyle = background;
+      ctx.fillRect(0, 0, size, size);
+    }
+    ctx.drawImage(img, 0, 0, size, size);
+    return ctx.getImageData(0, 0, size, size).data;
+  } finally {
+    URL.revokeObjectURL(url);
+  }
+}
+
+// src/pipeline.ts
+function mapsKey(source, bakeKey, size) {
+  return `${hashString(source)}:${hashString(bakeKey)}:${size}`;
+}
+async function bakeSvg(source, settings, size) {
+  const prepared = prepareSvg(
+    source,
+    {
+      mode: settings.mode,
+      color: settings.color,
+      frame: settings.frame,
+      outline: settings.outline,
+      autoOutline: settings.autoOutline
+    },
+    size
+  );
+  const [roles, slotsA, slotsB, albedo] = await Promise.all([
+    rasterizeSvg(prepared.roles, size, "#000"),
+    rasterizeSvg(prepared.slotsA, size, "#000"),
+    rasterizeSvg(prepared.slotsB, size, "#000"),
+    rasterizeSvg(prepared.albedo, size)
+  ]);
+  return bakeAsync({
+    size,
+    roles,
+    slotsA,
+    slotsB,
+    albedo,
+    params: {
+      depth: settings.depth,
+      rim: settings.rim,
+      fillHoles: settings.fillHoles,
+      floor: settings.floor,
+      profile: settings.profile,
+      bevel: settings.bevel,
+      edge: settings.edge,
+      enamelLevel: settings.enamelLevel,
+      enamelDome: settings.enamelDome,
+      domeWidth: settings.domeWidth,
+      smoothing: settings.smoothing
+    }
+  });
+}
+var cpuCache = /* @__PURE__ */ new Map();
+var cpuBytes = /* @__PURE__ */ new Map();
+var CPU_CACHE_ENTRIES = 8;
+var CPU_CACHE_BYTES = 48 * 1024 * 1024;
+function cachedBake(key, produce) {
+  let pending = cpuCache.get(key);
+  if (pending) {
+    cpuCache.delete(key);
+    cpuCache.set(key, pending);
+    return pending;
+  }
+  const job = produce();
+  job.then(
+    (out) => {
+      if (cpuCache.get(key) !== job) return;
+      cpuBytes.set(key, out.surface.byteLength + out.albedo.byteLength + out.weights.byteLength);
+      trimCpuCache();
+    },
+    () => cpuCache.get(key) === job && cpuCache.delete(key)
+  );
+  pending = job;
+  cpuCache.set(key, pending);
+  trimCpuCache();
+  return pending;
+}
+function trimCpuCache() {
+  let total = 0;
+  for (const bytes of cpuBytes.values()) total += bytes;
+  while (cpuCache.size > 1 && (cpuCache.size > CPU_CACHE_ENTRIES || total > CPU_CACHE_BYTES)) {
+    const oldest = cpuCache.keys().next().value;
+    total -= cpuBytes.get(oldest) ?? 0;
+    cpuCache.delete(oldest);
+    cpuBytes.delete(oldest);
+  }
+}
+var gpuCache = /* @__PURE__ */ new Map();
+async function acquireMaps(renderer, key, produce) {
+  let entry = gpuCache.get(key);
+  if (entry?.textures && entry.generation !== renderer.generation) entry = void 0;
+  if (!entry) {
+    const created = {
+      refs: 0,
+      generation: renderer.generation,
+      promise: cachedBake(key, produce).then((out) => {
+        created.textures = renderer.createBadgeTextures(out);
+        created.generation = renderer.generation;
+        return created.textures;
+      })
+    };
+    created.promise.catch(() => gpuCache.get(key) === created && gpuCache.delete(key));
+    gpuCache.set(key, created);
+    entry = created;
+  }
+  entry.refs++;
+  if (entry.disposeTimer) {
+    clearTimeout(entry.disposeTimer);
+    entry.disposeTimer = void 0;
+  }
+  try {
+    return { key, textures: await entry.promise, entry };
+  } catch (error) {
+    entry.refs--;
+    throw error;
+  }
+}
+function releaseMaps(renderer, handle) {
+  const entry = handle.entry;
+  entry.refs--;
+  if (entry.refs > 0) return;
+  entry.disposeTimer = setTimeout(() => {
+    if (entry.refs > 0) return;
+    if (gpuCache.get(handle.key) === entry) gpuCache.delete(handle.key);
+    if (entry.textures && entry.generation === renderer.generation) renderer.deleteBadgeTextures(entry.textures);
+  }, 4e3);
+}
+
+// src/render/hdr.ts
+function decodeHdr(buffer) {
+  const bytes = new Uint8Array(buffer);
+  let pos = 0;
+  const readLine = () => {
+    let s = "";
+    while (pos < bytes.length && bytes[pos] !== 10) s += String.fromCharCode(bytes[pos++]);
+    if (pos >= bytes.length) throw new Error("badgecraft: truncated HDR header");
+    pos++;
+    return s.replace(/\r$/, "");
+  };
+  const magic = readLine();
+  if (!magic.startsWith("#?")) throw new Error("badgecraft: not a Radiance HDR file");
+  let line = readLine();
+  while (line.length > 0) line = readLine();
+  const size = readLine().match(/-Y\s+(\d+)\s+\+X\s+(\d+)/);
+  if (!size) throw new Error("badgecraft: unsupported HDR orientation");
+  const height = Number(size[1]);
+  const width = Number(size[2]);
+  if (width < 1 || height < 1 || width * height > 16777216) {
+    throw new Error("badgecraft: invalid or oversized HDR dimensions");
+  }
+  const requireBytes = (count) => {
+    if (pos + count > bytes.length) throw new Error("badgecraft: truncated HDR pixels");
+  };
+  const rgbe = new Uint8Array(width * height * 4);
+  const scan = new Uint8Array(width * 4);
+  for (let y = 0; y < height; y++) {
+    requireBytes(4);
+    const rle = width >= 8 && width < 32768 && bytes[pos] === 2 && bytes[pos + 1] === 2 && !(bytes[pos + 2] & 128);
+    if (!rle) {
+      requireBytes(width * 4);
+      rgbe.set(bytes.subarray(pos, pos + width * 4), y * width * 4);
+      pos += width * 4;
+      continue;
+    }
+    if ((bytes[pos + 2] << 8 | bytes[pos + 3]) !== width) {
+      throw new Error("badgecraft: HDR scanline width mismatch");
+    }
+    pos += 4;
+    for (let c = 0; c < 4; c++) {
+      let x = 0;
+      while (x < width) {
+        requireBytes(1);
+        let count = bytes[pos++];
+        const length = count > 128 ? count - 128 : count;
+        if (length === 0 || x + length > width) throw new Error("badgecraft: invalid HDR run length");
+        requireBytes(count > 128 ? 1 : length);
+        if (count > 128) {
+          count -= 128;
+          const v = bytes[pos++];
+          for (let k = 0; k < count; k++) scan[x++ * 4 + c] = v;
+        } else {
+          for (let k = 0; k < count; k++) scan[x++ * 4 + c] = bytes[pos++];
+        }
+      }
+    }
+    rgbe.set(scan, y * width * 4);
+  }
+  const data = new Float32Array(width * height * 4);
+  for (let i = 0; i < width * height; i++) {
+    const e = rgbe[i * 4 + 3];
+    const f2 = e ? Math.pow(2, e - 136) : 0;
+    data[i * 4] = rgbe[i * 4] * f2;
+    data[i * 4 + 1] = rgbe[i * 4 + 1] * f2;
+    data[i * 4 + 2] = rgbe[i * 4 + 2] * f2;
+    data[i * 4 + 3] = 1;
+  }
+  return { width, height, data };
+}
+
+// src/render/mesh.ts
+function reliefMesh(surface, size) {
+  const steps = Math.min(size, 384);
+  const vertices = [];
+  const indices = [];
+  const distances = [];
+  const edges = /* @__PURE__ */ new Map();
+  const boundary = [];
+  const sample = (u, v) => {
+    const x = Math.max(0, Math.min(size - 1, u * size - 0.5));
+    const y = Math.max(0, Math.min(size - 1, v * size - 0.5));
+    const ix = Math.floor(x), iy = Math.floor(y);
+    const jx = Math.min(ix + 1, size - 1), jy = Math.min(iy + 1, size - 1);
+    const a = surface[(iy * size + ix) * 4 + 3] * (1 - x + ix) + surface[(iy * size + jx) * 4 + 3] * (x - ix);
+    const b = surface[(jy * size + ix) * 4 + 3] * (1 - x + ix) + surface[(jy * size + jx) * 4 + 3] * (x - ix);
+    return a * (1 - y + iy) + b * (y - iy);
+  };
+  for (let y = 0; y <= steps; y++) for (let x = 0; x <= steps; x++) {
+    vertices.push(x / steps, y / steps, 0);
+    distances.push(sample(x / steps, y / steps));
+  }
+  const crossing = (a, b) => {
+    if (distances[a] === 0) return a;
+    if (distances[b] === 0) return b;
+    const key = a < b ? `${a}:${b}` : `${b}:${a}`;
+    const found = edges.get(key);
+    if (found !== void 0) return found;
+    let lo = 0, hi = 1;
+    for (let i = 0; i < 12; i++) {
+      const t2 = (lo + hi) / 2;
+      const d = sample(vertices[a * 3] * (1 - t2) + vertices[b * 3] * t2, vertices[a * 3 + 1] * (1 - t2) + vertices[b * 3 + 1] * t2);
+      if (d >= 0 === distances[a] >= 0) lo = t2;
+      else hi = t2;
+    }
+    const t = (lo + hi) / 2;
+    const id = vertices.length / 3;
+    vertices.push(vertices[a * 3] * (1 - t) + vertices[b * 3] * t, vertices[a * 3 + 1] * (1 - t) + vertices[b * 3 + 1] * t, 0);
+    distances.push(0);
+    edges.set(key, id);
+    return id;
+  };
+  const triangle = (a, b, c) => {
+    const input = [a, b, c], poly = [];
+    for (let i = 0; i < 3; i++) {
+      const p = input[i], q = input[(i + 1) % 3];
+      if (distances[p] >= 0) poly.push(p);
+      if (distances[p] >= 0 !== distances[q] >= 0) poly.push(crossing(p, q));
+    }
+    for (let i = poly.length - 1; i >= 0; i--) {
+      if (poly[i] === poly[(i + 1) % poly.length]) poly.splice(i, 1);
+    }
+    if (poly.length < 3) return;
+    for (let i = 1; i + 1 < poly.length; i++) indices.push(poly[0], poly[i], poly[i + 1]);
+    for (let i = 0; i < poly.length; i++) {
+      const p = poly[i], q = poly[(i + 1) % poly.length];
+      const onMapEdge = [0, 1].some((axis) => vertices[p * 3 + axis] === vertices[q * 3 + axis] && (vertices[p * 3 + axis] === 0 || vertices[p * 3 + axis] === 1));
+      if (distances[p] === 0 && distances[q] === 0 || onMapEdge) boundary.push([p, q]);
+    }
+  };
+  for (let y = 0; y < steps; y++) for (let x = 0; x < steps; x++) {
+    const a = y * (steps + 1) + x, b = a + 1, c = a + steps + 1, d = c + 1;
+    const da = distances[a], db = distances[b], dc = distances[c], dd = distances[d];
+    if (da < 0 && db < 0 && dc < 0 && dd < 0) continue;
+    if (da > 0 && db > 0 && dc > 0 && dd > 0 && x > 0 && y > 0 && x < steps - 1 && y < steps - 1) {
+      indices.push(a, c, b, b, c, d);
+      continue;
+    }
+    triangle(a, c, b);
+    triangle(b, c, d);
+  }
+  const faceCount = indices.length;
+  for (const [a, b] of boundary) {
+    const i = vertices.length / 3;
+    for (const [id, side] of [[a, 1], [a, -1], [b, 1], [b, -1]]) vertices.push(vertices[id * 3], vertices[id * 3 + 1], side);
+    indices.push(i, i + 1, i + 2, i + 2, i + 1, i + 3);
+  }
+  return { vertices: new Float32Array(vertices), indices: new Uint32Array(indices), faceCount };
+}
+
+// src/render/math.ts
+function perspective(fovY, aspect, near, far) {
+  const f2 = 1 / Math.tan(fovY / 2);
+  const nf = 1 / (near - far);
+  const m = new Float32Array(16);
+  m[0] = f2 / aspect;
+  m[5] = f2;
+  m[10] = (far + near) * nf;
+  m[11] = -1;
+  m[14] = 2 * far * near * nf;
+  return m;
+}
+function multiply(a, b) {
+  const out = new Float32Array(16);
+  for (let c = 0; c < 4; c++) {
+    for (let r = 0; r < 4; r++) {
+      out[c * 4 + r] = a[r] * b[c * 4] + a[4 + r] * b[c * 4 + 1] + a[8 + r] * b[c * 4 + 2] + a[12 + r] * b[c * 4 + 3];
+    }
+  }
+  return out;
+}
+function translation(x, y, z) {
+  const m = identity();
+  m[12] = x;
+  m[13] = y;
+  m[14] = z;
+  return m;
+}
+function identity() {
+  const m = new Float32Array(16);
+  m[0] = m[5] = m[10] = m[15] = 1;
+  return m;
+}
+function rotation(pitch, yaw, roll = 0) {
+  const cx = Math.cos(pitch);
+  const sx = Math.sin(pitch);
+  const cy = Math.cos(yaw);
+  const sy = Math.sin(yaw);
+  const rx = identity();
+  rx[5] = cx;
+  rx[6] = sx;
+  rx[9] = -sx;
+  rx[10] = cx;
+  const ry = identity();
+  ry[0] = cy;
+  ry[2] = -sy;
+  ry[8] = sy;
+  ry[10] = cy;
+  let m = multiply(ry, rx);
+  if (roll) {
+    const cz = Math.cos(roll);
+    const sz = Math.sin(roll);
+    const rz = identity();
+    rz[0] = cz;
+    rz[1] = sz;
+    rz[4] = -sz;
+    rz[5] = cz;
+    m = multiply(m, rz);
+  }
+  return m;
+}
+function normalMatrix(m) {
+  return new Float32Array([m[0], m[1], m[2], m[4], m[5], m[6], m[8], m[9], m[10]]);
+}
+
+// src/render/shaders.ts
+var common = (
+  /* glsl */
+  `
+const float PI = 3.14159265359;
+
+// Equirectangular mapping. u = 0.5 looks along +z (towards the viewer), v = 0 is straight up.
+vec2 dirToUv(vec3 d, float rotation) {
+  float u = atan(d.x, d.z) * (0.5 / PI) + 0.5 + rotation;
+  float v = acos(clamp(d.y, -1.0, 1.0)) / PI;
+  return vec2(u, v);
+}
+
+vec3 uvToDir(vec2 uv) {
+  float phi = (uv.x - 0.5) * 2.0 * PI;
+  float theta = uv.y * PI;
+  return vec3(sin(theta) * sin(phi), cos(theta), sin(theta) * cos(phi));
+}
+`
+);
+var fullscreenVertex = (
+  /* glsl */
+  `#version 300 es
+void main() {
+  vec2 p = vec2(float((gl_VertexID << 1) & 2), float(gl_VertexID & 2));
+  gl_Position = vec4(p * 2.0 - 1.0, 0.0, 1.0);
+}
+`
+);
+var MAX_LIGHTS = 8;
+var envGenerateFragment = (
+  /* glsl */
+  `#version 300 es
+precision highp float;
+${common}
+uniform vec2 uSize;
+uniform vec3 uTop;
+uniform vec3 uHorizon;
+uniform vec3 uBottom;
+uniform int uLightCount;
+uniform vec3 uLightDir[${MAX_LIGHTS}];
+uniform vec3 uLightColor[${MAX_LIGHTS}];
+uniform vec4 uLightShape[${MAX_LIGHTS}]; // tan(half width), tan(half height), softness, circle?
+uniform float uScale;
+out vec4 outColor;
+
+void main() {
+  vec2 uv = gl_FragCoord.xy / uSize;
+  vec3 d = uvToDir(uv);
+  vec3 col = d.y > 0.0
+    ? mix(uHorizon, uTop, pow(d.y, 0.55))
+    : mix(uHorizon, uBottom, pow(-d.y, 0.4));
+  for (int i = 0; i < ${MAX_LIGHTS}; i++) {
+    if (i >= uLightCount) break;
+    vec3 c = uLightDir[i];
+    float cd = dot(d, c);
+    if (cd <= 0.02) continue;
+    vec3 up = abs(c.y) > 0.99 ? vec3(0.0, 0.0, 1.0) : vec3(0.0, 1.0, 0.0);
+    vec3 right = normalize(cross(up, c));
+    vec3 upv = cross(c, right);
+    vec2 p = vec2(dot(d, right), dot(d, upv)) / cd;
+    vec4 s = uLightShape[i];
+    float soft = clamp(s.z, 0.02, 1.0);
+    float e;
+    if (s.w > 0.5) {
+      e = length(p) / s.x;
+    } else {
+      vec2 q = abs(p) / s.xy;
+      e = pow(pow(q.x, 8.0) + pow(q.y, 8.0), 0.125);
+    }
+    float m = 1.0 - smoothstep(1.0 - soft, 1.0, e);
+    col += uLightColor[i] * m;
+  }
+  outColor = vec4(col * uScale, 1.0);
+}
+`
+);
+var sampling = (
+  /* glsl */
+  `
+vec2 hammersley(int i, int n) {
+  uint b = uint(i);
+  b = (b << 16u) | (b >> 16u);
+  b = ((b & 0x55555555u) << 1u) | ((b & 0xAAAAAAAAu) >> 1u);
+  b = ((b & 0x33333333u) << 2u) | ((b & 0xCCCCCCCCu) >> 2u);
+  b = ((b & 0x0F0F0F0Fu) << 4u) | ((b & 0xF0F0F0F0u) >> 4u);
+  b = ((b & 0x00FF00FFu) << 8u) | ((b & 0xFF00FF00u) >> 8u);
+  return vec2(float(i) / float(n), float(b) * 2.3283064365386963e-10);
+}
+
+mat3 tangentFrame(vec3 n) {
+  vec3 up = abs(n.z) < 0.999 ? vec3(0.0, 0.0, 1.0) : vec3(1.0, 0.0, 0.0);
+  vec3 t = normalize(cross(up, n));
+  return mat3(t, cross(n, t), n);
+}
+`
+);
+var prefilterFragment = (
+  /* glsl */
+  `#version 300 es
+precision highp float;
+${common}
+${sampling}
+uniform sampler2D uSrc;
+uniform vec2 uSize;
+uniform float uRoughness;
+uniform float uTexelSolidAngle;
+out vec4 outColor;
+const int SAMPLES = 256;
+
+void main() {
+  vec2 uv = gl_FragCoord.xy / uSize;
+  // The mirror level is a resample, not a convolution. Preserve crisp studio
+  // cards and skip 256 identical GGX samples over the largest mip level.
+  if (uRoughness <= 0.001) {
+    outColor = vec4(textureLod(uSrc, uv, 0.0).rgb, 1.0);
+    return;
+  }
+  vec3 N = uvToDir(uv);
+  float a = max(uRoughness * uRoughness, 1e-4);
+  float a2 = a * a;
+  mat3 tbn = tangentFrame(N);
+  vec3 sum = vec3(0.0);
+  float wsum = 0.0;
+  for (int i = 0; i < SAMPLES; i++) {
+    vec2 xi = hammersley(i, SAMPLES);
+    float phi = 2.0 * PI * xi.x;
+    float cosT = sqrt((1.0 - xi.y) / (1.0 + (a2 - 1.0) * xi.y));
+    float sinT = sqrt(1.0 - cosT * cosT);
+    vec3 H = tbn * vec3(cos(phi) * sinT, sin(phi) * sinT, cosT);
+    float NdH = dot(N, H);
+    vec3 L = 2.0 * NdH * H - N;
+    float NdL = dot(N, L);
+    if (NdL > 0.0) {
+      float d = NdH * NdH * (a2 - 1.0) + 1.0;
+      float D = a2 / (PI * d * d);
+      float pdf = D * 0.25;
+      float saSample = 1.0 / (float(SAMPLES) * pdf + 1e-5);
+      float lod = max(0.5 * log2(saSample / uTexelSolidAngle) + 1.0, 0.0);
+      sum += textureLod(uSrc, dirToUv(L, 0.0), lod).rgb * NdL;
+      wsum += NdL;
+    }
+  }
+  outColor = vec4(sum / max(wsum, 1e-4), 1.0);
+}
+`
+);
+var irradianceFragment = (
+  /* glsl */
+  `#version 300 es
+precision highp float;
+${common}
+${sampling}
+uniform sampler2D uSrc;
+uniform vec2 uSize;
+uniform float uTexelSolidAngle;
+out vec4 outColor;
+const int SAMPLES = 512;
+
+void main() {
+  vec2 uv = gl_FragCoord.xy / uSize;
+  vec3 N = uvToDir(uv);
+  mat3 tbn = tangentFrame(N);
+  vec3 sum = vec3(0.0);
+  for (int i = 0; i < SAMPLES; i++) {
+    vec2 xi = hammersley(i, SAMPLES);
+    float phi = 2.0 * PI * xi.x;
+    float cosT = sqrt(1.0 - xi.y);
+    float sinT = sqrt(xi.y);
+    vec3 L = tbn * vec3(cos(phi) * sinT, sin(phi) * sinT, cosT);
+    float pdf = cosT / PI;
+    float saSample = 1.0 / (float(SAMPLES) * pdf + 1e-5);
+    float lod = max(0.5 * log2(saSample / uTexelSolidAngle) + 1.0, 0.0);
+    sum += textureLod(uSrc, dirToUv(L, 0.0), lod).rgb;
+  }
+  outColor = vec4(sum / float(SAMPLES), 1.0);
+}
+`
+);
+var badgeVertex = (
+  /* glsl */
+  `#version 300 es
+precision highp float;
+layout(location = 0) in vec2 aUv;
+layout(location = 1) in float aLip;
+uniform sampler2D uSurface;
+uniform mat4 uModel;
+uniform mat4 uViewProj;
+uniform float uDepth;
+uniform float uThickness;
+uniform float uEdgeTexels;
+uniform float uSide;
+out vec2 vUv;
+out vec3 vWorld;
+out vec3 vLocal;
+
+float roundProfile(float t) {
+  float u = 1.0 - clamp(t, 0.0, 1.0);
+  return sqrt(max(0.0, 1.0 - u * u));
+}
+
+void main() {
+  vec4 s = textureLod(uSurface, aUv, 0.0);
+  float side = uSide == 0.0 ? aLip : uSide;
+  float z = side > 0.0 ? s.r * uDepth : -uThickness * roundProfile(max(s.a, 0.0) / uEdgeTexels);
+  vec3 p = vec3(aUv.x - 0.5, 0.5 - aUv.y, z);
+  vec4 w = uModel * vec4(p, 1.0);
+  vUv = aUv;
+  vWorld = w.xyz;
+  vLocal = p;
+  gl_Position = uViewProj * w;
+}
+`
+);
+var badgeFragment = (
+  /* glsl */
+  `#version 300 es
+precision highp float;
+${common}
+in vec2 vUv;
+in vec3 vWorld;
+in vec3 vLocal;
+
+uniform sampler2D uSurface;
+uniform sampler2D uAlbedo;
+uniform sampler2D uWeights;
+uniform sampler2D uEnvSpec;
+uniform sampler2D uEnvIrr;
+uniform float uEnvMaxLod;
+uniform float uEnvRotation;
+uniform float uEnvScale;
+
+uniform vec4 uMatColor[4]; // linear rgb, useSvgColor
+uniform vec4 uMatA[4];     // metalness, roughness, clearcoat, clearcoat roughness
+uniform vec4 uMatB[4];     // dielectric f0, iridescence, film thickness (nm), flakes
+uniform vec4 uMatC[4];     // brushed, brush direction, flake scale, emissive
+
+uniform mat3 uNormalMatrix;
+uniform vec3 uCamPos;
+uniform float uMapSize;
+uniform float uPixelScale;
+uniform float uDepth;
+uniform float uThickness;
+uniform float uEdgeTexels;
+uniform float uAo;
+uniform float uExposure;
+uniform float uSide;
+uniform int uToneMap;
+uniform float uLocked;
+uniform vec3 uLockedColor;
+uniform float uShine;
+
+out vec4 outColor;
+
+vec3 envSpec(vec3 dir, float roughness) {
+  return textureLod(uEnvSpec, dirToUv(dir, uEnvRotation), roughness * uEnvMaxLod).rgb * uEnvScale;
+}
+
+vec3 envIrr(vec3 dir) {
+  return textureLod(uEnvIrr, dirToUv(dir, uEnvRotation), 0.0).rgb * uEnvScale;
+}
+
+// Karis' analytic approximation of the split-sum BRDF integral.
+vec2 envBRDF(float roughness, float NdV) {
+  const vec4 c0 = vec4(-1.0, -0.0275, -0.572, 0.022);
+  const vec4 c1 = vec4(1.0, 0.0425, 1.04, -0.04);
+  vec4 r = roughness * c0 + c1;
+  float a004 = min(r.x * r.x, exp2(-9.28 * NdV)) * r.x + r.y;
+  return vec2(-1.04, 1.04) * a004 + r.zw;
+}
+
+float hash12(vec2 p) {
+  vec3 p3 = fract(vec3(p.xyx) * 0.1031);
+  p3 += dot(p3, p3.yzx + 33.33);
+  return fract((p3.x + p3.y) * p3.z);
+}
+
+vec3 hash32(vec2 p) {
+  vec3 p3 = fract(vec3(p.xyx) * vec3(0.1031, 0.1030, 0.0973));
+  p3 += dot(p3, p3.yxz + 33.33);
+  return fract((p3.xxy + p3.yzz) * p3.zyx);
+}
+
+float noise1(float x) {
+  float i = floor(x);
+  float f = fract(x);
+  float a = hash12(vec2(i, 17.0));
+  float b = hash12(vec2(i + 1.0, 17.0));
+  return mix(a, b, f * f * (3.0 - 2.0 * f));
+}
+
+// Thin-film interference tint (cheap spectral approximation).
+vec3 thinFilm(float cosTheta, float thicknessNm) {
+  float n = 1.4;
+  float cosT = sqrt(max(0.0, 1.0 - (1.0 - cosTheta * cosTheta) / (n * n)));
+  float opd = 2.0 * n * thicknessNm * cosT;
+  vec3 phase = 2.0 * PI * opd / vec3(650.0, 532.0, 450.0);
+  return 0.5 + 0.5 * cos(phase);
+}
+
+vec3 srgbToLinear(vec3 c) {
+  return mix(c / 12.92, pow((c + 0.055) / 1.055, vec3(2.4)), step(0.04045, c));
+}
+
+vec3 linearToSrgb(vec3 c) {
+  c = clamp(c, 0.0, 1.0);
+  return mix(c * 12.92, 1.055 * pow(c, vec3(1.0 / 2.4)) - 0.055, step(0.0031308, c));
+}
+
+// Khronos PBR Neutral: keeps base colours faithful, rolls off highlights.
+vec3 toneNeutral(vec3 color) {
+  const float startCompression = 0.8 - 0.04;
+  const float desaturation = 0.15;
+  float x = min(color.r, min(color.g, color.b));
+  float offset = x < 0.08 ? x - 6.25 * x * x : 0.04;
+  color -= offset;
+  float peak = max(color.r, max(color.g, color.b));
+  if (peak < startCompression) return color;
+  const float d = 1.0 - startCompression;
+  float newPeak = 1.0 - d * d / (peak + d - startCompression);
+  color *= newPeak / peak;
+  float g = 1.0 - 1.0 / (desaturation * (peak - newPeak) + 1.0);
+  return mix(color, vec3(newPeak), g);
+}
+
+vec3 toneAces(vec3 x) {
+  x *= 0.6;
+  return clamp((x * (2.51 * x + 0.03)) / (x * (2.43 * x + 0.59) + 0.14), 0.0, 1.0);
+}
+
+vec3 toneAgx(vec3 v) {
+  const mat3 m = mat3(0.842479062253094, 0.0423282422610123, 0.0423756549057051,
+                      0.0784335999999992, 0.878468636469772, 0.0784336,
+                      0.0792237451477643, 0.0791661274605434, 0.879142973793104);
+  const mat3 mi = mat3(1.19687900512017, -0.0528968517574562, -0.0529716355144438,
+                       -0.0980208811401368, 1.15190312990417, -0.0980434501171241,
+                       -0.0990297440797205, -0.0989611768448433, 1.15107367264116);
+  const float minEv = -12.47393;
+  const float maxEv = 4.026069;
+  v = m * v;
+  v = clamp(log2(max(v, 1e-10)), minEv, maxEv);
+  v = (v - minEv) / (maxEv - minEv);
+  vec3 v2 = v * v;
+  vec3 v4 = v2 * v2;
+  v = 15.5 * v4 * v2 - 40.14 * v4 * v + 31.96 * v4 - 6.868 * v2 * v + 0.4298 * v2 + 0.1191 * v - 0.00232;
+  v = mi * v;
+  return pow(max(v, 0.0), vec3(2.2));
+}
+
+vec3 toneMap(vec3 c) {
+  if (uToneMap == 0) return toneNeutral(c);
+  if (uToneMap == 1) return toneAces(c);
+  if (uToneMap == 2) return toneAgx(c);
+  return c;
+}
+
+void main() {
+  vec4 s = texture(uSurface, vUv);
+  float sd = s.a;
+  // The contour mesh supplies silhouette coverage through MSAA. A second
+  // distance-field alpha cut would expose cracks at the front/back seam.
+  float alpha = 1.0;
+
+  vec4 w = texture(uWeights, vUv);
+  w /= max(w.r + w.g + w.b + w.a, 1e-4);
+
+  if (uLocked > 0.5) {
+    float line = alpha * clamp(w.r + w.a, 0.0, 1.0);
+    if (line <= 0.001) discard;
+    outColor = vec4(linearToSrgb(uLockedColor) * line, line);
+    return;
+  }
+
+  vec3 nLocal;
+  if (uSide > 0.0) {
+    float k = uDepth * uMapSize;
+    nLocal = normalize(vec3(-s.g * k, s.b * k, 1.0));
+  } else {
+    // Flat back with the same rounded edge as the front.
+    float texel = 1.0 / uMapSize;
+    float sx = texture(uSurface, vUv + vec2(texel, 0.0)).a - texture(uSurface, vUv - vec2(texel, 0.0)).a;
+    float sy = texture(uSurface, vUv + vec2(0.0, texel)).a - texture(uSurface, vUv - vec2(0.0, texel)).a;
+    float t = clamp(sd / uEdgeTexels, 0.0, 1.0);
+    float u = 1.0 - t;
+    float dp = t < 1.0 ? u / max(sqrt(max(1.0 - u * u, 1e-4)), 0.05) : 0.0;
+    float k = uThickness * dp / uEdgeTexels * uMapSize * 0.5;
+    nLocal = uSide == 0.0 ? normalize(vec3(-sx, sy, 0.0)) : normalize(vec3(-k * sx, k * sy, -1.0));
+    w = vec4(1.0, 0.0, 0.0, 0.0);
+  }
+  vec3 N = normalize(uNormalMatrix * nLocal);
+  vec3 V = normalize(uCamPos - vWorld);
+
+  vec4 albedo = texture(uAlbedo, vUv);
+  vec3 svg = albedo.rgb; // sRGB texture: already linear
+  float cavity = uSide > 0.0 ? albedo.a : 0.0;
+
+  vec3 baseColor = vec3(0.0);
+  vec4 A = vec4(0.0);
+  vec4 B = vec4(0.0);
+  vec4 C = vec4(0.0);
+  float brushDir = 0.0;
+  float brushBest = -1.0;
+  for (int i = 0; i < 4; i++) {
+    float wi = w[i];
+    baseColor += wi * mix(uMatColor[i].rgb, svg, uMatColor[i].a);
+    A += wi * uMatA[i];
+    B += wi * uMatB[i];
+    C += wi * uMatC[i];
+    float bw = wi * uMatC[i].x;
+    if (bw > brushBest) {
+      brushBest = bw;
+      brushDir = uMatC[i].y;
+    }
+  }
+  float metalness = clamp(A.x, 0.0, 1.0);
+  float roughness = clamp(A.y, 0.02, 1.0);
+  float clearcoat = clamp(A.z, 0.0, 1.0);
+  float ccRoughness = clamp(A.w, 0.02, 1.0);
+  float f0d = B.x;
+  float irid = B.y;
+  float filmNm = B.z;
+  float flakes = B.w;
+  float brushed = C.x;
+  if (uSide < 0.0) {
+    // The back plate gets a lathe-turned finish.
+    brushed = max(brushed, 0.55);
+    brushDir = 0.0;
+  }
+  float flakeScale = max(C.z, 1.0);
+  float emissive = C.w;
+
+  // Brushed metal: streaky normal perturbation along the brushing direction.
+  vec3 Nb = N;
+  if (brushed > 0.001) {
+    vec2 p = vLocal.xy;
+    float coord;
+    vec2 across;
+    if (brushDir < 0.5) { coord = length(p) * 700.0; across = normalize(p + 1e-5); }
+    else if (brushDir < 1.5) { coord = atan(p.y, p.x) * 160.0; across = normalize(vec2(-p.y, p.x) + 1e-5); }
+    else if (brushDir < 2.5) { coord = p.y * 700.0; across = vec2(0.0, 1.0); }
+    else { coord = p.x * 700.0; across = vec2(1.0, 0.0); }
+    // Streaks finer than a pixel would alias into moir\xE9; fade them and let roughness carry the look.
+    float footprint = fwidth(coord) * uPixelScale;
+    float n = (noise1(coord) - 0.5) * clamp(1.4 - footprint * 0.9, 0.0, 1.0)
+            + 0.5 * (noise1(coord * 3.7 + 11.0) - 0.5) * clamp(1.4 - footprint * 3.3, 0.0, 1.0);
+    Nb = normalize(N + uNormalMatrix * vec3(across * n * 0.22 * brushed, 0.0));
+    roughness = mix(roughness, min(1.0, roughness + 0.12), brushed);
+  }
+
+  float NdV = clamp(dot(Nb, V), 1e-4, 1.0);
+  // Resolve normal detail below a pixel into roughness instead of sparkling
+  // pinprick highlights. This uses derivatives, with no additional map reads.
+  vec3 dx = dFdx(N) * uPixelScale;
+  vec3 dy = dFdy(N) * uPixelScale;
+  float variance = min(0.15 * (dot(dx, dx) + dot(dy, dy)), 0.025);
+  roughness = sqrt(clamp(roughness * roughness + variance, 0.0004, 1.0));
+  ccRoughness = sqrt(clamp(ccRoughness * ccRoughness + variance, 0.0004, 1.0));
+
+  vec3 F0 = mix(vec3(f0d), baseColor, metalness);
+  if (irid > 0.001) {
+    vec3 film = thinFilm(NdV, filmNm);
+    F0 = mix(F0, mix(film, film * baseColor * 1.6, metalness * 0.5), irid);
+  }
+  vec2 ab = envBRDF(roughness, NdV);
+  vec3 FssEss = F0 * ab.x + ab.y;
+  float Ems = 1.0 - (ab.x + ab.y);
+  vec3 Favg = F0 + (1.0 - F0) / 21.0;
+  vec3 Fms = FssEss * Favg / (1.0 - Ems * Favg);
+  vec3 specWeight = FssEss + Fms * Ems;
+
+  float ao = 1.0 - uAo * cavity;
+  float specAo = mix(1.0, ao, 0.65);
+  vec3 R = reflect(-V, Nb);
+  vec3 irradiance = envIrr(Nb);
+  vec3 diffuse = baseColor * (1.0 - metalness) * (1.0 - specWeight) * irradiance * ao;
+  // Multiple scattering is broad, so it follows irradiance rather than the
+  // sharp reflected softbox. Reuse the diffuse lookup already in this pass.
+  vec3 color = diffuse + envSpec(R, roughness) * FssEss * specAo
+             + irradiance * Fms * Ems * ao;
+
+  // Metallic flakes: each cell reflects the environment at its own random angle.
+  if (flakes > 0.001) {
+    vec2 cuv = vUv * flakeScale;
+    vec2 cell = floor(cuv);
+    vec3 rnd = hash32(cell);
+    vec2 f = fract(cuv) - 0.5 - (rnd.xy - 0.5) * 0.4;
+    float footprint = max(fwidth(cuv.x), fwidth(cuv.y)) * uPixelScale;
+    float edge = max(0.025, footprint * 0.35);
+    float mask = (1.0 - smoothstep(0.23 - edge, 0.23 + edge, length(f))) * step(0.3, rnd.z);
+    // Unresolved flakes become the average coverage, avoiding crawling pixels.
+    float resolved = 1.0 - smoothstep(0.6, 1.8, footprint);
+    mask = mix(0.116, mask, resolved);
+    vec3 fn = normalize(Nb + uNormalMatrix * vec3((rnd.xy - 0.5) * 1.3 * resolved, 0.0));
+    vec3 fr = reflect(-V, fn);
+    vec3 flakeColor = envSpec(fr, mix(max(roughness, 0.25), 0.06, resolved)) * mix(vec3(0.85), baseColor, 0.55) * specAo;
+    color = mix(color, flakeColor, mask * clamp(flakes, 0.0, 1.0));
+  }
+
+  // Clear-coat layer (uses the unperturbed normal).
+  if (clearcoat > 0.001) {
+    float NdVc = clamp(dot(N, V), 1e-4, 1.0);
+    float Fc = 0.04 + 0.96 * pow(1.0 - NdVc, 5.0);
+    vec2 abc = envBRDF(ccRoughness, NdVc);
+    vec3 cc = envSpec(reflect(-V, N), ccRoughness) * (0.04 * abc.x + abc.y);
+    float transmission = 1.0 - clearcoat * Fc;
+    color = color * transmission * transmission + clearcoat * cc * specAo;
+  }
+
+  color += baseColor * emissive;
+
+  // Optional travelling glint across the face.
+  if (uShine > 0.0) {
+    float band = dot(vLocal.xy, normalize(vec2(1.0, 0.6))) - (uShine * 2.6 - 1.3);
+    color += exp(-band * band * 90.0) * 0.9 * specWeight;
+  }
+
+  color = toneMap(color * uExposure);
+  color = linearToSrgb(color);
+  color += (hash12(gl_FragCoord.xy) - 0.5) / 255.0;
+  outColor = vec4(color * alpha, alpha);
+}
+`
+);
+var shadowVertex = (
+  /* glsl */
+  `#version 300 es
+precision highp float;
+layout(location = 0) in vec2 aUv;
+uniform mat4 uModel;
+uniform mat4 uViewProj;
+uniform float uZ;
+uniform float uOffset;
+uniform float uSpread;
+out vec2 vUv;
+
+void main() {
+  vec2 uv = (aUv - 0.5) * uSpread + 0.5;
+  vec3 p = vec3(uv.x - 0.5, 0.5 - uv.y, uZ);
+  vec4 w = uModel * vec4(p, 1.0);
+  w.y -= uOffset;
+  vUv = uv;
+  gl_Position = uViewProj * w;
+}
+`
+);
+var shadowFragment = (
+  /* glsl */
+  `#version 300 es
+precision highp float;
+in vec2 vUv;
+uniform sampler2D uSurface;
+uniform float uOpacity;
+uniform float uBlur;
+out vec4 outColor;
+
+void main() {
+  float sd = texture(uSurface, clamp(vUv, 0.0, 1.0)).a;
+  float a = smoothstep(-uBlur, uBlur * 0.5, sd);
+  a = a * a * uOpacity;
+  if (a <= 0.002) discard;
+  outColor = vec4(0.0, 0.0, 0.0, a);
+}
+`
+);
+
+// src/render/renderer.ts
+var ENV_WIDTH = 512;
+var ENV_LEVELS = 6;
+var IRR_WIDTH = 64;
+var BRUSH_DIRS = { circular: 0, radial: 1, horizontal: 2, vertical: 3 };
+function compile(gl, type, source) {
+  const shader = gl.createShader(type);
+  gl.shaderSource(shader, source);
+  gl.compileShader(shader);
+  if (!gl.getShaderParameter(shader, gl.COMPILE_STATUS) && !gl.isContextLost()) {
+    const log = gl.getShaderInfoLog(shader);
+    gl.deleteShader(shader);
+    throw new Error(`badgecraft: shader compile failed
+${log}`);
+  }
+  return shader;
+}
+function link(gl, vs, fs) {
+  const program = gl.createProgram();
+  const v = compile(gl, gl.VERTEX_SHADER, vs);
+  const f2 = compile(gl, gl.FRAGMENT_SHADER, fs);
+  gl.attachShader(program, v);
+  gl.attachShader(program, f2);
+  gl.linkProgram(program);
+  gl.deleteShader(v);
+  gl.deleteShader(f2);
+  if (!gl.getProgramParameter(program, gl.LINK_STATUS) && !gl.isContextLost()) {
+    throw new Error(`badgecraft: program link failed
+${gl.getProgramInfoLog(program)}`);
+  }
+  const u = {};
+  const count = gl.getProgramParameter(program, gl.ACTIVE_UNIFORMS);
+  for (let i = 0; i < count; i++) {
+    const info = gl.getActiveUniform(program, i);
+    if (!info) continue;
+    const name = info.name.replace(/\[0\]$/, "");
+    u[name] = gl.getUniformLocation(program, info.name);
+  }
+  return { program, u };
+}
+var shared;
+var Renderer = class _Renderer {
+  constructor() {
+    /** Incremented whenever the context is restored; GPU resources must be re-created. */
+    this.generation = 0;
+    this.floatTargets = false;
+    this.anisotropy = null;
+    this.maxAnisotropy = 1;
+    this.renderLimit = 2048;
+    this.envCache = /* @__PURE__ */ new Map();
+    this.listeners = /* @__PURE__ */ new Set();
+    this.canvas = document.createElement("canvas");
+    this.canvas.width = 256;
+    this.canvas.height = 256;
+    const gl = this.canvas.getContext("webgl2", {
+      alpha: true,
+      premultipliedAlpha: true,
+      antialias: true,
+      depth: true,
+      stencil: false,
+      preserveDrawingBuffer: false
+    });
+    if (!gl) throw new Error("badgecraft: WebGL2 is not available");
+    this.gl = gl;
+    this.canvas.addEventListener("webglcontextlost", (e) => e.preventDefault());
+    this.canvas.addEventListener("webglcontextrestored", () => {
+      this.envCache.clear();
+      this.init();
+      this.generation++;
+      this.listeners.forEach((fn) => fn());
+    });
+    this.init();
+  }
+  /** The page-wide renderer, or null when WebGL2 is unavailable. */
+  static shared() {
+    if (shared === void 0) {
+      try {
+        shared = new _Renderer();
+      } catch (error) {
+        console.warn(error);
+        shared = null;
+      }
+    }
+    return shared;
+  }
+  /** Called after a lost context has been restored. */
+  onRestore(fn) {
+    this.listeners.add(fn);
+    return () => this.listeners.delete(fn);
+  }
+  init() {
+    const gl = this.gl;
+    this.renderLimit = Math.min(2048, gl.getParameter(gl.MAX_RENDERBUFFER_SIZE));
+    this.floatTargets = !!gl.getExtension("EXT_color_buffer_float");
+    this.anisotropy = gl.getExtension("EXT_texture_filter_anisotropic");
+    this.maxAnisotropy = this.anisotropy ? Math.min(2, gl.getParameter(this.anisotropy.MAX_TEXTURE_MAX_ANISOTROPY_EXT)) : 1;
+    gl.getExtension("OES_texture_float_linear");
+    this.badgeProgram = link(gl, badgeVertex, badgeFragment);
+    this.shadowProgram = link(gl, shadowVertex, shadowFragment);
+    this.envProgram = link(gl, fullscreenVertex, envGenerateFragment);
+    this.prefilterProgram = link(gl, fullscreenVertex, prefilterFragment);
+    this.irrProgram = link(gl, fullscreenVertex, irradianceFragment);
+    this.fbo = gl.createFramebuffer();
+    this.emptyVao = gl.createVertexArray();
+    const verts = new Float32Array([0, 0, 1, 0, 0, 1, 1, 1]);
+    const indices = new Uint16Array([0, 2, 1, 1, 2, 3]);
+    this.shadowQuad = gl.createVertexArray();
+    gl.bindVertexArray(this.shadowQuad);
+    const vb = gl.createBuffer();
+    gl.bindBuffer(gl.ARRAY_BUFFER, vb);
+    gl.bufferData(gl.ARRAY_BUFFER, verts, gl.STATIC_DRAW);
+    gl.enableVertexAttribArray(0);
+    gl.vertexAttribPointer(0, 2, gl.FLOAT, false, 0, 0);
+    const ib = gl.createBuffer();
+    gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, ib);
+    gl.bufferData(gl.ELEMENT_ARRAY_BUFFER, indices, gl.STATIC_DRAW);
+    gl.bindVertexArray(null);
+  }
+  get contextLost() {
+    return this.gl.isContextLost();
+  }
+  // ---------------------------------------------------------------- textures
+  texture(internal, format, type, size, data, mipmaps) {
+    const gl = this.gl;
+    const tex = gl.createTexture();
+    gl.bindTexture(gl.TEXTURE_2D, tex);
+    gl.pixelStorei(gl.UNPACK_ALIGNMENT, 1);
+    gl.texImage2D(gl.TEXTURE_2D, 0, internal, size, size, 0, format, type, data);
+    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
+    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
+    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR);
+    if (mipmaps) {
+      gl.generateMipmap(gl.TEXTURE_2D);
+      gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR_MIPMAP_LINEAR);
+      if (this.anisotropy) {
+        gl.texParameterf(gl.TEXTURE_2D, this.anisotropy.TEXTURE_MAX_ANISOTROPY_EXT, this.maxAnisotropy);
+      }
+    } else {
+      gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR);
+    }
+    return tex;
+  }
+  createBadgeTextures(out) {
+    const gl = this.gl;
+    const data = reliefMesh(out.surface, out.size);
+    const mesh = gl.createVertexArray();
+    const vertexBuffer = gl.createBuffer();
+    const indexBuffer = gl.createBuffer();
+    gl.bindVertexArray(mesh);
+    gl.bindBuffer(gl.ARRAY_BUFFER, vertexBuffer);
+    gl.bufferData(gl.ARRAY_BUFFER, data.vertices, gl.STATIC_DRAW);
+    gl.enableVertexAttribArray(0);
+    gl.vertexAttribPointer(0, 2, gl.FLOAT, false, 12, 0);
+    gl.enableVertexAttribArray(1);
+    gl.vertexAttribPointer(1, 1, gl.FLOAT, false, 12, 8);
+    gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, indexBuffer);
+    gl.bufferData(gl.ELEMENT_ARRAY_BUFFER, data.indices, gl.STATIC_DRAW);
+    gl.bindVertexArray(null);
+    return {
+      mesh,
+      vertexBuffer,
+      indexBuffer,
+      faceCount: data.faceCount,
+      sideCount: data.indices.length - data.faceCount,
+      surface: this.texture(gl.RGBA16F, gl.RGBA, gl.FLOAT, out.size, out.surface, this.floatTargets),
+      albedo: this.texture(gl.SRGB8_ALPHA8, gl.RGBA, gl.UNSIGNED_BYTE, out.size, out.albedo, true),
+      weights: this.texture(gl.RGBA8, gl.RGBA, gl.UNSIGNED_BYTE, out.size, out.weights, true),
+      size: out.size,
+      heightScale: out.heightScale
+    };
+  }
+  deleteBadgeTextures(t) {
+    const gl = this.gl;
+    gl.deleteVertexArray(t.mesh);
+    gl.deleteBuffer(t.vertexBuffer);
+    gl.deleteBuffer(t.indexBuffer);
+    gl.deleteTexture(t.surface);
+    gl.deleteTexture(t.albedo);
+    gl.deleteTexture(t.weights);
+  }
+  // ------------------------------------------------------------- environment
+  /** Pre-filtered environment textures, shared and reference-counted across badges. */
+  async acquireEnvironment(env) {
+    const key = env.key;
+    let entry = this.envCache.get(key);
+    if (!entry) {
+      const created = { refs: 0, promise: this.buildEnvironment(env) };
+      created.promise.then(
+        (t) => created.textures = t,
+        () => this.envCache.get(key) === created && this.envCache.delete(key)
+      );
+      this.envCache.set(key, created);
+      entry = created;
+    }
+    entry.refs++;
+    if (entry.disposeTimer) {
+      clearTimeout(entry.disposeTimer);
+      entry.disposeTimer = void 0;
+    }
+    try {
+      return { key, textures: await entry.promise };
+    } catch (error) {
+      entry.refs--;
+      throw error;
+    }
+  }
+  releaseEnvironment(handle) {
+    const entry = this.envCache.get(handle.key);
+    if (!entry || entry.textures !== handle.textures) return;
+    entry.refs--;
+    if (entry.refs > 0) return;
+    entry.disposeTimer = setTimeout(() => {
+      if (entry.refs > 0 || this.envCache.get(handle.key) !== entry) return;
+      this.envCache.delete(handle.key);
+      if (entry.textures && !this.gl.isContextLost()) {
+        this.gl.deleteTexture(entry.textures.spec);
+        this.gl.deleteTexture(entry.textures.irr);
+      }
+    }, 5e3);
+  }
+  envFormat() {
+    const gl = this.gl;
+    return this.floatTargets ? { internal: gl.RGBA16F, type: gl.HALF_FLOAT, scale: 1 } : { internal: gl.RGBA8, type: gl.UNSIGNED_BYTE, scale: 8 };
+  }
+  allocEnvTexture(width, height, levels) {
+    const gl = this.gl;
+    const { internal } = this.envFormat();
+    const tex = gl.createTexture();
+    gl.bindTexture(gl.TEXTURE_2D, tex);
+    gl.texStorage2D(gl.TEXTURE_2D, levels, internal, width, height);
+    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.REPEAT);
+    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
+    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR);
+    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, levels > 1 ? gl.LINEAR_MIPMAP_LINEAR : gl.LINEAR);
+    return tex;
+  }
+  async buildEnvironment(env) {
+    const gl = this.gl;
+    const { scale } = this.envFormat();
+    const generation = this.generation;
+    const image = env.kind === "image" ? await this.loadImageEnvironment(env.spec.url, (env.spec.intensity ?? 1) / scale) : null;
+    if (gl.isContextLost() || generation !== this.generation) {
+      throw new Error("badgecraft: environment invalidated by context loss");
+    }
+    const srcW = ENV_WIDTH * 2;
+    const srcH = ENV_WIDTH;
+    const srcLevels = Math.floor(Math.log2(srcW)) + 1;
+    const src = this.allocEnvTexture(srcW, srcH, srcLevels);
+    try {
+      if (env.kind === "procedural") {
+        this.renderProcedural(src, srcW, srcH, env.spec, scale);
+      } else if (image) {
+        this.uploadImageEnvironment(src, srcW, srcH, image);
+      }
+    } catch (error) {
+      gl.deleteTexture(src);
+      throw error;
+    }
+    gl.bindTexture(gl.TEXTURE_2D, src);
+    gl.generateMipmap(gl.TEXTURE_2D);
+    const spec = this.allocEnvTexture(ENV_WIDTH, ENV_WIDTH / 2, ENV_LEVELS);
+    const texelSA = 4 * Math.PI / (srcW * srcH);
+    const pre = this.prefilterProgram;
+    gl.useProgram(pre.program);
+    gl.activeTexture(gl.TEXTURE0);
+    gl.bindTexture(gl.TEXTURE_2D, src);
+    gl.uniform1i(pre.u.uSrc, 0);
+    gl.uniform1f(pre.u.uTexelSolidAngle, texelSA);
+    for (let level = 0; level < ENV_LEVELS; level++) {
+      const w = ENV_WIDTH >> level;
+      const h = Math.max(1, ENV_WIDTH / 2 >> level);
+      this.bindTarget(spec, level, w, h);
+      gl.uniform2f(pre.u.uSize, w, h);
+      gl.uniform1f(pre.u.uRoughness, level / (ENV_LEVELS - 1));
+      this.fullscreen();
+    }
+    const irr = this.allocEnvTexture(IRR_WIDTH, IRR_WIDTH / 2, 1);
+    const ip = this.irrProgram;
+    gl.useProgram(ip.program);
+    gl.bindTexture(gl.TEXTURE_2D, src);
+    gl.uniform1i(ip.u.uSrc, 0);
+    gl.uniform1f(ip.u.uTexelSolidAngle, texelSA);
+    this.bindTarget(irr, 0, IRR_WIDTH, IRR_WIDTH / 2);
+    gl.uniform2f(ip.u.uSize, IRR_WIDTH, IRR_WIDTH / 2);
+    this.fullscreen();
+    gl.bindFramebuffer(gl.FRAMEBUFFER, null);
+    gl.deleteTexture(src);
+    return { spec, irr, maxLod: ENV_LEVELS - 1, scale };
+  }
+  bindTarget(tex, level, w, h) {
+    const gl = this.gl;
+    gl.bindFramebuffer(gl.FRAMEBUFFER, this.fbo);
+    gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.TEXTURE_2D, tex, level);
+    gl.viewport(0, 0, w, h);
+    gl.disable(gl.BLEND);
+    gl.disable(gl.DEPTH_TEST);
+    gl.disable(gl.CULL_FACE);
+    gl.disable(gl.SCISSOR_TEST);
+  }
+  fullscreen() {
+    const gl = this.gl;
+    gl.bindVertexArray(this.emptyVao);
+    gl.drawArrays(gl.TRIANGLES, 0, 3);
+    gl.bindVertexArray(null);
+  }
+  renderProcedural(target, w, h, spec, scale) {
+    const gl = this.gl;
+    const p = this.envProgram;
+    const intensity = spec.intensity ?? 1;
+    const lights = (spec.lights ?? []).slice(0, MAX_LIGHTS);
+    const dirs = new Float32Array(MAX_LIGHTS * 3);
+    const colors = new Float32Array(MAX_LIGHTS * 3);
+    const shapes = new Float32Array(MAX_LIGHTS * 4);
+    lights.forEach((l, i) => {
+      const az = l.azimuth * Math.PI / 180;
+      const el = l.elevation * Math.PI / 180;
+      dirs.set([Math.sin(az) * Math.cos(el), Math.sin(el), Math.cos(az) * Math.cos(el)], i * 3);
+      const c = linearRgb(l.color ?? "#ffffff");
+      const k = (l.intensity ?? 1) * intensity;
+      colors.set([c[0] * k, c[1] * k, c[2] * k], i * 3);
+      const size = l.size ?? 30;
+      const [sw, sh] = Array.isArray(size) ? size : [size, size];
+      const t = (deg) => Math.tan(Math.min(deg, 170) * Math.PI / 360);
+      shapes.set([t(sw), t(sh), l.softness ?? 0.5, l.shape === "circle" ? 1 : 0], i * 4);
+    });
+    const top = linearRgb(spec.top ?? "#555555").map((v) => v * intensity);
+    const horizon = linearRgb(spec.horizon ?? "#222222").map((v) => v * intensity);
+    const bottom = linearRgb(spec.bottom ?? "#080808").map((v) => v * intensity);
+    gl.useProgram(p.program);
+    this.bindTarget(target, 0, w, h);
+    gl.uniform2f(p.u.uSize, w, h);
+    gl.uniform3fv(p.u.uTop, top);
+    gl.uniform3fv(p.u.uHorizon, horizon);
+    gl.uniform3fv(p.u.uBottom, bottom);
+    gl.uniform1i(p.u.uLightCount, lights.length);
+    gl.uniform3fv(p.u.uLightDir, dirs);
+    gl.uniform3fv(p.u.uLightColor, colors);
+    gl.uniform4fv(p.u.uLightShape, shapes);
+    gl.uniform1f(p.u.uScale, 1 / scale);
+    this.fullscreen();
+  }
+  async loadImageEnvironment(url, intensity) {
+    let width;
+    let height;
+    let data;
+    if (/\.hdr(\?|#|$)/i.test(url)) {
+      const res = await fetch(url);
+      if (!res.ok) throw new Error(`badgecraft: failed to load environment ${url}`);
+      ({ width, height, data } = decodeHdr(await res.arrayBuffer()));
+    } else {
+      const img = new Image();
+      img.crossOrigin = "anonymous";
+      img.src = url;
+      await img.decode();
+      const scale = Math.min(1, 2048 / Math.max(img.naturalWidth, img.naturalHeight));
+      width = Math.max(1, Math.round(img.naturalWidth * scale));
+      height = Math.max(1, Math.round(img.naturalHeight * scale));
+      const c = document.createElement("canvas");
+      c.width = width;
+      c.height = height;
+      const ctx = c.getContext("2d");
+      ctx.drawImage(img, 0, 0, width, height);
+      const px = ctx.getImageData(0, 0, width, height).data;
+      data = new Float32Array(width * height * 4);
+      const lut = new Float32Array(256);
+      for (let i = 0; i < 256; i++) {
+        const v = i / 255;
+        lut[i] = v <= 0.04045 ? v / 12.92 : Math.pow((v + 0.055) / 1.055, 2.4);
+      }
+      for (let i = 0; i < width * height; i++) {
+        data[i * 4] = lut[px[i * 4]];
+        data[i * 4 + 1] = lut[px[i * 4 + 1]];
+        data[i * 4 + 2] = lut[px[i * 4 + 2]];
+        data[i * 4 + 3] = 1;
+      }
+    }
+    for (let i = 0; i < data.length; i++) if ((i & 3) !== 3) data[i] *= intensity;
+    return { width, height, data };
+  }
+  uploadImageEnvironment(target, w, h, image) {
+    const gl = this.gl;
+    const { width, height, data } = image;
+    const limit = gl.getParameter(gl.MAX_TEXTURE_SIZE);
+    if (width > limit || height > limit) {
+      throw new Error(`badgecraft: environment dimensions exceed the GPU texture limit (${limit}px)`);
+    }
+    const tmp = gl.createTexture();
+    gl.bindTexture(gl.TEXTURE_2D, tmp);
+    gl.pixelStorei(gl.UNPACK_ALIGNMENT, 1);
+    const floatLinear = !!gl.getExtension("OES_texture_float_linear");
+    gl.texImage2D(gl.TEXTURE_2D, 0, floatLinear ? gl.RGBA32F : gl.RGBA16F, width, height, 0, gl.RGBA, gl.FLOAT, data);
+    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR);
+    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR);
+    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.REPEAT);
+    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
+    const pre = this.prefilterProgram;
+    gl.useProgram(pre.program);
+    gl.activeTexture(gl.TEXTURE0);
+    gl.uniform1i(pre.u.uSrc, 0);
+    gl.uniform1f(pre.u.uRoughness, 0);
+    gl.uniform1f(pre.u.uTexelSolidAngle, 4 * Math.PI / (width * height));
+    this.bindTarget(target, 0, w, h);
+    gl.bindTexture(gl.TEXTURE_2D, tmp);
+    gl.uniform2f(pre.u.uSize, w, h);
+    this.fullscreen();
+    gl.deleteTexture(tmp);
+  }
+  // ------------------------------------------------------------------ drawing
+  ensureSize(w, h) {
+    const c = this.canvas;
+    if (c.width >= w && c.height >= h) return;
+    c.width = Math.max(c.width, Math.ceil(w / 128) * 128);
+    c.height = Math.max(c.height, Math.ceil(h / 128) * 128);
+  }
+  /** Draw a badge and copy the result into `target`. */
+  draw(p, target) {
+    const gl = this.gl;
+    if (gl.isContextLost()) return;
+    const sampleScale = Math.max(1, Math.min(2, this.renderLimit / Math.max(p.width, p.height)));
+    const w = Math.round(p.width * sampleScale);
+    const h = Math.round(p.height * sampleScale);
+    this.ensureSize(w, h);
+    gl.bindFramebuffer(gl.FRAMEBUFFER, null);
+    gl.viewport(0, 0, w, h);
+    gl.enable(gl.SCISSOR_TEST);
+    gl.scissor(0, 0, w, h);
+    gl.clearColor(0, 0, 0, 0);
+    gl.clearDepth(1);
+    gl.depthMask(true);
+    gl.clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT);
+    gl.enable(gl.BLEND);
+    gl.blendFunc(gl.ONE, gl.ONE_MINUS_SRC_ALPHA);
+    gl.enable(gl.DEPTH_TEST);
+    gl.depthFunc(gl.LEQUAL);
+    const fov = 22 * Math.PI / 180;
+    const aspect = w / h;
+    const extent = 0.5 / (1 - 2 * Math.min(0.4, Math.max(0, p.padding)));
+    const fit = aspect >= 1 ? extent : extent / aspect;
+    const dist = fit / Math.tan(fov / 2);
+    const proj = perspective(fov, aspect, Math.max(0.05, dist - 2), dist + 2);
+    const viewProj = multiply(proj, translation(0, 0, -dist));
+    const model = rotation(p.pitch, p.yaw, p.roll);
+    const nMat = normalMatrix(model);
+    const depth = p.locked ? 0 : p.maps.heightScale;
+    const thickness = p.locked ? 0 : p.thickness;
+    const edgeTexels = Math.max(1, p.edge * p.maps.size);
+    gl.activeTexture(gl.TEXTURE0);
+    gl.bindTexture(gl.TEXTURE_2D, p.maps.surface);
+    if (p.shadow > 0 && !p.locked) {
+      const s = this.shadowProgram;
+      gl.useProgram(s.program);
+      gl.depthMask(false);
+      gl.disable(gl.CULL_FACE);
+      gl.uniformMatrix4fv(s.u.uModel, false, model);
+      gl.uniformMatrix4fv(s.u.uViewProj, false, viewProj);
+      gl.uniform1i(s.u.uSurface, 0);
+      gl.uniform1f(s.u.uZ, -thickness - 0.01);
+      gl.uniform1f(s.u.uOffset, 0.018);
+      gl.uniform1f(s.u.uSpread, 1);
+      gl.uniform1f(s.u.uOpacity, p.shadow);
+      gl.uniform1f(s.u.uBlur, p.shadowBlur * p.maps.size);
+      gl.bindVertexArray(this.shadowQuad);
+      gl.drawElements(gl.TRIANGLES, 6, gl.UNSIGNED_SHORT, 0);
+      gl.depthMask(true);
+    }
+    const b = this.badgeProgram;
+    gl.useProgram(b.program);
+    gl.activeTexture(gl.TEXTURE1);
+    gl.bindTexture(gl.TEXTURE_2D, p.maps.albedo);
+    gl.activeTexture(gl.TEXTURE2);
+    gl.bindTexture(gl.TEXTURE_2D, p.maps.weights);
+    gl.activeTexture(gl.TEXTURE3);
+    gl.bindTexture(gl.TEXTURE_2D, p.env.spec);
+    gl.activeTexture(gl.TEXTURE4);
+    gl.bindTexture(gl.TEXTURE_2D, p.env.irr);
+    gl.uniform1i(b.u.uSurface, 0);
+    gl.uniform1i(b.u.uAlbedo, 1);
+    gl.uniform1i(b.u.uWeights, 2);
+    gl.uniform1i(b.u.uEnvSpec, 3);
+    gl.uniform1i(b.u.uEnvIrr, 4);
+    gl.uniform1f(b.u.uEnvMaxLod, p.env.maxLod);
+    gl.uniform1f(b.u.uEnvScale, p.env.scale);
+    gl.uniform1f(b.u.uEnvRotation, p.envRotation / (2 * Math.PI));
+    gl.uniformMatrix4fv(b.u.uModel, false, model);
+    gl.uniformMatrix4fv(b.u.uViewProj, false, viewProj);
+    gl.uniformMatrix3fv(b.u.uNormalMatrix, false, nMat);
+    gl.uniform3f(b.u.uCamPos, 0, 0, dist);
+    gl.uniform1f(b.u.uMapSize, p.maps.size);
+    gl.uniform1f(b.u.uPixelScale, sampleScale);
+    gl.uniform1f(b.u.uDepth, depth);
+    gl.uniform1f(b.u.uThickness, thickness);
+    gl.uniform1f(b.u.uEdgeTexels, edgeTexels);
+    gl.uniform1f(b.u.uAo, p.ao);
+    gl.uniform1f(b.u.uExposure, p.exposure);
+    gl.uniform1i(b.u.uToneMap, p.toneMapping);
+    gl.uniform1f(b.u.uLocked, p.locked ? 1 : 0);
+    gl.uniform3fv(b.u.uLockedColor, p.lockedColor);
+    gl.uniform1f(b.u.uShine, p.shine);
+    this.setMaterials(b.u, p.materials);
+    gl.enable(gl.CULL_FACE);
+    gl.cullFace(gl.BACK);
+    gl.bindVertexArray(p.maps.mesh);
+    if (!p.locked) {
+      gl.frontFace(gl.CW);
+      gl.uniform1f(b.u.uSide, -1);
+      gl.drawElements(gl.TRIANGLES, p.maps.faceCount, gl.UNSIGNED_INT, 0);
+    }
+    gl.frontFace(gl.CCW);
+    gl.uniform1f(b.u.uSide, 1);
+    gl.drawElements(gl.TRIANGLES, p.maps.faceCount, gl.UNSIGNED_INT, 0);
+    if (!p.locked && p.maps.sideCount > 0) {
+      gl.uniform1f(b.u.uSide, 0);
+      gl.drawElements(gl.TRIANGLES, p.maps.sideCount, gl.UNSIGNED_INT, p.maps.faceCount * 4);
+    }
+    gl.bindVertexArray(null);
+    gl.disable(gl.SCISSOR_TEST);
+    target.clearRect(0, 0, target.canvas.width, target.canvas.height);
+    target.imageSmoothingEnabled = true;
+    target.imageSmoothingQuality = "high";
+    target.drawImage(this.canvas, 0, this.canvas.height - h, w, h, 0, 0, target.canvas.width, target.canvas.height);
+  }
+  setMaterials(u, mats) {
+    const gl = this.gl;
+    const color = new Float32Array(16);
+    const a = new Float32Array(16);
+    const b = new Float32Array(16);
+    const c = new Float32Array(16);
+    mats.forEach((m, i) => {
+      const lin = linearRgb(m.color);
+      color.set([lin[0], lin[1], lin[2], m.useSvgColor ? 1 : 0], i * 4);
+      a.set([m.metalness, m.roughness, m.clearcoat, m.clearcoatRoughness], i * 4);
+      const f0 = ((m.ior - 1) / (m.ior + 1)) ** 2;
+      const coatedF0 = ((m.ior - 1.5) / (m.ior + 1.5)) ** 2;
+      const coat = Math.min(1, Math.max(0, m.clearcoat));
+      b.set([f0 + (coatedF0 - f0) * coat, m.iridescence, m.iridescenceThickness, m.flakes], i * 4);
+      c.set([m.brushed, BRUSH_DIRS[m.brushDirection] ?? 0, m.flakeScale, m.emissive], i * 4);
+    });
+    gl.uniform4fv(u.uMatColor, color);
+    gl.uniform4fv(u.uMatA, a);
+    gl.uniform4fv(u.uMatB, b);
+    gl.uniform4fv(u.uMatC, c);
+  }
+};
+
+// src/scheduler.ts
+var active = /* @__PURE__ */ new Set();
+var rescheduled = /* @__PURE__ */ new Set();
+var raf = 0;
+var last = 0;
+var ticking = false;
+function tick(now) {
+  raf = 0;
+  ticking = true;
+  const dt = last ? Math.min(0.05, (now - last) / 1e3) : 1 / 60;
+  last = now;
+  rescheduled.clear();
+  for (const task of [...active]) {
+    let keep = false;
+    try {
+      keep = task.frame(dt, now);
+    } catch (error) {
+      console.error(error);
+    }
+    if (!keep && !rescheduled.has(task)) active.delete(task);
+  }
+  rescheduled.clear();
+  ticking = false;
+  if (active.size > 0) raf = requestAnimationFrame(tick);
+  else last = 0;
+}
+function schedule(task) {
+  active.add(task);
+  if (ticking) {
+    rescheduled.add(task);
+    return;
+  }
+  if (!raf && typeof requestAnimationFrame !== "undefined") raf = requestAnimationFrame(tick);
+}
+function unschedule(task) {
+  active.delete(task);
+  rescheduled.delete(task);
+}
+
+// src/svg/load.ts
+var fetched = /* @__PURE__ */ new Map();
+async function loadSvgSource(input) {
+  if (typeof input !== "string") return Promise.resolve(new XMLSerializer().serializeToString(input));
+  const s = input.trim();
+  if (!s) throw new Error("badgecraft: SVG source is empty");
+  if (s.startsWith("<")) return Promise.resolve(s);
+  if (s.startsWith("data:")) {
+    const comma = s.indexOf(",");
+    if (comma < 0) throw new Error("badgecraft: invalid SVG data URL");
+    const meta = s.slice(0, comma);
+    const body = s.slice(comma + 1);
+    return Promise.resolve(meta.includes(";base64") ? decodeURIComponent(escape(atob(body))) : decodeURIComponent(body));
+  }
+  const key = new URL(s, document.baseURI).href;
+  let pending = fetched.get(key);
+  if (pending) {
+    fetched.delete(key);
+    fetched.set(key, pending);
+    return pending;
+  }
+  const job = fetch(key).then((res) => {
+    if (!res.ok) throw new Error(`badgecraft: failed to load SVG from ${s} (${res.status})`);
+    return res.text();
+  });
+  job.catch(() => fetched.get(key) === job && fetched.delete(key));
+  fetched.set(key, job);
+  while (fetched.size > 32) fetched.delete(fetched.keys().next().value);
+  return job;
+}
+
+// src/badge.ts
+var MAX_PIXELS = 2048;
+function stepSpring(s, dt, stiffness, damping) {
+  const steps = Math.ceil(dt / (1 / 240));
+  const h = dt / steps;
+  for (let i = 0; i < steps; i++) {
+    const a = stiffness * (s.target - s.x) - damping * s.v;
+    s.v += a * h;
+    s.x += s.v * h;
+  }
+  if (Math.abs(s.target - s.x) < 0.02 && Math.abs(s.v) < 0.2) {
+    s.x = s.target;
+    s.v = 0;
+    return false;
+  }
+  return true;
+}
+var prefersReducedMotion = () => typeof matchMedia !== "undefined" && matchMedia("(prefers-reduced-motion: reduce)").matches;
+var Badgecraft = class {
+  constructor(host, options) {
+    this.maps = null;
+    this.mapSize = 0;
+    this.pendingSize = 0;
+    this.env = null;
+    this.fallbackImage = null;
+    this.bakeToken = 0;
+    this.envToken = 0;
+    this.visible = true;
+    this.destroyed = false;
+    this.dirty = true;
+    this.isReady = false;
+    this.cleanups = [];
+    // Motion state, in degrees.
+    this.pitch = { x: 0, v: 0, target: 0 };
+    this.yaw = { x: 0, v: 0, target: 0 };
+    this.hover = null;
+    this.drag = null;
+    this.coasting = false;
+    this.spinning = false;
+    this.time = 0;
+    this.shine = 0;
+    this.shineStart = -1;
+    this.host = host;
+    this.options = { ...options };
+    this.resolved = resolveOptions(this.options);
+    this.ready = new Promise((resolve, reject) => {
+      this.resolveReady = resolve;
+      this.rejectReady = reject;
+    });
+    this.ready.catch(() => {
+    });
+    this.canvas = document.createElement("canvas");
+    this.canvas.setAttribute("aria-hidden", "true");
+    this.canvas.style.cssText = "display:block;width:100%;height:100%;";
+    this.canvas.width = 0;
+    this.canvas.height = 0;
+    host.appendChild(this.canvas);
+    if (!host.hasAttribute("role")) host.setAttribute("role", "img");
+    this.ensureHostSize();
+    const ctx = this.canvas.getContext("2d");
+    if (!ctx) {
+      this.canvas.remove();
+      throw new Error("badgecraft: 2D canvas unavailable");
+    }
+    this.ctx = ctx;
+    this.renderer = Renderer.shared();
+    if (this.renderer) {
+      this.cleanups.push(this.renderer.onRestore(() => this.handleContextRestore()));
+    }
+    this.observe();
+    this.bindPointer();
+    this.applyInteractionStyle();
+    this.loadEnvironment();
+  }
+  ensureHostSize() {
+    const host = this.host;
+    if (host.getClientRects().length > 0) {
+      const style = getComputedStyle(host);
+      if (host.clientHeight === 0 && !style.aspectRatio.includes("/")) host.style.aspectRatio = "1 / 1";
+      if (host.clientWidth === 0 && style.display === "inline") host.style.display = "inline-block";
+      if (host.clientWidth === 0 && !host.style.width) host.style.width = "160px";
+    }
+  }
+  // ------------------------------------------------------------------ public
+  /** Merge new options. Only what changed is recomputed. */
+  update(partial) {
+    this.setOptions({ ...this.options, ...partial });
+  }
+  /** Replace all options. */
+  setOptions(options) {
+    if (this.destroyed) return;
+    const prev = this.resolved;
+    const prevSvg = this.options.svg;
+    this.options = { ...options };
+    this.resolved = resolveOptions(this.options);
+    const next = this.resolved;
+    const needsLargerMaps = next.quality === "auto" && next.render.padding !== prev.render.padding && this.targetMapSize() > this.mapSize * 1.25;
+    if (next.bakeKey !== prev.bakeKey || this.options.svg !== prevSvg || next.quality !== prev.quality || needsLargerMaps) {
+      this.rebuild();
+    }
+    if (next.render.environment.key !== prev.render.environment.key) this.loadEnvironment();
+    if (next.render.interaction !== prev.render.interaction || next.render.locked !== prev.render.locked) {
+      this.stopMotion();
+      this.applyInteractionStyle();
+    }
+    if (next.renderKey !== prev.renderKey) this.invalidate();
+  }
+  spin(turns = 1) {
+    if (this.destroyed || this.resolved.render.locked || !Number.isFinite(turns * 360) || prefersReducedMotion()) return;
+    this.spinning = true;
+    this.coasting = false;
+    this.yaw.target = Math.round(this.yaw.x / 360) * 360 + 360 * turns;
+    this.pitch.target = 0;
+    this.invalidate();
+  }
+  /** Sweep a highlight across the badge once. */
+  glint() {
+    if (this.destroyed || this.resolved.render.locked || prefersReducedMotion()) return;
+    this.shineStart = this.time;
+    this.invalidate();
+  }
+  toDataURL(type = "image/png", quality) {
+    this.renderNow();
+    return this.canvas.toDataURL(type, quality);
+  }
+  toBlob(type = "image/png", quality) {
+    this.renderNow();
+    return new Promise((resolve) => this.canvas.toBlob(resolve, type, quality));
+  }
+  destroy() {
+    if (this.destroyed) return;
+    this.destroyed = true;
+    this.bakeToken++;
+    this.envToken++;
+    if (!this.isReady) this.rejectReady(new DOMException("badgecraft: destroyed before ready", "AbortError"));
+    unschedule(this);
+    this.cleanups.forEach((fn) => fn());
+    if (this.maps && this.renderer) releaseMaps(this.renderer, this.maps);
+    if (this.env && this.renderer) this.renderer.releaseEnvironment(this.env);
+    this.maps = null;
+    this.env = null;
+    this.fallbackImage = null;
+    this.canvas.remove();
+  }
+  // --------------------------------------------------------------- lifecycle
+  observe() {
+    const ro = new ResizeObserver((entries) => {
+      const entry = entries[entries.length - 1];
+      const box = entry.devicePixelContentBoxSize?.[0];
+      const dpr = window.devicePixelRatio || 1;
+      const w = box ? box.inlineSize : Math.round(entry.contentRect.width * dpr);
+      const h = box ? box.blockSize : Math.round(entry.contentRect.height * dpr);
+      this.resize(w, h);
+    });
+    try {
+      ro.observe(this.canvas, { box: "device-pixel-content-box" });
+    } catch {
+      ro.observe(this.canvas);
+    }
+    this.cleanups.push(() => ro.disconnect());
+    if (typeof IntersectionObserver !== "undefined") {
+      const io = new IntersectionObserver(
+        (entries) => {
+          this.visible = entries[entries.length - 1].isIntersecting;
+          if (this.visible) this.invalidate();
+        },
+        { rootMargin: "200px" }
+      );
+      io.observe(this.canvas);
+      this.cleanups.push(() => io.disconnect());
+    }
+  }
+  resize(w, h) {
+    if (w <= 0 || h <= 0) {
+      if (this.host.getClientRects().length > 0) {
+        requestAnimationFrame(() => {
+          if (!this.destroyed) this.ensureHostSize();
+        });
+      }
+      return;
+    }
+    const scale = Math.min(1, MAX_PIXELS / Math.max(w, h));
+    w = Math.max(1, Math.round(w * scale));
+    h = Math.max(1, Math.round(h * scale));
+    if (this.canvas.width !== w || this.canvas.height !== h) {
+      this.canvas.width = w;
+      this.canvas.height = h;
+      this.dirty = true;
+    }
+    const wanted = this.targetMapSize();
+    const grow = !this.maps || wanted > this.mapSize * 1.25;
+    if (grow && wanted !== this.pendingSize && this.renderer) this.rebuild();
+    else if (!this.renderer && !this.fallbackImage) this.rebuild();
+    if (this.renderer) this.renderNow();
+    else this.paintFallback();
+  }
+  targetMapSize() {
+    const q = this.resolved.quality;
+    if (q !== "auto") return q;
+    const px = Math.max(this.canvas.width, this.canvas.height) * (1 - 2 * this.resolved.render.padding);
+    return clamp(Math.ceil(px * 1.2 / 64) * 64, 256, 1024);
+  }
+  async rebuild() {
+    const token = ++this.bakeToken;
+    if (this.canvas.width <= 0 && this.resolved.quality === "auto") return;
+    const size = this.targetMapSize();
+    this.pendingSize = size;
+    try {
+      const source = await loadSvgSource(this.options.svg);
+      if (token !== this.bakeToken || this.destroyed) return;
+      if (!this.renderer) {
+        const image = await this.loadFallback(source);
+        if (token !== this.bakeToken || this.destroyed) return;
+        this.fallbackImage = image;
+        this.paintFallback();
+        this.markReady();
+        return;
+      }
+      const { bake: bake2, bakeKey } = this.resolved;
+      const key = mapsKey(source, bakeKey, size);
+      if (this.maps?.key === key) return;
+      const handle = await acquireMaps(this.renderer, key, () => bakeSvg(source, bake2, size));
+      if (token !== this.bakeToken || this.destroyed) {
+        releaseMaps(this.renderer, handle);
+        return;
+      }
+      if (this.maps) releaseMaps(this.renderer, this.maps);
+      this.maps = handle;
+      this.mapSize = size;
+      this.invalidate();
+    } catch (error) {
+      if (token === this.bakeToken) this.fail(error);
+    } finally {
+      if (token === this.bakeToken) this.pendingSize = 0;
+    }
+  }
+  async loadEnvironment() {
+    if (!this.renderer) return;
+    const token = ++this.envToken;
+    const env = this.resolved.render.environment;
+    try {
+      const handle = await this.renderer.acquireEnvironment(env);
+      if (token !== this.envToken || this.destroyed) {
+        this.renderer.releaseEnvironment(handle);
+        return;
+      }
+      if (this.env) this.renderer.releaseEnvironment(this.env);
+      this.env = handle;
+      this.invalidate();
+    } catch (error) {
+      if (token === this.envToken && !this.renderer.contextLost) this.fail(error);
+    }
+  }
+  handleContextRestore() {
+    if (this.destroyed) return;
+    this.maps = null;
+    this.env = null;
+    this.mapSize = 0;
+    this.loadEnvironment();
+    this.rebuild();
+  }
+  fail(error) {
+    if (this.destroyed) return;
+    const err = error instanceof Error ? error : new Error(String(error));
+    if (!this.isReady) this.rejectReady(err);
+    if (this.options.onError) this.options.onError(err);
+    else console.error(err);
+  }
+  markReady() {
+    if (this.isReady) return;
+    this.isReady = true;
+    this.resolveReady();
+    this.options.onReady?.();
+  }
+  /** Without WebGL2, show the flat artwork. */
+  async loadFallback(source) {
+    const root = parseSvg(source);
+    if (!root.hasAttribute("color")) root.setAttribute("color", this.resolved.bake.color);
+    source = new XMLSerializer().serializeToString(root);
+    const url = URL.createObjectURL(new Blob([source], { type: "image/svg+xml" }));
+    try {
+      const img = new Image();
+      img.src = url;
+      await img.decode();
+      return img;
+    } finally {
+      URL.revokeObjectURL(url);
+    }
+  }
+  paintFallback() {
+    const img = this.fallbackImage;
+    if (!img) return;
+    const { width, height } = this.canvas;
+    this.ctx.clearRect(0, 0, width, height);
+    const s = Math.min(width, height) * (1 - 2 * this.resolved.render.padding);
+    const scale = s / Math.max(img.naturalWidth, img.naturalHeight);
+    const w = img.naturalWidth * scale;
+    const h = img.naturalHeight * scale;
+    this.ctx.drawImage(img, (width - w) / 2, (height - h) / 2, w, h);
+  }
+  // ---------------------------------------------------------------- drawing
+  invalidate() {
+    this.dirty = true;
+    if (!this.destroyed) schedule(this);
+  }
+  renderNow() {
+    const r = this.renderer;
+    if (!r || !this.maps || !this.env || this.destroyed || r.contextLost) return;
+    if (this.canvas.width <= 0) return;
+    const s = this.resolved.render;
+    const rad = Math.PI / 180;
+    r.draw(
+      {
+        width: this.canvas.width,
+        height: this.canvas.height,
+        maps: this.maps.textures,
+        env: this.env.textures,
+        materials: s.materials,
+        pitch: (this.pitch.x + (s.locked ? 0 : s.pose.pitch)) * rad,
+        yaw: (this.yaw.x + (s.locked ? 0 : s.pose.yaw)) * rad,
+        roll: (s.locked ? 0 : s.pose.roll) * rad,
+        thickness: s.thickness,
+        edge: s.edge,
+        ao: s.ao,
+        exposure: s.exposure,
+        toneMapping: s.toneMapping,
+        envRotation: s.envRotation,
+        locked: s.locked,
+        lockedColor: linearRgb(s.lockedColor),
+        shadow: s.shadow,
+        shadowBlur: 0.022,
+        padding: s.padding,
+        shine: this.shine
+      },
+      this.ctx
+    );
+    this.dirty = false;
+    this.markReady();
+  }
+  /** Scheduler callback: advance motion, redraw if needed. */
+  frame(dt) {
+    if (this.destroyed) return false;
+    this.time += dt;
+    const s = this.resolved.render;
+    const reduced = prefersReducedMotion();
+    let moving = false;
+    const before = this.pitch.x + this.yaw.x * 1e3 + this.shine * 1e7;
+    if (!this.drag && !this.spinning && !this.coasting) {
+      let tp = 0;
+      let ty = 0;
+      if (this.hover && s.interaction === "tilt" && !s.locked) {
+        const max = reduced ? s.tiltMax * 0.4 : s.tiltMax;
+        tp = this.hover.y * max;
+        ty = this.hover.x * max;
+      } else if (s.idle === "float" && !reduced && !s.locked) {
+        tp = Math.sin(this.time * 0.9) * 4;
+        ty = Math.sin(this.time * 0.6 + 1.3) * 7;
+        moving = true;
+      }
+      this.pitch.target = tp;
+      this.yaw.target = Math.round(this.yaw.x / 360) * 360 + ty;
+    }
+    if (this.drag) {
+      moving = true;
+    } else if (this.coasting) {
+      this.yaw.x += this.yaw.v * dt;
+      this.yaw.v *= Math.exp(-dt * 1.6);
+      stepSpring(this.pitch, dt, 120, 18);
+      if (Math.abs(this.yaw.v) < 120) {
+        this.coasting = false;
+        this.spinning = true;
+        this.yaw.target = Math.round(this.yaw.x / 360) * 360;
+      }
+      moving = true;
+    } else {
+      const k = this.spinning ? 26 : 140;
+      const c = this.spinning ? 2 * Math.sqrt(k) * 0.82 : 2 * Math.sqrt(k) * 0.72;
+      const a = stepSpring(this.pitch, dt, k, c);
+      const b = stepSpring(this.yaw, dt, k, c);
+      if (!a && !b && this.spinning) {
+        this.spinning = false;
+        this.yaw.x = this.yaw.target = (this.yaw.x % 360 + 360) % 360;
+      }
+      moving = moving || a || b;
+    }
+    if (s.idle === "shine" && !reduced && !s.locked && this.shineStart < 0) {
+      if (this.time % 5 < dt) this.shineStart = this.time;
+      moving = true;
+    }
+    if (this.shineStart >= 0) {
+      const t = (this.time - this.shineStart) / 1.3;
+      this.shine = t >= 1 ? 0 : Math.max(1e-4, t);
+      if (t >= 1) this.shineStart = -1;
+      moving = true;
+    }
+    if (this.pitch.x + this.yaw.x * 1e3 + this.shine * 1e7 !== before) this.dirty = true;
+    if (this.dirty) {
+      if (this.renderer) this.renderNow();
+      else {
+        this.paintFallback();
+        this.dirty = false;
+      }
+    }
+    return moving && this.visible;
+  }
+  // ------------------------------------------------------------ interaction
+  stopMotion() {
+    const id = this.drag?.id;
+    this.drag = null;
+    if (id !== void 0 && this.canvas.hasPointerCapture(id)) this.canvas.releasePointerCapture(id);
+    this.hover = null;
+    this.coasting = false;
+    this.spinning = false;
+    this.pitch.v = this.yaw.v = 0;
+    this.pitch.target = 0;
+    this.yaw.target = Math.round(this.yaw.x / 360) * 360;
+  }
+  applyInteractionStyle() {
+    const mode = this.resolved.render.locked ? "none" : this.resolved.render.interaction;
+    this.canvas.style.touchAction = mode === "drag" ? "none" : "pan-y";
+    this.canvas.style.cursor = mode === "drag" ? "grab" : "";
+  }
+  bindPointer() {
+    const el = this.canvas;
+    const local = (e) => {
+      const rect = el.getBoundingClientRect();
+      return {
+        x: clamp((e.clientX - rect.left) / rect.width * 2 - 1, -1, 1),
+        y: clamp((e.clientY - rect.top) / rect.height * 2 - 1, -1, 1)
+      };
+    };
+    const onMove = (e) => {
+      const mode = this.resolved.render.interaction;
+      if (mode === "tilt" && e.pointerType !== "touch") {
+        this.hover = local(e);
+        this.invalidate();
+      }
+      if (this.drag && e.pointerId === this.drag.id) {
+        const dx = e.clientX - this.drag.x;
+        const dy = e.clientY - this.drag.y;
+        const now = performance.now();
+        const prevYaw = this.yaw.x;
+        this.yaw.x = this.drag.yaw + dx * 0.7;
+        this.pitch.x = clamp(this.drag.pitch + dy * 0.35, -30, 30);
+        const dt = Math.max(1, now - this.drag.t) / 1e3;
+        this.drag.vx = this.drag.vx * 0.6 + (this.yaw.x - prevYaw) / dt * 0.4;
+        this.drag.t = now;
+        this.yaw.v = 0;
+        this.pitch.v = 0;
+        this.invalidate();
+      }
+    };
+    const onLeave = () => {
+      this.hover = null;
+      this.invalidate();
+    };
+    const onDown = (e) => {
+      if (this.drag || e.button !== 0 || this.resolved.render.interaction !== "drag" || this.resolved.render.locked) return;
+      el.setPointerCapture(e.pointerId);
+      this.spinning = false;
+      this.coasting = false;
+      this.drag = { id: e.pointerId, x: e.clientX, y: e.clientY, yaw: this.yaw.x, pitch: this.pitch.x, t: performance.now(), vx: 0 };
+      el.style.cursor = "grabbing";
+      this.invalidate();
+    };
+    const onUp = (e) => {
+      if (!this.drag || e.pointerId !== this.drag.id) return;
+      const idle = performance.now() - this.drag.t > 80;
+      this.yaw.v = idle || e.type !== "pointerup" || prefersReducedMotion() ? 0 : clamp(this.drag.vx, -2400, 2400);
+      this.drag = null;
+      el.style.cursor = "grab";
+      this.pitch.target = 0;
+      if (Math.abs(this.yaw.v) > 120) this.coasting = true;
+      else {
+        this.spinning = true;
+        this.yaw.target = Math.round(this.yaw.x / 360) * 360;
+      }
+      this.invalidate();
+    };
+    el.addEventListener("pointermove", onMove);
+    el.addEventListener("pointerleave", onLeave);
+    el.addEventListener("pointerdown", onDown);
+    el.addEventListener("pointerup", onUp);
+    el.addEventListener("pointercancel", onUp);
+    el.addEventListener("lostpointercapture", onUp);
+    this.cleanups.push(() => {
+      el.removeEventListener("pointermove", onMove);
+      el.removeEventListener("pointerleave", onLeave);
+      el.removeEventListener("pointerdown", onDown);
+      el.removeEventListener("pointerup", onUp);
+      el.removeEventListener("pointercancel", onUp);
+      el.removeEventListener("lostpointercapture", onUp);
+    });
+  }
+};
+function createBadge(host, options) {
+  return new Badgecraft(host, options);
+}
+
+export { Badgecraft, createBadge, defaults, environments, framePaths, materials, resolveMaterial };
+//# sourceMappingURL=chunk-RRYBMB25.js.map
+//# sourceMappingURL=chunk-RRYBMB25.js.map