gamesteel 0.2.0 → 0.3.0

package/dist/pkgs/artgen/dist/draw-worker.js

@@ -0,0 +1,1574 @@
+import { fileURLToPath as __gamesteelPath } from 'node:url';
+import { createRequire as __gamesteelRequire } from 'node:module';
+const __gamesteelRoot = new URL("../../../", import.meta.url);
+const __gamesteelResolve = (spec) => __gamesteelPath(new URL('resolved/' + spec, __gamesteelRoot));
+const require = __gamesteelRequire(import.meta.url);
+
+// ../artgen/dist/draw-worker.js
+import { parentPort } from "node:worker_threads";
+
+// ../artgen/dist/raster.js
+var CLEAR = [0, 0, 0, 0];
+var Raster = class {
+  w;
+  h;
+  d;
+  constructor(w, h) {
+    this.w = w;
+    this.h = h;
+    this.d = new Float32Array(w * h * 4);
+  }
+  get(x, y) {
+    const i = (y * this.w + x) * 4;
+    return [this.d[i] ?? 0, this.d[i + 1] ?? 0, this.d[i + 2] ?? 0, this.d[i + 3] ?? 0];
+  }
+  set(x, y, c) {
+    if (x < 0 || y < 0 || x >= this.w || y >= this.h)
+      return;
+    const i = (y * this.w + x) * 4;
+    this.d[i] = c[0];
+    this.d[i + 1] = c[1];
+    this.d[i + 2] = c[2];
+    this.d[i + 3] = c[3];
+  }
+  /** Source over. */
+  over(x, y, c) {
+    if (x < 0 || y < 0 || x >= this.w || y >= this.h || c[3] <= 0)
+      return;
+    const b = this.get(x, y);
+    const a = c[3] + b[3] * (1 - c[3]);
+    if (a <= 0)
+      return;
+    const k = b[3] * (1 - c[3]);
+    this.set(x, y, [(c[0] * c[3] + b[0] * k) / a, (c[1] * c[3] + b[1] * k) / a, (c[2] * c[3] + b[2] * k) / a, a]);
+  }
+  blit(src, x, y) {
+    for (let sy = 0; sy < src.h; sy++)
+      for (let sx = 0; sx < src.w; sx++)
+        this.over(x + sx, y + sy, src.get(sx, sy));
+  }
+  /** Every pixel from a shader. One sample is crisp, for pixel art; more
+   *  samples average sub-pixel positions, for smooth edges. */
+  paint(f, samples2) {
+    for (let y = 0; y < this.h; y++)
+      for (let x = 0; x < this.w; x++) {
+        if (samples2 === 1) {
+          this.set(x, y, f(x + 0.5, y + 0.5));
+          continue;
+        }
+        let r = 0, g = 0, b = 0, a = 0;
+        for (let j = 0; j < samples2; j++)
+          for (let i = 0; i < samples2; i++) {
+            const c = f(x + (i + 0.5) / samples2, y + (j + 0.5) / samples2);
+            r += c[0] * c[3];
+            g += c[1] * c[3];
+            b += c[2] * c[3];
+            a += c[3];
+          }
+        this.set(x, y, a > 0 ? [r / a, g / a, b / a, a / (samples2 * samples2)] : CLEAR);
+      }
+    return this;
+  }
+  /** RGBA bytes, row-major: what a canvas or a PNG takes. */
+  toBytes() {
+    const out = new Uint8ClampedArray(this.w * this.h * 4);
+    for (let i = 0; i < out.length; i++)
+      out[i] = Math.round((this.d[i] ?? 0) * 255);
+    return out;
+  }
+};
+
+// ../artgen/dist/math.js
+var clamp = (x, a = 0, b = 1) => Math.min(b, Math.max(a, x));
+function smooth(e0, e1, x) {
+  const t = clamp((x - e0) / (e1 - e0));
+  return t * t * (3 - 2 * t);
+}
+function hash(x, y, seed) {
+  let h = Math.imul(x | 0, 374761393) + Math.imul(y | 0, 668265263) + Math.imul(seed | 0, 2147483647) | 0;
+  h = Math.imul(h ^ h >>> 13, 1274126177);
+  return ((h ^ h >>> 16) >>> 0) / 4294967296;
+}
+var wrap = (a, p) => (a % p + p) % p;
+function noise(x, y, px, py, seed) {
+  const ix = Math.floor(x), iy = Math.floor(y);
+  const fx = x - ix, fy = y - iy;
+  const u = fx * fx * (3 - 2 * fx), v = fy * fy * (3 - 2 * fy);
+  const a = hash(wrap(ix, px), wrap(iy, py), seed), b = hash(wrap(ix + 1, px), wrap(iy, py), seed);
+  const c = hash(wrap(ix, px), wrap(iy + 1, py), seed), d = hash(wrap(ix + 1, px), wrap(iy + 1, py), seed);
+  return a + (b - a) * u + (c - a) * v + (a - b - c + d) * u * v;
+}
+function fbm(x, y, cells, seed, octaves = 4) {
+  let sum = 0, amp = 0.5, norm = 0, c = cells;
+  for (let o = 0; o < octaves; o++) {
+    sum += amp * noise(x * c, y * c, c, c, seed + o * 101);
+    norm += amp;
+    amp *= 0.5;
+    c *= 2;
+  }
+  return sum / norm;
+}
+function voronoi(x, y, cells, seed) {
+  const gx = (x - Math.floor(x)) * cells, gy = (y - Math.floor(y)) * cells;
+  const ix = Math.floor(gx), iy = Math.floor(gy);
+  let d1 = 9, d2 = 9, id = 0;
+  for (let j = -1; j <= 1; j++)
+    for (let i = -1; i <= 1; i++) {
+      const cx = ix + i, cy = iy + j;
+      const wx = wrap(cx, cells), wy = wrap(cy, cells);
+      const px = cx + 0.15 + 0.7 * hash(wx, wy, seed), py = cy + 0.15 + 0.7 * hash(wx, wy, seed + 7);
+      const d = Math.hypot(px - gx, py - gy);
+      if (d < d1) {
+        d2 = d1;
+        d1 = d;
+        id = wx * 131 + wy;
+      } else if (d < d2)
+        d2 = d;
+    }
+  return { d1, d2, id };
+}
+var sdCircle = (x, y, r) => Math.hypot(x, y) - r;
+function sdBox(x, y, hw, hh, r = 0) {
+  const qx = Math.abs(x) - hw + r, qy = Math.abs(y) - hh + r;
+  return Math.hypot(Math.max(qx, 0), Math.max(qy, 0)) + Math.min(Math.max(qx, qy), 0) - r;
+}
+function sdTriangle(x, y, hw, h) {
+  const px = Math.abs(x), py = y;
+  const t = clamp((px * hw + py * h) / (hw * hw + h * h));
+  const ax = px - hw * t, ay = py - h * t;
+  const bx = px - hw * clamp(px / hw), by = py - h;
+  const dx = Math.min(ax * ax + ay * ay, bx * bx + by * by);
+  const dy = Math.min(-(px * h - py * hw), -(py - h));
+  return -Math.sqrt(dx) * Math.sign(dy);
+}
+function sdHeart(x, y) {
+  const px = Math.abs(x), py = -y + 0.5;
+  if (py + px > 1)
+    return Math.sqrt((px - 0.25) ** 2 + (py - 0.75) ** 2) - Math.SQRT2 / 4;
+  const m = Math.max(px + py, 0) * 0.5;
+  return Math.sqrt(Math.min(px ** 2 + (py - 1) ** 2, (px - m) ** 2 + (py - m) ** 2)) * Math.sign(px - py);
+}
+function sdCapsule(x, y, ax, ay, bx, by, r) {
+  const pax = x - ax, pay = y - ay, bax = bx - ax, bay = by - ay;
+  const h = clamp((pax * bax + pay * bay) / (bax * bax + bay * bay || 1));
+  return Math.hypot(pax - bax * h, pay - bay * h) - r;
+}
+var BAYER = [0, 8, 2, 10, 12, 4, 14, 6, 3, 11, 1, 9, 15, 7, 13, 5];
+var bayer = (x, y) => ((BAYER[wrap(Math.floor(y), 4) * 4 + wrap(Math.floor(x), 4)] ?? 0) + 0.5) / 16;
+
+// ../artgen/dist/color.js
+var hex = (h, a = 1) => [(h >> 16 & 255) / 255, (h >> 8 & 255) / 255, (h & 255) / 255, a];
+var mix = (a, b, t) => [a[0] + (b[0] - a[0]) * t, a[1] + (b[1] - a[1]) * t, a[2] + (b[2] - a[2]) * t, a[3] + (b[3] - a[3]) * t];
+var shade = (c, k) => k >= 0 ? mix(c, [1, 1, 1, c[3]], k) : mix(c, [0, 0, 0, c[3]], -k);
+function hsl(h, s, l) {
+  const hh = (h % 360 + 360) % 360 / 60;
+  const c = (1 - Math.abs(2 * l - 1)) * s;
+  const x = c * (1 - Math.abs(hh % 2 - 1));
+  const [r, g, b] = hh < 1 ? [c, x, 0] : hh < 2 ? [x, c, 0] : hh < 3 ? [0, c, x] : hh < 4 ? [0, x, c] : hh < 5 ? [x, 0, c] : [c, 0, x];
+  const m = l - c / 2;
+  return [r + m, g + m, b + m, 1];
+}
+var lin = (v) => v <= 0.04045 ? v / 12.92 : ((v + 0.055) / 1.055) ** 2.4;
+var luminance = (c) => 0.2126 * lin(c[0]) + 0.7152 * lin(c[1]) + 0.0722 * lin(c[2]);
+function contrast(a, b) {
+  const la = luminance(a), lb = luminance(b);
+  return (Math.max(la, lb) + 0.05) / (Math.min(la, lb) + 0.05);
+}
+var ramp = (c) => [shade(c, -0.55), shade(c, -0.3), c, shade(c, 0.25), shade(c, 0.5)];
+
+// ../artgen/dist/dna.js
+var MIN_CONTRAST = { groundBackdrop: 1.35, outline: 2, heroDanger: 1.25 };
+var hueOf = (h) => (h % 360 + 360) % 360;
+function toward(a, b, t) {
+  let d = hueOf(b) - hueOf(a);
+  if (d > 180)
+    d -= 360;
+  if (d < -180)
+    d += 360;
+  return hueOf(a + d * t);
+}
+function accents(h, harmony) {
+  switch (harmony) {
+    case "complementary":
+      return [h + 180, h + 150];
+    case "analogous":
+      return [h + 30, h - 30];
+    case "triadic":
+      return [h + 120, h + 240];
+    case "split":
+      return [h + 150, h + 210];
+    case "monochrome":
+      return [h + 8, h - 8];
+  }
+}
+function apart(c, from, min) {
+  let out = c;
+  const up = luminance(c) >= luminance(from);
+  for (let i = 0; i < 24 && contrast(out, from) < min; i++)
+    out = shade(out, up ? 0.12 : -0.12);
+  if (contrast(out, from) < min) {
+    out = c;
+    for (let i = 0; i < 24 && contrast(out, from) < min; i++)
+      out = shade(out, up ? -0.12 : 0.12);
+  }
+  return out;
+}
+function paletteOf(dna) {
+  const { hue: h, saturation: s, brightness: b } = dna;
+  const [a1, a2] = accents(h, dna.harmony);
+  const role = {
+    ground: hsl(toward(a2, 30, 0.55), 0.3 + 0.3 * s, 0.33 + 0.14 * b),
+    groundDark: [0, 0, 0, 1],
+    surface: hsl(a1, 0.4 + 0.45 * s, 0.42 + 0.2 * b),
+    foliage: hsl(a1 - 12, 0.35 + 0.4 * s, 0.32 + 0.15 * b),
+    skyTop: hsl(toward(h + 190, 215, 0.45), 0.45 + 0.35 * s, 0.48 + 0.15 * b),
+    skyHorizon: hsl(toward(h + 190, 215, 0.45), 0.35 + 0.3 * s, 0.8 + 0.1 * b),
+    far: [0, 0, 0, 1],
+    near: hsl(a1 - 20, 0.3 + 0.35 * s, 0.5 + 0.12 * b),
+    outline: hsl(h, 0.35, 0.1),
+    hero: hsl(a1 + 70, 0.65 + 0.3 * s, 0.55),
+    danger: hsl(toward(355, h, 0.08), 0.7 + 0.25 * s, 0.5),
+    treasure: hsl(toward(46, h, 0.06), 0.85, 0.56),
+    wood: hsl(toward(28, h, 0.1), 0.4 + 0.2 * s, 0.43),
+    stone: hsl(h, 0.06 + 0.1 * s, 0.52 + 0.1 * b),
+    metal: hsl(toward(215, h, 0.2), 0.12, 0.7),
+    water: hsl(toward(200, h + 190, 0.3), 0.55 + 0.3 * s, 0.5),
+    light: hsl(toward(52, h, 0.1), 0.7, 0.88)
+  };
+  role.groundDark = shade(role.ground, -0.35);
+  role.far = shade(hsl(toward(h + 200, 230, 0.3), 0.18 + 0.2 * s, 0.6 + 0.1 * b), 0);
+  role.far = apart(role.far, role.ground, MIN_CONTRAST.groundBackdrop);
+  role.near = apart(role.near, role.ground, MIN_CONTRAST.groundBackdrop);
+  role.skyHorizon = apart(role.skyHorizon, role.ground, MIN_CONTRAST.groundBackdrop);
+  for (const k of ["ground", "surface", "hero", "danger"]) {
+    if (contrast(role.outline, role[k]) < MIN_CONTRAST.outline)
+      role.outline = shade(role.outline, -0.9);
+    if (contrast(role.outline, role[k]) < MIN_CONTRAST.outline)
+      role[k] = apart(role[k], role.outline, MIN_CONTRAST.outline);
+  }
+  for (let i = 0; i < 6 && !distinct(role.hero, role.danger); i++)
+    role.hero = hsl(a1 + 70 + 40 * (i + 1), 0.7 + 0.25 * s, 0.55);
+  if (!distinct(role.hero, role.danger))
+    role.hero = apart(role.hero, role.danger, MIN_CONTRAST.heroDanger);
+  const warnings = [];
+  for (const [k, v] of Object.entries(dna.overrides))
+    role[k] = hex(v);
+  const set = new Set(Object.keys(dna.overrides));
+  const warn = (k, other, min, what) => {
+    if ((set.has(k) || set.has(other)) && contrast(role[k], role[other]) < min)
+      warnings.push(`${k} is hard to tell from ${other}: ${what}`);
+  };
+  warn("far", "ground", MIN_CONTRAST.groundBackdrop, "the backdrop may hide where the player can stand");
+  warn("near", "ground", MIN_CONTRAST.groundBackdrop, "the backdrop may hide where the player can stand");
+  for (const k of ["ground", "surface", "hero", "danger"])
+    warn("outline", k, MIN_CONTRAST.outline, "outlines may not show");
+  if ((set.has("hero") || set.has("danger")) && !distinct(role.hero, role.danger))
+    warnings.push("hero is hard to tell from danger");
+  return { ...role, warnings };
+}
+function hueOfColour(c) {
+  const [r, g, b] = c;
+  const mx = Math.max(r, g, b), mn = Math.min(r, g, b);
+  if (mx === mn)
+    return 0;
+  const d = mx - mn;
+  const raw = mx === r ? (g - b) / d % 6 : mx === g ? (b - r) / d + 2 : (r - g) / d + 4;
+  return (raw * 60 + 360) % 360;
+}
+function distinct(a, b) {
+  const d = Math.abs(hueOfColour(a) - hueOfColour(b)) % 360;
+  return Math.min(d, 360 - d) >= 60 || contrast(a, b) >= MIN_CONTRAST.heroDanger;
+}
+
+// ../artgen/dist/shape.js
+var tileSize = (dna) => dna.pixel ? dna.pixelsPerTile : 128;
+var lightVector = (dna) => {
+  const t = dna.light * Math.PI / 180;
+  return [Math.sin(t), -Math.cos(t)];
+};
+function outlineWidth(dna, size) {
+  if (dna.outline === "none")
+    return 0;
+  if (dna.pixel)
+    return dna.outline === "thick" && size >= 24 ? 2 : 1;
+  return (dna.outline === "thick" ? 2.6 : 1.3) * (size / 64);
+}
+function toneColour(base, tone, dna, x, y) {
+  const r = ramp(base);
+  const t = dna.shading === "flat" ? 0.5 : dna.shading === "banded" ? tone < 0.42 ? 0.25 : tone < 0.7 ? 0.5 : 0.75 : tone;
+  const f = Math.max(0, Math.min(r.length - 1.0001, t * (r.length - 1)));
+  const i = Math.floor(f), k = f - i;
+  const a = r[i] ?? base, b = r[i + 1] ?? base;
+  if (dna.pixel)
+    return k > (dna.shading === "soft" ? bayer(x, y) : 0.5) ? b : a;
+  return [a[0] + (b[0] - a[0]) * k, a[1] + (b[1] - a[1]) * k, a[2] + (b[2] - a[2]) * k, 1];
+}
+function shapeShader(sd, base, dna, palette, size, opts = {}) {
+  const unit = 2 / size;
+  const ow = outlineWidth(dna, size) * unit;
+  const [lx, ly] = lightVector(dna);
+  return (x, y) => {
+    const u = x / size * 2 - 1, v = y / size * 2 - 1;
+    const d = sd(u, v);
+    if (d > 0)
+      return CLEAR;
+    if (ow > 0 && d > -ow)
+      return palette.outline;
+    const e = 0.02;
+    const gx = sd(u + e, v) - sd(u - e, v), gy = sd(u, v + e) - sd(u, v - e);
+    const gl = Math.hypot(gx, gy) || 1;
+    const lit = gx / gl * lx + gy / gl * ly;
+    const rim = Math.max(0, 1 - -d / 0.32);
+    let tone = 0.55 + 0.32 * lit * rim;
+    const custom = opts.detail?.(u, v, d, tone);
+    if (custom !== null && custom !== void 0)
+      return custom;
+    if (opts.gloss === true && Math.hypot((u - lx * 0.4) / 1.3, v - ly * 0.42) < 0.15)
+      return shade(base, 0.7);
+    tone = Math.max(0, Math.min(1, tone));
+    return toneColour(base, tone, dna, x, y);
+  };
+}
+
+// ../artgen/dist/recipes/registry.js
+var recipes = /* @__PURE__ */ new Map();
+function register(...list) {
+  for (const r of list)
+    recipes.set(r.name, r);
+}
+function checkOptionsFor(recipe, raw) {
+  if (raw !== void 0 && (typeof raw !== "object" || raw === null || Array.isArray(raw))) {
+    return { ok: false, reason: "options are an object of option names and values" };
+  }
+  const given = raw ?? {};
+  const names = Object.keys(recipe.options);
+  for (const key of Object.keys(given)) {
+    if (!names.includes(key)) {
+      return { ok: false, reason: `'${key}' is not an option of ${recipe.name}; its options are ${names.length === 0 ? "none" : names.join(", ")}` };
+    }
+  }
+  const out = {};
+  for (const [name, spec] of Object.entries(recipe.options)) {
+    const v = given[name];
+    if (v === void 0) {
+      out[name] = spec.default;
+      continue;
+    }
+    if (spec.kind === "enum") {
+      if (typeof v !== "string" || !spec.values.includes(v)) {
+        return { ok: false, reason: `${name} '${String(v)}' is not one of ${spec.values.join(", ")}` };
+      }
+      out[name] = v;
+    } else {
+      if (typeof v !== "number" || !(v >= spec.min && v <= spec.max)) {
+        return { ok: false, reason: `${name} is a number from ${String(spec.min)} to ${String(spec.max)}` };
+      }
+      out[name] = v;
+    }
+  }
+  return { ok: true, options: out };
+}
+function drawWith(recipe, raw, dna, seed) {
+  const checked = checkOptionsFor(recipe, raw);
+  if (!checked.ok)
+    return checked;
+  const drawn = recipe.render(checked.options, dna, paletteOf(dna), seed);
+  const { raster } = drawn;
+  return {
+    ok: true,
+    w: raster.w,
+    h: raster.h,
+    bytes: raster.toBytes(),
+    entry: {
+      kind: recipe.kind,
+      tags: [recipe.family, recipe.name],
+      pixel: dna.pixel,
+      image: { w: raster.w, h: raster.h },
+      frame: drawn.frame,
+      ...drawn.clips === void 0 ? {} : { clips: drawn.clips },
+      ...drawn.fps === void 0 ? {} : { fps: drawn.fps },
+      ...drawn.pieces === void 0 ? {} : { pieces: drawn.pieces },
+      ...drawn.oneWay === void 0 ? {} : { oneWay: drawn.oneWay },
+      made: { by: "code", recipe: recipe.name, options: checked.options, seed, dna: dna.version }
+    }
+  };
+}
+function draw(recipe, options, dna, seed) {
+  const r = recipes.get(recipe);
+  if (r === void 0)
+    return { ok: false, reason: `there is no recipe '${recipe}'; the recipes are ${[...recipes.keys()].join(", ")}` };
+  return drawWith(r, options, dna, seed);
+}
+
+// ../artgen/dist/recipes/ground.js
+var SURFACES = ["grass", "snow", "sand", "moss", "crystal", "none"];
+var FILLS = ["dirt", "stone", "cobble", "bricks", "ice", "wood", "metal"];
+var LEDGES = ["plank", "stone", "cloud"];
+var WALLS = ["stone", "bricks", "wood", "metal", "hedge"];
+var samplesFor = (dna) => dna.pixel ? 1 : 2;
+function pick(r, t, x, y, dna) {
+  const f = Math.max(0, Math.min(r.length - 1.0001, t * (r.length - 1)));
+  const i = Math.floor(f), k = f - i;
+  const a = r[i], b = r[i + 1];
+  if (dna.pixel)
+    return k > bayer(x, y) ? b : a;
+  return mix(a, b, k);
+}
+var steps = (c) => [shade(c, -0.32), shade(c, -0.15), c, shade(c, 0.14)];
+function fillColour(fill, p, dna, fx, fy, x, y, seed) {
+  const busy = 0.4 + 0.6 * dna.texture;
+  switch (fill) {
+    case "stone": {
+      const row = Math.floor(fy * 3);
+      const off = row % 2 * 0.5;
+      const by = (fy * 3 + 0.5) % 1, bx = (fx + off + 0.27) % 1;
+      if (by < 0.07 || bx < 0.035)
+        return shade(p.stone, -0.4);
+      return pick(steps(p.stone), 0.3 + 0.4 * fbm(fx, fy, 3, seed) * busy + (by < 0.2 ? 0.25 : 0), x, y, dna);
+    }
+    case "cobble": {
+      const v = voronoi(fx, fy, 2 + Math.round(2 * dna.texture), seed);
+      if (v.d2 - v.d1 < 0.09)
+        return shade(p.stone, -0.45);
+      return pick(steps(p.stone), 0.3 + 0.35 * hash(v.id, 1, seed) + 0.3 * (1 - v.d1), x, y, dna);
+    }
+    case "bricks": {
+      const brick = mix(p.ground, p.danger, 0.45);
+      const row = Math.floor(fy * 4), off = row % 2 ? 0.25 : 0;
+      const bx = ((fx + off) * 2 + 0.3) % 1, by = (fy * 4 + 0.5) % 1;
+      if (by < 0.13 || bx < 0.06)
+        return shade(p.stone, -0.35);
+      return pick(steps(brick), 0.35 + 0.3 * hash(Math.floor((fx + off) * 2 + 0.3) % 2, row, seed) + (by < 0.3 ? 0.25 : 0), x, y, dna);
+    }
+    case "ice": {
+      const ice = mix(p.water, [1, 1, 1, 1], 0.55);
+      const streak = Math.abs((fx + fy * 0.6) * 3 % 1 - 0.5) < 0.04 ? 0.35 : 0;
+      return pick(steps(ice), 0.4 + 0.3 * fbm(fx, fy, 2, seed) + streak, x, y, dna);
+    }
+    case "wood": {
+      const col = Math.floor(fx * 4 + 0.5) % 4;
+      if ((fx * 4 + 0.5) % 1 < 0.06)
+        return shade(p.wood, -0.45);
+      return pick(steps(p.wood), 0.3 + 0.45 * noise(fx * 8, fy * 10 + col * 3, 8, 10, seed) * busy, x, y, dna);
+    }
+    case "metal": {
+      const px = (fx * 2 + 0.5) % 1, py = (fy * 2 + 0.5) % 1;
+      if (px < 0.04 || py < 0.04)
+        return shade(p.metal, -0.4);
+      if (Math.hypot(px - 0.14, py - 0.14) < 0.05 || Math.hypot(px - 0.86, py - 0.86) < 0.05)
+        return shade(p.metal, 0.35);
+      return pick(steps(p.metal), 0.45 + 0.2 * (1 - py), x, y, dna);
+    }
+    default: {
+      const v = voronoi(fx, fy, 4 + Math.round(3 * dna.texture), seed + 3);
+      if (v.d1 < 0.15 && hash(v.id, 9, seed) < 0.25 + 0.3 * dna.texture)
+        return hash(v.id, 4, seed) < 0.5 ? shade(p.ground, 0.2) : p.groundDark;
+      return pick(steps(p.ground), 0.2 + 0.7 * fbm(fx, fy, 3, seed) * busy + 0.15 * (1 - busy), x, y, dna);
+    }
+  }
+}
+function surfaceColour(surface, p) {
+  switch (surface) {
+    case "snow":
+      return mix(p.skyHorizon, [1, 1, 1, 1], 0.75);
+    case "sand":
+      return mix(p.treasure, p.ground, 0.45);
+    case "moss":
+      return p.foliage;
+    case "crystal":
+      return mix(p.water, [1, 1, 1, 1], 0.3);
+    default:
+      return p.surface;
+  }
+}
+function capDepth(u, dna, seed) {
+  const base = 4.2;
+  if (dna.edges === "straight")
+    return base;
+  if (dna.edges === "spiky")
+    return base + 1.3 * (Math.abs(u / 16 * 8 % 1 - 0.5) * 2 - 0.5);
+  return base + 1.1 * Math.sin(u / 16 * Math.PI * 4 + seed) + 1.1 * (noise(u / 16 * 4, 0.5, 4, 1, seed + 5) - 0.5);
+}
+var outlineUnits = (dna, S) => dna.outline === "none" ? 0 : dna.pixel ? 16 / S * (dna.outline === "thick" && S >= 32 ? 2 : 1) : dna.outline === "thick" ? 1.3 : 0.75;
+function openDistance(u, v, mask, r) {
+  const up = (mask & 1) !== 0, right = (mask & 2) !== 0, down = (mask & 4) !== 0, left = (mask & 8) !== 0;
+  let d = 99;
+  if (!up)
+    d = Math.min(d, v);
+  if (!down)
+    d = Math.min(d, 16 - v);
+  if (!left)
+    d = Math.min(d, u);
+  if (!right)
+    d = Math.min(d, 16 - u);
+  const corners = [
+    [!up && !left, r, r],
+    [!up && !right, 16 - r, r],
+    [!down && !left, r, 16 - r],
+    [!down && !right, 16 - r, 16 - r]
+  ];
+  for (const [open, cx, cy] of corners) {
+    if (!open || r <= 0)
+      continue;
+    if (!((cx < 8 ? u < cx : u > cx) && (cy < 8 ? v < cy : v > cy)))
+      continue;
+    const dc = r - Math.hypot(u - cx, v - cy);
+    if (dc < 0)
+      return -1;
+    d = Math.min(d, dc);
+  }
+  return d;
+}
+function solidPiece(o, dna, p, mask, S, seed) {
+  const g = S / 16;
+  const r = 0.6 + 3.6 * dna.roundness;
+  const ow = outlineUnits(dna, S);
+  const surface = o["surface"] === "none" ? null : surfaceColour(String(o["surface"]), p);
+  const up = (mask & 1) !== 0;
+  return new Raster(S, S).paint((x, y) => {
+    const u = x / g, v = y / g;
+    const d = openDistance(u, v, mask, r);
+    if (d < 0)
+      return CLEAR;
+    if (d < ow)
+      return p.outline;
+    let c = fillColour(String(o["fill"]), p, dna, x / S, y / S, x, y, seed);
+    if (surface !== null && !up) {
+      const depth = capDepth(u, dna, seed);
+      if (v < depth) {
+        const cap = steps(surface);
+        const k = v < 1.6 ? 0.98 : v > depth - 1.1 ? 0.15 : 0.55 + 0.3 * (noise(u * 1.2, v * 1.2, 64, 64, seed + 8) - 0.5) * dna.texture;
+        c = pick(cap, k, x, y, dna);
+      } else if (v < depth + 1)
+        c = shade(c, -0.28);
+    }
+    if (d < 3 && dna.shading !== "flat") {
+      const k = (3 - d) / 3;
+      const lit = !up && v < 3 || (mask & 8) === 0 && u < 3;
+      c = shade(c, lit ? 0.1 * k : -0.18 * k);
+    }
+    return c;
+  }, samplesFor(dna));
+}
+function ledgePiece(o, dna, p, ends, S, seed) {
+  const g = S / 16;
+  const ow = outlineUnits(dna, S);
+  const ledge = String(o["ledge"]);
+  const base = ledge === "stone" ? p.stone : ledge === "cloud" ? mix(p.skyHorizon, [1, 1, 1, 1], 0.8) : p.wood;
+  const openL = ends === "left" || ends === "single", openR = ends === "right" || ends === "single";
+  const height = ledge === "cloud" ? 6.5 : 6;
+  return new Raster(S, S).paint((x, y) => {
+    const u = x / g, v = y / g;
+    if (v > height + 0.5)
+      return CLEAR;
+    const rr = ledge === "cloud" ? 3 : 1 + 2 * dna.roundness;
+    let d = Math.min(v, height - v);
+    for (const [open, cx] of [[openL, rr], [openR, 16 - rr]]) {
+      if (!open || !(cx < 8 ? u < cx : u > cx))
+        continue;
+      const dist = Math.hypot(u - cx, Math.max(0, Math.abs(v - height / 2) - (height / 2 - rr)));
+      if (dist > rr)
+        return CLEAR;
+      d = Math.min(d, rr - dist);
+    }
+    if (ledge === "cloud") {
+      const bump = 0.9 * Math.sin(u / 16 * Math.PI * 6 + seed);
+      if (v < 1 - bump * 0.6)
+        return CLEAR;
+    }
+    if (openL)
+      d = Math.min(d, u);
+    if (openR)
+      d = Math.min(d, 16 - u);
+    if (d < ow)
+      return p.outline;
+    if (ledge === "plank" && (Math.abs(u - 3.5) < 0.8 || Math.abs(u - 12.5) < 0.8) && Math.abs(v - 3) < 0.8)
+      return shade(base, -0.5);
+    let c = v < 1.8 ? shade(base, 0.25) : pick(steps(base), 0.35 + 0.45 * noise(u * 0.3, v * 1.5, 64, 64, seed + 11), x, y, dna);
+    if (v > height - 1.4)
+      c = shade(c, -0.25);
+    return c;
+  }, samplesFor(dna));
+}
+function floorPiece(o, dna, p, S, seed) {
+  const tuft = o["surface"] === "grass" || o["surface"] === "moss" ? surfaceColour(String(o["surface"]), p) : null;
+  const snow = o["surface"] === "snow";
+  return new Raster(S, S).paint((x, y) => {
+    const fx = x / S, fy = y / S;
+    if (tuft !== null) {
+      const v = voronoi(fx, fy, 5, seed + 21);
+      if (v.d1 < 0.14 && hash(v.id, 2, seed) < 0.5)
+        return shade(tuft, 0.15);
+      return pick(steps(tuft), 0.35 + 0.4 * fbm(fx, fy, 3, seed), x, y, dna);
+    }
+    const c = fillColour(String(o["fill"]), p, dna, fx, fy, x, y, seed);
+    return snow ? mix(c, [1, 1, 1, 1], 0.55) : c;
+  }, samplesFor(dna));
+}
+function wallPiece(o, dna, p, mask, S, seed) {
+  const g = S / 16;
+  const ow = outlineUnits(dna, S);
+  const material = String(o["material"]);
+  const down = (mask & 4) !== 0;
+  const fill = material === "hedge" ? null : material === "wood" ? "wood" : material === "metal" ? "metal" : material === "bricks" ? "bricks" : "stone";
+  return new Raster(S, S).paint((x, y) => {
+    const u = x / g, v = y / g;
+    const d = openDistance(u, v, mask, 0.5 + 2 * dna.roundness);
+    if (d < 0)
+      return CLEAR;
+    if (d < ow)
+      return p.outline;
+    const face = !down && v > 10;
+    const c = fill === null ? pick(steps(p.foliage), 0.3 + 0.5 * fbm(x / S, y / S, 4, seed), x, y, dna) : fillColour(fill, p, dna, x / S, y / S, x, y, seed);
+    if (face)
+      return shade(c, -0.35 - (v > 14 ? 0.1 : 0));
+    return shade(c, v < 2 && (mask & 1) === 0 ? 0.18 : 0.08);
+  }, samplesFor(dna));
+}
+function sheetOf(pieces, S, rows) {
+  const out = new Raster(4 * S, rows * S);
+  pieces.forEach((piece, i) => {
+    out.blit(piece, i % 4 * S, Math.floor(i / 4) * S);
+  });
+  return out;
+}
+var MASKS = Object.fromEntries(Array.from({ length: 16 }, (_, m) => [m, m]));
+register({
+  name: "ground",
+  family: "ground",
+  kind: "tileset",
+  description: "Ground blocks: a surface (grass, snow...) over a fill (dirt, stone...), and ledges you can jump up through. view top makes a floor seen from above.",
+  options: {
+    view: { kind: "enum", values: ["side", "top"], default: "side", note: "side for platformers, top for floors seen from above" },
+    surface: { kind: "enum", values: SURFACES, default: "grass", note: "what grows on top" },
+    fill: { kind: "enum", values: FILLS, default: "dirt", note: "what the block is made of" },
+    ledge: { kind: "enum", values: LEDGES, default: "plank", note: "the one-way platforms (side view)" }
+  },
+  render: (o, dna, p, seed) => {
+    const S = tileSize(dna);
+    if (o["view"] === "top") {
+      const floor = floorPiece(o, dna, p, S, seed);
+      return { raster: sheetOf(Array.from({ length: 16 }, () => floor), S, 4), frame: { w: S, h: S }, pieces: MASKS };
+    }
+    const solids = Array.from({ length: 16 }, (_, m) => solidPiece(o, dna, p, m, S, seed));
+    const ledges = ["left", "middle", "right", "single"].map((e) => ledgePiece(o, dna, p, e, S, seed));
+    return {
+      raster: sheetOf([...solids, ...ledges], S, 5),
+      frame: { w: S, h: S },
+      pieces: MASKS,
+      oneWay: { left: 16, middle: 17, right: 18, single: 19 }
+    };
+  }
+}, {
+  name: "wall",
+  family: "ground",
+  kind: "tileset",
+  description: "Walls seen from above, for top-down games: a lit top and a darker front face where nothing is below.",
+  options: {
+    material: { kind: "enum", values: WALLS, default: "stone", note: "what the wall is made of" }
+  },
+  render: (o, dna, p, seed) => {
+    const S = tileSize(dna);
+    return { raster: sheetOf(Array.from({ length: 16 }, (_, m) => wallPiece(o, dna, p, m, S, seed)), S, 4), frame: { w: S, h: S }, pieces: MASKS };
+  }
+});
+
+// ../artgen/dist/recipes/backdrop.js
+var sideSize = (dna) => {
+  const h = dna.pixel ? dna.pixelsPerTile * 9 : 540;
+  return { w: h * 3, h };
+};
+function ridge(x, cells, seed, octaves = 4) {
+  let s = 0, a = 0.5, n = 0, c = cells;
+  for (let o = 0; o < octaves; o++) {
+    s += a * noise(x * c, 0.5, c, 1, seed + o * 31);
+    n += a;
+    a *= 0.5;
+    c *= 2;
+  }
+  return s / n;
+}
+var around = (a, b) => {
+  const d = a - b;
+  return d - Math.round(d);
+};
+function band(a, b, t, x, y, dna, steps2 = 6) {
+  if (!dna.pixel)
+    return mix(a, b, t);
+  const f = t * steps2, i = Math.floor(f);
+  return mix(a, b, Math.min(1, (i + (f - i > bayer(x, y) ? 1 : 0)) / steps2));
+}
+function skyColours(time, p) {
+  if (time === "night")
+    return { top: shade(p.skyTop, -0.72), horizon: shade(p.skyTop, -0.42) };
+  if (time === "dusk")
+    return { top: shade(mix(p.skyTop, p.danger, 0.3), -0.35), horizon: mix(p.treasure, p.danger, 0.35) };
+  return { top: p.skyTop, horizon: p.skyHorizon };
+}
+function sky(o, dna, p, seed) {
+  const { w: W, h: H } = sideSize(dna);
+  const time = String(o["time"]), clouds = String(o["clouds"]), kind = String(o["ridge"]);
+  const { top, horizon } = skyColours(time, p);
+  const sun = time === "night" ? mix(p.light, [1, 1, 1, 1], 0.5) : time === "dusk" ? mix(p.treasure, p.light, 0.5) : p.light;
+  const cloudCount = clouds === "none" ? 0 : clouds === "few" ? 3 : 6;
+  const cloudColour = time === "night" ? shade(p.skyTop, -0.5) : time === "dusk" ? mix(p.treasure, [1, 1, 1, 1], 0.55) : mix(p.skyHorizon, [1, 1, 1, 1], 0.7);
+  const far = time === "night" ? shade(p.far, -0.55) : time === "dusk" ? mix(p.far, p.danger, 0.25) : p.far;
+  const raster = new Raster(W, H).paint((x, y) => {
+    const fx = x / W, fy = y / H;
+    let c = band(top, horizon, smooth(0, 0.8, fy), x, y, dna, 8);
+    if (time === "night" && hash(x, y, seed) > 0.9975 && fy < 0.6)
+      c = mix(c, [1, 1, 1, 1], 0.6 + 0.4 * hash(y, x, seed));
+    const ds = Math.hypot(around(fx, 0.72) * W / H, fy - 0.24);
+    if (ds < 0.07)
+      c = sun;
+    else
+      c = mix(c, sun, 0.3 * Math.max(0, 1 - (ds - 0.07) / 0.18) ** 2);
+    for (let k = 0; k < cloudCount; k++) {
+      const cx = (k + 0.4 * hash(k, 5, seed)) / cloudCount, cy = 0.1 + 0.18 * hash(k, 7, seed);
+      const ax = around(fx, cx) * W / H, bottom = cy + 0.045;
+      let d = 9;
+      for (let b = 0; b < 5; b++) {
+        const r = (0.04 + 0.03 * hash(k * 7 + b, 3, seed + 6) + (b === 2 ? 0.02 : 0)) * (0.8 + 0.4 * dna.roundness);
+        d = Math.min(d, Math.hypot(ax - (b - 2) * 0.05, fy - (bottom - r * 0.9)) - r);
+      }
+      d = Math.max(d, fy - bottom);
+      if (d < 0)
+        c = shade(cloudColour, fy > bottom - 0.02 ? -0.1 : d > -8e-3 ? -0.04 : 0.03);
+    }
+    if (kind !== "none") {
+      let hF;
+      if (kind === "mesas")
+        hF = 0.5 + 0.18 * (Math.round((1 - ridge(fx, 3, seed + 5)) * 4) / 4) - 0.08;
+      else if (kind === "skyline") {
+        const col = Math.floor(fx * 40);
+        hF = 0.42 + 0.22 * hash(col, 1, seed + 9);
+        if (fy > hF && time === "night" && Math.floor(fx * 160) % 2 === 1 && Math.floor(fy * 60) % 2 === 1 && hash(Math.floor(fx * 160), Math.floor(fy * 60), seed) > 0.6)
+          return p.light;
+      } else
+        hF = 0.4 + 0.24 * (1 - ridge(fx, 3, seed + 5));
+      if (fy > hF) {
+        const snow = kind === "mountains" && fy < hF + 0.025 && hF < 0.48 && time !== "dusk";
+        c = snow ? shade(far, 0.55) : band(mix(far, horizon, 0.3), far, smooth(hF, 0.95, fy), x, y, dna, 4);
+      }
+    }
+    return c;
+  }, 1);
+  return { raster, frame: { w: W, h: H } };
+}
+function scenery(kind, dx, fy, base, size) {
+  switch (kind) {
+    case "pines":
+      return sdTriangle(dx, fy - (base - size), size * 0.42, size);
+    case "round-trees":
+      return Math.min(sdCircle(dx, fy - (base - size * 0.75), size * 0.38), sdBox(dx, fy - (base - size * 0.2), size * 0.06, size * 0.22));
+    case "rocks":
+      return Math.max(Math.hypot(dx / 1.5, fy - base) - size * 0.4, fy - base);
+    case "cacti":
+      return Math.min(sdCapsule(dx, fy, 0, base, 0, base - size * 0.9, size * 0.09), sdCapsule(dx, fy, 0, base - size * 0.45, size * 0.22, base - size * 0.45, size * 0.07), sdCapsule(dx, fy, size * 0.22, base - size * 0.45, size * 0.22, base - size * 0.7, size * 0.07));
+    case "mushrooms":
+      return Math.min(sdBox(dx, fy - (base - size * 0.25), size * 0.07, size * 0.25), Math.max(sdCircle(dx, fy - (base - size * 0.5), size * 0.32), fy - (base - size * 0.5)));
+    case "houses":
+      return Math.min(sdBox(dx, fy - (base - size * 0.3), size * 0.32, size * 0.3), sdTriangle(dx, fy - (base - size * 0.95), size * 0.42, size * 0.35));
+    default:
+      return 9;
+  }
+}
+function hills(o, dna, p, seed) {
+  const { w: W, h: H } = sideSize(dna);
+  const kind = String(o["scenery"]);
+  const lift = o["height"] === "high" ? -0.1 : o["height"] === "low" ? 0.08 : 0;
+  const mid = p.near, near = shade(p.foliage, -0.05);
+  const line = (fx, k, amp, cells, s) => 0.64 + lift + k + amp * Math.sin(fx * Math.PI * 2 * 3 + seed) + amp * (ridge(fx, cells, seed + s, 3) - 0.5);
+  const count = 14;
+  const raster = new Raster(W, H).paint((x, y) => {
+    const fx = x / W, fy = y / H;
+    let c = CLEAR;
+    const hM = line(fx, 0, 0.05, 6, 9);
+    for (let k = 0; k < count; k++) {
+      const tx = k === 0 ? 8e-3 : (k + 0.35 * (hash(k, 1, seed + 2) - 0.5)) / count;
+      const dx = around(fx, tx) * W / H;
+      if (Math.abs(dx) > 0.2)
+        continue;
+      const size = 0.08 + 0.05 * hash(k, 3, seed + 4);
+      const d = scenery(kind, dx, fy, line(tx, 0, 0.05, 6, 9) + 0.01, size);
+      if (d < 0)
+        c = d > -4e-3 ? shade(mid, -0.35) : shade(kind === "houses" || kind === "mushrooms" ? mix(mid, p.danger, 0.25) : mid, dx < 0 ? 0.06 : -0.16);
+    }
+    if (fy > hM)
+      c = fy < hM + 0.012 ? shade(mid, 0.2) : band(mid, shade(mid, -0.2), smooth(hM, 1, fy), x, y, dna, 3);
+    const hN = line(fx, 0.16, 0.04, 10, 13);
+    if (fy > hN)
+      c = fy < hN + 0.012 ? shade(near, 0.18) : band(near, shade(near, -0.25), smooth(hN, 1, fy), x, y, dna, 3);
+    return c;
+  }, 1);
+  return { raster, frame: { w: W, h: H } };
+}
+function field(o, dna, p, seed) {
+  const S = dna.pixel ? dna.pixelsPerTile * 8 : 512;
+  const pattern = String(o["pattern"]);
+  const raster = new Raster(S, S).paint((x, y) => {
+    const fx = x / S, fy = y / S;
+    switch (pattern) {
+      case "water": {
+        const w = Math.sin((fy * 8 + 0.3 * Math.sin(fx * Math.PI * 2 * 3)) * Math.PI * 2);
+        return band(shade(p.water, -0.15), shade(p.water, 0.2), 0.5 + 0.5 * w * (0.4 + 0.6 * fbm(fx, fy, 2, seed)), x, y, dna, 4);
+      }
+      case "sand": {
+        const ripple = Math.sin((fy * 10 + 0.6 * fbm(fx, fy, 2, seed)) * Math.PI * 2);
+        const sand = mix(p.treasure, p.ground, 0.5);
+        return band(shade(sand, -0.1), shade(sand, 0.12), 0.5 + 0.5 * ripple, x, y, dna, 4);
+      }
+      case "space": {
+        const base = band(shade(p.skyTop, -0.85), shade(mix(p.skyTop, p.hero, 0.4), -0.6), fbm(fx, fy, 2, seed), x, y, dna, 4);
+        return hash(x % S, y % S, seed) > 0.996 ? mix(base, [1, 1, 1, 1], 0.8) : base;
+      }
+      case "checker": {
+        const a = Math.floor(fx * 8 + 0.5) + Math.floor(fy * 8 + 0.5);
+        return a % 2 === 0 ? shade(p.stone, 0.1) : shade(p.stone, -0.12);
+      }
+      case "stripes":
+        return Math.floor(fx * 8 + 0.5) % 2 === 0 ? shade(p.near, 0.1) : shade(p.near, -0.08);
+      default: {
+        const g = p.surface;
+        const t = fbm(fx, fy, 4, seed);
+        const tuft = hash(Math.floor(fx * 32 + 0.5) % 32, Math.floor(fy * 32 + 0.5) % 32, seed) > 0.92;
+        return tuft ? shade(g, 0.2) : band(shade(g, -0.15), shade(g, 0.1), t, x, y, dna, 4);
+      }
+    }
+  }, 1);
+  return { raster, frame: { w: S, h: S } };
+}
+register({
+  name: "sky",
+  family: "backdrop",
+  kind: "background",
+  description: "The far backdrop for side-view games: a sky by time of day, clouds, and a far ridge. Opaque; use parallax 0 to 0.2.",
+  options: {
+    time: { kind: "enum", values: ["day", "dusk", "night"], default: "day", note: "time of day" },
+    clouds: { kind: "enum", values: ["none", "few", "many"], default: "few", note: "how many clouds" },
+    ridge: { kind: "enum", values: ["none", "mountains", "mesas", "skyline"], default: "mountains", note: "what stands far away" }
+  },
+  render: sky
+}, {
+  name: "hills",
+  family: "backdrop",
+  kind: "background",
+  description: "A near backdrop layer for side-view games: rolling hills with scenery on them, see-through above. Use parallax 0.3 to 0.6 over a sky.",
+  options: {
+    scenery: { kind: "enum", values: ["none", "pines", "round-trees", "rocks", "cacti", "mushrooms", "houses"], default: "pines", note: "what stands on the hills" },
+    height: { kind: "enum", values: ["low", "mid", "high"], default: "mid", note: "how high the hills reach" }
+  },
+  render: hills
+}, {
+  name: "field",
+  family: "backdrop",
+  kind: "background",
+  description: "A backdrop for top-down and single-screen games that repeats in both directions.",
+  options: {
+    pattern: { kind: "enum", values: ["grass", "water", "sand", "space", "checker", "stripes"], default: "grass", note: "what the field is" }
+  },
+  render: field
+});
+
+// ../artgen/dist/recipes/things.js
+var samples = (dna) => dna.pixel ? 1 : 3;
+function picture(sd, base, dna, p, tw = 1, th = 1, opts = {}) {
+  const S = tileSize(dna);
+  const W = Math.round(S * tw), H = Math.round(S * th);
+  const s = Math.min(W, H);
+  const k = 0.9 + 0.06 * hash(variant, 1, 41), a = 1 + 0.08 * (hash(variant, 2, 41) - 0.5);
+  const fx = k * a, fy = k / a;
+  const scaled = (u, v) => sd(u / fx, v / fy) * Math.min(fx, fy);
+  const detail = opts.detail;
+  const shaded = detail === void 0 ? opts : { ...opts, detail: (u, v, d, tone) => detail(u / fx, v / fy, d, tone) };
+  const shader = shapeShader(scaled, base, dna, p, s, shaded);
+  const tint = 0.14 * (hash(variant, 3, 41) - 0.5);
+  const sh = (x, y) => {
+    const c = shader(x, y);
+    return c[3] === 0 ? c : shade(c, tint);
+  };
+  return new Raster(W, H).paint((x, y) => sh(x - (W - s) / 2, y - (H - s) / 2), samples(dna));
+}
+var variant = 1;
+var seeded = (r) => ({
+  ...r,
+  render: (o, dna, p, seed) => {
+    variant = seed;
+    try {
+      return r.render(o, dna, p, seed);
+    } finally {
+      variant = 1;
+    }
+  }
+});
+function strip(frames, fps) {
+  const f = frames[0];
+  const out = new Raster(f.w * frames.length, f.h);
+  frames.forEach((r, i) => {
+    out.blit(r, i * f.w, 0);
+  });
+  return { raster: out, frame: { w: f.w, h: f.h }, clips: { idle: frames.map((_, i) => i) }, fps };
+}
+var one = (r) => ({ raster: r, frame: { w: r.w, h: r.h } });
+var union = (...ds) => Math.min(...ds);
+function sdStar(u, v, outer, inner) {
+  const a = Math.atan2(u, -v);
+  const k = Math.abs((a / (2 * Math.PI) * 5 % 1 + 1) % 1 - 0.5) * 2;
+  return Math.hypot(u, v) - (inner + (outer - inner) * k ** 1.6);
+}
+var wobble = (u, v, r, seed, amount) => {
+  const a = Math.atan2(v, u) / (2 * Math.PI) + 0.5;
+  return Math.hypot(u, v) - r * (1 + amount * (noise(a * 6, 0.5, 6, 1, seed) - 0.5));
+};
+var lightTint = (c) => shade(c, 0.25);
+var PICKUPS = [
+  {
+    name: "coin",
+    family: "pickup",
+    kind: "animation",
+    description: "A coin that spins, in the treasure colour.",
+    options: {},
+    render: (_o, dna, p) => strip([1, 0.62, 0.2, 0.62].map((sx, i) => picture((u, v) => (Math.hypot(u / (0.72 * sx), v / 0.72) - 1) * 0.72 * sx, p.treasure, dna, p, 1, 1, {
+      gloss: i === 0,
+      detail: (u, v, d) => i === 0 && d < -0.17 && d > -0.24 ? shade(p.treasure, -0.3) : i === 0 && sdBox(u, v, 0.08, 0.28) < 0 ? shade(p.treasure, 0.35) : null
+    })), 8)
+  },
+  {
+    name: "gem",
+    family: "pickup",
+    kind: "picture",
+    description: "A cut gem in the treasure accent.",
+    options: { cut: { kind: "enum", values: ["round", "square", "diamond", "tear"], default: "diamond", note: "the cut" } },
+    render: (o, dna, p) => {
+      const cut = String(o["cut"]);
+      const base = mix(p.treasure, p.hero, 0.55);
+      const sd = cut === "round" ? (u, v) => sdCircle(u, v, 0.66) : cut === "square" ? (u, v) => sdBox(u, v, 0.58, 0.58, 0.08) : cut === "tear" ? (u, v) => union(sdCircle(u, v - 0.18, 0.48), sdTriangle(u, v + 0.75, 0.36, 0.6)) : (u, v) => Math.max((Math.abs(u) / 0.78 + Math.abs(v + 0.05) / 0.82 - 1) * 0.55, -(v + 0.48));
+      return one(picture(sd, base, dna, p, 1, 1, {
+        gloss: true,
+        detail: (u, v) => {
+          if (cut !== "diamond")
+            return null;
+          const face = v < -0.2 ? Math.abs(u) < 0.28 ? 0.92 : 0.75 : u < 0 ? 0.55 : 0.32;
+          return face > 0.8 ? shade(base, 0.4) : face > 0.6 ? shade(base, 0.15) : face > 0.45 ? base : shade(base, -0.25);
+        }
+      }));
+    }
+  },
+  {
+    name: "heart",
+    family: "pickup",
+    kind: "picture",
+    description: "A heart, a life.",
+    options: {},
+    render: (_o, dna, p) => one(picture((u, v) => sdHeart(u * 0.72, v * 0.68 + 0.02), lightTint(p.danger), dna, p, 1, 1, { gloss: true }))
+  },
+  {
+    name: "key",
+    family: "pickup",
+    kind: "picture",
+    description: "A key, in the treasure colour.",
+    options: {},
+    render: (_o, dna, p) => {
+      const k = dna.pixel ? 1.6 : 1;
+      return one(picture((u, v) => union(Math.abs(sdCircle(u + 0.42, v, 0.3)) - 0.11 * k, sdBox(u - 0.2, v, 0.5, 0.09 * k), sdBox(u - 0.56, v - 0.2, 0.08 * k, 0.14), sdBox(u - 0.3, v - 0.17, 0.07 * k, 0.1)), p.treasure, dna, p));
+    }
+  },
+  {
+    name: "star",
+    family: "pickup",
+    kind: "picture",
+    description: "A star, a bonus.",
+    options: {},
+    render: (_o, dna, p) => one(picture((u, v) => sdStar(u, v, 0.8, 0.36), p.treasure, dna, p, 1, 1, { gloss: true }))
+  },
+  {
+    name: "potion",
+    family: "pickup",
+    kind: "picture",
+    description: "A bottle with something to drink.",
+    options: {},
+    render: (_o, dna, p) => one(picture((u, v) => union(sdCircle(u, v - 0.22, 0.5), sdBox(u, v + 0.42, 0.16, 0.24), sdBox(u, v + 0.7, 0.2, 0.08)), p.metal, dna, p, 1, 1, {
+      gloss: true,
+      detail: (u, v, d) => v > 0.02 && d < -0.06 ? v < 0.1 ? shade(p.danger, 0.3) : p.danger : v < -0.62 && Math.abs(u) < 0.2 ? p.wood : null
+    }))
+  },
+  {
+    name: "orb",
+    family: "pickup",
+    kind: "picture",
+    description: "A glowing orb, a power-up.",
+    options: {},
+    render: (_o, dna, p) => one(picture((u, v) => sdCircle(u, v, 0.66), p.hero, dna, p, 1, 1, { gloss: true }))
+  },
+  {
+    name: "ring",
+    family: "pickup",
+    kind: "picture",
+    description: "A ring with a stone.",
+    options: {},
+    render: (_o, dna, p) => one(picture((u, v) => union(Math.abs(sdCircle(u, v + 0.08, 0.48)) - 0.11, sdCircle(u, v + 0.62, 0.18)), p.treasure, dna, p, 1, 1, {
+      detail: (u, v, d) => v < -0.44 && d < -0.03 ? mix(p.treasure, p.hero, 0.7) : null
+    }))
+  },
+  {
+    name: "chest",
+    family: "pickup",
+    kind: "picture",
+    description: "A treasure chest, closed or open.",
+    options: { open: { kind: "enum", values: ["no", "yes"], default: "no", note: "open shows the gold inside" } },
+    render: (o, dna, p) => {
+      const open = o["open"] === "yes";
+      const sd = open ? (u, v) => union(sdBox(u, v - 0.3, 0.72, 0.42, 0.06), sdBox(u, v + 0.42, 0.72, 0.16, 0.08)) : (u, v) => union(sdBox(u, v - 0.22, 0.72, 0.5, 0.06), Math.max(sdCircle(u * 0.6, v + 0.1, 0.44), v + 0.1 - 0.6));
+      return one(picture(sd, p.wood, dna, p, 1, 1, {
+        detail: (u, v, d) => {
+          if (open && v > -0.12 && v < 0.02 && Math.abs(u) < 0.66)
+            return lightTint(p.treasure);
+          if (Math.abs(u) < 0.1 && Math.abs(v - 0.05) < 0.12)
+            return p.treasure;
+          if (d > -0.12 || Math.abs(v + (open ? 0 : 0.28)) < 0.05)
+            return shade(p.treasure, -0.15);
+          return null;
+        }
+      }));
+    }
+  },
+  {
+    name: "clock",
+    family: "pickup",
+    kind: "picture",
+    description: "A clock, more time.",
+    options: {},
+    render: (_o, dna, p) => one(picture((u, v) => sdCircle(u, v, 0.7), p.treasure, dna, p, 1, 1, {
+      detail: (u, v, d) => {
+        if (d > -0.14)
+          return null;
+        if (sdCapsule(u, v, 0, 0, 0, -0.38, 0.05) < 0 || sdCapsule(u, v, 0, 0, 0.26, 0.1, 0.05) < 0)
+          return p.outline;
+        return p.light;
+      }
+    }))
+  }
+];
+var PROPS = [
+  {
+    name: "crate",
+    family: "prop",
+    kind: "picture",
+    description: "A wooden crate.",
+    options: {},
+    render: (_o, dna, p) => one(picture((u, v) => sdBox(u, v, 0.8, 0.8, 0.06 + 0.1 * dna.roundness), p.wood, dna, p, 1, 1, {
+      detail: (u, v, d) => d > -0.18 ? shade(p.wood, 0.12) : Math.abs(u - v) < 0.12 ? shade(p.wood, 0.12) : Math.abs(u - v) < 0.18 ? shade(p.wood, -0.3) : null
+    }))
+  },
+  {
+    name: "barrel",
+    family: "prop",
+    kind: "picture",
+    description: "A barrel with metal hoops.",
+    options: {},
+    render: (_o, dna, p) => one(picture((u, v) => sdBox(u * (1 + 0.25 * v * v), v, 0.58, 0.8, 0.2), p.wood, dna, p, 1, 1, {
+      detail: (_u, v) => Math.abs(Math.abs(v) - 0.5) < 0.07 ? p.metal : null
+    }))
+  },
+  {
+    name: "door",
+    family: "prop",
+    kind: "picture",
+    description: "A door, one tile wide and two high.",
+    options: {},
+    render: (_o, dna, p) => one(picture((u, v) => union(sdBox(u, v - 0.3, 0.86, 1.62), sdCircle(u, v + 1.12, 0.86)), p.wood, dna, p, 1, 2, {
+      detail: (u, v, d) => d > -0.14 ? shade(p.wood, -0.3) : Math.hypot(u - 0.48, v - 0.3) < 0.1 ? p.treasure : Math.abs(u + 0.28) < 0.04 || Math.abs(u - 0.28) < 0.04 ? shade(p.wood, -0.3) : null
+    }))
+  },
+  {
+    name: "sign",
+    family: "prop",
+    kind: "picture",
+    description: "A signpost.",
+    options: {},
+    render: (_o, dna, p) => one(picture((u, v) => union(sdBox(u, v + 0.15, 0.72, 0.36, 0.06), sdBox(u, v - 0.5, 0.09, 0.38)), p.wood, dna, p, 1, 1, {
+      detail: (u, v) => v < 0.1 && v > -0.4 && Math.abs(v + 0.15) < 0.04 && Math.abs(u) < 0.5 ? shade(p.wood, -0.4) : null
+    }))
+  },
+  {
+    name: "rock",
+    family: "prop",
+    kind: "picture",
+    description: "A rock; each one a little different.",
+    options: {},
+    render: (_o, dna, p, seed) => one(picture((u, v) => Math.max(wobble(u, v - 0.18, 0.66, seed, 0.35), v - 0.82), p.stone, dna, p))
+  },
+  {
+    name: "bush",
+    family: "prop",
+    kind: "picture",
+    description: "A bush; each one a little different.",
+    options: {},
+    render: (_o, dna, p, seed) => one(picture((u, v) => {
+      let d = 9;
+      for (let i = 0; i < 4; i++)
+        d = Math.min(d, sdCircle(u - (i - 1.5) * 0.36, v - 0.25 + 0.2 * hash(i, 1, seed), 0.34 + 0.12 * hash(i, 2, seed)));
+      return Math.max(d, v - 0.8);
+    }, p.foliage, dna, p))
+  },
+  {
+    name: "tree",
+    family: "prop",
+    kind: "picture",
+    description: "A tree, one tile wide and two high; each one a little different.",
+    options: {},
+    render: (_o, dna, p, seed) => one(picture((u, v) => {
+      let crown = 9;
+      for (let i = 0; i < 5; i++)
+        crown = Math.min(crown, sdCircle(u - 0.5 * (hash(i, 3, seed) - 0.5), v + 1.05 - 0.6 * hash(i, 4, seed), 0.52 + 0.14 * hash(i, 5, seed)));
+      return union(crown, sdBox(u, v - 0.9, 0.15, 1));
+    }, p.foliage, dna, p, 1, 2, {
+      detail: (_u, v, d) => v > 0 && d < -0.02 ? p.wood : null
+    }))
+  },
+  {
+    name: "mushroom",
+    family: "prop",
+    kind: "picture",
+    description: "A spotted mushroom.",
+    options: {},
+    render: (_o, dna, p) => one(picture((u, v) => union(sdBox(u, v - 0.45, 0.2, 0.36, 0.08), Math.max(sdCircle(u, v - 0.1, 0.72), v - 0.08)), p.danger, dna, p, 1, 1, {
+      detail: (u, v) => v > 0.1 ? p.light : Math.hypot(u + 0.3, v + 0.3) < 0.12 || Math.hypot(u - 0.25, v + 0.42) < 0.1 ? p.light : null
+    }))
+  },
+  {
+    name: "fence",
+    family: "prop",
+    kind: "picture",
+    description: "A fence section that joins the next one.",
+    options: {},
+    render: (_o, dna, p) => one(picture((u, v) => union(sdBox(u + 0.55, v - 0.15, 0.13, 0.75, 0.04), sdBox(u - 0.55, v - 0.15, 0.13, 0.75, 0.04), sdBox(u, v + 0.15, 1.02, 0.08), sdBox(u, v - 0.4, 1.02, 0.08)), p.wood, dna, p))
+  },
+  {
+    name: "torch",
+    family: "prop",
+    kind: "animation",
+    description: "A torch whose flame flickers.",
+    options: {},
+    render: (_o, dna, p) => strip([0, 1, 2, 3].map((f) => picture((u, v) => {
+      const lean = 0.08 * Math.sin(f * 1.7);
+      const flame = union(sdCircle(u - lean * (v + 0.6), v + 0.38, 0.32 + 0.03 * Math.cos(f)), sdTriangle(u - lean * 1.5, v + 0.92, 0.24, 0.6));
+      return union(sdBox(u, v - 0.35, 0.14, 0.5), flame);
+    }, p.wood, dna, p, 1, 1, {
+      detail: (_u, v) => v < -0.1 ? v < -0.45 ? p.light : mix(p.treasure, p.danger, 0.4) : null
+    })), 10)
+  },
+  {
+    name: "flag",
+    family: "prop",
+    kind: "animation",
+    description: "A flag waving on its pole, a goal.",
+    options: {},
+    render: (_o, dna, p) => strip([0, 1, 2, 3].map((f) => picture((u, v) => {
+      const wave = 0.08 * Math.sin(u * 4 + f * Math.PI / 2);
+      return union(sdBox(u + 0.62, v, 0.06, 0.82), sdBox(u - 0.05, v + 0.45 - wave, 0.58, 0.26));
+    }, p.hero, dna, p, 1, 1, {
+      detail: (u) => u < -0.52 ? p.metal : null
+    })), 6)
+  },
+  {
+    name: "spikes",
+    family: "prop",
+    kind: "picture",
+    description: "Spikes, a hazard.",
+    options: {},
+    render: (_o, dna, p) => one(picture((u, v) => union(...dna.pixel ? [sdTriangle(u + 0.42, v + 0.55, 0.4, 1.25), sdTriangle(u - 0.42, v + 0.55, 0.4, 1.25)] : [sdTriangle(u + 0.56, v + 0.5, 0.26, 1.15), sdTriangle(u, v + 0.5, 0.26, 1.15), sdTriangle(u - 0.56, v + 0.5, 0.26, 1.15)], sdBox(u, v - 0.75, 0.88, 0.1, 0.03)), mix(p.metal, p.danger, 0.25), dna, p))
+  }
+];
+var ARCADE = [
+  {
+    name: "brick",
+    family: "arcade",
+    kind: "picture",
+    description: "A brick to break, two tiles wide when long; cracked by damage.",
+    options: {
+      shape: { kind: "enum", values: ["long", "square", "round"], default: "long", note: "its shape" },
+      damage: { kind: "enum", values: ["0", "1", "2"], default: "0", note: "how cracked it is" }
+    },
+    render: (o, dna, p, seed) => {
+      const long = o["shape"] === "long", round = o["shape"] === "round";
+      const cracks = Number(o["damage"]);
+      return one(picture((u, v) => round ? sdBox(u, v, long ? 1.9 : 0.9, 0.8, 0.6) : sdBox(u, v, long ? 1.96 : 0.96, 0.88, 0.12), mix(p.hero, p.danger, 0.3), dna, p, long ? 2 : 1, 1, {
+        gloss: false,
+        detail: (u, v) => {
+          for (let c = 0; c < cracks; c++) {
+            const x0 = (hash(c, 1, seed) - 0.5) * 1.2;
+            if (Math.abs(u - x0 - 0.35 * Math.sin(v * 5 + c)) < 0.04)
+              return p.outline;
+          }
+          return null;
+        }
+      }));
+    }
+  },
+  {
+    name: "paddle",
+    family: "arcade",
+    kind: "picture",
+    description: "A paddle, three tiles wide.",
+    options: {},
+    render: (_o, dna, p) => one(picture((u, v) => sdCapsule(u, v, -2.7, 0, 2.7, 0, 0.4), p.hero, dna, p, 3, 1, { gloss: true }))
+  },
+  {
+    name: "ball",
+    family: "arcade",
+    kind: "picture",
+    description: "A ball.",
+    options: {},
+    render: (_o, dna, p) => one(picture((u, v) => sdCircle(u, v, 0.7), p.light, dna, p, 1, 1, { gloss: true }))
+  },
+  {
+    name: "bumper",
+    family: "arcade",
+    kind: "picture",
+    description: "A round bumper.",
+    options: {},
+    render: (_o, dna, p) => one(picture((u, v) => sdCircle(u, v, 0.78), p.danger, dna, p, 1, 1, {
+      detail: (_u, _v, d) => d < -0.3 ? lightTint(p.danger) : d < -0.22 ? p.light : null
+    }))
+  },
+  {
+    name: "bar",
+    family: "arcade",
+    kind: "picture",
+    description: "A wall bar, two tiles wide and half a tile high.",
+    options: {},
+    render: (_o, dna, p) => one(picture((u, v) => sdBox(u, v, 4, 0.94, 0.15), p.metal, dna, p, 2, 0.5))
+  },
+  {
+    name: "target",
+    family: "arcade",
+    kind: "picture",
+    description: "A target with rings.",
+    options: {},
+    render: (_o, dna, p) => one(picture((u, v) => sdCircle(u, v, 0.78), p.light, dna, p, 1, 1, {
+      detail: (u, v) => {
+        const r = Math.hypot(u, v);
+        return r < 0.2 ? p.danger : r < 0.38 ? p.light : r < 0.56 ? p.danger : null;
+      }
+    }))
+  }
+];
+register(...[...PICKUPS, ...PROPS, ...ARCADE].map(seeded));
+
+// ../artgen/dist/recipes/effects.js
+function frame(sd, base, dna, p, alpha = 1, opts = {}) {
+  const S = tileSize(dna);
+  const sh = shapeShader(sd, base, dna, p, S, opts);
+  return new Raster(S, S).paint((x, y) => {
+    const c = sh(x, y);
+    return [c[0], c[1], c[2], c[3] * alpha];
+  }, dna.pixel ? 1 : 3);
+}
+function strip2(frames, fps) {
+  const f = frames[0];
+  const out = new Raster(f.w * frames.length, f.h);
+  frames.forEach((r, i) => {
+    out.blit(r, i * f.w, 0);
+  });
+  return { raster: out, frame: { w: f.w, h: f.h }, clips: { idle: frames.map((_, i) => i) }, fps };
+}
+var FOUR = [0, 1, 2, 3];
+var EFFECTS = [
+  {
+    name: "bullet",
+    family: "effect",
+    kind: "animation",
+    seeded: false,
+    description: "A bullet, flying right.",
+    options: {},
+    render: (_o, dna, p) => strip2([0, 1].map((f) => frame((u, v) => sdCapsule(u, v, -0.3, 0, 0.3, 0, 0.16 + 0.02 * f), p.treasure, dna, p, 1, { gloss: true })), 12)
+  },
+  {
+    name: "laser",
+    family: "effect",
+    kind: "animation",
+    seeded: false,
+    description: "A laser bolt, flying right.",
+    options: {},
+    render: (_o, dna, p) => strip2([0, 1].map((f) => frame((u, v) => sdCapsule(u, v, -0.75, 0, 0.75, 0, 0.09 + 0.03 * f), p.hero, dna, p, 1, {
+      detail: (_u, _v, d) => d < -0.05 ? mix(p.hero, [1, 1, 1, 1], 0.7) : null
+    })), 16)
+  },
+  {
+    name: "fireball",
+    family: "effect",
+    kind: "animation",
+    seeded: false,
+    description: "A fireball, flying right.",
+    options: {},
+    render: (_o, dna, p) => strip2(FOUR.map((f) => frame((u, v) => Math.min(sdCircle(u - 0.25, v, 0.34), sdTriangle(v + 1e-4, -(u - 0.15) + 1e-4, 0.26 + 0.04 * Math.sin(f * 1.6), 0.75 + 0.08 * Math.cos(f))), mix(p.treasure, p.danger, 0.5), dna, p, 1, {
+      detail: (u, _v, d) => d < -0.12 && u > 0.05 ? p.light : null
+    })), 12)
+  },
+  {
+    name: "arrow",
+    family: "effect",
+    kind: "animation",
+    seeded: false,
+    description: "An arrow, flying right.",
+    options: {},
+    render: (_o, dna, p) => strip2([frame((u, v) => Math.min(sdBox(u, v, 0.62, 0.05), sdTriangle(v, -(u - 0.82), 0.16, 0.28), sdBox(u + 0.62, v, 0.12, 0.13)), p.wood, dna, p, 1, { detail: (u) => u > 0.55 ? p.metal : u < -0.48 ? p.light : null })], 1)
+  },
+  {
+    name: "sparkle",
+    family: "effect",
+    kind: "animation",
+    seeded: false,
+    description: "A sparkle that twinkles.",
+    options: {},
+    render: (_o, dna, p) => strip2(FOUR.map((f) => {
+      const k = [0.45, 0.8, 0.55, 0.25][f] ?? 0.5;
+      return frame((u, v) => Math.min(sdBox(u, v, 0.08, 0.75 * k, 0.05), sdBox(u, v, 0.75 * k, 0.08, 0.05)), p.light, dna, p);
+    }), 10)
+  },
+  {
+    name: "puff",
+    family: "effect",
+    kind: "animation",
+    description: "A puff of smoke that spreads and fades.",
+    options: {},
+    render: (_o, dna, p, seed) => strip2([0, 1, 2, 3, 4].map((f) => frame((u, v) => {
+      let d = 9;
+      for (let i = 0; i < 4; i++) {
+        const a = i / 4 * Math.PI * 2 + hash(i, 1, seed);
+        d = Math.min(d, sdCircle(u - Math.cos(a) * 0.12 * (f + 1), v - Math.sin(a) * 0.1 * (f + 1), 0.22 + 0.04 * f));
+      }
+      return d;
+    }, shade(p.stone, 0.35), dna, p, 1 - f * 0.18)), 10)
+  },
+  {
+    name: "explosion",
+    family: "effect",
+    kind: "animation",
+    seeded: false,
+    description: "An explosion that grows, then fades.",
+    options: {},
+    render: (_o, dna, p) => strip2([0, 1, 2, 3, 4, 5].map((f) => {
+      const r = [0.25, 0.45, 0.62, 0.72, 0.78, 0.8][f] ?? 0.8;
+      const colour = f < 2 ? p.light : f < 4 ? mix(p.treasure, p.danger, 0.5) : shade(p.stone, -0.1);
+      return frame((u, v) => sdCircle(u, v, r), colour, dna, p, f < 4 ? 1 : 1 - (f - 3) * 0.4, {
+        detail: (u, v, d) => f >= 2 && f < 4 && d < -0.25 ? p.light : f >= 4 && Math.hypot(u, v) < r * 0.5 ? shade(p.stone, 0.2) : null
+      });
+    }), 14)
+  },
+  {
+    name: "flash",
+    family: "effect",
+    kind: "animation",
+    seeded: false,
+    description: "A hit flash.",
+    options: {},
+    render: (_o, dna, p) => strip2([0, 1, 2].map((f) => frame((u, v) => sdCircle(u, v, 0.7 - f * 0.2), p.light, dna, p, 1 - f * 0.3)), 20)
+  }
+];
+register(...EFFECTS);
+
+// ../artgen/dist/recipes/creatures.js
+var GROUND = 0.88;
+var POSES = [
+  { sx: 1, sy: 1, lean: 0, step: 0, flap: 0 },
+  { sx: 1.05, sy: 0.94, lean: 0, step: 0, flap: 1 },
+  { sx: 0.96, sy: 1.04, lean: 0.16, step: 1, flap: 0 },
+  { sx: 1.06, sy: 0.92, lean: 0.22, step: 2, flap: 1 },
+  { sx: 0.95, sy: 1.05, lean: 0.16, step: 3, flap: 0 },
+  { sx: 1.04, sy: 0.94, lean: 0.2, step: 4, flap: 1 },
+  { sx: 0.88, sy: 1.12, lean: 0.06, step: 0, flap: 1 },
+  { sx: 1.1, sy: 0.9, lean: -0.04, step: 0, flap: 0 },
+  { sx: 0.94, sy: 1.02, lean: -0.34, step: 0, flap: 0, eyes: "shut" },
+  { sx: 1.14, sy: 0.9, lean: 0.44, step: 2, flap: 1 },
+  { sx: 1.22, sy: 0.64, lean: 0, step: 0, flap: 0, eyes: "dead", fallen: true }
+];
+var BODIES = {
+  blob: { bw: 0.62, bh: 0.48 },
+  round: { bw: 0.52, bh: 0.52 },
+  bean: { bw: 0.4, bh: 0.64 },
+  square: { bw: 0.52, bh: 0.5 },
+  flyer: { bw: 0.44, bh: 0.44 },
+  bug: { bw: 0.68, bh: 0.34 }
+};
+function creatureFrame(o, dna, p, pose, S, seed) {
+  const body = String(o["body"]), eyes = String(o["eyes"]), mouth = String(o["mouth"]);
+  const extra = String(o["extra"]), feet = body === "flyer" || pose.fallen === true ? "none" : String(o["feet"]);
+  const j = (k) => hash(seed, k, 31) - 0.5;
+  const colour = shade(o["role"] === "enemy" ? p.danger : p.hero, 0.14 * j(1));
+  const kind = BODIES[body] ?? { bw: 0.5, bh: 0.5 };
+  const dims = { bw: kind.bw * (1 + 0.16 * j(2)), bh: kind.bh * (1 + 0.12 * j(3)) };
+  const bw = dims.bw * pose.sx, bh = dims.bh * pose.sy;
+  const flying = body === "flyer" && pose.fallen !== true;
+  const bottom = flying ? 0.25 + 0.04 * Math.sin(pose.flap * Math.PI) : feet === "legs" ? GROUND - 0.2 : feet === "stubs" ? GROUND - 0.07 : GROUND;
+  const cy = bottom - bh;
+  const lean = pose.lean;
+  const lx = (u, v) => u - lean * (bottom - v) * 0.5;
+  const round = 0.1 + 0.25 * dna.roundness;
+  const bodySd = body === "square" ? (u, v) => sdBox(lx(u, v), v - cy, bw, bh, round) : (u, v) => {
+    const e = (Math.hypot(lx(u, v) / bw, (v - cy) / bh) - 1) * Math.min(bw, bh);
+    return flying ? e : Math.max(e, v - bottom);
+  };
+  const parts = [];
+  const at = (fx, fy) => [fx * bw + lean * (bottom - (cy + fy * bh)) * 0.5, cy + fy * bh];
+  if (extra === "tail") {
+    const [ax, ay] = at(-0.85, 0.3), [bx, by] = at(-1.25, -0.25);
+    parts.push({ sd: (u, v) => sdCapsule(u, v, ax, ay, bx, by, 0.07), base: shade(colour, -0.15) });
+  }
+  if (flying || extra === "wings") {
+    const angle = pose.flap === 1 ? -0.7 : 0.15;
+    const [wx, wy] = at(-0.7, -0.85);
+    const c = Math.cos(angle), s = Math.sin(angle);
+    parts.push({
+      sd: (u, v) => {
+        const du = u - wx, dv = v - wy;
+        const ru = du * c - dv * s, rv = du * s + dv * c;
+        return (Math.hypot(ru / 0.4, rv / 0.2) - 1) * 0.2;
+      },
+      base: mix(p.light, colour, 0.25)
+    });
+  }
+  if (feet === "legs") {
+    for (const side of [-1, 1]) {
+      const swing = pose.step === 0 ? 0 : 0.12 * Math.sin(pose.step / 4 * Math.PI * 2 + (side > 0 ? 0 : Math.PI));
+      const hx = side * 0.22 * dims.bw;
+      parts.push({ sd: (u, v) => sdCapsule(u, v, hx, bottom - 0.04, hx + swing, GROUND - 0.06, 0.06), base: shade(colour, -0.3) });
+    }
+  }
+  if (feet === "stubs") {
+    for (const side of [-1, 1]) {
+      const hx = side * 0.3 * dims.bw + (pose.step % 2 === 1 ? 0.03 * side : 0);
+      parts.push({ sd: (u, v) => (Math.hypot((u - hx) / 0.15, (v - (GROUND - 0.07)) / 0.07) - 1) * 0.07, base: shade(colour, -0.3) });
+    }
+  }
+  parts.push({
+    sd: bodySd,
+    base: colour,
+    opts: {
+      gloss: dna.shading !== "flat",
+      ...body === "bug" ? { detail: (u, v, d) => d < -0.03 && Math.abs((lx(u, v) / bw + 1) * 2.5 % 1 - 0.5) > 0.46 ? shade(colour, -0.3) : null } : {}
+    }
+  });
+  if (extra === "shell") {
+    const [sx, sy] = at(-0.25, -0.15);
+    parts.push({
+      sd: (u, v) => Math.max((Math.hypot((u - sx) / (bw * 0.75), (v - sy) / (bh * 0.85)) - 1) * bh * 0.8, v - (cy + bh * 0.55)),
+      base: mix(p.wood, p.treasure, 0.4),
+      opts: { detail: (u, v, d) => d < -0.04 && Math.abs(Math.hypot(u - sx, v - sy) % 0.14 - 0.07) < 0.012 ? shade(mix(p.wood, p.treasure, 0.4), -0.35) : null }
+    });
+  }
+  if (extra === "spikes") {
+    for (const k of [-0.55, -0.2, 0.15]) {
+      const [tx, ty] = at(k, -0.92);
+      parts.push({ sd: (u, v) => sdTriangle(u - tx, v - (ty - 0.2), 0.08, 0.22), base: p.light });
+    }
+  }
+  if (extra === "horns" || extra === "ears") {
+    for (const k of [-0.4, 0.25]) {
+      const [tx, ty] = at(k, -0.85);
+      parts.push(extra === "horns" ? { sd: (u, v) => sdTriangle(u - tx, v - (ty - 0.24), 0.07, 0.26), base: p.light } : { sd: (u, v) => sdTriangle(u - tx, v - (ty - 0.22), 0.13, 0.26) - 0.03, base: shade(colour, -0.1) });
+    }
+  }
+  if (extra === "antennae") {
+    for (const k of [-0.25, 0.3]) {
+      const [tx, ty] = at(k, -0.9);
+      const ex = tx + 0.12, ey = ty - 0.3;
+      parts.push({ sd: (u, v) => Math.min(sdCapsule(u, v, tx, ty, ex, ey, 0.025), sdCircle(u - ex, v - ey, 0.06)), base: p.outline });
+    }
+  }
+  if (extra === "hat") {
+    const [hx, hy] = at(0.05, -0.86);
+    parts.push({ sd: (u, v) => Math.min(sdBox(u - hx, v - (hy - 0.16), 0.26, 0.18, 0.04), sdBox(u - hx, v - (hy + 0.02), 0.42, 0.045, 0.02)), base: shade(p.outline, 0.35) });
+  }
+  const gap = 0.12 * j(4), size = 1 + 0.3 * j(5);
+  const eyeSpots = eyes === "cyclops" ? [[0.3, 0.26 * size]] : [[0.02 - gap, 0.18 * size], [0.5 + gap, 0.18 * size]];
+  for (const [ex, er] of eyeSpots) {
+    const [x0, y0] = at(ex, -0.25);
+    const r = er * Math.min(dims.bw, dims.bh) / 0.52;
+    const stroke = Math.max(0.03, r * 0.28);
+    if (pose.eyes === "shut") {
+      parts.push({ sd: (u, v) => sdCapsule(u, v, x0 - r, y0, x0 + r, y0, stroke), base: p.outline });
+      continue;
+    }
+    if (pose.eyes === "dead") {
+      parts.push({
+        sd: (u, v) => Math.min(sdCapsule(u, v, x0 - r, y0 - r, x0 + r, y0 + r, stroke), sdCapsule(u, v, x0 - r, y0 + r, x0 + r, y0 - r, stroke)),
+        base: p.outline
+      });
+      continue;
+    }
+    parts.push({
+      sd: (u, v) => sdCircle(u - x0, v - y0, r),
+      base: [1, 1, 1, 1],
+      opts: {
+        detail: (u, v) => {
+          if (eyes === "sleepy" && v < y0)
+            return shade(colour, -0.08);
+          if (Math.hypot(u - x0 - r * 0.3, v - y0) < r * 0.48)
+            return p.outline;
+          return [1, 1, 1, 1];
+        }
+      }
+    });
+    if (eyes === "angry") {
+      parts.push({ sd: (u, v) => sdCapsule(u, v, x0 - r * 1.1, y0 - r * 1.35, x0 + r * 1.1, y0 - r * 0.9, Math.max(0.035, r * 0.22)), base: p.outline });
+    }
+  }
+  const [mx, my] = at(0.32, 0.25);
+  if (mouth === "smile" || mouth === "fangs") {
+    parts.push({ sd: (u, v) => Math.max(Math.abs(Math.hypot(u - mx, v - (my - 0.1)) - 0.13) - 0.03, -(v - (my - 0.04))), base: p.outline });
+    if (mouth === "fangs") {
+      for (const k of [-0.06, 0.06])
+        parts.push({ sd: (u, v) => sdTriangle(u - (mx + k), v - (my + 0.02), 0.035, -1e-4 + 0.09), base: [1, 1, 1, 1] });
+    }
+  }
+  if (mouth === "beak") {
+    const [bx, by] = at(0.85, 0.05);
+    parts.push({ sd: (u, v) => Math.max(Math.abs(v - by) - (bx + 0.24 - u) * 0.45, bx - 0.04 - u, u - (bx + 0.24)), base: p.treasure });
+  }
+  const shaders = parts.map((part) => ({ sd: part.sd, sh: shapeShader(part.sd, part.base, dna, p, S, part.opts) }));
+  return new Raster(S, S).paint((x, y) => {
+    const u = x / S * 2 - 1, v = y / S * 2 - 1;
+    for (let i = shaders.length - 1; i >= 0; i--) {
+      const s = shaders[i];
+      if (s.sd(u, v) <= 0)
+        return s.sh(x, y);
+    }
+    return CLEAR;
+  }, dna.pixel ? 1 : 3);
+}
+register({
+  name: "creature",
+  family: "creature",
+  kind: "animation",
+  description: "A creature built from parts, with idle, run, jump and fall, and hurt, attack and death for a script to play. role hero for the player, enemy for enemies.",
+  options: {
+    body: { kind: "enum", values: ["blob", "round", "bean", "square", "flyer", "bug"], default: "blob", note: "its body; flyer floats and flaps" },
+    eyes: { kind: "enum", values: ["round", "angry", "sleepy", "cyclops"], default: "round", note: "its eyes" },
+    mouth: { kind: "enum", values: ["smile", "fangs", "beak", "none"], default: "smile", note: "its mouth" },
+    extra: { kind: "enum", values: ["none", "horns", "ears", "antennae", "wings", "spikes", "shell", "hat", "tail"], default: "none", note: "one extra part" },
+    feet: { kind: "enum", values: ["none", "stubs", "legs"], default: "stubs", note: "its feet; flyers have none" },
+    role: { kind: "enum", values: ["hero", "enemy"], default: "hero", note: "hero takes the hero colour, enemy the danger colour" }
+  },
+  render: (o, dna, p, seed) => {
+    const S = tileSize(dna);
+    const frames = POSES.map((pose) => creatureFrame(o, dna, p, pose, S, seed));
+    const out = new Raster(S * frames.length, S);
+    frames.forEach((f, i) => {
+      out.blit(f, i * S, 0);
+    });
+    return { raster: out, frame: { w: S, h: S }, clips: { idle: [0, 1], run: [2, 3, 4, 5], jump: [6], fall: [7], hurt: [8], attack: [9], death: [10] }, fps: 8 };
+  }
+});
+
+// ../artgen/dist/draw-worker.js
+parentPort?.on("message", (m) => {
+  let result;
+  try {
+    result = draw(m.recipe, m.options, m.dna, m.seed);
+  } catch (error) {
+    result = { ok: false, reason: `the piece could not be drawn: ${error.message}` };
+  }
+  parentPort?.postMessage({ id: m.id, result }, result.ok ? [result.bytes.buffer] : []);
+});