@bitmagic/cli 0.1.64-dev.14 → 0.1.64-dev.16

package/README.md

@@ -705,8 +705,10 @@ Click the name for the rest of the answer: the game's id, the environment it tal
 built for, its engine version — and the two pictures that decide how the whole project looks, the
 **accepted reference image** and the **cover art**, side by side. Both were previously visible only
 in a terminal (`bitmagic reference show`, `bitmagic cover`); the dialog draws them from the local
-copies under `.bitmagic/`, so they are there whether or not the recorded URL still resolves. A
-project missing one is told which command makes it. The reference's caption warns you when it was
+copies under `.bitmagic/`, so they are there whether or not the recorded URL still resolves. Click
+either thumbnail to see it full size — a couple of hundred pixels of an image generated at 1024 is
+not enough to judge the look it exists to fix; click anywhere, or press Escape, and the dialog is
+still underneath. A project missing one is told which command makes it. The reference's caption warns you when it was
 never re-hosted, because that URL — the one every later generation inherits — will expire.
 
 What you reach for all session sits in the bar: the **Game / Editor** tabs, **Auto-reload**, the

package/assets/blender-level/README.md

@@ -15,10 +15,15 @@ skill's step 1 tells an agent how to copy them into a project's `tools/blender-l
 | `bmlevel/` | Blender, or python3 for a dry run | the authoring vocabulary (`__init__.py`), the bpy-free maths and JSON writers (`core.py`), the Blender backend (`scene_bpy.py`) and the recording backend (`scene_null.py`) |
 | `example_level.py` | either | a complete hut-and-courtyard level using every helper; the tests' fixture |
 | `audit.py` | Blender | ray-cast audit of the COLLIDERS: floor continuity, door and route clearance, sealed envelopes, z-fighting candidates |
-| `review.py` | Blender | deterministic review renders (overview, every door, every stair, every room) and a contact sheet |
+| `review.py` | Blender | deterministic review renders (overview, every door, every stair, every room) and a contact sheet; `--shot 'FROM -> TO'` aims a frame anywhere, `--only` renders just those, `--lighting game` swaps the review fill for the engine's interior preset and the level's own lamps |
 | `sync_world.py` | python3 | carries the doors, spawn and `terrain.shape: 'none'` into `src/work/world.json` |
 | `tests/` | python3 | `python3 -m unittest discover -s tests` — no Blender needed; `cli`'s `pnpm test` runs it |
 
+`review.py` and `audit.py` are the skill's **inner loop**: with the build they answer every
+geometric and (under `--lighting game`) every lighting question about a level for a few seconds
+and no network, which is what lets the engine handoff — `bitmagic assets add`, `sync_world.py`,
+`bitmagic verify`, `bitmagic judge` — happen once per design pass instead of once per edit.
+
 The JSON contract is owned by the engine (`game/src/engine/meshlevel/MeshLevelSchema.ts`,
 documented in `game/agent-docs/mesh-level.md`); `core.py` writes exactly that shape, and the
 engine's validator is the arbiter when the two disagree. The intended end state is a

package/assets/blender-level/bmlevel/core.py

@@ -1,4 +1,6 @@
-"""The bpy-free half of bmlevel: coordinates, records, collider math and the JSON writers.
+"""The bpy-free half of bmlevel: coordinates, records, collider math, the JSON writers and the
+review cameras — both the standard set (`review_cameras`) and the ad-hoc `--shot` specs
+(`resolve_point`, `custom_shot`) review.py aims from a level JSON.
 
 Everything a level script says is in GAME coordinates — metres, Y up, +Z forward, yaw in radians
 about +Y so that an entity's forward at yaw θ is (sin θ, 0, cos θ) (engine/agent-docs/
@@ -436,3 +438,78 @@ def review_cameras(level: dict, doors: Sequence[dict] = ()) -> list[dict]:
         fx, fz = rotate_xz(0.0, 1.0, yaw) if long_axis_z else rotate_xz(1.0, 0.0, yaw)
         shots.append({'name': f"volume-{v['name']}", 'kind': 'persp', 'position': (p[0] + ox, eye_y, p[2] + oz), 'target': (p[0] + ox + fx * 4, eye_y - 0.3, p[2] + oz + fz * 4)})
     return shots
+
+
+# ---------------------------------------------------------------- ad-hoc shots
+
+EYE_HEIGHT = 1.6
+"""Where a standing player's camera is above the floor — the height every review shot uses."""
+
+
+def level_center(level: dict) -> Vec3:
+    """The centre of the collider bounds, at eye height above their floor: what a shot with no
+    target looks at."""
+    pts: list[Vec3] = []
+    for c in level.get('colliders', []):
+        if c['shape'] == 'box':
+            pts.extend(box_corners(c['position'], c['size'], c.get('yaw', 0.0)))
+        else:
+            pts.extend(flat_to_points(c['vertices']))
+    b = aabb(pts)
+    if not b:
+        return (0.0, EYE_HEIGHT, 0.0)
+    return ((b[0][0] + b[1][0]) / 2, b[0][1] + EYE_HEIGHT, (b[0][2] + b[1][2]) / 2)
+
+
+def resolve_point(spec: str, level: dict, doors: Sequence[dict] = (), *, as_eye: bool = False) -> Vec3:
+    """A game-space point from one end of a `--shot` spec.
+
+    `landmark:<name>`, `volume:<name>`, `door:<id>` or a raw `x,y,z`. Landmarks, doors and volumes
+    are recorded at the floor, the door's centre and the room's centre respectively, so `as_eye`
+    (the FROM end) lifts each to a standing camera and the TO end aims at the thing itself. Raw
+    coordinates are used exactly as written, either end — they are the escape hatch.
+    """
+    spec = spec.strip()
+    kind, _, rest = spec.partition(':')
+    kind, rest = kind.strip().lower(), rest.strip()
+    if kind == 'landmark':
+        for l in level.get('landmarks', []):
+            if l['name'] == rest:
+                x, y, z = l['position']
+                return (x, y + (EYE_HEIGHT if as_eye else 1.0), z)
+        known = ', '.join(sorted(l['name'] for l in level.get('landmarks', []))) or '(none)'
+        raise ValueError(f'no landmark named {rest!r} — the level has: {known}')
+    if kind == 'volume':
+        for v in level.get('volumes', []):
+            if v['name'] == rest:
+                x, y, z = v['position']
+                return (x, y - v['size'][1] / 2 + EYE_HEIGHT, z) if as_eye else (x, y, z)
+        known = ', '.join(sorted(v['name'] for v in level.get('volumes', []))) or '(none)'
+        raise ValueError(f'no volume named {rest!r} — the level has: {known}')
+    if kind == 'door':
+        for d in doors:
+            if d['id'] == rest:
+                p = d['position']
+                x, y, z = (p['x'], p['y'], p['z']) if isinstance(p, dict) else tuple(p)
+                return (x, y - d['height'] / 2 + EYE_HEIGHT, z) if as_eye else (x, y, z)
+        known = ', '.join(sorted(d['id'] for d in doors)) or '(none)'
+        raise ValueError(f'no door with id {rest!r} — the level has: {known}')
+    parts = [p for p in spec.replace(' ', '').split(',') if p]
+    if len(parts) == 3:
+        try:
+            return (float(parts[0]), float(parts[1]), float(parts[2]))
+        except ValueError:
+            pass
+    raise ValueError(f'cannot read shot point {spec!r} — use landmark:<name>, volume:<name>, door:<id> or x,y,z')
+
+
+def custom_shot(spec: str, index: int, level: dict, doors: Sequence[dict] = (), fov: float | None = None) -> dict:
+    """One `--shot` argument as a review shot. `'FROM -> TO'`, or `'FROM'` to look at the level's
+    centre. `index` numbers the frame (`shot-1`, `shot-2`, …)."""
+    frm, arrow, to = spec.partition('->')
+    position = resolve_point(frm, level, doors, as_eye=True)
+    target = resolve_point(to, level, doors) if arrow else level_center(level)
+    shot = {'name': f'shot-{index}', 'kind': 'persp', 'position': position, 'target': target, 'spec': spec.strip()}
+    if fov is not None:
+        shot['fov'] = fov
+    return shot

package/assets/blender-level/review.py

@@ -1,14 +1,23 @@
 """Headless review renders of a built level, run inside Blender:
 
     "$BLENDER" -b --python tools/blender-level/review.py -- build/level/hut.blend build/level/hut.mesh-level.json build/level/review/
+        [--lighting review|game] [--shot 'FROM -> TO']... [--only] [--fov <degrees>]
 
 Opens the .blend (named parts intact) and renders a deterministic set of shots from the level
 JSON — `overview` (top-down), `door-<id>-a/b` (both approaches of every door), `stairs-<name>`
 (from the foot), `volume-<name>` (inside every room) — into the output directory, plus
 `contact-sheet.png` with all of them. Read the sheet, then the shots that look wrong.
 
-EEVEE, 960 x 540, a camera-mounted fill light so interiors are legible whatever the JSON lights
-say. This is a look at the geometry, not the game's lighting — `bitmagic verify` shows that.
+`--shot` adds a frame you aim yourself: both ends are `landmark:<name>`, `volume:<name>`,
+`door:<id>` or a raw `x,y,z` in game coordinates, and `'FROM'` alone looks at the level's centre.
+Repeat it; `--only` renders just those and skips the standard set and the sheet, which is the
+one-render look at the thing you just changed.
+
+`--lighting review` (the default) mounts a camera fill and a sun so nothing hides in shadow: this
+is a look at the GEOMETRY. `--lighting game` instead runs the engine's `interior` preset and the
+`lamp()`s and `spot()`s the level JSON declares, so the lighting pass can be judged here rather
+than through a `bitmagic verify`. EEVEE is not three.js — trust "too dark" and "too bright", not
+an exact colour.
 """
 import json
 import math
@@ -19,14 +28,40 @@ import bpy
 from mathutils import Vector
 
 sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
-from bmlevel.core import review_cameras, to_blender  # noqa: E402
+from bmlevel.core import custom_shot, review_cameras, to_blender  # noqa: E402
 
 argv = sys.argv[sys.argv.index('--') + 1:] if '--' in sys.argv else sys.argv[1:]
-if len(argv) < 3:
+positional = [a for a in argv if not a.startswith('--')]
+
+
+def flag_value(name: str, default: str | None = None) -> str | None:
+    return argv[argv.index(name) + 1] if name in argv and argv.index(name) + 1 < len(argv) else default
+
+
+def flag_values(name: str) -> list[str]:
+    return [argv[i + 1] for i, a in enumerate(argv) if a == name and i + 1 < len(argv)]
+
+
+# `--shot`, `--lighting` and `--fov` each consume the token after them, which would otherwise read
+# as a positional path.
+consumed = {argv[i + 1] for i, a in enumerate(argv) if a in ('--shot', '--lighting', '--fov') and i + 1 < len(argv)}
+positional = [a for a in positional if a not in consumed]
+if len(positional) < 3:
     print(__doc__)
     sys.exit(2)
-BLEND, LEVEL_PATH, OUT = argv[0], argv[1], argv[2]
+BLEND, LEVEL_PATH, OUT = positional[0], positional[1], positional[2]
+LIGHTING = (flag_value('--lighting', 'review') or 'review').lower()
+if LIGHTING not in ('review', 'game'):
+    print(f"--lighting takes 'review' or 'game', not {LIGHTING!r}")
+    sys.exit(2)
+SHOT_SPECS = flag_values('--shot')
+ONLY = '--only' in argv
+FOV = float(flag_value('--fov')) if flag_value('--fov') else None
+if ONLY and not SHOT_SPECS:
+    print('--only needs at least one --shot')
+    sys.exit(2)
 WIDTH, HEIGHT = 960, 540
+DEFAULT_LENS = 24.0
 
 level = json.load(open(LEVEL_PATH))
 doors_path = LEVEL_PATH.replace('.mesh-level.json', '.doors.json')
@@ -47,7 +82,10 @@ if scene.world is None:
 scene.world.use_nodes = True
 bg = scene.world.node_tree.nodes['Background']
 bg.inputs[0].default_value = (0.35, 0.4, 0.5, 1)
-bg.inputs[1].default_value = 0.6
+# The engine's `interior` preset holds environment at 0.22 and the skybox at 0.3 against an
+# ambient floor of 0.8 (engine/agent-docs/mesh-level.md); a world background is EEVEE's nearest
+# equivalent to that plus the retargeted HemisphereLight. `review` lights it flat instead.
+bg.inputs[1].default_value = 0.6 if LIGHTING == 'review' else 0.35
 
 cam_data = bpy.data.cameras.new('review')
 cam = bpy.data.objects.new('review', cam_data)
@@ -59,10 +97,57 @@ fill_data.shadow_soft_size = 2
 fill = bpy.data.objects.new('review-fill', fill_data)
 scene.collection.objects.link(fill)
 sun_data = bpy.data.lights.new('review-sun', 'SUN')
-sun_data.energy = 2.5
+# The engine dims its sun to 8% indoors; `review` keeps a full one so geometry reads everywhere.
+sun_data.energy = 2.5 if LIGHTING == 'review' else 2.5 * 0.08
 sun = bpy.data.objects.new('review-sun', sun_data)
 scene.collection.objects.link(sun)
 sun.rotation_euler = (math.radians(50), math.radians(15), math.radians(30))
+if LIGHTING == 'game':
+    fill.hide_render = True
+
+
+def hex_rgb(value) -> tuple[float, float, float]:
+    """`#rrggbb` (or a three.js colour number) to linear-ish rgb. The level JSON writes hex."""
+    if isinstance(value, str):
+        h = value.lstrip('#')
+        n = int(h, 16) if h else 0xFFFFFF
+    else:
+        n = int(value)
+    return (((n >> 16) & 255) / 255, ((n >> 8) & 255) / 255, (n & 255) / 255)
+
+
+def add_level_lights() -> int:
+    """The JSON's own lamps and spots as real EEVEE lights. three.js intensities are unitless and
+    Blender's are watts; 30 W per unit puts a default `lamp(intensity=8)` where the eye expects a
+    room light. The engine pools point lights (a room with eight lamps gets four in game) — this
+    lights all of them, so read brightness, not count."""
+    for light in level.get('lights', []):
+        color = hex_rgb(light.get('color', '#ffffff'))
+        if light['type'] == 'point':
+            data = bpy.data.lights.new(light['name'], 'POINT')
+            data.energy = light.get('intensity', 8.0) * 30
+            data.shadow_soft_size = 0.25
+            obj = bpy.data.objects.new(light['name'], data)
+            obj.location = to_blender(light['position'])
+        else:
+            data = bpy.data.lights.new(light['name'], 'SPOT')
+            data.energy = light.get('intensity', 20.0) * 30
+            # three.js `angle` is the half-cone; Blender's `spot_size` is the full one.
+            data.spot_size = min(light.get('angle', math.pi / 4) * 2, math.pi)
+            data.spot_blend = light.get('penumbra', 0.3)
+            data.shadow_soft_size = 0.1
+            data.use_shadow = bool(light.get('castShadow', True))
+            obj = bpy.data.objects.new(light['name'], data)
+            pos = Vector(to_blender(light['position']))
+            obj.location = pos
+            obj.rotation_euler = (Vector(to_blender(light['target'])) - pos).to_track_quat('-Z', 'Y').to_euler()
+        data.color = color
+        scene.collection.objects.link(obj)
+    return len(level.get('lights', []))
+
+
+if LIGHTING == 'game':
+    print(f'LIGHTING game — interior preset, {add_level_lights()} level lights, emissive materials as authored')
 
 
 def render(shot: dict) -> str:
@@ -77,8 +162,14 @@ def render(shot: dict) -> str:
         fill.hide_render = True
     else:
         cam_data.type = 'PERSP'
-        cam_data.lens = 24
-        fill.hide_render = False
+        fov = shot.get('fov', FOV)
+        if fov:
+            cam_data.lens_unit = 'FOV'
+            cam_data.angle = math.radians(fov)
+        else:
+            cam_data.lens_unit = 'MILLIMETERS'
+            cam_data.lens = DEFAULT_LENS
+        fill.hide_render = LIGHTING == 'game'
         fill.location = pos + Vector((0, 0, 0.6))
     path = os.path.join(OUT, f"{shot['name']}.png")
     scene.render.filepath = path
@@ -86,10 +177,14 @@ def render(shot: dict) -> str:
     return path
 
 
-shots = review_cameras(level, doors)
+shots = [] if ONLY else review_cameras(level, doors)
+shots += [custom_shot(spec, i + 1, level, doors, FOV) for i, spec in enumerate(SHOT_SPECS)]
 paths = [render(s) for s in shots]
 for s, p in zip(shots, paths):
-    print(f'SHOT {s["name"]} -> {p}')
+    print(f"SHOT {s['name']} -> {p}" + (f"  ({s['spec']})" if 'spec' in s else ''))
+
+if ONLY:
+    sys.exit(0)
 
 # Contact sheet: every shot at half size, four per row, labelled by file name in the log.
 import numpy as np  # Blender bundles numpy  # noqa: E402

package/assets/blender-level/tests/test_core.py

@@ -185,5 +185,54 @@ class SyncWorldTests(unittest.TestCase):
         self.assertEqual({d['id'] for d in merged}, {'front', 'gone', 'new'})
 
 
+class ShotSpecTests(unittest.TestCase):
+    """`--shot` specs: the ad-hoc camera review.py aims from the level JSON."""
+
+    LEVEL = {
+        'colliders': [{'shape': 'box', 'position': [0, 0, 0], 'size': [10, 1, 10], 'yaw': 0}],
+        'landmarks': [{'name': 'spawn', 'position': [1, 0.1, 2], 'yaw': 0, 'tags': []}],
+        'volumes': [{'name': 'hall', 'position': [0, 1.75, 0], 'size': [12, 3.5, 8], 'yaw': 0, 'tags': []}],
+    }
+    DOORS = [{'id': 'north', 'position': {'x': 0, 'y': 1.1, 'z': -4}, 'rotationY': 0, 'width': 1.4, 'height': 2.2}]
+
+    def test_landmark_is_an_eye_at_the_from_end_and_the_thing_at_the_to_end(self):
+        self.assertEqual(core.resolve_point('landmark:spawn', self.LEVEL, as_eye=True), (1, 0.1 + core.EYE_HEIGHT, 2))
+        self.assertEqual(core.resolve_point('landmark:spawn', self.LEVEL), (1, 1.1, 2))
+
+    def test_volume_from_is_eye_height_above_its_floor_and_to_is_its_centre(self):
+        self.assertEqual(core.resolve_point('volume:hall', self.LEVEL, as_eye=True), (0, 1.75 - 1.75 + core.EYE_HEIGHT, 0))
+        self.assertEqual(core.resolve_point('volume:hall', self.LEVEL), (0, 1.75, 0))
+
+    def test_door_from_is_eye_height_above_its_threshold(self):
+        self.assertEqual(core.resolve_point('door:north', self.LEVEL, self.DOORS, as_eye=True), (0, 1.1 - 1.1 + core.EYE_HEIGHT, -4))
+        self.assertEqual(core.resolve_point('door:north', self.LEVEL, self.DOORS), (0, 1.1, -4))
+
+    def test_raw_coordinates_are_used_exactly_at_either_end(self):
+        self.assertEqual(core.resolve_point('3, -1.5,7', self.LEVEL, as_eye=True), (3.0, -1.5, 7.0))
+        self.assertEqual(core.resolve_point('3,-1.5,7', self.LEVEL), (3.0, -1.5, 7.0))
+
+    def test_an_unknown_name_lists_the_known_ones(self):
+        with self.assertRaises(ValueError) as raised:
+            core.resolve_point('landmark:altar', self.LEVEL)
+        self.assertIn('spawn', str(raised.exception))
+        with self.assertRaises(ValueError):
+            core.resolve_point('nonsense', self.LEVEL)
+
+    def test_a_shot_without_a_target_looks_at_the_level_centre(self):
+        shot = core.custom_shot('landmark:spawn', 1, self.LEVEL, self.DOORS)
+        self.assertEqual(shot['name'], 'shot-1')
+        self.assertEqual(shot['kind'], 'persp')
+        self.assertEqual(shot['target'], core.level_center(self.LEVEL))
+        self.assertNotIn('fov', shot)
+
+    def test_a_from_to_shot_carries_both_ends_and_the_fov(self):
+        shot = core.custom_shot('landmark:spawn -> volume:hall', 2, self.LEVEL, self.DOORS, fov=70)
+        self.assertEqual(shot['name'], 'shot-2')
+        self.assertEqual(shot['position'], (1, 0.1 + core.EYE_HEIGHT, 2))
+        self.assertEqual(shot['target'], (0, 1.75, 0))
+        self.assertEqual(shot['fov'], 70)
+        self.assertEqual(shot['spec'], 'landmark:spawn -> volume:hall')
+
+
 if __name__ == '__main__':
     unittest.main()

package/dist/editor/game-info-panel.d.ts

@@ -22,7 +22,7 @@
  * name, in the weight the bar already gave it, that happens to be clickable. Only the hover and
  * focus treatments are added, so it reads as a control the moment a pointer is near it.
  */
-export declare const GAME_INFO_PANEL_CSS = "\n  /* The name IS the button. Bold and white like the label it replaces, with the id and env it\n     absorbed now one click away rather than two more slots in the bar. */\n  #game-info-toggle {\n    display: flex;\n    align-items: center;\n    gap: 6px;\n    max-width: 26vw;\n    padding: 4px 8px;\n    background: transparent;\n    border: 1px solid transparent;\n    border-radius: 6px;\n    color: var(--bm-text);\n    font-family: var(--bm-font);\n    font-size: 14px;\n    font-weight: 700;\n    line-height: 1.2;\n    cursor: pointer;\n    transition: background .15s ease, border-color .15s ease;\n  }\n  #game-info-toggle:hover { background: var(--bm-surface-alt); border-color: var(--bm-border-muted); }\n  #game-info-toggle:focus-visible { outline: none; box-shadow: var(--bm-focus-ring); }\n  #game-info-toggle .name { overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }\n  /* The affordance. Dim, so the name still reads as the name rather than as a menu. */\n  #game-info-toggle .chevron { flex: none; color: var(--bm-text-dim); font-size: 10px; }\n\n  /* Level with the other two dialogs: all three are opened from different controls and never\n     stack. */\n  #info-overlay { z-index: 10; }\n  #info-dialog { width: min(560px, 92vw); max-height: 86vh; overflow-y: auto; padding: 20px; }\n  #info-dialog h2 { margin-bottom: 16px; }\n  /* A definition list, because that is what this is: a fixed set of fields with one value each.\n     Two columns so the values line up and the whole block is scannable without reading it. */\n  #info-facts { display: grid; grid-template-columns: auto 1fr; gap: 8px 16px; margin: 0 0 20px; }\n  #info-facts dt { font-size: 12px; font-weight: 700; text-transform: uppercase;\n                   letter-spacing: 1.4px; color: var(--bm-text-muted); }\n  #info-facts dd { margin: 0; min-width: 0; color: var(--bm-text); overflow-wrap: anywhere; }\n  /* Ids, versions and modes are read character by character; names and genres are read as words. */\n  #info-facts dd.mono { font-family: var(--bm-font-mono); font-size: 12px; }\n  #info-facts dd .note { color: var(--bm-text-dim); }\n  /* The two pictures, side by side: they are the same kind of thing and are compared, not read\n     in order. They wrap to one column when the dialog is at its narrowest. */\n  #info-art { display: flex; flex-wrap: wrap; gap: 16px; }\n  .info-art-card { flex: 1 1 200px; min-width: 0; }\n  .info-art-card .bm-label { display: block; margin-bottom: 8px; }\n  /* A square frame either way, so a present picture and a missing one leave the dialog the same\n     height and the two cards stay level. */\n  .info-art-frame {\n    display: flex;\n    align-items: center;\n    justify-content: center;\n    aspect-ratio: 1 / 1;\n    padding: 12px;\n    background: var(--bm-surface-alt);\n    border: 1px solid var(--bm-border-muted);\n    border-radius: 6px;\n    text-align: center;\n  }\n  /* The frame holds the picture AND the \"not yet\" copy, and shows exactly one of them: the class\n     is applied by openInfo(), because a page assembled as a string has no inline styles to toggle\n     (DESIGN.md, and the same rule the Creator follows). */\n  .info-art-frame img { display: none; max-width: 100%; max-height: 100%; border-radius: 4px; }\n  .info-art-frame.has-image img { display: block; }\n  .info-art-frame.has-image .empty { display: none; }\n  /* What to run to make the missing one, rather than the bare fact that it is missing. */\n  .info-art-frame .empty { font-size: 12px; color: var(--bm-text-dim); }\n  .info-art-frame .empty code { display: block; margin-top: 6px; color: var(--bm-aqua);\n                                font-family: var(--bm-font-mono); }\n  .info-art-card .caption { margin-top: 8px; font-size: 12px; color: var(--bm-text-dim);\n                            overflow-wrap: anywhere; }\n  .info-art-card .caption a { color: var(--bm-aqua); text-decoration: none; }\n  .info-art-card .caption a:hover { text-decoration: underline; }\n  /* An expiring reference URL is the one thing on this card worth interrupting for. */\n  .info-art-card .caption .stale { color: var(--bm-pumpkin); }\n  /* The sidecar could not answer. Said in the dialog rather than in the bar's status line, which\n     belongs to the save state and would be overwritten by the next poll. */\n  #info-error { display: none; margin: 0 0 16px; font-size: 12px; color: var(--bm-pumpkin); }\n  #info-error.show { display: block; }\n  #info-actions { display: flex; justify-content: flex-end; margin-top: 20px; }\n";
+export declare const GAME_INFO_PANEL_CSS = "\n  /* The name IS the button. Bold and white like the label it replaces, with the id and env it\n     absorbed now one click away rather than two more slots in the bar. */\n  #game-info-toggle {\n    display: flex;\n    align-items: center;\n    gap: 6px;\n    max-width: 26vw;\n    padding: 4px 8px;\n    background: transparent;\n    border: 1px solid transparent;\n    border-radius: 6px;\n    color: var(--bm-text);\n    font-family: var(--bm-font);\n    font-size: 14px;\n    font-weight: 700;\n    line-height: 1.2;\n    cursor: pointer;\n    transition: background .15s ease, border-color .15s ease;\n  }\n  #game-info-toggle:hover { background: var(--bm-surface-alt); border-color: var(--bm-border-muted); }\n  #game-info-toggle:focus-visible { outline: none; box-shadow: var(--bm-focus-ring); }\n  #game-info-toggle .name { overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }\n  /* The affordance. Dim, so the name still reads as the name rather than as a menu. */\n  #game-info-toggle .chevron { flex: none; color: var(--bm-text-dim); font-size: 10px; }\n\n  /* Level with the other two dialogs: all three are opened from different controls and never\n     stack. */\n  #info-overlay { z-index: 10; }\n  #info-dialog { width: min(560px, 92vw); max-height: 86vh; overflow-y: auto; padding: 20px; }\n  #info-dialog h2 { margin-bottom: 16px; }\n  /* A definition list, because that is what this is: a fixed set of fields with one value each.\n     Two columns so the values line up and the whole block is scannable without reading it. */\n  #info-facts { display: grid; grid-template-columns: auto 1fr; gap: 8px 16px; margin: 0 0 20px; }\n  #info-facts dt { font-size: 12px; font-weight: 700; text-transform: uppercase;\n                   letter-spacing: 1.4px; color: var(--bm-text-muted); }\n  #info-facts dd { margin: 0; min-width: 0; color: var(--bm-text); overflow-wrap: anywhere; }\n  /* Ids, versions and modes are read character by character; names and genres are read as words. */\n  #info-facts dd.mono { font-family: var(--bm-font-mono); font-size: 12px; }\n  #info-facts dd .note { color: var(--bm-text-dim); }\n  /* The two pictures, side by side: they are the same kind of thing and are compared, not read\n     in order. They wrap to one column when the dialog is at its narrowest. */\n  #info-art { display: flex; flex-wrap: wrap; gap: 16px; }\n  .info-art-card { flex: 1 1 200px; min-width: 0; }\n  .info-art-card .bm-label { display: block; margin-bottom: 8px; }\n  /* A square frame either way, so a present picture and a missing one leave the dialog the same\n     height and the two cards stay level.\n\n     A button rather than a div, because with a picture in it that is what it is: the thumbnail is\n     a couple of hundred pixels of an image generated at 1024, which is not enough to judge the\n     look it is supposed to fix \u2014 clicking it opens the full size. Disabled while the card is\n     empty, so the control is dead exactly when there is nothing to open, and reachable by keyboard\n     for free either way. */\n  .info-art-frame {\n    display: flex;\n    align-items: center;\n    justify-content: center;\n    width: 100%;\n    aspect-ratio: 1 / 1;\n    padding: 12px;\n    background: var(--bm-surface-alt);\n    border: 1px solid var(--bm-border-muted);\n    border-radius: 6px;\n    color: inherit;\n    font: inherit;\n    text-align: center;\n    cursor: zoom-in;\n    transition: border-color .15s ease;\n  }\n  .info-art-frame:hover:not(:disabled) { border-color: var(--bm-text-dim); }\n  .info-art-frame:focus-visible { outline: none; box-shadow: var(--bm-focus-ring); }\n  /* Not dimmed like an ordinary disabled control: there is nothing to enable here, and greying the\n     \"not yet\" copy would hide the command that fixes it. */\n  .info-art-frame:disabled { cursor: default; }\n  /* The frame holds the picture AND the \"not yet\" copy, and shows exactly one of them: the class\n     is applied by openInfo(), because a page assembled as a string has no inline styles to toggle\n     (DESIGN.md, and the same rule the Creator follows). */\n  .info-art-frame img { display: none; max-width: 100%; max-height: 100%; border-radius: 4px; }\n  .info-art-frame.has-image img { display: block; }\n  .info-art-frame.has-image .empty { display: none; }\n  /* What to run to make the missing one, rather than the bare fact that it is missing. */\n  .info-art-frame .empty { font-size: 12px; color: var(--bm-text-dim); }\n  .info-art-frame .empty code { display: block; margin-top: 6px; color: var(--bm-aqua);\n                                font-family: var(--bm-font-mono); }\n  .info-art-card .caption { margin-top: 8px; font-size: 12px; color: var(--bm-text-dim);\n                            overflow-wrap: anywhere; }\n  .info-art-card .caption a { color: var(--bm-aqua); text-decoration: none; }\n  .info-art-card .caption a:hover { text-decoration: underline; }\n  /* An expiring reference URL is the one thing on this card worth interrupting for. */\n  .info-art-card .caption .stale { color: var(--bm-pumpkin); }\n  /* === The full-size view ===================================================================\n     A layer of its own above the dialog rather than a new browser tab: the dev view is the window\n     the creator is already in, and a tab showing a bare image on a loopback port is a place they\n     then have to come back from. Click anywhere, or Escape, and the dialog is still underneath\n     exactly as it was. */\n  #info-zoom { z-index: 11; flex-direction: column; gap: 12px; cursor: zoom-out; }\n  #info-zoom img { max-width: 92vw; max-height: 84vh; border-radius: 6px;\n                   box-shadow: var(--bm-shadow-dialog); }\n  #info-zoom .hint { font-size: 12px; color: var(--bm-text-muted); }\n\n  /* The sidecar could not answer. Said in the dialog rather than in the bar's status line, which\n     belongs to the save state and would be overwritten by the next poll. */\n  #info-error { display: none; margin: 0 0 16px; font-size: 12px; color: var(--bm-pumpkin); }\n  #info-error.show { display: block; }\n  #info-actions { display: flex; justify-content: flex-end; margin-top: 20px; }\n";
 /**
  * Markup for the Game-info dialog.
  *
@@ -30,4 +30,4 @@ export declare const GAME_INFO_PANEL_CSS = "\n  /* The name IS the button. Bold
  * interpolated at render time: this page is built once when the server starts, and `bitmagic
  * cover` or `bitmagic reference accept` usually runs hours later in another terminal.
  */
-export declare const GAME_INFO_PANEL_HTML = "  <div id=\"info-overlay\" class=\"bm-overlay\">\n    <div id=\"info-dialog\" class=\"bm-dialog\">\n      <h2 id=\"info-title\"></h2>\n      <p id=\"info-error\"></p>\n      <dl id=\"info-facts\">\n        <dt>Game id</dt><dd id=\"info-game-id\" class=\"mono\"></dd>\n        <dt>Environment</dt><dd id=\"info-environment\" class=\"mono\"></dd>\n        <dt>Genre</dt><dd id=\"info-genre\"></dd>\n        <dt>Physics</dt><dd id=\"info-physics\" class=\"mono\"></dd>\n        <dt>Art style</dt><dd id=\"info-art-style\"></dd>\n        <dt>Platform</dt><dd id=\"info-platform\"></dd>\n        <dt>Engine</dt><dd id=\"info-engine\" class=\"mono\"></dd>\n      </dl>\n      <div id=\"info-art\">\n        <div class=\"info-art-card\">\n          <span class=\"bm-label\">Reference image</span>\n          <div id=\"info-reference-frame\" class=\"info-art-frame\">\n            <img id=\"info-reference-img\" alt=\"This game's accepted reference image\">\n            <span id=\"info-reference-empty\" class=\"empty\">No reference image yet.<code>bitmagic reference make</code></span>\n          </div>\n          <p id=\"info-reference-caption\" class=\"caption\"></p>\n        </div>\n        <div class=\"info-art-card\">\n          <span class=\"bm-label\">Cover art</span>\n          <div id=\"info-cover-frame\" class=\"info-art-frame\">\n            <img id=\"info-cover-img\" alt=\"This game's cover art\">\n            <span id=\"info-cover-empty\" class=\"empty\">No cover art yet.<code>bitmagic cover</code></span>\n          </div>\n          <p id=\"info-cover-caption\" class=\"caption\"></p>\n        </div>\n      </div>\n      <div id=\"info-actions\">\n        <button id=\"info-close\" class=\"bm-pill bm-pill--primary\" type=\"button\">Close</button>\n      </div>\n    </div>\n  </div>\n";
+export declare const GAME_INFO_PANEL_HTML = "  <div id=\"info-overlay\" class=\"bm-overlay\">\n    <div id=\"info-dialog\" class=\"bm-dialog\">\n      <h2 id=\"info-title\"></h2>\n      <p id=\"info-error\"></p>\n      <dl id=\"info-facts\">\n        <dt>Game id</dt><dd id=\"info-game-id\" class=\"mono\"></dd>\n        <dt>Environment</dt><dd id=\"info-environment\" class=\"mono\"></dd>\n        <dt>Genre</dt><dd id=\"info-genre\"></dd>\n        <dt>Physics</dt><dd id=\"info-physics\" class=\"mono\"></dd>\n        <dt>Art style</dt><dd id=\"info-art-style\"></dd>\n        <dt>Platform</dt><dd id=\"info-platform\"></dd>\n        <dt>Engine</dt><dd id=\"info-engine\" class=\"mono\"></dd>\n      </dl>\n      <div id=\"info-art\">\n        <div class=\"info-art-card\">\n          <span class=\"bm-label\">Reference image</span>\n          <button id=\"info-reference-frame\" class=\"info-art-frame\" type=\"button\" disabled title=\"See it full size\">\n            <img id=\"info-reference-img\" alt=\"This game's accepted reference image\">\n            <span id=\"info-reference-empty\" class=\"empty\">No reference image yet.<code>bitmagic reference make</code></span>\n          </button>\n          <p id=\"info-reference-caption\" class=\"caption\"></p>\n        </div>\n        <div class=\"info-art-card\">\n          <span class=\"bm-label\">Cover art</span>\n          <button id=\"info-cover-frame\" class=\"info-art-frame\" type=\"button\" disabled title=\"See it full size\">\n            <img id=\"info-cover-img\" alt=\"This game's cover art\">\n            <span id=\"info-cover-empty\" class=\"empty\">No cover art yet.<code>bitmagic cover</code></span>\n          </button>\n          <p id=\"info-cover-caption\" class=\"caption\"></p>\n        </div>\n      </div>\n      <div id=\"info-actions\">\n        <button id=\"info-close\" class=\"bm-pill bm-pill--primary\" type=\"button\">Close</button>\n      </div>\n    </div>\n  </div>\n  <div id=\"info-zoom\" class=\"bm-overlay\">\n    <img id=\"info-zoom-img\" alt=\"\">\n    <span class=\"hint\">Click anywhere to go back.</span>\n  </div>\n";

package/dist/editor/game-info-panel.js

@@ -68,18 +68,34 @@ export const GAME_INFO_PANEL_CSS = `
   .info-art-card { flex: 1 1 200px; min-width: 0; }
   .info-art-card .bm-label { display: block; margin-bottom: 8px; }
   /* A square frame either way, so a present picture and a missing one leave the dialog the same
-     height and the two cards stay level. */
+     height and the two cards stay level.
+
+     A button rather than a div, because with a picture in it that is what it is: the thumbnail is
+     a couple of hundred pixels of an image generated at 1024, which is not enough to judge the
+     look it is supposed to fix — clicking it opens the full size. Disabled while the card is
+     empty, so the control is dead exactly when there is nothing to open, and reachable by keyboard
+     for free either way. */
   .info-art-frame {
     display: flex;
     align-items: center;
     justify-content: center;
+    width: 100%;
     aspect-ratio: 1 / 1;
     padding: 12px;
     background: var(--bm-surface-alt);
     border: 1px solid var(--bm-border-muted);
     border-radius: 6px;
+    color: inherit;
+    font: inherit;
     text-align: center;
+    cursor: zoom-in;
+    transition: border-color .15s ease;
   }
+  .info-art-frame:hover:not(:disabled) { border-color: var(--bm-text-dim); }
+  .info-art-frame:focus-visible { outline: none; box-shadow: var(--bm-focus-ring); }
+  /* Not dimmed like an ordinary disabled control: there is nothing to enable here, and greying the
+     "not yet" copy would hide the command that fixes it. */
+  .info-art-frame:disabled { cursor: default; }
   /* The frame holds the picture AND the "not yet" copy, and shows exactly one of them: the class
      is applied by openInfo(), because a page assembled as a string has no inline styles to toggle
      (DESIGN.md, and the same rule the Creator follows). */
@@ -96,6 +112,16 @@ export const GAME_INFO_PANEL_CSS = `
   .info-art-card .caption a:hover { text-decoration: underline; }
   /* An expiring reference URL is the one thing on this card worth interrupting for. */
   .info-art-card .caption .stale { color: var(--bm-pumpkin); }
+  /* === The full-size view ===================================================================
+     A layer of its own above the dialog rather than a new browser tab: the dev view is the window
+     the creator is already in, and a tab showing a bare image on a loopback port is a place they
+     then have to come back from. Click anywhere, or Escape, and the dialog is still underneath
+     exactly as it was. */
+  #info-zoom { z-index: 11; flex-direction: column; gap: 12px; cursor: zoom-out; }
+  #info-zoom img { max-width: 92vw; max-height: 84vh; border-radius: 6px;
+                   box-shadow: var(--bm-shadow-dialog); }
+  #info-zoom .hint { font-size: 12px; color: var(--bm-text-muted); }
+
   /* The sidecar could not answer. Said in the dialog rather than in the bar's status line, which
      belongs to the save state and would be overwritten by the next poll. */
   #info-error { display: none; margin: 0 0 16px; font-size: 12px; color: var(--bm-pumpkin); }
@@ -125,18 +151,18 @@ export const GAME_INFO_PANEL_HTML = `  <div id="info-overlay" class="bm-overlay"
       <div id="info-art">
         <div class="info-art-card">
           <span class="bm-label">Reference image</span>
-          <div id="info-reference-frame" class="info-art-frame">
+          <button id="info-reference-frame" class="info-art-frame" type="button" disabled title="See it full size">
             <img id="info-reference-img" alt="This game's accepted reference image">
             <span id="info-reference-empty" class="empty">No reference image yet.<code>bitmagic reference make</code></span>
-          </div>
+          </button>
           <p id="info-reference-caption" class="caption"></p>
         </div>
         <div class="info-art-card">
           <span class="bm-label">Cover art</span>
-          <div id="info-cover-frame" class="info-art-frame">
+          <button id="info-cover-frame" class="info-art-frame" type="button" disabled title="See it full size">
             <img id="info-cover-img" alt="This game's cover art">
             <span id="info-cover-empty" class="empty">No cover art yet.<code>bitmagic cover</code></span>
-          </div>
+          </button>
           <p id="info-cover-caption" class="caption"></p>
         </div>
       </div>
@@ -145,5 +171,9 @@ export const GAME_INFO_PANEL_HTML = `  <div id="info-overlay" class="bm-overlay"
       </div>
     </div>
   </div>
+  <div id="info-zoom" class="bm-overlay">
+    <img id="info-zoom-img" alt="">
+    <span class="hint">Click anywhere to go back.</span>
+  </div>
 `;
 //# sourceMappingURL=game-info-panel.js.map

package/dist/editor/game-info-panel.js.map

@@ -1 +1 @@
-{"version":3,"file":"game-info-panel.js","sourceRoot":"","sources":["../../src/editor/game-info-panel.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,mBAAmB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+ElC,CAAC;AAEF;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,oBAAoB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoCnC,CAAC"}
+{"version":3,"file":"game-info-panel.js","sourceRoot":"","sources":["../../src/editor/game-info-panel.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,mBAAmB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyGlC,CAAC;AAEF;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,oBAAoB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwCnC,CAAC"}

package/dist/editor/shell-page.js

@@ -379,6 +379,10 @@ ${ASSET_DETAIL_HTML}
   var infoCoverFrame = document.getElementById('info-cover-frame');
   var infoCoverImg = document.getElementById('info-cover-img');
   var infoCoverCaption = document.getElementById('info-cover-caption');
+  var infoZoom = document.getElementById('info-zoom');
+  var infoZoomImg = document.getElementById('info-zoom-img');
+  /** Which thumbnail opened the full-size layer, so closing it gives focus back. */
+  var zoomOrigin = null;
   /** The last publish the poll saw, or null until this project has had one. */
   var lastPublish = null;
   var recordToggle = document.getElementById('record');
@@ -1283,6 +1287,9 @@ ${ASSET_DETAIL_HTML}
     caption.textContent = '';
     img.removeAttribute('src');
     frame.classList.remove('has-image');
+    // Dead exactly while there is nothing to open. Re-disabled on every fill, because the picture
+    // that was there last time may have been cleared since.
+    frame.disabled = true;
     if (!image) return;
     // Prefix tests rather than a regex: a slash inside one would have to be double-escaped to
     // survive this literal, and that is the exact trap shell-page.test.ts exists to catch.
@@ -1305,9 +1312,13 @@ ${ASSET_DETAIL_HTML}
           return;
         }
         frame.classList.remove('has-image');
+        // The card is back to its "not yet" copy, so the control that opens a picture must go
+        // dead with it rather than open an empty layer.
+        frame.disabled = true;
       };
       img.src = src;
       frame.classList.add('has-image');
+      frame.disabled = false;
     }
     var label = image.candidateId || (kind === 'cover' ? 'Cover image' : 'Reference image');
     if (remote) {
@@ -1339,6 +1350,33 @@ ${ASSET_DETAIL_HTML}
     infoToggle.focus();
   }
 
+  /**
+   * The picture at full size, on a layer above the dialog.
+   *
+   * The thumbnail is a couple of hundred pixels of an image generated at 1024, which is not enough
+   * to judge the look it exists to fix. A layer rather than a new tab: the dev view is the window
+   * the creator is already in, and the dialog is still underneath when they come back.
+   *
+   * Reuses the thumbnail's own resolved src, so whichever source that one settled on (the local
+   * bytes, or the recorded URL after the fallback) is the one that opens \u2014 the browser has it
+   * decoded already, and this cannot fail where the thumbnail succeeded.
+   */
+  function openZoom(frame, img) {
+    if (!img.getAttribute('src')) return;
+    zoomOrigin = frame;
+    infoZoomImg.src = img.src;
+    infoZoomImg.alt = img.alt;
+    infoZoom.classList.add('show');
+  }
+
+  function closeZoom() {
+    infoZoom.classList.remove('show');
+    infoZoomImg.removeAttribute('src');
+    // Back to the thumbnail that opened it, which is where the eye already is.
+    if (zoomOrigin && infoOverlay.classList.contains('show')) zoomOrigin.focus();
+    zoomOrigin = null;
+  }
+
   /**
    * The Record panel — the Creator's Dev Tools recording settings, worn by this lane.
    *
@@ -2385,6 +2423,7 @@ ${ASSET_DETAIL_HTML}
     if (closeRecordingPanel()) return;
     if (closeMotionPanel()) return;
     if (publishOverlay.classList.contains('show')) { closePublish(); return; }
+    if (infoZoom.classList.contains('show')) { closeZoom(); return; }
     if (infoOverlay.classList.contains('show')) { closeInfo(); return; }
     hqOverlay.classList.remove('show');
   });
@@ -2719,6 +2758,10 @@ ${ASSET_DETAIL_HTML}
   });
 
   infoToggle.addEventListener('click', function () { void openInfo(); });
+  infoReferenceFrame.addEventListener('click', function () { openZoom(infoReferenceFrame, infoReferenceImg); });
+  infoCoverFrame.addEventListener('click', function () { openZoom(infoCoverFrame, infoCoverImg); });
+  // Anywhere: the whole layer is the picture and the way back out of it.
+  infoZoom.addEventListener('click', closeZoom);
   infoClose.addEventListener('click', closeInfo);
   infoOverlay.addEventListener('click', function (event) {
     if (event.target === infoOverlay) closeInfo();

package/dist/editor/shell-page.js.map

@@ -1 +1 @@
-{"version":3,"file":"shell-page.js","sourceRoot":"","sources":["../../src/editor/shell-page.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiDG;AAEH,OAAO,EACL,qBAAqB,EAAE,kBAAkB,GAC1C,MAAM,qDAAqD,CAAC;AAC7D,OAAO,EAAE,iBAAiB,EAAE,MAAM,+CAA+C,CAAC;AAClF,OAAO,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AAC9E,OAAO,EAAE,mBAAmB,EAAE,oBAAoB,EAAE,MAAM,sBAAsB,CAAC;AACjF,OAAO,EAAE,iBAAiB,EAAE,kBAAkB,EAAE,MAAM,oBAAoB,CAAC;AAC3E,OAAO,EAAE,mBAAmB,EAAE,oBAAoB,EAAE,qBAAqB,EAAE,MAAM,sBAAsB,CAAC;AACxG,OAAO,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AACrD,OAAO,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AACzF,OAAO,EAAE,eAAe,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AACrE,OAAO,EAAE,qBAAqB,EAAE,kBAAkB,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAC;AAE7F,oGAAoG;AACpG,MAAM,gBAAgB,GAAG,GAAG,CAAC;AAE7B;;;;;;GAMG;AACH,MAAM,gBAAgB,GAAG,GAAG,CAAC;AAE7B;;;;;;;;;;;;GAYG;AACH,SAAS,sBAAsB;IAC7B,OAAO;QACL,6BAA6B,IAAI,CAAC,SAAS,CAAC,iBAAiB,CAAC,GAAG;QACjE,iCAAiC,qBAAqB,CAAC,QAAQ,EAAE,GAAG;QACpE,8BAA8B,kBAAkB,CAAC,QAAQ,EAAE,GAAG;KAC/D,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;AACjB,CAAC;AAED;;;;;;GAMG;AACH,MAAM,qBAAqB,GAAG,IAAI,CAAC;AAEnC,kGAAkG;AAClG,SAAS,UAAU,CAAC,KAAa;IAC/B,OAAO,KAAK;SACT,OAAO,CAAC,IAAI,EAAE,OAAO,CAAC;SACtB,OAAO,CAAC,IAAI,EAAE,QAAQ,CAAC;SACvB,OAAO,CAAC,IAAI,EAAE,MAAM,CAAC;SACrB,OAAO,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC;AAC3B,CAAC;AAmBD,oGAAoG;AACpG,MAAM,oBAAoB,GAAG,cAAc,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;AAElE,MAAM,UAAU,iBAAiB,CAAC,OAA2B;IAC3D,MAAM,OAAO,GAAG,oBAAoB,OAAO,CAAC,QAAQ,2BAA2B,kBAAkB,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE,CAAC;IACpH,MAAM,OAAO,GAAG,OAAO,CAAC,OAAO,KAAK,KAAK,CAAC;IAC1C,MAAM,SAAS,GAAG,OAAO;QACvB,CAAC,CAAC,YAAY,OAAO,CAAC,UAAU,uDAAuD;QACvF,CAAC,CAAC,YAAY,OAAO,CAAC,UAAU,qCAAqC,CAAC;IACxE,MAAM,KAAK,GAAG,GAAG,OAAO,CAAC,QAAQ,kBAAkB,OAAO,CAAC,CAAC,CAAC,cAAc,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC;IACnF,OAAO;;;;SAIA,UAAU,CAAC,KAAK,CAAC;EACxB,kBAAkB;;EAElB,mBAAmB;EACnB,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA+HrB,gBAAgB;EAChB,mBAAmB;EACnB,iBAAiB;EACjB,mBAAmB;EACnB,gBAAgB;EAChB,eAAe;;;;;;yCAMwB,OAAO,CAAC,CAAC,CAAC,oBAAoB,CAAC,CAAC,CAAC,EAAE,YAAY,UAAU,CAAC,SAAS,CAAC,KAAK,OAAO,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC,CAAC,SAAS;mJACA,UAAU,CAAC,OAAO,CAAC,QAAQ,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA4C7K,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;EAyBhB,oBAAoB;EACpB,kBAAkB;EAClB,oBAAoB;EACpB,iBAAiB;EACjB,iBAAiB;;;;mBAIA,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC;kBACxB,gBAAgB;yBACT,qBAAqB;2BACnB,gBAAgB;;IAEvC,sBAAsB,EAAE;;;;;;;;0BAQF,IAAI,CAAC,SAAS,CAAC,qBAAqB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAs/BvC,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAq1C1C,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmChB,CAAC;AACF,CAAC"}
+{"version":3,"file":"shell-page.js","sourceRoot":"","sources":["../../src/editor/shell-page.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiDG;AAEH,OAAO,EACL,qBAAqB,EAAE,kBAAkB,GAC1C,MAAM,qDAAqD,CAAC;AAC7D,OAAO,EAAE,iBAAiB,EAAE,MAAM,+CAA+C,CAAC;AAClF,OAAO,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AAC9E,OAAO,EAAE,mBAAmB,EAAE,oBAAoB,EAAE,MAAM,sBAAsB,CAAC;AACjF,OAAO,EAAE,iBAAiB,EAAE,kBAAkB,EAAE,MAAM,oBAAoB,CAAC;AAC3E,OAAO,EAAE,mBAAmB,EAAE,oBAAoB,EAAE,qBAAqB,EAAE,MAAM,sBAAsB,CAAC;AACxG,OAAO,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AACrD,OAAO,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AACzF,OAAO,EAAE,eAAe,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AACrE,OAAO,EAAE,qBAAqB,EAAE,kBAAkB,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAC;AAE7F,oGAAoG;AACpG,MAAM,gBAAgB,GAAG,GAAG,CAAC;AAE7B;;;;;;GAMG;AACH,MAAM,gBAAgB,GAAG,GAAG,CAAC;AAE7B;;;;;;;;;;;;GAYG;AACH,SAAS,sBAAsB;IAC7B,OAAO;QACL,6BAA6B,IAAI,CAAC,SAAS,CAAC,iBAAiB,CAAC,GAAG;QACjE,iCAAiC,qBAAqB,CAAC,QAAQ,EAAE,GAAG;QACpE,8BAA8B,kBAAkB,CAAC,QAAQ,EAAE,GAAG;KAC/D,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;AACjB,CAAC;AAED;;;;;;GAMG;AACH,MAAM,qBAAqB,GAAG,IAAI,CAAC;AAEnC,kGAAkG;AAClG,SAAS,UAAU,CAAC,KAAa;IAC/B,OAAO,KAAK;SACT,OAAO,CAAC,IAAI,EAAE,OAAO,CAAC;SACtB,OAAO,CAAC,IAAI,EAAE,QAAQ,CAAC;SACvB,OAAO,CAAC,IAAI,EAAE,MAAM,CAAC;SACrB,OAAO,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC;AAC3B,CAAC;AAmBD,oGAAoG;AACpG,MAAM,oBAAoB,GAAG,cAAc,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;AAElE,MAAM,UAAU,iBAAiB,CAAC,OAA2B;IAC3D,MAAM,OAAO,GAAG,oBAAoB,OAAO,CAAC,QAAQ,2BAA2B,kBAAkB,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE,CAAC;IACpH,MAAM,OAAO,GAAG,OAAO,CAAC,OAAO,KAAK,KAAK,CAAC;IAC1C,MAAM,SAAS,GAAG,OAAO;QACvB,CAAC,CAAC,YAAY,OAAO,CAAC,UAAU,uDAAuD;QACvF,CAAC,CAAC,YAAY,OAAO,CAAC,UAAU,qCAAqC,CAAC;IACxE,MAAM,KAAK,GAAG,GAAG,OAAO,CAAC,QAAQ,kBAAkB,OAAO,CAAC,CAAC,CAAC,cAAc,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC;IACnF,OAAO;;;;SAIA,UAAU,CAAC,KAAK,CAAC;EACxB,kBAAkB;;EAElB,mBAAmB;EACnB,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA+HrB,gBAAgB;EAChB,mBAAmB;EACnB,iBAAiB;EACjB,mBAAmB;EACnB,gBAAgB;EAChB,eAAe;;;;;;yCAMwB,OAAO,CAAC,CAAC,CAAC,oBAAoB,CAAC,CAAC,CAAC,EAAE,YAAY,UAAU,CAAC,SAAS,CAAC,KAAK,OAAO,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC,CAAC,SAAS;mJACA,UAAU,CAAC,OAAO,CAAC,QAAQ,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA4C7K,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;EAyBhB,oBAAoB;EACpB,kBAAkB;EAClB,oBAAoB;EACpB,iBAAiB;EACjB,iBAAiB;;;;mBAIA,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC;kBACxB,gBAAgB;yBACT,qBAAqB;2BACnB,gBAAgB;;IAEvC,sBAAsB,EAAE;;;;;;;;0BAQF,IAAI,CAAC,SAAS,CAAC,qBAAqB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBA4hCvC,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA01C1C,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmChB,CAAC;AACF,CAAC"}

package/dist/scaffold/blender-level-skill-files.d.ts

@@ -16,6 +16,13 @@
  * and everything else goes to `bitmagic forge`. The CLI cannot tell which model drives it, so the
  * gate is the agent's own call — stated once, plainly, where the planning skill sends it.
  *
+ * Steps 4-9 are shaped around two loops, because the first creator to use this took the whole
+ * chain — build, upload, verify, judge — round on every edit, and the costs are nothing alike: a
+ * Blender build, render and ray audit are seconds and local, while `assets add` uploads, `verify`
+ * type-checks and drives real Chrome, and `judge` spends sparks. So the geometry loop is named as
+ * the inner one, the engine handoff is gated on it being clean, and `review.py --lighting game`
+ * exists so even the lighting pass can stay inside it.
+ *
  * Backticks and `${` are escaped for the template literal; `project-files.test.ts` checks the
  * rendered frontmatter and that no escape leaks into the output.
  */

package/dist/scaffold/blender-level-skill-files.js

@@ -16,6 +16,13 @@
  * and everything else goes to `bitmagic forge`. The CLI cannot tell which model drives it, so the
  * gate is the agent's own call — stated once, plainly, where the planning skill sends it.
  *
+ * Steps 4-9 are shaped around two loops, because the first creator to use this took the whole
+ * chain — build, upload, verify, judge — round on every edit, and the costs are nothing alike: a
+ * Blender build, render and ray audit are seconds and local, while `assets add` uploads, `verify`
+ * type-checks and drives real Chrome, and `judge` spends sparks. So the geometry loop is named as
+ * the inner one, the engine handoff is gated on it being clean, and `review.py --lighting game`
+ * exists so even the lighting pass can stay inside it.
+ *
  * Backticks and `${` are escaped for the template literal; `project-files.test.ts` checks the
  * rendered frontmatter and that no escape leaks into the output.
  */
@@ -78,6 +85,10 @@ grep -qx 'build/' .gitignore || echo 'build/' >> .gitignore
 \`tools/blender-level/README.md\` lists what each file does. Level scripts go in \`tools/level/\`,
 outputs in \`build/level/\`.
 
+Run that install line again on an existing project too. It overwrites, and \`bitmagic upgrade\`
+re-renders this skill but NOT the scripts — so a flag named below that your copy does not
+recognise means the copy is old, not that the skill is wrong.
+
 ## 2. Plan the place in words, then as a table
 
 Write the \`## Art direction\` of \`GAME-DESIGN.md\` first — \`bitmagic judge\` scores against it, and a
@@ -128,7 +139,34 @@ Rules that are not style:
 - **Doors are records, not meshes.** \`door()\` writes a \`DoorDefinition\`; the engine builds and
   animates the leaf. \`jamb=\` adds solid jambs and a header so the wall reads as a doorway.
 
-## 4. Build
+## The two loops
+
+Everything below runs in one of two loops, and knowing which one you are in is the difference
+between building a level in a morning and building it in a day.
+
+**The Blender loop** — edit \`tools/level/<name>.py\` → build → look → audit. Seconds each, all
+local: nothing uploaded, no browser, no sparks. This is where the level is actually made, and you
+should go round it tens of times.
+
+**The engine handoff** — register the GLB → sync world.json → \`check\` → \`verify\` → \`judge\` →
+walk it in \`bitmagic dev\`. \`assets add\` uploads to the CDN, \`verify\` type-checks the project and
+drives a real Chrome through a settle loop, \`judge\` spends sparks and must not be run twice on
+one milestone. Run it at the END of a pass — never after an edit.
+
+**The gate: do not hand the level to the engine until the contact sheet has nothing wrong on it
+and both audit modes exit 0.** Every build writes \`build/level/<name>.glb\` already; that is free.
+Publishing it is what costs. A round trip through the engine to discover a hole in a floor is a
+round trip the audit would have made for nothing, and the station lost a day to exactly that.
+
+| The level is wrong like this | Found in |
+|---|---|
+| a hole in a floor, a doorway you cannot walk through, a route blocked by a prop, a room that is not sealed | the Blender loop — \`audit.py\`, both modes |
+| z-fighting, a blank wall, a sign that reads backwards, a missing ceiling, stairs ending in air, a wedge of sky beside a junction, the wrong footprint | the Blender loop — the contact sheet |
+| the level washed out or black, an empty published game, doors animating inside walls, no NPCs, the framerate | the engine handoff — nothing in Blender can see these |
+
+## The Blender loop
+
+### 4. Build
 
 \`\`\`
 "$BLENDER" -b --python tools/level/<name>.py
@@ -140,7 +178,7 @@ line to keep for step 7. Outputs: \`build/level/<name>.glb\` (one draw call per
 or geometry error prints a Python traceback naming the helper and the object — fix and rebuild;
 builds take seconds. \`python3 tools/level/<name>.py --dry-run\` gives the counts without Blender.
 
-## 5. Render and look
+### 5. Render and look
 
 \`\`\`
 "$BLENDER" -b --python tools/blender-level/review.py -- build/level/<name>.blend build/level/<name>.mesh-level.json build/level/review/
@@ -152,7 +190,23 @@ is missing, stairs that end in the air, a sign that reads backwards, two surface
 one another. Fix the script, rebuild, re-render. Do not go on to the audit while the sheet is
 wrong; the audit finds holes, not ugliness.
 
-## 6. Audit
+The fixed set is what you read first. After that the flags turn it into a camera you can aim, so
+a second look costs one render rather than a trip through the engine:
+
+\`\`\`
+… review.py -- <blend> <level json> <out dir> --shot 'landmark:spawn -> volume:hall' --only        # just this frame
+… review.py -- <blend> <level json> <out dir> --shot 'door:north door -> landmark:altar' --fov 50
+… review.py -- <blend> <level json> <out dir> --lighting game                                     # the lamps and spots you declared
+\`\`\`
+
+\`--shot 'FROM -> TO'\` takes \`landmark:<name>\`, \`volume:<name>\`, \`door:<id>\` or a raw \`x,y,z\`, and
+repeats; \`--only\` renders those instead of the standard set. \`--lighting game\` swaps the review
+fill for the engine's \`interior\` preset and the JSON's own \`lamp()\` / \`spot()\` records, which is
+how you judge the lighting pass without a verify — dark under \`--lighting game\` is dark in the
+game. Keep the default \`--lighting review\` while you are judging geometry: it is lit so that
+nothing can hide.
+
+### 6. Audit
 
 \`\`\`
 "$BLENDER" -b --python tools/blender-level/audit.py -- build/level/<name>.mesh-level.json                   # doors open: floors, doorways, routes
@@ -166,7 +220,16 @@ on the line between two rooms, a step that ends short); a failed \`sealed_envelo
 roof or wall. \`coplanar_overlap\` is a warning: two faces on one plane, which flicker. Never
 answer a failure by removing the volume or the link that found it.
 
-## 7. Register the GLB, sync world.json, write the game code
+A failure sends you back to step 4, not on to step 7. Both modes exiting 0 with a clean contact
+sheet is the whole gate; nothing below can be trusted until you have it.
+
+## The engine handoff — once per pass
+
+Steps 7 and 8 are the expensive half: an upload, a type-check, a real browser. Do them when the
+Blender loop has nothing left to say, and then do all of them — a partial handoff is what makes
+\`verify\` pass on stale files.
+
+### 7. Register the GLB, sync world.json, write the game code
 
 \`\`\`
 bitmagic assets add build/level/<name>.glb --name <name> --keep-glb --asset-id level-<name> --height <native height>   # the REGISTER line from step 4
@@ -197,7 +260,7 @@ this.playerController.configureFallRescue({ ...DEFAULT_FALL_RESCUE_OPTIONS, kill
 (\`npc.spawn(x, z, y)\` — pass the storey's Y for interiors), \`volumesAt(position)\` for room logic,
 the lighting modes, and \`samples/mesh-level-setup.ts\`.
 
-## 8. Check, verify, walk it
+### 8. Check, verify, walk it
 
 \`bitmagic check\`, then \`bitmagic verify\`: the console must show one \`[MeshLevel] loaded …\` line
 with the collider and light counts you expect, and no \`404\` for the GLB. Then walk it in the
@@ -205,16 +268,24 @@ with the collider and light counts you expect, and no \`404\` for the GLB. Then
 proves geometry, not that the place is good to be in. \`bitmagic verify --platform mobile\` too if
 phones matter.
 
+All three of step 7 again on every handoff — register with the SAME \`--asset-id\` (the entry is
+replaced), re-run \`sync_world.py\`, re-copy the JSON. Skip one and \`verify\` grades the previous
+build: the collider count in \`[MeshLevel] loaded …\` is how you catch it.
+
 ## 9. Judge, then iterate in passes
 
 \`bitmagic judge\` scores the verify screenshot against your art direction. Improve the level in
-passes, each one a full loop (edit script → build → review → audit → sync → verify):
+passes — and a pass is **many turns of the Blender loop followed by one handoff**, not a handoff
+per edit:
 
-1. **Structure** — rooms, doors, routes, stairs, the spawn. Audit clean, walkable.
+1. **Structure** — rooms, doors, routes, stairs, the spawn. Audit clean in both modes; the one
+   verify is for walking it in \`bitmagic dev\`, which is the only thing Blender cannot tell you.
 2. **Detail** — cladding, casings, coffers, deck plates, signage, props. All \`decor()\` unless the
-   player should bump into it; keep every travel clearance.
+   player should bump into it; keep every travel clearance. The sheet and the audit carry this
+   pass almost alone; the one verify is to confirm nothing regressed.
 3. **Surfaces and light** — materials, emissive strips, warm and cool lamps, a spot or two with
-   shadows. Look at it in the real game, not only in the render.
+   shadows. Render with \`--lighting game\` (step 5) until the rooms read, then verify and judge
+   once against the real thing.
 
 \`references/level-design-passes.md\` says what each pass contains and when to stop.
 
@@ -328,6 +399,10 @@ the art, because decoration is exactly what must not be solid. The renders show
 .blend**, so a level can pass the audit and look wrong, or look right and fail. Do both, in that
 order: look first (cheap, catches design errors), audit second (catches the errors you cannot see).
 
+Together they are the Blender loop, and they are the whole reason the engine handoff can wait:
+between them they answer every geometric question about the level for the cost of a few seconds
+and no upload. Go round them until neither has anything to say, and only then register the GLB.
+
 ## The checks
 
 | Check | Mode | What it fires | Failure means | Usual fix |
@@ -368,6 +443,28 @@ no volumes passes every check and holds no claim.
 \`volume-<name>\` (inside every room, from one end looking along it). Then \`contact-sheet.png\`,
 four per row in the order the log prints.
 
+## Aiming the camera, and the two lightings
+
+The standard set is what you read first. After that, ask for what you want to see:
+
+| Flag | Does |
+|---|---|
+| \`--shot 'FROM -> TO'\` | one extra frame. Both ends are \`landmark:<name>\`, \`volume:<name>\`, \`door:<id>\` or a raw \`x,y,z\` (game coordinates). Repeats; each frame is named \`shot-1\`, \`shot-2\`, … |
+| \`--shot 'FROM'\` | from that point, looking at the level's centre — enough for "what does it look like from the spawn" |
+| \`--only\` | render just the \`--shot\`s and skip the standard set and the sheet: one render, one look |
+| \`--fov <deg>\` | horizontal field of view for the perspective shots; default 24 mm ≈ 74° |
+| \`--lighting review\` | default. A camera-mounted fill and a sun, so nothing can hide in shadow |
+| \`--lighting game\` | the engine's \`interior\` preset — the sun at 8%, the hemisphere at 0.65, your \`lamp()\`s and \`spot()\`s as real lights, emissive materials glowing at their \`glow\` |
+
+Judge geometry under \`--lighting review\`; judge the lighting pass under \`--lighting game\`. The
+second is close enough to the engine that a room which is black there is black in the game, so
+pass 3 no longer needs a verify to find an unlit corner — only to confirm the fixed one.
+
+Where \`--lighting game\` and the engine still differ: EEVEE is not three.js, so exposure and
+falloff are approximate, and the engine pools point lights (a room with eight lamps gets four of
+them in game, all eight in the render). Treat "too dark" and "too bright" as real; treat an exact
+colour match as a job for the verify screenshot.
+
 What to look for, frame by frame:
 
 - **overview** — the footprint matches the plan; nothing floats outside the walls; corridors meet
@@ -378,24 +475,24 @@ What to look for, frame by frame:
 - **stairs** — treads reach the landing; the rail follows the slope; nothing pokes through a step.
 - **volumes** — a ceiling; walls meeting at the corners; props sitting on the floor, not in it.
 
-The renderer adds its own fill light so interiors are legible; it shows geometry, not the game's
-lighting. Judge the lighting in \`bitmagic verify\`'s screenshot and in the dev browser.
-
 ## When a render is right and the game is wrong
 
-The two are the same geometry only if the GLB you registered is the one you just built. After
-every rebuild: register again (same \`--asset-id\`, the entry is replaced), re-run \`sync_world.py\`,
-copy the JSON into \`src/work/\`, and check \`[MeshLevel] loaded\` in the verify console reports the
-new collider count. A verify that passes on stale files is the trap the station fell into three
-times.
+The two are the same geometry only if the GLB you registered is the one you just built. That is
+the whole content of the engine handoff, and it is all-or-nothing: register again (same
+\`--asset-id\`, the entry is replaced), re-run \`sync_world.py\`, copy the JSON into \`src/work/\`, and
+check \`[MeshLevel] loaded\` in the verify console reports the new collider count. A verify that
+passes on stale files is the trap the station fell into three times — and the reason to hand off
+rarely and completely rather than often and in pieces.
 `;
 }
 export function renderBlenderPassesReference() {
     return `# Level design in passes
 
 A level that is only walls and floors is walkable and dead. The station that taught this skill
-went from boxes to a place people wanted to screenshot in four passes, each a full loop of edit →
-build → review → audit → sync → verify. The passes, what goes in each, and when to stop.
+went from boxes to a place people wanted to screenshot in four passes. A pass is many turns of the
+Blender loop — edit → build → review → audit — ended by one engine handoff; each pass's "Stop
+when" below is the condition for that handoff, not a checkpoint you take on the way. The passes,
+what goes in each, and when to stop.
 
 ## Pass 1 — structure
 
@@ -441,8 +538,13 @@ clean (detail is the pass that breaks clearances — a casing 20 cm into a doorw
 - **The engine's interior preset dims the sun for you**; a level that looks washed out in the game
   after looking fine in the render has an \`exterior\` mode set, or its own sun in \`lightingConfig\`.
 
-Stop when: \`bitmagic judge\` no longer names lighting or flat surfaces, and the level reads the same
-in the verify screenshot as in the reference image.
+This is the pass where the default review render lies to you — its fill light makes every room
+legible whatever your lamps do. Iterate under \`review.py --lighting game\`, which runs that same
+interior preset and your own \`lamp()\`s and \`spot()\`s, and a dark room shows up dark.
+
+Stop when: nothing is unlit or blown out under \`--lighting game\`, then hand off — \`bitmagic judge\`
+no longer names lighting or flat surfaces, and the level reads the same in the verify screenshot
+as in the reference image.
 
 ## Pass 4 — the reference image
 
@@ -466,6 +568,12 @@ The engine side is \`MeshLevel\` — \`engine/agent-docs/mesh-level.md\` is the
 \`engine/agent-docs/samples/mesh-level-setup.ts\` the compile-checked sample. This page is the
 seam: what the build wrote, what each command does with it, and the four ways it goes wrong.
 
+**This is the outer loop — run it once per pass, and run all of it.** An upload, a type-check and
+a real browser, against a level the contact sheet and both audit modes have already cleared. Every
+question you can answer in Blender, answer in Blender; what is left here is what only the running
+game knows: how it feels to walk, how it is lit on a phone, and whether the published bundle can
+fetch what it needs.
+
 ## The files the build wrote
 
 | File | Goes | Carries |

package/dist/scaffold/blender-level-skill-files.js.map

@@ -1 +1 @@
-{"version":3,"file":"blender-level-skill-files.js","sourceRoot":"","sources":["../../src/scaffold/blender-level-skill-files.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,MAAM,UAAU,wBAAwB;IACtC,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8MR,CAAC;AACF,CAAC;AAED,MAAM,UAAU,iCAAiC;IAC/C,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyFR,CAAC;AACF,CAAC;AAED,MAAM,UAAU,4BAA4B;IAC1C,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmER,CAAC;AACF,CAAC;AAED,MAAM,UAAU,4BAA4B;IAC1C,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkER,CAAC;AACF,CAAC;AAED,MAAM,UAAU,mCAAmC;IACjD,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyGR,CAAC;AACF,CAAC"}
+{"version":3,"file":"blender-level-skill-files.js","sourceRoot":"","sources":["../../src/scaffold/blender-level-skill-files.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAEH,MAAM,UAAU,wBAAwB;IACtC,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8QR,CAAC;AACF,CAAC;AAED,MAAM,UAAU,iCAAiC;IAC/C,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyFR,CAAC;AACF,CAAC;AAED,MAAM,UAAU,4BAA4B;IAC1C,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2FR,CAAC;AACF,CAAC;AAED,MAAM,UAAU,4BAA4B;IAC1C,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyER,CAAC;AACF,CAAC;AAED,MAAM,UAAU,mCAAmC;IACjD,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+GR,CAAC;AACF,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bitmagic/cli",
-  "version": "0.1.64-dev.14",
+  "version": "0.1.64-dev.16",
   "description": "Build Bitmagic games from your own agent tool",
   "license": "SEE LICENSE IN LICENSE.md",
   "author": "Bitmagic Oy",
@@ -25,9 +25,9 @@
     "playwright-core": "^1.59.1",
     "tar": "^7.4.3",
     "ws": "^8.21.3",
-    "@bitmagic/animation-forger": "0.1.19-dev.14",
-    "@bitmagic/asset-core": "0.2.19-dev.14",
-    "@bitmagic/world-forger": "0.1.24-dev.14"
+    "@bitmagic/asset-core": "0.2.19-dev.16",
+    "@bitmagic/world-forger": "0.1.24-dev.16",
+    "@bitmagic/animation-forger": "0.1.19-dev.16"
   },
   "devDependencies": {
     "@eslint/js": "^9.38.0",