[lane F] Round 0 scaffold: docs, contracts, lane charters, bootable stub world

GDD v1 (flow-locked hybrid movement, 5 biomes + secret, boss roster), TECH contracts (world API, level schema v0, bus events, manifest law), ART_BIBLE (synthetic scanner look), PIPELINE (MODELBEAST-first, fal gated), PROCESS (PROCITY lane/round law), charters A-F + ROUND1 instructions. Seed code: shell + boot + core (rng/bus/flags) + stub world (peristalsis shader tube, 1 draw / 102k tris, contract-complete) + qa.sh (GREEN). Verified in-browser; evidence docs/shots/laneF/round0_stub_tube.png. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
2026-07-16 01:28:35 +10:00 · 2026-07-16 01:28:35 +10:00 · 34f84ab162
commit 34f84ab162
42 changed files with 85788 additions and 0 deletions
--- a/.claude/launch.json
+++ b/.claude/launch.json
@ -0,0 +1,11 @@
 {
  "version": "0.0.1",
  "configurations": [
    {
      "name": "guts",
      "runtimeExecutable": "python3",
      "runtimeArgs": ["-m", "http.server", "8140", "--directory", "web"],
      "port": 8140
    }
  ]
 }
--- a/.gitignore
+++ b/.gitignore
@ -0,0 +1,8 @@
 .DS_Store
 node_modules/
 pipeline/.genraw/
 pipeline/.genprops/
 pipeline/.genaudio/
 pipeline/_normalized/
 docs/shots/**/*.mov
 docs/shots/**/*.mp4
--- a/README.md
+++ b/README.md
@ -0,0 +1,49 @@
 # GUTS — a fantastic voyage through the alimentary canal
 Browser flight-combat game (three.js, zero build step). You pilot **ENDO-1**, a microscopic
 probe, mouth → rectum through five anatomically-grounded biomes: ride peristalsis down the
 esophagus, cross the acid sea of the stomach, thread the villi forest of the small intestine,
 survive the gas swamps of the colon. *Fantastic Voyage* × *Star Fox* × *Descent*.
 - **Design:** [docs/GDD.md](docs/GDD.md) · **Look:** [docs/ART_BIBLE.md](docs/ART_BIBLE.md)
 - **Architecture + contracts:** [docs/TECH.md](docs/TECH.md)
 - **Asset generation:** [docs/PIPELINE.md](docs/PIPELINE.md)
 - **How we work (lanes/rounds):** [docs/PROCESS.md](docs/PROCESS.md) — **read this first if you are a lane**
 - **Current round:** [docs/LANES/ROUND1_INSTRUCTIONS.md](docs/LANES/ROUND1_INSTRUCTIONS.md)
 ## Run it
 ```bash
 cd web && python3 -m http.server 8140
 # http://localhost:8140            — the game
 # http://localhost:8140/?stub=1&dbg=1  — stub world + debug HUD (works from day 0)
 ```
 No bundler, no npm, no build. ES modules + import map; three.js r175 vendored in `web/vendor/`
 (never CDN — the game must run offline). Before you finish a session: `bash tools/qa.sh`.
 ## The one-paragraph tech pitch
 The whole canal is a **spline**. World position is `(s, θ, ρ)` — distance along the canal,
 angle and radius in the cross-section. Tube walls are chunked extrusions along
 parallel-transport frames; peristalsis and breathing are **vertex-shader displacement**
 (cheap, squishy, everywhere); collision is an analytic radius test (no physics engine).
 Caverns (mouth, stomach) switch the same controller to free 6DOF. Look is **synthetic
 scanner** — dark endoscope void, SEM-style monochrome walls with FLUX-generated detail
 textures, emissive-coded enemies. Everything is seeded + deterministic, and every asset is
 optional at runtime — the game boots and plays asset-free with procedural fallbacks.
 ## Hard laws (all lanes)
 1. **Determinism.** No `Math.random` outside `js/core/rng.js`. Seeded RNG only. qa.sh greps.
 2. **Assets are optional.** Missing texture/model/audio ⇒ procedural fallback, never a crash.
 3. **Eyeball everything.** Visual work isn't done until a screenshot is in `docs/shots/laneX/`.
 4. **Perf budget:** ≤300 draw calls, 60 fps on M-series / mid laptop. Measure via `window.DBG`.
 5. **Free-first.** Local MODELBEAST generation before any paid API; fal.ai is a gated fallback
   (John's go). See PIPELINE.md.
 6. **Git:** stage only your exact paths, commit + push each session, never `git add .`.
 ## Deploy
 Target: partly.party (static). Not wired yet — when it's time, consult the `deploy-map` skill
 and run `ship-check` first. Origin: `ssh://git@100.71.119.27:222/monster/guts.git`.
--- a/docs/ART_BIBLE.md
+++ b/docs/ART_BIBLE.md
@ -0,0 +1,78 @@
 # ART BIBLE — the "synthetic scanner" look
 Owner: Lane D (generation) + Lane A (shaders) + F (final eyeball). This settles the
 realistic-vs-wireframe question from the concept discussion: **hybrid, decided.**
 ## The look, in one line
 A live feed from an impossible medical instrument: dark endoscope void, walls rendered like
 scanning-electron-microscope tissue in a single biome tint with artificial rim light,
 everything alive and pulsing; gameplay-relevant things glow.
 Why: SEM-monochrome + rim light gives us the gross-out organic detail *and* perfect visual
 hierarchy (emissive enemies pop against dark tinted walls) *and* browser-friendly perf (no
 real SSS, no fluid sim — fresnel rim + matcap + vertex displacement fake all of it).
 ## Rendering recipe (Lane A)
 - **Walls:** custom ShaderMaterial. Base = biome tint × FLUX detail texture (used as
  luminance/AO, tiled along (s,θ) UVs) + **fresnel rim light** (the SEM edge glow, biome
  accent color) + optional matcap for wet specular. NO real-time lights needed for walls.
 - **Motion:** vertex shader — traveling peristalsis wave `disp = A·pulse(k·s − ω·t)` along
  inward normal, plus small fbm "breathing". Villi = InstancedMesh cones swaying with the
  same phase. Collision uses conservative max amplitude (TECH: `wallRho`).
 - **Depth:** exponential fog to the biome void color — the tunnel ahead fades to dark, the
  scanner-light radius around the player is your safety bubble (esp. level 5).
 - **Post (F wires, A supplies):** vignette + faint scanline/noise overlay (the "feed"),
  chromatic aberration pulse on damage, subtle radial blur on boost. All cheap fullscreen.
 ## Emissive code (readability law — never violate)
 | meaning | color |
 |---|---|
 | hostile | hot amber → red core `#ff5a2a` |
 | hostile projectile | white-hot `#ffe9d0` |
 | neutral flora / interactive | cyan `#39e6ff` |
 | pickups | soft green `#7dffb0` |
 | checkpoints/gates | violet `#b06aff` |
 | acid / corrosive zones | sickly yellow-green `#c8ff3a` |
 ## Biome palettes (tint / accent-rim / void-fog)
 | biome | tint | rim accent | void | feel |
 |---|---|---|---|---|
 | oral cavity | pale blue-white `#a8c4d8` | ice `#dff2ff` | `#06090e` | clinical, bright, tutorial-readable |
 | esophagus | deep teal `#1e6e64` | mint `#5affd2` | `#02100d` | speed, ribbed rings rushing past |
 | stomach | amber `#b0571e` | ember `#ffb13a` | `#120801` | hell-sea; acid glows `#c8ff3a` |
 | small intestine | magenta-violet `#7a2a6e` | pink `#ff6ad5` | `#0d0312` | dense alien forest |
 | large intestine | murk green `#3a4a26` | bio-lume `#9dff4a` | `#050702` | dark swamp, scanner-light gameplay |
 | appendix (secret) | gold `#8a7020` | `#ffe066` | `#0a0800` | treasure room |
 ## FLUX prompt kit (Lane D — flux_local, 1024², then tile-check + normal-derive)
 Style stem, always: `scanning electron microscope micrograph, monochrome, high detail
 organic tissue, dark background, dramatic rim lighting, seamless tiling texture`
 - esophageal wall: stem + `human esophageal mucosa, longitudinal ribbed folds, wet ridges`
 - stomach wall: stem + `gastric mucosa, pitted craters, gastric pits, glistening mucus`
 - small intestine: stem + `intestinal villi, dense finger-like projections, forest of fronds`
 - colon wall: stem + `colonic mucosa, smooth undulating folds, scattered biofilm patches`
 - matcaps: `spherical material study ball, wet translucent organic tissue, subsurface glow,
  studio black background` (crop sphere → matcap)
 - Texture is authored **grayscale**; the shader applies biome tint. One texture can serve
  two biomes at different tints/tilings — generate ~2 per biome, not ten.
 - Tiling: generate → wrap-offset check (see PIPELINE) → if seams, mirror-tile or inpaint the
  seam with `mflux_image_edit`. **Eyeball every texture in-engine before committing.**
 ## Hero meshes (round 2+, D): ENDO-1 ship, macrophage, tapeworm head, pyloric guardian
 nodes, Blockage chunks. Concept via flux_local (stem: `game asset concept, single object,
 centered, black background` + subject) → sf3d draft to sanity-check silhouette → trellis_mac
 final → normalize to house GLB law. Blobby organic forms are TRELLIS's sweet spot; thin
 fins/antennae or translucency are its weakness → fal.ai Hunyuan fallback list (gated).
 ## Screens & HUD (Lane E)
 HUD is part of the fiction: an instrument overlay. Thin cyan line-work, small caps type,
 data-noise ticks. The **gut-map** is the star: a full alimentary-canal silhouette as the
 level/progress bar, current position blipping. Damage = feed glitches (aberration, tearing),
 not red screen-edges. Title screen: slow fly-through of the esophagus stub + big type.
--- a/docs/GDD.md
+++ b/docs/GDD.md
@ -0,0 +1,95 @@
 # GUTS — Game Design Document (v1, round 1)
 Owner: Lane C (with F sign-off). This v1 settles the open questions from the original
 concept discussion; C refines numbers/encounters in-lane, but the **decisions** below are
 integrator-settled for v1.
 ## Fantasy & tone
 You are ENDO-1, a one-pilot micro-probe injected to clear a patient's digestive tract of a
 hostile infestation, mouth to exit. Tone: playful-gross medical sci-fi — *Fantastic Voyage*
 wonder, *Star Fox* arcade flow, a wink of *Osmos*-y biology-nerd humor. The body is not the
 enemy; it's the weather. Enemies are the infestation + an immune system that can't tell
 you're friendly.
 ## DECISION — movement model: "flow-locked" hybrid
 Neither pure rail nor pure 6DOF — **the anatomy picks the mode**:
 - **Tube mode** (esophagus, intestines): peristalsis is a forward current you cannot fully
  fight. Base flow speed comes from the biome (`world.biomeAt(s).flow`); throttle gives
  ±40%, boost gives short +120% bursts. Full analog movement in the cross-section disc
  (mouse/stick aims, ship banks). You steer *within* the tube; the tube carries you. This is
  the Star Fox layer: readable, forward, fast.
 - **Arena mode** (oral cavity, stomach, boss lairs): the same controller unlocked to free
  6DOF, Descent-style, no gravity. Slower, spatial, exploratory. This is where fights and
  secrets breathe.
 - Transitions are diegetic: sphincters are literal gates between modes.
 Rationale: pure rail wastes the stomach; pure 6DOF makes the esophagus a boring corridor.
 The hybrid also keeps collision cheap in the 90% case (tube = radius test).
 ## DECISION — structure: 5 levels + gates + 1 secret
 Each level ends at a real anatomical valve, staged as a gate ritual or boss:
 | # | level | mode | signature mechanic | exit gate |
 |---|---|---|---|---|
 | 1 | **Oral Cavity** | arena (tutorial) | dodging molar crush-cycles, saliva tides | **Epiglottis** — timing gate: dive on the swallow |
 | 2 | **Esophagus** | tube (speed run) | ride peristalsis rings for boost; **reflux surge** chase finale | **Cardiac sphincter** — outrun the acid wall through it |
 | 3 | **Stomach** | arena (the acid sea) | pH as environmental damage; mucus shallows are safe lanes; churn cyclones | **BOSS: Pyloric Guardian** — the sphincter itself |
 | 4 | **Small Intestine** | tube (the long maze) | villi forest occludes sightlines; bile slicks; immune hunters | **MINIBOSS: Tapeworm chase** → ileocecal valve |
 | 5 | **Large Intestine** | tube→arena (gas swamps) | flammable gas pockets: shooting inside one detonates it (hurts everyone — risk/reward); darkness + your scanner light | **BOSS: The Blockage** — then triumphant ejection finale |
 | S | **Appendix** (secret) | arena | hidden lair off the cecum, bonus loot + lore | — |
 Target: 6–10 min/level first playthrough, ~45 min campaign, built to replay for medals.
 ## Player systems
 - **Hull** (HP, pickups only) + **Mucus coat** (regenerating shield; drained continuously by
  ambient pH/enzymes — biome-dependent — and by hits). The coat is the pH mechanic: in the
  stomach open acid, coat drain is brutal; hugging mucus shallows pauses it.
 - **Weapons:** primary **lysozyme cannon** (fast pellet stream, infinite, heat-limited);
  secondary **antacid torpedo** (limited ammo, AoE, *also neutralizes an acid zone for ~10 s*
  — the dual-use is the interesting bit).
 - **Boost** with a short i-frame window at spend; recharges from nutrient orbs.
 - **Pickups:** nutrient orbs (score+boost), mucin globs (coat refill), B12 cell (hull),
  antacid ammo, **biopsy samples** (3 hidden per level — the collectible).
 ## Enemies (v1 roster — B implements behaviors, D makes them pretty later)
 All emissive-coded (ART_BIBLE): hostile = hot amber/red, projectiles = white-hot,
 neutral flora = cyan (turns hostile if shot).
 | enemy | biome | behavior archetype |
 |---|---|---|
 | amylase droplet | mouth | slow floater, corrosive contact aura |
 | bolus chunk | esophagus | tumbling debris in the flow (crush) |
 | pepsin swarm | stomach | small fast seekers, dissolve on kill |
 | churn cyclone | stomach | environmental vortex, flings you |
 | macrophage | small int. | big slow hunter; grab → mash to escape; eats other corpses to grow |
 | antibody turret (Peyer's patch) | small int. | wall-mounted, fires homing Y-shaped darts |
 | gut flora colony | large int. | neutral biofilm; shot ⇒ angry E. coli swarm |
 | gas vent | large int. | hazard: thrust-shove + flammable cloud |
 Bosses: **Pyloric Guardian** (armored sphincter; destroy mucosal nodes during open-cycles
 while dodging acid spouts, arena slowly churns), **Tapeworm** (tube chase; shoot segment
 weak-points as it coils around the canal ahead/behind), **The Blockage** (compacted-mass
 fortress with embedded turrets and gas pockets; peel it layer by layer, finale = the canal
 itself expels you both).
 ## Scoring & replay
 Star-Fox-style medals per level: score (kills × style multiplier, chained kills), par time,
 biopsy samples, damageless-gate bonus. Combo meter feeds the music layer (E). Endless
 "colonoscopy run" mode is V2 (see V2_IDEAS.md).
 ## Difficulty & assists
 Three difficulties scale coat-drain, enemy density, boss timing windows. Assist toggles
 (flow auto-center, aim magnetism) — arcade games live or die on feel accessibility.
 ## Open for C to design in-lane (not settled)
 Exact level lengths/pacing curves, encounter tables per segment, par times, pickup economy,
 boss phase timings, secret placement, tutorialization beats of level 1.
--- a/docs/LANES/LANE_A_WORLD.md
+++ b/docs/LANES/LANE_A_WORLD.md
@ -0,0 +1,49 @@
 # LANE A — World (canal geometry, biome shaders, arenas)
 Mission: the alimentary canal itself — a living, pulsing, deterministic tube-world that
 implements THE WORLD CONTRACT (TECH.md) exactly, looks like the ART_BIBLE, and stays inside
 the perf budget. You own `web/js/world/**` and nothing else.
 ## Core design (settled)
 - **Centreline spline** per level, generated from C's level JSON (`segments[].curviness`,
  seeded via `core/rng.js`): sum of seeded low-frequency sine/fbm offsets along the main
  axis — smooth, no self-intersection, byte-identical per seed. Arclength-parameterized
  lookup table (s → t) so `sample(s)` is O(1)-ish.
 - **Parallel-transport frames** (not Frenet — Frenet flips on inflections and will make B's
  camera roll-snap; this is the classic tube-racer bug, don't ship it).
 - **Tube chunks:** extruded rings, ~2 rings/unit × 64–96 radial segs, chunked every ~40
  units; stream a window of chunks around `playerS` (build/dispose, leak-clean). Bake
  `(s, θ)` into UV2 for the shader.
 - **Radius law:** `radius(s) = base · (1 + wobble·fbm(s))`, plus per-biome features (villi
  band in small intestine as InstancedMesh cones on the wall — instanced, one draw).
 - **Wall shader** (ShaderMaterial, ART_BIBLE recipe): biome tint × detail texture
  (luminance, from D via `assets.get`, flat-tint fallback) + fresnel rim + fog-to-void.
  **Peristalsis in the vertex shader:** `disp = A·max(0, sin(k·s − ω·t))³` traveling wave +
  small fbm breathing, along inward normal. Export the *same* phase function to JS
  (`world.flowPulse(s, t)`) so B can boost players riding a wave crest and E can pulse audio.
 - **Arenas:** displaced icospheres (seeded fbm) with the same wall shader; `arenaAt` gives
  B the 6DOF clamp bounds. Stomach arena has an "acid level" plane (animated, emissive
  `#c8ff3a`) whose height C's events can move.
 - **Collision truth:** `wallRho(s,θ)` = geometric radius − max displacement amplitude −
  skin margin. `collide()` for arena mode + hazards. Cheap, analytic, no physics lib.
 ## You owe others
 - The world contract, frozen after round-1 sign-off (changes after that: propose in NOTES,
  F referees). `world.hash()` golden determinism hash + a qa selfcheck.
 - `?fly=1` noclip camera so everyone can inspect your work without Lane B.
 - `js/world/biomes.js` — the palette/params registry (values from ART_BIBLE; C's JSON
  references biomes by id).
 ## You consume
 C's level JSON (schema TECH.md), D's textures via `assets.get` (never hard-require),
 F's `core/{rng,bus,flags}.js`, stub as reference implementation of the contract.
 ## Laws
 Determinism (no Math.random, no Date.now in geometry paths — shader time comes from
 `world.update(dt)` accumulation). Perf: tube worst-view ≤150 draws (leave headroom for B/E).
 Dispose-clean streaming (renderer.info deltas cited in NOTES). Screenshot evidence every
 round (`docs/shots/laneA/`), each biome as it lands.
--- a/docs/LANES/LANE_B_FLIGHT.md
+++ b/docs/LANES/LANE_B_FLIGHT.md
@ -0,0 +1,50 @@
 # LANE B — Flight & Combat (controller, weapons, enemies)
 Mission: the game *feel*. Flow-locked flight that's silk at 60 fps, readable combat, enemy
 behaviors with personality. You own `web/js/flight/**` and `web/js/combat/**`.
 ## Flight (the hybrid model, GDD-settled)
 - Player state lives in **spline space** in tube mode: `(s, x, y)` where (x,y) is the
  cross-section disc offset. `ds/dt = biome.flow · throttle + boost`; throttle ∈ [0.6, 1.4],
  boost bursts +120% with i-frames. Convert to world space via `world.sample(s)` frame.
  Clamp disc position against `world.wallRho(s, θ)` — wall contact = velocity-scaled coat
  damage + a shove, never a hard stop (arcade, not sim).
 - **Arena mode** (world.modeAt): same inputs drive free 6DOF (velocity-damped, no gravity),
  clamped to `arenaAt` bounds. Mode transition = smooth handoff over ~0.5 s at the gate.
 - **Input:** mouse-aim + WASD (strafe = disc movement), Space boost, gamepad twin-stick.
  Aim reticle leads the ship (Star Fox lag), ship banks into lateral motion.
 - **Camera rig:** chase cam on the parallel-transport frame, spring-damped, slight FOV kick
  on boost. Camera roll follows frame `nor` — never world-up in tube mode (this is why A
  uses parallel transport; if you see roll snapping, file it to A, don't hack it here).
 - Riding a peristalsis crest (`world.flowPulse(s,t)` > threshold at your s) grants surf
  boost — the esophagus mechanic. Feel numbers documented in NOTES as you tune.
 ## Combat
 - **Weapons:** lysozyme cannon (hitscan-ish fast pellets, heat meter), antacid torpedo
  (slow AoE projectile; emits `level:neutralize {s, radius, duration}` on the bus — A/C
  consume for acid zones). Pooled projectiles, InstancedMesh, one draw per weapon type.
 - **Damage model** (GDD): mucus coat (regen, ambient drain = `biome.coatDrain`) over hull.
  Emit `player:damage {amount, kind}`; E renders the feedback, you own the numbers.
 - **Enemy framework:** `combat/enemies.js` registry — `spawn(type, {s, theta, rho})` from
  C's level events (listen `level:event` type `spawn`). Behaviors are small state machines
  updated in one pass; visuals = emissive primitives (ART_BIBLE colors) with
  `assets.get('models', type)` upgrade path when D's GLBs land (swap mesh, keep logic).
 - Round-1 archetypes: **floater** (amylase droplet — drifts, contact aura), **seeker**
  (pepsin — pursue in spline space, cheap: chase in (s,x,y)), **turret** (wall-mounted,
  homing darts with turn-rate limit — dodgeable by design). More per GDD roster later.
 - Hit tests: sphere-vs-sphere in world space, broad-phase by s-bucket. No physics engine.
 ## You owe / consume
 Owe: `createPlayer(…)` + `createCombat(…)` factories (TECH convention), bus events as
 specced, feel-tuning writeup in NOTES (the numbers ARE the deliverable). Consume: world
 contract (build against `?stub=1` until A lands — the stub is the contract), C's events,
 E renders your bus emissions, D's models optionally.
 ## Laws
 Everything pooled + disposed (leak-test enter/exit). Determinism: enemy RNG from `core/rng`
 streams. ≤80 draws budget for all combat visuals. Playability > realism, always. Screenshot
 + short capture evidence (`docs/shots/laneB/`); cite `window.DBG` numbers in NOTES.
--- a/docs/LANES/LANE_C_LEVELS.md
+++ b/docs/LANES/LANE_C_LEVELS.md
@ -0,0 +1,48 @@
 # LANE C — Levels & Encounters (data, pacing, bosses)
 Mission: turn the GDD into playable levels — you are the game designer lane. You own
 `web/js/levels/**` (JSON + registry/loader) and `docs/GDD.md` refinements.
 ## What you build
 - **Level JSONs** (schema TECH.md — you own the schema from round 1 sign-off onward; evolve
  it via NOTES + F referee, never silently). One file per level, `L1_mouth` … `L5_colon`
  + `LS_appendix`. Everything data-driven: if you need a new event `type` or enemy param,
  spec it in NOTES for B/A and stub it in data first.
 - **`levels/index.js`**: registry, loader, and a **schema selfcheck** (every biome id exists
  in A's registry, events sorted by s, s within length, checkpoint before every boss…) that
  qa.sh runs headlessly via `node`.
 - **Encounter design:** density curves (breather → pressure → spike → gate), teach-then-test
  (every mechanic appears safe before it appears lethal), par times, pickup economy,
  biopsy-sample hiding spots (visible-but-costly law: secrets are seen, reaching them is
  the challenge).
 - **Boss scripts** (`levels/bosses/*.js` — logic-as-data where possible, small state
  machines where not; B owns the enemy framework you plug into): Pyloric Guardian, Tapeworm
  chase, The Blockage. Spec each as: phases, telegraphs, windows, failure pressure.
 - **Difficulty scaling:** a single `difficulty.js` table (coat-drain ×, density ×, window ×)
  — GDD §Difficulty. No per-level hand-tuned forks.
 ## Design laws
 - **Anatomy is the level designer.** Every hazard/setpiece maps to something real (GDD
  table) — the game's charm is that it's *actually* the digestive tract. When inventing,
  check the anatomy first; reality is weirder and better (bile from the duodenum, Peyer's
  patches, the appendix as a secret room are all real).
 - **Readable at speed.** Tube levels are experienced at 10–20 u/s: telegraph everything
  ≥2 s upstream (E gives you `audio:cue` + HUD pings — spec what you need in NOTES).
 - **Checkpoints are sphincter-themed** where anatomy allows; death costs ≤30 s of progress.
 - Tutorialization: level 1 teaches move/shoot/coat in arena safety; the epiglottis gate is
  the exam.
 ## You owe / consume
 Owe: level JSONs + registry + selfcheck; encounter tables per level in NOTES (they double
 as B's spawn-behavior wishlist); boss specs early (round 1–2) so A can build lair arenas
 and D can concept hero meshes. Consume: A's biome registry, B's enemy/event vocabulary,
 GDD as your spec (refine it in place — it's yours now, banner what you change).
 ## Verification
 You can't screenshot data — your evidence is **playthrough notes**: boot each level
 (`?lvl=L2_esophagus&stub=1` before A lands), fly it, record pacing against your curve, note
 where it lies. Cite times/densities measured, not intended. qa selfcheck stays green.
--- a/docs/LANES/LANE_D_ASSETS.md
+++ b/docs/LANES/LANE_D_ASSETS.md
@ -0,0 +1,46 @@
 # LANE D — Assets (FLUX textures, GLB meshes, audio, manifest)
 Mission: make it gorgeous, for free. You own `pipeline/**`, `web/assets/**`, and
 `web/js/core/assets.js`. **PIPELINE.md is your bible; ART_BIBLE.md is your spec.**
 Everything you ship is optional at runtime — you make GUTS beautiful, not functional.
 ## Ground rules (hard-won, PROCITY scars)
 - **Free-first, always.** flux_local / sf3d / trellis_mac on the m3ultra box
  (`m3ultra@100.89.131.57`, repo cloned there). fal.ai only via `FAL_LIST.md` + John's go,
  after ≤2 local attempts. Check 3GOD depot + `~/Documents/3D=models/` before generating.
 - **Port, don't reinvent:** PROCITY's `gen_skins.py --local`, `gen_props.py`, `gen_audio.py`,
  `normalize.py`, `glb_stat.py` (`~/Documents/PROCITY/pipeline/`) are proven against these
  exact operators. Adapt them; keep their idempotent/resumable, `--dry-run`-first shape.
 - **Eyeball law:** contact sheets for every batch; view textures in-engine on the stub tube;
  thumbnail every GLB; delete rejects before harvest. Never "should look right".
 - **House GLB law:** metres, +Y up, sensible origin, ≤5k tris (decimate TRELLIS's 25–77k),
  WebP ≤1024, no Draco. `normalize.py` enforces; you verify.
 - One GPU job at a time on the beast; long TRELLIS runs get a heartbeat (`jobs` convention)
  if >10 min.
 ## Deliverables by area
 - **Textures:** grayscale SEM-style tiling walls (2/biome), matcaps, derived normal maps
  (`derive_maps.py`, numpy Sobel — no model), acid/decal sprites. ART_BIBLE prompt kit.
 - **Meshes (round 2+):** ENDO-1 ship, GDD enemy/boss heroes. concept → sf3d draft →
  trellis_mac → normalize → thumb → manifest. Enemies must read at a glance: silhouette
  first, detail second; check thumbs at 128 px — if it doesn't read there, it won't in-game.
 - **Audio:** procedural numpy pack (PIPELINE §Audio) — beds per biome, sfx set, stingers.
  OGG+M4A dual, ≤10 MB shipped, spectrogram + loop-seam evidence.
 - **`assets.js` + `manifest.json`:** the loader contract (TECH.md) — null on miss, never
  throw; `?localassets=0` empty-boot path; `build_manifest.py` + `validate_manifest.py`
  (qa hook).
 ## You owe / consume
 Owe: the manifest contract + validator; contact sheets/thumbs in `docs/shots/laneD/`;
 provenance + prompt log per asset (committed batch JSONs — regeneration must be possible);
 FAL_LIST.md when candidates appear. Consume: ART_BIBLE (F/A arbitrate look disputes), C's
 boss specs for hero concepts, A's UV/tiling conventions (ask in NOTES before assuming).
 ## Verification
 In-engine screenshots of your textures on the stub tube (`?dbg=1`), thumbs for meshes,
 spectrograms for audio, `validate_manifest.py` 0 errors in qa. Numbers (gen-time, file
 sizes, tri counts) measured and logged in NOTES.
--- a/docs/LANES/LANE_E_UIHUD.md
+++ b/docs/LANES/LANE_E_UIHUD.md
@ -0,0 +1,47 @@
 # LANE E — UI / HUD / Audio engine
 Mission: the instrument you fly by. Diegetic scanner HUD, screens, and the WebAudio engine
 that plays D's pack (or synthesizes fallbacks). You own `web/js/ui/**` and `web/js/audio/**`.
 ## HUD (ART_BIBLE §Screens: thin cyan line-work, small caps, data-noise ticks)
 - Core readouts: mucus-coat + hull bars, heat meter, torpedo count, speed/flow indicator,
  combo meter, score. All driven by **bus events only** (TECH §Bus) — zero imports from
  B's internals; if a signal is missing, request the event in NOTES, don't reach in.
 - **The gut-map** (the star): full alimentary-canal silhouette as the campaign progress
  bar — current level lit, player blip moving along it, checkpoints ticked. One SVG/canvas
  path, hand-drawn once, used everywhere (title, HUD corner, level-complete).
 - Telegraphs: upstream-hazard pings for C (spec: `level:event` lookahead), boss health
  when `boss:start`.
 - **Damage = feed corruption** (aberration/tearing via F's post hooks + your overlay
  glitches), not red vignette. Death/respawn = feed drop + re-acquire sequence. Cheap DOM/
  canvas overlay preferred over three.js sprites — it's an instrument overlay, let it be 2D.
 - Screens: title (over `?fly=1`-style esophagus drift), pause, level-complete medal card
  (score/par/samples — GDD §Scoring), game-over, minimal settings (difficulty, assists,
  volume, `?mute` respect).
 ## Audio engine (`js/audio/engine.js`)
 - WebAudio graph: bed bus (crossfade per `biomeAt` changes), sfx bus (pooled buffers),
  stinger duck. Autoplay-unlock on first input (browser law).
 - Consumes D's manifest audio (`ogg` with `m4a` fallback via `canPlayType`). **Procedural
  fallback law:** no pack ⇒ synthesized WebAudio beeps/noise bursts so the game is never
  silent-broken (`assets.get` null path).
 - The heartbeat: a low pulse bed whose **tempo maps to danger** (combo/boss/coat-low —
  define the danger scalar from bus events, document the mapping). This is the audio
  identity of the game; treat it as a headline feature.
 - Sync hook: `world.flowPulse` phase available for pulse-aligned squelches (nice-to-have,
  round 2+).
 ## You owe / consume
 Owe: `createHUD/createScreens/createAudio` factories (TECH convention), the event-needs
 list in NOTES (B and C build to it), volume/mute persistence (localStorage). Consume: bus
 events, D's audio manifest, ART_BIBLE, F's post-processing hooks for damage fx.
 ## Laws
 60 fps law applies to the HUD too — no per-frame DOM layout thrash (mutate via transforms/
 canvas; measure with `?dbg=1`). Everything disposes (screens swap clean). Screenshots of
 every screen + HUD states in `docs/shots/laneE/`; audio evidence = the engine playing D's
 spectrogram-verified pack + a written fallback-mode check.
--- a/docs/LANES/LANE_F_INTEGRATION.md
+++ b/docs/LANES/LANE_F_INTEGRATION.md
@ -0,0 +1,34 @@
 # LANE F — Integration (Fable, the integrator)
 Mission: everything between the lanes. Shell, core, contracts, QA gate, round instructions,
 final eyeball. F is run by the coordinating session (Fable), not an Opus lane — lanes never
 edit F territory: `web/index.html`, `web/js/boot.js`, `web/js/core/{rng,bus,flags}.js`,
 `web/js/stub/**`, `tools/qa.sh`, `docs/LANES/ROUND*_INSTRUCTIONS.md`.
 ## Standing duties
 - **Round loop:** read every lane's NOTES + progress + shots after a round; verify claims
  by booting the game (eyeball law applies to the integrator most of all); write
  `ROUND<N+1>_INSTRUCTIONS.md` with integrator decisions spelled out; banner the old round
  SUPERSEDED.
 - **Shell wiring:** lanes offer factory snippets in NOTES (`### → Lane F`); F pastes into
  boot.js behind flags, updates the TECH flags table.
 - **Contract referee:** world contract freeze, schema evolution, bus-event naming, budget
  arbitration (who spends the draw calls).
 - **QA gate:** grow `tools/qa.sh` — each round's regressions become next round's gates
  (PROCITY pattern: selfchecks accumulate; keep it fast and dependency-free).
 - **Stub parity:** `world_stub.js` must track the world contract exactly — it's the
  contract's executable spec and every lane's fallback.
 - Integration passes: cross-lane bugs (dispose leaks at seams, event races, budget
  overruns) are F's to fix or assign.
 ## Verification duties
 Boot matrix per round: default, `?stub=1`, `?localassets=0`, `?fly=1`, each `?lvl=`.
 Zero console errors. DBG numbers recorded in `docs/progress/f-progress.md`. Screenshots
 of integration state per round in `docs/shots/laneF/`.
 ## Ship duties (later)
 Deploy to partly.party via `deploy-map` skill; `ship-check` before anything is exposed;
 version tags on round completion (`v0.<round>`).
--- a/docs/LANES/ROUND1_INSTRUCTIONS.md
+++ b/docs/LANES/ROUND1_INSTRUCTIONS.md
@ -0,0 +1,94 @@
 # GUTS — Round 1 lane instructions (from Fable, integrator)
 Date: 2026-07-16 · Repo state: F's round-0 scaffold is committed on `main` — docs complete
 (README/PROCESS/GDD/TECH/ART_BIBLE/PIPELINE + charters), shell boots the **stub world**
 (straight pulsing tube, flat shading) with a fly camera, `tools/qa.sh` GREEN. Everything
 below builds against that scaffold. Read PROCESS.md §A-lane-session before starting.
 ## Integrator decisions (settled — don't relitigate in-round)
 1. **Movement is the flow-locked hybrid** (GDD). **Look is synthetic scanner** (ART_BIBLE).
   Wireframe-only and full-flesh-realism are both rejected.
 2. **The world contract in TECH.md is v1.** Round 1 is its shakedown: A implements it, B
   consumes it (via stub first). Friction → NOTES immediately; F freezes it at round end.
 3. **Level schema v0 in TECH.md is C's to ratify** — C may amend it this round (it's young),
   but must update the stub's sample level + notify A/B via NOTES in the same session.
 4. **No mesh generation this round** (D). Textures + audio proof first; hero meshes need
   C's boss specs and concept sign-off (round 2). Exception: sf3d drafts to *test* the
   concept loop are fine (free, seconds).
 5. **Vertical slice target = level 2 (esophagus)**, not level 1: the tube is the core tech
   risk and the esophagus is the purest tube. Mouth/arena tutorial comes after the spine
   works. Round 2 goal: fly the esophagus with 2 enemy types, HUD live, textured walls.
 6. Dev port **8140**; evidence law and exact-path git staging are in force everywhere.
 ## Lane A — the canal, v0
 Build `js/world/` per your charter, priority order:
 1. Spline + parallel-transport frames + arclength LUT from level JSON (consume
   `js/levels/L2_esophagus.json`; the stub's inline level shows the shape). Seeded, and
   `world.hash()` + selfcheck wired for qa.
 2. Chunked tube geometry with (s,θ) UVs, streaming window, dispose-clean (cite
   renderer.info deltas in NOTES).
 3. Wall ShaderMaterial: biome tint + fresnel rim + fog (flat-tint fallback path — D's
   textures may land mid-round; integrate via `assets.get` if present).
 4. Peristalsis vertex displacement + `world.flowPulse(s,t)` JS mirror.
 5. `?fly=1` noclip camera. Screenshot set: esophagus straights, curves, a wave crest.
 Stretch: stomach arena icosphere v0. Don't touch: player, HUD, levels' content values.
 ## Lane B — flight + first blood, on the stub
 Work entirely against `?stub=1` (contract-identical); swap to A's world late in the round
 if it's landed, but **don't block on A**.
 1. `createPlayer`: tube-mode controller (s,x,y), mouse+WASD+gamepad, banking chase cam,
   boost + i-frames, wall-graze damage + shove. Feel numbers documented in NOTES.
 2. Weapons: lysozyme cannon (pooled, instanced, heat) + hit tests vs sphere targets.
 3. Enemy framework + 3 archetypes (floater/seeker/turret) as emissive primitives, spawned
   from `level:event` (the stub level includes sample spawns; C's L2 JSON is your real feed).
 4. Damage/coat model + all bus emissions per TECH §Bus (E builds against these — emit
   faithfully even with no listener).
 Evidence: capture or screenshot sequence + DBG numbers. Arena-mode controller = round 2.
 ## Lane C — GDD ownership + the data spine
 1. Ratify/amend level schema v0 (TECH.md) — you own it from now; sync stub sample + NOTES.
 2. `js/levels/index.js` registry + headless selfcheck (qa.sh already calls
   `node js/levels/index.js --selfcheck` — make it real).
 3. **`L2_esophagus.json` complete** (the vertical-slice level): segments, flow, encounter
   curve with B's three archetypes, reflux-surge finale as a `hazard` event, checkpoints,
   par time. Fly it on the stub; pacing notes in NOTES.
 4. Draft `L1_mouth.json` + `L3_stomach.json` skeletons (biomes/lengths/arenas only).
 5. **Boss specs** (Pyloric Guardian, Tapeworm, Blockage) as one-pagers in your NOTES —
   phases/telegraphs/windows — so A can shape lairs and D can concept in round 2.
 ## Lane D — pipeline online + first texture pack + audio proof
 On the m3ultra box (clone the repo there; PIPELINE.md has the verified operator map):
 1. Port PROCITY's script shapes: `gen_textures.py` (--dry-run/--local/--harvest),
   `derive_maps.py`, `build_manifest.py`, `validate_manifest.py`.
 2. **First pack:** esophagus ×2, stomach ×2, small-intestine ×2 walls (grayscale, tiling,
   ART_BIBLE prompts) + 1 wet-tissue matcap → normals → WebP → manifest. Contact sheet +
   in-engine stub screenshots to `docs/shots/laneD/`.
 3. `js/core/assets.js` per the manifest contract (null-on-miss, `?localassets=0`).
 4. **Audio proof (small):** port `gen_audio.py` shape; synthesize 1 esophagus bed (loop-
   clean) + 4 sfx (pellet, hit-squelch, boost, pickup). Spectrogram evidence. Full pack =
   round 2.
 ## Lane E — instrument panel v0
 1. HUD overlay (DOM/canvas): coat/hull bars, heat, speed/flow, score — bus-driven only,
   against B's emissions (they land this round; stub-emit fake events for dev via a
   `?fakebus=1` helper you own).
 2. **Gut-map v1**: draw the alimentary silhouette once (SVG path), show it as progress bar
   with player blip. This is the game's signature UI — spend the taste budget here.
 3. Title screen (over the stub drift) + pause + respect `?shots=1`/`?mute=1`.
 4. `js/audio/engine.js`: bed crossfade + sfx pool + autoplay unlock + **procedural fallback
   beeps** (D's pack may land mid-round; handle both paths).
 Screenshots of every state to `docs/shots/laneE/`.
 ## Lane F (Fable) — done in round 0, then on-call
 Scaffold committed. During the round: answer contract questions in NOTES daily-ish; end of
 round: boot matrix, verify evidence, freeze world contract, write ROUND2.
 ## Round-2 preview (so you can aim): textured esophagus slice playable start-to-finish —
 A's world + B's flight/enemies + C's L2 + D's pack + E's HUD, integrated by F, tagged v0.2.
--- a/docs/PIPELINE.md
+++ b/docs/PIPELINE.md
@ -0,0 +1,76 @@
 # PIPELINE — asset generation (Lane D)
 Everything generates **free and local** on the m3ultra box via MODELBEAST; fal.ai is a paid,
 gated fallback. Verified live 2026-07-16: `m3ultra@100.89.131.57` (tailnet, key auth),
 `~/Documents/MODELBEAST/server/operators/` = `flux_local` (FLUX.2-klein-4B text→image on MPS,
 ~6 s/img, weights cached), `mflux_image_edit` (img2img/inpaint), `sf3d` (image→GLB, seconds,
 draft quality), `trellis_mac` (TRELLIS image→GLB `1024_cascade`, ~3–8 min, quality),
 `seedvr2_upscale`. Venvs: `~/Documents/MODELBEAST/venvs/{mflux,rmbg,sf3d}`.
 Run pipeline scripts **on the m3ultra box** (clone this repo there) or drive over ssh the
 PROCITY way — copy the working patterns from `~/Documents/PROCITY/pipeline/` (`gen_skins.py
 --local` drives `flux_local/run.py` directly, no server, one GPU job at a time; `gen_props.py`
 chains concept→trellis; `gen_audio.py` is the procedural audio precedent; `normalize.py` is
 the Blender house-law enforcer; `glb_stat.py` the dependency-free GLB parser). Don't reinvent
 these — port them.
 ## Textures (round 1)
 1. `pipeline/gen_textures.py --dry-run` lists the pack (prompts live in the script, style
   stems from ART_BIBLE). `--local` → flux_local → `pipeline/.genraw/` at 1024².
 2. **Tile check:** script renders each result wrap-offset by 50% into a contact sheet —
   seams are instantly visible. Fix seams by mirror-tiling or `mflux_image_edit` inpaint
   (≤2 attempts, then pick a different prompt).
 3. **Normals:** `pipeline/derive_maps.py` — grayscale → height (blur pyramid) → Sobel normal
   map, plus WebP conversion (≤1024, quality ~82). Pure numpy/PIL, no model.
 4. `--harvest` → `web/assets/gen/*.webp` + entries in `web/assets/manifest.json`
   (`build_manifest.py`), thumbs contact sheet → `docs/shots/laneD/`.
 5. **Eyeball in-engine** (boot with `?dbg=1`, check tiling scale on the stub tube) before
   committing. Delete rejects from `.genraw/` — committed junk is forever.
 ## Meshes (round 2+, after concept sign-off)
 concept (flux_local, ART_BIBLE stem) → **sf3d draft** (seconds — iterate the concept until
 the silhouette reads) → **trellis_mac** final → `normalize.py` (Blender: metres, +Y up,
 origin, decimate to ≤5k tris — TRELLIS outputs run 25–77k, always decimate — WebP ≤1024,
 no Draco) → thumbnail → manifest. **Eyeball every thumbnail.**
 Known TRELLIS weaknesses (PROCITY scars): transparent/glassy surfaces, thin wires/fins →
 don't burn attempts; straight to the fal list.
 ## fal.ai fallback (the only money in the project)
 Rules: **≤2 local attempts** per asset, then it goes on `pipeline/FAL_LIST.md` with the
 concept image attached — **John personally approves and runs the batch** (key is his; never
 committed, never in env on shared boxes). Cost ~10¢/gen billed 30¢ (MeshGod law). Expected
 fal candidates: tapeworm head (long thin body), anything translucent. Check the
 3GOD depot (`digalot.fyi/3god`) + `~/Documents/3D=models/` first — never regenerate what
 exists.
 ## Audio (round 1 proof, round 2 full pack)
 Procedural synthesis in numpy → WAV → ffmpeg OGG/Opus + M4A/AAC dual-ship (the PROCITY
 `gen_audio.py` approach — $0, deterministic, seamless loops, parody-safe). GUTS pack:
 biome ambience beds (wet cavernous drones, muffled heartbeat — tempo maps to danger, E's
 hook), sfx (pellet, torpedo, squelch hits, boost, gate, pickup chime, alarm), boss stingers.
 Beds `loudnorm` −16 LUFS, sfx peak-normalized, budget ≤10 MB shipped. Verification =
 spectrogram sheet + numeric loop-seam check into `docs/shots/laneD/`; final ear-check is
 John's.
 ## Licensing
 Everything generated here is ours (🟢 web-ok). Any sourced mesh must be Sketchfab CC0/CC-BY
 or CGTrader royalty-free; **no ActorCore in web builds** (house licensing zones). No humanoid
 characters planned, so the Mixamo fleet rule shouldn't apply — if a humanoid ever appears,
 use the character_kit base meshes, never a new rig.
 ## Artifacts
 Git-ignored (regenerable): `pipeline/.genraw/`, `pipeline/.genprops/`, `pipeline/.genaudio/`,
 `pipeline/_normalized/`. Committed: scripts, prompt/batch JSONs, `FAL_LIST.md`,
 `web/assets/**` shipped files, `docs/shots/laneD/` evidence.
 | step | cost |
 |---|---|
 | textures, normals, audio, drafts, TRELLIS meshes | **free** (local MPS) |
 | fal.ai fallback meshes | ~30¢/asset, gated on John, expected ≤$3 total |
--- a/docs/PROCESS.md
+++ b/docs/PROCESS.md
@ -0,0 +1,56 @@
 # PROCESS — lanes, rounds, and how not to step on each other
 This repo is built by parallel Claude sessions ("lanes"), each with a fixed territory,
 coordinated in numbered rounds by an integrator (Fable, = Lane F). The workflow is inherited
 from PROCITY, where it shipped a whole town in 12 rounds — follow it exactly.
 ## The cast
 | lane | territory | charter |
 |---|---|---|
 | **A — World** | canal geometry, biome shaders, arenas | [LANE_A_WORLD.md](LANES/LANE_A_WORLD.md) |
 | **B — Flight & Combat** | controls, collision response, weapons, enemies | [LANE_B_FLIGHT.md](LANES/LANE_B_FLIGHT.md) |
 | **C — Levels & Encounters** | level data, encounter design, bosses, pacing | [LANE_C_LEVELS.md](LANES/LANE_C_LEVELS.md) |
 | **D — Assets** | FLUX textures, GLB meshes, audio pack, manifest | [LANE_D_ASSETS.md](LANES/LANE_D_ASSETS.md) |
 | **E — UI/HUD/Audio-engine** | HUD, menus, gut-map, WebAudio engine | [LANE_E_UIHUD.md](LANES/LANE_E_UIHUD.md) |
 | **F — Integration** (Fable) | shell (`index.html`, `boot.js`), core/, contracts, QA, round instructions | [LANE_F_INTEGRATION.md](LANES/LANE_F_INTEGRATION.md) |
 ## A lane session, step by step
 1. Read, in order: `README.md` → `docs/TECH.md` → your lane charter → the **current**
   `docs/LANES/ROUND<N>_INSTRUCTIONS.md` (highest N not marked SUPERSEDED) → your own
   `docs/LANES/LANE_<X>_NOTES.md` and any "→ Lane <X>" sections in the other lanes' NOTES.
 2. `git pull` first. Check `git status`; if another lane's uncommitted work is present, touch
   nothing of theirs.
 3. Do the round's work **inside your territory only** (ownership map in TECH.md §Ownership).
   If you need a change in someone else's file, write the request in your NOTES under a
   `### → Lane <X>` heading (include exact code if you can — see PROCITY LANE_B_NOTES for the
   house style: offer the wiring, let the owner paste it).
 4. Evidence: screenshots into `docs/shots/lane<x>/` (use `?shots=1` for clean frames). For
   audio: spectrogram sheet + numeric loop-seam check. Numbers you claim (draw calls, fps,
   gen-times) must be **measured**, and say how you measured them.
 5. Update `docs/LANES/LANE_<X>_NOTES.md` (what landed, measured results, contract offers,
   open questions) and append a dated entry to `docs/progress/<x>-progress.md`.
 6. `bash tools/qa.sh` — leave it green.
 7. Commit **only your exact paths** (`git add <file> <file>` — never `git add .` / `-a`),
   message `[lane X] <what>`, and **push**.
 ## Rounds
 - F writes `ROUND<N>_INSTRUCTIONS.md` after reviewing all lanes' NOTES + progress + shots.
  Old round files get a `⚠ SUPERSEDED` banner — never action a superseded round.
 - Rounds are sized so a lane session finishes comfortably in one context window. If you're
  running long: land what's solid, document the rest as "next round" in NOTES, push.
 - Blocked on another lane? Build against the **stub** (`?stub=1`, `js/stub/world_stub.js`)
  or the contract in TECH.md; never idle-wait, never implement the other lane's side.
 - Integrator decisions in round instructions are **settled** — don't relitigate in-lane;
  argue in NOTES for next round if you must.
 ## Git specifics
 - Remote: `ssh://git@100.71.119.27:222/monster/guts.git`, single branch `main`.
 - Lanes may share one working tree (PROCITY style) or run from separate clones — either way
  the exact-path staging rule and pull-before-work rule are what keep it safe.
 - Generated artifacts that are re-derivable (raw gen output, staging GLBs, WAV scratch) are
  git-ignored; shipped assets (`web/assets/**` webp/ogg/m4a/glb) are committed. See
  `.gitignore` + PIPELINE.md §Artifacts.
--- a/docs/TECH.md
+++ b/docs/TECH.md
@ -0,0 +1,134 @@
 # TECH — architecture, contracts, ownership
 Stack: vanilla three.js **r175** (vendored, `web/vendor/`), ES modules + import map, zero
 build step, `python3 -m http.server` to run. No physics engine, no framework. This is house
 style (proven in PROCITY) — keep it.
 ## Module layout & ownership
 ```
 web/
  index.html            F   shell + import map + flags table wiring
  js/boot.js            F   creates renderer/scene/loop, wires lane factories, window.DBG
  js/core/rng.js        F   mulberry32 seeded RNG (THE only randomness source)
  js/core/bus.js        F   event bus (on/off/emit)
  js/core/flags.js      F   URL flag parsing
  js/core/assets.js     D   manifest loader + `depot:`/local resolution + fallback law
  js/stub/world_stub.js F   straight-tube world implementing the world contract
  js/world/**           A   createWorld() — spline, tube chunks, arenas, biome shaders
  js/flight/**          B   createPlayer() — controller, camera rig, collision response
  js/combat/**          B   weapons, damage, enemy framework + behaviors
  js/levels/*.json      C   level data (schema below)
  js/levels/index.js    C   level registry + loader + schema selfcheck
  js/ui/**              E   HUD, menus, gut-map, screens
  js/audio/**           E   WebAudio engine (plays D's pack; procedural fallback)
  assets/**             D   manifest.json + generated webp/glb/ogg/m4a + thumbs
 pipeline/**             D   generation scripts (run on the m3ultra box)
 tools/qa.sh             F   the gate
 docs/**                 all (own lane's files only)
 ```
 Never edit outside your column. Shell wiring requests → your NOTES (`### → Lane F`), with
 the exact snippet to paste (PROCITY house style).
 ## Lane factory convention
 Every lane exports pure factories, constructed by boot, no side effects at import time:
 ```js
 export function createX({ scene, world, bus, rng, flags, assets }) {
  return { update(dt, ctx){}, dispose(){}, /* lane-specific API */ };
 }
 ```
 Default-off behind flags until F wires them on. Dispose must actually free GPU resources
 (geometries, materials, textures) — enter/exit cycles are leak-tested.
 ## THE WORLD CONTRACT (A implements; stub implements it today; frozen after round-1 sign-off)
 Spline-space: `s` = arclength along the canal centreline (units), `θ` = angle in the
 cross-section (rad), `ρ` = radial distance from centreline. Units are metres in three.js
 terms; fiction scale ≈ 1 unit : 1 mm. +Y up, right-handed.
 ```js
 const world = await createWorld(levelData, { rng, quality });
 world.length                    // total arclength
 world.group                     // THREE.Group (boot adds to scene)
 world.sample(s)                 // → { pos, tan, nor, bin, radius }  (parallel-transport frame)
 world.project(pos)              // → { s, theta, rho }  (world → spline space, player-local fast path)
 world.wallRho(s, theta)         // → max safe ρ (radius minus conservative displacement amplitude)
 world.collide(pos, r)           // → null | { push:Vector3, kind:'wall'|'hazard', biome }
 world.biomeAt(s)                // → { id, palette, fog, flow, coatDrain }   (see biomes.js registry)
 world.modeAt(s)                 // → 'tube' | 'arena'
 world.arenaAt(s)                // → null | { center:Vector3, radius }      (bounds for 6DOF clamp)
 world.update(dt, playerS)       // stream chunks, advance shader time
 ```
 Determinism law: same `levelData.seed` ⇒ byte-identical geometry. A maintains a golden
 hash (`world.hash()` over sampled frames) checked by qa.
 ## Level data schema v0 (C owns; F drafted; sign-off in round 1)
 ```jsonc
 {
  "id": "L2_esophagus", "name": "Esophagus", "seed": 20260716,
  "segments": [                          // concatenated along s
    { "biome": "esophagus", "length": 600,
      "radius": { "base": 10, "wobble": 0.25 },   // wobble: seeded radius variation 0..1
      "curviness": 0.6,                            // 0 straight .. 1 writhing
      "flow": 14 }                                 // base current, units/s
  ],
  "arenas":  [ { "at": 580, "radius": 90, "biome": "stomach" } ],
  "events":  [                           // consumed by B (spawns) & E (telegraphs) via bus
    { "s": 40,  "type": "spawn",      "enemy": "bolus_chunk", "count": 6 },
    { "s": 120, "type": "hazard",     "kind": "reflux_surge", "speed": 22 },
    { "s": 300, "type": "checkpoint" },
    { "s": 560, "type": "boss",       "id": "pyloric_guardian" }
  ]
 }
 ```
 ## Bus events (append here when adding; F referees name collisions)
 `player:spawn {s}` · `player:damage {amount, kind}` · `player:death` · `player:boost` ·
 `enemy:spawn {id,type}` · `enemy:die {id,type,s}` · `pickup {kind}` · `level:event {…}` (raw
 C events as player crosses their `s`) · `level:checkpoint {s}` · `level:complete {stats}` ·
 `boss:start {id}` / `boss:phase` / `boss:end` · `combo {n}` · `audio:cue {name}`.
 ## Asset manifest contract (D owns `assets.js` + `manifest.json`)
 ```jsonc
 { "textures": { "wall_esophagus_a": { "url": "gen/wall_esophagus_a.webp",
                 "normal": "gen/wall_esophagus_a_n.webp", "tile": [3, 8] } },
  "matcaps":  { "tissue_wet": { "url": "gen/matcap_tissue.webp" } },
  "models":   { "macrophage": { "url": "models/macrophage.glb", "tris": 4200 } },
  "audio":    { "beds": { "stomach": {"ogg": "...", "m4a": "..."} }, "sfx": { … } } }
 ```
 Law: **every entry is optional at runtime.** `assets.get('textures','x')` returns `null` on
 miss and the consumer must have a procedural fallback (flat palette color, primitive mesh,
 synthesized beep). The game must be fully playable with an empty `assets/gen/`.
 House GLB law (from PROCITY): metres, +Y up, sensible origin, **≤5k tris**, WebP textures
 ≤1024, no Draco. `?localassets=0` simulates empty-manifest boot for fallback testing.
 ## Flags (F owns this table; lanes request rows via NOTES)
 | flag | owner | effect |
 |---|---|---|
 | `?stub=1` | F | world stub instead of Lane A world |
 | `?lvl=<id>` | C | boot straight into a level |
 | `?seed=<n>` | F | override level seed |
 | `?fly=1` | A | noclip fly camera (no player) |
 | `?dbg=1` | F | perf HUD + `window.DBG` helpers |
 | `?mute=1` | E | no audio |
 | `?shots=1` | F | hide HUD/debug for clean screenshots |
 | `?localassets=0` | D | boot with empty manifest (fallback test) |
 ## Perf & QA budgets
 ≤300 draw calls worst view · ≤500k tris in frustum · 60 fps M-series & mid laptops ·
 level load <2 s · zero console errors · dispose-clean on level exit (renderer.info deltas).
 `window.DBG` (F provides): `{draws, tris, fps, shot(name)}` — cite it when claiming numbers.
 `tools/qa.sh` gates: `node --check` every js file · no `Math.random` outside `core/rng.js` ·
 level JSONs parse + required keys · vendor present · (grows per round).
--- a/docs/V2_IDEAS.md
+++ b/docs/V2_IDEAS.md
@ -0,0 +1,12 @@
 # V2_IDEAS — parked, do not action in v1 rounds
 - **Colonoscopy Run** — endless procedural tube, daily seed, leaderboard.
 - **Boss rush** + speedrun mode with in-fiction timer ("procedure duration").
 - **Co-op** (two probes; one flies, one operates the instrument turret?).
 - **Realism mode** — the rejected full-flesh look as an unlockable shader toggle.
 - **Photo/endoscopy mode** — freeze, free cam, scanline filters, export frame.
 - **Sequel organ systems:** BLOOD (circulatory — currents + immune heat), AIRWAYS (lungs).
 - Peristalsis rhythm game micro-mode at the esophagus (ride waves to a beat).
 - WebXR cockpit view.
 - Gut-flora reputation system (don't shoot the biome, it helps you in level 5).
 - Mobile/touch controls.
--- a/docs/progress/f-progress.md
+++ b/docs/progress/f-progress.md
@ -0,0 +1,21 @@
 # Lane F (Fable) — progress
 ## 2026-07-16 — Round 0: scaffold
 Repo initialized from empty. Landed:
 - Full doc set: README, PROCESS (lane/round law, inherited from PROCITY), GDD v1 (movement
  = flow-locked hybrid; 5 levels + secret; enemy roster; bosses), TECH (world contract,
  level schema v0, bus events, manifest contract, flags, budgets), ART_BIBLE (synthetic
  scanner look, palettes, emissive code, FLUX prompt kit), PIPELINE (MODELBEAST operator
  map — verified live on m3ultra@100.89.131.57 2026-07-16: flux_local, mflux_image_edit,
  sf3d, trellis_mac, seedvr2_upscale; fal.ai gated fallback), V2_IDEAS.
 - Lane charters A–F + ROUND1_INSTRUCTIONS.
 - Seed code: index.html shell + boot.js (world pick w/ stub fallback, drift/fly debug cam,
  window.DBG, resize/loop), core/{rng,bus,flags}.js, stub/world_stub.js (executable world
  contract: analytic centreline, parallel-transport-style frames, inward tube mesh with
  peristalsis vertex shader + fresnel rim + fog, project/collide/wallRho/hash).
 - three r175 vendored from PROCITY (module + core + addons).
 - tools/qa.sh: node --check, Math.random grep, level JSON checks, selfcheck/manifest hooks,
  vendor gate.
 Verification: qa.sh GREEN; booted `?stub=1&dbg=1` in browser — see docs/shots/laneF/.
--- a/docs/shots/laneF/round0_stub_tube.png
+++ b/docs/shots/laneF/round0_stub_tube.png
--- a/tools/qa.sh
+++ b/tools/qa.sh
@ -0,0 +1,47 @@
 #!/bin/bash
 # tools/qa.sh (Lane F) — the gate. Run before you finish a session; leave it GREEN.
 # Dependency-free: bash + node + python3. Gates accumulate each round.
 set -u
 cd "$(dirname "$0")/.."
 FAIL=0
 red()   { printf '\033[31m✗ %s\033[0m\n' "$1"; FAIL=1; }
 green() { printf '\033[32m✓ %s\033[0m\n' "$1"; }
 # 1. every JS module parses
 JSBAD=0
 while IFS= read -r -d '' f; do
  node --check "$f" 2>/dev/null || { node --check "$f"; JSBAD=1; }
 done < <(find web/js -name '*.js' -print0)
 [ "$JSBAD" = 0 ] && green "node --check: all web/js modules parse" || red "JS syntax errors"
 # 2. determinism law: Math.random only in core/rng.js
 RAND=$(grep -rn 'Math\.random' web/js --include='*.js' | grep -v 'core/rng.js' || true)
 if [ -n "$RAND" ]; then red "Math.random outside core/rng.js:"; echo "$RAND"; else green "determinism: no stray Math.random"; fi
 # 3. level JSONs parse + minimal keys
 LVLBAD=0
 for f in web/js/levels/*.json; do
  [ -e "$f" ] || continue
  python3 - "$f" <<'PY' || LVLBAD=1
 import json, sys
 d = json.load(open(sys.argv[1]))
 assert d.get("id") and isinstance(d.get("seed"), int) and d.get("segments"), "missing id/seed/segments"
 PY
 done
 [ "$LVLBAD" = 0 ] && green "level JSONs valid" || red "level JSON errors"
 # 4. Lane C selfcheck (when it exists)
 if [ -f web/js/levels/index.js ]; then
  node web/js/levels/index.js --selfcheck && green "levels selfcheck" || red "levels selfcheck failed"
 fi
 # 5. Lane D manifest validation (when it exists)
 if [ -f pipeline/validate_manifest.py ]; then
  python3 pipeline/validate_manifest.py && green "manifest valid" || red "manifest errors"
 fi
 # 6. vendor present (the game must run offline)
 [ -f web/vendor/three.module.js ] && green "vendor: three r175 present" || red "web/vendor/three.module.js missing"
 [ "$FAIL" = 0 ] && printf '\033[32mQA GREEN\033[0m\n' || printf '\033[31mQA RED\033[0m\n'
 exit $FAIL
--- a/web/index.html
+++ b/web/index.html
@ -0,0 +1,26 @@
 <!DOCTYPE html>
 <html lang="en">
 <head>
 <meta charset="utf-8">
 <meta name="viewport" content="width=device-width, initial-scale=1">
 <title>GUTS</title>
 <style>
  html, body { margin: 0; height: 100%; overflow: hidden; background: #02100d; }
  #game canvas { display: block; }
  #ui { position: fixed; inset: 0; pointer-events: none; }  /* Lane E's layer */
  #dbg { display: none; position: fixed; left: 10px; bottom: 10px; color: #39e6ff;
         font: 12px/1.4 ui-monospace, monospace; text-shadow: 0 0 4px #000;
         pointer-events: none; z-index: 10; }
 </style>
 <script type="importmap">
 { "imports": { "three": "./vendor/three.module.js",
               "three/addons/": "./vendor/addons/" } }
 </script>
 </head>
 <body>
 <div id="game"></div>
 <div id="ui"></div>
 <div id="dbg"></div>
 <script type="module" src="./js/boot.js"></script>
 </body>
 </html>
--- a/web/js/boot.js
+++ b/web/js/boot.js
@ -0,0 +1,117 @@
 // boot.js (Lane F) — the shell. Creates renderer/scene/loop, picks the world (real or
 // stub), hosts the debug camera + DBG. Lanes: request wiring via NOTES, don't edit here.
 import * as THREE from 'three';
 import { parseFlags } from './core/flags.js';
 import { createRng } from './core/rng.js';
 import { createBus } from './core/bus.js';
 import { createWorld as createStubWorld, STUB_LEVEL } from './stub/world_stub.js';
 const flags = parseFlags();
 const bus = createBus();
 const renderer = new THREE.WebGLRenderer({ antialias: true, preserveDrawingBuffer: true });
 renderer.setPixelRatio(Math.min(devicePixelRatio, 2));
 renderer.setSize(innerWidth, innerHeight);
 document.getElementById('game').appendChild(renderer.domElement);
 const scene = new THREE.Scene();
 const camera = new THREE.PerspectiveCamera(75, innerWidth / innerHeight, 0.1, 600);
 async function pickWorld() {
  if (!flags.stub) {
    try {
      const mod = await import('./world/index.js');           // Lane A's world, when it lands
      const level = await loadLevel(flags.lvl);
      return mod.createWorld(level, { rng: createRng(flags.seed ?? level.seed) });
    } catch (e) {
      console.info('[boot] Lane A world not available, using stub —', e.message);
    }
  }
  return createStubWorld(STUB_LEVEL, { rng: createRng(flags.seed ?? STUB_LEVEL.seed) });
 }
 async function loadLevel(id) {
  const mod = await import('./levels/index.js');              // Lane C's registry, when it lands
  return mod.getLevel(id);
 }
 const world = await pickWorld();
 scene.add(world.group);
 scene.background = new THREE.Color(world.biomeAt(0).palette.void);
 // --- debug drift/fly camera (placeholder until Lane B's player rig; ?fly=1 = manual) ---
 let sCam = 5, look = { yaw: 0, pitch: 0 }, dragging = false, speed = world.biomeAt(0).flow * 0.6;
 const keys = new Set();
 addEventListener('keydown', (e) => keys.add(e.code));
 addEventListener('keyup', (e) => keys.delete(e.code));
 addEventListener('mousedown', () => (dragging = true));
 addEventListener('mouseup', () => (dragging = false));
 addEventListener('mousemove', (e) => {
  if (!dragging) return;
  look.yaw -= e.movementX * 0.003;
  look.pitch = THREE.MathUtils.clamp(look.pitch - e.movementY * 0.003, -1.2, 1.2);
 });
 function updateCamera(dt) {
  if (flags.fly) {
    if (keys.has('KeyW')) sCam += speed * 2 * dt;
    if (keys.has('KeyS')) sCam -= speed * 2 * dt;
  } else {
    sCam += speed * dt;                                        // title-screen auto-drift
  }
  sCam = ((sCam % world.length) + world.length) % world.length;
  const f = world.sample(sCam), ahead = world.sample(Math.min(sCam + 12, world.length));
  camera.position.copy(f.pos).addScaledVector(f.nor, -f.radius * 0.25);
  const target = ahead.pos.clone()
    .addScaledVector(f.bin, Math.sin(look.yaw) * 8)
    .addScaledVector(f.nor, Math.sin(look.pitch) * 8);
  camera.up.copy(f.nor);
  camera.lookAt(target);
 }
 // --- DBG (?dbg=1) — cite these numbers in NOTES; DBG.shot('name') saves a frame ---
 const dbgEl = document.getElementById('dbg');
 let frames = 0, fpsT = 0, fps = 0;
 renderer.info.autoReset = false;                 // three resets info at render end — cache per-frame instead
 const stats = { draws: 0, tris: 0 };
 window.DBG = {
  get draws() { return stats.draws; },
  get tris() { return stats.tris; },
  get fps() { return fps; },
  world,
  shot(name = 'shot') {
    const a = document.createElement('a');
    a.download = `${name}.png`;
    a.href = renderer.domElement.toDataURL('image/png');
    a.click();
  },
 };
 addEventListener('resize', () => {
  camera.aspect = innerWidth / innerHeight;
  camera.updateProjectionMatrix();
  renderer.setSize(innerWidth, innerHeight);
 });
 let last = performance.now();
 function frame(now) {
  const dt = Math.min((now - last) / 1000, 0.05);
  last = now;
  world.update(dt, sCam);
  updateCamera(dt);
  renderer.render(scene, camera);
  stats.draws = renderer.info.render.calls;
  stats.tris = renderer.info.render.triangles;
  renderer.info.reset();
  frames++; fpsT += dt;
  if (fpsT >= 0.5) {
    fps = Math.round(frames / fpsT); frames = 0; fpsT = 0;
    if (flags.dbg && !flags.shots)
      dbgEl.textContent = `${fps} fps · ${DBG.draws} draws · ${(DBG.tris / 1000) | 0}k tris · s=${sCam.toFixed(0)} · ${world.level?.id ?? '?'} ${world.hash?.() ?? ''}`;
  }
  requestAnimationFrame(frame);
 }
 if (flags.dbg && !flags.shots) dbgEl.style.display = 'block';
 requestAnimationFrame(frame);
 export { scene, camera, renderer, bus, flags, world };   // read-only handles for lanes
--- a/web/js/core/bus.js
+++ b/web/js/core/bus.js
@ -0,0 +1,17 @@
 // core/bus.js (Lane F) — event bus. Event names are a contract: TECH.md §Bus.
 export function createBus() {
  const map = new Map();
  return {
    on(name, fn) {
      if (!map.has(name)) map.set(name, new Set());
      map.get(name).add(fn);
      return () => map.get(name)?.delete(fn);
    },
    off(name, fn) { map.get(name)?.delete(fn); },
    emit(name, payload) {
      const set = map.get(name);
      if (set) for (const fn of [...set]) fn(payload);
    },
  };
 }
--- a/web/js/core/flags.js
+++ b/web/js/core/flags.js
@ -0,0 +1,18 @@
 // core/flags.js (Lane F) — URL flags. The table of record lives in TECH.md; add rows there.
 export function parseFlags(search = location.search) {
  const p = new URLSearchParams(search);
  const on = (k) => p.has(k) && p.get(k) !== '0';
  return {
    stub: on('stub'),
    fly: on('fly'),
    dbg: on('dbg'),
    shots: on('shots'),
    mute: on('mute'),
    fakebus: on('fakebus'),
    localassets: p.get('localassets') !== '0',   // ?localassets=0 => empty-manifest boot
    lvl: p.get('lvl') || null,
    seed: p.has('seed') ? (parseInt(p.get('seed'), 10) >>> 0) : null,
    raw: p,
  };
 }
--- a/web/js/core/rng.js
+++ b/web/js/core/rng.js
@ -0,0 +1,31 @@
 // core/rng.js (Lane F) — THE only randomness source in GUTS. qa.sh greps for violators.
 // mulberry32: tiny, fast, deterministic. Same seed => same sequence, forever.
 export function mulberry32(seed) {
  let a = seed >>> 0;
  return function () {
    a |= 0; a = (a + 0x6D2B79F5) | 0;
    let t = Math.imul(a ^ (a >>> 15), 1 | a);
    t = (t + Math.imul(t ^ (t >>> 7), 61 | t)) ^ t;
    return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
  };
 }
 // Named sub-streams so lanes don't perturb each other's sequences:
 // rng('world'), rng('enemies'), ... each is an independent deterministic stream.
 export function createRng(seed) {
  const streams = new Map();
  function hash(str) {
    let h = 2166136261 >>> 0;
    for (let i = 0; i < str.length; i++) { h ^= str.charCodeAt(i); h = Math.imul(h, 16777619); }
    return h >>> 0;
  }
  const rng = (stream = 'main') => {
    if (!streams.has(stream)) streams.set(stream, mulberry32((seed ^ hash(stream)) >>> 0));
    return streams.get(stream);
  };
  rng.seed = seed;
  rng.float = (stream, min = 0, max = 1) => min + rng(stream)() * (max - min);
  rng.int = (stream, min, max) => Math.floor(rng.float(stream, min, max + 1));
  return rng;
 }
--- a/web/js/stub/world_stub.js
+++ b/web/js/stub/world_stub.js
@ -0,0 +1,166 @@
 // stub/world_stub.js (Lane F) — executable spec of THE WORLD CONTRACT (docs/TECH.md).
 // A straight-ish pulsing esophagus tube, analytic everywhere. Lane A replaces this with
 // js/world/index.js; until then every lane builds against this. Keep contract-identical.
 import * as THREE from 'three';
 export const STUB_LEVEL = {
  id: 'STUB', name: 'Stub Esophagus', seed: 20260716,
  segments: [{ biome: 'esophagus', length: 400, radius: { base: 10, wobble: 0.15 }, curviness: 0.3, flow: 14 }],
  arenas: [],
  events: [
    { s: 60,  type: 'spawn', enemy: 'floater', count: 4 },
    { s: 140, type: 'spawn', enemy: 'seeker', count: 3 },
    { s: 200, type: 'checkpoint' },
    { s: 260, type: 'spawn', enemy: 'turret', count: 2 },
  ],
 };
 const BIOME = {   // mirrors ART_BIBLE esophagus row; A's biomes.js is the real registry
  id: 'esophagus', flow: 14, coatDrain: 0.5,
  palette: { tint: 0x1e6e64, rim: 0x5affd2, void: 0x02100d },
  fog: 0.028,
 };
 const WAVE_A = 0.9;        // peristalsis displacement amplitude (units, inward)
 const WAVE_K = 0.22;       // spatial frequency (rad/unit along s)
 const WAVE_W = 3.0;        // angular speed (rad/s)
 const SKIN = 0.6;          // collision safety margin
 export async function createWorld(levelData = STUB_LEVEL, { rng } = {}) {
  const seg = levelData.segments[0];
  const LEN = seg.length, R = seg.radius.base;
  const AX = seg.curviness * 8, AY = seg.curviness * 5;   // gentle analytic centreline
  const KX = 0.020, KY = 0.031;
  // --- centreline & frames (analytic; s ≈ arclength for these gentle amplitudes) ---
  const centre = (s) => new THREE.Vector3(AX * Math.sin(s * KX), AY * Math.sin(s * KY), -s);
  const tangent = (s) => new THREE.Vector3(AX * KX * Math.cos(s * KX), AY * KY * Math.cos(s * KY), -1).normalize();
  function sample(s) {
    const tan = tangent(s);
    const up = new THREE.Vector3(0, 1, 0);
    const nor = up.clone().addScaledVector(tan, -up.dot(tan)).normalize();  // Gram-Schmidt (stable: tube never goes vertical)
    const bin = new THREE.Vector3().crossVectors(tan, nor);
    return { pos: centre(s), tan, nor, bin, radius: radiusAt(s) };
  }
  const radiusAt = (s) => R * (1 + seg.radius.wobble * Math.sin(s * 0.05) * Math.sin(s * 0.013 + 2.1));
  const flowPulse = (s, t) => Math.pow(Math.max(0, Math.sin(WAVE_K * s - WAVE_W * t)), 3);
  // --- geometry: rings along s, uv = (theta/2pi, s), inward-facing ---
  // seam ring vertex is duplicated (RADIAL+1 columns) so uv.x runs 0..1 without wrapping
  // backwards across the last quad (visible streak otherwise).
  const RADIAL = 64, COLS = RADIAL + 1, STEP = 0.5;
  const rings = Math.floor(LEN / STEP) + 1;
  const pos = new Float32Array(rings * COLS * 3);
  const inward = new Float32Array(rings * COLS * 3);
  const uv = new Float32Array(rings * COLS * 2);
  let p = 0, q = 0;
  for (let i = 0; i < rings; i++) {
    const s = i * STEP, f = sample(s);
    for (let j = 0; j < COLS; j++) {
      const th = (j / RADIAL) * Math.PI * 2;
      const dir = f.nor.clone().multiplyScalar(Math.cos(th)).addScaledVector(f.bin, Math.sin(th));
      const v = f.pos.clone().addScaledVector(dir, f.radius);
      pos[p] = v.x; pos[p + 1] = v.y; pos[p + 2] = v.z;
      inward[p] = -dir.x; inward[p + 1] = -dir.y; inward[p + 2] = -dir.z;
      p += 3;
      uv[q++] = j / RADIAL; uv[q++] = s;
    }
  }
  const idx = [];
  for (let i = 0; i < rings - 1; i++)
    for (let j = 0; j < RADIAL; j++) {
      const a = i * COLS + j, b = i * COLS + j + 1, c = a + COLS, d = b + COLS;
      idx.push(a, c, b, b, c, d);   // wound to face inward
    }
  const geo = new THREE.BufferGeometry();
  geo.setAttribute('position', new THREE.BufferAttribute(pos, 3));
  geo.setAttribute('aInward', new THREE.BufferAttribute(inward, 3));
  geo.setAttribute('uv', new THREE.BufferAttribute(uv, 2));
  geo.setIndex(idx);
  const mat = new THREE.ShaderMaterial({
    side: THREE.FrontSide,
    uniforms: {
      uTime: { value: 0 },
      uTint: { value: new THREE.Color(BIOME.palette.tint) },
      uRim: { value: new THREE.Color(BIOME.palette.rim) },
      uVoid: { value: new THREE.Color(BIOME.palette.void) },
      uFog: { value: BIOME.fog },
    },
    vertexShader: /* glsl */`
      attribute vec3 aInward;
      varying vec2 vUv; varying vec3 vN; varying vec3 vView;
      uniform float uTime;
      void main() {
        vUv = uv;
        float pulse = pow(max(0.0, sin(${WAVE_K.toFixed(3)} * uv.y - ${WAVE_W.toFixed(2)} * uTime)), 3.0);
        float breathe = 0.15 * sin(uv.y * 0.7 + uTime * 0.8) * sin(uv.x * 6.2831 * 3.0);
        vec3 disp = position + aInward * (${WAVE_A.toFixed(2)} * pulse + breathe);
        vec4 mv = modelViewMatrix * vec4(disp, 1.0);
        vN = normalize(normalMatrix * aInward);
        vView = -mv.xyz;
        gl_Position = projectionMatrix * mv;
      }`,
    fragmentShader: /* glsl */`
      varying vec2 vUv; varying vec3 vN; varying vec3 vView;
      uniform vec3 uTint; uniform vec3 uRim; uniform vec3 uVoid; uniform float uFog; uniform float uTime;
      void main() {
        // fake SEM detail until Lane D textures land: ridged folds along theta + s striation
        float folds = 0.55 + 0.45 * sin(vUv.x * 6.2831 * 9.0 + sin(vUv.y * 0.9) * 2.0);
        float stria = 0.85 + 0.15 * sin(vUv.y * 2.2);
        vec3 base = uTint * folds * stria * 0.8;
        float fres = pow(1.0 - abs(dot(normalize(vN), normalize(vView))), 2.2);
        vec3 col = base + uRim * fres * 0.9;
        float d = length(vView);
        col = mix(col, uVoid, 1.0 - exp(-uFog * d * 0.55));
        gl_FragColor = vec4(col, 1.0);
      }`,
  });
  const mesh = new THREE.Mesh(geo, mat);
  mesh.frustumCulled = false;   // one chunk; A's real world streams + culls properly
  const group = new THREE.Group();
  group.name = 'world';
  group.add(mesh);
  let time = 0;
  const world = {
    level: levelData,
    length: LEN,
    group,
    sample,
    flowPulse: (s, t = time) => flowPulse(s, t),
    project(v) {
      const s = THREE.MathUtils.clamp(-v.z, 0, LEN);
      const f = sample(s);
      const rel = v.clone().sub(f.pos);
      return { s, theta: Math.atan2(rel.dot(f.bin), rel.dot(f.nor)), rho: rel.length() };
    },
    wallRho: (s, _theta) => radiusAt(s) - WAVE_A - SKIN,
    collide(v, r = 0) {
      const { s, theta, rho } = world.project(v);
      const max = world.wallRho(s, theta) - r;
      if (rho <= max) return null;
      const f = sample(s);
      const dir = f.nor.clone().multiplyScalar(Math.cos(theta)).addScaledVector(f.bin, Math.sin(theta));
      return { push: dir.multiplyScalar(max - rho), kind: 'wall', biome: BIOME.id };
    },
    biomeAt: (_s) => BIOME,
    modeAt: (_s) => 'tube',
    arenaAt: (_s) => null,
    update(dt, _playerS) { time += dt; mat.uniforms.uTime.value = time; },
    hash() {
      let h = 2166136261 >>> 0;
      for (let s = 0; s <= LEN; s += 10) {
        const v = sample(s).pos;
        for (const x of [v.x, v.y, v.z, radiusAt(s)]) {
          h ^= Math.round(x * 1000) & 0xffff; h = Math.imul(h, 16777619);
        }
      }
      return (h >>> 0).toString(16);
    },
    dispose() { geo.dispose(); mat.dispose(); },
  };
  return world;
 }
--- a/web/vendor/addons/controls/PointerLockControls.js
+++ b/web/vendor/addons/controls/PointerLockControls.js
@ -0,0 +1,270 @@
 import {
 	Controls,
 	Euler,
 	Vector3
 } from 'three';
 const _euler = new Euler( 0, 0, 0, 'YXZ' );
 const _vector = new Vector3();
 /**
 * Fires when the user moves the mouse.
 *
 * @event PointerLockControls#change
 * @type {Object}
 */
 const _changeEvent = { type: 'change' };
 /**
 * Fires when the pointer lock status is "locked" (in other words: the mouse is captured).
 *
 * @event PointerLockControls#lock
 * @type {Object}
 */
 const _lockEvent = { type: 'lock' };
 /**
 * Fires when the pointer lock status is "unlocked" (in other words: the mouse is not captured anymore).
 *
 * @event PointerLockControls#unlock
 * @type {Object}
 */
 const _unlockEvent = { type: 'unlock' };
 const _PI_2 = Math.PI / 2;
 /**
 * The implementation of this class is based on the [Pointer Lock API]{@link https://developer.mozilla.org/en-US/docs/Web/API/Pointer_Lock_API}.
 * `PointerLockControls` is a perfect choice for first person 3D games.
 *
 * ```js
 * const controls = new PointerLockControls( camera, document.body );
 *
 * // add event listener to show/hide a UI (e.g. the game's menu)
 * controls.addEventListener( 'lock', function () {
 *
 * 	menu.style.display = 'none';
 *
 * } );
 *
 * controls.addEventListener( 'unlock', function () {
 *
 * 	menu.style.display = 'block';
 *
 * } );
 * ```
 *
 * @augments Controls
 */
 class PointerLockControls extends Controls {
 	/**
 	 * Constructs a new controls instance.
 	 *
 	 * @param {Camera} camera - The camera that is managed by the controls.
 	 * @param {?HTMLDOMElement} domElement - The HTML element used for event listeners.
 	 */
 	constructor( camera, domElement = null ) {
 		super( camera, domElement );
 		/**
 		 * Whether the controls are locked or not.
 		 *
 		 * @type {boolean}
 		 * @readonly
 		 * @default false
 		 */
 		this.isLocked = false;
 		/**
 		 * Camera pitch, lower limit. Range is '[0, Math.PI]' in radians.
 		 *
 		 * @type {number}
 		 * @default 0
 		 */
 		this.minPolarAngle = 0;
 		/**
 		 * Camera pitch, upper limit. Range is '[0, Math.PI]' in radians.
 		 *
 		 * @type {number}
 		 * @default Math.PI
 		 */
 		this.maxPolarAngle = Math.PI;
 		/**
 		 * Multiplier for how much the pointer movement influences the camera rotation.
 		 *
 		 * @type {number}
 		 * @default 1
 		 */
 		this.pointerSpeed = 1.0;
 		// event listeners
 		this._onMouseMove = onMouseMove.bind( this );
 		this._onPointerlockChange = onPointerlockChange.bind( this );
 		this._onPointerlockError = onPointerlockError.bind( this );
 		if ( this.domElement !== null ) {
 			this.connect( this.domElement );
 		}
 	}
 	connect( element ) {
 		super.connect( element );
 		this.domElement.ownerDocument.addEventListener( 'mousemove', this._onMouseMove );
 		this.domElement.ownerDocument.addEventListener( 'pointerlockchange', this._onPointerlockChange );
 		this.domElement.ownerDocument.addEventListener( 'pointerlockerror', this._onPointerlockError );
 	}
 	disconnect() {
 		this.domElement.ownerDocument.removeEventListener( 'mousemove', this._onMouseMove );
 		this.domElement.ownerDocument.removeEventListener( 'pointerlockchange', this._onPointerlockChange );
 		this.domElement.ownerDocument.removeEventListener( 'pointerlockerror', this._onPointerlockError );
 	}
 	dispose() {
 		this.disconnect();
 	}
 	getObject() {
 		console.warn( 'THREE.PointerLockControls: getObject() has been deprecated. Use controls.object instead.' ); // @deprecated r169
 		return this.object;
 	}
 	/**
 	 * Returns the look direction of the camera.
 	 *
 	 * @param {Vector3} v - The target vector that is used to store the method's result.
 	 * @return {Vector3} The normalized direction vector.
 	 */
 	getDirection( v ) {
 		return v.set( 0, 0, - 1 ).applyQuaternion( this.object.quaternion );
 	}
 	/**
 	 * Moves the camera forward parallel to the xz-plane. Assumes camera.up is y-up.
 	 *
 	 * @param {number} distance - The signed distance.
 	 */
 	moveForward( distance ) {
 		if ( this.enabled === false ) return;
 		// move forward parallel to the xz-plane
 		// assumes camera.up is y-up
 		const camera = this.object;
 		_vector.setFromMatrixColumn( camera.matrix, 0 );
 		_vector.crossVectors( camera.up, _vector );
 		camera.position.addScaledVector( _vector, distance );
 	}
 	/**
 	 * Moves the camera sidewards parallel to the xz-plane.
 	 *
 	 * @param {number} distance - The signed distance.
 	 */
 	moveRight( distance ) {
 		if ( this.enabled === false ) return;
 		const camera = this.object;
 		_vector.setFromMatrixColumn( camera.matrix, 0 );
 		camera.position.addScaledVector( _vector, distance );
 	}
 	/**
 	 * Activates the pointer lock.
 	 * 
 	 * @param {boolean} [unadjustedMovement=false] - Disables OS-level adjustment for mouse acceleration, and accesses raw mouse input instead.
 	 * Setting it to true will disable mouse acceleration.
 	 */
 	lock( unadjustedMovement = false ) {
 		this.domElement.requestPointerLock( {
 			unadjustedMovement
 		} );
 	}
 	/**
 	 * Exits the pointer lock.
 	 */
 	unlock() {
 		this.domElement.ownerDocument.exitPointerLock();
 	}
 }
 // event listeners
 function onMouseMove( event ) {
 	if ( this.enabled === false || this.isLocked === false ) return;
 	const camera = this.object;
 	_euler.setFromQuaternion( camera.quaternion );
 	_euler.y -= event.movementX * 0.002 * this.pointerSpeed;
 	_euler.x -= event.movementY * 0.002 * this.pointerSpeed;
 	_euler.x = Math.max( _PI_2 - this.maxPolarAngle, Math.min( _PI_2 - this.minPolarAngle, _euler.x ) );
 	camera.quaternion.setFromEuler( _euler );
 	this.dispatchEvent( _changeEvent );
 }
 function onPointerlockChange() {
 	if ( this.domElement.ownerDocument.pointerLockElement === this.domElement ) {
 		this.dispatchEvent( _lockEvent );
 		this.isLocked = true;
 	} else {
 		this.dispatchEvent( _unlockEvent );
 		this.isLocked = false;
 	}
 }
 function onPointerlockError() {
 	console.error( 'THREE.PointerLockControls: Unable to use Pointer Lock API' );
 }
 export { PointerLockControls };
--- a/web/vendor/addons/loaders/GLTFLoader.js
+++ b/web/vendor/addons/loaders/GLTFLoader.js
--- a/web/vendor/addons/postprocessing/EffectComposer.js
+++ b/web/vendor/addons/postprocessing/EffectComposer.js
@ -0,0 +1,361 @@
 import {
 	Clock,
 	HalfFloatType,
 	NoBlending,
 	Vector2,
 	WebGLRenderTarget
 } from 'three';
 import { CopyShader } from '../shaders/CopyShader.js';
 import { ShaderPass } from './ShaderPass.js';
 import { ClearMaskPass, MaskPass } from './MaskPass.js';
 /**
 * Used to implement post-processing effects in three.js.
 * The class manages a chain of post-processing passes to produce the final visual result.
 * Post-processing passes are executed in order of their addition/insertion.
 * The last pass is automatically rendered to screen.
 *
 * This module can only be used with {@link WebGLRenderer}.
 *
 * ```js
 * const composer = new EffectComposer( renderer );
 *
 * // adding some passes
 * const renderPass = new RenderPass( scene, camera );
 * composer.addPass( renderPass );
 *
 * const glitchPass = new GlitchPass();
 * composer.addPass( glitchPass );
 *
 * const outputPass = new OutputPass()
 * composer.addPass( outputPass );
 *
 * function animate() {
 *
 * 	composer.render(); // instead of renderer.render()
 *
 * }
 * ```
 */
 class EffectComposer {
 	/**
 	 * Constructs a new effect composer.
 	 *
 	 * @param {WebGLRenderer} renderer - The renderer.
 	 * @param {WebGLRenderTarget} [renderTarget] - This render target and a clone will
 	 * be used as the internal read and write buffers. If not given, the composer creates
 	 * the buffers automatically.
 	 */
 	constructor( renderer, renderTarget ) {
 		/**
 		 * The renderer.
 		 *
 		 * @type {WebGLRenderer}
 		 */
 		this.renderer = renderer;
 		this._pixelRatio = renderer.getPixelRatio();
 		if ( renderTarget === undefined ) {
 			const size = renderer.getSize( new Vector2() );
 			this._width = size.width;
 			this._height = size.height;
 			renderTarget = new WebGLRenderTarget( this._width * this._pixelRatio, this._height * this._pixelRatio, { type: HalfFloatType } );
 			renderTarget.texture.name = 'EffectComposer.rt1';
 		} else {
 			this._width = renderTarget.width;
 			this._height = renderTarget.height;
 		}
 		this.renderTarget1 = renderTarget;
 		this.renderTarget2 = renderTarget.clone();
 		this.renderTarget2.texture.name = 'EffectComposer.rt2';
 		/**
 		 * A reference to the internal write buffer. Passes usually write
 		 * their result into this buffer.
 		 *
 		 * @type {WebGLRenderTarget}
 		 */
 		this.writeBuffer = this.renderTarget1;
 		/**
 		 * A reference to the internal read buffer. Passes usually read
 		 * the previous render result from this buffer.
 		 *
 		 * @type {WebGLRenderTarget}
 		 */
 		this.readBuffer = this.renderTarget2;
 		/**
 		 * Whether the final pass is rendered to the screen (default framebuffer) or not.
 		 *
 		 * @type {boolean}
 		 * @default true
 		 */
 		this.renderToScreen = true;
 		/**
 		 * An array representing the (ordered) chain of post-processing passes.
 		 *
 		 * @type {Array<Pass>}
 		 */
 		this.passes = [];
 		/**
 		 * A copy pass used for internal swap operations.
 		 *
 		 * @private
 		 * @type {ShaderPass}
 		 */
 		this.copyPass = new ShaderPass( CopyShader );
 		this.copyPass.material.blending = NoBlending;
 		/**
 		 * The intenral clock for managing time data.
 		 *
 		 * @private
 		 * @type {Clock}
 		 */
 		this.clock = new Clock();
 	}
 	/**
 	 * Swaps the internal read/write buffers.
 	 */
 	swapBuffers() {
 		const tmp = this.readBuffer;
 		this.readBuffer = this.writeBuffer;
 		this.writeBuffer = tmp;
 	}
 	/**
 	 * Adds the given pass to the pass chain.
 	 *
 	 * @param {Pass} pass - The pass to add.
 	 */
 	addPass( pass ) {
 		this.passes.push( pass );
 		pass.setSize( this._width * this._pixelRatio, this._height * this._pixelRatio );
 	}
 	/**
 	 * Inserts the given pass at a given index.
 	 *
 	 * @param {Pass} pass - The pass to insert.
 	 * @param {number} index - The index into the pass chain.
 	 */
 	insertPass( pass, index ) {
 		this.passes.splice( index, 0, pass );
 		pass.setSize( this._width * this._pixelRatio, this._height * this._pixelRatio );
 	}
 	/**
 	 * Removes the given pass from the pass chain.
 	 *
 	 * @param {Pass} pass - The pass to remove.
 	 */
 	removePass( pass ) {
 		const index = this.passes.indexOf( pass );
 		if ( index !== - 1 ) {
 			this.passes.splice( index, 1 );
 		}
 	}
 	/**
 	 * Returns `true` if the pass for the given index is the last enabled pass in the pass chain.
 	 *
 	 * @param {number} passIndex - The pass index.
 	 * @return {boolean} Whether the the pass for the given index is the last pass in the pass chain.
 	 */
 	isLastEnabledPass( passIndex ) {
 		for ( let i = passIndex + 1; i < this.passes.length; i ++ ) {
 			if ( this.passes[ i ].enabled ) {
 				return false;
 			}
 		}
 		return true;
 	}
 	/**
 	 * Executes all enabled post-processing passes in order to produce the final frame.
 	 *
 	 * @param {number} deltaTime - The delta time in seconds. If not given, the composer computes
 	 * its own time delta value.
 	 */
 	render( deltaTime ) {
 		// deltaTime value is in seconds
 		if ( deltaTime === undefined ) {
 			deltaTime = this.clock.getDelta();
 		}
 		const currentRenderTarget = this.renderer.getRenderTarget();
 		let maskActive = false;
 		for ( let i = 0, il = this.passes.length; i < il; i ++ ) {
 			const pass = this.passes[ i ];
 			if ( pass.enabled === false ) continue;
 			pass.renderToScreen = ( this.renderToScreen && this.isLastEnabledPass( i ) );
 			pass.render( this.renderer, this.writeBuffer, this.readBuffer, deltaTime, maskActive );
 			if ( pass.needsSwap ) {
 				if ( maskActive ) {
 					const context = this.renderer.getContext();
 					const stencil = this.renderer.state.buffers.stencil;
 					//context.stencilFunc( context.NOTEQUAL, 1, 0xffffffff );
 					stencil.setFunc( context.NOTEQUAL, 1, 0xffffffff );
 					this.copyPass.render( this.renderer, this.writeBuffer, this.readBuffer, deltaTime );
 					//context.stencilFunc( context.EQUAL, 1, 0xffffffff );
 					stencil.setFunc( context.EQUAL, 1, 0xffffffff );
 				}
 				this.swapBuffers();
 			}
 			if ( MaskPass !== undefined ) {
 				if ( pass instanceof MaskPass ) {
 					maskActive = true;
 				} else if ( pass instanceof ClearMaskPass ) {
 					maskActive = false;
 				}
 			}
 		}
 		this.renderer.setRenderTarget( currentRenderTarget );
 	}
 	/**
 	 * Resets the internal state of the EffectComposer.
 	 *
 	 * @param {WebGLRenderTarget} [renderTarget] - This render target has the same purpose like
 	 * the one from the constructor. If set, it is used to setup the read and write buffers.
 	 */
 	reset( renderTarget ) {
 		if ( renderTarget === undefined ) {
 			const size = this.renderer.getSize( new Vector2() );
 			this._pixelRatio = this.renderer.getPixelRatio();
 			this._width = size.width;
 			this._height = size.height;
 			renderTarget = this.renderTarget1.clone();
 			renderTarget.setSize( this._width * this._pixelRatio, this._height * this._pixelRatio );
 		}
 		this.renderTarget1.dispose();
 		this.renderTarget2.dispose();
 		this.renderTarget1 = renderTarget;
 		this.renderTarget2 = renderTarget.clone();
 		this.writeBuffer = this.renderTarget1;
 		this.readBuffer = this.renderTarget2;
 	}
 	/**
 	 * Resizes the internal read and write buffers as well as all passes. Similar to {@link WebGLRenderer#setSize},
 	 * this method honors the current pixel ration.
 	 *
 	 * @param {number} width - The width in logical pixels.
 	 * @param {number} height - The height in logical pixels.
 	 */
 	setSize( width, height ) {
 		this._width = width;
 		this._height = height;
 		const effectiveWidth = this._width * this._pixelRatio;
 		const effectiveHeight = this._height * this._pixelRatio;
 		this.renderTarget1.setSize( effectiveWidth, effectiveHeight );
 		this.renderTarget2.setSize( effectiveWidth, effectiveHeight );
 		for ( let i = 0; i < this.passes.length; i ++ ) {
 			this.passes[ i ].setSize( effectiveWidth, effectiveHeight );
 		}
 	}
 	/**
 	 * Sets device pixel ratio. This is usually used for HiDPI device to prevent blurring output.
 	 * Setting the pixel ratio will automatically resize the composer.
 	 *
 	 * @param {number} pixelRatio - The pixel ratio to set.
 	 */
 	setPixelRatio( pixelRatio ) {
 		this._pixelRatio = pixelRatio;
 		this.setSize( this._width, this._height );
 	}
 	/**
 	 * Frees the GPU-related resources allocated by this instance. Call this
 	 * method whenever the composer is no longer used in your app.
 	 */
 	dispose() {
 		this.renderTarget1.dispose();
 		this.renderTarget2.dispose();
 		this.copyPass.dispose();
 	}
 }
 export { EffectComposer };
--- a/web/vendor/addons/postprocessing/MaskPass.js
+++ b/web/vendor/addons/postprocessing/MaskPass.js
@ -0,0 +1,194 @@
 import { Pass } from './Pass.js';
 /**
 * This pass can be used to define a mask during post processing.
 * Meaning only areas of subsequent post processing are affected
 * which lie in the masking area of this pass. Internally, the masking
 * is implemented with the stencil buffer.
 *
 * ```js
 * const maskPass = new MaskPass( scene, camera );
 * composer.addPass( maskPass );
 * ```
 *
 * @augments Pass
 */
 class MaskPass extends Pass {
 	/**
 	 * Constructs a new mask pass.
 	 *
 	 * @param {Scene} scene - The 3D objects in this scene will define the mask.
 	 * @param {Camera} camera - The camera.
 	 */
 	constructor( scene, camera ) {
 		super();
 		/**
 		 * The scene that defines the mask.
 		 *
 		 * @type {Scene}
 		 */
 		this.scene = scene;
 		/**
 		 * The camera.
 		 *
 		 * @type {Camera}
 		 */
 		this.camera = camera;
 		/**
 		 * Overwritten to perform a clear operation by default.
 		 *
 		 * @type {boolean}
 		 * @default true
 		 */
 		this.clear = true;
 		/**
 		 * Overwritten to disable the swap.
 		 *
 		 * @type {boolean}
 		 * @default false
 		 */
 		this.needsSwap = false;
 		/**
 		 * Whether to inverse the mask or not.
 		 *
 		 * @type {boolean}
 		 * @default false
 		 */
 		this.inverse = false;
 	}
 	/**
 	 * Performs a mask pass with the configured scene and camera.
 	 *
 	 * @param {WebGLRenderer} renderer - The renderer.
 	 * @param {WebGLRenderTarget} writeBuffer - The write buffer. This buffer is intended as the rendering
 	 * destination for the pass.
 	 * @param {WebGLRenderTarget} readBuffer - The read buffer. The pass can access the result from the
 	 * previous pass from this buffer.
 	 * @param {number} deltaTime - The delta time in seconds.
 	 * @param {boolean} maskActive - Whether masking is active or not.
 	 */
 	render( renderer, writeBuffer, readBuffer /*, deltaTime, maskActive */ ) {
 		const context = renderer.getContext();
 		const state = renderer.state;
 		// don't update color or depth
 		state.buffers.color.setMask( false );
 		state.buffers.depth.setMask( false );
 		// lock buffers
 		state.buffers.color.setLocked( true );
 		state.buffers.depth.setLocked( true );
 		// set up stencil
 		let writeValue, clearValue;
 		if ( this.inverse ) {
 			writeValue = 0;
 			clearValue = 1;
 		} else {
 			writeValue = 1;
 			clearValue = 0;
 		}
 		state.buffers.stencil.setTest( true );
 		state.buffers.stencil.setOp( context.REPLACE, context.REPLACE, context.REPLACE );
 		state.buffers.stencil.setFunc( context.ALWAYS, writeValue, 0xffffffff );
 		state.buffers.stencil.setClear( clearValue );
 		state.buffers.stencil.setLocked( true );
 		// draw into the stencil buffer
 		renderer.setRenderTarget( readBuffer );
 		if ( this.clear ) renderer.clear();
 		renderer.render( this.scene, this.camera );
 		renderer.setRenderTarget( writeBuffer );
 		if ( this.clear ) renderer.clear();
 		renderer.render( this.scene, this.camera );
 		// unlock color and depth buffer and make them writable for subsequent rendering/clearing
 		state.buffers.color.setLocked( false );
 		state.buffers.depth.setLocked( false );
 		state.buffers.color.setMask( true );
 		state.buffers.depth.setMask( true );
 		// only render where stencil is set to 1
 		state.buffers.stencil.setLocked( false );
 		state.buffers.stencil.setFunc( context.EQUAL, 1, 0xffffffff ); // draw if == 1
 		state.buffers.stencil.setOp( context.KEEP, context.KEEP, context.KEEP );
 		state.buffers.stencil.setLocked( true );
 	}
 }
 /**
 * This pass can be used to clear a mask previously defined with {@link MaskPass}.
 *
 * ```js
 * const clearPass = new ClearMaskPass();
 * composer.addPass( clearPass );
 * ```
 *
 * @augments Pass
 */
 class ClearMaskPass extends Pass {
 	/**
 	 * Constructs a new clear mask pass.
 	 */
 	constructor() {
 		super();
 		/**
 		 * Overwritten to disable the swap.
 		 *
 		 * @type {boolean}
 		 * @default false
 		 */
 		this.needsSwap = false;
 	}
 	/**
 	 * Performs the clear of the currently defined mask.
 	 *
 	 * @param {WebGLRenderer} renderer - The renderer.
 	 * @param {WebGLRenderTarget} writeBuffer - The write buffer. This buffer is intended as the rendering
 	 * destination for the pass.
 	 * @param {WebGLRenderTarget} readBuffer - The read buffer. The pass can access the result from the
 	 * previous pass from this buffer.
 	 * @param {number} deltaTime - The delta time in seconds.
 	 * @param {boolean} maskActive - Whether masking is active or not.
 	 */
 	render( renderer /*, writeBuffer, readBuffer, deltaTime, maskActive */ ) {
 		renderer.state.buffers.stencil.setLocked( false );
 		renderer.state.buffers.stencil.setTest( false );
 	}
 }
 export { MaskPass, ClearMaskPass };
--- a/web/vendor/addons/postprocessing/OutputPass.js
+++ b/web/vendor/addons/postprocessing/OutputPass.js
@ -0,0 +1,138 @@
 import {
 	ColorManagement,
 	RawShaderMaterial,
 	UniformsUtils,
 	LinearToneMapping,
 	ReinhardToneMapping,
 	CineonToneMapping,
 	AgXToneMapping,
 	ACESFilmicToneMapping,
 	NeutralToneMapping,
 	CustomToneMapping,
 	SRGBTransfer
 } from 'three';
 import { Pass, FullScreenQuad } from './Pass.js';
 import { OutputShader } from '../shaders/OutputShader.js';
 /**
 * This pass is responsible for including tone mapping and color space conversion
 * into your pass chain. In most cases, this pass should be included at the end
 * of each pass chain. If a pass requires sRGB input (e.g. like FXAA), the pass
 * must follow `OutputPass` in the pass chain.
 *
 * The tone mapping and color space settings are extracted from the renderer.
 *
 * ```js
 * const outputPass = new OutputPass();
 * composer.addPass( outputPass );
 * ```
 *
 * @augments Pass
 */
 class OutputPass extends Pass {
 	/**
 	 * Constructs a new output pass.
 	 */
 	constructor() {
 		super();
 		/**
 		 * The pass uniforms.
 		 *
 		 * @type {Object}
 		 */
 		this.uniforms = UniformsUtils.clone( OutputShader.uniforms );
 		/**
 		 * The pass material.
 		 *
 		 * @type {RawShaderMaterial}
 		 */
 		this.material = new RawShaderMaterial( {
 			name: OutputShader.name,
 			uniforms: this.uniforms,
 			vertexShader: OutputShader.vertexShader,
 			fragmentShader: OutputShader.fragmentShader
 		} );
 		// internals
 		this._fsQuad = new FullScreenQuad( this.material );
 		this._outputColorSpace = null;
 		this._toneMapping = null;
 	}
 	/**
 	 * Performs the output pass.
 	 *
 	 * @param {WebGLRenderer} renderer - The renderer.
 	 * @param {WebGLRenderTarget} writeBuffer - The write buffer. This buffer is intended as the rendering
 	 * destination for the pass.
 	 * @param {WebGLRenderTarget} readBuffer - The read buffer. The pass can access the result from the
 	 * previous pass from this buffer.
 	 * @param {number} deltaTime - The delta time in seconds.
 	 * @param {boolean} maskActive - Whether masking is active or not.
 	 */
 	render( renderer, writeBuffer, readBuffer/*, deltaTime, maskActive */ ) {
 		this.uniforms[ 'tDiffuse' ].value = readBuffer.texture;
 		this.uniforms[ 'toneMappingExposure' ].value = renderer.toneMappingExposure;
 		// rebuild defines if required
 		if ( this._outputColorSpace !== renderer.outputColorSpace || this._toneMapping !== renderer.toneMapping ) {
 			this._outputColorSpace = renderer.outputColorSpace;
 			this._toneMapping = renderer.toneMapping;
 			this.material.defines = {};
 			if ( ColorManagement.getTransfer( this._outputColorSpace ) === SRGBTransfer ) this.material.defines.SRGB_TRANSFER = '';
 			if ( this._toneMapping === LinearToneMapping ) this.material.defines.LINEAR_TONE_MAPPING = '';
 			else if ( this._toneMapping === ReinhardToneMapping ) this.material.defines.REINHARD_TONE_MAPPING = '';
 			else if ( this._toneMapping === CineonToneMapping ) this.material.defines.CINEON_TONE_MAPPING = '';
 			else if ( this._toneMapping === ACESFilmicToneMapping ) this.material.defines.ACES_FILMIC_TONE_MAPPING = '';
 			else if ( this._toneMapping === AgXToneMapping ) this.material.defines.AGX_TONE_MAPPING = '';
 			else if ( this._toneMapping === NeutralToneMapping ) this.material.defines.NEUTRAL_TONE_MAPPING = '';
 			else if ( this._toneMapping === CustomToneMapping ) this.material.defines.CUSTOM_TONE_MAPPING = '';
 			this.material.needsUpdate = true;
 		}
 		//
 		if ( this.renderToScreen === true ) {
 			renderer.setRenderTarget( null );
 			this._fsQuad.render( renderer );
 		} else {
 			renderer.setRenderTarget( writeBuffer );
 			if ( this.clear ) renderer.clear( renderer.autoClearColor, renderer.autoClearDepth, renderer.autoClearStencil );
 			this._fsQuad.render( renderer );
 		}
 	}
 	/**
 	 * Frees the GPU-related resources allocated by this instance. Call this
 	 * method whenever the pass is no longer used in your app.
 	 */
 	dispose() {
 		this.material.dispose();
 		this._fsQuad.dispose();
 	}
 }
 export { OutputPass };
--- a/web/vendor/addons/postprocessing/Pass.js
+++ b/web/vendor/addons/postprocessing/Pass.js
@ -0,0 +1,189 @@
 import {
 	BufferGeometry,
 	Float32BufferAttribute,
 	OrthographicCamera,
 	Mesh
 } from 'three';
 /**
 * Abstract base class for all post processing passes.
 *
 * This module is only relevant for post processing with {@link WebGLRenderer}.
 *
 * @abstract
 */
 class Pass {
 	/**
 	 * Constructs a new pass.
 	 */
 	constructor() {
 		/**
 		 * This flag can be used for type testing.
 		 *
 		 * @type {boolean}
 		 * @readonly
 		 * @default true
 		 */
 		this.isPass = true;
 		/**
 		 * If set to `true`, the pass is processed by the composer.
 		 *
 		 * @type {boolean}
 		 * @default true
 		 */
 		this.enabled = true;
 		/**
 		 * If set to `true`, the pass indicates to swap read and write buffer after rendering.
 		 *
 		 * @type {boolean}
 		 * @default true
 		 */
 		this.needsSwap = true;
 		/**
 		 * If set to `true`, the pass clears its buffer before rendering
 		 *
 		 * @type {boolean}
 		 * @default false
 		 */
 		this.clear = false;
 		/**
 		 * If set to `true`, the result of the pass is rendered to screen. The last pass in the composers
 		 * pass chain gets automatically rendered to screen, no matter how this property is configured.
 		 *
 		 * @type {boolean}
 		 * @default false
 		 */
 		this.renderToScreen = false;
 	}
 	/**
 	 * Sets the size of the pass.
 	 *
 	 * @abstract
 	 * @param {number} width - The width to set.
 	 * @param {number} height - The width to set.
 	 */
 	setSize( /* width, height */ ) {}
 	/**
 	 * This method holds the render logic of a pass. It must be implemented in all derived classes.
 	 *
 	 * @abstract
 	 * @param {WebGLRenderer} renderer - The renderer.
 	 * @param {WebGLRenderTarget} writeBuffer - The write buffer. This buffer is intended as the rendering
 	 * destination for the pass.
 	 * @param {WebGLRenderTarget} readBuffer - The read buffer. The pass can access the result from the
 	 * previous pass from this buffer.
 	 * @param {number} deltaTime - The delta time in seconds.
 	 * @param {boolean} maskActive - Whether masking is active or not.
 	 */
 	render( /* renderer, writeBuffer, readBuffer, deltaTime, maskActive */ ) {
 		console.error( 'THREE.Pass: .render() must be implemented in derived pass.' );
 	}
 	/**
 	 * Frees the GPU-related resources allocated by this instance. Call this
 	 * method whenever the pass is no longer used in your app.
 	 *
 	 * @abstract
 	 */
 	dispose() {}
 }
 // Helper for passes that need to fill the viewport with a single quad.
 const _camera = new OrthographicCamera( - 1, 1, 1, - 1, 0, 1 );
 // https://github.com/mrdoob/three.js/pull/21358
 class FullscreenTriangleGeometry extends BufferGeometry {
 	constructor() {
 		super();
 		this.setAttribute( 'position', new Float32BufferAttribute( [ - 1, 3, 0, - 1, - 1, 0, 3, - 1, 0 ], 3 ) );
 		this.setAttribute( 'uv', new Float32BufferAttribute( [ 0, 2, 0, 0, 2, 0 ], 2 ) );
 	}
 }
 const _geometry = new FullscreenTriangleGeometry();
 /**
 * This module is a helper for passes which need to render a full
 * screen effect which is quite common in context of post processing.
 *
 * The intended usage is to reuse a single full screen quad for rendering
 * subsequent passes by just reassigning the `material` reference.
 *
 * This module can only be used with {@link WebGLRenderer}.
 *
 * @augments Mesh
 */
 class FullScreenQuad {
 	/**
 	 * Constructs a new full screen quad.
 	 *
 	 * @param {?Material} material - The material to render te full screen quad with.
 	 */
 	constructor( material ) {
 		this._mesh = new Mesh( _geometry, material );
 	}
 	/**
 	 * Frees the GPU-related resources allocated by this instance. Call this
 	 * method whenever the instance is no longer used in your app.
 	 */
 	dispose() {
 		this._mesh.geometry.dispose();
 	}
 	/**
 	 * Renders the full screen quad.
 	 *
 	 * @param {WebGLRenderer} renderer - The renderer.
 	 */
 	render( renderer ) {
 		renderer.render( this._mesh, _camera );
 	}
 	/**
 	 * The quad's material.
 	 *
 	 * @type {?Material}
 	 */
 	get material() {
 		return this._mesh.material;
 	}
 	set material( value ) {
 		this._mesh.material = value;
 	}
 }
 export { Pass, FullScreenQuad };
--- a/web/vendor/addons/postprocessing/RenderPass.js
+++ b/web/vendor/addons/postprocessing/RenderPass.js
@ -0,0 +1,182 @@
 import {
 	Color
 } from 'three';
 import { Pass } from './Pass.js';
 /**
 * This class represents a render pass. It takes a camera and a scene and produces
 * a beauty pass for subsequent post processing effects.
 *
 * ```js
 * const renderPass = new RenderPass( scene, camera );
 * composer.addPass( renderPass );
 * ```
 *
 * @augments Pass
 */
 class RenderPass extends Pass {
 	/**
 	 * Constructs a new render pass.
 	 *
 	 * @param {Scene} scene - The scene to render.
 	 * @param {Camera} camera - The camera.
 	 * @param {?Material} [overrideMaterial=null] - The override material. If set, this material is used
 	 * for all objects in the scene.
 	 * @param {?(number|Color|string)} [clearColor=null] - The clear color of the render pass.
 	 * @param {?number} [clearAlpha=null] - The clear alpha of the render pass.
 	 */
 	constructor( scene, camera, overrideMaterial = null, clearColor = null, clearAlpha = null ) {
 		super();
 		/**
 		 * The scene to render.
 		 *
 		 * @type {Scene}
 		 */
 		this.scene = scene;
 		/**
 		 * The camera.
 		 *
 		 * @type {Camera}
 		 */
 		this.camera = camera;
 		/**
 		 * The override material. If set, this material is used
 		 * for all objects in the scene.
 		 *
 		 * @type {?Material}
 		 * @default null
 		 */
 		this.overrideMaterial = overrideMaterial;
 		/**
 		 * The clear color of the render pass.
 		 *
 		 * @type {?(number|Color|string)}
 		 * @default null
 		 */
 		this.clearColor = clearColor;
 		/**
 		 * The clear alpha of the render pass.
 		 *
 		 * @type {?number}
 		 * @default null
 		 */
 		this.clearAlpha = clearAlpha;
 		/**
 		 * Overwritten to perform a clear operation by default.
 		 *
 		 * @type {boolean}
 		 * @default true
 		 */
 		this.clear = true;
 		/**
 		 * If set to `true`, only the depth can be cleared when `clear` is to `false`.
 		 *
 		 * @type {boolean}
 		 * @default false
 		 */
 		this.clearDepth = false;
 		/**
 		 * Overwritten to disable the swap.
 		 *
 		 * @type {boolean}
 		 * @default false
 		 */
 		this.needsSwap = false;
 		this._oldClearColor = new Color();
 	}
 	/**
 	 * Performs a beauty pass with the configured scene and camera.
 	 *
 	 * @param {WebGLRenderer} renderer - The renderer.
 	 * @param {WebGLRenderTarget} writeBuffer - The write buffer. This buffer is intended as the rendering
 	 * destination for the pass.
 	 * @param {WebGLRenderTarget} readBuffer - The read buffer. The pass can access the result from the
 	 * previous pass from this buffer.
 	 * @param {number} deltaTime - The delta time in seconds.
 	 * @param {boolean} maskActive - Whether masking is active or not.
 	 */
 	render( renderer, writeBuffer, readBuffer /*, deltaTime, maskActive */ ) {
 		const oldAutoClear = renderer.autoClear;
 		renderer.autoClear = false;
 		let oldClearAlpha, oldOverrideMaterial;
 		if ( this.overrideMaterial !== null ) {
 			oldOverrideMaterial = this.scene.overrideMaterial;
 			this.scene.overrideMaterial = this.overrideMaterial;
 		}
 		if ( this.clearColor !== null ) {
 			renderer.getClearColor( this._oldClearColor );
 			renderer.setClearColor( this.clearColor, renderer.getClearAlpha() );
 		}
 		if ( this.clearAlpha !== null ) {
 			oldClearAlpha = renderer.getClearAlpha();
 			renderer.setClearAlpha( this.clearAlpha );
 		}
 		if ( this.clearDepth == true ) {
 			renderer.clearDepth();
 		}
 		renderer.setRenderTarget( this.renderToScreen ? null : readBuffer );
 		if ( this.clear === true ) {
 			// TODO: Avoid using autoClear properties, see https://github.com/mrdoob/three.js/pull/15571#issuecomment-465669600
 			renderer.clear( renderer.autoClearColor, renderer.autoClearDepth, renderer.autoClearStencil );
 		}
 		renderer.render( this.scene, this.camera );
 		// restore
 		if ( this.clearColor !== null ) {
 			renderer.setClearColor( this._oldClearColor );
 		}
 		if ( this.clearAlpha !== null ) {
 			renderer.setClearAlpha( oldClearAlpha );
 		}
 		if ( this.overrideMaterial !== null ) {
 			this.scene.overrideMaterial = oldOverrideMaterial;
 		}
 		renderer.autoClear = oldAutoClear;
 	}
 }
 export { RenderPass };
--- a/web/vendor/addons/postprocessing/ShaderPass.js
+++ b/web/vendor/addons/postprocessing/ShaderPass.js
@ -0,0 +1,134 @@
 import {
 	ShaderMaterial,
 	UniformsUtils
 } from 'three';
 import { Pass, FullScreenQuad } from './Pass.js';
 /**
 * This pass can be used to create a post processing effect
 * with a raw GLSL shader object. Useful for implementing custom
 * effects.
 *
 * ```js
 * const fxaaPass = new ShaderPass( FXAAShader );
 * composer.addPass( fxaaPass );
 * ```
 *
 * @augments Pass
 */
 class ShaderPass extends Pass {
 	/**
 	 * Constructs a new shader pass.
 	 *
 	 * @param {Object|ShaderMaterial} [shader] - A shader object holding vertex and fragment shader as well as
 	 * defines and uniforms. It's also valid to pass a custom shader material.
 	 * @param {string} [textureID='tDiffuse'] - The name of the texture uniform that should sample
 	 * the read buffer.
 	 */
 	constructor( shader, textureID = 'tDiffuse' ) {
 		super();
 		/**
 		 * The name of the texture uniform that should sample the read buffer.
 		 *
 		 * @type {string}
 		 * @default 'tDiffuse'
 		 */
 		this.textureID = textureID;
 		/**
 		 * The pass uniforms.
 		 *
 		 * @type {?Object}
 		 */
 		this.uniforms = null;
 		/**
 		 * The pass material.
 		 *
 		 * @type {?ShaderMaterial}
 		 */
 		this.material = null;
 		if ( shader instanceof ShaderMaterial ) {
 			this.uniforms = shader.uniforms;
 			this.material = shader;
 		} else if ( shader ) {
 			this.uniforms = UniformsUtils.clone( shader.uniforms );
 			this.material = new ShaderMaterial( {
 				name: ( shader.name !== undefined ) ? shader.name : 'unspecified',
 				defines: Object.assign( {}, shader.defines ),
 				uniforms: this.uniforms,
 				vertexShader: shader.vertexShader,
 				fragmentShader: shader.fragmentShader
 			} );
 		}
 		// internals
 		this._fsQuad = new FullScreenQuad( this.material );
 	}
 	/**
 	 * Performs the shader pass.
 	 *
 	 * @param {WebGLRenderer} renderer - The renderer.
 	 * @param {WebGLRenderTarget} writeBuffer - The write buffer. This buffer is intended as the rendering
 	 * destination for the pass.
 	 * @param {WebGLRenderTarget} readBuffer - The read buffer. The pass can access the result from the
 	 * previous pass from this buffer.
 	 * @param {number} deltaTime - The delta time in seconds.
 	 * @param {boolean} maskActive - Whether masking is active or not.
 	 */
 	render( renderer, writeBuffer, readBuffer /*, deltaTime, maskActive */ ) {
 		if ( this.uniforms[ this.textureID ] ) {
 			this.uniforms[ this.textureID ].value = readBuffer.texture;
 		}
 		this._fsQuad.material = this.material;
 		if ( this.renderToScreen ) {
 			renderer.setRenderTarget( null );
 			this._fsQuad.render( renderer );
 		} else {
 			renderer.setRenderTarget( writeBuffer );
 			// TODO: Avoid using autoClear properties, see https://github.com/mrdoob/three.js/pull/15571#issuecomment-465669600
 			if ( this.clear ) renderer.clear( renderer.autoClearColor, renderer.autoClearDepth, renderer.autoClearStencil );
 			this._fsQuad.render( renderer );
 		}
 	}
 	/**
 	 * Frees the GPU-related resources allocated by this instance. Call this
 	 * method whenever the pass is no longer used in your app.
 	 */
 	dispose() {
 		this.material.dispose();
 		this._fsQuad.dispose();
 	}
 }
 export { ShaderPass };
--- a/web/vendor/addons/postprocessing/UnrealBloomPass.js
+++ b/web/vendor/addons/postprocessing/UnrealBloomPass.js
@ -0,0 +1,491 @@
 import {
 	AdditiveBlending,
 	Color,
 	HalfFloatType,
 	MeshBasicMaterial,
 	ShaderMaterial,
 	UniformsUtils,
 	Vector2,
 	Vector3,
 	WebGLRenderTarget
 } from 'three';
 import { Pass, FullScreenQuad } from './Pass.js';
 import { CopyShader } from '../shaders/CopyShader.js';
 import { LuminosityHighPassShader } from '../shaders/LuminosityHighPassShader.js';
 /**
 * This pass is inspired by the bloom pass of Unreal Engine. It creates a
 * mip map chain of bloom textures and blurs them with different radii. Because
 * of the weighted combination of mips, and because larger blurs are done on
 * higher mips, this effect provides good quality and performance.
 *
 * When using this pass, tone mapping must be enabled in the renderer settings.
 *
 * Reference:
 * - [Bloom in Unreal Engine]{@link https://docs.unrealengine.com/latest/INT/Engine/Rendering/PostProcessEffects/Bloom/}
 *
 * ```js
 * const resolution = new THREE.Vector2( window.innerWidth, window.innerHeight );
 * const bloomPass = new UnrealBloomPass( resolution, 1.5, 0.4, 0.85 );
 * composer.addPass( bloomPass );
 * ```
 *
 * @augments Pass
 */
 class UnrealBloomPass extends Pass {
 	/**
 	 * Constructs a new Unreal Bloom pass.
 	 *
 	 * @param {Vector2} [resolution] - The effect's resolution.
 	 * @param {number} [strength=1] - The Bloom strength.
 	 * @param {number} radius - The Bloom radius.
 	 * @param {number} threshold - The luminance threshold limits which bright areas contribute to the Bloom effect.
 	 */
 	constructor( resolution, strength = 1, radius, threshold ) {
 		super();
 		/**
 		 * The Bloom strength.
 		 *
 		 * @type {number}
 		 * @default 1
 		 */
 		this.strength = strength;
 		/**
 		 * The Bloom radius.
 		 *
 		 * @type {number}
 		 */
 		this.radius = radius;
 		/**
 		 * The luminance threshold limits which bright areas contribute to the Bloom effect.
 		 *
 		 * @type {number}
 		 */
 		this.threshold = threshold;
 		/**
 		 * The effect's resolution.
 		 *
 		 * @type {Vector2}
 		 * @default (256,256)
 		 */
 		this.resolution = ( resolution !== undefined ) ? new Vector2( resolution.x, resolution.y ) : new Vector2( 256, 256 );
 		/**
 		 * The effect's clear color
 		 *
 		 * @type {Color}
 		 * @default (0,0,0)
 		 */
 		this.clearColor = new Color( 0, 0, 0 );
 		/**
 		 * Overwritten to disable the swap.
 		 *
 		 * @type {boolean}
 		 * @default false
 		 */
 		this.needsSwap = false;
 		// internals
 		// render targets
 		this.renderTargetsHorizontal = [];
 		this.renderTargetsVertical = [];
 		this.nMips = 5;
 		let resx = Math.round( this.resolution.x / 2 );
 		let resy = Math.round( this.resolution.y / 2 );
 		this.renderTargetBright = new WebGLRenderTarget( resx, resy, { type: HalfFloatType } );
 		this.renderTargetBright.texture.name = 'UnrealBloomPass.bright';
 		this.renderTargetBright.texture.generateMipmaps = false;
 		for ( let i = 0; i < this.nMips; i ++ ) {
 			const renderTargetHorizontal = new WebGLRenderTarget( resx, resy, { type: HalfFloatType } );
 			renderTargetHorizontal.texture.name = 'UnrealBloomPass.h' + i;
 			renderTargetHorizontal.texture.generateMipmaps = false;
 			this.renderTargetsHorizontal.push( renderTargetHorizontal );
 			const renderTargetVertical = new WebGLRenderTarget( resx, resy, { type: HalfFloatType } );
 			renderTargetVertical.texture.name = 'UnrealBloomPass.v' + i;
 			renderTargetVertical.texture.generateMipmaps = false;
 			this.renderTargetsVertical.push( renderTargetVertical );
 			resx = Math.round( resx / 2 );
 			resy = Math.round( resy / 2 );
 		}
 		// luminosity high pass material
 		const highPassShader = LuminosityHighPassShader;
 		this.highPassUniforms = UniformsUtils.clone( highPassShader.uniforms );
 		this.highPassUniforms[ 'luminosityThreshold' ].value = threshold;
 		this.highPassUniforms[ 'smoothWidth' ].value = 0.01;
 		this.materialHighPassFilter = new ShaderMaterial( {
 			uniforms: this.highPassUniforms,
 			vertexShader: highPassShader.vertexShader,
 			fragmentShader: highPassShader.fragmentShader
 		} );
 		// gaussian blur materials
 		this.separableBlurMaterials = [];
 		const kernelSizeArray = [ 3, 5, 7, 9, 11 ];
 		resx = Math.round( this.resolution.x / 2 );
 		resy = Math.round( this.resolution.y / 2 );
 		for ( let i = 0; i < this.nMips; i ++ ) {
 			this.separableBlurMaterials.push( this._getSeparableBlurMaterial( kernelSizeArray[ i ] ) );
 			this.separableBlurMaterials[ i ].uniforms[ 'invSize' ].value = new Vector2( 1 / resx, 1 / resy );
 			resx = Math.round( resx / 2 );
 			resy = Math.round( resy / 2 );
 		}
 		// composite material
 		this.compositeMaterial = this._getCompositeMaterial( this.nMips );
 		this.compositeMaterial.uniforms[ 'blurTexture1' ].value = this.renderTargetsVertical[ 0 ].texture;
 		this.compositeMaterial.uniforms[ 'blurTexture2' ].value = this.renderTargetsVertical[ 1 ].texture;
 		this.compositeMaterial.uniforms[ 'blurTexture3' ].value = this.renderTargetsVertical[ 2 ].texture;
 		this.compositeMaterial.uniforms[ 'blurTexture4' ].value = this.renderTargetsVertical[ 3 ].texture;
 		this.compositeMaterial.uniforms[ 'blurTexture5' ].value = this.renderTargetsVertical[ 4 ].texture;
 		this.compositeMaterial.uniforms[ 'bloomStrength' ].value = strength;
 		this.compositeMaterial.uniforms[ 'bloomRadius' ].value = 0.1;
 		const bloomFactors = [ 1.0, 0.8, 0.6, 0.4, 0.2 ];
 		this.compositeMaterial.uniforms[ 'bloomFactors' ].value = bloomFactors;
 		this.bloomTintColors = [ new Vector3( 1, 1, 1 ), new Vector3( 1, 1, 1 ), new Vector3( 1, 1, 1 ), new Vector3( 1, 1, 1 ), new Vector3( 1, 1, 1 ) ];
 		this.compositeMaterial.uniforms[ 'bloomTintColors' ].value = this.bloomTintColors;
 		// blend material
 		this.copyUniforms = UniformsUtils.clone( CopyShader.uniforms );
 		this.blendMaterial = new ShaderMaterial( {
 			uniforms: this.copyUniforms,
 			vertexShader: CopyShader.vertexShader,
 			fragmentShader: CopyShader.fragmentShader,
 			blending: AdditiveBlending,
 			depthTest: false,
 			depthWrite: false,
 			transparent: true
 		} );
 		this._oldClearColor = new Color();
 		this._oldClearAlpha = 1;
 		this._basic = new MeshBasicMaterial();
 		this._fsQuad = new FullScreenQuad( null );
 	}
 	/**
 	 * Frees the GPU-related resources allocated by this instance. Call this
 	 * method whenever the pass is no longer used in your app.
 	 */
 	dispose() {
 		for ( let i = 0; i < this.renderTargetsHorizontal.length; i ++ ) {
 			this.renderTargetsHorizontal[ i ].dispose();
 		}
 		for ( let i = 0; i < this.renderTargetsVertical.length; i ++ ) {
 			this.renderTargetsVertical[ i ].dispose();
 		}
 		this.renderTargetBright.dispose();
 		//
 		for ( let i = 0; i < this.separableBlurMaterials.length; i ++ ) {
 			this.separableBlurMaterials[ i ].dispose();
 		}
 		this.compositeMaterial.dispose();
 		this.blendMaterial.dispose();
 		this._basic.dispose();
 		//
 		this._fsQuad.dispose();
 	}
 	/**
 	 * Sets the size of the pass.
 	 *
 	 * @param {number} width - The width to set.
 	 * @param {number} height - The width to set.
 	 */
 	setSize( width, height ) {
 		let resx = Math.round( width / 2 );
 		let resy = Math.round( height / 2 );
 		this.renderTargetBright.setSize( resx, resy );
 		for ( let i = 0; i < this.nMips; i ++ ) {
 			this.renderTargetsHorizontal[ i ].setSize( resx, resy );
 			this.renderTargetsVertical[ i ].setSize( resx, resy );
 			this.separableBlurMaterials[ i ].uniforms[ 'invSize' ].value = new Vector2( 1 / resx, 1 / resy );
 			resx = Math.round( resx / 2 );
 			resy = Math.round( resy / 2 );
 		}
 	}
 	/**
 	 * Performs the Bloom pass.
 	 *
 	 * @param {WebGLRenderer} renderer - The renderer.
 	 * @param {WebGLRenderTarget} writeBuffer - The write buffer. This buffer is intended as the rendering
 	 * destination for the pass.
 	 * @param {WebGLRenderTarget} readBuffer - The read buffer. The pass can access the result from the
 	 * previous pass from this buffer.
 	 * @param {number} deltaTime - The delta time in seconds.
 	 * @param {boolean} maskActive - Whether masking is active or not.
 	 */
 	render( renderer, writeBuffer, readBuffer, deltaTime, maskActive ) {
 		renderer.getClearColor( this._oldClearColor );
 		this._oldClearAlpha = renderer.getClearAlpha();
 		const oldAutoClear = renderer.autoClear;
 		renderer.autoClear = false;
 		renderer.setClearColor( this.clearColor, 0 );
 		if ( maskActive ) renderer.state.buffers.stencil.setTest( false );
 		// Render input to screen
 		if ( this.renderToScreen ) {
 			this._fsQuad.material = this._basic;
 			this._basic.map = readBuffer.texture;
 			renderer.setRenderTarget( null );
 			renderer.clear();
 			this._fsQuad.render( renderer );
 		}
 		// 1. Extract Bright Areas
 		this.highPassUniforms[ 'tDiffuse' ].value = readBuffer.texture;
 		this.highPassUniforms[ 'luminosityThreshold' ].value = this.threshold;
 		this._fsQuad.material = this.materialHighPassFilter;
 		renderer.setRenderTarget( this.renderTargetBright );
 		renderer.clear();
 		this._fsQuad.render( renderer );
 		// 2. Blur All the mips progressively
 		let inputRenderTarget = this.renderTargetBright;
 		for ( let i = 0; i < this.nMips; i ++ ) {
 			this._fsQuad.material = this.separableBlurMaterials[ i ];
 			this.separableBlurMaterials[ i ].uniforms[ 'colorTexture' ].value = inputRenderTarget.texture;
 			this.separableBlurMaterials[ i ].uniforms[ 'direction' ].value = UnrealBloomPass.BlurDirectionX;
 			renderer.setRenderTarget( this.renderTargetsHorizontal[ i ] );
 			renderer.clear();
 			this._fsQuad.render( renderer );
 			this.separableBlurMaterials[ i ].uniforms[ 'colorTexture' ].value = this.renderTargetsHorizontal[ i ].texture;
 			this.separableBlurMaterials[ i ].uniforms[ 'direction' ].value = UnrealBloomPass.BlurDirectionY;
 			renderer.setRenderTarget( this.renderTargetsVertical[ i ] );
 			renderer.clear();
 			this._fsQuad.render( renderer );
 			inputRenderTarget = this.renderTargetsVertical[ i ];
 		}
 		// Composite All the mips
 		this._fsQuad.material = this.compositeMaterial;
 		this.compositeMaterial.uniforms[ 'bloomStrength' ].value = this.strength;
 		this.compositeMaterial.uniforms[ 'bloomRadius' ].value = this.radius;
 		this.compositeMaterial.uniforms[ 'bloomTintColors' ].value = this.bloomTintColors;
 		renderer.setRenderTarget( this.renderTargetsHorizontal[ 0 ] );
 		renderer.clear();
 		this._fsQuad.render( renderer );
 		// Blend it additively over the input texture
 		this._fsQuad.material = this.blendMaterial;
 		this.copyUniforms[ 'tDiffuse' ].value = this.renderTargetsHorizontal[ 0 ].texture;
 		if ( maskActive ) renderer.state.buffers.stencil.setTest( true );
 		if ( this.renderToScreen ) {
 			renderer.setRenderTarget( null );
 			this._fsQuad.render( renderer );
 		} else {
 			renderer.setRenderTarget( readBuffer );
 			this._fsQuad.render( renderer );
 		}
 		// Restore renderer settings
 		renderer.setClearColor( this._oldClearColor, this._oldClearAlpha );
 		renderer.autoClear = oldAutoClear;
 	}
 	// internals
 	_getSeparableBlurMaterial( kernelRadius ) {
 		const coefficients = [];
 		for ( let i = 0; i < kernelRadius; i ++ ) {
 			coefficients.push( 0.39894 * Math.exp( - 0.5 * i * i / ( kernelRadius * kernelRadius ) ) / kernelRadius );
 		}
 		return new ShaderMaterial( {
 			defines: {
 				'KERNEL_RADIUS': kernelRadius
 			},
 			uniforms: {
 				'colorTexture': { value: null },
 				'invSize': { value: new Vector2( 0.5, 0.5 ) }, // inverse texture size
 				'direction': { value: new Vector2( 0.5, 0.5 ) },
 				'gaussianCoefficients': { value: coefficients } // precomputed Gaussian coefficients
 			},
 			vertexShader:
 				`varying vec2 vUv;
 				void main() {
 					vUv = uv;
 					gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
 				}`,
 			fragmentShader:
 				`#include <common>
 				varying vec2 vUv;
 				uniform sampler2D colorTexture;
 				uniform vec2 invSize;
 				uniform vec2 direction;
 				uniform float gaussianCoefficients[KERNEL_RADIUS];
 				void main() {
 					float weightSum = gaussianCoefficients[0];
 					vec3 diffuseSum = texture2D( colorTexture, vUv ).rgb * weightSum;
 					for( int i = 1; i < KERNEL_RADIUS; i ++ ) {
 						float x = float(i);
 						float w = gaussianCoefficients[i];
 						vec2 uvOffset = direction * invSize * x;
 						vec3 sample1 = texture2D( colorTexture, vUv + uvOffset ).rgb;
 						vec3 sample2 = texture2D( colorTexture, vUv - uvOffset ).rgb;
 						diffuseSum += (sample1 + sample2) * w;
 						weightSum += 2.0 * w;
 					}
 					gl_FragColor = vec4(diffuseSum/weightSum, 1.0);
 				}`
 		} );
 	}
 	_getCompositeMaterial( nMips ) {
 		return new ShaderMaterial( {
 			defines: {
 				'NUM_MIPS': nMips
 			},
 			uniforms: {
 				'blurTexture1': { value: null },
 				'blurTexture2': { value: null },
 				'blurTexture3': { value: null },
 				'blurTexture4': { value: null },
 				'blurTexture5': { value: null },
 				'bloomStrength': { value: 1.0 },
 				'bloomFactors': { value: null },
 				'bloomTintColors': { value: null },
 				'bloomRadius': { value: 0.0 }
 			},
 			vertexShader:
 				`varying vec2 vUv;
 				void main() {
 					vUv = uv;
 					gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
 				}`,
 			fragmentShader:
 				`varying vec2 vUv;
 				uniform sampler2D blurTexture1;
 				uniform sampler2D blurTexture2;
 				uniform sampler2D blurTexture3;
 				uniform sampler2D blurTexture4;
 				uniform sampler2D blurTexture5;
 				uniform float bloomStrength;
 				uniform float bloomRadius;
 				uniform float bloomFactors[NUM_MIPS];
 				uniform vec3 bloomTintColors[NUM_MIPS];
 				float lerpBloomFactor(const in float factor) {
 					float mirrorFactor = 1.2 - factor;
 					return mix(factor, mirrorFactor, bloomRadius);
 				}
 				void main() {
 					gl_FragColor = bloomStrength * ( lerpBloomFactor(bloomFactors[0]) * vec4(bloomTintColors[0], 1.0) * texture2D(blurTexture1, vUv) +
 						lerpBloomFactor(bloomFactors[1]) * vec4(bloomTintColors[1], 1.0) * texture2D(blurTexture2, vUv) +
 						lerpBloomFactor(bloomFactors[2]) * vec4(bloomTintColors[2], 1.0) * texture2D(blurTexture3, vUv) +
 						lerpBloomFactor(bloomFactors[3]) * vec4(bloomTintColors[3], 1.0) * texture2D(blurTexture4, vUv) +
 						lerpBloomFactor(bloomFactors[4]) * vec4(bloomTintColors[4], 1.0) * texture2D(blurTexture5, vUv) );
 				}`
 		} );
 	}
 }
 UnrealBloomPass.BlurDirectionX = new Vector2( 1.0, 0.0 );
 UnrealBloomPass.BlurDirectionY = new Vector2( 0.0, 1.0 );
 export { UnrealBloomPass };
--- a/web/vendor/addons/shaders/CopyShader.js
+++ b/web/vendor/addons/shaders/CopyShader.js
@ -0,0 +1,49 @@
 /** @module CopyShader */
 /**
 * Full-screen copy shader pass.
 *
 * @constant
 * @type {ShaderMaterial~Shader}
 */
 const CopyShader = {
 	name: 'CopyShader',
 	uniforms: {
 		'tDiffuse': { value: null },
 		'opacity': { value: 1.0 }
 	},
 	vertexShader: /* glsl */`
 		varying vec2 vUv;
 		void main() {
 			vUv = uv;
 			gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
 		}`,
 	fragmentShader: /* glsl */`
 		uniform float opacity;
 		uniform sampler2D tDiffuse;
 		varying vec2 vUv;
 		void main() {
 			vec4 texel = texture2D( tDiffuse, vUv );
 			gl_FragColor = opacity * texel;
 		}`
 };
 export { CopyShader };
--- a/web/vendor/addons/shaders/LuminosityHighPassShader.js
+++ b/web/vendor/addons/shaders/LuminosityHighPassShader.js
@ -0,0 +1,65 @@
 import {
 	Color
 } from 'three';
 /** @module LuminosityHighPassShader */
 /**
 * Luminosity high pass shader.
 *
 * @constant
 * @type {ShaderMaterial~Shader}
 */
 const LuminosityHighPassShader = {
 	name: 'LuminosityHighPassShader',
 	uniforms: {
 		'tDiffuse': { value: null },
 		'luminosityThreshold': { value: 1.0 },
 		'smoothWidth': { value: 1.0 },
 		'defaultColor': { value: new Color( 0x000000 ) },
 		'defaultOpacity': { value: 0.0 }
 	},
 	vertexShader: /* glsl */`
 		varying vec2 vUv;
 		void main() {
 			vUv = uv;
 			gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
 		}`,
 	fragmentShader: /* glsl */`
 		uniform sampler2D tDiffuse;
 		uniform vec3 defaultColor;
 		uniform float defaultOpacity;
 		uniform float luminosityThreshold;
 		uniform float smoothWidth;
 		varying vec2 vUv;
 		void main() {
 			vec4 texel = texture2D( tDiffuse, vUv );
 			float v = luminance( texel.xyz );
 			vec4 outputColor = vec4( defaultColor.rgb, defaultOpacity );
 			float alpha = smoothstep( luminosityThreshold, luminosityThreshold + smoothWidth, v );
 			gl_FragColor = mix( outputColor, texel, alpha );
 		}`
 };
 export { LuminosityHighPassShader };
--- a/web/vendor/addons/shaders/OutputShader.js
+++ b/web/vendor/addons/shaders/OutputShader.js
@ -0,0 +1,100 @@
 /** @module OutputShader */
 /**
 * Performs tone mapping and color space conversion for
 * FX workflows.
 *
 * Used by {@link OutputPass}.
 *
 * @constant
 * @type {ShaderMaterial~Shader}
 */
 const OutputShader = {
 	name: 'OutputShader',
 	uniforms: {
 		'tDiffuse': { value: null },
 		'toneMappingExposure': { value: 1 }
 	},
 	vertexShader: /* glsl */`
 		precision highp float;
 		uniform mat4 modelViewMatrix;
 		uniform mat4 projectionMatrix;
 		attribute vec3 position;
 		attribute vec2 uv;
 		varying vec2 vUv;
 		void main() {
 			vUv = uv;
 			gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
 		}`,
 	fragmentShader: /* glsl */`
 		precision highp float;
 		uniform sampler2D tDiffuse;
 		#include <tonemapping_pars_fragment>
 		#include <colorspace_pars_fragment>
 		varying vec2 vUv;
 		void main() {
 			gl_FragColor = texture2D( tDiffuse, vUv );
 			// tone mapping
 			#ifdef LINEAR_TONE_MAPPING
 				gl_FragColor.rgb = LinearToneMapping( gl_FragColor.rgb );
 			#elif defined( REINHARD_TONE_MAPPING )
 				gl_FragColor.rgb = ReinhardToneMapping( gl_FragColor.rgb );
 			#elif defined( CINEON_TONE_MAPPING )
 				gl_FragColor.rgb = CineonToneMapping( gl_FragColor.rgb );
 			#elif defined( ACES_FILMIC_TONE_MAPPING )
 				gl_FragColor.rgb = ACESFilmicToneMapping( gl_FragColor.rgb );
 			#elif defined( AGX_TONE_MAPPING )
 				gl_FragColor.rgb = AgXToneMapping( gl_FragColor.rgb );
 			#elif defined( NEUTRAL_TONE_MAPPING )
 				gl_FragColor.rgb = NeutralToneMapping( gl_FragColor.rgb );
 			#elif defined( CUSTOM_TONE_MAPPING )
 				gl_FragColor.rgb = CustomToneMapping( gl_FragColor.rgb );
 			#endif
 			// color space
 			#ifdef SRGB_TRANSFER
 				gl_FragColor = sRGBTransferOETF( gl_FragColor );
 			#endif
 		}`
 };
 export { OutputShader };
--- a/web/vendor/addons/shaders/VignetteShader.js
+++ b/web/vendor/addons/shaders/VignetteShader.js
@ -0,0 +1,53 @@
 /** @module VignetteShader */
 /**
 * Based on [PaintEffect postprocess from ro.me]{@link http://code.google.com/p/3-dreams-of-black/source/browse/deploy/js/effects/PaintEffect.js}.
 *
 * @constant
 * @type {ShaderMaterial~Shader}
 */
 const VignetteShader = {
 	name: 'VignetteShader',
 	uniforms: {
 		'tDiffuse': { value: null },
 		'offset': { value: 1.0 },
 		'darkness': { value: 1.0 }
 	},
 	vertexShader: /* glsl */`
 		varying vec2 vUv;
 		void main() {
 			vUv = uv;
 			gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
 		}`,
 	fragmentShader: /* glsl */`
 		uniform float offset;
 		uniform float darkness;
 		uniform sampler2D tDiffuse;
 		varying vec2 vUv;
 		void main() {
 			// Eskil's vignette
 			vec4 texel = texture2D( tDiffuse, vUv );
 			vec2 uv = ( vUv - vec2( 0.5 ) ) * vec2( offset );
 			gl_FragColor = vec4( mix( texel.rgb, vec3( 1.0 - darkness ), dot( uv, uv ) ), texel.a );
 		}`
 };
 export { VignetteShader };
--- a/web/vendor/addons/utils/BufferGeometryUtils.js
+++ b/web/vendor/addons/utils/BufferGeometryUtils.js
--- a/web/vendor/addons/utils/SkeletonUtils.js
+++ b/web/vendor/addons/utils/SkeletonUtils.js
@ -0,0 +1,490 @@
 import {
 	AnimationClip,
 	AnimationMixer,
 	Matrix4,
 	Quaternion,
 	QuaternionKeyframeTrack,
 	SkeletonHelper,
 	Vector3,
 	VectorKeyframeTrack
 } from 'three';
 /**
 * @module SkeletonUtils
 * @three_import import * as SkeletonUtils from 'three/addons/utils/SkeletonUtils.js';
 */
 function getBoneName( bone, options ) {
 	if ( options.getBoneName !== undefined ) {
 		return options.getBoneName( bone );
 	}
 	return options.names[ bone.name ];
 }
 /**
 * Retargets the skeleton from the given source 3D object to the
 * target 3D object.
 *
 * @param {Object3D} target - The target 3D object.
 * @param {Object3D} source - The source 3D object.
 * @param {module:SkeletonUtils~RetargetOptions} options - The options.
 */
 function retarget( target, source, options = {} ) {
 	const quat = new Quaternion(),
 		scale = new Vector3(),
 		relativeMatrix = new Matrix4(),
 		globalMatrix = new Matrix4();
 	options.preserveBoneMatrix = options.preserveBoneMatrix !== undefined ? options.preserveBoneMatrix : true;
 	options.preserveBonePositions = options.preserveBonePositions !== undefined ? options.preserveBonePositions : true;
 	options.useTargetMatrix = options.useTargetMatrix !== undefined ? options.useTargetMatrix : false;
 	options.hip = options.hip !== undefined ? options.hip : 'hip';
 	options.hipInfluence = options.hipInfluence !== undefined ? options.hipInfluence : new Vector3( 1, 1, 1 );
 	options.scale = options.scale !== undefined ? options.scale : 1;
 	options.names = options.names || {};
 	const sourceBones = source.isObject3D ? source.skeleton.bones : getBones( source ),
 		bones = target.isObject3D ? target.skeleton.bones : getBones( target );
 	let bone, name, boneTo,
 		bonesPosition;
 	// reset bones
 	if ( target.isObject3D ) {
 		target.skeleton.pose();
 	} else {
 		options.useTargetMatrix = true;
 		options.preserveBoneMatrix = false;
 	}
 	if ( options.preserveBonePositions ) {
 		bonesPosition = [];
 		for ( let i = 0; i < bones.length; i ++ ) {
 			bonesPosition.push( bones[ i ].position.clone() );
 		}
 	}
 	if ( options.preserveBoneMatrix ) {
 		// reset matrix
 		target.updateMatrixWorld();
 		target.matrixWorld.identity();
 		// reset children matrix
 		for ( let i = 0; i < target.children.length; ++ i ) {
 			target.children[ i ].updateMatrixWorld( true );
 		}
 	}
 	for ( let i = 0; i < bones.length; ++ i ) {
 		bone = bones[ i ];
 		name = getBoneName( bone, options );
 		boneTo = getBoneByName( name, sourceBones );
 		globalMatrix.copy( bone.matrixWorld );
 		if ( boneTo ) {
 			boneTo.updateMatrixWorld();
 			if ( options.useTargetMatrix ) {
 				relativeMatrix.copy( boneTo.matrixWorld );
 			} else {
 				relativeMatrix.copy( target.matrixWorld ).invert();
 				relativeMatrix.multiply( boneTo.matrixWorld );
 			}
 			// ignore scale to extract rotation
 			scale.setFromMatrixScale( relativeMatrix );
 			relativeMatrix.scale( scale.set( 1 / scale.x, 1 / scale.y, 1 / scale.z ) );
 			// apply to global matrix
 			globalMatrix.makeRotationFromQuaternion( quat.setFromRotationMatrix( relativeMatrix ) );
 			if ( target.isObject3D ) {
 				if ( options.localOffsets ) {
 					if ( options.localOffsets[ bone.name ] ) {
 						globalMatrix.multiply( options.localOffsets[ bone.name ] );
 					}
 				}
 			}
 			globalMatrix.copyPosition( relativeMatrix );
 		}
 		if ( name === options.hip ) {
 			globalMatrix.elements[ 12 ] *= options.scale * options.hipInfluence.x;
 			globalMatrix.elements[ 13 ] *= options.scale * options.hipInfluence.y;
 			globalMatrix.elements[ 14 ] *= options.scale * options.hipInfluence.z;
 			if ( options.hipPosition !== undefined ) {
 				globalMatrix.elements[ 12 ] += options.hipPosition.x * options.scale;
 				globalMatrix.elements[ 13 ] += options.hipPosition.y * options.scale;
 				globalMatrix.elements[ 14 ] += options.hipPosition.z * options.scale;
 			}
 		}
 		if ( bone.parent ) {
 			bone.matrix.copy( bone.parent.matrixWorld ).invert();
 			bone.matrix.multiply( globalMatrix );
 		} else {
 			bone.matrix.copy( globalMatrix );
 		}
 		bone.matrix.decompose( bone.position, bone.quaternion, bone.scale );
 		bone.updateMatrixWorld();
 	}
 	if ( options.preserveBonePositions ) {
 		for ( let i = 0; i < bones.length; ++ i ) {
 			bone = bones[ i ];
 			name = getBoneName( bone, options ) || bone.name;
 			if ( name !== options.hip ) {
 				bone.position.copy( bonesPosition[ i ] );
 			}
 		}
 	}
 	if ( options.preserveBoneMatrix ) {
 		// restore matrix
 		target.updateMatrixWorld( true );
 	}
 }
 /**
 * Retargets the animation clip of the source object to the
 * target 3D object.
 *
 * @param {Object3D} target - The target 3D object.
 * @param {Object3D} source - The source 3D object.
 * @param {AnimationClip} clip - The animation clip.
 * @param {module:SkeletonUtils~RetargetOptions} options - The options.
 * @return {AnimationClip} The retargeted animation clip.
 */
 function retargetClip( target, source, clip, options = {} ) {
 	options.useFirstFramePosition = options.useFirstFramePosition !== undefined ? options.useFirstFramePosition : false;
 	// Calculate the fps from the source clip based on the track with the most frames, unless fps is already provided.
 	options.fps = options.fps !== undefined ? options.fps : ( Math.max( ...clip.tracks.map( track => track.times.length ) ) / clip.duration );
 	options.names = options.names || [];
 	if ( ! source.isObject3D ) {
 		source = getHelperFromSkeleton( source );
 	}
 	const numFrames = Math.round( clip.duration * ( options.fps / 1000 ) * 1000 ),
 		delta = clip.duration / ( numFrames - 1 ),
 		convertedTracks = [],
 		mixer = new AnimationMixer( source ),
 		bones = getBones( target.skeleton ),
 		boneDatas = [];
 	let positionOffset,
 		bone, boneTo, boneData,
 		name;
 	mixer.clipAction( clip ).play();
 	// trim
 	let start = 0, end = numFrames;
 	if ( options.trim !== undefined ) {
 		start = Math.round( options.trim[ 0 ] * options.fps );
 		end = Math.min( Math.round( options.trim[ 1 ] * options.fps ), numFrames ) - start;
 		mixer.update( options.trim[ 0 ] );
 	} else {
 		mixer.update( 0 );
 	}
 	source.updateMatrixWorld();
 	//
 	for ( let frame = 0; frame < end; ++ frame ) {
 		const time = frame * delta;
 		retarget( target, source, options );
 		for ( let j = 0; j < bones.length; ++ j ) {
 			bone = bones[ j ];
 			name = getBoneName( bone, options ) || bone.name;
 			boneTo = getBoneByName( name, source.skeleton );
 			if ( boneTo ) {
 				boneData = boneDatas[ j ] = boneDatas[ j ] || { bone: bone };
 				if ( options.hip === name ) {
 					if ( ! boneData.pos ) {
 						boneData.pos = {
 							times: new Float32Array( end ),
 							values: new Float32Array( end * 3 )
 						};
 					}
 					if ( options.useFirstFramePosition ) {
 						if ( frame === 0 ) {
 							positionOffset = bone.position.clone();
 						}
 						bone.position.sub( positionOffset );
 					}
 					boneData.pos.times[ frame ] = time;
 					bone.position.toArray( boneData.pos.values, frame * 3 );
 				}
 				if ( ! boneData.quat ) {
 					boneData.quat = {
 						times: new Float32Array( end ),
 						values: new Float32Array( end * 4 )
 					};
 				}
 				boneData.quat.times[ frame ] = time;
 				bone.quaternion.toArray( boneData.quat.values, frame * 4 );
 			}
 		}
 		if ( frame === end - 2 ) {
 			// last mixer update before final loop iteration
 			// make sure we do not go over or equal to clip duration
 			mixer.update( delta - 0.0000001 );
 		} else {
 			mixer.update( delta );
 		}
 		source.updateMatrixWorld();
 	}
 	for ( let i = 0; i < boneDatas.length; ++ i ) {
 		boneData = boneDatas[ i ];
 		if ( boneData ) {
 			if ( boneData.pos ) {
 				convertedTracks.push( new VectorKeyframeTrack(
 					'.bones[' + boneData.bone.name + '].position',
 					boneData.pos.times,
 					boneData.pos.values
 				) );
 			}
 			convertedTracks.push( new QuaternionKeyframeTrack(
 				'.bones[' + boneData.bone.name + '].quaternion',
 				boneData.quat.times,
 				boneData.quat.values
 			) );
 		}
 	}
 	mixer.uncacheAction( clip );
 	return new AnimationClip( clip.name, - 1, convertedTracks );
 }
 /**
 * Clones the given 3D object and its descendants, ensuring that any `SkinnedMesh` instances are
 * correctly associated with their bones. Bones are also cloned, and must be descendants of the
 * object passed to this method. Other data, like geometries and materials, are reused by reference.
 *
 * @param {Object3D} source - The 3D object to clone.
 * @return {Object3D} The cloned 3D object.
 */
 function clone( source ) {
 	const sourceLookup = new Map();
 	const cloneLookup = new Map();
 	const clone = source.clone();
 	parallelTraverse( source, clone, function ( sourceNode, clonedNode ) {
 		sourceLookup.set( clonedNode, sourceNode );
 		cloneLookup.set( sourceNode, clonedNode );
 	} );
 	clone.traverse( function ( node ) {
 		if ( ! node.isSkinnedMesh ) return;
 		const clonedMesh = node;
 		const sourceMesh = sourceLookup.get( node );
 		const sourceBones = sourceMesh.skeleton.bones;
 		clonedMesh.skeleton = sourceMesh.skeleton.clone();
 		clonedMesh.bindMatrix.copy( sourceMesh.bindMatrix );
 		clonedMesh.skeleton.bones = sourceBones.map( function ( bone ) {
 			return cloneLookup.get( bone );
 		} );
 		clonedMesh.bind( clonedMesh.skeleton, clonedMesh.bindMatrix );
 	} );
 	return clone;
 }
 // internal helper
 function getBoneByName( name, skeleton ) {
 	for ( let i = 0, bones = getBones( skeleton ); i < bones.length; i ++ ) {
 		if ( name === bones[ i ].name )
 			return bones[ i ];
 	}
 }
 function getBones( skeleton ) {
 	return Array.isArray( skeleton ) ? skeleton : skeleton.bones;
 }
 function getHelperFromSkeleton( skeleton ) {
 	const source = new SkeletonHelper( skeleton.bones[ 0 ] );
 	source.skeleton = skeleton;
 	return source;
 }
 function parallelTraverse( a, b, callback ) {
 	callback( a, b );
 	for ( let i = 0; i < a.children.length; i ++ ) {
 		parallelTraverse( a.children[ i ], b.children[ i ], callback );
 	}
 }
 /**
 * Retarget options of `SkeletonUtils`.
 *
 * @typedef {Object} module:SkeletonUtils~RetargetOptions
 * @property {boolean} [useFirstFramePosition=false] - Whether to use the position of the first frame or not.
 * @property {number} [fps] - The FPS of the clip.
 * @property {Object<string,string>} [names] - A dictionary for mapping target to source bone names.
 * @property {function(string):string} [getBoneName] - A function for mapping bone names. Alternative to `names`.
 * @property {Array<number>} [trim] - Whether to trim the clip or not. If set the array should hold two values for the start and end.
 * @property {boolean} [preserveBoneMatrix=true] - Whether to preserve bone matrices or not.
 * @property {boolean} [preserveBonePositions=true] - Whether to preserve bone positions or not.
 * @property {boolean} [useTargetMatrix=false] - Whether to use the target matrix or not.
 * @property {string} [hip='hip'] - The name of the source's hip bone.
 * @property {Vector3} [hipInfluence=(1,1,1)] - The hip influence.
 * @property {number} [scale=1] - The scale.
 **/
 export {
 	retarget,
 	retargetClip,
 	clone,
 };
--- a/web/vendor/three.core.js
+++ b/web/vendor/three.core.js
--- a/web/vendor/three.module.js
+++ b/web/vendor/three.module.js