feat(art): re-bake the DESCENT campaign through the rev-2 pipeline

All 208 frames of seeds 7/69/59, rendered with per-direction cameras
(directedVantage: gap-centered when open, close + off-axis when walled,
per-class wall seed) and dithered through the speckle-free rev-2 recipe
(sRGB-spaced LUT, gamut-clamped diffusion, --overshoot 6).

Walls no longer grow phantom doors; the passage you walk is the passage
you see; shadows are warm stone instead of green confetti.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

reikhelm-web/fpv.js

@@ -53,6 +53,59 @@ export function roomVantage(env, region, opts = {}) {
   return mostOpenCell(distanceToWall(tiles, env.width, env.height), env.width, region.cells);
 }
 
+// Per-(room, facing) camera cell, chosen so the faced geometry reads
+// UNAMBIGUOUSLY in the depth map. The room-wide most-open vantage stands far
+// from everything: the faced wall lands near max-view (≈ black), and the
+// diffusion model decorates that ambiguity with hallucinated doors — while a
+// real opening renders off-center because the camera isn't aligned with the
+// gap. Instead:
+//   open ahead  → stand in a cell whose straight-ahead ray ESCAPES the room
+//                 through the gap, a comfortable 2–7 cells back: the passage
+//                 you'd walk through is centered and clearly deep.
+//   wall ahead  → stand ~3 cells from the wall: it renders mid-bright and
+//                 solid, leaving the model nothing to invent.
+export function directedVantage(env, region, dirName, opts = {}) {
+  const { tiles } = getStage(env, opts.stage);
+  const w = env.width, h = env.height;
+  const dist = distanceToWall(tiles, w, h);
+  const [dx, dy] = DIRS[dirName];
+  const cellSet = new Set(region.cells.map(([x, y]) => x + ',' + y));
+  const [cx, cy] = centroidOf(region.cells);
+
+  let best = null, bestScore = Infinity, anyEscape = false;
+  const cand = [];
+  for (const [x, y] of region.cells) {
+    let px = x, py = y, run = 0, escaped = false;
+    for (let s = 0; s < 24; s++) {
+      px += dx; py += dy;
+      if (px < 0 || py < 0 || px >= w || py >= h) break;
+      if (blocks(tiles[py][px])) break;
+      run++;
+      if (!cellSet.has(px + ',' + py)) escaped = true; // ray left the room through a gap
+    }
+    if (escaped) anyEscape = true;
+    cand.push({ x, y, run, escaped });
+  }
+  for (const c of cand) {
+    if (anyEscape && !c.escaped) continue; // when a gap is sightable, only gap-aligned cells qualify
+    const clearance = dist[c.y * w + c.x];
+    // Sweet bands: gaps read best 2–7 cells out; a blank wall at ~2.
+    const band = anyEscape
+      ? (c.run < 2 ? (2 - c.run) * 6 : c.run > 7 ? (c.run - 7) * 2 : 0)
+      : Math.abs(c.run - 2) * 3; // closed: stand close — a bright dominant slab leaves no room for phantom doors
+    const hug = clearance <= 1 ? 5 : 0; // don't press against a side wall
+    // Open: center on the gap. Closed: deliberately stand OFF the room's
+    // perpendicular axis — a symmetric stage begs the model to paint a
+    // centered focal door; an off-axis dead-end corner doesn't.
+    const perp = dirName === 'N' || dirName === 'S' ? c.x - cx : c.y - cy;
+    const cen = ((c.x - cx) ** 2 + (c.y - cy) ** 2) * 0.05;
+    const offAxis = anyEscape ? 0 : (Math.abs(perp) < 1.5 ? 4 : 0);
+    const score = band + hug + (anyEscape ? cen : offAxis + cen * 0.4);
+    if (score < bestScore) { bestScore = score; best = [c.x, c.y]; }
+  }
+  return best ?? mostOpenCell(dist, w, region.cells);
+}
+
 // Default demo vantage: the most-open cell of the largest room (or, failing that,
 // the most open floor cell anywhere).
 export function vantage(env, opts = {}) {

reikhelm-web/main.js

@@ -5,7 +5,7 @@
 import init, { generate, default_config_json } from './pkg/reikhelm_wasm.js';
 import { renderMap, getStage, THEMES } from './render.js';
 import { downloadDepth, exportDepthDataURL, exportDepthToServer } from './depth.js';
-import { exportFPVDataURL, exportFPVToServer, vantage } from './fpv.js';
+import { exportFPVDataURL, exportFPVToServer, vantage, directedVantage } from './fpv.js';
 import { dungeonManifest } from './explore.js';
 
 const canvas = document.getElementById('view');
@@ -241,7 +241,10 @@ window.reikhelm = {
     const sd = state.env.seed;
     for (const r of m.rooms) {
       for (const dir of ['N', 'E', 'S', 'W']) {
-        await exportFPVToServer(state.env, `atlas/${sd}/_work/r${r.id}_${dir}_depth.png`, { at: r.vantage, dir });
+        // Per-direction camera: gap-aligned when the way is open, near-wall
+        // when it's closed — so the depth map can't be misread by the model.
+        const at = directedVantage(state.env, state.env.regions[r.id], dir);
+        await exportFPVToServer(state.env, `atlas/${sd}/_work/r${r.id}_${dir}_depth.png`, { at, dir });
       }
     }
     await this.saveJSON(`atlas/${sd}/manifest.json`, m);

tools/bake_atlas.py

@@ -56,7 +56,11 @@ DEFAULT_BODY = THEME_BODY["stone"]
 # These reinforce the depth (a deep recess vs a near wall straight ahead) so the
 # model paints a passage only where one actually exists — killing phantom doors.
 AHEAD_OPEN = "a dark arched passage leads onward into shadow ahead"
-AHEAD_WALL = "a solid carved stone wall closes the way ahead"
+# cfg 1.0 makes negatives inert, so the closed case is carried by emphatic
+# positive description — themes like the vault say "locked", which otherwise
+# summons phantom doors on blank walls.
+AHEAD_WALL = ("the way ahead ends at a blank unbroken wall of carved stone blocks, "
+              "sealed solid masonry with no door and no opening, a dead end")
 NEGATIVE = ("person, people, human, figure, character, hands, fingers, hand, arm, arms, "
             "holding weapon, sword, feet, legs, body, silhouette, UI, HUD, text, watermark, modern")
 
@@ -124,13 +128,18 @@ def main():
         theme = room.get("theme")
         is_open = bool(room.get("open", {}).get(d, False))
         prompt = prompt_for(theme, is_open)
+        strength = a.strength
+        # Walls render under their own FIXED seed: the open-frame seed's
+        # favorite composition is a centered doorway — exactly what a closed
+        # wall must not grow. One class, one seed → style stays coherent.
+        render_seed = a.render_seed if is_open else a.render_seed + 13
         prefix = f"r{rid}_{d}_{RUN}"  # per-run unique; avoids ComfyUI prefix-counter collisions on re-bake
         frame = os.path.join(atlas, f"r{rid}_{d}.png")
         tag = f"[{i}/{len(depths)}] r{rid} {d} {theme or '?'}{'·open' if is_open else '·wall'}"
 
         if not run(["python3", COMFY, "zrender", a.url, "--depth", depth,
                     "--width", str(a.width), "--height", str(a.height),
-                    "--strength", str(a.strength), "--seed", str(a.render_seed),
+                    "--strength", str(strength), "--seed", str(render_seed),
                     "--prompt", prompt, "--negative", NEGATIVE,
                     "--prefix", prefix, "--wait", "300"]):
             print(f"  {tag}  RENDER FAILED"); continue
@@ -141,7 +150,8 @@ def main():
         render = renders[0]
 
         if not run([VENV_PY, PIXELATE, render, "--palette", PALETTE,
-                    "--size", a.size, "--preview-scale", "0", "--out", frame]):
+                    "--size", a.size, "--preview-scale", "0", "--overshoot", "6",
+                    "--out", frame]):
             print(f"  {tag}  DITHER FAILED"); continue
 
         os.remove(render)  # keep the depth, drop the big intermediate render