@adatechnology/game-test-room 0.10.0 → 0.11.1

package/dist/index.global.js

@@ -4587,6 +4587,56 @@ var GameTestRoom = (() => {
     };
   }
   var GAME_SFX_BANK = { id: "game_sfx", sounds: [...GAME_SFX_CLASSES, GAME_SFX_FALLBACK].map((row) => noiseClassRecipe(row)) };
+  var ATTACK = 2e-3;
+  function lengthOf(d, attack) {
+    if (typeof d === "number") return attack + d;
+    if (Array.isArray(d)) return [attack + d[0], attack + d[1]];
+    return { ...d, add: (d.add ?? 0) + attack };
+  }
+  var envelope = (attack) => [
+    [0, 1e-4, "set", "fixed"],
+    [attack, 1, "exp"],
+    ["1d", 1e-4, "exp", "fixed"]
+  ];
+  function sceneNoise(o) {
+    const a = o.a ?? ATTACK;
+    const over = typeof o.d === "number" ? o.d : 0;
+    return {
+      filters: {
+        mode: "serial",
+        bank: [{ type: o.type ?? "lowpass", frequency: o.f2 === void 0 ? { set: o.f } : { set: o.f, to: o.f2, curve: "exp", over }, q: o.q ?? 0.7 }]
+      },
+      duration: lengthOf(o.d, a),
+      gain: o.vol,
+      ...o.delay === void 0 ? {} : { at: o.delay },
+      ...o.wet === void 0 ? {} : { wet: o.wet },
+      source: { kind: "noise", offset: "random", offsetScale: 1.5, loop: true },
+      envelope: envelope(a)
+    };
+  }
+  function sceneTone(o) {
+    return {
+      source: { kind: "osc", wave: o.wave ?? "sine", frequency: { from: o.f, to: o.f2 ?? "from", curve: "exp", over: "duration" } },
+      duration: lengthOf(o.d, ATTACK),
+      gain: o.vol,
+      ...o.delay === void 0 ? {} : { at: o.delay },
+      ...o.wet === void 0 ? {} : { wet: o.wet },
+      envelope: envelope(ATTACK)
+    };
+  }
+  var sceneMany = (count, make) => Array.from({ length: count }, make);
+  function sceneRecipe(id, layers, line, options = {}) {
+    return {
+      id,
+      bus: options.bus ?? "world",
+      pan: true,
+      layers,
+      falloff: DISTANCE_CURVES.art_scene,
+      ...options.vars ? { vars: options.vars } : {},
+      ...options.group ? { group: options.group } : {},
+      sources: [`cena:${line}`]
+    };
+  }
   function fillNoise(random, length3) {
     const samples = new Float32Array(length3);
     for (let index = 0; index < length3; index++) samples[index] = random() * 2 - 1;
@@ -6859,77 +6909,77 @@ var GameTestRoom = (() => {
     }));
   }
   function spawnPuff(pool, random, init) {
-    const puff2 = pool.acquire();
-    puff2.x = init.x ?? 0;
-    puff2.y = init.y ?? 0;
-    puff2.z = init.z ?? 0;
-    puff2.vx = init.vx ?? 0;
-    puff2.vy = init.vy ?? 0;
-    puff2.vz = init.vz ?? 0;
-    puff2.s0 = init.s0 ?? 0.2;
-    puff2.s1 = init.s1 ?? 1;
-    puff2.sg = init.sg ?? 0.1;
-    puff2.gk = init.gk ?? 6;
-    puff2.life = init.life ?? 3;
-    puff2.t = 0;
-    puff2.h0 = init.h0 ?? 0;
-    puff2.hl = init.hl ?? 0.4;
-    puff2.drag = init.drag ?? 3;
-    puff2.buoy = init.buoy ?? 0.5;
-    puff2.grav = init.grav ?? 0;
-    puff2.kind = init.kind ?? 0;
-    puff2.seed = random.next();
-    puff2.wind = init.wind ?? 1;
-    puff2.color = init.color ?? SMOKE_COLORS.grey;
-    puff2.ring = init.ring ?? null;
-    puff2.ph = init.ph ?? 0;
-    puff2.th = init.th ?? 0;
-    puff2.rng = random;
-    puff2.age = 0;
-    puff2.heat = 0;
-    puff2.size = 0;
-    return puff2;
-  }
-  function ageOrKeep2(puff2, dt) {
-    puff2.t += dt;
-    return puff2.t < puff2.life;
-  }
-  function moveOnRing(puff2, ring2, wind) {
+    const puff3 = pool.acquire();
+    puff3.x = init.x ?? 0;
+    puff3.y = init.y ?? 0;
+    puff3.z = init.z ?? 0;
+    puff3.vx = init.vx ?? 0;
+    puff3.vy = init.vy ?? 0;
+    puff3.vz = init.vz ?? 0;
+    puff3.s0 = init.s0 ?? 0.2;
+    puff3.s1 = init.s1 ?? 1;
+    puff3.sg = init.sg ?? 0.1;
+    puff3.gk = init.gk ?? 6;
+    puff3.life = init.life ?? 3;
+    puff3.t = 0;
+    puff3.h0 = init.h0 ?? 0;
+    puff3.hl = init.hl ?? 0.4;
+    puff3.drag = init.drag ?? 3;
+    puff3.buoy = init.buoy ?? 0.5;
+    puff3.grav = init.grav ?? 0;
+    puff3.kind = init.kind ?? 0;
+    puff3.seed = random.next();
+    puff3.wind = init.wind ?? 1;
+    puff3.color = init.color ?? SMOKE_COLORS.grey;
+    puff3.ring = init.ring ?? null;
+    puff3.ph = init.ph ?? 0;
+    puff3.th = init.th ?? 0;
+    puff3.rng = random;
+    puff3.age = 0;
+    puff3.heat = 0;
+    puff3.size = 0;
+    return puff3;
+  }
+  function ageOrKeep2(puff3, dt) {
+    puff3.t += dt;
+    return puff3.t < puff3.life;
+  }
+  function moveOnRing(puff3, ring2, wind) {
     const ringTime = ring2.t;
     const centerY = ring2.y0 + ring2.rise * (1 - Math.exp(-ringTime * ring2.rk));
     const majorRadius = ring2.R0 + (ring2.R1 - ring2.R0) * (1 - Math.exp(-ringTime * 1.6));
-    const theta = puff2.th + ringTime * ring2.roll;
+    const theta = puff3.th + ringTime * ring2.roll;
     const minorRadius = ring2.r * (0.8 + 0.4 * Math.min(1, ringTime));
     const radius = majorRadius + minorRadius * Math.cos(theta);
-    puff2.x = ring2.x + Math.cos(puff2.ph) * radius + wind.x * ringTime * 0.6;
-    puff2.z = ring2.z + Math.sin(puff2.ph) * radius + wind.z * ringTime * 0.6;
-    puff2.y = centerY + minorRadius * Math.sin(theta);
-  }
-  function moveFree(puff2, dt, age, heat, wind) {
-    const damping = Math.exp(-puff2.drag * dt);
-    puff2.vx *= damping;
-    puff2.vy *= damping;
-    puff2.vz *= damping;
-    puff2.vy += (puff2.buoy * (heat > 0 ? 1.6 : 1) - puff2.grav) * dt;
-    puff2.x += (puff2.vx + wind.x * puff2.wind * age) * dt;
-    puff2.y += puff2.vy * dt;
-    puff2.z += (puff2.vz + wind.z * puff2.wind * age) * dt;
-    if (puff2.y < puff2.s0 * FLOOR_FRACTION) {
-      puff2.y = puff2.s0 * FLOOR_FRACTION;
-      if (puff2.vy < 0) puff2.vy *= FLOOR_BOUNCE;
+    puff3.x = ring2.x + Math.cos(puff3.ph) * radius + wind.x * ringTime * 0.6;
+    puff3.z = ring2.z + Math.sin(puff3.ph) * radius + wind.z * ringTime * 0.6;
+    puff3.y = centerY + minorRadius * Math.sin(theta);
+  }
+  function moveFree(puff3, dt, age, heat, wind) {
+    const damping = Math.exp(-puff3.drag * dt);
+    puff3.vx *= damping;
+    puff3.vy *= damping;
+    puff3.vz *= damping;
+    puff3.vy += (puff3.buoy * (heat > 0 ? 1.6 : 1) - puff3.grav) * dt;
+    puff3.x += (puff3.vx + wind.x * puff3.wind * age) * dt;
+    puff3.y += puff3.vy * dt;
+    puff3.z += (puff3.vz + wind.z * puff3.wind * age) * dt;
+    if (puff3.y < puff3.s0 * FLOOR_FRACTION) {
+      puff3.y = puff3.s0 * FLOOR_FRACTION;
+      if (puff3.vy < 0) puff3.vy *= FLOOR_BOUNCE;
     }
   }
   function updatePuffs(pool, dt, wind) {
     pool.compact(ageOrKeep2, dt);
-    for (const puff2 of pool.items) {
-      const age = puff2.t / puff2.life;
-      const heat = puff2.h0 > 0 ? puff2.h0 * Math.pow(Math.max(0, 1 - puff2.t / puff2.hl), 1.25) : 0;
-      if (puff2.ring) moveOnRing(puff2, puff2.ring, wind);
-      else moveFree(puff2, dt, age, heat, wind);
-      const size = puff2.s0 + (puff2.s1 - puff2.s0) * (1 - Math.exp(-puff2.t * puff2.gk)) + puff2.sg * Math.min(puff2.t, GROWTH_CAP_SECONDS);
-      puff2.size = size * Math.min(1, puff2.t * ARRIVAL_FRAME + ARRIVAL_BASE);
-      puff2.age = age;
-      puff2.heat = heat;
+    for (const puff3 of pool.items) {
+      const age = puff3.t / puff3.life;
+      const heat = puff3.h0 > 0 ? puff3.h0 * Math.pow(Math.max(0, 1 - puff3.t / puff3.hl), 1.25) : 0;
+      if (puff3.ring) moveOnRing(puff3, puff3.ring, wind);
+      else moveFree(puff3, dt, age, heat, wind);
+      const size = puff3.s0 + (puff3.s1 - puff3.s0) * (1 - Math.exp(-puff3.t * puff3.gk)) + puff3.sg * Math.min(puff3.t, GROWTH_CAP_SECONDS);
+      puff3.size = size * Math.min(1, puff3.t * ARRIVAL_FRAME + ARRIVAL_BASE);
+      puff3.age = age;
+      puff3.heat = heat;
     }
   }
   var GROUND_LIFT = 0.02;
@@ -6986,9 +7036,9 @@ var GameTestRoom = (() => {
   var HOT_GLOW_COLOR = [1, 0.45, 0.12];
   function addPuff(core, random, init) {
     core.spawned.puffs++;
-    const puff2 = spawnPuff(core.puffs, random, init);
-    core.trace?.puff?.(puff2);
-    return puff2;
+    const puff3 = spawnPuff(core.puffs, random, init);
+    core.trace?.puff?.(puff3);
+    return puff3;
   }
   function addSpark(core, init) {
     core.spawned.sparks++;
@@ -7170,6 +7220,7 @@ var GameTestRoom = (() => {
   var neg = call("neg");
   var abs = call("abs");
   var sqrt = call("sqrt");
+  var exp = call("exp");
   var sin = call("sin");
   var cos = call("cos");
   var atan2 = call("atan2");
@@ -7215,10 +7266,12 @@ var GameTestRoom = (() => {
   var INDEX = { $: "index" };
   var QUALITY = { $: "quality" };
   var FRESH = { $: "fresh" };
+  var DIRECTION = { $: "direction" };
   var CAMERA_POSITION = { $: "cameraPosition" };
   var burst = (system, count, spawn2) => ({ op: "burst", system, count, spawn: spawn2 });
   var spawn = (system, options) => ({ op: "spawn", system, spawn: options });
   var emit = (key, system, rate, options) => ({ op: "emit", key, system, rate, spawn: options });
+  var mesh = (options) => ({ op: "mesh", spawn: options });
   var debris = (options) => ({ op: "debris", spawn: options });
   var decal = (...args) => ({ op: "decal", args });
   var ring = (...args) => ({ op: "ring", args });
@@ -8230,6 +8283,241 @@ var GameTestRoom = (() => {
       )
     ]
   };
+  var SPOTS_X = [-3, 1, 5];
+  var SPOTS_Z = [-1, -2.4, 0.4];
+  var FOG_AND_ASH = {
+    id: "fog_and_ash",
+    pageId: "neblina",
+    team: "world",
+    budget: { particles: 120, lights: 1 },
+    loop: 0,
+    view: { eye: [3, 1.8, 7.5], target: [-3, 1.2, -1] },
+    setup: [
+      cue("fog", { density: 0.075 }),
+      cue("lamp_cone", { visible: true }),
+      cue("zombie_visible", { index: -1, visible: false }),
+      repeat(
+        SPOTS_X.length,
+        set("turn", rnd(-0.6, 0.6)),
+        behavior("walkers", "place", { index: INDEX, x: pick(SPOTS_X, INDEX), z: pick(SPOTS_Z, INDEX), facing: variable("turn") })
+      )
+    ],
+    timeline: [],
+    tick: [
+      emit("fog", "normal", 5, { p: [rnd(-14, 10), rnd(0.2, 1.1), rnd(-3, 8)], v: [rnd(0.15, 0.35), 0, rnd(-0.05, 0.05)], sp: 0, life: [9, 13], size: [3, 5], grow: 1.4, c0: 8227488, a: 0.13, fi: 0.35 }),
+      emit("ash", "normal", 14, { p: [rnd(-10, 8), rnd(4, 6), rnd(-3, 7)], v: [rnd(0.1, 0.4), -0.35, rnd(-0.1, 0.1)], sp: [0.05, 0.15], life: [8, 12], size: [0.025, 0.04], c0: 10525328, a: 0.75, fi: 0.1, gnd: 1 })
+    ]
+  };
+  var RAIN_CAPACITY = 4e3;
+  var FALL_SPEED = 15;
+  var WIND_PER_FALL = 0.07;
+  var STREAK_SLANT = 0.04;
+  var STREAK_LENGTH = 0.6;
+  var BOX_X = [-15, 15];
+  var BOX_Z = [-6, 16];
+  var START_HEIGHT = [0, 16];
+  var REENTRY_HEIGHT = [14, 17];
+  var SPLASH_CHANCE = 0.35;
+  var SPLASH_RANGE = 12;
+  var SPRITE_CHANCE = 0.5;
+  var UP9 = [0, 1, 0];
+  var WORKSHOP_PUDDLES = [
+    [-1.5, 2.2, 1.6, 0.9],
+    [3, 3.6, 1.1, 0.7],
+    [-6, 3.2, 1.3, 0.8],
+    [1.4, -2.2, 0.9, 0.5]
+  ];
+  var inPuddle = (puddles, x, z) => puddles.some((p) => ((x - p[0]) / p[2]) ** 2 + ((z - p[1]) / p[3]) ** 2 < 1);
+  var RainField = class {
+    constructor(engine) {
+      __publicField(this, "engine", engine);
+      __publicField(this, "positions", new Float32Array(RAIN_CAPACITY * 6));
+      __publicField(this, "count", 0);
+      __publicField(this, "wind", 1);
+      __publicField(this, "on", false);
+      __publicField(this, "centerX", 0);
+      __publicField(this, "centerZ", 0);
+      __publicField(this, "puddles", WORKSHOP_PUDDLES);
+      __publicField(this, "puddleAt");
+    }
+    /** `initRain` (W321): `count` streaks (thinned by the quality), each drawn at a random place in the box. */
+    init(count, wind) {
+      const { random } = this.engine;
+      this.count = Math.min(RAIN_CAPACITY, Math.round(count * this.engine.context.quality.mult));
+      this.wind = wind;
+      this.on = true;
+      for (let index = 0; index < this.count; index++) {
+        const offset = index * 6;
+        const x = random.between(BOX_X[0], BOX_X[1]);
+        const y = random.between(START_HEIGHT[0], START_HEIGHT[1]);
+        const z = random.between(BOX_Z[0], BOX_Z[1]);
+        this.set(offset, x, y, z);
+      }
+    }
+    /**
+     * What a game does with the field every frame: the box follows the camera (`centerX`, `centerZ`), the streaks thin or thicken to `count` (a new streak
+     * starts at a random place of the box, as `init` draws it) and the wind slants them. The golden never calls it.
+     */
+    drive(count, wind, centerX, centerZ) {
+      const { random } = this.engine;
+      const target = Math.max(0, Math.min(RAIN_CAPACITY, Math.round(count * this.engine.context.quality.mult)));
+      this.wind = wind;
+      this.centerX = centerX;
+      this.centerZ = centerZ;
+      this.on = target > 0;
+      for (let index = this.count; index < target; index++) {
+        this.set(index * 6, random.between(BOX_X[0], BOX_X[1]) + centerX, random.between(START_HEIGHT[0], START_HEIGHT[1]), random.between(BOX_Z[0], BOX_Z[1]) + centerZ);
+      }
+      this.count = target;
+    }
+    /** `updateRain` (W322-329). `camera` is where the eye is; `splash` lets the drops that land leave a splash. */
+    update(dt, splash, camera2) {
+      if (!this.on) return;
+      const { random, context } = this.engine;
+      const positions = this.positions;
+      const fall = FALL_SPEED * dt;
+      const slant = this.wind * fall * WIND_PER_FALL;
+      const reach = SPLASH_RANGE / (1 + context.quality.level);
+      for (let index = 0; index < this.count; index++) {
+        const o = index * 6;
+        positions[o] += slant;
+        positions[o + 3] += slant;
+        positions[o + 1] -= fall;
+        positions[o + 4] -= fall;
+        const ground = context.groundAt(positions[o], positions[o + 2]);
+        if (positions[o + 4] < ground) {
+          const x = positions[o];
+          const z = positions[o + 2];
+          if (splash && random.next() < SPLASH_CHANCE) {
+            const distance4 = Math.hypot(x - camera2[0], z - camera2[2]);
+            if (distance4 < reach) {
+              if (random.next() < SPRITE_CHANCE) {
+                this.engine.spawn("normal", { p: [x, ground + 0.01, z], dir: UP9, cone: 0.6, sp: [0.6, 1.3], life: [0.18, 0.3], size: 0.035, c0: 12110044, a: 0.6, g: 9.8, fi: 0 });
+              }
+              if (this.puddleAt ? this.puddleAt(x, z) : inPuddle(this.puddles, x, z)) {
+                this.engine.ring([[x, ground + 0.012, z], 0.01, random.between(0.12, 0.25), random.between(0.4, 0.6), 6978192]);
+              }
+            }
+          }
+          const nx = random.between(BOX_X[0], BOX_X[1]) + this.centerX;
+          const ny = random.between(REENTRY_HEIGHT[0], REENTRY_HEIGHT[1]);
+          const nz = random.between(BOX_Z[0], BOX_Z[1]) + this.centerZ;
+          this.set(o, nx, ny, nz);
+        }
+      }
+    }
+    /** `rain.visible = false; RN.on = false` (W440): the field stops; the streaks stay where they were. */
+    clear() {
+      this.on = false;
+    }
+    set(offset, x, y, z) {
+      const positions = this.positions;
+      positions[offset] = x;
+      positions[offset + 1] = y;
+      positions[offset + 2] = z;
+      positions[offset + 3] = x + this.wind * STREAK_SLANT;
+      positions[offset + 4] = y - STREAK_LENGTH;
+      positions[offset + 5] = z;
+    }
+  };
+  var DROPS = [900, 2200, 4e3];
+  var SLANT = [0.3, 1.2, 4.5];
+  var STORM = 2;
+  var FLASH_STEPS = ite(lt(variable("flash"), 0.08), 1, ite(lt(variable("flash"), 0.16), 0.2, ite(lt(variable("flash"), 0.26), 0.8, 0)));
+  var RAIN_AND_PUDDLES = {
+    id: "rain_and_puddles",
+    pageId: "chuva",
+    team: "world",
+    params: { id: "intensity", options: ["drizzle", "rain", "storm"], default: 1 },
+    budget: { particles: 4e3, decals: 4 },
+    loop: 0,
+    view: { eye: [2, 2, 7], target: [-1, 0.6, 1] },
+    setup: [
+      cue("lamp_cone", { visible: true }),
+      ...WORKSHOP_PUDDLES.map(([x, z, radiusX, radiusZ]) => decal(x, 0, z, radiusX * 2, 790550, { grow: 0, life: 1e6, ar: radiusZ / radiusX }))
+    ],
+    timeline: [
+      behavior("rain", "init", { count: ite(eq(PARAM, 0), DROPS[0], ite(eq(PARAM, 1), DROPS[1], DROPS[2])), wind: ite(eq(PARAM, 0), SLANT[0], ite(eq(PARAM, 1), SLANT[1], SLANT[2])) }),
+      set("nextStrike", rnd(2, 4)),
+      set("flash", -1)
+    ],
+    tick: [
+      behavior("rain", "update", { dt: DELTA, splash: gt(PARAM, 0) }),
+      when(eq(PARAM, STORM), [
+        when(gt(TIME, variable("nextStrike")), [set("nextStrike", add(TIME, rnd(3.5, 6))), set("flash", 0)]),
+        when(ge(variable("flash"), 0), [
+          set("flash", add(variable("flash"), DELTA)),
+          set("light", FLASH_STEPS),
+          cue("lightning", { intensity: variable("light") }),
+          screen({ max: { white: mul(variable("light"), 0.12) } }),
+          when(gt(variable("flash"), 0.4), [set("flash", -1), cue("lightning", { intensity: 0 })])
+        ]),
+        emit("sheet", "normal", 2.5, { p: [-12, 2.5, rnd(-1, 8)], box: [0, 2, 0], v: [7, -0.5, 0], sp: 0, life: [3, 4], size: [3, 5], grow: 1.3, c0: 9083568, a: 0.06, fi: 0.3 })
+      ])
+    ]
+  };
+  var CAR_ORIGIN2 = [5.6, 0, 0.8];
+  var CAR_ROTATION2 = [0, -0.4, 0];
+  var carPoint = (x, y, z) => localToWorld(CAR_ORIGIN2, CAR_ROTATION2, [x, y, z]);
+  var carDirection = (from, to) => normalized([to[0] - from[0], to[1] - from[1], to[2] - from[2]]);
+  var BEAM_FROM = carPoint(0, 0.74, 2.15);
+  var BEAM_DIRECTION = carDirection(BEAM_FROM, carPoint(0, 0.74, 3.15));
+  var BEAM_SIDE = [BEAM_DIRECTION[2], 0, -BEAM_DIRECTION[0]];
+  var WALKERS = 6;
+  var WALK_SPEED2 = 0.7;
+  var DROPS2 = 1800;
+  var SLANT2 = 0.8;
+  var startWalking = [
+    set("spot", query("car", "point", rnd(-2, 2), 0, rnd(8, 18))),
+    set("goal", query("car", "point", rnd(-0.6, 0.6), 0, 2.6)),
+    behavior("walkers", "place", { index: INDEX, x: pick(variable("spot"), 0), z: pick(variable("spot"), 2), facing: 0 }),
+    behavior("walkers", "walk", { index: INDEX, to: variable("goal"), speed: WALK_SPEED2 })
+  ];
+  var HEADLIGHTS_IN_RAIN = {
+    id: "headlights_in_rain",
+    pageId: "farol",
+    team: "vehicles",
+    budget: { particles: 600, lights: 2 },
+    loop: 0,
+    view: { eye: [-2.5, 2, 5.5], target: [4, 1, 6] },
+    setup: [
+      cue("fog", { density: 0.05 }),
+      cue("headlights", { on: true, intensity: 2.4, color: 16773584 }),
+      behavior("rain", "init", { count: DROPS2, wind: SLANT2 }),
+      repeat(WALKERS, ...startWalking)
+    ],
+    timeline: [],
+    tick: [
+      behavior("rain", "update", { dt: DELTA, splash: true }),
+      emit(
+        "lit",
+        "streak",
+        600,
+        local(
+          "depth",
+          rnd(1, 13),
+          local(
+            "spread",
+            mul(variable("depth"), 0.33, sqrt(rand())),
+            local(
+              "turn",
+              rnd(0, 6.283),
+              local("base", vadd(BEAM_FROM, vscale(BEAM_DIRECTION, variable("depth")), vscale(BEAM_SIDE, mul(cos(variable("turn")), variable("spread")))), {
+                p: vwith(variable("base"), 1, add(vy(variable("base")), mul(sin(variable("turn")), variable("spread"), 0.6))),
+                v: [0.8, -14, 0],
+                sp: 0,
+                life: 0.06,
+                len: 0.035,
+                c0: 13622512,
+                a: 0.9
+              })
+            )
+          )
+        )
+      ),
+      repeat(WALKERS, when(not(query("walkers", "is_walking", INDEX)), startWalking))
+    ]
+  };
   var YAW = -Math.PI / 2;
   var COS = Math.cos(YAW);
   var SIN = Math.sin(YAW);
@@ -8257,10 +8545,6 @@ var GameTestRoom = (() => {
       fireLight(0, [vx(variable("contact")), 0.34, vz(variable("contact"))], 1.6, mul(TIME, 3))
     ]
   };
-  var CAR_ORIGIN2 = [5.6, 0, 0.8];
-  var CAR_ROTATION2 = [0, -0.4, 0];
-  var carPoint = (x, y, z) => localToWorld(CAR_ORIGIN2, CAR_ROTATION2, [x, y, z]);
-  var carDirection = (from, to) => normalized([to[0] - from[0], to[1] - from[1], to[2] - from[2]]);
   var HOOD = carPoint(0, 1.02, 1.4);
   var EXHAUST = carPoint(0.5, 0.3, -2.2);
   var EXHAUST_DIRECTION = carDirection(EXHAUST, carPoint(0.5, 0.3, -3));
@@ -8294,7 +8578,7 @@ var GameTestRoom = (() => {
       ], [fireLightOff(0)])
     ]
   };
-  var UP9 = [0, 1, 0];
+  var UP10 = [0, 1, 0];
   var doorVelocity = (side) => {
     const out = carPoint(side * 4, 3, 0.3);
     const centre = carPoint(0, 0, 0.3);
@@ -8304,7 +8588,7 @@ var GameTestRoom = (() => {
     call2("explode", vadd(query("car", "position"), [0, 0.6, 0]), 1.8, 2759188),
     cue("car_burnt"),
     behavior("car", "launch", { rise: 4.5, spin: 0.9 }),
-    repeat(scaled(30), debris({ p: vadd(query("car", "position"), [0, 1.3, 0]), dir: UP9, cone: 1.3, sp: [2, 6], size: [0.06, 6e-3, 0.06], c: 11061464, life: 20 })),
+    repeat(scaled(30), debris({ p: vadd(query("car", "position"), [0, 1.3, 0]), dir: UP10, cone: 1.3, sp: [2, 6], size: [0.06, 6e-3, 0.06], c: 11061464, life: 20 })),
     debris({ p: carPoint(0, 1, 1.4), v: [rnd(-1, 1), 9, rnd(-1, 1)], sp: 0, size: [1.6, 0.06, 1.2], c: 3808536, spin: 6, life: 20, bounce: 0.2 }),
     ...[-1, 1].map((side) => debris({ p: carPoint(side * 0.95, 0.7, 0.3), v: doorVelocity(side), sp: 0, size: [0.06, 0.7, 1.1], c: 3808536, spin: 5, life: 20, bounce: 0.2 })),
     debris({ p: carPoint(0.95, 0.38, 1.35), v: [3, 4, 2], sp: 0, size: [0.3, 0.76, 0.76], c: 1118481, spin: 8, life: 20, bounce: 0.4 })
@@ -8474,7 +8758,7 @@ var GameTestRoom = (() => {
       ])
     ]
   };
-  var WALKERS = 6;
+  var WALKERS2 = 6;
   var NEAR = 9;
   var RANGE = 7;
   var RESTING_BPM = 70;
@@ -8490,7 +8774,7 @@ var GameTestRoom = (() => {
     setup: [
       cue("zombie_visible", { index: -1, visible: false }),
       repeat(
-        WALKERS,
+        WALKERS2,
         set("startX", rnd(-4, 4)),
         set("startZ", sub(rnd(-4, -2), mul(INDEX, 0.6))),
         behavior("walkers", "place", { index: INDEX, x: variable("startX"), z: variable("startZ"), facing: 0 }),
@@ -8500,7 +8784,7 @@ var GameTestRoom = (() => {
     timeline: [],
     tick: [
       set("nearest", 99),
-      repeat(WALKERS, set("nearest", min(variable("nearest"), vdist(walkerPoint, CAMERA_POSITION)))),
+      repeat(WALKERS2, set("nearest", min(variable("nearest"), vdist(walkerPoint, CAMERA_POSITION)))),
       set("fear", clamp3(div(sub(NEAR, variable("nearest")), RANGE), 0, 1)),
       set("bpm", add(RESTING_BPM, mul(BPM_RISE, variable("fear")))),
       when(lt(mod(div(mul(TIME, variable("bpm")), 60), 1), div(mul(DELTA, variable("bpm")), 60)), [screen({ set: { beat: add(0.4, mul(0.6, variable("fear"))) } })]),
@@ -8567,7 +8851,7 @@ var GameTestRoom = (() => {
     ]
   };
   var FACING4 = [0, 0, 1];
-  var UP10 = [0, 1, 0];
+  var UP11 = [0, 1, 0];
   var ORIGIN = [0, 0, 0];
   var FORWARD4 = [0, 0, -1];
   var IMPACT_MATERIALS = ["concrete", "metal", "wood", "glass", "flesh", "water"];
@@ -8697,12 +8981,157 @@ var GameTestRoom = (() => {
       team: "destruction",
       budget: { particles: 20, debris: 8 },
       loop: 2,
-      timeline: [call2("chips", ORIGIN, UP10, 8, 0.9), call2("rust_at", ORIGIN, 6)]
+      timeline: [call2("chips", ORIGIN, UP11, 8, 0.9), call2("rust_at", ORIGIN, 6)]
     }
   ];
-  var ALL_EFFECTS = [BLOOD_HIT, HEADSHOT, DISMEMBER, BLOATER_CLOUD, SCREAMER_SHRIEK, CORPSE_DECAY, REANIMATION, EYES_IN_FOG, MUZZLE_FLASH, IMPACT_BY_MATERIAL, PENETRATION, CASINGS_AND_MAGAZINE, MOLOTOV, GRENADE, EXPLOSIVE_BARREL, SHOPFRONT_GLASS, DOOR_STAGES, BUILDING_COLLAPSE, BLOCK_WALL, METAL_DOOR_EFFECT, IRON_RAILING, WOODEN_FENCE, HIT_POINT_BREAKAGE, PRESSURE_CYLINDERS, BUILDING_FIRE, SCRAPING_SPARKS, ENGINE_SMOKE, FUEL_LEAK, CAR_EXPLOSION, WINDSHIELD, DAMAGE_AND_BITE, INFECTION_PHASES, PANIC, BLOATER_BLINDNESS, CAMPFIRE, COUGH_AND_BREATH];
+  var PI = Math.PI;
+  var SMOKE = { color: 9079430, width: 10, height: 8, gravity: -0.08, drag: 2.2, growth: 2.1 };
+  var FLASH_SECONDS = 0.055;
+  var FLASH_RAMP = [0.6, 0.9];
+  var FLASH_OPACITY = 0.95;
+  var FLAME_COLORS = [16742946, 16760896, 13121050, 16773296];
+  var FLAME_ADDITIVE = 3;
+  var ORIGIN2 = [0, 0, 0];
+  var SIZE = variable("size");
+  var wide = (width) => mul(sub(rand(), 0.5), width);
+  var puff2 = (point, velocity, world, radius, life, opacity) => mesh({
+    shape: "sphere",
+    p: point,
+    v: velocity,
+    wv: world,
+    r: radius,
+    seg: SMOKE.width,
+    seg2: SMOKE.height,
+    life,
+    c0: SMOKE.color,
+    a: opacity,
+    fade: true,
+    lit: true,
+    g: SMOKE.gravity,
+    drag: SMOKE.drag,
+    grow: SMOKE.growth
+  });
+  var flameBit = (point, velocity, world, radius, life) => [
+    set("bitPoint", point),
+    set("bitVelocity", velocity),
+    set("bitWorld", world),
+    set("bitRadius", radius),
+    set("bitLife", life),
+    set("bitColour", floor(mul(rand(), FLAME_COLORS.length))),
+    mesh({
+      shape: "icosahedron",
+      p: variable("bitPoint"),
+      v: variable("bitVelocity"),
+      wv: variable("bitWorld"),
+      r: variable("bitRadius"),
+      seg: 1,
+      rot: [mul(rand(), 3), mul(rand(), 3), 0],
+      spin: [3, 4, 2],
+      life: variable("bitLife"),
+      c0: pick(FLAME_COLORS, variable("bitColour")),
+      add: eq(variable("bitColour"), FLAME_ADDITIVE),
+      a: 0.9,
+      fade: true,
+      g: -1.4,
+      drag: 1.4,
+      grow: 2.2
+    })
+  ];
+  var flashPiece = (shape, radius, height, width, at3, rot, color) => mesh({ shape, r: radius, ...height === void 0 ? {} : { h: height }, seg: width, seg2: shape === "sphere" ? 8 : 1, p: ORIGIN2, at: at3, rot, roll: variable("roll"), ramp: FLASH_RAMP, life: FLASH_SECONDS, c0: color, a: FLASH_OPACITY, add: true });
+  var MUZZLE_FLASH2 = {
+    id: "viewmodel_muzzle_flash",
+    pageId: "event:viewmodel_muzzle_flash",
+    team: "weapons",
+    budget: { particles: 12, lights: 1 },
+    loop: 0.1,
+    timeline: [
+      set("angles", []),
+      repeat(4, append("angles", add(div(mul(INDEX, PI), 2), mul(rand(), 0.6)))),
+      set("roll", mul(rand(), PI)),
+      flash(ORIGIN2, 16756832, mul(4, SIZE), FLASH_SECONDS, mul(2, SIZE), true, true),
+      flashPiece("cone_open", mul(0.013, SIZE), mul(0.085, SIZE), 10, [mul(0.042, SIZE), 0, 0], [0, 0, -PI / 2], 16757575),
+      repeat(
+        4,
+        set("angle", pick(variable("angles"), INDEX)),
+        flashPiece(
+          "cone",
+          mul(5e-3, SIZE),
+          mul(0.04, SIZE),
+          6,
+          [mul(0.012, SIZE), mul(cos(variable("angle")), 0.016, SIZE), mul(sin(variable("angle")), 0.016, SIZE)],
+          [variable("angle"), 0, -PI / 2],
+          16757575
+        )
+      ),
+      flashPiece("sphere", mul(0.016, SIZE), void 0, 12, [mul(8e-3, SIZE), 0, 0], [0, 0, 0], 16773568),
+      repeat(
+        6,
+        puff2(
+          ORIGIN2,
+          [add(0.15, mul(rand(), 0.35)), add(0.03, mul(rand(), 0.12)), mul(sub(rand(), 0.5), 0.14)],
+          [0, 0, 0],
+          mul(0.013, SIZE),
+          add(1.3, mul(rand(), 0.6)),
+          0.45
+        )
+      )
+    ]
+  };
+  var SMOKE_PUFF = {
+    id: "weapon_smoke_puff",
+    pageId: "event:weapon_smoke_puff",
+    team: "weapons",
+    budget: { particles: 1 },
+    loop: 0.1,
+    timeline: [puff2(ORIGIN2, void 0, [variable("vx"), variable("vy"), variable("vz")], variable("radius"), variable("life"), variable("opacity"))]
+  };
+  var BACKBLAST = {
+    id: "launcher_backblast",
+    pageId: "event:launcher_backblast",
+    team: "weapons",
+    budget: { particles: 40 },
+    loop: 0.1,
+    timeline: [
+      repeat(26, puff2(ORIGIN2, [neg(add(1.5, mul(rand(), 3))), 0, 0], [wide(1.4), wide(0.8), wide(1.4)], add(0.03, mul(rand(), 0.03)), add(1.8, mul(rand(), 1.4)), 0.5)),
+      repeat(14, ...flameBit(ORIGIN2, [neg(add(2, mul(rand(), 2))), 0, 0], [wide(1), wide(0.6), wide(1)], 0.02, 0.25))
+    ]
+  };
+  var FLAME_JET = {
+    id: "flame_jet",
+    pageId: "event:flame_jet",
+    team: "weapons",
+    budget: { particles: 30 },
+    loop: 0.1,
+    timeline: [
+      repeat(
+        floor(mul(420, variable("dt"), variable("scale"))),
+        set("speed", mul(add(2.2, mul(rand(), 1.1)), variable("scale"))),
+        ...flameBit(
+          [mul(rand(), variable("speed"), min(variable("dt"), 0.3)), 0, 0],
+          [variable("speed"), 0, 0],
+          [wide(0.35), mul(sub(rand(), 0.3), 0.3), wide(0.35)],
+          add(0.02, mul(rand(), 0.022)),
+          add(0.4, mul(rand(), 0.35))
+        )
+      ),
+      when(lt(rand(), 0.5), [
+        puff2([add(mul(1.1, variable("scale")), mul(rand(), 0.4)), 0, 0], void 0, [mul(vx(DIRECTION), 0.6), 0.35, mul(vz(DIRECTION), 0.6)], 0.03, 1.6, 0.4)
+      ])
+    ]
+  };
+  var VIEWMODEL_EFFECTS = [MUZZLE_FLASH2, SMOKE_PUFF, BACKBLAST, FLAME_JET];
+  var aliasOf = (base, id, changes) => ({ ...base, id, pageId: `vehicle:${id}`, anchor: CAR_ORIGIN2, ...changes });
+  var VEHICLE_EFFECTS = [
+    /** The engine on fire: `engine_smoke` at its worst condition (black smoke, flames in the hood, a light). */
+    aliasOf(ENGINE_SMOKE, "vehicle_fire", { params: { id: "condition", options: ["100", "60", "30", "10"], default: 3 }, loop: 12 }),
+    /** The exhaust of a car under way: `engine_smoke` in the best condition, for half a second so a moving car asks again. */
+    aliasOf(ENGINE_SMOKE, "vehicle_exhaust", { params: { id: "condition", options: ["100", "60", "30", "10"], default: 0 }, loop: 0.5 }),
+    /** A hole in the tank: the page's own petrol leak (drips, pool, sparks, fire running to the tank). */
+    aliasOf(FUEL_LEAK, "vehicle_leak", {})
+  ];
+  var ALL_EFFECTS = [BLOOD_HIT, HEADSHOT, DISMEMBER, BLOATER_CLOUD, SCREAMER_SHRIEK, CORPSE_DECAY, REANIMATION, EYES_IN_FOG, MUZZLE_FLASH, IMPACT_BY_MATERIAL, PENETRATION, CASINGS_AND_MAGAZINE, MOLOTOV, GRENADE, EXPLOSIVE_BARREL, SHOPFRONT_GLASS, DOOR_STAGES, BUILDING_COLLAPSE, BLOCK_WALL, METAL_DOOR_EFFECT, IRON_RAILING, WOODEN_FENCE, HIT_POINT_BREAKAGE, PRESSURE_CYLINDERS, BUILDING_FIRE, RAIN_AND_PUDDLES, FOG_AND_ASH, SCRAPING_SPARKS, ENGINE_SMOKE, FUEL_LEAK, CAR_EXPLOSION, WINDSHIELD, HEADLIGHTS_IN_RAIN, DAMAGE_AND_BITE, INFECTION_PHASES, PANIC, BLOATER_BLINDNESS, CAMPFIRE, COUGH_AND_BREATH];
   var WORKSHOP_EFFECTS = Object.fromEntries(ALL_EFFECTS.map((effect) => [effect.id, effect]));
-  var GAME_EFFECTS = { ...WORKSHOP_EFFECTS, ...Object.fromEntries(EVENT_EFFECTS.map((effect) => [effect.id, effect])) };
+  var GAME_EFFECTS = { ...WORKSHOP_EFFECTS, ...Object.fromEntries([...EVENT_EFFECTS, ...VIEWMODEL_EFFECTS, ...VEHICLE_EFFECTS].map((effect) => [effect.id, effect])) };
   var LEHMER_MULTIPLIER = 16807;
   var LEHMER_MODULUS = 2147483647;
   var HASH_MIX = 2654435761;
@@ -8798,7 +9227,7 @@ var GameTestRoom = (() => {
   }
   var COLUMNS = 6;
   var ROWS = 5;
-  var ORIGIN2 = [-2.2, 0, 2.6];
+  var ORIGIN3 = [-2.2, 0, 2.6];
   var BLOCK_SIZE = [0.5, 0.44, 0.25];
   var OBJECT_ID_DRAWS2 = 4;
   var FLOOR2 = 0.13;
@@ -8841,7 +9270,7 @@ var GameTestRoom = (() => {
           const chipScale = random.between(0.8, 1.3) * scale2;
           for (let draw2 = 0; draw2 < OBJECT_ID_DRAWS2; draw2++) random.next();
           best.holes.push({ x: offsetX, y: offsetY, scale: scale2, chipTurn, chipScale });
-          impact(host.engine, "concrete", [ORIGIN2[0] + x, y, ORIGIN2[2] + 0.13], [0, 0, 1], 0.8);
+          impact(host.engine, "concrete", [ORIGIN3[0] + x, y, ORIGIN3[2] + 0.13], [0, 0, 1], 0.8);
         } else if (action === "collapse") {
           const { x, y } = args;
           for (const block of blocks) {
@@ -8891,7 +9320,7 @@ var GameTestRoom = (() => {
       }
     };
   }
-  var ORIGIN3 = [5.6, 0, 0.8];
+  var ORIGIN4 = [5.6, 0, 0.8];
   var MAX_TILT = 0.25;
   function createCarBehavior() {
     let y = 0;
@@ -8923,8 +9352,13 @@ var GameTestRoom = (() => {
           }
         }
       },
-      query(_host, name) {
-        if (name === "position") return [ORIGIN3[0], y, ORIGIN3[2]];
+      query(_host, name, args) {
+        if (name === "position") return [ORIGIN4[0], y, ORIGIN4[2]];
+        if (name === "point") {
+          const [x, py, z] = args;
+          const point = carPoint(x, py, z);
+          return [point[0], point[1] + y, point[2]];
+        }
         if (name === "roll") return roll;
         throw new Error(`car: unknown query ${name}`);
       },
@@ -9124,6 +9558,29 @@ var GameTestRoom = (() => {
       }
     };
   }
+  function createRainBehavior() {
+    return {
+      reset() {
+      },
+      act(host, action, args) {
+        const { engine, camera: camera2 } = host;
+        if (action === "init") {
+          const { count, wind } = args;
+          engine.rain.init(count, wind);
+        } else if (action === "update") {
+          const { dt, splash } = args;
+          engine.rain.update(dt, splash, camera2.position);
+        }
+      },
+      query(host, name) {
+        if (name === "count") return host.engine.rain.count;
+        if (name === "on") return host.engine.rain.on;
+        throw new Error(`rain: unknown query ${name}`);
+      },
+      update() {
+      }
+    };
+  }
   var WALKER_COUNT = 10;
   var ARRIVAL_DISTANCE = 0.05;
   var SWAY_AMPLITUDE = 0.04;
@@ -9189,7 +9646,8 @@ var GameTestRoom = (() => {
     blocks: () => createBlocksBehavior(),
     plate: () => createPlateBehavior(),
     cylinder: () => createCylinderBehavior(),
-    car: () => createCarBehavior()
+    car: () => createCarBehavior(),
+    rain: () => createRainBehavior()
   };
   var NOOP = () => {
   };
@@ -9260,6 +9718,8 @@ var GameTestRoom = (() => {
         return Math.abs(asNumber(first));
       case "sqrt":
         return Math.sqrt(asNumber(first));
+      case "exp":
+        return Math.exp(asNumber(first));
       case "sin":
         return Math.sin(asNumber(first));
       case "cos":
@@ -9378,7 +9838,7 @@ var GameTestRoom = (() => {
         return evaluateCall(value.$, args.map((entry) => resolve(entry, context)));
     }
   }
-  var UP11 = [0, 1, 0];
+  var UP12 = [0, 1, 0];
   var ZERO = [0, 0, 0];
   var FULL_TURN_DRAWN = 6.283;
   function scaledSizes(range2, factor) {
@@ -9391,7 +9851,7 @@ var GameTestRoom = (() => {
       p: centre,
       r: radius,
       flat: true,
-      dir: options.dir ?? UP11,
+      dir: options.dir ?? UP12,
       cone: 0.35,
       sp: [0.4, 1.4],
       v: wind,
@@ -9408,7 +9868,7 @@ var GameTestRoom = (() => {
       p: centre,
       r: radius * 0.6,
       flat: true,
-      dir: UP11,
+      dir: UP12,
       cone: 0.3,
       sp: [0.3, 0.8],
       life: [0.2, 0.4],
@@ -9423,14 +9883,14 @@ var GameTestRoom = (() => {
     if (engine.quality < 2) {
       engine.emit(`${key}e`, "streak", 10 * factor, dt, () => {
         const jitter = plus(wind, engine.random.between(-0.4, 0.4), 0, engine.random.between(-0.4, 0.4));
-        return { p: centre, box: [radius, 0, radius], dir: UP11, cone: 0.5, sp: [1.5, 3.5], v: jitter, life: [0.8, 1.8], len: 0.03, c0: 16756816, c1: 6295552, g: -0.6, drag: 0.4 };
+        return { p: centre, box: [radius, 0, radius], dir: UP12, cone: 0.5, sp: [1.5, 3.5], v: jitter, life: [0.8, 1.8], len: 0.03, c0: 16756816, c1: 6295552, g: -0.6, drag: 0.4 };
       });
     }
     if (options.noSmoke) return;
     engine.emit(`${key}s`, "normal", (options.smoke || 14) * factor, dt, () => ({
       p: plus(centre, 0, 0.8 * sqrtFactor, 0),
       r: radius * 0.7,
-      dir: UP11,
+      dir: UP12,
       cone: 0.35,
       sp: [0.6, 1.4],
       v: wind,
@@ -9470,15 +9930,15 @@ var GameTestRoom = (() => {
     engine.screen.shake += 0.7 * scale2;
     engine.screen.white += 0.18 * scale2;
     engine.burst("add", 55 * scale2, { p: point, r: 0.3 * scale2, sp: [2, 7 * scale2], drag: 4, life: [0.25, 0.6], size: [0.7 * scale2, 1.4 * scale2], grow: 1.7, c0: 16773296, c1: 10103304, fi: 0.04 });
-    engine.burst("add", 28 * scale2, { p: plus(point, 0, 0.3, 0), r: 0.3, dir: UP11, cone: 0.7, sp: [2, 5 * scale2], drag: 1.5, life: [0.6, 1.1], size: [0.6 * scale2, 1 * scale2], grow: 1.3, c0: 16760928, c1: 5902853, g: -2, fi: 0.05 });
+    engine.burst("add", 28 * scale2, { p: plus(point, 0, 0.3, 0), r: 0.3, dir: UP12, cone: 0.7, sp: [2, 5 * scale2], drag: 1.5, life: [0.6, 1.1], size: [0.6 * scale2, 1 * scale2], grow: 1.3, c0: 16760928, c1: 5902853, g: -2, fi: 0.05 });
     engine.ring([plus(point, 0, 0.05, 0), 0.3, 7 * scale2, 0.55, 16767136]);
     const toCamera = normalized([cameraPosition[0] - point[0], cameraPosition[1] - point[1], cameraPosition[2] - point[2]]);
     engine.ring([plus(point, 0, 1, 0), 0.3, 5 * scale2, 0.35, 16773328, toCamera]);
-    engine.burst("normal", 32 * scale2, { p: plus(point, 0, 0.6, 0), r: 0.8 * scale2, dir: UP11, cone: 1.1, sp: [1, 3], drag: 1.2, life: [3, 6], size: [1 * scale2, 1.8 * scale2], grow: 2.6, c0: 2828068, c1: 987155, a: 0.6, fi: 0.18, g: -0.35 });
+    engine.burst("normal", 32 * scale2, { p: plus(point, 0, 0.6, 0), r: 0.8 * scale2, dir: UP12, cone: 1.1, sp: [1, 3], drag: 1.2, life: [3, 6], size: [1 * scale2, 1.8 * scale2], grow: 2.6, c0: 2828068, c1: 987155, a: 0.6, fi: 0.18, g: -0.35 });
     ringOfDust(engine, point, scale2);
-    if (engine.quality < 2) engine.burst("streak", 44 * scale2, { p: point, dir: UP11, cone: 1.45, sp: [10, 26], life: [0.3, 0.7], len: 0.03, c0: 16760944, c1: 8396800, g: 9.8, gnd: 2 });
+    if (engine.quality < 2) engine.burst("streak", 44 * scale2, { p: point, dir: UP12, cone: 1.45, sp: [10, 26], life: [0.3, 0.7], len: 0.03, c0: 16760944, c1: 8396800, g: 9.8, gnd: 2 });
     for (let index = 0; index < engine.scaled(16 * scale2); index++) {
-      engine.debrisPiece({ p: point, dir: UP11, cone: 1.2, sp: [3, 9], size: [0.12, 0.06, 0.1], k: [0.6, 1.6], c: chipColor || 2762274, life: 9 });
+      engine.debrisPiece({ p: point, dir: UP12, cone: 1.2, sp: [3, 9], size: [0.12, 0.06, 0.1], k: [0.6, 1.6], c: chipColor || 2762274, life: 9 });
     }
     engine.decal([point[0], engine.context.groundAt(point[0], point[2]), point[2], 3 * scale2, 657930, { grow: 0.15, life: 60 }]);
   }
@@ -9621,6 +10081,7 @@ var GameTestRoom = (() => {
       if (!def) return;
       this.schedule.clear();
       this.variables.clear();
+      for (const [name, value] of Object.entries(this.setup.values ?? {})) this.variables.set(name, value);
       for (const behavior2 of this.deps.behaviors()) behavior2.reset(this.host);
       this.time = 0;
       this.within(() => {
@@ -9679,6 +10140,10 @@ var GameTestRoom = (() => {
           return engine.spawn(step.system, this.value(step.spawn));
         case "emit":
           return engine.emit(step.key, step.system, this.value(step.rate), this.dt, () => this.value(step.spawn));
+        case "mesh": {
+          engine.mesh(this.value(step.spawn));
+          return;
+        }
         case "debris":
           return engine.debrisPiece(this.value(step.spawn));
         case "decal":
@@ -9760,7 +10225,7 @@ var GameTestRoom = (() => {
       this.index = previous;
     }
   };
-  var ORIGIN4 = [0, 0, 0];
+  var ORIGIN5 = [0, 0, 0];
   var DEFAULT_HEADING = [0, 0, -1];
   var DEFAULT_MAX_INSTANCES = 48;
   var ENDLESS_SECONDS = 60;
@@ -9805,7 +10270,7 @@ var GameTestRoom = (() => {
     }
     function placementOf(entry) {
       const origin = entry.follow ? [entry.origin[0] + positionOf2(entry.follow)[0], entry.origin[1] + positionOf2(entry.follow)[1], entry.origin[2] + positionOf2(entry.follow)[2]] : entry.origin;
-      return { origin, anchor: entry.anchor, yaw: entry.yaw };
+      return { origin, anchor: entry.anchor, yaw: entry.yaw, ...entry.orientation ? { orientation: entry.orientation } : {} };
     }
     function drawing(entry, action) {
       const context = engine.context;
@@ -9829,8 +10294,9 @@ var GameTestRoom = (() => {
           random: playOptions.seed !== void 0 ? streamOf(playOptions.seed) : void 0,
           follow: playOptions.follow,
           origin: point,
-          anchor: def.anchor ?? ORIGIN4,
+          anchor: def.anchor ?? ORIGIN5,
           yaw: yawOf(heading, playOptions.direction),
+          orientation: playOptions.orientation,
           seconds: playOptions.seconds ?? (def.loop && def.loop > 0 ? def.loop : ENDLESS_SECONDS)
         };
         playing.push(entry);
@@ -9839,7 +10305,8 @@ var GameTestRoom = (() => {
           () => instance.begin(def, paramIndex(def, playOptions.param), {
             placement: placementOf(entry),
             ...playOptions.direction ? { direction: playOptions.direction } : {},
-            ...playOptions.normal ? { normal: playOptions.normal } : {}
+            ...playOptions.normal ? { normal: playOptions.normal } : {},
+            ...playOptions.values ? { values: playOptions.values } : {}
           })
         );
         return entry.handle;
@@ -10099,15 +10566,15 @@ var GameTestRoom = (() => {
     return shock;
   }
   function pushPuffs(puffs, shock, reach, dt, age) {
-    for (const puff2 of puffs) {
-      if (puff2.ring || puff2.t > PUSH_AGE_LIMIT) continue;
-      const dx = puff2.x - shock.x;
-      const dz = puff2.z - shock.z;
+    for (const puff3 of puffs) {
+      if (puff3.ring || puff3.t > PUSH_AGE_LIMIT) continue;
+      const dx = puff3.x - shock.x;
+      const dz = puff3.z - shock.z;
       const distance4 = Math.hypot(dx, dz) + 1e-3;
-      if (Math.abs(distance4 - reach) < PUSH_BAND && puff2.y < PUSH_CEILING) {
+      if (Math.abs(distance4 - reach) < PUSH_BAND && puff3.y < PUSH_CEILING) {
         const strength = 4 * dt * (1 - age);
-        puff2.vx += dx / distance4 * strength * 6;
-        puff2.vz += dz / distance4 * strength * 6;
+        puff3.vx += dx / distance4 * strength * 6;
+        puff3.vz += dz / distance4 * strength * 6;
       }
     }
   }
@@ -10407,10 +10874,10 @@ var GameTestRoom = (() => {
       const life = random.between(ring2.life * 0.75, ring2.life);
       const h0 = random.between(1, 1.25);
       const hl = random.between(0.9, 1.6);
-      const puff2 = addPuff(core, random, { x, y, z, s0: spec.radius * 0.2, s1, sg: spec.radius * 0.06, gk: 3, life, h0, hl, color, kind: 0 });
-      puff2.ring = ring2;
-      puff2.ph = random.next() * Math.PI * 2;
-      puff2.th = random.next() * Math.PI * 2;
+      const puff3 = addPuff(core, random, { x, y, z, s0: spec.radius * 0.2, s1, sg: spec.radius * 0.06, gk: 3, life, h0, hl, color, kind: 0 });
+      puff3.ring = ring2;
+      puff3.ph = random.next() * Math.PI * 2;
+      puff3.th = random.next() * Math.PI * 2;
     }
     const stemCount = Math.round((spec.stem || 18) * Math.max(lod, 0.4));
     for (let index = 0; index < stemCount; index++) {
@@ -11211,7 +11678,7 @@ var GameTestRoom = (() => {
   };
   var TWO_PI_ROUNDED = 6.2832;
   var WIDE_CONE = 3.1;
-  var UP12 = [0, 1, 0];
+  var UP13 = [0, 1, 0];
   function drawRange(random, range2) {
     if (Array.isArray(range2)) return random.between(range2[0], range2[1]);
     return range2 || 0;
@@ -11239,7 +11706,7 @@ var GameTestRoom = (() => {
   }
   function coneDirection(random, direction, cone, out) {
     if (cone >= WIDE_CONE) return randomUnit(random, out);
-    const [dx, dy, dz] = direction ?? UP12;
+    const [dx, dy, dz] = direction ?? UP13;
     const cosTilt = 1 - random.next() * (1 - Math.cos(cone));
     const sinTilt = Math.sqrt(1 - cosTilt * cosTilt);
     const phase = random.next() * TWO_PI_ROUNDED;
@@ -11359,12 +11826,12 @@ var GameTestRoom = (() => {
     }
   };
   var CAPACITY2 = 400;
-  var UP13 = [0, 1, 0];
+  var UP14 = [0, 1, 0];
   var DEFAULT_LIFE2 = 60;
   var DEFAULT_GROW = 1.2;
   var EVAPORATION = { fuel: [6, 5], water: [40, 20] };
   function createDecal() {
-    return { on: false, x: 0, y: 0, z: 0, sx: 0, sy: 0, t: 0, life: 0, grow: 0, color: 0, normal: UP13, fluid: void 0, dryColor: -1, dryAt: 0, dryTime: 0 };
+    return { on: false, x: 0, y: 0, z: 0, sx: 0, sy: 0, t: 0, life: 0, grow: 0, color: 0, normal: UP14, fluid: void 0, dryColor: -1, dryAt: 0, dryTime: 0 };
   }
   var DecalPool = class {
     constructor(context) {
@@ -11377,7 +11844,7 @@ var GameTestRoom = (() => {
       const random = this.context.random;
       const index = this.next++ % CAPACITY2;
       const decal2 = this.decals[index];
-      const normal = options.n ?? UP13;
+      const normal = options.n ?? UP14;
       random.between(0, 6.28);
       const offset = 4e-3 + index % 40 * 4e-4;
       decal2.on = true;
@@ -11418,6 +11885,94 @@ var GameTestRoom = (() => {
       }
     }
   };
+  var CAPACITY3 = 400;
+  var IDENTITY2 = [0, 0, 0, 1];
+  function multiply(a, b) {
+    const [ax, ay, az, aw] = a;
+    const [bx, by, bz, bw] = b;
+    return [aw * bx + ax * bw + ay * bz - az * by, aw * by - ax * bz + ay * bw + az * bx, aw * bz + ax * by - ay * bx + az * bw, aw * bw - ax * bx - ay * by - az * bz];
+  }
+  var aboutX = (angle) => [Math.sin(angle / 2), 0, 0, Math.cos(angle / 2)];
+  var MeshPool = class {
+    constructor(capacity = CAPACITY3) {
+      __publicField(this, "capacity", capacity);
+      __publicField(this, "particles", []);
+      __publicField(this, "serial", 0);
+    }
+    get count() {
+      return this.particles.length;
+    }
+    spawn(options, frame3 = IDENTITY2) {
+      const velocity = options.v ?? [0, 0, 0];
+      const world = options.wv ?? [0, 0, 0];
+      const particle = {
+        id: ++this.serial,
+        shape: options.shape,
+        radius: options.r,
+        height: options.h ?? 0,
+        segments: options.seg ?? 0,
+        segments2: options.seg2 ?? 0,
+        color: options.c0,
+        additive: options.add === true,
+        lit: options.lit === true,
+        x: options.p[0],
+        y: options.p[1],
+        z: options.p[2],
+        frame: options.roll ? multiply(frame3, aboutX(options.roll)) : frame3,
+        at: options.at ?? [0, 0, 0],
+        rx: options.rot?.[0] ?? 0,
+        ry: options.rot?.[1] ?? 0,
+        rz: options.rot?.[2] ?? 0,
+        scale: 1,
+        opacity: options.a,
+        age: 0,
+        life: options.life,
+        vx: velocity[0] + world[0],
+        vy: velocity[1] + world[1],
+        vz: velocity[2] + world[2],
+        spin: options.spin ?? [0, 0, 0],
+        gravity: options.g ?? 0,
+        drag: options.drag ?? 0,
+        grow: options.grow ?? 0,
+        ramp: options.ramp,
+        fade: options.fade === true,
+        startOpacity: options.a
+      };
+      this.particles.push(particle);
+      if (this.particles.length > this.capacity) this.particles.shift();
+      return particle;
+    }
+    update(dt) {
+      const live = this.particles;
+      for (let index = 0; index < live.length; index++) {
+        const particle = live[index];
+        particle.age += dt;
+        if (particle.ramp ? particle.age >= particle.life : particle.age > particle.life) {
+          live.splice(index--, 1);
+          continue;
+        }
+        if (particle.fade) particle.opacity = Math.max(0, particle.startOpacity * (1 - particle.age / particle.life));
+        particle.vy -= particle.gravity * dt;
+        if (particle.drag) {
+          const keep = Math.max(0, 1 - particle.drag * dt);
+          particle.vx *= keep;
+          particle.vy *= keep;
+          particle.vz *= keep;
+        }
+        particle.x += particle.vx * dt;
+        particle.y += particle.vy * dt;
+        particle.z += particle.vz * dt;
+        particle.rx += particle.spin[0] * dt;
+        particle.ry += particle.spin[1] * dt;
+        particle.rz += particle.spin[2] * dt;
+        if (particle.grow) particle.scale *= 1 + particle.grow * dt;
+        if (particle.ramp) particle.scale = particle.ramp[0] + Math.min(1, particle.age / particle.life) * particle.ramp[1];
+      }
+    }
+    clear() {
+      this.particles.length = 0;
+    }
+  };
   var DEFAULT_FADE_IN = 0.1;
   var FLOATS_PER_VECTOR = 3;
   var BYTE_MAX2 = 255;
@@ -11707,11 +12262,11 @@ var GameTestRoom = (() => {
   };
   var RING_CAPACITY = 120;
   var LIGHT_CAPACITY = 4;
-  var UP14 = [0, 1, 0];
+  var UP15 = [0, 1, 0];
   var DEFAULT_LIGHT_DISTANCE = 14;
   var WaveRingPool = class {
     constructor() {
-      __publicField(this, "rings", Array.from({ length: RING_CAPACITY }, () => ({ on: false, point: UP14, from: 0, to: 0, t: 0, duration: 1, color: 0, normal: UP14, hold: 0 })));
+      __publicField(this, "rings", Array.from({ length: RING_CAPACITY }, () => ({ on: false, point: UP15, from: 0, to: 0, t: 0, duration: 1, color: 0, normal: UP15, hold: 0 })));
       __publicField(this, "count", 0);
       __publicField(this, "next", 0);
     }
@@ -11724,7 +12279,7 @@ var GameTestRoom = (() => {
       ring2.t = 0;
       ring2.duration = duration;
       ring2.color = color;
-      ring2.normal = normal ?? UP14;
+      ring2.normal = normal ?? UP15;
       ring2.hold = hold || 0;
     }
     clear() {
@@ -11744,7 +12299,7 @@ var GameTestRoom = (() => {
   var FlashLightPool = class {
     constructor(context) {
       __publicField(this, "context", context);
-      __publicField(this, "lights", Array.from({ length: LIGHT_CAPACITY }, () => ({ x: 0, y: 0, z: 0, color: 16760944, distance: DEFAULT_LIGHT_DISTANCE, peak: 0, duration: 1, t: 0, intensity: 0 })));
+      __publicField(this, "lights", Array.from({ length: LIGHT_CAPACITY }, () => ({ x: 0, y: 0, z: 0, color: 16760944, distance: DEFAULT_LIGHT_DISTANCE, peak: 0, duration: 1, t: 0, intensity: 0, steady: false })));
       __publicField(this, "fire", [
         { x: 0, y: 0, z: 0, intensity: 0 },
         { x: 0, y: 0, z: 0, intensity: 0 }
@@ -11754,7 +12309,7 @@ var GameTestRoom = (() => {
     get lit() {
       return this.lights.filter((light) => light.intensity > 0).length;
     }
-    flash(point, color, intensity, duration, distance4, force) {
+    flash(point, color, intensity, duration, distance4, force, steady) {
       const { level } = this.context.quality;
       if (level >= 1 && !force) return;
       if (level >= 2 && force !== "boom") return;
@@ -11767,6 +12322,7 @@ var GameTestRoom = (() => {
       light.peak = intensity;
       light.duration = duration;
       light.t = 0;
+      light.steady = steady === true;
       light.intensity = intensity;
     }
     clear() {
@@ -11778,7 +12334,7 @@ var GameTestRoom = (() => {
         if (light.intensity <= 0) continue;
         light.t += dt;
         const age = light.t / light.duration;
-        light.intensity = age >= 1 ? 0 : light.peak * (1 - age) * (1 - age);
+        light.intensity = age >= 1 ? 0 : light.steady ? light.peak : light.peak * (1 - age) * (1 - age);
       }
     }
   };
@@ -11786,6 +12342,14 @@ var GameTestRoom = (() => {
   var FIRE_FLICKER_SWAY = 0.25;
   var FIRE_FLICKER_JITTER = 0.08;
   var LENS_FADE = 0.16;
+  function rotate(q, v) {
+    const [qx, qy, qz, qw] = q;
+    const ix = qw * v[0] + qy * v[2] - qz * v[1];
+    const iy = qw * v[1] + qz * v[0] - qx * v[2];
+    const iz = qw * v[2] + qx * v[1] - qy * v[0];
+    const iw = -qx * v[0] - qy * v[1] - qz * v[2];
+    return [ix * qw + iw * -qx + iy * -qz - iz * -qy, iy * qw + iw * -qy + iz * -qx - ix * -qz, iz * qw + iw * -qz + ix * -qy - iy * -qx];
+  }
   function workshopGround(x, z) {
     return z < -2.9 && z > -4.5 && Math.abs(x) < 13 ? 0.12 : 0;
   }
@@ -11799,6 +12363,8 @@ var GameTestRoom = (() => {
       __publicField(this, "decals");
       __publicField(this, "rings", new WaveRingPool());
       __publicField(this, "lights");
+      __publicField(this, "rain", new RainField(this));
+      __publicField(this, "meshes", new MeshPool());
       __publicField(this, "screen", createScreenState());
       __publicField(this, "lens", []);
       __publicField(this, "post", {});
@@ -11831,7 +12397,11 @@ var GameTestRoom = (() => {
     place(point) {
       const placement = this.placement;
       if (!placement) return point;
-      const { anchor, origin, yaw } = placement;
+      const { anchor, origin, yaw, orientation } = placement;
+      if (orientation) {
+        const turned = rotate(orientation, [point[0] - anchor[0], point[1] - anchor[1], point[2] - anchor[2]]);
+        return [origin[0] + turned[0], origin[1] + turned[1], origin[2] + turned[2]];
+      }
       const x = point[0] - anchor[0];
       const z = point[2] - anchor[2];
       const cos2 = Math.cos(yaw);
@@ -11842,6 +12412,7 @@ var GameTestRoom = (() => {
     turn(vector) {
       const placement = this.placement;
       if (!placement) return vector;
+      if (placement.orientation) return rotate(placement.orientation, vector);
       const cos2 = Math.cos(placement.yaw);
       const sin2 = Math.sin(placement.yaw);
       return [cos2 * vector[0] + sin2 * vector[2], vector[1], -sin2 * vector[0] + cos2 * vector[2]];
@@ -11870,6 +12441,14 @@ var GameTestRoom = (() => {
       }
       this.accumulators.set(key, carried);
     }
+    /** A solid particle (a cone, a sphere): the group sits at `p` turned by the placement, `v` is turned with it and `wv` is not. */
+    mesh(recipe) {
+      const placement = this.placement;
+      const options = placement ? { ...recipe, p: this.place(recipe.p), ...recipe.v ? { v: this.turn(recipe.v) } : {} } : recipe;
+      this.context.trace?.("mesh", [options]);
+      const grouped = recipe.at !== void 0 || recipe.roll !== void 0;
+      return this.meshes.spawn(options, placement && grouped ? placement.orientation ?? [0, Math.sin(placement.yaw / 2), 0, Math.cos(placement.yaw / 2)] : void 0);
+    }
     debrisPiece(recipe) {
       const options = this.placed(recipe);
       this.context.trace?.("debris", [options]);
@@ -11890,10 +12469,11 @@ var GameTestRoom = (() => {
       this.context.trace?.("ring", args);
       this.rings.add(args[0], args[1], args[2], args[3], args[4], args[5], args[6]);
     }
+    /** `steady` (a seventh number): the light holds its intensity for its duration and goes out, where the Workshop's fades with the square of its age. */
     flash(recipe) {
-      const args = this.placement ? [this.place(recipe[0]), recipe[1], recipe[2], recipe[3], recipe[4], recipe[5]] : recipe;
-      this.context.trace?.("flash", args);
-      this.lights.flash(args[0], args[1], args[2], args[3], args[4], args[5]);
+      const args = this.placement ? [this.place(recipe[0]), recipe[1], recipe[2], recipe[3], recipe[4], recipe[5], recipe[6]] : recipe;
+      this.context.trace?.("flash", args.slice(0, 6));
+      this.lights.flash(args[0], args[1], args[2], args[3], args[4], args[5], args[6]);
     }
     /** `fireLight` (W400): sways with the clock and flickers with one draw. */
     fireLight(slot, recipe, intensity, time) {
@@ -11918,6 +12498,7 @@ var GameTestRoom = (() => {
       this.debris.update(dt);
       this.decals.update(dt);
       this.rings.update(dt);
+      this.meshes.update(dt);
       this.lights.update(dt);
       updateScreen(this.screen, dt);
       for (let index = this.lens.length - 1; index >= 0; index--) {
@@ -11934,7 +12515,9 @@ var GameTestRoom = (() => {
       this.debris.clear();
       this.decals.clear();
       this.rings.clear();
+      this.meshes.clear();
       this.lights.clear();
+      this.rain.clear();
       this.accumulators.clear();
       resetScreenState(this.screen);
       this.lens.length = 0;
@@ -12080,16 +12663,16 @@ var GameTestRoom = (() => {
       },
       push(point, radius, speed) {
         spriteSystem.push(point, radius, speed);
-        for (const puff2 of core.puffs.items) {
-          const dx = puff2.x - point[0];
-          const dy = puff2.y - point[1];
-          const dz = puff2.z - point[2];
+        for (const puff3 of core.puffs.items) {
+          const dx = puff3.x - point[0];
+          const dy = puff3.y - point[1];
+          const dz = puff3.z - point[2];
           const distance4 = Math.sqrt(dx * dx + dy * dy + dz * dz);
           if (distance4 >= radius) continue;
           const strength = speed * (1 - distance4 / radius) / (distance4 + 1e-3);
-          puff2.vx += dx * strength;
-          puff2.vy += dy * strength;
-          puff2.vz += dz * strength;
+          puff3.vx += dx * strength;
+          puff3.vy += dy * strength;
+          puff3.vz += dz * strength;
         }
       },
       stop(handle) {
@@ -12106,6 +12689,12 @@ var GameTestRoom = (() => {
         camera2.y = position[1];
         camera2.z = position[2];
       },
+      setWind(next) {
+        wind.x = next[0];
+        wind.y = next[1];
+        wind.z = next[2];
+      },
+      wind: () => [wind.x, wind.y, wind.z],
       forceLod(scale2) {
         core.clock.forcedLod = scale2;
       },
@@ -12374,11 +12963,11 @@ void main(){
     geometry.setAttribute("aC", attributes[2]);
     geometry.instanceCount = 0;
     const material = new THREE.ShaderMaterial({ uniforms, vertexShader: PUFF_VERTEX, fragmentShader: PUFF_FRAGMENT });
-    const mesh = new THREE.Mesh(geometry, material);
-    mesh.name = "vfx-puffs";
-    mesh.frustumCulled = false;
+    const mesh2 = new THREE.Mesh(geometry, material);
+    mesh2.name = "vfx-puffs";
+    mesh2.frustumCulled = false;
     return {
-      mesh,
+      mesh: mesh2,
       sync() {
         let n = 0;
         for (const p of pool.items) {
@@ -12419,12 +13008,12 @@ void main(){
     geometry.setAttribute("aE", attributes[2]);
     geometry.instanceCount = 0;
     const material = new THREE.ShaderMaterial({ transparent: true, depthWrite: false, blending: THREE.AdditiveBlending, vertexShader: SPARK_VERTEX, fragmentShader: SPARK_FRAGMENT });
-    const mesh = new THREE.Mesh(geometry, material);
-    mesh.name = "vfx-sparks";
-    mesh.frustumCulled = false;
-    mesh.renderOrder = 5;
+    const mesh2 = new THREE.Mesh(geometry, material);
+    mesh2.name = "vfx-sparks";
+    mesh2.frustumCulled = false;
+    mesh2.renderOrder = 5;
     return {
-      mesh,
+      mesh: mesh2,
       sync() {
         let n = 0;
         for (const s of pool.items) {
@@ -12462,12 +13051,12 @@ void main(){
     geometry.setAttribute("aC", attributes[1]);
     geometry.instanceCount = 0;
     const material = new THREE.ShaderMaterial({ transparent: true, depthWrite: false, blending: THREE.AdditiveBlending, vertexShader: GLOW_VERTEX, fragmentShader: GLOW_FRAGMENT });
-    const mesh = new THREE.Mesh(geometry, material);
-    mesh.name = "vfx-glows";
-    mesh.frustumCulled = false;
-    mesh.renderOrder = 6;
+    const mesh2 = new THREE.Mesh(geometry, material);
+    mesh2.name = "vfx-glows";
+    mesh2.frustumCulled = false;
+    mesh2.renderOrder = 6;
     return {
-      mesh,
+      mesh: mesh2,
       sync() {
         let n = 0;
         for (const g of pool.items) {
@@ -12496,14 +13085,14 @@ void main(){
     const rockMaterial = new THREE.MeshStandardMaterial({ color: 16777215, roughness: 0.85, flatShading: true });
     const plateMaterial = rockMaterial.clone();
     const make = (geometry, material) => {
-      const mesh = new THREE.InstancedMesh(geometry, material, capacity);
-      mesh.instanceMatrix.setUsage(THREE.DynamicDrawUsage);
-      mesh.castShadow = true;
-      mesh.receiveShadow = true;
-      mesh.frustumCulled = false;
-      mesh.count = 0;
-      mesh.setColorAt(0, new THREE.Color(1, 1, 1));
-      return mesh;
+      const mesh2 = new THREE.InstancedMesh(geometry, material, capacity);
+      mesh2.instanceMatrix.setUsage(THREE.DynamicDrawUsage);
+      mesh2.castShadow = true;
+      mesh2.receiveShadow = true;
+      mesh2.frustumCulled = false;
+      mesh2.count = 0;
+      mesh2.setColorAt(0, new THREE.Color(1, 1, 1));
+      return mesh2;
     };
     const rocks = make(shapes.rock, rockMaterial);
     const plates = make(shapes.plate, plateMaterial);
@@ -12522,20 +13111,20 @@ void main(){
           euler.set(chunk.rx, chunk.ry, chunk.rz);
           quaternion.setFromEuler(euler);
           matrix.compose(position.set(chunk.x, chunk.y, chunk.z), quaternion, scale2.set(chunk.sx, chunk.sy, chunk.sz));
-          const mesh = chunk.plate ? plates : rocks;
+          const mesh2 = chunk.plate ? plates : rocks;
           const index = chunk.plate ? plateCount++ : rockCount++;
-          mesh.setMatrixAt(index, matrix);
+          mesh2.setMatrixAt(index, matrix);
           const color = colorOf2(chunk);
-          const colors = mesh.instanceColor.array;
+          const colors = mesh2.instanceColor.array;
           colors[index * 3] = color[0];
           colors[index * 3 + 1] = color[1];
           colors[index * 3 + 2] = color[2];
         }
         rocks.count = rockCount;
         plates.count = plateCount;
-        for (const mesh of [rocks, plates]) {
-          mesh.instanceMatrix.needsUpdate = true;
-          mesh.instanceColor.needsUpdate = true;
+        for (const mesh2 of [rocks, plates]) {
+          mesh2.instanceMatrix.needsUpdate = true;
+          mesh2.instanceColor.needsUpdate = true;
         }
         return rockCount + plateCount;
       },
@@ -12719,28 +13308,28 @@ void main(){
         position.setXYZ(index, worldX, (options.ground?.heightAt(worldX, worldZ) ?? 0) + mark.lift, worldZ);
       }
       geometry.computeVertexNormals();
-      const mesh = new THREE.Mesh(geometry, material);
-      mesh.receiveShadow = true;
-      return mesh;
+      const mesh2 = new THREE.Mesh(geometry, material);
+      mesh2.receiveShadow = true;
+      return mesh2;
     }
     function addRock(mark) {
-      const mesh = new THREE.Mesh(mark.plate ? options.plateGeometry : options.rockGeometry, rockMaterial(mark.color));
-      mesh.position.set(mark.x, mark.y, mark.z);
-      mesh.scale.set(mark.scale[0], mark.scale[1], mark.scale[2]);
-      mesh.rotation.set(mark.rotation[0], mark.rotation[1], mark.rotation[2]);
-      mesh.castShadow = true;
-      mesh.receiveShadow = true;
-      return mesh;
+      const mesh2 = new THREE.Mesh(mark.plate ? options.plateGeometry : options.rockGeometry, rockMaterial(mark.color));
+      mesh2.position.set(mark.x, mark.y, mark.z);
+      mesh2.scale.set(mark.scale[0], mark.scale[1], mark.scale[2]);
+      mesh2.rotation.set(mark.rotation[0], mark.rotation[1], mark.rotation[2]);
+      mesh2.castShadow = true;
+      mesh2.receiveShadow = true;
+      return mesh2;
     }
     function addBlood(mark) {
-      const mesh = new THREE.Mesh(bloodGeometry, bloodMaterial);
-      mesh.position.set(mark.x, mark.y, mark.z);
-      mesh.scale.set(mark.scaleX, 1, mark.scaleZ);
-      mesh.rotation.y = mark.rotation;
-      mesh.receiveShadow = true;
-      mesh.scale.multiplyScalar(0.05);
-      blood.push({ mesh, scaleX: mark.scaleX, scaleZ: mark.scaleZ, age: 0 });
-      return mesh;
+      const mesh2 = new THREE.Mesh(bloodGeometry, bloodMaterial);
+      mesh2.position.set(mark.x, mark.y, mark.z);
+      mesh2.scale.set(mark.scaleX, 1, mark.scaleZ);
+      mesh2.rotation.y = mark.rotation;
+      mesh2.receiveShadow = true;
+      mesh2.scale.multiplyScalar(0.05);
+      blood.push({ mesh: mesh2, scaleX: mark.scaleX, scaleZ: mark.scaleZ, age: 0 });
+      return mesh2;
     }
     function build(mark) {
       if (mark.kind === "scorch") return conform(mark, scorchMaterials[mark.variant]);
@@ -12951,6 +13540,73 @@ void main() {
       }
     };
   }
+  var SPHERE_DEFAULT_WIDTH = 8;
+  var SPHERE_DEFAULT_HEIGHT = 6;
+  function geometryOf(THREE, particle) {
+    switch (particle.shape) {
+      case "cone":
+        return new THREE.ConeGeometry(particle.radius, particle.height, particle.segments || void 0, particle.segments2 || 1, false);
+      case "cone_open":
+        return new THREE.ConeGeometry(particle.radius, particle.height, particle.segments || void 0, particle.segments2 || 1, true);
+      case "sphere":
+        return new THREE.SphereGeometry(particle.radius, particle.segments || SPHERE_DEFAULT_WIDTH, particle.segments2 || SPHERE_DEFAULT_HEIGHT);
+      case "icosahedron":
+        return new THREE.IcosahedronGeometry(particle.radius, particle.segments);
+    }
+  }
+  function materialOf(THREE, particle) {
+    if (particle.lit) return new THREE.MeshStandardMaterial({ color: particle.color, roughness: 1, metalness: 0, transparent: true, opacity: particle.opacity, depthWrite: false });
+    return new THREE.MeshBasicMaterial({ color: particle.color, transparent: true, opacity: particle.opacity, depthWrite: false, ...particle.additive ? { blending: THREE.AdditiveBlending } : {} });
+  }
+  function createMeshLayer(THREE, pool) {
+    const group = new THREE.Group();
+    group.name = "workshop-meshes";
+    const drawn = /* @__PURE__ */ new Map();
+    const frame3 = new THREE.Quaternion();
+    const euler = new THREE.Euler();
+    const turn = new THREE.Quaternion();
+    const offset = new THREE.Vector3();
+    function release(mesh2) {
+      mesh2.removeFromParent();
+      mesh2.geometry.dispose();
+      mesh2.material.dispose();
+    }
+    return {
+      group,
+      sync() {
+        const live = /* @__PURE__ */ new Set();
+        for (const particle of pool.particles) {
+          live.add(particle.id);
+          let mesh2 = drawn.get(particle.id);
+          if (!mesh2) {
+            mesh2 = new THREE.Mesh(geometryOf(THREE, particle), materialOf(THREE, particle));
+            mesh2.frustumCulled = false;
+            mesh2.renderOrder = particle.additive ? 5 : 3;
+            drawn.set(particle.id, mesh2);
+            group.add(mesh2);
+          }
+          frame3.set(particle.frame[0], particle.frame[1], particle.frame[2], particle.frame[3]);
+          offset.set(particle.at[0], particle.at[1], particle.at[2]).multiplyScalar(particle.scale).applyQuaternion(frame3);
+          mesh2.position.set(particle.x + offset.x, particle.y + offset.y, particle.z + offset.z);
+          turn.setFromEuler(euler.set(particle.rx, particle.ry, particle.rz));
+          mesh2.quaternion.copy(frame3).multiply(turn);
+          mesh2.scale.setScalar(particle.scale);
+          mesh2.material.opacity = particle.opacity;
+        }
+        for (const [id, mesh2] of drawn) {
+          if (live.has(id)) continue;
+          release(mesh2);
+          drawn.delete(id);
+        }
+        return pool.count;
+      },
+      dispose() {
+        for (const mesh2 of drawn.values()) release(mesh2);
+        drawn.clear();
+        group.removeFromParent();
+      }
+    };
+  }
   var WORKSHOP_SPRITE_VERTEX = `attribute float size;attribute float alpha;attribute vec3 pcol;varying vec3 vC;varying float vA;uniform float uScale;
 void main(){vC=pcol;vA=alpha;vec4 mv=modelViewMatrix*vec4(position,1.);gl_PointSize=clamp(size*uScale/-mv.z,1.,512.);gl_Position=projectionMatrix*mv;}`;
   var WORKSHOP_SPRITE_FRAGMENT = `uniform float uSoft;varying vec3 vC;varying float vA;
@@ -13026,13 +13682,37 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       }
     };
   }
+  function rainLayer(THREE, rain) {
+    const geometry = new THREE.BufferGeometry();
+    const position = new THREE.BufferAttribute(rain.positions, 3).setUsage(THREE.DynamicDrawUsage);
+    geometry.setAttribute("position", position);
+    geometry.setDrawRange(0, 0);
+    const material = new THREE.LineBasicMaterial({ color: 10466255, transparent: true, opacity: 0.35, depthWrite: false });
+    const lines = new THREE.LineSegments(geometry, material);
+    lines.frustumCulled = false;
+    lines.name = "workshop-rain";
+    return {
+      object: lines,
+      sync() {
+        const drawn = rain.on && rain.count > 0;
+        lines.visible = drawn;
+        geometry.setDrawRange(0, drawn ? rain.count * 2 : 0);
+        position.needsUpdate = true;
+        return drawn;
+      },
+      dispose() {
+        geometry.dispose();
+        material.dispose();
+      }
+    };
+  }
   function debrisLayer(THREE, pool) {
     const geometry = new THREE.BoxGeometry(1, 1, 1);
     const material = new THREE.MeshStandardMaterial({ color: 16777215, roughness: 0.45, metalness: 0.25, flatShading: true });
-    const mesh = new THREE.InstancedMesh(geometry, material, DEBRIS_CAPACITY);
-    mesh.instanceMatrix.setUsage(THREE.DynamicDrawUsage);
-    mesh.frustumCulled = false;
-    mesh.name = "workshop-debris";
+    const mesh2 = new THREE.InstancedMesh(geometry, material, DEBRIS_CAPACITY);
+    mesh2.instanceMatrix.setUsage(THREE.DynamicDrawUsage);
+    mesh2.frustumCulled = false;
+    mesh2.name = "workshop-debris";
     const euler = new THREE.Euler();
     const quaternion = new THREE.Quaternion();
     const position = new THREE.Vector3();
@@ -13040,16 +13720,16 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
     const matrix = new THREE.Matrix4();
     const colour = new THREE.Color();
     const hidden = new THREE.Matrix4().makeScale(0, 0, 0);
-    for (let index = 0; index < DEBRIS_CAPACITY; index++) mesh.setMatrixAt(index, hidden);
-    mesh.setColorAt(0, colour.setHex(16777215));
+    for (let index = 0; index < DEBRIS_CAPACITY; index++) mesh2.setMatrixAt(index, hidden);
+    mesh2.setColorAt(0, colour.setHex(16777215));
     return {
-      object: mesh,
+      object: mesh2,
       sync() {
         let drawn = false;
         for (let index = 0; index < DEBRIS_CAPACITY; index++) {
           const piece = pool.pieces[index];
           if (!piece.on) {
-            mesh.setMatrixAt(index, hidden);
+            mesh2.setMatrixAt(index, hidden);
             continue;
           }
           drawn = true;
@@ -13057,11 +13737,11 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
           euler.set(piece.rx, piece.ry, piece.rz);
           quaternion.setFromEuler(euler);
           matrix.compose(position.set(piece.x, piece.y, piece.z), quaternion, scale2.set(piece.sx * shrink, piece.sy * shrink, piece.sz * shrink));
-          mesh.setMatrixAt(index, matrix);
-          mesh.setColorAt(index, colour.setHex(piece.color));
+          mesh2.setMatrixAt(index, matrix);
+          mesh2.setColorAt(index, colour.setHex(piece.color));
         }
-        mesh.instanceMatrix.needsUpdate = true;
-        if (mesh.instanceColor) mesh.instanceColor.needsUpdate = true;
+        mesh2.instanceMatrix.needsUpdate = true;
+        if (mesh2.instanceColor) mesh2.instanceColor.needsUpdate = true;
         return drawn;
       },
       dispose() {
@@ -13118,11 +13798,11 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
     const dryMesh = new THREE.InstancedMesh(geometry, dry, DECAL_CAPACITY);
     const group = new THREE.Group();
     group.name = "workshop-decals";
-    for (const mesh of [wetMesh, dryMesh]) {
-      mesh.frustumCulled = false;
-      mesh.renderOrder = 1;
-      mesh.instanceMatrix.setUsage(THREE.DynamicDrawUsage);
-      group.add(mesh);
+    for (const mesh2 of [wetMesh, dryMesh]) {
+      mesh2.frustumCulled = false;
+      mesh2.renderOrder = 1;
+      mesh2.instanceMatrix.setUsage(THREE.DynamicDrawUsage);
+      group.add(mesh2);
     }
     const hidden = new THREE.Matrix4().makeScale(0, 0, 0);
     const colour = new THREE.Color();
@@ -13159,13 +13839,13 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
           quaternion.multiply(turn.setFromAxisAngle(forward, index * 2.399963));
           const offset = 4e-3 + index % 40 * 4e-4;
           matrix.compose(position.set(decal2.x + normal.x * offset, decal2.y + normal.y * offset, decal2.z + normal.z * offset), quaternion, scale2.set(look.sx, look.sy, 1));
-          const mesh = look.dried ? dryMesh : wetMesh;
-          mesh.setMatrixAt(index, matrix);
-          mesh.setColorAt(index, colour);
+          const mesh2 = look.dried ? dryMesh : wetMesh;
+          mesh2.setMatrixAt(index, matrix);
+          mesh2.setColorAt(index, colour);
         }
-        for (const mesh of [wetMesh, dryMesh]) {
-          mesh.instanceMatrix.needsUpdate = true;
-          if (mesh.instanceColor) mesh.instanceColor.needsUpdate = true;
+        for (const mesh2 of [wetMesh, dryMesh]) {
+          mesh2.instanceMatrix.needsUpdate = true;
+          if (mesh2.instanceColor) mesh2.instanceColor.needsUpdate = true;
         }
         return drawn;
       },
@@ -13179,10 +13859,10 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
   function ringLayer(THREE, pool) {
     const geometry = new THREE.RingGeometry(0.86, 1, 40);
     const material = new THREE.MeshBasicMaterial({ color: 16777215, transparent: true, blending: THREE.AdditiveBlending, depthWrite: false, side: THREE.DoubleSide });
-    const mesh = new THREE.InstancedMesh(geometry, material, RING_CAPACITY3);
-    mesh.frustumCulled = false;
-    mesh.instanceMatrix.setUsage(THREE.DynamicDrawUsage);
-    mesh.name = "workshop-rings";
+    const mesh2 = new THREE.InstancedMesh(geometry, material, RING_CAPACITY3);
+    mesh2.frustumCulled = false;
+    mesh2.instanceMatrix.setUsage(THREE.DynamicDrawUsage);
+    mesh2.name = "workshop-rings";
     const hidden = new THREE.Matrix4().makeScale(0, 0, 0);
     const colour = new THREE.Color();
     const normal = new THREE.Vector3();
@@ -13191,16 +13871,16 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
     const position = new THREE.Vector3();
     const scale2 = new THREE.Vector3();
     const matrix = new THREE.Matrix4();
-    mesh.setColorAt(0, colour.setHex(0));
-    for (let index = 0; index < RING_CAPACITY3; index++) mesh.setMatrixAt(index, hidden);
+    mesh2.setColorAt(0, colour.setHex(0));
+    for (let index = 0; index < RING_CAPACITY3; index++) mesh2.setMatrixAt(index, hidden);
     return {
-      object: mesh,
+      object: mesh2,
       sync() {
         let drawn = false;
         for (let index = 0; index < RING_CAPACITY3; index++) {
           const ring2 = pool.rings[index];
           if (!ring2.on) {
-            mesh.setMatrixAt(index, hidden);
+            mesh2.setMatrixAt(index, hidden);
             continue;
           }
           drawn = true;
@@ -13208,11 +13888,11 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
           const radius = ring2.from + (ring2.to - ring2.from) * (1 - Math.pow(1 - k, 2));
           quaternion.setFromUnitVectors(forward, normal.set(ring2.normal[0], ring2.normal[1], ring2.normal[2]));
           matrix.compose(position.set(ring2.point[0], ring2.point[1], ring2.point[2]), quaternion, scale2.set(radius, radius, 1));
-          mesh.setMatrixAt(index, matrix);
-          mesh.setColorAt(index, colour.setHex(ring2.color).multiplyScalar(ring2.hold ? ring2.hold : 1 - k));
+          mesh2.setMatrixAt(index, matrix);
+          mesh2.setColorAt(index, colour.setHex(ring2.color).multiplyScalar(ring2.hold ? ring2.hold : 1 - k));
         }
-        mesh.instanceMatrix.needsUpdate = true;
-        if (mesh.instanceColor) mesh.instanceColor.needsUpdate = true;
+        mesh2.instanceMatrix.needsUpdate = true;
+        if (mesh2.instanceColor) mesh2.instanceColor.needsUpdate = true;
         return drawn;
       },
       dispose() {
@@ -13228,11 +13908,14 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       spriteLayer(THREE, engine.add, true, 1, pointScale),
       spriteLayer(THREE, engine.normal, false, 0.55, pointScale),
       streakLayer(THREE, engine.streaks),
+      rainLayer(THREE, engine.rain),
       debrisLayer(THREE, engine.debris),
       decalLayer(THREE, engine.decals),
       ringLayer(THREE, engine.rings)
     ];
     for (const layer2 of layers) group.add(layer2.object);
+    const meshes = createMeshLayer(THREE, engine.meshes);
+    group.add(meshes.group);
     const flashLights = engine.lights.lights.map(() => new THREE.PointLight(16760944, 0, 14));
     const fireLights = engine.lights.fire.map(() => new THREE.PointLight(FIRE_LIGHT_COLOR, 0, FIRE_LIGHT_DISTANCE));
     for (const light of [...flashLights, ...fireLights]) group.add(light);
@@ -13241,6 +13924,7 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       sync() {
         let drawCalls = 0;
         for (const layer2 of layers) if (layer2.sync()) drawCalls++;
+        drawCalls += meshes.sync();
         engine.lights.lights.forEach((source, index) => {
           const light = flashLights[index];
           light.position.set(source.x, source.y, source.z);
@@ -13257,6 +13941,7 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       },
       dispose() {
         for (const layer2 of layers) layer2.dispose();
+        meshes.dispose();
         group.clear();
       }
     };
@@ -13372,8 +14057,10 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
         return world.play(request.effect, request.point, {
           ...request.direction ? { direction: request.direction } : {},
           ...request.normal ? { normal: request.normal } : {},
+          ...request.orientation ? { orientation: request.orientation } : {},
           ...request.seed !== void 0 ? { seed: request.seed } : {},
-          ...request.param !== void 0 ? { param: request.param } : {}
+          ...request.param !== void 0 ? { param: request.param } : {},
+          ...request.values ? { values: request.values } : {}
         });
       },
       stop: (handle) => world.stop(handle),
@@ -13438,8 +14125,8 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
     const uv = geometry.attributes.uv;
     for (let index = 0; index < position.count; index++) uv.setXY(index, position.getX(index) / metres, position.getZ(index) / metres);
     const material = options.material ?? new THREE.MeshStandardMaterial({ color: 2829359, roughness: 0.93, flatShading: true });
-    const mesh = new THREE.Mesh(geometry, material);
-    mesh.receiveShadow = true;
+    const mesh2 = new THREE.Mesh(geometry, material);
+    mesh2.receiveShadow = true;
     let version = -1;
     function sync() {
       if (field.version === version) return false;
@@ -13450,7 +14137,7 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       return true;
     }
     return {
-      mesh,
+      mesh: mesh2,
       sync,
       dispose() {
         geometry.dispose();
@@ -13564,11 +14251,11 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
      * Bullet holes that stay on a fragment (`Fragment.marks`): dark discs that are children of its mesh, so they fall, spin and settle with it. The mesh is
      * a unit box scaled to the fragment, so each disc is scaled back; exact for a mark on a face, which is where a bullet hole is.
      */
-    addMarks(mesh, f) {
+    addMarks(mesh2, f) {
       if (!f.marks?.length) return;
       this.markGeometry ?? (this.markGeometry = new this.THREE.CircleGeometry(1, 10));
       this.markMaterial ?? (this.markMaterial = new this.THREE.MeshBasicMaterial({ color: 723465, depthWrite: false, polygonOffset: true, polygonOffsetFactor: -4, polygonOffsetUnits: -4 }));
-      const sc = mesh.scale;
+      const sc = mesh2.scale;
       for (const mark of f.marks) {
         const disc = new this.THREE.Mesh(this.markGeometry, this.markMaterial);
         const radius = Math.max(4e-3, mark.diameter) * 0.6;
@@ -13576,22 +14263,22 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
         disc.position.set(mark.point[0] / sc.x + n.x * 2e-3 / sc.x, mark.point[1] / sc.y + n.y * 2e-3 / sc.y, mark.point[2] / sc.z + n.z * 2e-3 / sc.z);
         disc.quaternion.setFromUnitVectors(this.w.set(0, 0, 1), n);
         disc.scale.set(radius / sc.x, radius / sc.y, radius / sc.z);
-        mesh.add(disc);
+        mesh2.add(disc);
       }
     }
     /** Create the mesh of a fragment and start its motion. `maxAllowed` is the live budget. */
     spawn(f, material, home, maxAllowed) {
       const geo = f.shape === "shard" ? this.shardGeometry(hashString(f.id)) : this.box;
-      const mesh = new this.THREE.Mesh(geo, material);
-      mesh.position.set(f.center[0], f.center[1], f.center[2]);
-      mesh.quaternion.set(f.rotation[0], f.rotation[1], f.rotation[2], f.rotation[3]).normalize();
+      const mesh2 = new this.THREE.Mesh(geo, material);
+      mesh2.position.set(f.center[0], f.center[1], f.center[2]);
+      mesh2.quaternion.set(f.rotation[0], f.rotation[1], f.rotation[2], f.rotation[3]).normalize();
       const sz = f.size;
       const sc = new this.THREE.Vector3(Math.max(5e-3, sz[0]), Math.max(5e-3, sz[1]), Math.max(3e-3, sz[2]));
-      mesh.scale.copy(sc);
-      mesh.castShadow = true;
-      this.o.scene.add(mesh);
+      mesh2.scale.copy(sc);
+      mesh2.castShadow = true;
+      this.o.scene.add(mesh2);
       const live = {
-        mesh,
+        mesh: mesh2,
         home,
         vel: new this.THREE.Vector3(f.velocity[0], f.velocity[1], f.velocity[2]),
         ang: new this.THREE.Vector3(f.angularVelocity[0], f.angularVelocity[1], f.angularVelocity[2]),
@@ -13612,8 +14299,8 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
           alive--;
         }
       }
-      this.addMarks(mesh, f);
-      return mesh;
+      this.addMarks(mesh2, f);
+      return mesh2;
     }
     /** Add velocity to every fragment within `radius` of a point (blasts). */
     blast(point, radius, speed) {
@@ -13652,24 +14339,24 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       }
     }
     step(f, dt, g) {
-      const mesh = f.mesh;
+      const mesh2 = f.mesh;
       f.vel.y -= g * dt;
-      mesh.position.addScaledVector(f.vel, dt);
+      mesh2.position.addScaledVector(f.vel, dt);
       const w = f.ang.length();
       if (w > 1e-5) {
         this.dq.setFromAxisAngle(this.v.copy(f.ang).multiplyScalar(1 / w), w * dt);
-        mesh.quaternion.premultiply(this.dq).normalize();
+        mesh2.quaternion.premultiply(this.dq).normalize();
       }
-      this.m.makeRotationFromQuaternion(mesh.quaternion);
+      this.m.makeRotationFromQuaternion(mesh2.quaternion);
       const e = this.m.elements;
       const h = f.half;
       const sc = f.dying ? f.fade : 1;
       const ext = (Math.abs(e[1]) * h.x + Math.abs(e[5]) * h.y + Math.abs(e[9]) * h.z) * sc;
-      const gy = this.o.groundAt(mesh.position.x, mesh.position.z);
+      const gy = this.o.groundAt(mesh2.position.x, mesh2.position.z);
       let contact = false;
-      if (mesh.position.y - ext < gy) {
+      if (mesh2.position.y - ext < gy) {
         contact = true;
-        mesh.position.y = gy + ext;
+        mesh2.position.y = gy + ext;
         if (f.vel.y < -0.6) {
           f.vel.y = -f.vel.y * 0.25;
           f.vel.x *= 0.7;
@@ -13702,8 +14389,8 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
     }
     /** Tip the fragment towards lying on its flattest face. */
     settle(f, dt) {
-      const mesh = f.mesh;
-      this.m.makeRotationFromQuaternion(mesh.quaternion);
+      const mesh2 = f.mesh;
+      this.m.makeRotationFromQuaternion(mesh2.quaternion);
       const e = this.m.elements;
       const up = [e[1], e[5], e[9]];
       const half = [f.half.x, f.half.y, f.half.z];
@@ -13718,8 +14405,8 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       this.v.set(e[axis2 * 4], e[axis2 * 4 + 1], e[axis2 * 4 + 2]).multiplyScalar(sign);
       this.w.set(0, 1, 0);
       this.dq.setFromUnitVectors(this.v, this.w);
-      this.q.copy(this.dq).multiply(mesh.quaternion);
-      mesh.quaternion.slerp(this.q, clamp6(dt * 7, 0, 1));
+      this.q.copy(this.dq).multiply(mesh2.quaternion);
+      mesh2.quaternion.slerp(this.q, clamp6(dt * 7, 0, 1));
     }
     /** Remove the fragments of one object (after `restore`). */
     removeHome(home) {
@@ -13789,13 +14476,13 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
         }
       }
       while (this.spots.length >= this.cap) this.remove(this.spots[0]);
-      const mesh = new this.THREE.Mesh(this.geometry, this.material(kind, color));
+      const mesh2 = new this.THREE.Mesh(this.geometry, this.material(kind, color));
       const y = this.groundAt(x, z) + 4e-3 + this.spots.length % 8 * 4e-4;
-      mesh.position.set(x, y, z);
-      mesh.scale.setScalar(1e-3);
-      mesh.renderOrder = 1;
-      this.scene.add(mesh);
-      this.spots.push({ mesh, kind, home, x, z, radius: 1e-3, target: Math.min(MAX_RADIUS, radius) });
+      mesh2.position.set(x, y, z);
+      mesh2.scale.setScalar(1e-3);
+      mesh2.renderOrder = 1;
+      this.scene.add(mesh2);
+      this.spots.push({ mesh: mesh2, kind, home, x, z, radius: 1e-3, target: Math.min(MAX_RADIUS, radius) });
     }
     remove(s) {
       const i = this.spots.indexOf(s);
@@ -14171,7 +14858,7 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
     /** Bars drawn now, over every part. */
     get count() {
       let n = 0;
-      for (const mesh of this.cages.values()) n += mesh.count;
+      for (const mesh2 of this.cages.values()) n += mesh2.count;
       return n;
     }
     /** Meshes of the live cages (tests and picking). */
@@ -14182,25 +14869,25 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
     set(key, bars) {
       this.remove(key);
       if (bars.length === 0) return;
-      const mesh = new this.THREE.InstancedMesh(this.geometry, this.material, bars.length);
+      const mesh2 = new this.THREE.InstancedMesh(this.geometry, this.material, bars.length);
       bars.forEach(([a, b], i) => {
         this.dir.set(b[0] - a[0], b[1] - a[1], b[2] - a[2]);
         const length3 = this.dir.length();
         this.mid.set((a[0] + b[0]) / 2, (a[1] + b[1]) / 2, (a[2] + b[2]) / 2);
         this.q.setFromUnitVectors(this.up, length3 > 1e-9 ? this.dir.divideScalar(length3) : this.up);
         this.m.compose(this.mid, this.q, this.scale.set(1, Math.max(length3, 1e-4), 1));
-        mesh.setMatrixAt(i, this.m);
+        mesh2.setMatrixAt(i, this.m);
       });
-      mesh.instanceMatrix.needsUpdate = true;
-      mesh.castShadow = true;
-      this.scene.add(mesh);
-      this.cages.set(key, mesh);
+      mesh2.instanceMatrix.needsUpdate = true;
+      mesh2.castShadow = true;
+      this.scene.add(mesh2);
+      this.cages.set(key, mesh2);
     }
     remove(key) {
-      const mesh = this.cages.get(key);
-      if (!mesh) return;
-      this.scene.remove(mesh);
-      mesh.dispose();
+      const mesh2 = this.cages.get(key);
+      if (!mesh2) return;
+      this.scene.remove(mesh2);
+      mesh2.dispose();
       this.cages.delete(key);
     }
     /** Remove the cages of every part of `object` (keys are `object|part`). */
@@ -14484,25 +15171,25 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
     /**
      * @param range vertex range `[v0, v1)` of a merged mesh this part is drawn by (see `MeshRange`); `hosts` caches the shared state per mesh for one `bind`.
      */
-    makeMeshVis(mesh, home, range2, hosts) {
+    makeMeshVis(mesh2, home, range2, hosts) {
       let host = null;
       if (range2) {
-        host = hosts?.get(mesh) ?? null;
+        host = hosts?.get(mesh2) ?? null;
         if (!host) {
-          host = { mesh, origGeometry: mesh.geometry, origMaterial: mesh.material, ownGeo: false, work: null, ownMat: false, sharers: [] };
-          hosts?.set(mesh, host);
+          host = { mesh: mesh2, origGeometry: mesh2.geometry, origMaterial: mesh2.material, ownGeo: false, work: null, ownMat: false, sharers: [] };
+          hosts?.set(mesh2, host);
         }
       }
       const mv = {
-        mesh,
+        mesh: mesh2,
         home,
-        origGeometry: mesh.geometry,
-        origMaterial: mesh.material,
-        origVisible: mesh.visible,
-        origParent: mesh.parent,
-        origPosition: mesh.position.clone(),
-        origQuaternion: mesh.quaternion.clone(),
-        origScale: mesh.scale.clone(),
+        origGeometry: mesh2.geometry,
+        origMaterial: mesh2.material,
+        origVisible: mesh2.visible,
+        origParent: mesh2.parent,
+        origPosition: mesh2.position.clone(),
+        origQuaternion: mesh2.quaternion.clone(),
+        origScale: mesh2.scale.clone(),
         ownMat: false,
         ownGeo: false,
         work: null,
@@ -14627,15 +15314,15 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
      * Returns false when nothing was changed (too far, low quality on a heavy mesh, or no editable positions).
      */
     applyDent(mv, worldPoint, worldNormal, dent) {
-      const mesh = mv.mesh;
+      const mesh2 = mv.mesh;
       if (this.lowQuality && this.vertexCount(mv) > 2e4) return false;
-      mesh.updateWorldMatrix(true, false);
-      const s = mesh.matrixWorld.getMaxScaleOnAxis() || 1;
-      const lp = mesh.worldToLocal(this.a.copy(worldPoint));
-      const ln = this.b.copy(worldNormal).transformDirection(this.m4.copy(mesh.matrixWorld).invert()).normalize();
+      mesh2.updateWorldMatrix(true, false);
+      const s = mesh2.matrixWorld.getMaxScaleOnAxis() || 1;
+      const lp = mesh2.worldToLocal(this.a.copy(worldPoint));
+      const ln = this.b.copy(worldNormal).transformDirection(this.m4.copy(mesh2.matrixWorld).invert()).normalize();
       const r = dent.radius / s;
       const depth = dent.depth / s;
-      const geo = mesh.geometry;
+      const geo = mesh2.geometry;
       let bb;
       if (mv.host) bb = this.localBox(mv, this.lbox);
       else {
@@ -14645,7 +15332,7 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       if (bb && !bb.isEmpty() && bb.distanceToPoint(lp) > r) return false;
       if (!this.ownGeometry(mv)) return false;
       const work = mv.host ? mv.host.work : mv.work;
-      const pos = positionAttr(mesh.geometry);
+      const pos = positionAttr(mesh2.geometry);
       const r2 = r * r;
       let touched = false;
       const px = lp.x;
@@ -14711,11 +15398,11 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
     // Decals
     // ------------------------------------------------------------------------------------------------------------------------------------
     /** Decal pose in mesh space: position and a rotation taking +Z to the surface normal. */
-    decalPose(mesh, worldPoint, worldNormal, lift) {
-      mesh.updateWorldMatrix(true, false);
-      const s = mesh.matrixWorld.getMaxScaleOnAxis() || 1;
-      const ln = worldNormal.clone().transformDirection(this.m4.copy(mesh.matrixWorld).invert()).normalize();
-      const pos = mesh.worldToLocal(worldPoint.clone()).addScaledVector(ln, lift / s);
+    decalPose(mesh2, worldPoint, worldNormal, lift) {
+      mesh2.updateWorldMatrix(true, false);
+      const s = mesh2.matrixWorld.getMaxScaleOnAxis() || 1;
+      const ln = worldNormal.clone().transformDirection(this.m4.copy(mesh2.matrixWorld).invert()).normalize();
+      const pos = mesh2.worldToLocal(worldPoint.clone()).addScaledVector(ln, lift / s);
       const quat2 = new this.THREE.Quaternion().setFromUnitVectors(new this.THREE.Vector3(0, 0, 1), ln);
       return { s, pos, quat: quat2 };
     }
@@ -14851,7 +15538,7 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       if (Math.abs(m - pv.meltApplied) < 0.01) return;
       pv.meltApplied = m;
       for (const mv of pv.meshes) {
-        const mesh = mv.mesh;
+        const mesh2 = mv.mesh;
         if (mv.host) {
           mv.meltApplied = m;
           mv.touched = true;
@@ -14859,27 +15546,27 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
           continue;
         }
         if (mv.meltApplied === 0 && m > 0) {
-          mesh.updateWorldMatrix(true, false);
-          mv.bottomY = this.box.setFromObject(mesh).min.y;
+          mesh2.updateWorldMatrix(true, false);
+          mv.bottomY = this.box.setFromObject(mesh2).min.y;
         }
         mv.meltApplied = m;
         mv.moved = true;
         const sy = lerp5(1, 0.25, m);
         const sxz = 1 + 0.18 * m;
-        mesh.scale.set(mv.origScale.x * sxz, mv.origScale.y * sy, mv.origScale.z * sxz);
-        mesh.position.copy(mv.origPosition);
-        mesh.updateWorldMatrix(true, false);
-        const bottom = this.box.setFromObject(mesh).min.y;
+        mesh2.scale.set(mv.origScale.x * sxz, mv.origScale.y * sy, mv.origScale.z * sxz);
+        mesh2.position.copy(mv.origPosition);
+        mesh2.updateWorldMatrix(true, false);
+        const bottom = this.box.setFromObject(mesh2).min.y;
         const dy = mv.bottomY - bottom;
-        if (Math.abs(dy) > 1e-6 && mesh.parent) {
-          mesh.parent.updateWorldMatrix(true, false);
-          const inv = this.m4.copy(mesh.parent.matrixWorld).invert();
+        if (Math.abs(dy) > 1e-6 && mesh2.parent) {
+          mesh2.parent.updateWorldMatrix(true, false);
+          const inv = this.m4.copy(mesh2.parent.matrixWorld).invert();
           this.a.set(0, dy, 0).applyMatrix4(inv);
           this.b.set(0, 0, 0).applyMatrix4(inv);
-          mesh.position.copy(mv.origPosition).add(this.a.sub(this.b));
+          mesh2.position.copy(mv.origPosition).add(this.a.sub(this.b));
         }
         if (!(this.lowQuality && this.vertexCount(mv) > 2e4) && this.ownGeometry(mv)) {
-          this.writePositions(mv, positionAttr(mesh.geometry));
+          this.writePositions(mv, positionAttr(mesh2.geometry));
         }
       }
     }
@@ -15152,30 +15839,30 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
         this.restoreRanged(mv);
         return;
       }
-      const mesh = mv.mesh;
+      const mesh2 = mv.mesh;
       for (const d of mv.decals) this.disposeDecal(d);
       mv.decals.length = 0;
       if (mv.ownGeo) {
-        mesh.geometry.dispose();
-        mesh.geometry = mv.origGeometry;
+        mesh2.geometry.dispose();
+        mesh2.geometry = mv.origGeometry;
         mv.ownGeo = false;
         mv.work = null;
       }
       if (mv.ownMat) {
-        for (const m of materialsOf(mesh.material)) m.dispose();
-        mesh.material = mv.origMaterial;
+        for (const m of materialsOf(mesh2.material)) m.dispose();
+        mesh2.material = mv.origMaterial;
         mv.ownMat = false;
         mv.baseColors = null;
       }
-      mesh.visible = mv.origVisible;
-      if (mv.origParent && mesh.parent !== mv.origParent) {
-        mv.origParent.add(mesh);
+      mesh2.visible = mv.origVisible;
+      if (mv.origParent && mesh2.parent !== mv.origParent) {
+        mv.origParent.add(mesh2);
         mv.moved = true;
       }
       if (mv.moved) {
-        mesh.position.copy(mv.origPosition);
-        mesh.quaternion.copy(mv.origQuaternion);
-        mesh.scale.copy(mv.origScale);
+        mesh2.position.copy(mv.origPosition);
+        mesh2.quaternion.copy(mv.origQuaternion);
+        mesh2.scale.copy(mv.origScale);
         mv.moved = false;
       }
       mv.meltApplied = 0;
@@ -16223,88 +16910,42 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       this.disposed = true;
     }
   };
-  var ATTACK = 2e-3;
-  var lengthOf = (d, attack) => {
-    if (typeof d === "number") return attack + d;
-    if (Array.isArray(d)) return [attack + d[0], attack + d[1]];
-    return { ...d, add: (d.add ?? 0) + attack };
-  };
-  var envelope = (attack) => [
-    [0, 1e-4, "set", "fixed"],
-    [attack, 1, "exp"],
-    ["1d", 1e-4, "exp", "fixed"]
-  ];
-  function noise(o) {
-    const a = o.a ?? ATTACK;
-    const over = typeof o.d === "number" ? o.d : 0;
-    return {
-      filters: {
-        mode: "serial",
-        bank: [{ type: o.type ?? "lowpass", frequency: o.f2 === void 0 ? { set: o.f } : { set: o.f, to: o.f2, curve: "exp", over }, q: o.q ?? 0.7 }]
-      },
-      duration: lengthOf(o.d, a),
-      gain: o.vol,
-      ...o.delay === void 0 ? {} : { at: o.delay },
-      ...o.wet === void 0 ? {} : { wet: o.wet },
-      source: { kind: "noise", offset: "random", offsetScale: 1.5, loop: true },
-      envelope: envelope(a)
-    };
-  }
-  function tone(o) {
-    return {
-      source: { kind: "osc", wave: o.wave ?? "sine", frequency: { from: o.f, to: o.f2 ?? "from", curve: "exp", over: "duration" } },
-      duration: lengthOf(o.d, ATTACK),
-      gain: o.vol,
-      ...o.delay === void 0 ? {} : { at: o.delay },
-      ...o.wet === void 0 ? {} : { wet: o.wet },
-      envelope: envelope(ATTACK)
-    };
-  }
-  var many = (count, make) => Array.from({ length: count }, make);
-  var scene = (id, layers, line, vars) => ({
-    id,
-    bus: "world",
-    pan: true,
-    layers,
-    falloff: DISTANCE_CURVES.art_scene,
-    ...vars ? { vars } : {},
-    sources: [`cena:${line}`]
-  });
+  var scene = (id, layers, line, vars) => sceneRecipe(id, layers, line, vars ? { vars } : {});
   var boomLayers = (big) => [
-    noise({ f: 1200, f2: 120, d: 1.8, vol: 2, wet: 1.2 }),
-    tone({ f: 65, f2: 24, d: 1, vol: 1.8 }),
-    noise({ type: "highpass", f: 1500, d: 0.2, vol: 0.8 }),
-    ...big ? [noise({ f: 500, f2: 90, a: 0.2, d: 2.4, vol: 1.2, wet: 1, delay: 0.15 })] : [],
-    ...many(8, () => tone({ f: [2600, 5600], d: 0.05, vol: 0.08, delay: [0.4, 1.6] }))
+    sceneNoise({ f: 1200, f2: 120, d: 1.8, vol: 2, wet: 1.2 }),
+    sceneTone({ f: 65, f2: 24, d: 1, vol: 1.8 }),
+    sceneNoise({ type: "highpass", f: 1500, d: 0.2, vol: 0.8 }),
+    ...big ? [sceneNoise({ f: 500, f2: 90, a: 0.2, d: 2.4, vol: 1.2, wet: 1, delay: 0.15 })] : [],
+    ...sceneMany(8, () => sceneTone({ f: [2600, 5600], d: 0.05, vol: 0.08, delay: [0.4, 1.6] }))
   ];
   var SCENE_SOUNDS = [
     scene(
       "glass_shatter",
-      [noise({ type: "highpass", f: 2800, d: 0.45, vol: 0.9, wet: 0.5 }), ...many(12, () => tone({ f: [3e3, 7500], d: [0.06, 0.14], vol: 0.18, delay: [0, 0.55] }))],
+      [sceneNoise({ type: "highpass", f: 2800, d: 0.45, vol: 0.9, wet: 0.5 }), ...sceneMany(12, () => sceneTone({ f: [3e3, 7500], d: [0.06, 0.14], vol: 0.18, delay: [0, 0.55] }))],
       "L1359 glass"
     ),
     scene(
       "wood_hit",
-      [noise({ type: "bandpass", f: 850, q: 1, d: 0.25, vol: 0.9, wet: 0.3 }), tone({ f: 210, f2: 90, d: 0.1, vol: 0.6 }), noise({ type: "highpass", f: 2e3, d: 0.04, vol: 0.5 })],
+      [sceneNoise({ type: "bandpass", f: 850, q: 1, d: 0.25, vol: 0.9, wet: 0.3 }), sceneTone({ f: 210, f2: 90, d: 0.1, vol: 0.6 }), sceneNoise({ type: "highpass", f: 2e3, d: 0.04, vol: 0.5 })],
       "L1360 wood"
     ),
-    scene("thunk", [noise({ type: "bandpass", f: 700, q: 2, d: 0.07, vol: 0.4 })], "L1361 thunk"),
-    scene("ping", [tone({ f: [2600, 3500], f2: 1400, d: 0.14, vol: 0.18, wet: 0.3 })], "L1362 ping"),
-    scene("clang", [tone({ f: [520, 720], f2: 480, d: 0.5, vol: 0.35, wet: 0.4 }), tone({ f: 1370, f2: 1300, d: 0.3, vol: 0.15 }), noise({ type: "highpass", f: 2e3, d: 0.05, vol: 0.5 })], "L1363 clang"),
-    scene("chip", [noise({ type: "bandpass", f: 1600, q: 1.2, d: 0.06, vol: 0.5 })], "L1364 chip"),
+    scene("thunk", [sceneNoise({ type: "bandpass", f: 700, q: 2, d: 0.07, vol: 0.4 })], "L1361 thunk"),
+    scene("ping", [sceneTone({ f: [2600, 3500], f2: 1400, d: 0.14, vol: 0.18, wet: 0.3 })], "L1362 ping"),
+    scene("clang", [sceneTone({ f: [520, 720], f2: 480, d: 0.5, vol: 0.35, wet: 0.4 }), sceneTone({ f: 1370, f2: 1300, d: 0.3, vol: 0.15 }), sceneNoise({ type: "highpass", f: 2e3, d: 0.05, vol: 0.5 })], "L1363 clang"),
+    scene("chip", [sceneNoise({ type: "bandpass", f: 1600, q: 1.2, d: 0.06, vol: 0.5 })], "L1364 chip"),
     scene(
       "crumble",
-      [noise({ f: 900, f2: 200, d: 0.6, vol: 0.9, wet: 0.3 }), ...many(5, () => noise({ type: "bandpass", f: [500, 1400], q: 2, d: 0.05, vol: 0.4, delay: [0.1, 0.5] }))],
+      [sceneNoise({ f: 900, f2: 200, d: 0.6, vol: 0.9, wet: 0.3 }), ...sceneMany(5, () => sceneNoise({ type: "bandpass", f: [500, 1400], q: 2, d: 0.05, vol: 0.4, delay: [0.1, 0.5] }))],
       "L1365 crumble"
     ),
     // `thud(x, z, v)`: `v` is the `scale` param (default 1)
-    scene("thud", [tone({ f: 75, f2: 38, d: 0.22, vol: { param: "scale", scale: 0.6 } }), noise({ f: 420, d: 0.16, vol: { param: "scale", scale: 0.45 } })], "L1358 thud", { scale: 1 }),
+    scene("thud", [sceneTone({ f: 75, f2: 38, d: 0.22, vol: { param: "scale", scale: 0.6 } }), sceneNoise({ f: 420, d: 0.16, vol: { param: "scale", scale: 0.45 } })], "L1358 thud", { scale: 1 }),
     // `hiss(x, z, d)`: `seconds` is the param `d` (default 1.2)
-    scene("hiss", [noise({ type: "highpass", f: 3500, a: 0.05, d: { param: "seconds" }, vol: 0.35 })], "L1366 hiss", { seconds: 1.2 }),
+    scene("hiss", [sceneNoise({ type: "highpass", f: 3500, a: 0.05, d: { param: "seconds" }, vol: 0.35 })], "L1366 hiss", { seconds: 1.2 }),
     scene("boom", boomLayers(false), "L1367 boom"),
     scene("boom_big", boomLayers(true), "L1367 boom (big)"),
-    scene("burst", [noise({ f: 700, f2: 120, d: 0.7, vol: 1.4, wet: 0.5 }), noise({ type: "highpass", f: 3e3, a: 0.05, d: 1.2, vol: 0.4, delay: 0.1 })], "L1357 burst"),
-    scene("crack", [noise({ type: "highpass", f: 1800, d: 0.05, vol: 0.8 }), tone({ f: 420, f2: 180, d: 0.06, vol: 0.4 })], "L1354 crack")
+    scene("burst", [sceneNoise({ f: 700, f2: 120, d: 0.7, vol: 1.4, wet: 0.5 }), sceneNoise({ type: "highpass", f: 3e3, a: 0.05, d: 1.2, vol: 0.4, delay: 0.1 })], "L1357 burst"),
+    scene("crack", [sceneNoise({ type: "highpass", f: 1800, d: 0.05, vol: 0.8 }), sceneTone({ f: 420, f2: 180, d: 0.06, vol: 0.4 })], "L1354 crack")
   ];
   var EXPLOSION_BOOM = {
     id: "explosion_boom",
@@ -32046,7 +32687,7 @@ ${problems.map((problem) => `  - ${problem}`).join("\n")}`);
       if (lastRow < 0) return;
       const profile = profileOf2();
       const rainScale = 1 - options.weather().rain;
-      const seconds = dryingSeconds * rainScale;
+      const seconds = dryingSeconds * rainScale * (options.weather().drying ?? 1);
       for (let row = firstRow; row <= lastRow; row++) {
         const offset = row * width;
         for (let column = firstColumn; column <= lastColumn; column++) {
@@ -32170,6 +32811,7 @@ ${problems.map((problem) => `  - ${problem}`).join("\n")}`);
   }
   var DEFAULT_STEP_RATE = 180;
   var DEFAULT_MAX_STEPS = 6;
+  var WASH_BELOW_DRYNESS = 0.5;
   function createFilm(options) {
     const { layout, random } = options;
     const cellCount = layout.width * layout.height;
@@ -32180,7 +32822,7 @@ ${problems.map((problem) => `  - ${problem}`).join("\n")}`);
       dryness: new Float32Array(cellCount),
       dampness: new Float32Array(cellCount)
     };
-    let weatherState = { rain: 0 };
+    let weatherState = { rain: 0, drying: 1 };
     let currentProfile = options.profile;
     const context = { field, random, profile: () => currentProfile };
     const drops = createDropPool(layout, context);
@@ -32218,9 +32860,29 @@ ${problems.map((problem) => `  - ${problem}`).join("\n")}`);
         simulator.advance({ dt, dryingSeconds });
       },
       setWeather(weather) {
-        weatherState = { rain: Math.min(1, Math.max(0, weather.rain ?? weatherState.rain)) };
+        weatherState = {
+          rain: Math.min(1, Math.max(0, weather.rain ?? weatherState.rain)),
+          drying: Math.max(0, weather.drying ?? weatherState.drying ?? 1)
+        };
       },
       weather: () => ({ ...weatherState }),
+      wash(maxDryness = WASH_BELOW_DRYNESS) {
+        simulator.refreshBounds();
+        const { firstRow, lastRow, firstColumn, lastColumn } = simulator.bounds;
+        let cleared = 0;
+        for (let row = firstRow; row <= lastRow; row++) {
+          for (let column = firstColumn; column <= lastColumn; column++) {
+            const index = row * layout.width + column;
+            if (field.thickness[index] > 0 && field.dryness[index] < maxDryness) {
+              field.thickness[index] = 0;
+              field.dryness[index] = 0;
+              field.dampness[index] = 0;
+              cleared++;
+            }
+          }
+        }
+        return cleared;
+      },
       clear() {
         field.thickness.fill(0);
         field.dryness.fill(0);
@@ -32324,8 +32986,8 @@ ${problems.map((problem) => `  - ${problem}`).join("\n")}`);
           bedHeight = roadY * 1e3 + z * 14 - (x - params.roadSlopeAnchorX) * 5;
           roughness = 0.55;
         }
-        const noise2 = valueNoise(column * 0.35, row * 0.35) * 0.6 + valueNoise(column * 1.3, row * 1.3) * 0.4;
-        bed[index] = bedHeight + (noise2 - 0.5) * roughness * 2;
+        const noise = valueNoise(column * 0.35, row * 0.35) * 0.6 + valueNoise(column * 1.3, row * 1.3) * 0.4;
+        bed[index] = bedHeight + (noise - 0.5) * roughness * 2;
         vertical[index] = region === 0 || region === 2 ? 0.95 : 1;
         pin[index] = 0.62 + 0.76 * (valueNoise(column * 0.21 + 40, row * 0.21) * 0.5 + hashCell(column, row) * 0.5) * (region === 3 ? 1.25 : 1);
       }
@@ -32482,8 +33144,8 @@ ${problems.map((problem) => `  - ${problem}`).join("\n")}`);
         for (let column = 0; column < columns; column++) {
           const index = (region.firstRow + row) * columns + column;
           const centre = add2(add2(region.origin, scale(columnAxis, (column + 0.5) * cell)), scale(region.rowAxis, (row + 0.5) * cell));
-          const noise2 = valueNoise(column * 0.35, (region.firstRow + row) * 0.35) * 0.6 + valueNoise(column * 1.3, (region.firstRow + row) * 1.3) * 0.4;
-          bed[index] = centre[1] * 1e3 + (noise2 - 0.5) * strip.roughness * 2;
+          const noise = valueNoise(column * 0.35, (region.firstRow + row) * 0.35) * 0.6 + valueNoise(column * 1.3, (region.firstRow + row) * 1.3) * 0.4;
+          bed[index] = centre[1] * 1e3 + (noise - 0.5) * strip.roughness * 2;
           vertical[index] = region.isVertical ? 0.95 : 1;
           pin[index] = 0.62 + 0.76 * (valueNoise(column * 0.21 + 40, (region.firstRow + row) * 0.21) * 0.5 + valueNoise(column * 0.9, row * 0.9) * 0.5);
         }
@@ -33150,11 +33812,11 @@ ${problems.map((problem) => `  - ${problem}`).join("\n")}`);
       const index = [];
       for (let i = 0; i < this.ring; i++) index.push(0, 1 + i, 1 + (i + 1) % this.ring);
       geometry.setIndex(index);
-      const mesh = new T.Mesh(geometry);
-      mesh.name = name;
-      mesh.frustumCulled = false;
-      mesh.renderOrder = order;
-      return { mesh, position, color };
+      const mesh2 = new T.Mesh(geometry);
+      mesh2.name = name;
+      mesh2.frustumCulled = false;
+      mesh2.renderOrder = order;
+      return { mesh: mesh2, position, color };
     }
     assign(def, materials) {
       this.outer.mesh.material = materials.stainFilm(def);
@@ -33877,12 +34539,12 @@ void main(){
       this.group = new THREE.Group();
       this.group.name = "film_grid";
       for (const region of layout.regions) {
-        const mesh = new THREE.Mesh(createStripGeometry(THREE, layout, region), this.material.material);
-        mesh.frustumCulled = false;
-        mesh.renderOrder = 3;
-        mesh.name = `film_${region.id}`;
-        this.strips.push(mesh);
-        this.group.add(mesh);
+        const mesh2 = new THREE.Mesh(createStripGeometry(THREE, layout, region), this.material.material);
+        mesh2.frustumCulled = false;
+        mesh2.renderOrder = 3;
+        mesh2.name = `film_${region.id}`;
+        this.strips.push(mesh2);
+        this.group.add(mesh2);
       }
       this.dropsView = createFilmDrops(THREE, layout.rules.dropCapacity, profile);
       this.group.add(this.dropsView.drops, this.dropsView.bead);
@@ -33927,6 +34589,19 @@ void main(){
       this.pending = this.union(this.pending, rect);
       return this.takePending();
     }
+    /** Clears the cells less than `maxDryness` dry and sends the rectangle that held them up with the next update. Returns how many it cleared. */
+    wash(maxDryness) {
+      const cleared = this.film.wash(maxDryness);
+      if (cleared > 0) {
+        const bounds = this.film.simulator.bounds;
+        if (bounds.lastRow >= 0) {
+          const rect = { firstRow: bounds.firstRow, lastRow: bounds.lastRow, firstColumn: bounds.firstColumn, lastColumn: bounds.lastColumn };
+          this.encode(rect);
+          this.pending = this.union(this.pending, rect);
+        }
+      }
+      return cleared;
+    }
     takePending() {
       const rect = this.pending;
       this.pending = null;
@@ -33982,7 +34657,7 @@ void main(){
       return { firstRow: Math.min(a.firstRow, b.firstRow), lastRow: Math.max(a.lastRow, b.lastRow), firstColumn: Math.min(a.firstColumn, b.firstColumn), lastColumn: Math.max(a.lastColumn, b.lastColumn) };
     }
     dispose() {
-      for (const mesh of this.strips) mesh.geometry.dispose();
+      for (const mesh2 of this.strips) mesh2.geometry.dispose();
       this.material.dispose();
       this.dropsView.dispose();
       this.texture.dispose();
@@ -33996,11 +34671,12 @@ void main(){
   var DEFAULT_GRID_METRES = 2;
   var DEFAULT_CELL2 = 0.0125;
   var BAKE_RANGE_FACTOR = 1.25;
+  var DEFAULT_WASHABLE = ["blood", "old_blood"];
   var EDGE_MARGIN = 0.35;
   var FLOOR_REACH = 0.3;
   var DROP_HEIGHT = 2.5;
   var DEFAULT_DROP_RADIUS = 3;
-  var FALL_SPEED = 2;
+  var FALL_SPEED2 = 2;
   var VISIBLE_THICKNESS22 = 0.035;
   var DEFAULT_HALF = 50;
   var FREE_AFTER_EMPTY = 2;
@@ -34021,6 +34697,7 @@ void main(){
       __publicField5(this, "staging", /* @__PURE__ */ new Map());
       __publicField5(this, "now");
       __publicField5(this, "rain", 0);
+      __publicField5(this, "drying", 1);
       __publicField5(this, "time", 0);
       __publicField5(this, "bakedCount", 0);
       __publicField5(this, "last", { grids: 0, drops: 0, wetCells: 0, simMs: 0, starved: 0, baked: 0, uploadedTexels: 0 });
@@ -34040,13 +34717,24 @@ void main(){
     }
     setWeather(weather) {
       this.rain = Math.min(1, Math.max(0, weather.rain));
-      for (const grid of this.grids) grid.film.setWeather({ rain: this.rain });
+      if (weather.drying !== void 0) this.drying = Math.max(0, weather.drying);
+      for (const grid of this.grids) grid.film.setWeather({ rain: this.rain, drying: this.drying });
+    }
+    /**
+     * Rain washes the fresh stain away (the visor's `ZG.wipe` with mode "chuva"): in the grids of the washable liquids (default blood and old blood), the
+     * cells that are less than `maxDryness` dry (default 0.5) are cleared. Returns how many cells it cleared.
+     */
+    wash(maxDryness) {
+      const washable = this.options.washable ?? DEFAULT_WASHABLE;
+      let cleared = 0;
+      for (const grid of this.grids) if (washable.includes(grid.profile.id)) cleared += grid.wash(maxDryness);
+      return cleared;
     }
     /** Throws a drop of a liquid: it lands in the grid under it (made on the spot) and leaves the impact splash. Null when it is out of range or has no surface. */
     launch(request) {
       const grid = this.gridFor(request.fluid, request.point, request.surfaces, request.tint);
       if (!grid) return null;
-      const velocity = request.velocity ?? [0, -FALL_SPEED, 0];
+      const velocity = request.velocity ?? [0, -FALL_SPEED2, 0];
       grid.film.launch(request.point, velocity, request.radius ?? DEFAULT_DROP_RADIUS);
       return grid;
     }
@@ -34071,7 +34759,7 @@ void main(){
       const layout = layoutFromSurfaces({ ...found, center: point, columns: this.columns(), rows: this.columns(), cellSize: this.options.cellSize ?? DEFAULT_CELL2 });
       if (this.grids.length >= (this.options.maxGrids ?? DEFAULT_MAX_GRIDS)) this.evict(point);
       const grid = new FilmGrid(this.THREE, { layout, profile, random: this.options.random, center: point, ...tint ? { tint } : {}, ...this.options.base === void 0 ? {} : { base: this.options.base } });
-      grid.film.setWeather({ rain: this.rain });
+      grid.film.setWeather({ rain: this.rain, drying: this.drying });
       this.grids.push(grid);
       this.group.add(grid.group);
       return grid;
@@ -34148,7 +34836,7 @@ void main(){
     /** Whether `point` is over the grid, away from its edge, so a splash there does not fall off the strip. */
     covers(grid, point) {
       const layout = grid.film.layout;
-      const wide = layout.width * layout.cellSize;
+      const wide2 = layout.width * layout.cellSize;
       for (const region of layout.regions) {
         const local2 = [point[0] - region.origin[0], point[1] - region.origin[1], point[2] - region.origin[2]];
         const above2 = local2[0] * region.normal[0] + local2[1] * region.normal[1] + local2[2] * region.normal[2];
@@ -34156,7 +34844,7 @@ void main(){
         const sideways = local2[0] * region.columnAxis[0] + local2[1] * region.columnAxis[1] + local2[2] * region.columnAxis[2];
         const down = local2[0] * region.rowAxis[0] + local2[1] * region.rowAxis[1] + local2[2] * region.rowAxis[2];
         const length3 = region.rowCount * layout.cellSize;
-        if (sideways > EDGE_MARGIN && sideways < wide - EDGE_MARGIN && down > EDGE_MARGIN && down < length3 - EDGE_MARGIN) return true;
+        if (sideways > EDGE_MARGIN && sideways < wide2 - EDGE_MARGIN && down > EDGE_MARGIN && down < length3 - EDGE_MARGIN) return true;
       }
       return false;
     }
@@ -34307,6 +34995,7 @@ void main(){
         return landed;
       },
       setWeather: (weather) => manager.setWeather(weather),
+      wash: (maxDryness) => manager.wash(maxDryness),
       update(dt) {
         if (leaks.size === 0) return;
         const streams = new Map(fluids.streams().map((stream) => [stream.id, stream]));
@@ -34399,15 +35088,15 @@ void main(){
       if (s.kind === "box") geo = new THREE.BoxGeometry(s.size[0], s.size[1], s.size[2]);
       else if (s.kind === "cylinder") geo = new THREE.CylinderGeometry(s.radius, s.radius, s.height, seg);
       else geo = new THREE.SphereGeometry(s.radius, seg, Math.max(6, seg - 4));
-      const mesh = new THREE.Mesh(geo, materialFor(p));
-      mesh.name = p.id;
-      mesh.userData.destructionPart = p.id;
-      mesh.userData.destructionMaterial = p.material;
-      mesh.position.set(p.position[0], p.position[1], p.position[2]);
-      if (p.rotation) mesh.rotation.set(p.rotation[0], p.rotation[1], p.rotation[2], "XYZ");
-      mesh.castShadow = shadows && !TRANSPARENT[p.material];
-      mesh.receiveShadow = shadows;
-      root.add(mesh);
+      const mesh2 = new THREE.Mesh(geo, materialFor(p));
+      mesh2.name = p.id;
+      mesh2.userData.destructionPart = p.id;
+      mesh2.userData.destructionMaterial = p.material;
+      mesh2.position.set(p.position[0], p.position[1], p.position[2]);
+      if (p.rotation) mesh2.rotation.set(p.rotation[0], p.rotation[1], p.rotation[2], "XYZ");
+      mesh2.castShadow = shadows && !TRANSPARENT[p.material];
+      mesh2.receiveShadow = shadows;
+      root.add(mesh2);
     }
     return root;
   }
@@ -35732,16 +36421,16 @@ void main(){
     const up = new THREE.Vector3(0, 1, 0);
     const clear = () => {
       projectiles.length = 0;
-      for (const mesh of meshes) mesh.removeFromParent();
+      for (const mesh2 of meshes) mesh2.removeFromParent();
       meshes.length = 0;
     };
     const addMesh = (geometry, color, metalness, at3) => {
-      const mesh = new THREE.Mesh(geometry, new THREE.MeshStandardMaterial({ color, roughness: 0.6, metalness }));
-      mesh.castShadow = true;
-      mesh.position.set(at3[0], at3[1], at3[2]);
-      scene2.add(mesh);
-      meshes.push(mesh);
-      return mesh;
+      const mesh2 = new THREE.Mesh(geometry, new THREE.MeshStandardMaterial({ color, roughness: 0.6, metalness }));
+      mesh2.castShadow = true;
+      mesh2.position.set(at3[0], at3[1], at3[2]);
+      scene2.add(mesh2);
+      meshes.push(mesh2);
+      return mesh2;
     };
     const remove = (projectile) => {
       for (const extra of projectile.attached ?? []) {
@@ -35759,9 +36448,9 @@ void main(){
       const isMolotov = !!use.fire;
       const isRocket = use.trigger === "impact" && (use.armDistance ?? 0) > 0;
       const geometry = isRocket ? new THREE.CylinderGeometry(0.04, 0.04, 0.5, 8) : isMolotov ? new THREE.CylinderGeometry(0.035, 0.04, 0.2, 8) : new THREE.SphereGeometry(0.045, 8, 6);
-      const mesh = addMesh(geometry, isMolotov ? 3897915 : isRocket ? 7041116 : 4936480, isMolotov ? 0 : 0.4, use.origin);
+      const mesh2 = addMesh(geometry, isMolotov ? 3897915 : isRocket ? 7041116 : 4936480, isMolotov ? 0 : 0.4, use.origin);
       projectiles.push({
-        mesh,
+        mesh: mesh2,
         pos: new THREE.Vector3(use.origin[0], use.origin[1], use.origin[2]),
         vel: new THREE.Vector3(use.velocity[0], use.velocity[1], use.velocity[2]),
         weapon: context.toolId(),
@@ -35812,11 +36501,11 @@ void main(){
       const placed = { ...use, origin: at3 };
       const body = createExplosiveBody(placed, arsenal.explosives, arsenal.rules.explosives);
       if (!body) return;
-      const mesh = addMesh(new THREE.BoxGeometry(0.18, 0.06, 0.1), use.explosive === "claymore" ? 5597999 : 12757112, 0.1, at3);
-      mesh.rotation.y = Math.atan2(use.direction[0], use.direction[2]);
+      const mesh2 = addMesh(new THREE.BoxGeometry(0.18, 0.06, 0.1), use.explosive === "claymore" ? 5597999 : 12757112, 0.1, at3);
+      mesh2.rotation.y = Math.atan2(use.direction[0], use.direction[2]);
       const attached = [markerAt(at3)];
       const segment = tripwireSegment(placed);
-      const projectile = { mesh, pos: new THREE.Vector3(at3[0], at3[1], at3[2]), vel: new THREE.Vector3(), weapon: context.toolId(), fuse: 0, burstOnImpact: false, energy: use.energy, radius: use.radius, age: 0, body, placed: true, attached };
+      const projectile = { mesh: mesh2, pos: new THREE.Vector3(at3[0], at3[1], at3[2]), vel: new THREE.Vector3(), weapon: context.toolId(), fuse: 0, burstOnImpact: false, energy: use.energy, radius: use.radius, age: 0, body, placed: true, attached };
       if (segment) {
         const wire = { from: segment.from, to: segment.to, letThrough: /* @__PURE__ */ new Set() };
         for (const id of touching(wire)) wire.letThrough.add(id);
@@ -36493,13 +37182,13 @@ void main(){
             if (!g || g.done) break;
             g.done = true;
             const [a, b] = ev.parts;
-            const many2 = g.list.length > 1;
+            const many = g.list.length > 1;
             c.log.add({
               channel: "event",
               type: "detach",
               objectId: ev.object,
               itemId: c.itemIdOf(ev.object),
-              text: many2 ? t(`ev.detach.many.${ev.by === "tool" ? "tool" : "break"}`, { obj: c.nameOf(ev.object), joints: joints(g.list.length), pieces: pieces(g.groups) }) : t("ev.detach", { obj: c.nameOf(ev.object), a, b, by: t(`by.${ev.by}`), pieces: pieces(g.groups) }),
+              text: many ? t(`ev.detach.many.${ev.by === "tool" ? "tool" : "break"}`, { obj: c.nameOf(ev.object), joints: joints(g.list.length), pieces: pieces(g.groups) }) : t("ev.detach", { obj: c.nameOf(ev.object), a, b, by: t(`by.${ev.by}`), pieces: pieces(g.groups) }),
               data: { joint: ev.joint, joints: g.list.map((j) => j.joint), parts: ev.parts, by: ev.by, groups: g.groups }
             });
             break;
@@ -40036,6 +40725,8 @@ void main(){
       camera: camera2,
       arsenal,
       fluids,
+      film: filmBridge,
+      vfx: vfx.world,
       fluidRenderer: fluidView,
       audio,
       environment,