Review fixes: group scale for floor plans, move waits for uploads, more tests

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Delete a single recording on the Frame or on this PC (trash)
2026-10-18 15:01:46 +02:00 · 2026-10-14 18:41:34 +02:00 · 2026-10-14 17:35:53 +02:00 · 2026-10-14 17:30:21 +02:00 · 2026-10-14 16:17:54 +02:00 · 2026-10-14 14:40:16 +02:00
30 changed files with 3586 additions and 151 deletions
@@ -0,0 +1,14 @@
+name: Tests
+
+on:
+  push:
+  pull_request:
+
+jobs:
+  tests:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: astral-sh/setup-uv@v6
+      - name: Run the tests
+        run: uv run --no-project --python 3.12 --with pytest --with numpy --with scipy --with pillow pytest -v
@@ -3,3 +3,4 @@ __pycache__/
 .venv/
 .splat-workshop/
 *.part
+.pytest_cache/
@@ -2,6 +2,54 @@

 All notable changes to Splat Workshop. The format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/), versions follow [Semantic Versioning](https://semver.org/).

+## [0.2.3] – 2026-10-14
+
+### Added
+
+- **Scale for models**, e.g. a model railway: set Z, N, TT, H0, S, 0, G or your own scale for a scene or a whole group (optionally passed on to its scenes). Floor plan, room sizes, the scale bar and the measuring tool then show the size of the original – a 10 cm H0 model reads as 8.7 m. The floor plan also looks for walls and floors in the model's scale, so a model is drawn like a real building.
+- **Walk through a model in its original size** in Gaussian XR (option): Splat Workshop sets Gaussian XR's `worldScale` when copying a scene or tour to the Frame – the scene files on the PC stay unchanged. *Not tested on the Frame yet.*
+
+- **Versions** of a scene or tour, several side by side: fewer splats for the Frame (0.75 / 1 / 1.5 / 2 M), all or a limit for the PC (3 / 5 / 8 M), or an own size – each also in the original's size for models. Every version gets its own place in the Frame's gallery (e.g. "Flat · 1 M" next to "Flat · 2 M"), so you can find out yourself what runs smoothly. Frame rates measured on a Steam Frame are shown for information.
+- **Fetch several recordings from the Frame at once**: *Fetch all* (everything not on this PC yet) or tick recordings and *Fetch selection*. They come one after the other, with one progress bar for all and *Cancel*; recordings ticked while fetching join the queue. A notification at the end says when the Frame can be switched off; one that fails does not stop the others.
+- **Delete a recording**, one at a time: on the Frame (for good – with a clear warning if it is not on this PC yet) or on this PC (to the trash). A recording that is being converted, checked or fetched, or that an unfinished scene still needs, stays.
+- **"On the Frame" tab** under the finished scenes: everything in Gaussian XR's gallery on the Frame with its preview image – scenes, tours, versions and Gaussian XR's own examples – and *Off the Frame* to delete any of them there (the PC is not touched).
+
+### Changed
+
+- **Scenes go to Gaussian XR's folder for personal scenes** (`Documents/GaussianXR` on the Frame) instead of the app's own `Scenes` folder, which a Steam update or "verify files" can reset. They appear in the gallery after Gaussian XR's examples. Scenes copied by older versions move over when copied again, or all at once with *Move to own scenes* in the *On the Frame* tab; numbers of new folders count both places.
+- **No backup copies on the Frame any more**: everything is on the PC, and *Copy again* restores a scene. Copies left in `Documents/GaussianSplats` by older versions are removed together with their scene.
+- **1 M splats is the recommended size for the Frame** (preselected for versions and tours, also the default of `combine.sh`, was 3.5 M). Measured on a Steam Frame with one tour: 0.75 M 36 fps, 1 M 35 fps, 1.5 M 29 fps, 2 M 24 fps, 5 M 14 fps – 1 M looked clearly sharper than 0.75 M, 1.5 M a little sharper but already slightly unsteady. All sizes stay selectable.
+- Putting a tour together offers 0.75 to 2 M splats or an own size for its Frame version (was 2 / 3.5 / 5 M).
+
+- Tests extended after an independent review with mutation testing (499 including the type checks of every request field): scale, versions, fetching several recordings, deleting recordings, the *On the Frame* tab and the new folder, and what is locked while a scene is computed, checked, fetched or copied.
+
+### Fixed
+
+- The floor plan no longer fails for scenes in which it finds no walls (e.g. a model without its scale).
+- The floor plan of a group uses the group's scale, also when it was not passed on to its scenes. Scenes in different scales without one for the group give a clear message instead of a plan in the wrong size.
+- *Move to own scenes* waits until no scene is being copied to the Frame.
+
+## [0.2.2] – 2026-10-14
+
+### Changed
+
+- **Tests hardened after an independent review in two rounds** (213 instead of 57): every deliberately broken piece of code from the review is now caught (mutation testing). New: the recording check, renaming recordings, the Frame's list, downloads (also a broken one) and copying scenes to the Frame (through a fake `ssh`), recovery after a power cut, what happens after a job (notification, tidying up), *Start over* from the list of cancelled runs, scenes being left alone while they are computed, checks before a conversion starts (fake `ffprobe` instead of switching the check off), splat orientation and size when putting rooms together, correction D against C on a turned tracking, the reduced Frame version. Synthetic rooms now have tracking noise, scale errors and turned splats. Even with broken code the tests can no longer open anything on the desktop or end the test run unnoticed.
+- Known limit, now written down as a test: walking into a room is only recognised up to 0.4 m from another recording's path.
+
+### Fixed
+
+- Wrongly typed fields (e.g. `members: 5` when saving a group) were answered with an internal error or stored – now they get a clean 400.
+
+## [0.2.1] – 2026-10-14
+
+### Added
+
+- **Automated tests** (57) that run on every push via GitHub Actions – no GPU, recordings or Frame needed: the server's protection against other websites and malformed requests, scenes, groups, conversions with cancel/start over/resume, tours, the four corrections on synthetic rooms with a known error, borders through doors, and the floor plan's orientation. See *Development* in the README.
+
+### Fixed
+
+- After cancelling, a conversion counted as finished as soon as the sleep inhibitor ended, while `splat.sh` was still putting the previous scene back – now the whole job has to end.
+
 ## [0.2.0] – 2026-10-14

 The big one: **put the rooms of your home together into one walkable tour.**
@@ -44,5 +92,8 @@ First release.
 - **Floor plans** (experimental) in two styles with a measuring tool.
 - Configurable video player; English and German interface.

+[0.2.3]: https://github.com/thunderheronight/splat-workshop/compare/v0.2.2...v0.2.3
+[0.2.2]: https://github.com/thunderheronight/splat-workshop/compare/v0.2.1...v0.2.2
+[0.2.1]: https://github.com/thunderheronight/splat-workshop/compare/v0.2.0...v0.2.1
 [0.2.0]: https://github.com/thunderheronight/splat-workshop/compare/v0.1.0...v0.2.0
 [0.1.0]: https://github.com/thunderheronight/splat-workshop/releases/tag/v0.1.0
@@ -2,6 +2,10 @@

 **Eine grafische Oberfläche für die Rekonstruktions-Pipeline von Arcturus Vision: Aufnahme der Arcturus Vision Camera an der Steam Frame auswählen, prüfen, umwandeln lassen und das Ergebnis direkt in die Gaussian-XR-Galerie auf der Brille bringen. Mit Weboberfläche, Tray-Symbol und Aufnahmeprüfung.**

+![Kein Root nötig](https://img.shields.io/badge/root-not%20needed-2ea44f) ![Kein Jailbreak](https://img.shields.io/badge/jailbreak-not%20needed-2ea44f) [![Release](https://img.shields.io/github/v/release/thunderheronight/splat-workshop)](https://github.com/thunderheronight/splat-workshop/releases) [![Tests](https://github.com/thunderheronight/splat-workshop/actions/workflows/tests.yml/badge.svg)](https://github.com/thunderheronight/splat-workshop/actions/workflows/tests.yml)
+
+> **Kein Root, kein Jailbreak.** Auf der Frame nutzt die Splat-Werkstatt nur den offiziellen *Entwicklermodus* aus den Steam-Einstellungen und SSH als normaler Benutzer – auf der Brille wird nichts installiert, ihr System bleibt unangetastet. Auch am PC läuft sie als dein Benutzer (nur die Voraussetzungen wie ffmpeg kommen aus der Paketverwaltung).
+
 [English](README.md)

 ![Splat-Werkstatt (Beispiel-Screenshot, Vorschaubilder durch Platzhalter ersetzt)](docs/screenshot.png)
@@ -26,6 +30,9 @@ Arcturus Vision stellt die Rekonstruktions-Skripte und einen Spirula-Studio-Fork
 - 🧹 **Speicherplatz, Aufräumen, Löschen** pro Szene und eine Liste **abgebrochener Läufe** zum Fortsetzen oder Entfernen.
 - 🛡️ **Sicherer**: *Neu rechnen* behält die alte Szene, bis die neue fertig ist; der PC geht während einer Umwandlung nicht mehr in den Standby.

+<img src="docs/groups.png" width="800" alt="Eine Gruppe „Example home“ mit sechs Räumen: der daraus zusammengesetzte Rundgang, sein Grundriss als Vorschau, wie gut die Räume aneinanderpassen, darunter die Räume">
+<br><sub>Beispieldaten (englische Oberfläche) – Raumnamen und Vorschaubilder sind Platzhalter, die Rundgang-Vorschau ist die synthetische Beispielwohnung.</sub>
+
 Alle Änderungen: [CHANGELOG.md](CHANGELOG.md) (englisch)

 ## Funktionen
@@ -36,6 +43,11 @@ Alle Änderungen: [CHANGELOG.md](CHANGELOG.md) (englisch)
 - **Abbrechen & Fortsetzen** ab dem letzten Zwischenstand.
 - **Aufnahmeprüfung ohne KI**: reine Messwerte je Sekunde, farbige Zeitleiste und konkrete Hinweise („0:45–0:59 wenig Struktur“).
 - **Gruppen und Rundgänge**: Szenen gruppieren (z. B. alle Räume der Wohnung) und zu einer Szene zusammensetzen – eine volle Fassung für Gaussian XR am PC und eine kleinere für die Frame. Aufnahmen aus einem Durchgang teilen das Tracking-Koordinatensystem der Frame; die Werkstatt richtet die Räume aneinander aus (Korrekturen A–D zur Wahl), legt die Grenzen zwischen den Aufnahmen in die Türen und zeigt, wie gut die Räume aneinanderpassen. Vor dem Start schätzt sie den Speicherbedarf.
+  <br><img src="docs/combine.png" width="360" alt="Dialog „Zusammensetzen“: Korrekturen A bis D, Grenzen zwischen den Aufnahmen, Größe der Frame-Fassung, volle Fassung, Speicherschätzung">
+  <br><sub>Beispieldaten (englische Oberfläche) – Raumnamen und Vorschaubilder sind Platzhalter.</sub>
+- **Fassungen** einer Szene oder eines Rundgangs nebeneinander: weniger Splats für die Frame (0,75–2 Mio.), alle oder eine Obergrenze für den PC oder eine eigene Größe – jede mit eigenem Platz in der Galerie der Frame, zum Vergleichen, was flüssig läuft.
+- Reiter **Auf der Frame**: alles, was in der Galerie von Gaussian XR auf der Frame liegt, mit Vorschaubildern – und von dort aufräumen.
+- **Maßstab für Modelle** wie eine Modelleisenbahn (Z, N, TT, H0, S, 0, G oder eigener): Grundriss, Größen und Messwerkzeug zeigen die Größe des Originals, und auf Wunsch zeigt Gaussian XR das Modell begehbar in Originalgröße *(an der Frame noch nicht getestet)*.
 - **Grundrisse** *(experimentell)* einzelner Szenen oder einer ganzen Gruppe – Aufnahmen aus einem Durchgang fügen sich von selbst zum Grundriss der ganzen Wohnung. Zwei Stile: *Hübsch* (Draufsicht in Farbe, Wände, gelaufener Weg) und *Klassisch* (leuchtende Punktdichte), dazu ein einfaches Messwerkzeug (Punkte anklicken, Abstände ablesen – etwa ±5 cm genau).
 - **Fertige Szenen**: später auf die Frame übertragen, erneut übertragen, umbenennen (Ordner und Namensschild ziehen mit), löschen (in den Papierkorb), Ordner oder Spirula Studio öffnen.
 - **Abgebrochene Läufe** werden mit ihrem Stand angezeigt: fortsetzen, neu starten oder löschen.
@@ -2,6 +2,10 @@

 **A graphical interface for the Arcturus Vision reconstruction pipeline: pick a recording from the Arcturus Vision Camera on your Steam Frame, check it, run the conversion and get the result straight into the Gaussian XR gallery on the headset. With a web interface, a tray icon and a recording check.**

+![No root needed](https://img.shields.io/badge/root-not%20needed-2ea44f) ![No jailbreak](https://img.shields.io/badge/jailbreak-not%20needed-2ea44f) [![Release](https://img.shields.io/github/v/release/thunderheronight/splat-workshop)](https://github.com/thunderheronight/splat-workshop/releases) [![Tests](https://github.com/thunderheronight/splat-workshop/actions/workflows/tests.yml/badge.svg)](https://github.com/thunderheronight/splat-workshop/actions/workflows/tests.yml)
+
+> **No root, no jailbreak.** On the Frame, Splat Workshop only uses the official *Developer Mode* from the Steam settings and SSH as the normal user – nothing is installed on the headset and its system stays untouched. On the PC it runs as your user, too (only the prerequisites like ffmpeg come from your package manager).
+
 [Deutsch](README.de.md)

 ![Splat Workshop: conversion in progress, recordings with check badges, check result and finished scenes](docs/screenshot.png)
@@ -17,7 +21,7 @@ Arcturus Vision publishes the reconstruction scripts and a Spirula Studio fork,
 1. **Pick a recording** directly from the Frame (over SSH) or from your PC, with thumbnails.
 2. **Check it** before spending an hour on it: brightness, structure, fast pans and covered lenses, second by second.
 3. **Convert it** with a quality preset (Fast / High / Maximum) or fine-tuned values, with live progress, ETA and a PSNR curve.
-4. **Put it in the gallery**: preview image and name plate in the look of the bundled example scenes, copied into Gaussian XR's `Scenes` folder on the Frame.
+4. **Put it in the gallery**: preview image and name plate in the look of the bundled example scenes, copied into Gaussian XR's folder for personal scenes on the Frame (`Documents/GaussianXR`).
 5. **Put your home together**: group the rooms and turn them into one tour you walk through – full size for the PC, smaller for the Frame.

 ## New in 0.2
@@ -28,6 +32,9 @@ Arcturus Vision publishes the reconstruction scripts and a Spirula Studio fork,
 - 🧹 **Disk usage, clean-up, delete** per scene, and a list of **cancelled runs** to resume or remove.
 - 🛡️ **Safer**: *Start over* keeps the old scene until the new one is done; the PC no longer goes to sleep mid-conversion.

+<img src="docs/groups.png" width="800" alt="A group “Example home” with six rooms: the tour put together from them, its floor plan as preview, how well the rooms meet, and the rooms below">
+<br><sub>Example data – room names and preview images are placeholders; the tour preview is the synthetic example home.</sub>
+
 All changes: [CHANGELOG.md](CHANGELOG.md)

 ## Features
@@ -38,6 +45,12 @@ All changes: [CHANGELOG.md](CHANGELOG.md)
 - **Cancel & resume**: a cancelled conversion continues from its last saved state.
 - **Recording check** without AI: plain per-second measurements with a colour-coded timeline and concrete hints (“0:45–0:59 little structure”). See [What the check measures](#what-the-check-measures).
 - **Groups and tours**: group scenes (e.g. all rooms of your home) and put them together into one scene – a full version for Gaussian XR on the PC and a smaller one for the Frame. Recordings from one session share the Frame's tracking frame; Splat Workshop fits the rooms to each other (corrections A–D to choose), lets the borders between recordings run through doors and shows how well the rooms meet. Before starting it estimates the memory needed.
+  <br><img src="docs/combine.png" width="360" alt="Dialog “Put together”: corrections A to D, borders between the recordings, size of the Frame version, full version, memory estimate">
+  <br><sub>Example data – room names and preview images are placeholders.</sub>
+- **Versions** of a scene or tour side by side: fewer splats for the Frame (0.75–2 M), all or a limit for the PC, or your own size – each with its own place in the Frame's gallery, so you can compare what runs smoothly.
+- **Fetch all** recordings from the Frame, or a selection, one after the other – with a notification when the Frame can be switched off.
+- **On the Frame** tab: everything in Gaussian XR's gallery on the Frame with preview images, and taking things off it.
+- **Scale for models** like a model railway (Z, N, TT, H0, S, 0, G or your own): floor plan, sizes and the measuring tool show the original's size, and optionally Gaussian XR shows the model in its original size to walk through *(not tested on the Frame yet)*.
 - **Floor plans** *(experimental)* of single scenes or a whole group – recordings from one session line up by themselves into a plan of your whole home. Two styles: *Pretty* (colour top view, walls, the path you walked) and *Classic* (glowing point density), plus a simple measuring tool (click points, get distances – about ±5 cm).
  <br><img src="docs/floorplan.png" width="640" alt="Combined floor plan of an example home in the classic style, with the measuring tool">
  <br><sub>Example home – synthetic data, drawn with the same renderer. Combining rooms relies on the Frame keeping its tracking frame between recordings; how well that holds for a whole home is still being tested.</sub>
@@ -105,7 +118,7 @@ Start **Splat Workshop** from the menu (or `./splat-workshop`). The tray icon ap
 | `scripts/to-frame.sh <run> "<name>"` | (re)copy a finished scene to the Frame |
 | `scripts/combine.sh <name> "<display name>" <run>=<label> ...` | put scenes together into a tour (`ALIGN=frame\|images\|shift\|rigid`, `FRAME_SPLATS`, `FULL=0`, `NO_UPLOAD=1`) |

-After copying, **restart Gaussian XR** on the Frame so the new scene appears in the gallery. A Steam “verify files” or app update can reset Gaussian XR's `Scenes` folder – Splat Workshop also keeps a copy in `~/Documents/GaussianSplats` on the Frame, and *Copy again* restores a scene.
+After copying, **restart Gaussian XR** on the Frame so the new scene appears in the gallery. Scenes go to `Documents/GaussianXR`, which Steam updates leave alone (Splat Workshop 0.2.3 and older used Gaussian XR's own `Scenes` folder – *Move to own scenes* in the *On the Frame* tab moves them over). Everything also stays on the PC, and *Copy again* restores a scene. For the Frame, about **1 M splats** runs smoothly and still looks sharp. The *On the Frame* tab under the finished scenes shows what is in the gallery on the Frame and takes things off it.

 ### Access from other devices

@@ -156,6 +169,18 @@ tours:             [paths] runs/<group>/ (scene.sog = Frame version, full/ = ful
 internal state:    next to runs/ in .splat-workshop/ (logs, thumbnails, check results)
 ```

+## Development
+
+Automated tests run on every push ([GitHub Actions](https://github.com/thunderheronight/splat-workshop/actions/workflows/tests.yml)). Run them yourself with:
+
+```bash
+uv run --no-project --with pytest --with numpy --with scipy --with pillow pytest
+```
+
+They need no GPU, no recordings and no Steam Frame: the Arcturus pipeline, Spirula, splat-transform, ffprobe, the desktop trash and notifications are replaced by small fakes, the Frame is a folder reached through a fake `ssh`/`scp`, and putting rooms together is tested on synthetic rooms with a known error – turned, shifted and scaled reconstructions, tracking noise, drift and turn (`tests/synth.py`).
+
+Covered: who may talk to the server (other websites, LAN mode, malformed or wrongly typed requests, paths outside the runs folder), the recording check, renaming recordings and scenes, clean-up, deleting, cancelled runs, a scene being left alone while it is computed, recovery after a power cut, groups, conversions with cancel/start over/resume (the real `splat.sh`), the Frame's list, downloads and copying scenes over (the real `to-frame.sh`), notifications and tidying up after a job, tours (the real `combine.sh`), the four corrections, splat orientation and size, borders through doors, and that the floor plan is not mirrored. The tests were reviewed independently with mutation testing (deliberately broken code must make them fail). Not covered: the real pipeline, Spirula, the real Frame, the tray icon, the browser interface and the server stopping itself when idle – those are tested by hand.
+
 ## Uninstall

 `./install.sh --uninstall` removes the menu entry, icon and autostart. Your config and scenes stay.
@@ -0,0 +1,2 @@
+[pytest]
+testpaths = tests
@@ -7,11 +7,12 @@
 # Environment:
 #   ALIGN=frame|images|shift|rigid  how the rooms are fitted together (default: images, see combine.py)
 #   PARTITION=view|nearest          where the borders between the recordings run (default: view)
-#   FRAME_SPLATS=3500000            splats in the Frame version (the full version keeps all)
+#   FRAME_SPLATS=1000000            splats in the Frame version (the full version keeps all)
 #   FULL=0                          skip the full SOG for the PC (the step that needs the most memory)
 #   FULL_NAME="..."                 name plate of the full version (default: "<name> (full)")
 #   PLAN_COMMA=1                    decimal comma on the floor plan used as preview
 #   NO_UPLOAD=1                     only compute, don't copy to the Frame
+#   WORLD_SCALE=87                  show a model in Gaussian XR in the size of the original (1:87)
 # A previous result of the same name stays until the new one is done.
 #
 # Lines starting with "@@" are machine-readable progress markers for the web interface.
@@ -36,7 +37,20 @@ log=$RUNS_DIR/$slug.log
 work=$RUNS_DIR/.building
 tmp=$work/$slug
 stem=$(printf '%s' "$slug" | tr 'A-Z' 'a-z')
-frame_splats=${FRAME_SPLATS:-3500000}
+frame_splats=${FRAME_SPLATS:-1000000}
+
+# Gaussian XR's worldScale in a scene's transform file, when WORLD_SCALE is set (a model shown in the
+# size of the original, e.g. 87 for H0)
+world_scale() {
+    [ -n "${WORLD_SCALE:-}" ] || return 0
+    python3 - "$1" "$WORLD_SCALE" <<'PY'
+import json, sys
+path, scale = sys.argv[1], float(sys.argv[2])
+data = json.load(open(path))
+data["worldScale"] = scale
+json.dump(data, open(path, "w"), indent=2)
+PY
+}

 main() {
    rm -rf "$tmp"
@@ -74,6 +88,7 @@ main() {
        uv run -q "$HERE/make_gallery.py" --plan "$tmp/plan.png" "$tmp/full" "${FULL_NAME:-$name (full)}" "$stem-full"
        cp "$tmp/full/scene.sog" "$tmp/full/$stem-full.sog"
        cp "$tmp/full/scene.xrSceneTransform.json" "$tmp/full/$stem-full.xrSceneTransform.json"
+        world_scale "$tmp/full/$stem-full.xrSceneTransform.json"
    fi

    # Replace the previous result only now
@@ -101,9 +101,11 @@ def heights(y):
    return np.percentile(y, 97), np.percentile(y, 3)


-def wall_angle(points_xz):
+def wall_angle(points_xz, bin_size=0.03):
    """Yaw that makes the walls axis-aligned: maximise the peakiness of the x/z histograms."""
    best, best_score = 0.0, -1
+    if len(points_xz) < 50:                                   # no walls found: leave it as it is
+        return best
    for deg in np.arange(0, 90, 0.5):
        a = np.radians(deg)
        c, s = np.cos(a), np.sin(a)
@@ -111,7 +113,7 @@ def wall_angle(points_xz):
        v = points_xz[:, 0] * s + points_xz[:, 1] * c
        score = 0
        for w in (u, v):
-            h, _ = np.histogram(w, bins=max(10, int((w.max() - w.min()) / 0.03)))
+            h, _ = np.histogram(w, bins=max(10, int((w.max() - w.min()) / bin_size)))
            score += float(np.sum(h.astype(np.float64) ** 2)) / len(w) ** 2
        if score > best_score:
            best, best_score = a, score
@@ -142,11 +144,16 @@ def main():
    ap.add_argument("runs", nargs="+", help="run folder, optionally =label")
    ap.add_argument("--title", default="")
    ap.add_argument("--comma", action="store_true", help="decimal comma in sizes")
+    ap.add_argument("--ratio", type=float, default=1.0,
+                    help="model scale, e.g. 87 for H0 (1:87): sizes and the scale bar show the original's size")
    ap.add_argument("--style", choices=("pretty", "classic"), default="pretty",
                    help="pretty: colour top view, glowing walls, camera path; classic: glowing point density only")
    args = ap.parse_args()
    out = Path(args.out)
    rng = np.random.default_rng(1)
+    # All lengths below are in metres of the original: a model (--ratio 87) is measured in its own scale,
+    # so its walls are looked for 1 to 2 cm above its floor instead of 0.9 to 1.9 m.
+    m = 1 / args.ratio
    scenes = []
    for arg in args.runs:
        run, _, label = arg.partition("=")
@@ -155,23 +162,25 @@ def main():
        floor, ceil = heights(xyz[:, 1])
        # keep the room: below the ceiling, not below the floor, and drop far-away floaters
        lo, hi = np.percentile(xyz[:, [0, 2]], 0.5, axis=0), np.percentile(xyz[:, [0, 2]], 99.5, axis=0)
-        inside = ((xyz[:, 1] > ceil + 0.25) & (xyz[:, 1] < floor + 0.15)
-                  & np.all(xyz[:, [0, 2]] >= lo - 0.3, axis=1) & np.all(xyz[:, [0, 2]] <= hi + 0.3, axis=1))
-        up = floor - xyz[:, 1]                                   # height above the floor in metres
-        walls = inside & (up > 0.9) & (up < 1.9)
+        inside = ((xyz[:, 1] > ceil + 0.25 * m) & (xyz[:, 1] < floor + 0.15 * m)
+                  & np.all(xyz[:, [0, 2]] >= lo - 0.3 * m, axis=1) & np.all(xyz[:, [0, 2]] <= hi + 0.3 * m, axis=1))
+        if inside.sum() < 100:                                   # e.g. a model drawn without its scale: keep all
+            inside = np.ones(len(xyz), bool)
+        up = floor - xyz[:, 1]                                   # height above the floor
+        walls = inside & (up > 0.9 * m) & (up < 1.9 * m)
        scenes.append({"label": label or run.name, "xyz": xyz[inside], "rgb": rgb[inside], "up": up[inside],
                       "walls": xyz[walls][:, [0, 2]], "cams": load_cameras(run), "floor": floor})

    all_walls = np.vstack([s["walls"] for s in scenes])
    sub = all_walls[rng.choice(len(all_walls), min(len(all_walls), 150_000), replace=False)]
-    angle = wall_angle(sub)
+    angle = wall_angle(sub, 0.03 * m)
    for s in scenes:
        s["p"] = rotate(s["xyz"][:, [0, 2]], angle)
        s["w"] = rotate(s["walls"], angle)
        s["c"] = rotate(s["cams"][:, [0, 2]], angle) if s["cams"] is not None else None
-        s["box"] = room_box(s["w"])
+        s["box"] = room_box(s["w"], 0.05 * m)
        if s["box"] is not None:                                   # keep only this room (plus a margin)
-            b0, b1 = s["box"][0] - 0.35, s["box"][1] + 0.35
+            b0, b1 = s["box"][0] - 0.35 * m, s["box"][1] + 0.35 * m
            ok = np.all((s["p"] >= b0) & (s["p"] <= b1), axis=1)
            s["p"], s["rgb"], s["up"] = s["p"][ok], s["rgb"][ok], s["up"][ok]
            okw = np.all((s["w"] >= b0) & (s["w"] <= b1), axis=1)
@@ -179,11 +188,11 @@ def main():

    boxes = [s["box"] for s in scenes if s["box"] is not None]
    if boxes:
-        lo = np.min([b[0] for b in boxes], axis=0) - 0.8
-        hi = np.max([b[1] for b in boxes], axis=0) + 0.8
+        lo = np.min([b[0] for b in boxes], axis=0) - 0.8 * m
+        hi = np.max([b[1] for b in boxes], axis=0) + 0.8 * m
    else:
        allp = np.vstack([s["p"] for s in scenes])
-        lo, hi = np.percentile(allp, 1, axis=0) - 0.5, np.percentile(allp, 99, axis=0) + 0.5
+        lo, hi = np.percentile(allp, 1, axis=0) - 0.5 * m, np.percentile(allp, 99, axis=0) + 0.5 * m
    span = hi - lo
    ppm = (SIZE - 160) / span.max()                               # pixels per metre
    W, H = int(span[0] * ppm) + 160, int(span[1] * ppm) + 200
@@ -212,23 +221,32 @@ def main():
        if s["box"] is not None:
            (bx0, bz0), (bx1, bz1) = s["box"]
            cx, cz = px(np.array([[(bx0 + bx1) / 2, (bz0 + bz1) / 2]]))
-            size = f"~ {bx1 - bx0:.1f} × {bz1 - bz0:.1f} m".replace(".", "," if args.comma else ".")
+            size = f"~ {(bx1 - bx0) * args.ratio:.1f} × {(bz1 - bz0) * args.ratio:.1f} m".replace(".", "," if args.comma else ".")
            for txt, fnt, dy in ((s["label"], f_label, -16), (size, f_small, 16)):
                tw = d.textlength(txt, font=fnt)
                d.text((cx[0] - tw / 2 + 1, cz[0] + dy - 13 + 1), txt, font=fnt, fill=(0, 0, 0))
                d.text((cx[0] - tw / 2, cz[0] + dy - 13), txt, font=fnt, fill=(255, 255, 255) if dy < 0 else (210, 214, 224))

-    # scale bar (1 m) and title
-    d.line((W - 60 - ppm, H - 40, W - 60, H - 40), fill=(230, 230, 230), width=3)
-    for xx in (W - 60 - ppm, W - 60):
+    # scale bar: a round length of the original (for a model: of the real thing), about 150 px long
+    real_ppm = ppm / args.ratio                                    # pixels per metre of the original
+    length = min((0.1, 0.2, 0.5, 1, 2, 5, 10, 20, 50, 100, 200, 500, 1000), key=lambda l: abs(l * real_ppm - 150))
+    bar = length * real_ppm
+    text = (f"{length * 100:g} cm" if length < 1 else f"{length:g} m")
+    d.line((W - 60 - bar, H - 40, W - 60, H - 40), fill=(230, 230, 230), width=3)
+    for xx in (W - 60 - bar, W - 60):
        d.line((xx, H - 47, xx, H - 33), fill=(230, 230, 230), width=3)
-    d.text((W - 60 - ppm / 2 - 12, H - 72), "1 m", font=f_small, fill=(230, 230, 230))
+    tw = d.textlength(text, font=f_small)
+    d.text((W - 60 - bar / 2 - tw / 2, H - 72), text, font=f_small, fill=(230, 230, 230))
+    if args.ratio != 1:
+        ratio = f"1:{args.ratio:g}".replace(".", "," if args.comma else ".")
+        d.text((W - 60 - bar - 20 - d.textlength(ratio, font=f_small), H - 50), ratio, font=f_small, fill=(230, 230, 230))
    if args.title:
        d.text((40, 32), args.title, font=f_title, fill=(235, 238, 245))
    out_img.save(out)
-    info = [{"label": s["label"], "size": [round(float(v), 2) for v in (s["box"][1] - s["box"][0])] if s["box"] is not None else None}
-            for s in scenes]
-    print(json.dumps({"angle": round(float(np.degrees(angle)), 1), "scenes": info, "pixels_per_metre": round(ppm, 1)}))
+    info = [{"label": s["label"], "size": [round(float(v) * args.ratio, 2) for v in (s["box"][1] - s["box"][0])]
+             if s["box"] is not None else None} for s in scenes]
+    print(json.dumps({"angle": round(float(np.degrees(angle)), 1), "scenes": info, "ratio": args.ratio,
+                      "pixels_per_metre": round(real_ppm, 4)}))


 def classic(scenes, px, W, H):
@@ -6,6 +6,7 @@

 Usage: uv run make_gallery.py <run folder> <pipeline log> <display name> <file stem>
       uv run make_gallery.py --plan <floor plan.png> <run folder> <display name> <file stem>
+       uv run make_gallery.py --label <name plate.png> <text>
 Reads the initial view from the log ("Gaussian XR initial view: cam0/... Display rotation X°")
 and writes <file stem>.gallery.png and <file stem>.sceneinfo.png into the run folder.
 The look matches the example scenes that ship with Gaussian XR.
@@ -93,6 +94,9 @@ def from_plan(plan: Path, out: Path) -> None:


 def main() -> None:
+    if len(sys.argv) == 4 and sys.argv[1] == "--label":
+        label(sys.argv[3], Path(sys.argv[2]))
+        return
    if len(sys.argv) == 6 and sys.argv[1] == "--plan":
        plan, run, name, stem = Path(sys.argv[2]), Path(sys.argv[3]), sys.argv[4], sys.argv[5]
        from_plan(plan, run / f"{stem}.gallery.png")
@@ -5,8 +5,10 @@
 # Usage: scripts/to-frame.sh <run folder> "<display name>"
 #   <run folder>    runs/<name> or just <name>
 #   GALLERY_ONLY=1  only create the gallery files (preview image, name plate) in the run folder
-#   TARGET=NN_name  use this scene folder on the Frame (default: same name, or next free number from 20)
+#   TARGET=NN_name  use this scene folder on the Frame (default: same name, or next free number from 20;
+#                   a folder of that name in Gaussian XR's own gallery folder is moved over)
 #   STEM=name       file stem (default: folder name in lower case)
+#   SLUG=name       name for a new scene folder on the Frame (default: the run folder's name)
 #   LOG=file        pipeline log with the initial view (default: runs/<folder>.log)
 set -euo pipefail
 # Everything in one block: bash reads it completely before it starts, so updating this file
@@ -16,23 +18,39 @@ set -euo pipefail
 HERE=$(cd "$(dirname "$(readlink -f "$0")")" && pwd)
 ROOT=$(dirname "$HERE")
 eval "$(cd "$ROOT" && python3 -m splat_workshop.config --shell)"
-FRAME_SCENES=.local/share/Steam/steamapps/common/ArcturusVisionGaussianXR/Scenes
-FRAME_BACKUP=Documents/GaussianSplats
+# Gaussian XR's folder for personal scenes – Steam updates leave it alone. Its own gallery folder
+# (FRAME_STEAM) holds the examples, and scenes copied by Splat Workshop 0.2.3 and older.
+FRAME_SCENES=Documents/GaussianXR
+FRAME_STEAM=.local/share/Steam/steamapps/common/ArcturusVisionGaussianXR/Scenes

 run=${1:?Give a run folder}
 name=${2:?Give a display name}
 [ -d "$run" ] || run=$RUNS_DIR/$run
 out=$(realpath "$run")
-slug=$(basename "$out")
+slug=${SLUG:-$(basename "$out")}
 [ -f "$out/scene.sog" ] || { echo "No scene.sog in $out" >&2; exit 1; }
 log=${LOG:-$RUNS_DIR/$slug.log}
 [ -f "$log" ] || log=$(grep -ls "Gaussian XR initial view" "$RUNS_DIR"/*.log 2>/dev/null | xargs -r grep -l "$out/" | head -1)
 [ -f "$log" ] || { echo "No pipeline log found for $slug (set LOG=...)" >&2; exit 1; }

+# Gaussian XR's worldScale in a scene's transform file, when WORLD_SCALE is set (a model shown in the
+# size of the original, e.g. 87 for H0)
+world_scale() {
+    [ -n "${WORLD_SCALE:-}" ] || return 0
+    python3 - "$1" "$WORLD_SCALE" <<'PY'
+import json, sys
+path, scale = sys.argv[1], float(sys.argv[2])
+data = json.load(open(path))
+data["worldScale"] = scale
+json.dump(data, open(path, "w"), indent=2)
+PY
+}
+
 # Gallery files: <stem>.sog / .xrSceneTransform.json / .gallery.png / .sceneinfo.png
 stem=${STEM:-$(printf '%s' "$slug" | tr 'A-Z' 'a-z')}
 cp "$out/scene.sog" "$out/$stem.sog"
 cp "$out/scene.xrSceneTransform.json" "$out/$stem.xrSceneTransform.json"
+world_scale "$out/$stem.xrSceneTransform.json"
 uv run -q "$HERE/make_gallery.py" "$out" "$log" "$name" "$stem"

 [ "${GALLERY_ONLY:-0}" = 1 ] && exit 0
@@ -41,20 +59,26 @@ uv run -q "$HERE/make_gallery.py" "$out" "$log" "$name" "$stem"
 echo "@@ phase upload"
 echo "Copying to the Frame ..."
 # Reuse an existing folder of the same name, otherwise the next free number from 20
+# (numbers are counted in both folders, so a scene never has the same number as another in the gallery)
 folder=${TARGET:-$(ssh -o ConnectTimeout=8 "$FRAME_HOST" "
-    existing=\$(ls -d $FRAME_SCENES/[0-9][0-9]_$slug 2>/dev/null | head -1)
+    found() { ls -d $FRAME_SCENES/\$1 $FRAME_STEAM/\$1 2>/dev/null | head -1; }
+    existing=\$(found '[0-9][0-9]_$slug')
    if [ -n \"\$existing\" ]; then basename \"\$existing\"; exit; fi
-    n=20; while ls -d $FRAME_SCENES/\${n}_* >/dev/null 2>&1; do n=\$((n+1)); done
+    n=20; while [ -n \"\$(found \${n}_\*)\" ]; do n=\$((n+1)); done
    echo \${n}_$slug")}
-ssh -o ConnectTimeout=8 "$FRAME_HOST" "mkdir -p $FRAME_BACKUP/$folder $FRAME_SCENES/$folder"
-scp -q "$out/$stem".{sog,xrSceneTransform.json,gallery.png,sceneinfo.png} "$FRAME_HOST:$FRAME_BACKUP/$folder/"
-# Files of this scene under an earlier name (renamed in Splat Workshop) go first, so the folder holds one scene
-ssh "$FRAME_HOST" "for d in $FRAME_SCENES/$folder $FRAME_BACKUP/$folder; do
-        for f in \$d/*.sog \$d/*.xrSceneTransform.json \$d/*.gallery.png \$d/*.sceneinfo.png; do
-            case \${f##*/} in $stem.*) ;; *) rm -f -- \"\$f\" ;; esac
-        done
+case "$folder" in [0-9][0-9]_?*) ;; *) echo "Unusable folder on the Frame: '$folder'" >&2; exit 1 ;; esac
+case "$folder" in */*|*..*) echo "Unusable folder on the Frame: '$folder'" >&2; exit 1 ;; esac
+# Straight into the gallery – everything is on the PC, copying again restores a scene.
+# Files of this scene under an earlier name (renamed in Splat Workshop) go first, so the folder holds one scene.
+# A copy made by 0.2.3 or older in Gaussian XR's own gallery folder moves to the personal one.
+ssh -o ConnectTimeout=8 "$FRAME_HOST" "mkdir -p $FRAME_SCENES && \
+    if [ -d $FRAME_STEAM/$folder ] && [ ! -e $FRAME_SCENES/$folder ]; then mv $FRAME_STEAM/$folder $FRAME_SCENES/; fi && \
+    rm -rf $FRAME_STEAM/$folder && mkdir -p $FRAME_SCENES/$folder && cd $FRAME_SCENES/$folder && \
+    for f in *.sog *.xrSceneTransform.json *.gallery.png *.sceneinfo.png; do
+        case \$f in $stem.*) ;; *) rm -f -- \"\$f\" ;; esac
    done"
-ssh "$FRAME_HOST" "cp $FRAME_BACKUP/$folder/$stem.* $FRAME_SCENES/$folder/ && chmod 755 $FRAME_SCENES/$folder/*"
+scp -q "$out/$stem".{sog,xrSceneTransform.json,gallery.png,sceneinfo.png} "$FRAME_HOST:$FRAME_SCENES/$folder/"
+ssh "$FRAME_HOST" "chmod 755 $FRAME_SCENES/$folder/*"
 echo "@@ done frame $folder"
 echo
 echo "Done: \"$name\" is in the Gaussian XR gallery ($folder)."
@@ -0,0 +1,85 @@
+#!/bin/bash
+# Versions of a finished scene or tour: fewer splats for the Frame, all (or a limit) for the PC,
+# optionally shown in the original's size (models). Each version is a complete scene in
+# <run folder>/versions/<key>/ and can be copied to the Frame next to the others.
+#
+# Usage: scripts/versions.sh <run folder> "<key>|<splats>|<scale>|<name plate>" ...
+#   <key>         folder name of the version, e.g. 1m, 0.75m, all, 1m-1x87
+#   <splats>      number of splats, or "all"
+#   <scale>       1, or e.g. 87: Gaussian XR shows it in the original's size (worldScale 87)
+#   <name plate>  text on the name plate in the gallery, e.g. "Flat · 1 M"
+# The splats come from <run folder>/spirula/scene.ply. Lines starting with "@@" are progress markers.
+set -euo pipefail
+# Everything in one block: bash reads it completely before it starts, so updating this file
+# (git pull, editing) does not affect a run that is already going.
+{
+
+HERE=$(cd "$(dirname "$(readlink -f "$0")")" && pwd)
+ROOT=$(dirname "$HERE")
+eval "$(cd "$ROOT" && python3 -m splat_workshop.config --shell)"
+
+out=$(realpath "${1:?Give a run folder}")
+shift
+[ $# -ge 1 ] || { echo "Give at least one version" >&2; exit 1; }
+src=$out/spirula/scene.ply
+[ -f "$src" ] || { echo "No spirula/scene.ply in $out" >&2; exit 1; }
+[ -n "$SPLAT_TRANSFORM" ] || { echo "splat-transform not found" >&2; exit 1; }
+slug=$(basename "$out")
+preview=$(ls "$out"/*.gallery.png 2>/dev/null | head -1 || true)
+total=$(python3 - "$src" <<'PY'
+import sys
+with open(sys.argv[1], "rb") as f:
+    for line in f:
+        if line.startswith(b"element vertex"):
+            print(int(line.split()[-1])); break
+PY
+)
+echo "Making $# version(s) of $slug ($total splats)"
+
+i=0
+for spec in "$@"; do
+    i=$((i + 1))
+    IFS='|' read -r key splats scale plate <<< "$spec"
+    case "$key" in ''|.*|*/*) echo "Unusable version name: $key" >&2; exit 1 ;; esac
+    echo "@@ vstep $i $# $key"
+    dir=$out/versions/$key
+    tmp=$dir.tmp
+    rm -rf "$tmp"
+    mkdir -p "$tmp"
+    trap 'rm -rf "$tmp"' EXIT
+    if [ "$splats" = all ] || [ "$splats" -ge "$total" ]; then
+        echo "$key: all $total splats"
+        "$SPLAT_TRANSFORM" -w "$src" "$tmp/scene.sog"
+        made=$total
+    else
+        echo "$key: reducing $total to $splats splats"
+        "$SPLAT_TRANSFORM" -w "$src" --decimate "$splats" "$tmp/reduced.ply"
+        "$SPLAT_TRANSFORM" -w "$tmp/reduced.ply" "$tmp/scene.sog"
+        rm -f "$tmp/reduced.ply"
+        made=$splats
+    fi
+    stem=$(printf '%s-%s' "$slug" "$key" | tr 'A-Z' 'a-z')
+    python3 - "$out/scene.xrSceneTransform.json" "$tmp/scene.xrSceneTransform.json" "$scale" <<'PY'
+import json, sys
+data = json.load(open(sys.argv[1]))
+data["worldScale"] = float(sys.argv[3])          # 1 = original size of the scene
+json.dump(data, open(sys.argv[2], "w"), indent=2)
+PY
+    if [ -n "$preview" ]; then
+        cp "$preview" "$tmp/$stem.gallery.png"
+    fi
+    uv run -q "$HERE/make_gallery.py" --label "$tmp/$stem.sceneinfo.png" "$plate"
+    python3 - "$tmp/version.json" "$key" "$made" "$splats" "$scale" "$plate" <<'PY'
+import json, sys, time
+path, key, made, target, scale, plate = sys.argv[1:]
+json.dump({"key": key, "splats": int(made), "target": target, "scale": float(scale), "label": plate,
+           "created": time.time()}, open(path, "w"), indent=1)
+PY
+    rm -rf "$dir"
+    mv "$tmp" "$dir"
+    trap - EXIT
+done
+echo "@@ done local"
+echo "Done: $out/versions"
+exit
+}
@@ -13,8 +13,13 @@ TEXTS = {
        "inhibit.download": "Downloading a recording from the Frame",
        "inhibit.combine": "Putting “{name}” together",
        "tour.full_name": "{name} (full)",
+        "inhibit.versions": "Making versions of “{name}”", "ver.all": "all splats", "ver.size": "{n} M",
        "notify.failed.title": "Conversion failed",
        "notify.failed": "“{name}” – details in Splat Workshop",
+        "notify.download.title": "Fetched from the Frame",
+        "notify.download": "{n} recording(s) are on this PC – you can switch the Frame off",
+        "notify.download_failed.title": "Fetching failed",
+        "notify.download_failed": "{n} recording(s) could not be fetched ({ok} did) – is the Frame switched on?",
        "notify.upload.title": "Copied to the Frame",
        "notify.upload": "“{name}” is in the Gaussian XR gallery",
        "notify.upload_failed.title": "Copying failed",
@@ -62,8 +67,13 @@ TEXTS = {
        "inhibit.download": "Lädt eine Aufnahme von der Frame",
        "inhibit.combine": "Setzt „{name}“ zusammen",
        "tour.full_name": "{name} (voll)",
+        "inhibit.versions": "Erstellt Fassungen von „{name}“", "ver.all": "alle Splats", "ver.size": "{n} Mio.",
        "notify.failed.title": "Umwandlung fehlgeschlagen",
        "notify.failed": "„{name}“ – Details in der Splat-Werkstatt",
+        "notify.download.title": "Von der Frame geholt",
+        "notify.download": "{n} Aufnahme(n) liegen auf dem PC – du kannst die Frame abschalten",
+        "notify.download_failed.title": "Holen fehlgeschlagen",
+        "notify.download_failed": "{n} Aufnahme(n) konnten nicht geholt werden ({ok} schon) – ist die Frame an?",
        "notify.upload.title": "Auf die Frame übertragen",
        "notify.upload": "„{name}“ liegt in der Gaussian-XR-Galerie",
        "notify.upload_failed.title": "Übertragung fehlgeschlagen",
@@ -29,7 +29,7 @@ from pathlib import Path
 from . import check, config
 from .i18n import T, detect

-VERSION = "0.2.0"
+VERSION = "0.2.3"
 CFG = config.load()
 ROOT = config.ROOT
 WEB = ROOT / "web"
@@ -43,7 +43,11 @@ STATE = STATE_DIR / "state.json"

 FRAME = CFG.frame_host
 FRAME_VIDEOS = "Videos/ArcturusVisionCamera"
-FRAME_SCENES = ".local/share/Steam/steamapps/common/ArcturusVisionGaussianXR/Scenes"
+FRAME_SCENES = "Documents/GaussianXR"         # Gaussian XR's personal scenes: Steam updates leave them alone
+# The gallery that comes with Gaussian XR: its examples, and scenes copied by Splat Workshop 0.2.3 and older
+FRAME_STEAM = ".local/share/Steam/steamapps/common/ArcturusVisionGaussianXR/Scenes"
+FRAME_PLACES = {"own": FRAME_SCENES, "steam": FRAME_STEAM}
+FRAME_BACKUP = "Documents/GaussianSplats"     # copies made by versions up to 0.2.3 – removed along with a scene
 SSH = ["ssh", "-o", "ConnectTimeout=4", "-o", "BatchMode=yes", FRAME]
 HOSTNAME = socket.gethostname().lower()
 # Names the server may be reached under (protects against DNS rebinding); IP addresses always work
@@ -57,7 +61,10 @@ plan_slots = threading.BoundedSemaphore(2)   # floor plans drawn at the same tim
 last_request = time.time()
 idle_exit = True
 proc = None                        # Popen of the running splat.sh (if started by this server)
-download = None                    # {"name", "total", "done", "error", "finished"}
+download = None                    # file being fetched: {"name", "total", "done", "error", "finished"}
+download_queue = []                # files waiting, fetched one after the other: [{"name", "size"}]
+download_batch = {}                # since the queue was last empty: {"files", "bytes", "done_files", "done_bytes", "failed"}
+download_proc = None               # ssh of the file being fetched (to cancel it)
 uploads = {}                       # slug -> {"proc", "out", "started", "notified"}
 frame_cache = {"t": 0, "data": None}
 probe_cache = {}
@@ -134,10 +141,22 @@ def save_state(st: dict) -> None:


 def pid_alive(pid: int) -> bool:
+    """Is the job started as `pid` still running? The job is its whole process group: the first process
+    (systemd-inhibit, if the PC is kept awake) can end before splat.sh has finished cleaning up."""
+    if proc is not None and proc.pid == pid:
+        proc.poll()                             # reap it, so a finished first process does not count
    try:
        cmd = Path(f"/proc/{pid}/cmdline").read_bytes().decode(errors="replace")
-        return "splat.sh" in cmd or "combine.sh" in cmd
+        if cmd:
+            return any(x in cmd for x in ("splat.sh", "combine.sh", "versions.sh"))
    except OSError:
+        pass
+    if not pid:
+        return False
+    try:
+        os.killpg(pid, 0)                       # the first process is gone, are others of the job left?
+        return True
+    except (ProcessLookupError, PermissionError):
        return False


@@ -159,7 +178,7 @@ def frame_listing(force=False):
    if not force and time.time() - frame_cache["t"] < 20:
        return frame_cache["data"]
    cmd = (f'(cd {FRAME_VIDEOS} 2>/dev/null && stat -c "%n|%s|%Y" *_stereo.mp4 2>/dev/null); echo ---; '
-           f'ls {FRAME_VIDEOS}/thumbnails 2>/dev/null; echo ---; ls {FRAME_SCENES} 2>/dev/null')
+           f'ls {FRAME_VIDEOS}/thumbnails 2>/dev/null; echo ---; (ls {FRAME_SCENES}; ls {FRAME_STEAM}) 2>/dev/null')
    try:
        r = subprocess.run(SSH + [cmd], capture_output=True, text=True, timeout=10)
    except subprocess.TimeoutExpired:
@@ -382,39 +401,101 @@ def check_worker():

 # ---------------------------------------------------------------- download from the Frame

-def start_download(name: str, size: int):
-    global download
+def download_busy() -> bool:
+    return bool(download_queue) or bool(download and not download.get("finished"))
+
+
+def start_download(files: list):
+    """Fetch recordings from the Frame, one after the other ([{"name", "size"}]). Files already on this PC are
+    skipped (a single one is refused). Adds to the queue when a download is already running."""
    with lock:
-        if download and not download.get("finished"):
-            return err("err.download_busy")
-        if (REC / name).exists():
-            return err("err.name_taken")
-        download = {"name": name, "total": size, "done": 0, "error": None, "finished": False}
-
-    def run():
-        REC.mkdir(parents=True, exist_ok=True)
-        part = REC / (name + ".part")
-        try:
-            with open(part, "wb") as fh:
-                p = subprocess.Popen(keep_awake(SSH + [f"cat {FRAME_VIDEOS}/{shq(name)}"], t("inhibit.download")),
-                                     stdout=subprocess.PIPE, stderr=subprocess.DEVNULL)
-                while chunk := p.stdout.read(1 << 20):
-                    fh.write(chunk)
-                    download["done"] += len(chunk)
-                rc = p.wait()
-            if rc != 0 or download["done"] != size:
-                raise RuntimeError("transfer interrupted")
-            part.rename(REC / name)
-            frame_cache["t"] = 0
-        except Exception as e:  # noqa: BLE001 – shown in the interface
-            download["error"] = str(e)
-            part.unlink(missing_ok=True)
-        download["finished"] = True
-
-    threading.Thread(target=run, daemon=True).start()
+        waiting = {f["name"] for f in download_queue} | ({download["name"]} if download_busy() and download else set())
+        new = [f for f in files if not (REC / f["name"]).exists() and f["name"] not in waiting]
+        if not new:
+            return err("err.name_taken") if len(files) == 1 and (REC / files[0]["name"]).exists() else (
+                err("err.download_busy") if files else err("err.not_on_frame"))
+        idle = not download_busy()
+        if idle:
+            download_batch.clear()
+            download_batch.update(files=0, bytes=0, done_files=0, done_bytes=0, failed=[])
+        download_batch["files"] += len(new)
+        download_batch["bytes"] += sum(f["size"] for f in new)
+        download_queue.extend(new)
+        if idle:
+            threading.Thread(target=download_worker, daemon=True).start()
    return None


+def download_worker():
+    global download
+    while True:
+        with lock:
+            if not download_queue:
+                break
+            f = download_queue.pop(0)
+            download = {"name": f["name"], "total": f["size"], "done": 0, "error": None, "finished": False}
+        fetch(f["name"], f["size"])
+        with lock:
+            download_batch["done_files"] += 1
+            download_batch["done_bytes"] += f["size"]
+            if download["error"]:
+                download_batch["failed"].append(f["name"])
+            download["finished"] = True
+    b = download_batch
+    if b.get("done_files") and not b.get("cancelled"):
+        ok = b["done_files"] - len(b["failed"])
+        if b["failed"]:
+            notify(t("notify.download_failed.title"), t("notify.download_failed", n=len(b["failed"]), ok=ok))
+        else:
+            notify(t("notify.download.title"), t("notify.download", n=ok))
+
+
+def fetch(name: str, size: int):
+    """One recording from the Frame, via a .part file (never a half file under the real name)."""
+    global download_proc
+    REC.mkdir(parents=True, exist_ok=True)
+    part = REC / (name + ".part")
+    try:
+        with open(part, "wb") as fh:
+            p = download_proc = subprocess.Popen(keep_awake(SSH + [f"cat {FRAME_VIDEOS}/{shq(name)}"],
+                                                            t("inhibit.download")),
+                                                 stdout=subprocess.PIPE, stderr=subprocess.DEVNULL)
+            while chunk := p.stdout.read(1 << 20):
+                fh.write(chunk)
+                download["done"] += len(chunk)
+            rc = p.wait()
+        if download.get("cancelled"):
+            raise RuntimeError("cancelled")
+        if rc != 0 or download["done"] != size:
+            raise RuntimeError("transfer interrupted")
+        part.rename(REC / name)
+        frame_cache["t"] = 0
+    except Exception as e:  # noqa: BLE001 – shown in the interface
+        download["error"] = str(e)
+        part.unlink(missing_ok=True)
+    finally:
+        download_proc = None
+
+
+def cancel_download():
+    """Empty the queue and stop the file being fetched (its half is removed)."""
+    with lock:
+        if not download_busy():
+            return err("err.no_download")
+        download_queue.clear()
+        download_batch["cancelled"] = True
+        if download and not download.get("finished"):
+            download["cancelled"] = True
+            if download_proc and download_proc.poll() is None:
+                download_proc.kill()
+    return None
+
+
+def download_status():
+    return {**(download or {}), "queue": [f["name"] for f in download_queue], "batch": dict(download_batch),
+            "busy": download_busy()} if download or download_queue else None
+
+
 # ---------------------------------------------------------------- conversion

 RX_EXTRACT = re.compile(r"Extraction progress: decoded (\d+)%")
@@ -454,10 +535,25 @@ def parse_combine(text: str) -> dict:
    return {"phase": phase, "pct": pct, "eta": None, "info": info}


+RX_VSTEP = re.compile(r"^@@ vstep (\d+) (\d+) (\S+)", re.M)
+
+
+def parse_versions(text: str) -> dict:
+    """Progress of versions.sh: one phase per version."""
+    steps = RX_VSTEP.findall(text)
+    i, n, key = steps[-1]
+    info = {"version": key, "versions": int(n)}
+    if RX_DONE.search(text):
+        info["done"] = True
+    return {"phase": int(i) - 1, "pct": round(100 * (int(i) - 1) / int(n)), "eta": None, "info": info}
+
+
 def parse_output(text: str) -> dict:
    text = text.replace("\r", "\n")
    if "@@ cphase" in text:
        return parse_combine(text)
+    if "@@ vstep" in text:
+        return parse_versions(text)
    phase, pct, eta = 0, None, None
    info = {}
    m = None
@@ -503,7 +599,7 @@ def job_status(tail=True) -> dict | None:
        return None
    out = Path(st["out"])
    text = out.read_text(errors="replace") if out.exists() else ""
-    running = (proc is not None and proc.poll() is None) or (proc is None and pid_alive(st["pid"]))
+    running = pid_alive(st["pid"])
    parsed = parse_output(text)
    res = {**st, **parsed, "running": running}
    if tail:
@@ -608,39 +704,46 @@ def activity() -> dict:
    job = None
    if js and js["running"]:
        job = {k: js.get(k) for k in ("name", "phase", "pct", "eta", "upload")}
-    dl = download if download and not download.get("finished") else None
-    return {"job": job, "download": {"pct": round(100 * dl["done"] / max(dl["total"], 1))} if dl else None,
+    b = download_batch
+    pct = (round(100 * (b["done_bytes"] + (download["done"] if download and not download.get("finished") else 0))
+                 / max(b["bytes"], 1)) if download_busy() else None)
+    return {"job": job, "download": {"pct": pct} if pct is not None else None,
            "checking": check_busy(), "uploading": any(u["proc"].poll() is None for u in uploads.values())}


+def watch_once(was_running):
+    """One look at the jobs: notification and tidying up when a run has ended. Returns whether one runs."""
+    if proc is not None:
+        proc.poll()                             # reap the zombie
+    js = job_status(tail=False)
+    running = bool(js and js["running"])
+    if was_running and not running and js:
+        mins = round((time.time() - js["started"]) / 60)
+        if js["result"] == "ok":
+            if js["info"].get("folder"):
+                write_meta(js["slug"], frame_folder=js["info"]["folder"])
+            with meta_lock:                     # the replaced scene's settings are not needed any more
+                meta = read_meta(js["slug"])
+                if meta.pop("previous", None) is not None:
+                    write_json(meta_file(js["slug"]), meta)
+            notify(t("notify.done.title"),
+                   t("notify.done.frame" if js["upload"] else "notify.done.local", name=js["name"], mins=mins))
+        elif js["result"] == "failed":
+            notify(t("notify.failed.title"), t("notify.failed", name=js["name"]))
+    if not running:
+        restore_previous()
+    for slug in list(uploads):
+        upload_status(slug)                     # notify even without an open page
+    return running
+
+
 def watcher():
-    """Notification when a run ends; stop the server after a longer idle time."""
+    """Every few seconds: notifications and tidying up; stop the server after a longer idle time."""
    was_running = None
    while True:
        time.sleep(3)
-        if proc is not None:
-            proc.poll()                         # reap the zombie
-        js = job_status(tail=False)
-        running = bool(js and js["running"])
-        if was_running and not running and js:
-            mins = round((time.time() - js["started"]) / 60)
-            if js["result"] == "ok":
-                if js["info"].get("folder"):
-                    write_meta(js["slug"], frame_folder=js["info"]["folder"])
-                with meta_lock:                 # the replaced scene's settings are not needed any more
-                    meta = read_meta(js["slug"])
-                    if meta.pop("previous", None) is not None:
-                        write_json(meta_file(js["slug"]), meta)
-                notify(t("notify.done.title"),
-                       t("notify.done.frame" if js["upload"] else "notify.done.local", name=js["name"], mins=mins))
-            elif js["result"] == "failed":
-                notify(t("notify.failed.title"), t("notify.failed", name=js["name"]))
-        was_running = running
-        if not running:
-            restore_previous()
-        for slug in list(uploads):
-            upload_status(slug)                 # notify even without an open page
-        busy = (running or (download and not download.get("finished")) or check_busy()
+        was_running = running = watch_once(was_running)
+        busy = (running or download_busy() or check_busy()
                or any(u["proc"].poll() is None for u in uploads.values()))
        if idle_exit and not busy and time.time() - last_request > CFG.idle_minutes * 60:
            os._exit(0)
@@ -648,31 +751,360 @@ def watcher():

 # ---------------------------------------------------------------- copy to the Frame

-def start_upload(slug: str):
+# ---------------------------------------------------------------- scale (models, e.g. a model railway)
+
+SCALE_MAX = 1000                           # 1:1000 – further than any model railway or building model
+
+
+def world_scale_env(meta: dict) -> dict:
+    """WORLD_SCALE for to-frame.sh/combine.sh: show a model in Gaussian XR in the size of the original."""
+    scale = meta.get("scale") or 1
+    return {"WORLD_SCALE": f"{scale:g}"} if meta.get("scale_xr") and scale != 1 else {}
+
+
+def set_scale(slug: str, ratio, xr: bool, members: bool, update_frame: bool):
+    """Scale 1:ratio of a scene or group (1 = original size). For a group optionally also for its scenes."""
+    try:
+        ratio = float(ratio)
+    except (TypeError, ValueError):
+        return err("err.bad_value", key="scale")
+    if not 1 <= ratio <= SCALE_MAX or ratio != ratio:
+        return err("err.range", key="scale", lo=1, hi=SCALE_MAX)
+    meta = read_meta(slug) if slug and Path(slug).name == slug and not slug.startswith(".") else {}
+    group = is_group(meta)
+    if not group and not (scene_dir(slug) and (RUNS / slug / "scene.sog").exists()):
+        return err("err.no_scene")
+    targets = [slug] + ([m for m in meta.get("members", []) if scene_dir(m)] if group and members else [])
+    if any(scene_busy(t_) for t_ in targets):
+        return err("err.scene_busy")
+    xr = bool(xr) and ratio != 1
+    for t_ in targets:
+        write_meta(t_, scale=ratio if ratio != 1 else None, scale_xr=xr)
+    if update_frame and FRAME and (RUNS / slug / "scene.sog").exists():
+        return start_upload(slug)                       # the Frame gets the new worldScale
+    return None
+
+
+# ---------------------------------------------------------------- versions (scripts/versions.sh)
+
+VERSION_LIMITS = (10_000, 50_000_000)       # splats
+
+
+def read_version(vdir: Path) -> dict:
+    try:
+        return json.loads((vdir / "version.json").read_text())
+    except (OSError, ValueError):
+        return {}
+
+
+def version_key(splats, scale: float) -> str:
+    """Folder name of a version: 1m, 0.75m, all; with a scale e.g. 1m-1x87."""
+    key = "all" if splats == "all" else f"{splats / 1e6:g}m"
+    return key + (f"-1x{scale:g}" if scale != 1 else "")
+
+
+def versions_of(slug: str) -> list:
+    d = scene_dir(slug)
+    if not d or not (d / "versions").is_dir():
+        return []
+    meta = read_meta(slug)
+    source = d / "spirula" / "scene.ply"
+    built = source.stat().st_mtime if source.exists() else 0
+    fr = frame_listing()
+    folders = meta.get("version_folders") or {}
+    out = []
+    for vdir in sorted((d / "versions").iterdir()):
+        info = read_version(vdir)
+        if not info or not (vdir / "scene.sog").exists():
+            continue
+        key = vdir.name
+        on_frame = None
+        if fr is not None:
+            folder = folders.get(key)
+            on_frame = (folder in fr["scenes"]) if folder else any(
+                re.fullmatch(r"\d\d_" + re.escape(f"{slug}-{key}"), x) for x in fr["scenes"])
+        out.append({"key": key, "label": info.get("label"), "splats": info.get("splats"), "scale": info.get("scale", 1),
+                    "size": (vdir / "scene.sog").stat().st_size, "created": int(info.get("created", 0)),
+                    "stale": info.get("created", 0) < built, "on_frame": on_frame,
+                    "upload": upload_status(f"{slug}#{key}")})
+    return sorted(out, key=lambda v: (v["scale"], v["splats"] or 0))
+
+
+def start_versions(p: dict):
+    """New versions of a scene or tour: sizes (splats, or "all") times scales."""
+    global proc
+    slug = p.get("slug", "")
+    d = scene_dir(slug) if slug and not slug.startswith(".") else None
+    if not d or not (d / "spirula" / "scene.ply").exists() or not (d / "scene.sog").exists():
+        return err("err.no_scene")
+    sizes, scales = [], []
+    for x in (p.get("sizes") or "").split(","):
+        x = x.strip()
+        if not x:
+            continue
+        if x == "all":
+            sizes.append("all")
+            continue
+        try:
+            n = int(float(x))
+        except ValueError:
+            return err("err.bad_value", key="sizes")
+        if not VERSION_LIMITS[0] <= n <= VERSION_LIMITS[1]:
+            return err("err.range", key="sizes", lo=VERSION_LIMITS[0], hi=VERSION_LIMITS[1])
+        sizes.append(n)
+    for x in (p.get("scales") or "1").split(","):
+        try:
+            sc = float(x)
+        except ValueError:
+            return err("err.bad_value", key="scales")
+        if not 1 <= sc <= SCALE_MAX or sc != sc:
+            return err("err.range", key="scales", lo=1, hi=SCALE_MAX)
+        scales.append(sc)
+    if not sizes:
+        return err("err.no_versions")
+    meta = read_meta(slug)
+    name = meta.get("name") or slug
+    specs = []
+    for sc in dict.fromkeys(scales):
+        for n in dict.fromkeys(sizes):
+            size = t("ver.all") if n == "all" else t("ver.size", n=f"{n / 1e6:g}".replace(".", "," if t.lang == "de" else "."))
+            plate = f"{name} · {size}" + (f" · 1:{sc:g}" if sc != 1 else "")
+            specs.append(f"{version_key(n, sc)}|{n}|{sc:g}|{plate}")
+    with lock:
+        if (cur := load_state().get("job")) and pid_alive(cur["pid"]):
+            return err("err.job_busy")
+        if scene_busy(slug):
+            return err("err.scene_busy")
+        JOBS.mkdir(parents=True, exist_ok=True)
+        out = JOBS / f"{time.strftime('%Y-%m-%d_%H-%M-%S')}_versions_{slug}.out"
+        with open(out, "wb") as fh:
+            proc = subprocess.Popen(keep_awake([str(SCRIPTS / "versions.sh"), str(d), *specs],
+                                               t("inhibit.versions", name=name)), cwd=ROOT, stdout=fh,
+                                    stderr=subprocess.STDOUT, stdin=subprocess.DEVNULL, start_new_session=True)
+        st = load_state()
+        st["job"] = {"kind": "versions", "pid": proc.pid, "out": str(out), "name": name, "slug": slug,
+                     "recording": "", "quality": "", "upload": False, "started": time.time(), "overrides": {},
+                     "steps": [s.split("|")[3].removeprefix(name + " · ") for s in specs]}
+        save_state(st)
+    return None
+
+
+GALLERY_TTL = 20                           # seconds the list of the Frame's gallery is reused
+gallery_cache = {"t": 0, "data": None}
+RX_FOLDER = re.compile(r"[A-Za-z0-9][A-Za-z0-9._ -]*")
+
+
+def frame_gallery(force=False):
+    """Every scene in Gaussian XR's gallery on the Frame (a folder with a preview image), with what it is:
+    a scene, tour or version made here, or something else (e.g. Gaussian XR's examples). None = no Frame."""
+    if not FRAME:
+        return None
+    if not force and time.time() - gallery_cache["t"] < GALLERY_TTL:
+        return gallery_cache["data"]
+    cmd = "".join(f'(cd {path} 2>/dev/null && for d in */; do d=${{d%/}}; '
+                  f'g=$(ls "$d"/*.gallery.png 2>/dev/null | head -1); [ -n "$g" ] || continue; '
+                  f'echo "{place}|$d|$(du -sb "$d" | cut -f1)|${{g##*/}}"; done); ' for place, path in FRAME_PLACES.items())
+    cmd += "true"
+    try:
+        r = subprocess.run(SSH + [cmd], capture_output=True, text=True, timeout=20)
+    except subprocess.TimeoutExpired:
+        r = None
+    if r is None or r.returncode == 255:
+        gallery_cache.update(t=time.time(), data=None)
+        return None
+    owners = {}                                 # folder -> (slug, version, kind, name)
+    for f in RUNS.glob("*.ui.json"):
+        slug = f.name.removesuffix(".ui.json")
+        meta = read_meta(slug)
+        kind, name = ("tour" if is_group(meta) else "scene"), meta.get("name") or slug
+        if meta.get("frame_folder"):
+            owners[meta["frame_folder"]] = (slug, "", kind, name)
+        for key, folder in (meta.get("version_folders") or {}).items():
+            label = read_version(RUNS / slug / "versions" / key).get("label") or f"{name} · {key}"
+            owners[folder] = (slug, key, "version", label)
+        owners.setdefault(("re", slug), (slug, "", kind, name))
+    out = []
+    for line in r.stdout.splitlines():
+        place, _, line = line.partition("|")
+        folder, _, rest = line.partition("|")
+        size, _, preview = rest.partition("|")
+        if place not in FRAME_PLACES or not RX_FOLDER.fullmatch(folder):
+            continue
+        owner = owners.get(folder)
+        if not owner and (m := re.fullmatch(r"\d\d_(.+)", folder)):
+            rest_ = m.group(1)
+            owner = owners.get(("re", rest_))
+            if not owner and "-" in rest_:              # <scene>-<version>
+                slug, _, key = rest_.rpartition("-")
+                if (RUNS / slug / "versions" / key / "version.json").exists():
+                    owner = (slug, key, "version", read_version(RUNS / slug / "versions" / key).get("label") or rest_)
+        slug, version, kind, name = owner or ("", "", "other", re.sub(r"^\d\d_", "", folder))
+        out.append({"folder": folder, "place": place, "size": int(size or 0), "preview": preview, "slug": slug,
+                    "version": version, "kind": kind, "name": name})
+    gallery_cache.update(t=time.time(), data=out)
+    return out
+
+
+def gallery_entry(gallery, folder: str, place: str = ""):
+    """A scene in the Frame's gallery by its folder (and place, when the same name is in both)."""
+    return next((x for x in gallery or [] if x["folder"] == folder and place in ("", x["place"])), None)
+
+
+def frame_preview(folder: str, place: str = ""):
+    """The gallery image of a scene on the Frame (cached on the PC)."""
+    g = gallery_entry(frame_gallery(), folder, place)
+    if not g:
+        return None
+    CACHE.mkdir(parents=True, exist_ok=True)
+    cached = CACHE / f"frame-{hashlib.sha1(f'{g['place']}|{folder}|{g['size']}'.encode()).hexdigest()[:16]}.png"
+    if cached.exists():
+        return cached.read_bytes()
+    try:
+        r = subprocess.run(SSH + [f"cat {FRAME_PLACES[g['place']]}/{shq(folder)}/{shq(g['preview'])}"],
+                           capture_output=True, timeout=20)
+    except subprocess.TimeoutExpired:
+        return None
+    if r.returncode != 0 or not r.stdout:
+        return None
+    cached.write_bytes(r.stdout)
+    return r.stdout
+
+
+def remove_frame_folder(folder: str, place: str = ""):
+    """Take a scene off the Frame's gallery – any scene in it (also Gaussian XR's examples; Steam brings
+    those back with "verify files"). The PC is not touched."""
+    if not FRAME:
+        return err("err.no_frame")
+    gallery = frame_gallery(force=True)
+    if gallery is None:
+        return err("err.frame_offline")
+    g = gallery_entry(gallery, folder, place)
+    if not g or not RX_FOLDER.fullmatch(folder):
+        return err("err.not_on_frame_version")
+    key = f"{g['slug']}#{g['version']}" if g["version"] else g["slug"]
+    if g["slug"] and (u := uploads.get(key)) and u["proc"].poll() is None:
+        return err("err.upload_busy")
+    try:
+        r = subprocess.run(SSH + [f"rm -rf -- {FRAME_PLACES[g['place']]}/{shq(folder)} {FRAME_BACKUP}/{shq(folder)}"],
+                           capture_output=True, text=True, timeout=30)
+    except subprocess.TimeoutExpired:
+        return err("err.frame_offline")
+    if r.returncode != 0:
+        return err("err.frame_failed", detail=(r.stderr.strip().splitlines() or [""])[-1])
+    if g["slug"]:                               # forget the folder, so copying again makes a new one
+        meta = read_meta(g["slug"])
+        if g["version"]:
+            folders = meta.get("version_folders") or {}
+            folders.pop(g["version"], None)
+            write_meta(g["slug"], version_folders=folders)
+        elif meta.get("frame_folder") == folder:
+            write_meta(g["slug"], frame_folder=None)
+        uploads.pop(key, None)
+    gallery_cache["t"] = frame_cache["t"] = 0
+    return None
+
+
+def remove_from_frame(slug: str, version: str):
+    """Take one version of a scene off the Frame."""
+    if not FRAME:
+        return err("err.no_frame")
+    if not slug or slug.startswith(".") or not version or version.startswith(".") or Path(version).name != version:
+        return err("err.no_version")
+    gallery = frame_gallery(force=True)
+    if gallery is None:
+        return err("err.frame_offline")
+    g = next((x for x in gallery if x["slug"] == slug and x["version"] == version), None)
+    if not g:
+        return err("err.not_on_frame_version")
+    return remove_frame_folder(g["folder"], g["place"])
+
+
+def move_to_own_folder():
+    """Move the scenes made here out of Gaussian XR's own gallery folder (where 0.2.3 and older copied them,
+    and where a Steam update may remove them) into the folder for personal scenes. Gaussian XR's examples stay."""
+    if not FRAME:
+        return err("err.no_frame")
+    gallery = frame_gallery(force=True)
+    if gallery is None:
+        return err("err.frame_offline")
+    if any(u["proc"].poll() is None for u in uploads.values()):    # to-frame.sh may be choosing or moving a folder
+        return err("err.upload_busy")
+    moving = [g for g in gallery if g["place"] == "steam" and g["kind"] != "other"]
+    if not moving:
+        return None
+    # A folder of the same name in the personal folder is the newer copy: the old one goes
+    cmd = f"mkdir -p {FRAME_SCENES} && " + " && ".join(
+        f"{{ [ -e {FRAME_SCENES}/{shq(g['folder'])} ] && rm -rf -- {FRAME_STEAM}/{shq(g['folder'])} || "
+        f"mv -- {FRAME_STEAM}/{shq(g['folder'])} {FRAME_SCENES}/; }}" for g in moving)
+    try:
+        r = subprocess.run(SSH + [cmd], capture_output=True, text=True, timeout=60)
+    except subprocess.TimeoutExpired:
+        return err("err.frame_offline")
+    gallery_cache["t"] = frame_cache["t"] = 0
+    if r.returncode != 0:
+        return err("err.frame_failed", detail=(r.stderr.strip().splitlines() or [""])[-1])
+    return None
+
+
+def delete_version(slug: str, key: str):
+    d = scene_dir(slug) if slug and not slug.startswith(".") else None
+    vdir = d / "versions" / Path(key).name if d and key and not key.startswith(".") else None
+    if not vdir or not vdir.is_dir():
+        return err("err.no_version")
+    if scene_busy(slug) or ((u := uploads.get(f"{slug}#{key}")) and u["proc"].poll() is None):
+        return err("err.scene_busy")
+    try:
+        r = subprocess.run(["gio", "trash", "--", str(vdir)], capture_output=True, text=True, timeout=120)
+    except (OSError, subprocess.TimeoutExpired) as e:
+        return err("err.trash_failed", detail=str(e))
+    if r.returncode != 0:
+        return err("err.trash_failed", detail=(r.stderr.strip().splitlines() or [""])[-1])
+    usage_cache.pop(d, None)
+    return None
+
+
+def start_upload(slug: str, version: str = ""):
+    """Copy a scene – or one of its versions – to the Frame. Every version gets its own scene folder there."""
    if not FRAME:
        return err("err.no_frame")
    d = scene_dir(slug)
    if not d or not (d / "scene.sog").exists():
        return err("err.no_scene")
+    vdir = None
+    if version:
+        vdir = d / "versions" / Path(version).name
+        if version.startswith(".") or not (vdir / "scene.sog").exists():
+            return err("err.no_version")
+    key = f"{slug}#{version}" if version else slug
    with lock:
-        u = uploads.get(slug)
+        u = uploads.get(key)
        if u and u["proc"].poll() is None:
            return err("err.upload_busy")
        meta = read_meta(slug)
        env = {**os.environ}
-        for key, var in (("frame_folder", "TARGET"), ("stem", "STEM")):
-            if meta.get(key):
-                env[var] = meta[key]
-        if meta.get("log"):
-            env["LOG"] = str(RUNS / Path(meta["log"]).name)
+        name = meta.get("name") or slug
+        if vdir:
+            info = read_version(vdir)
+            name = info.get("label") or name
+            env.update(STEM=f"{slug}-{version}".lower(), SLUG=f"{slug}-{version}",
+                       LOG=str(RUNS / Path(meta.get("log") or f"{slug}.log").name))
+            if folder := (meta.get("version_folders") or {}).get(version):
+                env["TARGET"] = folder
+        else:
+            for k, var in (("frame_folder", "TARGET"), ("stem", "STEM")):
+                if meta.get(k):
+                    env[var] = meta[k]
+            env.update(world_scale_env(meta))
+            if meta.get("log"):
+                env["LOG"] = str(RUNS / Path(meta["log"]).name)
        JOBS.mkdir(parents=True, exist_ok=True)
-        out = JOBS / f"{time.strftime('%Y-%m-%d_%H-%M-%S')}_to-frame_{slug}.out"
+        out = JOBS / f"{time.strftime('%Y-%m-%d_%H-%M-%S')}_to-frame_{slug}{'-' + version if version else ''}.out"
        with open(out, "wb") as fh:
-            p = subprocess.Popen(keep_awake([str(SCRIPTS / "to-frame.sh"), str(d), meta.get("name") or slug],
-                                            t("inhibit.upload", name=meta.get("name") or slug)), cwd=ROOT, env=env,
+            p = subprocess.Popen(keep_awake([str(SCRIPTS / "to-frame.sh"), str(vdir or d), name],
+                                            t("inhibit.upload", name=name)), cwd=ROOT, env=env,
                                 stdout=fh, stderr=subprocess.STDOUT, stdin=subprocess.DEVNULL,
                                 start_new_session=True)
-        uploads[slug] = {"proc": p, "out": out, "started": time.time(), "notified": False}
+        uploads[key] = {"proc": p, "out": out, "started": time.time(), "notified": False}
    return None


@@ -688,7 +1120,12 @@ def upload_status(slug: str):
        name = read_meta(slug).get("name") or slug
        if rc == 0:
            if (d := RX_DONE.search(text)) and d[2]:
-                write_meta(slug, frame_folder=d[2])
+                scene, _, version = slug.partition("#")
+                if version:
+                    folders = read_meta(scene).get("version_folders") or {}
+                    write_meta(scene, version_folders={**folders, version: d[2]})
+                else:
+                    write_meta(slug, frame_folder=d[2])
            frame_cache["t"] = 0
            notify(t("notify.upload.title"), t("notify.upload", name=name))
        else:
@@ -781,7 +1218,9 @@ def scenes():
                    "recording": meta.get("recording"), "size": sog.stat().st_size,
                    "mtime": int(sog.stat().st_mtime), "gaussians": gauss, "preview": bool(gallery),
                    "ply": (d / "spirula" / "scene.ply").exists(), "on_frame": on_frame, "disk": disk_usage(d),
-                    "upload": upload_status(slug), "replacing": replacing})
+                    "upload": upload_status(slug), "replacing": replacing,
+                    "scale": meta.get("scale") or 1, "scale_xr": bool(meta.get("scale_xr")),
+                    "versions": len(list(d.glob("versions/*/version.json")))})
    return out


@@ -790,8 +1229,9 @@ def scenes():
 plan_locks = {}                    # cache key -> Lock, so one plan is drawn only once at a time


-def floorplan(slugs: list[str], style: str, lang: str, title: str):
-    """(PNG bytes, info dict with pixels_per_metre) of one or more scenes (cached), or an error dict."""
+def floorplan(slugs: list[str], style: str, lang: str, title: str, group: str = ""):
+    """(PNG bytes, info dict with pixels_per_metre) of one or more scenes (cached), or an error dict.
+    The plan of a group is drawn in the group's scale, if it has one; otherwise all scenes need the same."""
    if style not in ("pretty", "classic"):
        style = "pretty"
    runs = []
@@ -803,9 +1243,19 @@ def floorplan(slugs: list[str], style: str, lang: str, title: str):
        runs.append((d, read_meta(slug).get("name") or slug, ply.stat().st_mtime))
    if not runs or len(runs) > 12:
        return err("err.bad_request")
+    gmeta = read_meta(group) if group and Path(group).name == group and not group.startswith(".") else {}
+    if gmeta and not is_group(gmeta):
+        return err("err.bad_request")
+    if (gmeta.get("scale") or 1) != 1:
+        ratio = gmeta["scale"]
+    else:
+        scales = {read_meta(slug).get("scale") or 1 for slug in dict.fromkeys(slugs)}
+        if len(scales) > 1:
+            return err("err.mixed_scale")
+        ratio = scales.pop()
    title = title.strip()[:60]
    script = (SCRIPTS / "floorplan.py").stat().st_mtime        # a new version of the script draws anew
-    key = hashlib.sha1(json.dumps([[str(r[0]), r[1], r[2]] for r in runs] + [style, lang, title, script]).encode()).hexdigest()[:16]
+    key = hashlib.sha1(json.dumps([[str(r[0]), r[1], r[2]] for r in runs] + [style, lang, title, script, ratio]).encode()).hexdigest()[:16]
    out = CACHE / f"plan-{key}.png"
    meta = out.with_suffix(".json")
    with lock:
@@ -819,6 +1269,8 @@ def floorplan(slugs: list[str], style: str, lang: str, title: str):
                cmd += ["--title", title]
            if lang == "de":
                cmd.append("--comma")
+            if ratio != 1:
+                cmd += ["--ratio", str(ratio)]
            if not plan_slots.acquire(timeout=1):
                return err("err.plan_busy")
            try:
@@ -1018,7 +1470,9 @@ def move_scene(slug: str, new: str) -> None:
        meta["frame_folder"] = next((s for s in fr["scenes"] if re.fullmatch(r"\d\d_" + re.escape(slug), s)), None)
    old_stem, new_stem = meta.get("stem") or slug.lower(), new.lower()
    d.rename(nd)
-    for folder, old, new_ in ((nd, old_stem, new_stem), (nd / "full", f"{old_stem}-full", f"{new_stem}-full")):
+    renames = [(nd, old_stem, new_stem), (nd / "full", f"{old_stem}-full", f"{new_stem}-full")]
+    renames += [(v, f"{slug}-{v.name}".lower(), f"{new}-{v.name}".lower()) for v in (nd / "versions").glob("*/")]
+    for folder, old, new_ in renames:
        for f in folder.glob(f"{glob_escape(old)}.*"):         # full/: the full version of a tour
            if f.name[len(old):] in (".sog", ".xrSceneTransform.json", ".gallery.png", ".sceneinfo.png"):
                f.rename(folder / (new_ + f.name[len(old):]))
@@ -1137,6 +1591,66 @@ def rename_recording(name: str, new: str):
    return None


+def recording_in_use(name: str):
+    """Why a recording can't be deleted right now (converted, checked or fetched), or None."""
+    job = load_state().get("job") or {}
+    if job.get("recording") == name and pid_alive(job.get("pid", 0)):
+        return err("err.recording_busy")
+    if checks.get(name, {}).get("state") in ("queued", "running"):
+        return err("err.recording_busy")
+    if download_busy() and (name in [f["name"] for f in download_queue] or (download and download["name"] == name)):
+        return err("err.recording_fetching")
+    return None
+
+
+def delete_recording(name: str):
+    """A recording on this PC into the desktop trash (recoverable). Only from the recordings folder."""
+    src = REC / Path(name).name
+    if not name or not src.is_file() or src.parent.resolve() != REC.resolve():
+        return err("err.not_local")
+    if e := recording_in_use(src.name):
+        return e
+    unfinished = [m.name.removesuffix(".ui.json") for m in RUNS.glob("*.ui.json")
+                  if read_meta(m.name.removesuffix(".ui.json")).get("recording") == src.name]
+    unfinished = [s for s in unfinished if (RUNS / s).is_dir() and not (RUNS / s / "scene.sog").exists()]
+    if unfinished:
+        return err("err.recording_needed", name=read_meta(unfinished[0]).get("name") or unfinished[0])
+    try:
+        r = subprocess.run(["gio", "trash", "--", str(src)], capture_output=True, text=True, timeout=120)
+    except (OSError, subprocess.TimeoutExpired) as e:
+        return err("err.trash_failed", detail=str(e))
+    if r.returncode != 0:
+        return err("err.trash_failed", detail=(r.stderr.strip().splitlines() or [""])[-1])
+    with lock:
+        meta = rec_meta()
+        if meta.pop(src.name, None) is not None:
+            write_json(RECMETA, meta, indent=1)
+        checks.pop(src.name, None)
+    frame_cache["t"] = 0
+    return None
+
+
+def delete_frame_recording(name: str):
+    """A recording on the Frame, for good (the Frame has no trash). Only from the Frame's recordings."""
+    if not FRAME:
+        return err("err.no_frame")
+    fr = frame_listing(force=True)
+    if fr is None:
+        return err("err.frame_offline")
+    if not any(f["name"] == name for f in fr["files"]) or Path(name).name != name:
+        return err("err.not_on_frame")
+    if e := recording_in_use(name):
+        return e
+    try:
+        r = subprocess.run(SSH + [f"rm -f -- {FRAME_VIDEOS}/{shq(name)}"], capture_output=True, text=True, timeout=30)
+    except subprocess.TimeoutExpired:
+        return err("err.frame_offline")
+    if r.returncode != 0:
+        return err("err.frame_failed", detail=(r.stderr.strip().splitlines() or [""])[-1])
+    frame_cache["t"] = 0
+    return None
+
+
 # ---------------------------------------------------------------- groups and tours (scripts/combine.sh)

 # A group is a <slug>.ui.json with kind "group" and its member scenes; once put together, the tour
@@ -1204,6 +1718,8 @@ def groups():
                   "on_frame": on_frame, "upload": upload_status(slug), "disk": disk_usage(d)}
        out.append({"slug": slug, "name": meta.get("name") or slug, "members": members, "result": res,
                    "busy": scene_busy(slug), "options": {k: meta.get(k) for k in ("align", "partition", "frame_splats", "full")},
+                    "scale": meta.get("scale") or 1, "scale_xr": bool(meta.get("scale_xr")),
+                    "versions": len(list(d.glob("versions/*/version.json"))),
                    "splats": sum(scene_list[m].get("gaussians") or 0 for m in members)})
    return {"groups": out, "suggestion": suggestion(scene_list, out), "mem_available_gb": mem_available()}

@@ -1292,7 +1808,7 @@ def start_combine(p: dict):
    if align not in ALIGNS or partition not in PARTITIONS:
        return err("err.bad_request")
    try:
-        frame_splats = int(p.get("frame_splats") or 3_500_000)
+        frame_splats = int(p.get("frame_splats") or 1_000_000)
    except (TypeError, ValueError):
        return err("err.bad_value", key="frame_splats")
    if not 500_000 <= frame_splats <= 10_000_000:
@@ -1315,6 +1831,7 @@ def start_combine(p: dict):
            env["PLAN_COMMA"] = "1"
        if meta.get("frame_folder"):
            env["TARGET"] = meta["frame_folder"]
+        env.update(world_scale_env(meta))
        upload = bool(p.get("upload")) and bool(FRAME)
        if not upload:
            env["NO_UPLOAD"] = "1"
@@ -1455,16 +1972,24 @@ class Handler(http.server.BaseHTTPRequestHandler):
            return self.send(200, check_status(Path(q.get("name", "")).name))
        if u.path == "/api/status":
            ups = {s: upload_status(s) for s in list(uploads)}
-            return self.send(200, {"job": job_status(), "download": download, "uploads": ups})
+            return self.send(200, {"job": job_status(), "download": download_status(), "uploads": ups})
        if u.path == "/api/scenes":
            return self.send(200, scenes())
        if u.path == "/api/unfinished":
            return self.send(200, unfinished_runs())
        if u.path == "/api/groups":
            return self.send(200, groups())
+        if u.path == "/api/frame/gallery":
+            g = frame_gallery(force=bool(q.get("refresh")))
+            return self.send(200, {"online": g is not None, "configured": bool(FRAME), "scenes": g or []})
+        if u.path == "/api/frame/preview":
+            data = frame_preview(q.get("folder", ""), q.get("place", ""))
+            return self.send(200, data, "image/png", cache=True) if data else self.send(404, b"", "image/png")
+        if u.path == "/api/versions":
+            return self.send(200, {"versions": versions_of(q.get("slug", ""))})
        if u.path == "/api/floorplan":
            data = floorplan([x for x in q.get("slugs", "").split(",") if x], q.get("style", "pretty"),
-                             q.get("lang", "en"), q.get("title", ""))
+                             q.get("lang", "en"), q.get("title", ""), q.get("group", ""))
            if isinstance(data, dict):
                return self.send(400, {"error": data})
            data, info = data
@@ -1502,7 +2027,9 @@ class Handler(http.server.BaseHTTPRequestHandler):
            p = None
        # Only flat objects of simple values; text fields are text
        if not isinstance(p, dict) or any(not isinstance(v, (str, int, float, bool, type(None))) for v in p.values()) \
-                or any(not isinstance(p.get(k, ""), str) for k in ("name", "new", "slug", "path", "what", "quality", "existing")):
+                or any(not isinstance(p.get(k, ""), str) for k in ("name", "new", "slug", "path", "what", "quality", "existing", "members", "key", "version", "sizes", "scales", "folder",
+                                                           "names", "place", "where",
+                                                           "align", "partition")):
            return self.send(400, {"error": err("err.bad_request")})
        path = urllib.parse.urlparse(self.path).path
        e = None
@@ -1518,10 +2045,23 @@ class Handler(http.server.BaseHTTPRequestHandler):
            e = cancel_job()
        elif path == "/api/download":
            fr = frame_listing()
-            f = next((f for f in (fr or {}).get("files", []) if f["name"] == p.get("name")), None)
-            e = start_download(f["name"], f["size"]) if f else err("err.not_on_frame")
+            names = p["names"].split("\n") if p.get("names") else [p.get("name")]     # several: one per line
+            on_frame = {f["name"]: f for f in (fr or {}).get("files", [])}
+            files = [on_frame[n] for n in names if isinstance(n, str) and n in on_frame]
+            e = start_download(files) if files else err("err.not_on_frame")
+        elif path == "/api/download/cancel":
+            e = cancel_download()
        elif path == "/api/upload":
-            e = start_upload(p.get("slug", ""))
+            e = start_upload(p.get("slug", ""), p.get("version", ""))
+        elif path == "/api/versions":
+            e = start_versions(p)
+        elif path == "/api/frame/remove":
+            e = (remove_frame_folder(p["folder"], p.get("place", "")) if p.get("folder") else
+                 remove_from_frame(p.get("slug", ""), p.get("version", "")))
+        elif path == "/api/frame/move":
+            e = move_to_own_folder()
+        elif path == "/api/version/delete":
+            e = delete_version(p.get("slug", ""), p.get("version", ""))
        elif path == "/api/pick":
            chosen = pick_file()
            if chosen:
@@ -1529,6 +2069,9 @@ class Handler(http.server.BaseHTTPRequestHandler):
            return self.send(200, {"path": chosen})
        elif path == "/api/check":
            e = start_check(Path(p.get("name", "")).name)
+        elif path == "/api/recording/delete":
+            e = delete_frame_recording(p.get("name", "")) if p.get("where") == "frame" else (
+                delete_recording(p.get("name", "")) if p.get("where") == "pc" else err("err.bad_request"))
        elif path == "/api/rename":
            if p.get("slug"):
                e = rename_scene(p["slug"], p.get("new", ""), bool(p.get("update_frame")))
@@ -1545,6 +2088,9 @@ class Handler(http.server.BaseHTTPRequestHandler):
            e = save_group(p.get("slug", ""), p.get("name", ""), p.get("members", ""))
            if isinstance(e, str):
                return self.send(200, {"ok": True, "slug": e})
+        elif path == "/api/scale":
+            e = set_scale(p.get("slug", ""), p.get("scale"), bool(p.get("xr")), bool(p.get("with_scenes")),
+                          bool(p.get("update_frame")))
        elif path == "/api/group/dismiss":
            st = load_state()
            st["dismissed_groups"] = sorted(set(st.get("dismissed_groups", [])) | {p.get("key", "")})[-50:]
@@ -0,0 +1,306 @@
+"""Test setup: a temporary home for Splat Workshop with fake tools, and the server on a free port.
+
+The real Arcturus pipeline, Spirula, splat-transform and the desktop trash are replaced by small fakes
+(written below), so the tests run anywhere – no GPU, no recordings, no Steam Frame. The server reads
+its configuration when it is imported, so everything is set up before that, once per test session.
+"""
+import http.client
+import json
+import os
+import shutil
+import sys
+import tempfile
+import threading
+import time
+from pathlib import Path
+
+import pytest
+
+ROOT = Path(__file__).resolve().parent.parent
+sys.path[:0] = [str(ROOT), str(Path(__file__).parent)]
+
+BASE = Path(tempfile.mkdtemp(prefix="splat-workshop-tests-"))
+RUNS, REC, STATE, BIN, TRASH, PIPE, FRAME_HOME = (BASE / n for n in (
+    "runs", "recordings", "state", "bin", "trash", "pipeline", "frame"))
+for d in (RUNS, REC, STATE, BIN, TRASH, PIPE, FRAME_HOME):
+    d.mkdir()
+TOOL_LOG = BASE / "tools.log"              # what the fake tools were called with, one JSON line each
+
+
+def script(path: Path, text: str):
+    path.write_text(text)
+    path.chmod(0o755)
+
+
+# Fake pipeline: behaves like av1_to_3dgs.py as far as Splat Workshop can see (progress lines, result files).
+# FAKE_PIPELINE=ok (default) | fail | slow (waits for 60 s, to be cancelled)
+script(PIPE / "av1_to_3dgs.py", r'''
+import base64, json, os, sys, time
+from pathlib import Path
+out = Path(sys.argv[2])
+mode = os.environ.get("FAKE_PIPELINE", "ok")
+# like the real pipeline: an unfinished training blocks --resume ("Incomplete training retained")
+run_json = out / "spirula" / "run.json"
+if "--resume" in sys.argv and run_json.exists() and json.loads(run_json.read_text()).get("status") != "complete":
+    sys.exit("error: Incomplete training retained; use a new output directory to restart")
+# like the real one: an existing output folder is only continued with --resume, and only once the camera
+# positions are complete ("Incomplete native SfM retained" / "already exists without a matching manifest")
+dataset = out / "dataset" / "spirula-dataset.json"
+if out.exists() and any(out.iterdir()):
+    if "--resume" not in sys.argv:
+        sys.exit("error: Spirula SfM output already exists without a matching resume manifest")
+    if not dataset.exists() or json.loads(dataset.read_text()).get("status") != "complete":
+        sys.exit("error: Incomplete native SfM retained for diagnosis; use a fresh output directory")
+(out / "dataset").mkdir(parents=True, exist_ok=True)
+print("Extracting 20 images from 2 video streams", flush=True)
+(out / "dataset" / "spirula-dataset.json").write_text(json.dumps({"status": "complete"}))
+print("Running native Spirula SfM", flush=True)
+print("Aligned 20 cameras using orientation anchor cam0/0000.jpg: RMS 0.0110 m, median 0.0090 m.", flush=True)
+if mode == "fail":
+    sys.exit("fake pipeline: failed on purpose")
+for step in (1000, 2000, 3000):
+    print(f"step {step:6d}/3000 ({step // 30:3d}%)  splats 1000  [elapsed 00:00:0{step // 1000}.000 | ETA 00:00:01.000]  rgb_loss=0.1  ssim=0.8  psnr=28.5", flush=True)
+    if mode == "slow":
+        time.sleep(20)
+(out / "spirula").mkdir(exist_ok=True)
+(out / "spirula" / "scene.ply").write_bytes(b"ply\n")
+run_json.write_text(json.dumps({"status": "complete"}))
+print("spirula: 1,000 Gaussians in " + str(out / "spirula" / "scene.ply"), flush=True)
+(out / "scene.sog").write_bytes(b"fake sog")
+(out / "scene.xrSceneTransform.json").write_text(json.dumps({"transform": [[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 1, 0], [0, 0, 0, 1]]}))
+png = base64.b64decode("iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNk+M9QDwADhgGAWjR9awAAAABJRU5ErkJggg==")
+(out / (out.name.lower() + ".gallery.png")).write_bytes(png)
+print("Gaussian XR scene transform: " + str(out / "scene.xrSceneTransform.json"), flush=True)
+''')
+script(BIN / "spirula", "#!/bin/sh\nexit 0\n")
+# splat-transform: copies the input (a .ply stays a .ply), writes a small file for .sog
+script(BIN / "splat-transform", f'''#!{sys.executable}
+import json, shutil, sys
+with open("{TOOL_LOG}", "a") as log:
+    log.write(json.dumps(["splat-transform", *sys.argv[1:]]) + "\\n")
+args = [a for a in sys.argv[1:] if a not in ("-w", "--overwrite")]
+if "--decimate" in args:
+    i = args.index("--decimate"); del args[i:i + 2]
+src, dst = args[0], args[-1]
+if dst.endswith(".ply"):
+    shutil.copy(src, dst)
+else:
+    open(dst, "wb").write(b"fake sog")
+print("done")
+''')
+# gio trash: moves into a trash folder of the test (numbered if a name repeats)
+script(BIN / "gio", f'''#!/bin/sh
+[ "$1" = trash ] || exit 1
+shift; [ "$1" = -- ] && shift
+exec mv --backup=numbered -t "{TRASH}" -- "$@"
+''')
+
+# Nothing may open on the desktop, even if the code under test is broken: file dialogs, xdg-open (folder,
+# video player) only leave a note in the tool log
+for tool in ("kdialog", "zenity", "xdg-open"):
+    script(BIN / tool, f'''#!{sys.executable}
+import json, sys
+with open("{TOOL_LOG}", "a") as log:
+    log.write(json.dumps(["{tool}", *sys.argv[1:]]) + "\\n")
+''')
+# notify-send: no desktop notifications from the tests, only a note in the tool log
+script(BIN / "notify-send", f'''#!{sys.executable}
+import json, sys
+with open("{TOOL_LOG}", "a") as log:
+    log.write(json.dumps(["notify-send", *sys.argv[1:]]) + "\\n")
+''')
+# ffprobe: a good Arcturus recording (two video streams, gpmd, 60 s) unless the file name says otherwise:
+# "mono" one video stream, "nogpmd" no metadata stream, "short" 5 s, "brief" 15 s
+script(BIN / "ffprobe", f'''#!{sys.executable}
+import json, sys
+name = sys.argv[-1]
+video = {{"codec_type": "video", "codec_tag_string": "hvc1", "width": 2464, "height": 2464, "avg_frame_rate": "30/1"}}
+streams = [video] if "mono" in name else [video, dict(video)]
+if "nogpmd" not in name:
+    streams.append({{"codec_type": "data", "codec_tag_string": "gpmd"}})
+dur = 5 if "short" in name else 15 if "brief" in name else 60
+print(json.dumps({{"streams": streams, "format": {{"duration": str(dur)}}}}))
+''')
+# ssh / scp: the Frame is a folder (its home directory); FAKE_FRAME_OFF=1 makes it unreachable
+script(BIN / "ssh", f'''#!{sys.executable}
+import os, subprocess, sys
+if os.environ.get("FAKE_FRAME_OFF"):
+    sys.exit(255)
+args = sys.argv[1:]
+while args and args[0].startswith("-"):
+    args = args[2:] if args[0] in ("-o", "-p", "-i") else args[1:]
+cmd = " ".join(args[1:])
+env = {{**os.environ, "HOME": "{FRAME_HOME}"}}
+if os.environ.get("FAKE_FRAME_CUT") and cmd.startswith("cat "):   # the connection breaks halfway
+    out = subprocess.run(["bash", "-c", cmd], cwd="{FRAME_HOME}", env=env, capture_output=True).stdout
+    sys.stdout.buffer.write(out[:len(out) // 2])
+    sys.exit(255)
+if os.environ.get("FAKE_FRAME_SHORT") and cmd.startswith("cat "):  # ends early, but without an error
+    out = subprocess.run(["bash", "-c", cmd], cwd="{FRAME_HOME}", env=env, capture_output=True).stdout
+    sys.stdout.buffer.write(out[:len(out) // 2])
+    sys.exit(0)
+if os.environ.get("FAKE_FRAME_SLOW") and cmd.startswith("cat "):  # a slow connection: 1 kB every 0.1 s
+    import time
+    out = subprocess.run(["bash", "-c", cmd], cwd="{FRAME_HOME}", env=env, capture_output=True).stdout
+    for i in range(0, len(out), 1000):
+        sys.stdout.buffer.write(out[i:i + 1000]); sys.stdout.buffer.flush(); time.sleep(0.1)
+    sys.exit(0)
+sys.exit(subprocess.run(["bash", "-c", cmd or "true"], cwd="{FRAME_HOME}", env=env).returncode)
+''')
+script(BIN / "scp", f'''#!{sys.executable}
+import os, shutil, sys
+from pathlib import Path
+if os.environ.get("FAKE_FRAME_OFF"):
+    sys.exit(255)
+args = [a for a in sys.argv[1:] if a not in ("-q",)]
+def local(a):
+    if ":" in a.split("/", 1)[0]:
+        return Path("{FRAME_HOME}") / a.split(":", 1)[1]
+    return Path(a)
+*src, dst = map(local, args)
+if os.environ.get("FAKE_SCP_SLOW"):                       # a slow connection: copying takes 3 s
+    import time
+    time.sleep(3)
+for s in src:
+    shutil.copy(s, dst / s.name if dst.is_dir() else dst)
+''')
+
+(BASE / "config.toml").write_text(f'''
+[paths]
+pipeline = "{PIPE}"
+spirula = "{BIN / 'spirula'}"
+splat_transform = "{BIN / 'splat-transform'}"
+recordings = "{REC}"
+runs = "{RUNS}"
+extra_recording_dirs = []
+[server]
+language = "en"
+[frame]
+host = ""
+''')
+os.environ.update(SPLAT_WORKSHOP_CONFIG=str(BASE / "config.toml"), SPLAT_WORKSHOP_STATE=str(STATE), FRAME_HOST="",
+                  PATH=f"{BIN}:{os.environ['PATH']}")
+os.environ.pop("SPLAT_LAN", None)
+
+from splat_workshop import server  # noqa: E402  (after the environment is set up)
+
+
+@pytest.fixture(autouse=True)
+def clean():
+    """Every test starts with empty runs, recordings, state and trash."""
+    yield
+    st = server.load_state().get("job") or {}
+    if server.pid_alive(st.get("pid", 0)):
+        server.cancel_job()
+        wait_job(timeout=20)
+    for d in (RUNS, REC, STATE, TRASH, FRAME_HOME):
+        shutil.rmtree(d, ignore_errors=True)
+        d.mkdir()
+    for cache in (server.usage_cache, server.probe_cache, server.uploads, server.checks):
+        cache.clear()
+    if server.download_busy():
+        server.cancel_download()
+        end = time.time() + 10
+        while server.download_busy() and time.time() < end:
+            time.sleep(0.05)
+    server.download, server.download_queue[:], server.download_batch = None, [], {}
+    for k in ("FAKE_PIPELINE", "FAKE_FRAME_OFF", "FAKE_FRAME_CUT", "FAKE_FRAME_SLOW", "FAKE_FRAME_SHORT", "FAKE_SCP_SLOW",
+              "FRAME_HOST"):
+        os.environ.pop(k, None)
+    os.environ["FRAME_HOST"] = ""
+    TOOL_LOG.unlink(missing_ok=True)
+    server.frame_cache.update(t=0, data=None)
+
+
+SHUTDOWNS = []                             # calls of server.shutdown during the current test
+
+
+@pytest.fixture(autouse=True)
+def never_exit(monkeypatch):
+    """Quitting must never end the test run – a broken guard would otherwise make it stop silently (green)."""
+    SHUTDOWNS.clear()
+    monkeypatch.setattr(server, "shutdown", lambda cancel: SHUTDOWNS.append(cancel))
+
+    def no_exit(code=0):
+        raise RuntimeError(f"os._exit({code}) called during a test")
+    monkeypatch.setattr(server.os, "_exit", no_exit)
+
+
+@pytest.fixture
+def frame(monkeypatch):
+    """A Steam Frame (the fake one: a folder) is configured and reachable. Returns its home directory."""
+    host = "steamos@frame.test"
+    monkeypatch.setattr(server, "FRAME", host)
+    monkeypatch.setattr(server, "SSH", [*server.SSH[:-1], host])
+    os.environ["FRAME_HOST"] = host                  # for the scripts (splat.sh, to-frame.sh)
+    for d in (server.FRAME_VIDEOS + "/thumbnails", server.FRAME_SCENES, server.FRAME_STEAM):
+        (FRAME_HOME / d).mkdir(parents=True, exist_ok=True)
+    return FRAME_HOME
+
+
+def tools_called():
+    """Calls of the fake tools so far, e.g. [["splat-transform", "-w", ...], ...]."""
+    return [json.loads(line) for line in TOOL_LOG.read_text().splitlines()] if TOOL_LOG.exists() else []
+
+
+def wait_for_tool(name, timeout=5):
+    """Calls of one fake tool, waiting a little for ones started in the background (notifications)."""
+    end = time.time() + timeout
+    while time.time() < end:
+        calls = [c for c in tools_called() if c[0] == name]
+        if calls:
+            return calls
+        time.sleep(0.1)
+    return []
+
+
+def recording(name="2026-10-12_16-40-00_stereo.mp4"):
+    p = REC / name
+    p.write_bytes(b"not really a video")
+    return p
+
+
+def wait_job(timeout=120):
+    """Wait until the current job has ended; returns its status."""
+    end = time.time() + timeout
+    while time.time() < end:
+        js = server.job_status(tail=True)
+        if js and not js["running"]:
+            return js
+        time.sleep(0.3)
+    raise TimeoutError("job did not finish")
+
+
+class Client:
+    def __init__(self, port):
+        self.port = port
+
+    def request(self, method, path, body=None, headers=None):
+        c = http.client.HTTPConnection("127.0.0.1", self.port, timeout=30)
+        data = body if isinstance(body, (bytes, type(None))) else json.dumps(body).encode()
+        c.request(method, path, body=data, headers={"Content-Type": "application/json", **(headers or {})})
+        r = c.getresponse()
+        raw = r.read()
+        try:
+            return r.status, json.loads(raw)
+        except ValueError:
+            return r.status, raw
+
+    def get(self, path, headers=None):
+        return self.request("GET", path, headers=headers)
+
+    def post(self, path, body=None, headers=None):
+        return self.request("POST", path, body if body is not None else {}, headers)
+
+
+@pytest.fixture(scope="session")
+def api():
+    srv = server.http.server.ThreadingHTTPServer(("127.0.0.1", 0), server.Handler)
+    srv.daemon_threads = True
+    threading.Thread(target=srv.serve_forever, daemon=True).start()
+    yield Client(srv.server_address[1])
+    srv.shutdown()
+
+
+def pytest_sessionfinish(session, exitstatus):
+    shutil.rmtree(BASE, ignore_errors=True)
@@ -0,0 +1,187 @@
+"""Synthetic rooms in the shape the Arcturus pipeline leaves them, for tests without real recordings.
+
+Two rooms side by side with a door between them (Y points down like in the pipeline):
+
+    z=3 +----------------+----------------+
+        |                |                |
+        |   room A       door   room B    |
+        |   (x 0..4)     |      (x 4..8)  |
+    z=0 +----------------+----------------+
+       x=0              x=4              x=8
+
+Every recording walks around its room; room B starts in room A next to the door and walks in
+(like a real recording that starts in the hallway). Each room gets what the pipeline writes:
+  dataset/main.aiscene            camera poses as tracked by the Frame (the truth, plus `drift`)
+  dataset/sparse/0/images.bin     camera poses of the reconstruction
+  dataset/sparse/0/points3D.bin   sparse points
+  spirula/scene.ply               splats (one per point)
+  scene.sog, scene.xrSceneTransform.json, <slug>.ui.json
+The reconstruction is off by a known small rotation and shift (`error`), as a real one is before
+it is fitted to the Frame's tracking.
+"""
+import base64
+import json
+import struct
+import zlib
+from pathlib import Path
+
+import numpy as np
+from scipy.spatial.transform import Rotation
+
+FLOOR, CEILING = 1.6, -0.9                 # y (down): floor below the cameras, ceiling above
+DOOR = (1.2, 2.0)                          # door between the rooms, z range
+PNG = base64.b64decode("iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNk+M9QDwADhgGAWjR9awAAAABJRU5ErkJggg==")
+PROPS = (["x", "y", "z", "nx", "ny", "nz", "f_dc_0", "f_dc_1", "f_dc_2"] + [f"f_rest_{i}" for i in range(45)]
+         + ["opacity", "scale_0", "scale_1", "scale_2", "rot_0", "rot_1", "rot_2", "rot_3"])
+
+
+def walls(x0, x1, step=0.04):
+    """Points on the walls, floor and ceiling of the room x0..x1 (z 0..3), with a door in the wall at x=4."""
+    pts = []
+    ys = np.arange(CEILING, FLOOR + 1e-9, step)
+    for x in (x0, x1):
+        for z in np.arange(0, 3 + 1e-9, step):
+            if x == 4 and DOOR[0] < z < DOOR[1]:
+                continue
+            pts += [(x, y, z) for y in ys]
+    for z in (0, 3):
+        for x in np.arange(x0, x1 + 1e-9, step):
+            pts += [(x, y, z) for y in ys]
+    for x in np.arange(x0, x1 + 1e-9, step * 2):
+        for z in np.arange(0, 3 + 1e-9, step * 2):
+            pts += [(x, FLOOR, z), (x, CEILING, z)]
+    return np.array(pts)
+
+
+def path(room, walk_in_offset=0.3):
+    """Camera positions over time (y = 0, head height) and the times in seconds."""
+    t = np.linspace(0, 2 * np.pi, 140)
+    if room == "A":
+        # starts at the far wall, passes the door in the middle of the round
+        loop = np.stack([2 + 1.3 * np.cos(t + np.pi), np.zeros_like(t), 1.5 + 0.9 * np.sin(t + np.pi)], 1)
+        return loop, np.linspace(0, 40, len(loop))
+    # starts in room A next to room A's round (like a recording that starts in the hallway), then through
+    # the door. walk_in_offset: how far from room A's own path (towards room A's wall) it starts.
+    tt = np.linspace(-1.0, 0, 18)
+    along_a = np.stack([2 + 1.3 * np.cos(tt), np.zeros_like(tt), 1.5 + 0.9 * np.sin(tt) - walk_in_offset], 1)
+    walk_in = np.vstack([along_a, np.stack([np.linspace(3.35, 4.6, 12), np.zeros(12), np.full(12, 1.6)], 1)])
+    loop = np.stack([6 + 1.3 * np.cos(t + np.pi), np.zeros_like(t), 1.5 + 0.9 * np.sin(t + np.pi)], 1)
+    pos = np.vstack([walk_in, loop])
+    return pos, np.linspace(0, 45, len(pos))
+
+
+def look_at(c, target):
+    """cam_from_world rotation for a camera at c looking at target (x right, y down, z forward)."""
+    z = target - c
+    z[1] = 0
+    z /= np.linalg.norm(z)
+    y = np.array([0.0, 1.0, 0.0])
+    x = np.cross(y, z)
+    return np.stack([x, y, z])
+
+
+def write_images(path_, names, R_list, C_list):
+    with open(path_, "wb") as f:
+        f.write(struct.pack("<Q", len(names)))
+        for i, (name, R, C) in enumerate(zip(names, R_list, C_list)):
+            qx, qy, qz, qw = Rotation.from_matrix(R).as_quat()
+            t = -R @ C
+            f.write(struct.pack("<i7di", i + 1, qw, qx, qy, qz, *t, 1))
+            f.write(name.encode() + b"\0")
+            f.write(struct.pack("<Q", 0))
+
+
+def write_points(path_, pts):
+    with open(path_, "wb") as f:
+        f.write(struct.pack("<Q", len(pts)))
+        for i, p in enumerate(pts):
+            f.write(struct.pack("<Q3d3BdQ", i + 1, *p, 128, 128, 128, 0.5, 0))
+
+
+def write_ply(path_, pts, colours, rotation=(1.0, 0.0, 0.0, 0.0), scale=0.02):
+    """One splat per point; all with the same rotation (w, x, y, z) and size (metres)."""
+    data = np.zeros(len(pts), dtype=np.dtype([(p, "<f4") for p in PROPS]))
+    data["x"], data["y"], data["z"] = pts.T
+    for k in range(3):
+        data[f"f_dc_{k}"] = (colours[:, k] - 0.5) / 0.28209479177387814
+    data["opacity"] = 3.0
+    for k in range(3):
+        data[f"scale_{k}"] = np.log(scale)
+    for k in range(4):
+        data[f"rot_{k}"] = rotation[k]
+    header = "ply\nformat binary_little_endian 1.0\nelement vertex %d\n%send_header\n" % (
+        len(pts), "".join(f"property float {p}\n" for p in PROPS))
+    with open(path_, "wb") as f:
+        f.write(header.encode())
+        data.tofile(f)
+
+
+MARKERS = (((1, 0, 0), (0.0, 0.5, 0.0)), ((0, 1, 0), (2.0, 0.5, 0.0)), ((0, 0, 1), (0.0, 0.5, 2.0)))
+SPLAT_TURN = Rotation.from_euler("x", 20, degrees=True)     # how every splat is turned in the real world
+SPLAT_SIZE = 0.02                                            # metres
+
+
+def make_room(runs: Path, slug: str, room: str, error=(1.0, (0.03, 0.0, -0.02)), scale=1.0,
+              drift=(0.0, 0.0, 0.0), turn=0.0, noise=0.005, walk_in_offset=0.3,
+              name=None, recording=None, markers=(), colour=None):
+    """Write one synthetic room into runs/<slug>. Returns the run folder.
+
+    The reconstruction differs from the real world by `error` = (yaw in degrees, shift in m) and `scale`.
+    The Frame's tracking of this recording is off by `drift` (m) and turned by `turn` (degrees, about the
+    room's middle), plus `noise` (m) per pose. markers: True for red/green/blue at the corner, along +x and
+    along +z, or a list of ((r, g, b), (x, y, z)) – blobs of 400 splats at real-world positions.
+    runs/<slug>/synth.json records how many splats are the room's own (of these, how many on the wall it
+    shares with the other room – zero thickness, so it belongs to both) and how many were seen through the door."""
+    rng = np.random.default_rng(zlib.crc32(slug.encode()))
+    run = runs / slug
+    sparse = run / "dataset" / "sparse" / "0"
+    sparse.mkdir(parents=True, exist_ok=True)
+    (run / "spirula").mkdir(exist_ok=True)
+    x0, x1 = (0.0, 4.0) if room == "A" else (4.0, 8.0)
+    pts = walls(x0, x1)
+    # every recording its own colour, so the origin of a splat can be seen after putting rooms together
+    colours = np.tile(colour or ((0.8, 0.3, 0.3) if room == "A" else (0.3, 0.3, 0.8)), (len(pts), 1))
+    for c, at in (MARKERS if markers is True else markers):
+        blob = np.array(at) + rng.normal(0, 0.05, (400, 3))
+        pts, colours = np.vstack([pts, blob]), np.vstack([colours, np.tile(c, (400, 1))])
+    own = len(pts)
+    shared = int((np.abs(pts[:, 0] - 4) < 1e-9).sum())          # the wall between the rooms belongs to both
+    # seen through the door: a little of the neighbouring room close to the door
+    other = walls(4.0, 8.0) if room == "A" else walls(0.0, 4.0)
+    near_door = other[(np.abs(other[:, 0] - 4) < 1.0) & (other[:, 2] > 0.6) & (other[:, 2] < 2.6)]
+    pts = np.vstack([pts, near_door])
+    colours = np.vstack([colours, np.tile(colours[0], (len(near_door), 1))])
+
+    pos, times = path(room, walk_in_offset)
+    centre = np.array([(x0 + x1) / 2, 0.0, 1.5])
+    yaw, shift = error
+    E = Rotation.from_euler("y", yaw, degrees=True)                 # world -> reconstruction
+    to_sfm = lambda p: scale * E.apply(p) + np.array(shift)
+    T = Rotation.from_euler("y", turn, degrees=True)                # the tracking's own turn
+    names, Rs, Cs, frames = [], [], [], []
+    for k, (c, t) in enumerate(zip(pos, times)):
+        R_world = look_at(c.copy(), centre)
+        image = f"cam0/{k:04d}-{t:.6f}.jpg"
+        names.append(image)
+        Rs.append(R_world @ E.as_matrix().T)
+        Cs.append(to_sfm(c))
+        world_from_cam = np.eye(4)
+        world_from_cam[:3, :3] = T.as_matrix() @ R_world.T
+        world_from_cam[:3, 3] = T.apply(c - centre) + centre + np.array(drift) + rng.normal(0, noise, 3)
+        frames.append({"cam": 0, "path": "images/" + image, "worldFromCam": world_from_cam.tolist(),
+                       "playbackTimestampSec": float(t)})
+    write_images(sparse / "images.bin", names, Rs, Cs)
+    write_points(sparse / "points3D.bin", to_sfm(pts))
+    q = (E * SPLAT_TURN).as_quat()                                   # (x, y, z, w) in the reconstruction
+    write_ply(run / "spirula" / "scene.ply", to_sfm(pts), colours, (q[3], q[0], q[1], q[2]), SPLAT_SIZE * scale)
+    (run / "dataset" / "main.aiscene").write_text(json.dumps({"format": "synthetic", "cameras": [], "frames": frames}))
+    (run / "scene.sog").write_bytes(b"synthetic")
+    (run / "scene.xrSceneTransform.json").write_text(json.dumps({"transform": np.eye(4).tolist(), "worldScale": 1.0}))
+    (run / f"{slug.lower()}.gallery.png").write_bytes(PNG)
+    (run / "synth.json").write_text(json.dumps({"own": own, "shared_wall": shared, "seen_through_door": len(near_door),
+                                                 "splats": len(pts)}))
+    (runs / f"{slug}.log").write_text(f"spirula: {len(pts):,} Gaussians in {run}/spirula/scene.ply\n")
+    meta = {"name": name or slug, "recording": recording or f"2026-10-12_16-{40 + (room == 'B') * 3:02d}-00_stereo.mp4",
+            "quality": "high"}
+    (runs / f"{slug}.ui.json").write_text(json.dumps(meta))
+    return run
@@ -0,0 +1,103 @@
+"""The recording check's rating (splat_workshop/check.py): per-second measurements in, findings out.
+
+Rows are made by hand with values clearly on one side of each limit, so the tests say what a user
+gets for a recording that is, say, 50 % dark – not what the code happens to compute."""
+import pytest
+
+from splat_workshop import check
+
+GOOD = {"bright": 120, "detail": 7.0, "motion": 10.0, "over": 0.0, "cast": 5, "rgb": (120, 120, 120),
+        "right": {"bright": 120, "detail": 7.0}}
+
+
+def rows(n=60, **changes_by_second):
+    """n good seconds; changes_by_second: {"dark": range(...), ...} turns those seconds bad in one way."""
+    out = [dict(GOOD, right=dict(GOOD["right"])) for _ in range(n)]
+    for kind, secs in changes_by_second.items():
+        for i in secs:
+            r = out[i]
+            if kind == "dark":
+                r["bright"] = r["right"]["bright"] = 20
+            elif kind == "flat":
+                r["detail"] = r["right"]["detail"] = 1.0
+            elif kind == "fast":
+                r["motion"] = 80.0
+            elif kind == "over":
+                r["over"] = 0.2
+            elif kind == "eye":                       # one lens covered
+                r["right"] = {"bright": 30, "detail": 0.5}
+    return out
+
+
+def findings(res):
+    return {f["code"]: f["level"] for f in res["findings"]}
+
+
+def test_a_good_recording():
+    res = check.evaluate(rows(), 60)
+    assert res["level"] == "ok" and res["findings"] == [] and set(res["timeline"]) == {"ok"}
+    assert res["summary"] == {"bright": 120, "detail": 7.0, "seconds": 60}
+
+
+def test_nothing_measured():
+    assert check.evaluate([], 0)["level"] == "bad"
+
+
+def test_too_dark_overall():
+    dark = [dict(r, bright=20, right={"bright": 20, "detail": 7.0}) for r in rows()]    # both lenses
+    assert findings(check.evaluate(dark, 60)) == {"too_dark": "bad"}
+
+
+@pytest.mark.parametrize("secs,level", [(range(0, 30), "bad"),      # half the recording dark
+                                         (range(0, 24), "warn"),     # 40 %: not more than 40 %
+                                         (range(0, 3), "warn")])
+def test_dark_stretches(secs, level):
+    res = check.evaluate(rows(dark=secs), 60)
+    assert findings(res)["dark"] == level
+    f = next(f for f in res["findings"] if f["code"] == "dark")
+    assert f["secs"] == len(secs) and f["spans"] == [(secs[0], secs[-1])]
+    assert res["timeline"][secs[0]] == "dark"
+
+
+@pytest.mark.parametrize("secs,level", [(range(10, 40), "bad"), (range(10, 15), "warn"), (range(10, 13), "info")])
+def test_plain_surfaces(secs, level):
+    # 30 s = 50 %: bad; 5 s = 8 %: warn; 3 s = 5 %: only a note
+    assert findings(check.evaluate(rows(flat=secs), 60))["flat"] == level
+
+
+def test_a_single_plain_second_is_not_worth_a_finding():
+    assert "flat" not in findings(check.evaluate(rows(flat=[10]), 60))
+
+
+@pytest.mark.parametrize("secs,level", [(range(0, 12), "warn"), (range(0, 5), "info")])
+def test_fast_pans(secs, level):
+    assert findings(check.evaluate(rows(fast=secs), 60))["fast"] == level
+
+
+def test_a_covered_lens_needs_three_seconds():
+    assert findings(check.evaluate(rows(eye=range(5, 8)), 60))["cameras_differ"] == "warn"
+    assert "cameras_differ" not in findings(check.evaluate(rows(eye=range(5, 7)), 60))
+
+
+def test_overexposure_and_colour_cast_are_notes_only():
+    tinted = [dict(r, cast=30, rgb=(160, 140, 80)) for r in rows(over=range(0, 5))]
+    res = check.evaluate(tinted, 60)
+    assert findings(res) == {"overexposed": "info", "color_cast": "info"}
+    assert res["level"] == "ok"
+    assert next(f for f in res["findings"] if f["code"] == "color_cast")["tone"] == "yellow"
+
+
+@pytest.mark.parametrize("duration,code,level", [(15, "short", "warn"), (200, "long", "info")])
+def test_length(duration, code, level):
+    assert findings(check.evaluate(rows(), duration))[code] == level
+
+
+def test_the_worst_finding_decides():
+    res = check.evaluate(rows(dark=range(0, 30), fast=range(40, 45)), 60)
+    assert res["level"] == "bad"
+    assert res["timeline"][0] == "dark" and res["timeline"][42] == "fast" and res["timeline"][50] == "ok"
+
+
+def test_spans():
+    assert check._spans([False, True, True, False, True]) == [(1, 2), (4, 4)]
+    assert check._spans([True, False, True, True], min_len=2) == [(2, 3)]
@@ -0,0 +1,189 @@
+"""Putting rooms together (scripts/combine.py, scripts/combine.sh) on synthetic rooms with a known error.
+
+The expectations come from how the synthetic rooms were built (tests/synth.py), not from the code:
+each reconstruction is turned, shifted and scaled by a known amount, the Frame's tracking has 5 mm
+noise and optionally a drift or a turn of its own."""
+import json
+import os
+import subprocess
+import sys
+
+import numpy as np
+import pytest
+from scipy.spatial.transform import Rotation
+
+from conftest import BASE, ROOT, RUNS, tools_called
+import synth
+
+COMBINE = ROOT / "scripts" / "combine.py"
+DRIFT_B = 0.03                            # metres: the Frame's tracking of room B is off by this much
+
+
+def two_rooms(drift_b=DRIFT_B, turn_b=0.0, b_far=False, walk_in_offset=0.3, scale_a=1.0, markers_b=()):
+    a = synth.make_room(RUNS, "A", "A", error=(1.0, (0.03, 0.0, -0.02)), scale=scale_a,
+                        markers=[((0, 1, 0), (1.0, 0.5, 0.3)), ((0, 1, 1), (1.0, 0.5, 2.7))])
+    b = synth.make_room(RUNS, "B", "B", error=(-0.8, (-0.02, 0.01, 0.03)), turn=turn_b,
+                        drift=(20.0 if b_far else drift_b, 0.0, 0.0), walk_in_offset=walk_in_offset,
+                        markers=markers_b)
+    return a, b
+
+
+def combine(*runs, align="images", partition="view"):
+    out = BASE / f"out-{align}-{partition}"
+    r = subprocess.run([sys.executable, str(COMBINE), str(out), *[f"{p}={p.name}" for p in runs],
+                        "--align", align, "--partition", partition], capture_output=True, text=True)
+    assert r.returncode == 0 or "@@ error" in r.stdout, r.stderr
+    return out, r
+
+
+def result(out):
+    return json.loads((out / "combine.json").read_text())
+
+
+def read_ply(path):
+    with open(path, "rb") as f:
+        header = b""
+        while not header.endswith(b"end_header\n"):
+            header += f.readline()
+        props = [l.split()[-1].decode() for l in header.splitlines() if l.startswith(b"property")]
+        n = int(next(l for l in header.splitlines() if l.startswith(b"element vertex")).split()[-1])
+        return np.fromfile(f, dtype=np.dtype([(p, "<f4") for p in props]), count=n)
+
+
+def blob(v, rgb):
+    """Centre of the marker splats of one colour (markers are pure colours, rooms are not)."""
+    c = 0.5 + 0.28209479177387814 * np.stack([v["f_dc_0"], v["f_dc_1"], v["f_dc_2"]], 1)
+    m = np.all(np.abs(c - np.array(rgb)) < 0.02, axis=1)
+    assert m.sum() >= 300, f"marker {rgb} not found"
+    return np.stack([v["x"], v["y"], v["z"]], 1)[m].mean(0)
+
+
+@pytest.mark.parametrize("align,lo,hi", [
+    ("frame", 5.0, 12.0),                 # as delivered: both reconstructions' errors add up
+    ("images", 2.0, 4.0),                 # rooms fitted, but room B's tracking drift (3 cm) is left
+    ("shift", 0.0, 1.0),                  # shifting the rooms over the door removes the drift
+    ("rigid", 0.0, 1.0),
+])
+def test_corrections_take_out_the_known_error(align, lo, hi):
+    out, r = combine(*two_rooms(), align=align)
+    seam = result(out)["seams"]["A|B"]["cm"]
+    assert lo <= seam <= hi, f"{align}: overlap off by {seam} cm"
+
+
+def test_every_room_is_fitted_to_the_frames_tracking():
+    out, r = combine(*two_rooms(drift_b=0.0, scale_a=1.03))
+    for room in result(out)["rooms"].values():
+        assert room["tracking_cm"] > 3              # off before: turned, shifted (and room A 3 % too big)
+        assert room["fitted_cm"] < 1.5              # fitted over all images: down to the 5 mm tracking noise
+
+
+def test_splats_get_the_rotation_and_size_they_have_in_reality():
+    """Room A's reconstruction is 3 % too big and turned by 1°; afterwards every splat must have its
+    real-world orientation (20° about x) and size (2 cm) again – with the right sign."""
+    out, r = combine(*two_rooms(drift_b=0.0, scale_a=1.03))
+    v = read_ply(out / "spirula" / "scene.ply")
+    q = np.stack([v["rot_1"], v["rot_2"], v["rot_3"], v["rot_0"]], 1).astype(np.float64)
+    off = (Rotation.from_quat(q) * synth.SPLAT_TURN.inv()).magnitude()
+    assert np.degrees(off).max() < 0.3, "splats are turned the wrong way"
+    size = np.exp(np.stack([v["scale_0"], v["scale_1"], v["scale_2"]], 1).astype(np.float64))
+    assert np.allclose(size, synth.SPLAT_SIZE, rtol=0.01), "splats have the wrong size"
+    # and the room itself has its real size: the two markers in room A are 2.4 m apart
+    assert abs(np.linalg.norm(blob(v, (0, 1, 1)) - blob(v, (0, 1, 0))) - 2.4) < 0.02
+
+
+def test_shift_and_turn_also_takes_out_a_turned_tracking():
+    """Room B's tracking is turned by 2° about the room's middle: shifting (C) cannot repair that,
+    shifting and turning (D) can reduce it. Measured independently of the alignment: the distances from
+    the markers in room A to a marker in the far corner of room B (rigid motions keep distances).
+    Known limit: the turn can only be read from the overlap at the door, so D does not take it out
+    completely (here about 2 cm are left of about 6 cm)."""
+    far_b = ((1, 0, 1), (7.5, 0.5, 2.7))
+    truth = [np.linalg.norm(np.array(far_b[1]) - np.array(p)) for p in ((1.0, 0.5, 0.3), (1.0, 0.5, 2.7))]
+
+    def error(align):
+        out, r = combine(*two_rooms(drift_b=0.0, turn_b=2.0, markers_b=[far_b]), align=align)
+        v = read_ply(out / "spirula" / "scene.ply")
+        got = [np.linalg.norm(blob(v, far_b[0]) - blob(v, c)) for c in ((0, 1, 0), (0, 1, 1))]
+        return max(abs(g - t) for g, t in zip(got, truth)) * 100
+
+    shift, rigid = error("shift"), error("rigid")
+    assert shift > 3, f"the test needs a turn that shifting cannot repair ({shift:.1f} cm)"
+    assert rigid < shift / 2, f"shift {shift:.1f} cm, shift and turn {rigid:.1f} cm"
+
+
+def test_every_splat_is_written_once():
+    a, b = two_rooms()
+    out, r = combine(a, b)
+    info, v = result(out), read_ply(out / "spirula" / "scene.ply")
+    assert len(v) == info["splats"]
+    for run in (a, b):
+        made = json.loads((run / "synth.json").read_text())
+        room = info["rooms"][run.name]
+        assert room["splats"] == made["splats"]            # read completely
+        # a room keeps its own splats (the shared wall may go either way); of what it saw of the neighbour
+        # through the door it keeps at most the part right behind the door, where its own cameras were closer
+        assert 0.95 * (made["own"] - made["shared_wall"]) <= room["kept"] <= made["own"] + made["seen_through_door"]
+    # each place once: together the rooms keep no more than they are made of
+    total_own = sum(json.loads((run / "synth.json").read_text())["own"] for run in (a, b))
+    assert len(v) <= total_own
+
+
+@pytest.mark.parametrize("offset", [0.1, 0.3])
+def test_borders_run_through_the_door(offset):
+    """Room B starts its recording in room A (walking in). With borders 'through doors' that stretch
+    claims nothing, so room A comes from room A's own recording; 'nearest camera' cuts into room A."""
+    def from_b_in_room_a(partition):
+        out, r = combine(*two_rooms(drift_b=0.0, walk_in_offset=offset), partition=partition)
+        v = read_ply(out / "spirula" / "scene.ply")
+        inside_a = (v["x"] > 0.2) & (v["x"] < 3.6)
+        c = 0.5 + 0.28209479177387814 * np.stack([v["f_dc_0"], v["f_dc_1"], v["f_dc_2"]], 1)
+        from_b = np.all(np.abs(c - (0.3, 0.3, 0.8)) < 0.02, axis=1)        # room B's own colour
+        return int((inside_a & from_b).sum()), result(out)["rooms"]["B"]["walk_in_out_cameras"]
+    view, walk_in = from_b_in_room_a("view")
+    assert walk_in > 10                                    # recognised as walking in
+    assert view < 50                                       # practically nothing of room B inside room A
+    if offset >= 0.3:                                      # close to the round, room A's cameras win anyway
+        nearest, _ = from_b_in_room_a("nearest")
+        assert nearest > 10 * max(view, 5)
+
+
+@pytest.mark.xfail(strict=True, reason="known limit: walking in is only recognised up to 0.4 m from the other "
+                                       "recording's round; further away the walk-in stretch claims room A's wall")
+def test_borders_with_a_walk_in_far_from_the_other_round():
+    out, r = combine(*two_rooms(drift_b=0.0, walk_in_offset=0.6))
+    assert result(out)["rooms"]["B"]["walk_in_out_cameras"] > 10
+
+
+def test_rooms_from_different_sessions_are_refused():
+    out, r = combine(*two_rooms(b_far=True))
+    assert r.returncode != 0
+    assert "@@ error not_connected" in r.stdout
+
+
+def run_combine_sh(env, *runs):
+    return subprocess.run([str(ROOT / "scripts" / "combine.sh"), "Tour", "Tour", *[f"{p}={p.name}" for p in runs]],
+                          env={**os.environ, "NO_UPLOAD": "1", **env}, capture_output=True, text=True)
+
+
+def test_combine_sh_reduces_for_the_frame_and_can_skip_the_full_version():
+    a, b = two_rooms()
+    r = run_combine_sh({"FRAME_SPLATS": "10000", "FULL": "0"}, a, b)
+    assert r.returncode == 0, r.stdout[-2000:] + r.stderr[-2000:]
+    calls = [c[1:] for c in tools_called() if c[0] == "splat-transform"]
+    tmp = str(RUNS / ".building" / "Tour")
+    assert calls[0] == ["-w", f"{tmp}/spirula/scene.ply", "--decimate", "10000", f"{tmp}/frame.ply"]
+    assert calls[1] == ["-w", f"{tmp}/frame.ply", f"{tmp}/scene.sog"]
+    assert len(calls) == 2                                 # no full version
+    tour = RUNS / "Tour"
+    assert (tour / "scene.sog").exists() and not (tour / "full").exists() and not (tour / "frame.ply").exists()
+    assert not (RUNS / ".building").exists()
+
+
+def test_combine_sh_full_version_without_reducing_a_small_tour():
+    a, b = two_rooms()
+    r = run_combine_sh({"FRAME_SPLATS": "3500000"}, a, b)
+    assert r.returncode == 0, r.stdout[-2000:] + r.stderr[-2000:]
+    calls = [c[1:] for c in tools_called() if c[0] == "splat-transform"]
+    assert not any("--decimate" in c for c in calls)        # fewer splats than the Frame version allows
+    assert (RUNS / "Tour" / "full" / "tour-full.sog").exists()
+    assert (RUNS / "Tour" / "full" / "tour-full.sceneinfo.png").exists()
@@ -0,0 +1,47 @@
+"""The floor plan is a top view, not its mirror image (scripts/floorplan.py).
+
+A plan may be turned (so the walls are straight), but never mirrored. Three coloured markers tell
+the two apart: red at the corner, green along +x, blue along +z. Turning keeps the sense of
+red -> green -> blue, mirroring reverses it. Seen from above with the y axis pointing down
+(like the pipeline's frame), +x to +z turns counter-clockwise on screen.
+"""
+import subprocess
+import sys
+
+import numpy as np
+from PIL import Image
+
+from conftest import BASE, ROOT
+import synth
+
+
+def draw(style):
+    runs = BASE / f"plan-{style}"
+    synth.make_room(runs, "Room", "A", error=(0.0, (0, 0, 0)), markers=True)
+    out = runs / "plan.png"
+    r = subprocess.run([sys.executable, str(ROOT / "scripts" / "floorplan.py"), str(out), f"{runs / 'Room'}=Room",
+                        "--style", style], capture_output=True, text=True)
+    assert r.returncode == 0, r.stderr
+    return np.asarray(Image.open(out).convert("RGB")).astype(int)
+
+
+def test_floor_plan_is_not_mirrored():
+    img = draw("pretty")                   # the pretty style shows the splats' own colours
+    rr, gg, bb = img[..., 0], img[..., 1], img[..., 2]
+
+    def centre(mask):
+        ys, xs = np.nonzero(mask)
+        assert len(xs) > 50, "marker not found"
+        return np.array([xs.mean(), ys.mean()])
+    red = centre((rr > 150) & (gg < 90) & (bb < 90))
+    green = centre((gg > 150) & (rr < 90) & (bb < 90))
+    blue = centre((bb > 150) & (rr < 90) & (gg < 90))
+    gx, gz = green - red, blue - red                 # screen directions of +x and +z (rows count downwards)
+    cross = gx[0] * gz[1] - gx[1] * gz[0]
+    assert cross < 0, "the floor plan is mirrored"
+
+
+def test_classic_style_smoke():
+    """Smoke test: the classic style draws something (its colours are per room, not checkable here)."""
+    img = draw("classic")
+    assert img.shape[0] > 500 and img.std() > 5    # not an empty picture
@@ -0,0 +1,132 @@
+"""The "On the Frame" tab: everything in Gaussian XR's gallery, what it is, and taking it off the Frame."""
+import json
+import time
+
+from conftest import RUNS, server
+import synth
+
+
+def upload(api, slug, version=""):
+    body = {"slug": slug, **({"version": version} if version else {})}
+    assert api.post("/api/upload", body)[0] == 200
+    key = f"{slug}#{version}" if version else slug
+    end = time.time() + 60
+    while (u := server.upload_status(key)) and u["running"] and time.time() < end:
+        time.sleep(0.2)
+    assert server.upload_status(key)["ok"]
+
+
+def example(frame, name="04_BurtLakeHouse"):
+    d = frame / server.FRAME_STEAM / name                           # Gaussian XR's own gallery folder
+    d.mkdir()
+    (d / "trained-572k.htgs.gallery.png").write_bytes(b"example preview")
+    (d / "trained-572k.htgs.ply").write_bytes(b"x" * 5000)
+    return d
+
+
+def test_the_gallery_on_the_frame(api, frame):
+    synth.make_room(RUNS, "Kitchen", "A", name="Kitchen")
+    upload(api, "Kitchen")
+    assert server.start_versions({"slug": "Kitchen", "sizes": "10000"}) is None
+    from conftest import wait_job
+    wait_job()
+    upload(api, "Kitchen", "0.01m")
+    example(frame)
+    (frame / server.FRAME_STEAM / "common_audio").mkdir()           # not a scene: no preview image
+    status, r = api.get("/api/frame/gallery?refresh=1")
+    assert status == 200 and r["online"]
+    by = {x["folder"]: x for x in r["scenes"]}
+    assert set(by) == {"04_BurtLakeHouse", "20_Kitchen", "21_Kitchen-0.01m"}
+    assert (by["20_Kitchen"]["kind"], by["20_Kitchen"]["name"], by["20_Kitchen"]["slug"]) == ("scene", "Kitchen", "Kitchen")
+    assert (by["21_Kitchen-0.01m"]["kind"], by["21_Kitchen-0.01m"]["version"]) == ("version", "0.01m")
+    assert (by["04_BurtLakeHouse"]["kind"], by["04_BurtLakeHouse"]["name"]) == ("other", "BurtLakeHouse")
+    assert by["04_BurtLakeHouse"]["size"] >= 5000
+    assert (by["04_BurtLakeHouse"]["place"], by["20_Kitchen"]["place"]) == ("steam", "own")
+    status, png = api.get("/api/frame/preview?folder=04_BurtLakeHouse")
+    assert status == 200 and png == b"example preview"
+    assert api.get("/api/frame/preview?folder=../../.ssh")[0] == 404
+
+
+def test_taking_a_scene_off_the_frame_and_copying_it_again(api, frame):
+    synth.make_room(RUNS, "Kitchen", "A", name="Kitchen")
+    upload(api, "Kitchen")
+    assert api.post("/api/frame/remove", {"folder": "20_Kitchen"})[0] == 200
+    assert not (frame / server.FRAME_SCENES / "20_Kitchen").exists()
+    assert (RUNS / "Kitchen" / "scene.sog").exists()                    # the PC is not touched
+    assert json.loads((RUNS / "Kitchen.ui.json").read_text()).get("frame_folder") is None
+    upload(api, "Kitchen")                                              # copying again works
+    assert (frame / server.FRAME_SCENES / "20_Kitchen" / "kitchen.sog").exists()
+
+
+def test_an_example_scene_can_be_deleted_too(api, frame):
+    d = example(frame)
+    assert api.post("/api/frame/remove", {"folder": "04_BurtLakeHouse"})[0] == 200
+    assert not d.exists()
+
+
+def test_only_scenes_of_the_gallery_can_be_removed(api, frame):
+    (frame / server.FRAME_STEAM / "common_audio").mkdir()
+    (frame / "Videos" / "keep.txt").write_text("x")
+    for folder in ("common_audio", "..", "../..", "../../Videos", "nope"):
+        status, r = api.post("/api/frame/remove", {"folder": folder})
+        assert status == 400, folder
+    assert (frame / server.FRAME_STEAM / "common_audio").exists() and (frame / "Videos" / "keep.txt").exists()
+
+
+def old_copy(frame, folder, stem, content=b"old"):
+    """A scene copied by Splat Workshop 0.2.3 or older: in Gaussian XR's own gallery folder."""
+    d = frame / server.FRAME_STEAM / folder
+    d.mkdir()
+    for ext in ("sog", "xrSceneTransform.json", "sceneinfo.png"):
+        (d / f"{stem}.{ext}").write_bytes(content)
+    (d / f"{stem}.gallery.png").write_bytes(b"preview")
+    return d
+
+
+def test_scenes_go_to_the_personal_folder_and_numbers_count_both(api, frame):
+    old_copy(frame, "20_Other", "other")                            # e.g. a scene of someone else
+    synth.make_room(RUNS, "Kitchen", "A", name="Kitchen")
+    upload(api, "Kitchen")
+    assert sorted(p.name for p in (frame / server.FRAME_SCENES).iterdir()) == ["21_Kitchen"]
+    assert (frame / server.FRAME_STEAM / "20_Other").exists()
+
+
+def test_copying_again_moves_an_old_copy_over(api, frame):
+    old = old_copy(frame, "22_Kitchen", "kitchen")
+    synth.make_room(RUNS, "Kitchen", "A", name="Kitchen")
+    upload(api, "Kitchen")
+    assert not old.exists()
+    new = frame / server.FRAME_SCENES / "22_Kitchen"
+    assert (new / "kitchen.sog").read_bytes() != b"old"
+    assert json.loads((RUNS / "Kitchen.ui.json").read_text())["frame_folder"] == "22_Kitchen"
+
+
+def test_moving_the_old_copies_to_the_personal_folder(api, frame):
+    synth.make_room(RUNS, "Kitchen", "A", name="Kitchen")
+    synth.make_room(RUNS, "Hallway", "B", name="Hallway")
+    old_copy(frame, "20_Kitchen", "kitchen")
+    old_copy(frame, "21_Hallway", "hallway")
+    example(frame)
+    newer = frame / server.FRAME_SCENES / "21_Hallway"               # already copied again: the newer one stays
+    newer.mkdir(parents=True)
+    (newer / "hallway.sog").write_bytes(b"new")
+    (newer / "hallway.gallery.png").write_bytes(b"preview")
+    assert api.post("/api/frame/move", {})[0] == 200
+    assert sorted(p.name for p in (frame / server.FRAME_STEAM).iterdir()) == ["04_BurtLakeHouse"]   # the example stays
+    assert sorted(p.name for p in (frame / server.FRAME_SCENES).iterdir()) == ["20_Kitchen", "21_Hallway"]
+    assert (frame / server.FRAME_SCENES / "20_Kitchen" / "kitchen.sog").read_bytes() == b"old"
+    assert (newer / "hallway.sog").read_bytes() == b"new"
+    kinds = {(x["folder"], x["place"]) for x in api.get("/api/frame/gallery?refresh=1")[1]["scenes"]}
+    assert kinds == {("04_BurtLakeHouse", "steam"), ("20_Kitchen", "own"), ("21_Hallway", "own")}
+    assert {s["slug"]: s["on_frame"] for s in server.scenes()} == {"Kitchen": True, "Hallway": True}
+
+
+def test_the_same_folder_in_both_places(api, frame):
+    old_copy(frame, "20_Kitchen", "kitchen")
+    d = frame / server.FRAME_SCENES / "20_Kitchen"
+    d.mkdir()
+    (d / "kitchen.gallery.png").write_bytes(b"own preview")
+    assert api.get("/api/frame/preview?folder=20_Kitchen&place=own") == (200, b"own preview")
+    assert api.post("/api/frame/remove", {"folder": "20_Kitchen", "place": "steam"})[0] == 200
+    assert d.exists() and not (frame / server.FRAME_STEAM / "20_Kitchen").exists()
+    assert api.post("/api/frame/remove", {"folder": "20_Kitchen", "place": "nowhere"})[0] == 400
@@ -0,0 +1,80 @@
+"""Groups of scenes: one group per scene, suggestions, renaming, cleaning up together."""
+import json
+
+from conftest import RUNS, server
+import synth
+
+
+def make_flat():
+    synth.make_room(RUNS, "Kitchen", "A", name="Kitchen", recording="2026-10-12_16-40-00_stereo.mp4")
+    synth.make_room(RUNS, "Hallway", "B", name="Hallway", recording="2026-10-12_16-43-00_stereo.mp4")
+    synth.make_room(RUNS, "Statue", "A", name="Statue", recording="2026-10-03_19-00-00_stereo.mp4")
+
+
+def test_rooms_recorded_one_after_another_are_suggested(api):
+    make_flat()
+    # 25 minutes after the hallway: more than the 20 minutes that still count as one session
+    synth.make_room(RUNS, "Garden", "A", name="Garden", recording="2026-10-12_17-08-00_stereo.mp4")
+    status, r = api.get("/api/groups")
+    assert status == 200 and r["groups"] == []
+    assert sorted(r["suggestion"]["members"]) == ["Hallway", "Kitchen"]     # not the statue from another day
+    assert r["suggestion"]["date"] == "2026-10-12"
+    assert api.post("/api/group/dismiss", {"key": r["suggestion"]["key"]})[0] == 200
+    assert api.get("/api/groups")[1]["suggestion"] is None
+
+
+def test_a_group_with_its_scenes(api):
+    make_flat()
+    status, r = api.post("/api/group", {"name": "Example home", "members": "Kitchen,Hallway"})
+    assert status == 200 and r["slug"] == "Example-home"
+    g = api.get("/api/groups")[1]["groups"][0]
+    assert (g["name"], g["members"], g["result"]) == ("Example home", ["Kitchen", "Hallway"], None)
+    assert "Example-home" not in {s["slug"] for s in api.get("/api/scenes")[1]}   # a group is not a scene
+    assert "Example-home" not in {u["slug"] for u in api.get("/api/unfinished")[1]}
+
+
+def test_a_scene_can_only_be_in_one_group(api):
+    make_flat()
+    api.post("/api/group", {"name": "Home", "members": "Kitchen,Hallway"})
+    status, r = api.post("/api/group", {"name": "Other", "members": "Kitchen,Statue"})
+    assert status == 400 and r["error"]["code"] == "err.in_other_group"
+    assert api.post("/api/group", {"name": "Empty", "members": ""})[0] == 400
+    assert api.post("/api/group", {"name": "Ghost", "members": "Nope"})[0] == 400
+
+
+def test_renaming_and_changing_a_group(api):
+    make_flat()
+    api.post("/api/group", {"name": "Home", "members": "Kitchen,Hallway"})
+    status, r = api.post("/api/group", {"slug": "Home", "name": "Old flat", "members": "Kitchen"})
+    assert status == 200 and r["slug"] == "Old-flat"
+    assert not (RUNS / "Home.ui.json").exists()
+    g = api.get("/api/groups")[1]["groups"][0]
+    assert (g["slug"], g["name"], g["members"]) == ("Old-flat", "Old flat", ["Kitchen"])
+
+
+def test_renamed_and_deleted_scenes_follow_their_group(api):
+    make_flat()
+    api.post("/api/group", {"name": "Home", "members": "Kitchen,Hallway"})
+    api.post("/api/rename", {"slug": "Kitchen", "new": "Küche"})
+    assert json.loads((RUNS / "Home.ui.json").read_text())["members"] == ["Kueche", "Hallway"]
+    api.post("/api/delete", {"slug": "Hallway"})
+    assert json.loads((RUNS / "Home.ui.json").read_text())["members"] == ["Kueche"]
+
+
+def test_cleaning_up_a_group_cleans_only_its_scenes(api):
+    make_flat()
+    for slug in ("Kitchen", "Hallway", "Statue"):
+        (RUNS / slug / "spirula" / "training").mkdir(parents=True)
+        (RUNS / slug / "spirula" / "training" / "x").write_bytes(b"x" * 1000)
+    api.post("/api/group", {"name": "Home", "members": "Kitchen,Hallway"})
+    assert api.post("/api/clean", {"slug": "Home", "what": "temp"})[0] == 200
+    assert not (RUNS / "Kitchen/spirula/training").exists() and not (RUNS / "Hallway/spirula/training").exists()
+    assert (RUNS / "Statue/spirula/training/x").exists()
+
+
+def test_dissolving_a_group_keeps_its_scenes(api):
+    make_flat()
+    api.post("/api/group", {"name": "Home", "members": "Kitchen,Hallway"})
+    assert api.post("/api/delete", {"slug": "Home"})[0] == 200
+    assert api.get("/api/groups")[1]["groups"] == []
+    assert {"Kitchen", "Hallway", "Statue"} <= {s["slug"] for s in server.scenes()}
@@ -0,0 +1,253 @@
+"""Conversions and tours as real background jobs (scripts/splat.sh, scripts/combine.sh) with a fake pipeline."""
+import json
+import os
+import time
+
+import pytest
+
+from conftest import RUNS, recording, server, wait_for_tool, wait_job
+import synth
+
+
+def convert(name="Kitchen", existing=None, quality="fast", rec=None):
+    rec = rec or recording()
+    e = server.start_job({"path": str(rec), "name": name, "quality": quality, "upload": False,
+                          **({"existing": existing} if existing else {})})
+    assert e is None, e
+    return wait_job()
+
+
+def test_conversion_makes_a_scene():
+    js = convert()
+    assert js["result"] == "ok", js["tail"]
+    assert js["info"]["cameras"] == 20 and js["info"]["rms_cm"] == 1.1
+    s = {x["slug"]: x for x in server.scenes()}["Kitchen"]
+    assert s["name"] == "Kitchen" and s["gaussians"] == 1000 and s["preview"]
+
+
+def test_a_second_run_of_the_same_name_asks_first():
+    convert()
+    assert server.start_job({"path": str(recording()), "name": "Kitchen", "quality": "fast", "upload": False}) == "exists"
+
+
+def test_start_over_that_fails_keeps_the_old_scene():
+    convert(quality="fast")
+    before = (RUNS / "Kitchen" / "scene.sog").stat().st_mtime_ns
+    os.environ["FAKE_PIPELINE"] = "fail"
+    js = convert(existing="fresh", quality="high")
+    assert js["result"] == "failed"
+    assert (RUNS / "Kitchen" / "scene.sog").stat().st_mtime_ns == before          # the old result is back
+    assert json.loads((RUNS / "Kitchen.ui.json").read_text())["quality"] == "fast"  # with its settings
+    assert not (RUNS / ".previous").exists()
+
+
+def test_cancelled_start_over_keeps_the_old_scene():
+    convert()
+    before = (RUNS / "Kitchen" / "scene.sog").stat().st_mtime_ns
+    os.environ["FAKE_PIPELINE"] = "slow"
+    assert server.start_job({"path": str(recording()), "name": "Kitchen", "quality": "fast", "upload": False,
+                             "existing": "fresh"}) is None
+    time.sleep(3)
+    # while it computes, the old scene stays in the list, marked
+    assert {s["slug"]: s["replacing"] for s in server.scenes()}.get("Kitchen") is True
+    assert server.cancel_job() is None
+    js = wait_job(timeout=30)
+    assert js["result"] == "cancelled"
+    assert (RUNS / "Kitchen" / "scene.sog").stat().st_mtime_ns == before
+
+
+def test_start_over_that_works_replaces_the_scene():
+    convert()
+    before = (RUNS / "Kitchen" / "scene.sog").stat().st_mtime_ns
+    time.sleep(0.05)
+    assert convert(existing="fresh")["result"] == "ok"
+    assert (RUNS / "Kitchen" / "scene.sog").stat().st_mtime_ns != before
+    assert not (RUNS / ".previous").exists()
+
+
+def test_resume_after_an_interrupted_training():
+    rec = recording()
+    (RUNS / "Kitchen" / "dataset").mkdir(parents=True)
+    (RUNS / "Kitchen" / "dataset" / "spirula-dataset.json").write_text('{"status": "complete"}')
+    (RUNS / "Kitchen" / "spirula" / "training" / "step-18000.ckpt").mkdir(parents=True)
+    (RUNS / "Kitchen" / "spirula" / "run.json").write_text('{"status": "running"}')
+    (RUNS / "Kitchen.ui.json").write_text(json.dumps({"name": "Kitchen", "recording": rec.name, "quality": "fast"}))
+    assert server.resume_run("Kitchen", fresh=False) is None
+    js = wait_job()
+    assert js["result"] == "ok", js["tail"]
+    # the (fake) pipeline refuses --resume with an unfinished training, like the real one: it only
+    # worked because splat.sh started the training over
+    assert "Training was interrupted (last checkpoint: 18000.ckpt)" in js["tail"]
+    assert "Incomplete training retained" not in js["tail"]
+    assert not (RUNS / "Kitchen" / "spirula" / "training").exists()
+
+
+def test_putting_a_tour_together():
+    synth.make_room(RUNS, "Kitchen", "A", name="Kitchen", recording="2026-10-12_16-40-00_stereo.mp4")
+    synth.make_room(RUNS, "Hallway", "B", name="Hallway", recording="2026-10-12_16-43-00_stereo.mp4", drift=(0.03, 0, 0))
+    assert server.save_group("", "Example home", "Kitchen,Hallway") == "Example-home"
+    assert server.start_combine({"slug": "Example-home", "align": "shift", "partition": "view",
+                                 "frame_splats": "500000", "full": True}) is None
+    js = wait_job()
+    assert js["result"] == "ok", js["tail"]
+    g = server.groups()["groups"][0]
+    r = g["result"]
+    assert r and r["splats"] > 10000 and r["align"] == "shift" and not r["stale"] and r["preview"]
+    assert r["seams"]["Kitchen|Hallway"]["cm"] < 0.5
+    tour = RUNS / "Example-home"
+    assert (tour / "example-home.sog").exists() and (tour / "example-home.sceneinfo.png").exists()
+    assert (tour / "full" / "example-home-full.sog").exists()
+    # a scene that changes afterwards makes the tour stale
+    time.sleep(0.05)
+    (RUNS / "Kitchen" / "scene.sog").write_bytes(b"newer")
+    assert server.groups()["groups"][0]["result"]["stale"]
+
+
+def test_a_tour_needs_two_scenes_and_no_other_job():
+    synth.make_room(RUNS, "Kitchen", "A", name="Kitchen")
+    server.save_group("", "Lonely", "Kitchen")
+    assert server.start_combine({"slug": "Lonely"})["code"] == "err.combine_too_few"
+    assert server.start_combine({"slug": "Lonely", "align": "magic"})["code"] == "err.bad_request"
+
+
+# ---------------------------------------------------------------- checks before a conversion starts
+
+@pytest.mark.parametrize("file,code", [
+    ("2026-10-12_16-40-00_mono.mp4", "probe.not_stereo"),
+    ("2026-10-12_16-40-00_nogpmd.mp4", "probe.no_gpmd"),
+    ("2026-10-12_16-40-00_short.mp4", "probe.too_short"),
+])
+def test_unsuitable_recordings_are_refused(api, file, code):
+    rec = recording(file)
+    status, r = api.post("/api/start", {"path": str(rec), "name": "Kitchen", "quality": "fast", "upload": False})
+    assert status == 400 and r["error"]["code"] == code
+    assert not (RUNS / "Kitchen").exists()
+
+
+def test_a_short_recording_only_warns():
+    p = server.probe(str(recording("2026-10-12_16-40-00_brief.mp4")))
+    assert p["ok"] and p["warnings"][0]["code"] == "probe.short"
+
+
+@pytest.mark.parametrize("body,code", [
+    ({"path": "/etc/passwd"}, "err.unknown_recording"),              # only recordings from the known folders
+    ({"quality": "bogus"}, "err.bad_quality"),
+    ({"frames": "9999"}, "err.range"),
+    ({"scale": "abc"}, "err.bad_value"),
+    ({"name": "///"}, "err.bad_name"),
+])
+def test_invalid_conversions_are_refused(body, code):
+    full = {"path": str(recording()), "name": "Kitchen", "quality": "fast", "upload": False, **body}
+    assert server.start_job(full)["code"] == code
+    assert server.load_state().get("job") is None
+
+
+# ---------------------------------------------------------------- a scene that is being computed is left alone
+
+def test_a_scene_being_computed_cannot_be_changed(api):
+    convert()                                              # a finished scene ...
+    os.environ["FAKE_PIPELINE"] = "slow"                   # ... computed again (resume keeps scene.sog meanwhile)
+    assert server.start_job({"path": str(recording()), "name": "Kitchen", "quality": "fast", "upload": False,
+                             "existing": "resume"}) is None
+    time.sleep(2)
+    for path, body in (("/api/delete", {"slug": "Kitchen"}), ("/api/rename", {"slug": "Kitchen", "new": "Other"}),
+                       ("/api/clean", {"slug": "Kitchen", "what": "temp"})):
+        status, r = api.post(path, body)
+        assert status == 400 and r["error"]["code"] == "err.scene_busy", path
+    # the new actions of 0.2.3 leave it alone, too
+    v = RUNS / "Kitchen" / "versions" / "0.01m"
+    v.mkdir(parents=True)
+    (v / "scene.sog").write_bytes(b"x")
+    (v / "version.json").write_text(json.dumps({"key": "0.01m", "splats": 10000, "scale": 1, "label": "Kitchen · 0.01 M"}))
+    for path, body, code in (("/api/scale", {"slug": "Kitchen", "scale": "87"}, "err.scene_busy"),
+                             ("/api/version/delete", {"slug": "Kitchen", "version": "0.01m"}, "err.scene_busy"),
+                             ("/api/versions", {"slug": "Kitchen", "sizes": "10000"}, "err.job_busy")):
+        status, r = api.post(path, body)
+        assert status == 400 and r["error"]["code"] == code, path
+    assert v.is_dir() and not (server.read_meta("Kitchen").get("scale") or 1) - 1
+    # and its recording stays
+    rec = server.load_state()["job"]["recording"]
+    status, r = api.post("/api/recording/delete", {"name": rec, "where": "pc"})
+    assert status == 400 and r["error"]["code"] == "err.recording_busy" and (server.REC / rec).exists()
+    # and no tour is put together meanwhile (one job at a time)
+    synth.make_room(RUNS, "Office", "A")
+    synth.make_room(RUNS, "Hallway", "B")
+    assert server.save_group("", "Home", "Office,Hallway") == "Home"
+    assert server.start_combine({"slug": "Home"})["code"] == "err.job_busy"
+    assert (RUNS / "Kitchen" / "scene.sog").exists() and (RUNS / "Kitchen.log").exists()
+    server.cancel_job()
+    wait_job(timeout=30)
+
+
+# ---------------------------------------------------------------- after a power cut
+
+def leftover_from_a_power_cut():
+    """A start over that never finished: the old scene sits in .previous, a half new run in its place."""
+    convert(quality="fast")
+    old = (RUNS / "Kitchen" / "scene.sog").read_bytes()
+    prev = RUNS / ".previous" / "Kitchen"
+    prev.mkdir(parents=True)
+    (RUNS / "Kitchen").rename(prev / "run")
+    (RUNS / "Kitchen.log").rename(prev / "log")
+    (RUNS / "Kitchen").mkdir()
+    (RUNS / "Kitchen" / "half.txt").write_text("half")
+    meta = json.loads((RUNS / "Kitchen.ui.json").read_text())
+    (RUNS / "Kitchen.ui.json").write_text(json.dumps({**meta, "quality": "high", "previous": meta}))
+    return old
+
+
+def test_the_server_puts_back_a_scene_left_after_a_power_cut():
+    old = leftover_from_a_power_cut()
+    server.restore_previous()
+    assert (RUNS / "Kitchen" / "scene.sog").read_bytes() == old
+    assert not (RUNS / "Kitchen" / "half.txt").exists()
+    assert (RUNS / "Kitchen.log").exists()
+    assert json.loads((RUNS / "Kitchen.ui.json").read_text())["quality"] == "fast"
+    assert not (RUNS / ".previous").exists()
+
+
+def test_start_over_after_a_power_cut_keeps_the_old_scene_if_it_fails():
+    old = leftover_from_a_power_cut()
+    os.environ["FAKE_PIPELINE"] = "fail"
+    js = convert(existing="fresh")
+    assert js["result"] == "failed"
+    assert (RUNS / "Kitchen" / "scene.sog").read_bytes() == old    # splat.sh first put the left-over back
+
+
+def test_start_over_from_the_list_of_cancelled_runs():
+    rec = recording()
+    # stopped while extracting images: what the pipeline leaves behind (state "running", half the images)
+    (RUNS / "Kitchen" / "dataset" / "images" / "cam0").mkdir(parents=True)
+    (RUNS / "Kitchen" / "dataset" / "images" / "cam0" / "0000.jpg").write_bytes(b"x")
+    (RUNS / "Kitchen" / "dataset" / "spirula-dataset.json").write_text('{"status": "running"}')
+    (RUNS / "Kitchen.log").write_text("Extraction progress: decoded 4% / saved 44 of 1000\n")
+    (RUNS / "Kitchen.ui.json").write_text(json.dumps({"name": "Kitchen", "recording": rec.name, "quality": "schnell"}))
+    assert server.resume_run("Kitchen", fresh=False)["code"] == "err.not_resumable"
+    assert server.resume_run("Kitchen", fresh=True) is None
+    js = wait_job()
+    assert js["result"] == "ok" and js["quality"] == "fast"    # settings of the first version understood
+    assert "Kitchen" in {s["slug"] for s in server.scenes()}
+    assert "Kitchen" not in {u["slug"] for u in server.unfinished_runs()}
+
+
+# ---------------------------------------------------------------- after a job: the watcher
+
+def test_after_a_job_the_watcher_notifies_and_tidies_up():
+    convert()
+    os.environ["FAKE_PIPELINE"] = "ok"
+    assert server.start_job({"path": str(recording()), "name": "Kitchen", "quality": "fast", "upload": False,
+                             "existing": "fresh"}) is None
+    assert server.watch_once(None) is True                    # running
+    wait_job()
+    assert "previous" in json.loads((RUNS / "Kitchen.ui.json").read_text())
+    assert server.watch_once(True) is False                   # it has just ended
+    assert "previous" not in json.loads((RUNS / "Kitchen.ui.json").read_text())
+    notes = wait_for_tool("notify-send")
+    assert notes and "Kitchen" in notes[-1][-1]
+
+
+def test_after_a_failed_job_the_watcher_says_so():
+    os.environ["FAKE_PIPELINE"] = "fail"
+    convert()
+    server.watch_once(True)
+    assert wait_for_tool("notify-send")
@@ -0,0 +1,321 @@
+"""Recordings on the PC and on the Frame: renaming, the Frame's list, download, copying scenes over."""
+import json
+import os
+import time
+
+import pytest
+
+from conftest import REC, RUNS, TRASH, recording, server, tools_called, wait_for_tool
+import synth
+
+VIDEOS = server.FRAME_VIDEOS
+SCENES = server.FRAME_SCENES
+
+
+# ---------------------------------------------------------------- renaming a recording on the PC
+
+def test_renaming_a_recording_keeps_date_check_result_and_thumbnail(api):
+    rec = recording("2026-10-12_16-40-00_stereo.mp4")
+    server.CACHE.mkdir(parents=True, exist_ok=True)
+    check = server.check_file(rec)
+    check.write_text(json.dumps({"level": "warn"}))
+    (server.CACHE / "2026-10-12_16-40-00_stereo.thumb").write_bytes(b"thumb")
+    status, r = api.post("/api/rename", {"name": rec.name, "new": "Kitchen / evening"})
+    assert status == 200 and r["name"] == "Kitchen - evening.mp4"
+    new = REC / "Kitchen - evening.mp4"
+    assert new.exists() and not rec.exists()
+    f = next(x for x in server.local_files() if x["name"] == new.name)
+    assert (f["date"], f["label"], f["orig"]) == ("2026-10-12T16:40", "Kitchen - evening", rec.name)
+    assert f["check"] == "warn"                                     # the check result moved along
+    assert (server.CACHE / "Kitchen - evening.thumb").read_bytes() == b"thumb"
+
+
+def test_runs_follow_a_renamed_recording(api):
+    rec = recording()
+    synth.make_room(RUNS, "Kitchen", "A", recording=rec.name)        # a finished scene made from it
+    api.post("/api/rename", {"name": rec.name, "new": "Kitchen take 1"})
+    meta = json.loads((RUNS / "Kitchen.ui.json").read_text())
+    assert meta["recording"] == "Kitchen take 1.mp4" and meta["recording_renamed"] is True
+    assert server.no_resume("Kitchen") == "renamed"
+
+
+def test_a_recording_with_an_unfinished_run_cannot_be_renamed(api):
+    rec = recording()
+    (RUNS / "Kitchen").mkdir()                                       # interrupted, no scene.sog
+    (RUNS / "Kitchen.ui.json").write_text(json.dumps({"name": "Kitchen", "recording": rec.name}))
+    status, r = api.post("/api/rename", {"name": rec.name, "new": "Other"})
+    assert status == 400 and r["error"]["code"] == "err.recording_unfinished"   # the pipeline could not resume it
+    assert rec.exists()
+
+
+def test_renaming_a_recording_to_a_taken_name_is_refused(api):
+    a, b = recording("2026-10-12_16-40-00_stereo.mp4"), recording("2026-10-12_16-43-00_stereo.mp4")
+    status, r = api.post("/api/rename", {"name": a.name, "new": b.stem})
+    assert status == 400 and r["error"]["code"] == "err.name_taken"
+    assert api.post("/api/rename", {"name": "../../etc/passwd", "new": "x"})[0] == 400
+
+
+# ---------------------------------------------------------------- the Frame
+
+def put_on_frame(home, name="2026-10-14_10-00-00_stereo.mp4", data=b"recording" * 1000):
+    (home / VIDEOS / name).write_bytes(data)
+    (home / VIDEOS / "thumbnails" / name.replace("_stereo.mp4", ".jpg")).write_bytes(b"jpegdata")
+    return name, data
+
+
+def test_the_frames_recordings_are_listed(api, frame):
+    name, data = put_on_frame(frame)
+    (frame / SCENES / "20_Kitchen").mkdir()
+    status, r = api.get("/api/recordings?refresh=1")
+    assert status == 200 and r["frame_online"]
+    f = r["frame"][0]
+    assert (f["name"], f["size"], f["date"], f["local"]) == (name, len(data), "2026-10-14T10:00", None)
+    assert server.frame_listing()["scenes"] == ["20_Kitchen"]
+
+
+def test_a_frame_that_is_off(api, frame):
+    os.environ["FAKE_FRAME_OFF"] = "1"
+    r = api.get("/api/recordings?refresh=1")[1]
+    assert r["frame_configured"] and r["frame_online"] is False and r["frame"] is None
+
+
+def test_the_frames_preview_image(api, frame):
+    name, _ = put_on_frame(frame)
+    status, body = api.get(f"/api/thumb?source=frame&name={name}")
+    assert status == 200 and body == b"jpegdata"
+
+
+def test_downloading_a_recording(api, frame):
+    name, data = put_on_frame(frame)
+    server.frame_listing(force=True)
+    assert api.post("/api/download", {"name": name})[0] == 200
+    end = time.time() + 20
+    while not (server.download or {}).get("finished") and time.time() < end:
+        time.sleep(0.1)
+    assert server.download["error"] is None
+    assert (REC / name).read_bytes() == data and not (REC / (name + ".part")).exists()
+    status, r = api.post("/api/download", {"name": name})               # never overwrites
+    assert status == 400 and r["error"]["code"] == "err.name_taken"
+    assert api.post("/api/download", {"name": "not-there.mp4"})[1]["error"]["code"] == "err.not_on_frame"
+
+
+def wait_upload(slug):
+    end = time.time() + 120
+    while time.time() < end:
+        u = server.upload_status(slug)
+        if u and not u["running"]:
+            return u
+        time.sleep(0.2)
+    raise TimeoutError
+
+
+def test_copying_a_scene_to_the_frame(api, frame):
+    synth.make_room(RUNS, "Kitchen", "A", name="Kitchen")
+    assert api.post("/api/upload", {"slug": "Kitchen"})[0] == 200
+    u = wait_upload("Kitchen")
+    assert u["ok"], u.get("error")
+    folder = frame / SCENES / "20_Kitchen"
+    assert sorted(p.name for p in folder.iterdir()) == [
+        "kitchen.gallery.png", "kitchen.sceneinfo.png", "kitchen.sog", "kitchen.xrSceneTransform.json"]
+    assert not (frame / "Documents" / "GaussianSplats").exists()        # no second copy on the Frame
+    assert json.loads((RUNS / "Kitchen.ui.json").read_text())["frame_folder"] == "20_Kitchen"
+    assert wait_for_tool("notify-send")                             # sent in the background
+    assert {s["slug"]: s["on_frame"] for s in server.scenes()}["Kitchen"] is True
+
+
+def test_a_renamed_scene_stays_in_its_frame_folder(api, frame):
+    synth.make_room(RUNS, "Kitchen", "A", name="Kitchen")
+    api.post("/api/upload", {"slug": "Kitchen"})
+    wait_upload("Kitchen")
+    api.post("/api/rename", {"slug": "Kitchen", "new": "Küche"})
+    assert api.post("/api/upload", {"slug": "Kueche"})[0] == 200
+    assert wait_upload("Kueche")["ok"]
+    scenes = sorted(p.name for p in (frame / SCENES).iterdir())
+    assert scenes == ["20_Kitchen"]                                    # no second copy
+    assert sorted(p.name for p in (frame / SCENES / "20_Kitchen").iterdir()) == [
+        "kueche.gallery.png", "kueche.sceneinfo.png", "kueche.sog", "kueche.xrSceneTransform.json"]
+
+
+def test_a_broken_download_leaves_nothing_behind(api, frame):
+    name, data = put_on_frame(frame)
+    server.frame_listing(force=True)
+    os.environ["FAKE_FRAME_CUT"] = "1"                  # the connection breaks halfway
+    assert api.post("/api/download", {"name": name})[0] == 200
+    end = time.time() + 20
+    while not (server.download or {}).get("finished") and time.time() < end:
+        time.sleep(0.1)
+    assert server.download["error"]
+    assert not (REC / name).exists() and not (REC / (name + ".part")).exists()
+
+
+def test_a_scene_renamed_before_its_frame_folder_was_remembered(api, frame):
+    """Copied to the Frame by an older version (no frame_folder in its settings): renaming finds the
+    folder on the Frame, so copying again does not create a second one."""
+    synth.make_room(RUNS, "Kitchen", "A", name="Kitchen")
+    (frame / SCENES / "20_Kitchen").mkdir()
+    (frame / SCENES / "20_Kitchen" / "kitchen.sog").write_bytes(b"old")
+    server.frame_listing(force=True)
+    assert api.post("/api/rename", {"slug": "Kitchen", "new": "Küche"})[0] == 200
+    assert json.loads((RUNS / "Kueche.ui.json").read_text())["frame_folder"] == "20_Kitchen"
+    api.post("/api/upload", {"slug": "Kueche"})
+    assert wait_upload("Kueche")["ok"]
+    assert sorted(p.name for p in (frame / SCENES).iterdir()) == ["20_Kitchen"]
+
+
+def wait_fetched(timeout=30):
+    end = time.time() + timeout
+    while server.download_busy() and time.time() < end:
+        time.sleep(0.05)
+    assert not server.download_busy()
+    return server.download_status()
+
+
+def fetch_notes(wait=0):
+    """Notifications about fetching (others of an earlier test may still arrive in the background)."""
+    end = time.time() + wait
+    while True:
+        notes = [c for c in tools_called() if c[0] == "notify-send" and "recording(s)" in c[-1]]
+        if notes or time.time() >= end:
+            return notes
+        time.sleep(0.05)
+
+
+NAMES = [f"2026-10-14_1{i}-00-00_stereo.mp4" for i in range(4)]
+
+
+def test_fetching_several_recordings_one_after_the_other(api, frame):
+    for i, n in enumerate(NAMES):
+        put_on_frame(frame, n, bytes([65 + i]) * 3000)
+    (REC / NAMES[0]).write_bytes(b"already here")                    # skipped, never overwritten
+    server.frame_listing(force=True)
+    os.environ["FAKE_FRAME_SLOW"] = "1"
+    assert api.post("/api/download", {"names": "\n".join(NAMES[:3])})[0] == 200
+    st = api.get("/api/status")[1]["download"]
+    assert st["busy"] and st["batch"]["files"] == 2
+    assert [st["name"], *st["queue"]] == NAMES[1:3] or st["queue"] == NAMES[1:3]
+    assert api.post("/api/download", {"names": f"{NAMES[3]}\n{NAMES[2]}"})[0] == 200   # added while running
+    assert api.post("/api/download", {"names": NAMES[2]})[1]["error"]["code"] == "err.download_busy"
+    st = wait_fetched()
+    assert st["batch"]["files"] == st["batch"]["done_files"] == 3 and st["batch"]["failed"] == []
+    assert (REC / NAMES[0]).read_bytes() == b"already here"
+    for i, n in enumerate(NAMES[1:], 1):
+        assert (REC / n).read_bytes() == bytes([65 + i]) * 3000
+    assert not list(REC.glob("*.part"))
+    note = fetch_notes(wait=5)
+    assert len(note) == 1 and "3 recording(s)" in note[0][-1]           # one notification at the end
+
+
+def test_a_failed_one_does_not_stop_the_others(api, frame):
+    for n in NAMES[:2]:
+        put_on_frame(frame, n)
+    server.frame_listing(force=True)
+    (frame / VIDEOS / NAMES[0]).unlink()                               # gone from the Frame in the meantime
+    assert api.post("/api/download", {"names": "\n".join(NAMES[:2])})[0] == 200
+    st = wait_fetched()
+    assert st["batch"]["failed"] == [NAMES[0]] and (REC / NAMES[1]).exists() and not (REC / NAMES[0]).exists()
+    assert not list(REC.glob("*.part"))
+    assert [n[-1] for n in fetch_notes(wait=5)] == ["1 recording(s) could not be fetched (1 did) – is the Frame switched on?"]
+
+
+def test_cancelling_empties_the_queue(api, frame):
+    for n in NAMES[:3]:
+        put_on_frame(frame, n, b"x" * 20000)
+    server.frame_listing(force=True)
+    os.environ["FAKE_FRAME_SLOW"] = "1"
+    assert api.post("/api/download", {"names": "\n".join(NAMES[:3])})[0] == 200
+    time.sleep(0.3)
+    assert api.post("/api/download/cancel", {})[0] == 200
+    st = wait_fetched()
+    assert st["queue"] == [] and st["batch"]["cancelled"]
+    assert not list(REC.iterdir())                                     # no file and no half of one
+    assert not fetch_notes(wait=0.5)
+    assert api.post("/api/download/cancel", {})[1]["error"]["code"] == "err.no_download"
+
+
+def test_fetching_only_what_is_on_the_frame(api, frame):
+    put_on_frame(frame, NAMES[0])
+    server.frame_listing(force=True)
+    for body in ({"names": "../../etc/passwd"}, {"names": "x\n.."}, {"names": "\n"}):
+        status, r = api.post("/api/download", body)
+        assert status == 400 and r["error"]["code"] == "err.not_on_frame", body
+    assert api.post("/api/download", {"names": [NAMES[0]]})[1]["error"]["code"] == "err.bad_request"
+
+
+def test_deleting_a_recording_on_this_pc_moves_it_to_the_trash(api):
+    rec = recording()
+    assert api.post("/api/rename", {"name": rec.name, "new": "Kitchen"})[0] == 200
+    assert api.post("/api/recording/delete", {"name": "Kitchen.mp4", "where": "pc"})[0] == 200
+    assert not (REC / "Kitchen.mp4").exists() and (TRASH / "Kitchen.mp4").exists()
+    assert "Kitchen.mp4" not in json.loads((server.RECMETA).read_text())          # its old name is forgotten
+    assert api.get("/api/recordings")[1]["local"] == []
+
+
+@pytest.mark.parametrize("name", ["", "..", "../state/state.json", "nope.mp4"])
+def test_deleting_only_recordings_of_the_recordings_folder(api, name):
+    recording()
+    status, r = api.post("/api/recording/delete", {"name": name, "where": "pc"})
+    assert status == 400 and r["error"]["code"] == "err.not_local"
+    assert len(list(REC.iterdir())) == 1 and not list(TRASH.iterdir())
+    assert api.post("/api/recording/delete", {"name": "x", "where": "elsewhere"})[0] == 400
+
+
+def test_a_recording_an_unfinished_scene_needs_stays(api):
+    rec = recording()
+    synth.make_room(RUNS, "Kitchen", "A", recording=rec.name)
+    (RUNS / "Kitchen" / "scene.sog").unlink()                                       # not finished yet
+    status, r = api.post("/api/recording/delete", {"name": rec.name, "where": "pc"})
+    assert status == 400 and r["error"]["code"] == "err.recording_needed"
+    assert rec.exists()
+
+
+def test_deleting_a_recording_on_the_frame(api, frame):
+    name, _ = put_on_frame(frame)
+    other, _ = put_on_frame(frame, NAMES[1])
+    (REC / name).write_bytes(b"the copy on this PC")
+    assert api.post("/api/recording/delete", {"name": name, "where": "frame"})[0] == 200
+    assert not (frame / VIDEOS / name).exists() and (frame / VIDEOS / other).exists()
+    assert (REC / name).read_bytes() == b"the copy on this PC"                     # the PC is not touched
+    assert [f["name"] for f in api.get("/api/recordings")[1]["frame"]] == [other]
+    for bad in (name, "../" + other, "thumbnails", ""):
+        status, r = api.post("/api/recording/delete", {"name": bad, "where": "frame"})
+        assert status == 400 and r["error"]["code"] == "err.not_on_frame", bad
+    assert (frame / VIDEOS / other).exists()
+
+
+def test_a_recording_being_fetched_is_not_deleted(api, frame):
+    for n in NAMES[:2]:
+        put_on_frame(frame, n, b"x" * 20000)
+    server.frame_listing(force=True)
+    os.environ["FAKE_FRAME_SLOW"] = "1"
+    assert api.post("/api/download", {"names": "\n".join(NAMES[:2])})[0] == 200
+    for n in NAMES[:2]:                                     # fetching right now, and waiting
+        status, r = api.post("/api/recording/delete", {"name": n, "where": "frame"})
+        assert status == 400 and r["error"]["code"] == "err.recording_fetching"
+    assert all((frame / VIDEOS / n).exists() for n in NAMES[:2])
+
+
+def test_deleting_on_a_frame_that_is_off(api, frame):
+    name, _ = put_on_frame(frame)
+    os.environ["FAKE_FRAME_OFF"] = "1"
+    status, r = api.post("/api/recording/delete", {"name": name, "where": "frame"})
+    assert status == 400 and r["error"]["code"] == "err.frame_offline"
+
+
+def test_a_recording_being_checked_is_not_deleted(api, frame):
+    rec = recording()
+    put_on_frame(frame, rec.name)
+    server.checks[rec.name] = {"state": "running"}
+    for where in ("pc", "frame"):
+        status, r = api.post("/api/recording/delete", {"name": rec.name, "where": where})
+        assert status == 400 and r["error"]["code"] == "err.recording_busy", where
+    assert rec.exists() and (frame / VIDEOS / rec.name).exists()
+
+
+def test_a_download_that_ends_too_early_leaves_nothing_behind(api, frame):
+    name, _ = put_on_frame(frame)
+    server.frame_listing(force=True)
+    os.environ["FAKE_FRAME_SHORT"] = "1"                 # half the file, but no error from ssh
+    assert api.post("/api/download", {"name": name})[0] == 200
+    st = wait_fetched()
+    assert st["error"] and st["batch"]["failed"] == [name]
+    assert not (REC / name).exists() and not (REC / (name + ".part")).exists()
@@ -0,0 +1,151 @@
+"""Scale for models (e.g. H0 = 1:87): floor plan and measurements in the original's size, and the
+original's size in Gaussian XR (worldScale).
+
+The model is the synthetic 4 x 3 m room built 87 times smaller, so the expected numbers are simply
+those of the full-size room."""
+import json
+import subprocess
+import sys
+import time
+
+import pytest
+
+from conftest import BASE, ROOT, RUNS, server
+import synth
+
+H0 = 87
+
+
+def plan(*runs, ratio=None):
+    out = runs[0].parent / "plan.png"
+    cmd = [sys.executable, str(ROOT / "scripts" / "floorplan.py"), str(out), *[f"{r}={r.name}" for r in runs]]
+    if ratio:
+        cmd += ["--ratio", str(ratio)]
+    r = subprocess.run(cmd, capture_output=True, text=True)
+    assert r.returncode == 0, r.stderr
+    return json.loads(r.stdout.strip().splitlines()[-1])
+
+
+def test_a_model_has_the_floor_plan_of_the_original():
+    full = plan(synth.make_room(BASE / "full", "Room", "A", error=(0.0, (0, 0, 0))))
+    model = plan(synth.make_room(BASE / "model", "Room", "A", error=(0.0, (0, 0, 0)), scale=1 / H0), ratio=H0)
+    assert model["scenes"][0]["size"] == pytest.approx(full["scenes"][0]["size"], abs=0.05)     # 4 x 3 m
+    assert model["pixels_per_metre"] == pytest.approx(full["pixels_per_metre"], rel=0.01)       # measuring in metres
+    assert model["ratio"] == H0
+
+
+def test_a_model_without_its_scale_still_draws():
+    info = plan(synth.make_room(BASE / "model", "Room", "A", error=(0.0, (0, 0, 0)), scale=1 / H0))
+    assert info["ratio"] == 1
+
+
+@pytest.mark.parametrize("scale", ["0.5", "2000", "abc", "nan"])
+def test_scales_out_of_range_are_refused(api, scale):
+    synth.make_room(RUNS, "Layout", "A")
+    status, r = api.post("/api/scale", {"slug": "Layout", "scale": scale})
+    assert status == 400 and r["error"]["code"] in ("err.range", "err.bad_value")
+
+
+def test_setting_and_clearing_the_scale_of_a_scene(api):
+    synth.make_room(RUNS, "Layout", "A")
+    assert api.post("/api/scale", {"slug": "Layout", "scale": "87", "xr": True})[0] == 200
+    s = {x["slug"]: x for x in api.get("/api/scenes")[1]}["Layout"]
+    assert (s["scale"], s["scale_xr"]) == (87, True)
+    assert api.post("/api/scale", {"slug": "Layout", "scale": "1", "xr": True})[0] == 200
+    s = {x["slug"]: x for x in api.get("/api/scenes")[1]}["Layout"]
+    assert (s["scale"], s["scale_xr"]) == (1, False)                  # original size: nothing to enlarge in XR
+    assert api.post("/api/scale", {"slug": "Nope", "scale": "87"})[0] == 400
+
+
+def test_a_group_passes_its_scale_on(api):
+    synth.make_room(RUNS, "Station", "A", recording="2026-10-12_16-40-00_stereo.mp4")
+    synth.make_room(RUNS, "Yard", "B", recording="2026-10-12_16-43-00_stereo.mp4")
+    synth.make_room(RUNS, "Other", "A", recording="2026-10-03_19-00-00_stereo.mp4")
+    server.save_group("", "Layout", "Station,Yard")
+    assert api.post("/api/scale", {"slug": "Layout", "scale": "160", "with_scenes": True})[0] == 200
+    scales = {x["slug"]: x["scale"] for x in api.get("/api/scenes")[1]}
+    assert scales == {"Station": 160, "Yard": 160, "Other": 1}
+    assert api.get("/api/groups")[1]["groups"][0]["scale"] == 160
+    api.post("/api/scale", {"slug": "Layout", "scale": "87"})         # without its scenes this time
+    assert {x["slug"]: x["scale"] for x in api.get("/api/scenes")[1]}["Station"] == 160
+
+
+def test_the_floor_plan_endpoint_measures_in_the_originals_metres(api):
+    synth.make_room(RUNS, "Layout", "A", error=(0.0, (0, 0, 0)), scale=1 / H0)
+    api.post("/api/scale", {"slug": "Layout", "scale": str(H0)})
+    status, png = api.get("/api/floorplan?slugs=Layout&style=classic")
+    assert status == 200 and png[:4] == b"\x89PNG"
+    full = plan(synth.make_room(BASE / "full", "Room", "A", error=(0.0, (0, 0, 0))))
+    info = server.floorplan(["Layout"], "classic", "en", "")[1]
+    assert info["pixels_per_metre"] == pytest.approx(full["pixels_per_metre"], rel=0.01)
+
+
+def wait_upload(slug):
+    end = time.time() + 120
+    while time.time() < end:
+        u = server.upload_status(slug)
+        if u and not u["running"]:
+            return u
+        time.sleep(0.2)
+    raise TimeoutError
+
+
+@pytest.mark.parametrize("xr,expected", [(True, H0), (False, 1.0)])
+def test_world_scale_on_the_frame(api, frame, xr, expected):
+    run = synth.make_room(RUNS, "Layout", "A")
+    api.post("/api/scale", {"slug": "Layout", "scale": str(H0), "xr": xr})
+    api.post("/api/upload", {"slug": "Layout"})
+    assert wait_upload("Layout")["ok"]
+    sent = json.loads((frame / server.FRAME_SCENES / "20_Layout" / "layout.xrSceneTransform.json").read_text())
+    assert sent["worldScale"] == expected
+    assert sent["transform"] == json.loads((run / "scene.xrSceneTransform.json").read_text())["transform"]
+    assert json.loads((run / "scene.xrSceneTransform.json").read_text())["worldScale"] == 1.0   # the original stays
+
+
+def test_changing_the_scale_updates_the_frame(api, frame):
+    synth.make_room(RUNS, "Layout", "A")
+    api.post("/api/upload", {"slug": "Layout"})
+    wait_upload("Layout")
+    assert api.post("/api/scale", {"slug": "Layout", "scale": "45", "xr": True, "update_frame": True})[0] == 200
+    assert wait_upload("Layout")["ok"]
+    sent = json.loads((frame / server.FRAME_SCENES / "20_Layout" / "layout.xrSceneTransform.json").read_text())
+    assert sent["worldScale"] == 45
+
+
+def test_a_tour_of_a_model_is_walkable_in_both_versions():
+    synth.make_room(RUNS, "Station", "A", recording="2026-10-12_16-40-00_stereo.mp4")
+    synth.make_room(RUNS, "Yard", "B", recording="2026-10-12_16-43-00_stereo.mp4")
+    server.save_group("", "Layout", "Station,Yard")
+    server.set_scale("Layout", H0, xr=True, members=True, update_frame=False)
+    assert server.start_combine({"slug": "Layout", "full": True}) is None
+    from conftest import wait_job
+    assert wait_job()["result"] == "ok"
+    tour = RUNS / "Layout"
+    assert json.loads((tour / "layout.xrSceneTransform.json").read_text())["worldScale"] == H0
+    assert json.loads((tour / "full" / "layout-full.xrSceneTransform.json").read_text())["worldScale"] == H0
+
+
+def test_the_floor_plan_of_a_group_in_the_groups_scale(api):
+    synth.make_room(RUNS, "Station", "A", error=(0.0, (0, 0, 0)), scale=1 / H0)
+    server.save_group("", "Layout", "Station")
+    api.post("/api/scale", {"slug": "Layout", "scale": str(H0)})         # only on the group, not passed on
+    assert {x["slug"]: x["scale"] for x in api.get("/api/scenes")[1]}["Station"] == 1
+    full = plan(synth.make_room(BASE / "full", "Room", "A", error=(0.0, (0, 0, 0))))
+    info = server.floorplan(["Station"], "classic", "en", "", "Layout")[1]
+    assert info["ratio"] == H0
+    assert info["scenes"][0]["size"] == pytest.approx(full["scenes"][0]["size"], abs=0.05)       # 4 x 3 m
+    status, png = api.get("/api/floorplan?slugs=Station&style=classic&group=Layout")
+    assert status == 200 and png[:4] == b"\x89PNG"
+    assert server.floorplan(["Station"], "classic", "en", "", "Station")["code"] == "err.bad_request"   # not a group
+
+
+def test_a_floor_plan_of_scenes_in_different_scales_is_refused(api):
+    synth.make_room(RUNS, "Station", "A", recording="2026-10-12_16-40-00_stereo.mp4")
+    synth.make_room(RUNS, "Yard", "B", recording="2026-10-12_16-43-00_stereo.mp4")
+    server.save_group("", "Layout", "Station,Yard")
+    api.post("/api/scale", {"slug": "Station", "scale": "87"})
+    api.post("/api/scale", {"slug": "Yard", "scale": "160"})
+    status, r = api.get("/api/floorplan?slugs=Station,Yard&group=Layout")
+    assert status == 400 and r["error"]["code"] == "err.mixed_scale"
+    api.post("/api/scale", {"slug": "Layout", "scale": "87"})            # one scale for the group decides
+    assert api.get("/api/floorplan?slugs=Station,Yard&style=classic&group=Layout")[0] == 200
@@ -0,0 +1,91 @@
+"""Finished scenes: renaming, cleaning up, deleting, and runs that did not finish."""
+import json
+
+from conftest import RUNS, TRASH, server
+import synth
+
+
+def scene_names():
+    return {s["slug"]: s["name"] for s in server.scenes()}
+
+
+def test_finished_scenes_are_listed(api):
+    synth.make_room(RUNS, "Kitchen", "A", name="Kitchen")
+    status, scenes = api.get("/api/scenes")
+    assert status == 200
+    assert [(s["slug"], s["name"], s["ply"]) for s in scenes] == [("Kitchen", "Kitchen", True)]
+    assert scenes[0]["gaussians"] > 1000
+
+
+def test_renaming_moves_folder_files_and_log(api):
+    run = synth.make_room(RUNS, "Aufnahme-12.10.-16-40", "A", name="Aufnahme 12.10.")
+    (run / "aufnahme-12.10.-16-40.sog").write_bytes(b"x")          # gallery files are named after the folder
+    (run / "aufnahme-12.10.-16-40.gallery.png").write_bytes(b"x")
+    status, r = api.post("/api/rename", {"slug": "Aufnahme-12.10.-16-40", "new": "Büro 12.10."})
+    assert status == 200, r
+    new = RUNS / "Buero-12.10."
+    assert new.is_dir() and not run.exists()
+    assert (new / "buero-12.10..sog").exists() and (new / "buero-12.10..gallery.png").exists()
+    assert (RUNS / "Buero-12.10..log").exists() and not (RUNS / "Aufnahme-12.10.-16-40.log").exists()
+    meta = json.loads((RUNS / "Buero-12.10..ui.json").read_text())
+    assert meta["name"] == "Büro 12.10." and meta["folder_renamed"] is True
+    assert server.no_resume("Buero-12.10.") == "renamed"        # the pipeline remembers the old path
+
+
+def test_renaming_to_a_taken_name_is_refused(api):
+    synth.make_room(RUNS, "Kitchen", "A")
+    synth.make_room(RUNS, "Office", "B")
+    status, r = api.post("/api/rename", {"slug": "Office", "new": "Kitchen"})
+    assert status == 400 and r["error"]["code"] == "err.scene_name_taken"
+    assert (RUNS / "Office").is_dir()
+
+
+def test_cleaning_up_removes_only_what_it_says(api):
+    run = synth.make_room(RUNS, "Kitchen", "A")
+    for rel in ("spirula/training/step-1.ckpt", "dataset/.spirula-sfm/x", "dataset/images/cam0/0000.jpg"):
+        (run / rel).parent.mkdir(parents=True, exist_ok=True)
+        (run / rel).write_bytes(b"x" * 1000)
+    assert api.post("/api/clean", {"slug": "Kitchen", "what": "temp"})[0] == 200
+    assert not (run / "spirula/training").exists() and not (run / "dataset/.spirula-sfm").exists()
+    assert (run / "dataset/images/cam0/0000.jpg").exists()          # training images stay
+    assert (run / "spirula/scene.ply").exists() and (run / "dataset/sparse/0/images.bin").exists()
+    assert server.no_resume("Kitchen") is None
+    assert api.post("/api/clean", {"slug": "Kitchen", "what": "images"})[0] == 200
+    assert not (run / "dataset/images").exists()
+    assert server.no_resume("Kitchen") == "images"                 # only a fresh start from now on
+    assert api.post("/api/clean", {"slug": "Kitchen", "what": "everything"})[0] == 400
+
+
+def test_deleting_moves_to_the_trash(api):
+    synth.make_room(RUNS, "Kitchen", "A")
+    assert api.post("/api/delete", {"slug": "Kitchen"})[0] == 200
+    assert "Kitchen" not in scene_names()
+    assert {p.name for p in TRASH.iterdir()} >= {"Kitchen", "Kitchen.log", "Kitchen.ui.json"}
+
+
+def test_unfinished_runs_resume_or_start_over(api):
+    # interrupted in the training: camera positions done -> it can continue
+    (RUNS / "Hallway" / "dataset").mkdir(parents=True)
+    (RUNS / "Hallway" / "dataset" / "spirula-dataset.json").write_text('{"status": "complete"}')
+    (RUNS / "Hallway.log").write_text("Running native Spirula SfM\nstep  13801/30000 ( 46%)  splats 2000000  "
+                                      "[elapsed 00:10:00.0 | ETA 00:12:00.0]  rgb_loss=0.1 ssim=0.7 psnr=25\n")
+    rec = "2026-10-12_16-43-00_stereo.mp4"
+    (RUNS / "Hallway.ui.json").write_text(json.dumps({"name": "Hallway", "recording": rec}))
+    (server.REC / rec).write_bytes(b"x")
+    # stopped while extracting images -> only from the start
+    (RUNS / "Broken").mkdir()
+    (RUNS / "Broken.log").write_text("Extraction progress: decoded 4% / saved 44 of 1000\n")
+    (RUNS / "Broken.ui.json").write_text(json.dumps({"name": "Broken", "recording": rec}))
+    (RUNS / "old-test.log").write_text("something\n")                # only a log file left
+    synth.make_room(RUNS, "Kitchen", "A", name="Kitchen")            # finished: not in this list
+
+    status, runs = api.get("/api/unfinished")
+    assert status == 200
+    by = {r["slug"]: r for r in runs}
+    assert set(by) == {"Hallway", "Broken", "old-test"}
+    assert (by["Hallway"]["phase"], by["Hallway"]["pct"], by["Hallway"]["resumable"]) == (2, 46, True)
+    assert (by["Broken"]["phase"], by["Broken"]["resumable"], by["Broken"]["restartable"]) == (0, False, True)
+    assert by["old-test"]["phase"] is None and not by["old-test"]["restartable"]
+    assert api.post("/api/resume", {"slug": "Broken"})[1]["error"]["code"] == "err.not_resumable"
+    assert api.post("/api/delete", {"slug": "old-test"})[0] == 200
+    assert not (RUNS / "old-test.log").exists()
@@ -0,0 +1,153 @@
+"""Who may talk to the server: only this PC (or the home network in LAN mode), never other websites."""
+import pytest
+
+from conftest import RUNS, SHUTDOWNS, server
+import synth
+
+
+def test_page_and_api_answer_locally(api):
+    assert api.get("/")[0] == 200
+    status, ping = api.get("/api/ping")
+    assert status == 200 and ping["app"] == "splat-workshop" and ping["version"] == server.VERSION
+
+
+@pytest.mark.parametrize("site", ["cross-site", "same-site"])
+def test_other_websites_are_refused(api, site):
+    # e.g. <img src="http://127.0.0.1:8771/api/floorplan?..."> on any website, or another port on localhost
+    assert api.get("/api/scenes", {"Sec-Fetch-Site": site})[0] == 403
+    assert api.post("/api/cancel", {}, {"Sec-Fetch-Site": site})[0] == 403
+
+
+def test_own_page_and_typed_address_work(api):
+    assert api.get("/api/scenes", {"Sec-Fetch-Site": "same-origin"})[0] == 200
+    assert api.get("/api/scenes", {"Sec-Fetch-Site": "none"})[0] == 200
+
+
+def test_a_link_may_open_the_page_but_not_the_api(api):
+    nav = {"Sec-Fetch-Site": "cross-site", "Sec-Fetch-Mode": "navigate"}
+    assert api.get("/", nav)[0] == 200
+    assert api.get("/api/scenes", nav)[0] == 403
+
+
+def test_post_from_another_origin_is_refused(api):
+    assert api.post("/api/cancel", {}, {"Origin": "http://evil.example"})[0] == 403
+
+
+def test_dns_rebinding_is_refused(api):
+    # a foreign host name that resolves to 127.0.0.1
+    assert api.get("/api/scenes", {"Host": "evil.example:8771"})[0] == 403
+
+
+@pytest.mark.parametrize("lan,client,ok", [
+    (False, "127.0.0.1", True), (False, "192.168.1.20", False),
+    (True, "192.168.1.20", True), (True, "10.8.0.2", True),
+    (True, "100.100.1.1", False),          # carrier-grade NAT / Tailscale: not a home network
+    (True, "84.150.3.3", False),           # the internet, e.g. through a port forwarding
+])
+def test_lan_mode_checks_the_real_client_address(monkeypatch, lan, client, ok):
+    monkeypatch.setattr(server.CFG, "lan", lan)
+
+    class H(server.Handler):
+        def __init__(self):                 # no socket: only what _host_ok looks at
+            self.client_address = (client, 50000)
+            self.headers = {"Host": "192.168.1.5:8771" if lan else "127.0.0.1:8771"}
+            self.command, self.path = "GET", "/api/scenes"
+    assert H()._host_ok() is ok
+
+
+@pytest.mark.parametrize("body,headers", [
+    (b"[1, 2]", {}),                                   # a list instead of an object
+    (b'{"name": 5, "new": "x"}', {}),                  # a number instead of text
+    (b'{"slug": {"a": 1}}', {}),                       # nested objects
+    (b"{not json", {}),
+    (b"", {"Content-Length": "-5"}),
+    (b"", {"Content-Length": str(10 ** 9)}),
+    (b'{"slug": "x", "full": {"a": 1}}', {}),          # nested value in a field that is not text
+])
+def test_invalid_requests_get_400_not_a_crash(api, body, headers):
+    assert api.post("/api/rename", body, headers)[0] == 400
+    assert api.get("/api/ping")[0] == 200            # still alive
+
+
+@pytest.fixture
+def leak():
+    """Something that looks like a scene one level above the runs folder – it must never be reachable."""
+    above = RUNS.parent
+    (above / "spirula").mkdir(exist_ok=True)
+    (above / "spirula" / "scene.ply").write_bytes(b"ply\n")
+    (above / "leak.gallery.png").write_bytes(b"secret")
+    (above / "scene.sog").write_bytes(b"secret")
+    yield
+    for f in ("leak.gallery.png", "scene.sog"):
+        (above / f).unlink(missing_ok=True)
+    (above / "spirula" / "scene.ply").unlink(missing_ok=True)
+    (above / "spirula").rmdir()
+
+
+@pytest.mark.parametrize("slug", ["..", "../runs", "/etc", ".previous", "a/../../b", "."])
+def test_no_paths_outside_the_runs_folder(api, leak, slug):
+    synth.make_room(RUNS, "Room", "A")
+    assert server.scene_dir(slug) is None
+    status, body = api.get(f"/api/preview?slug={slug}")
+    assert status == 404 and body != b"secret"
+    assert api.get(f"/api/floorplan?slugs={slug}")[0] == 400
+    for path, body in (("/api/delete", {"slug": slug}), ("/api/clean", {"slug": slug, "what": "temp"}),
+                       ("/api/rename", {"slug": slug, "new": "x"}), ("/api/upload", {"slug": slug}),
+                       ("/api/combine", {"slug": slug})):
+        assert api.post(path, body)[0] == 400, path
+    assert (RUNS / "Room" / "scene.sog").exists() and (RUNS.parent / "leak.gallery.png").exists()
+
+
+@pytest.mark.parametrize("path,body", [
+    ("/api/open", {"slug": "Room", "what": "folder"}), ("/api/play", {"name": "x.mp4"}),
+    ("/api/pick", {}), ("/api/shutdown", {}),
+])
+def test_actions_on_the_screen_only_from_this_pc(api, monkeypatch, path, body):
+    # video player, file dialog, folder, Spirula and quitting: not from another device in the LAN
+    monkeypatch.setattr(server.Handler, "_from_this_pc", lambda self: False)
+    started = []
+    monkeypatch.setattr(server.subprocess, "Popen", lambda *a, **k: started.append(a))
+    monkeypatch.setattr(server, "pick_file", lambda: started.append("file dialog"))
+    synth.make_room(RUNS, "Room", "A")
+    status, r = api.post(path, body)
+    assert status == 403 and r["error"]["code"] == "err.pc_only"
+    assert started == [] and SHUTDOWNS == []                       # and nothing happened
+
+
+def test_from_this_pc_means_loopback():
+    class Remote(server.Handler):
+        def __init__(self):
+            self.client_address = ("192.168.1.20", 50000)
+
+    class Local(server.Handler):
+        def __init__(self):
+            self.client_address = ("127.0.0.1", 50000)
+    assert not Remote()._from_this_pc() and Local()._from_this_pc()
+
+
+ENDPOINTS = ["/api/start", "/api/rename", "/api/clean", "/api/delete", "/api/upload", "/api/download", "/api/check",
+             "/api/group", "/api/group/dismiss", "/api/combine", "/api/resume", "/api/versions", "/api/scale",
+             "/api/frame/remove", "/api/frame/move", "/api/recording/delete", "/api/version/delete",
+             "/api/download/cancel"]
+
+
+@pytest.mark.parametrize("path", ENDPOINTS)
+@pytest.mark.parametrize("field", ["name", "new", "slug", "path", "what", "members", "key", "align", "quality",
+                                   "existing", "partition", "version", "sizes", "scales", "folder", "names", "place",
+                                   "where"])
+def test_wrongly_typed_fields_get_400_everywhere(api, path, field):
+    for bad in (5, ["a"], True):
+        assert api.post(path, {field: bad})[0] == 400, (path, field, bad)
+
+
+def test_unknown_thumbnail_names_leave_no_cache_files(api):
+    status, _ = api.get("/api/thumb?source=frame&name=whatever.mp4")
+    assert status == 404
+    assert not list(server.CACHE.glob("whatever*"))
+
+
+def test_nested_values_are_refused_in_any_field(api):
+    # a request that would work, apart from one nested value in a field that is not text
+    synth.make_room(RUNS, "Room", "A")
+    assert api.post("/api/rename", {"slug": "Room", "new": "Other", "update_frame": {"a": 1}})[0] == 400
+    assert (RUNS / "Room").is_dir() and not (RUNS / "Other").exists()
@@ -0,0 +1,220 @@
+"""Versions of a scene or tour (scripts/versions.sh): several sizes and scales side by side, each its own
+scene – also on the Frame, where every version gets its own folder in the gallery."""
+import json
+import os
+import time
+
+import pytest
+
+from conftest import RUNS, TRASH, recording, server, tools_called, wait_job
+import synth
+
+
+def room(slug="Room", **kw):
+    run = synth.make_room(RUNS, slug, "A", name=slug, **kw)
+    with open(run / "spirula" / "scene.ply", "rb") as f:
+        total = next(int(l.split()[-1]) for l in f if l.startswith(b"element vertex"))
+    return run, total
+
+
+def make(slug, sizes, scales="1"):
+    assert server.start_versions({"slug": slug, "sizes": sizes, "scales": scales}) is None
+    js = wait_job()
+    assert js["result"] == "ok", js["tail"]
+    return {v["key"]: v for v in server.versions_of(slug)}
+
+
+def test_versions_in_several_sizes():
+    run, total = room()
+    versions = make("Room", "10000,20000,all")
+    assert set(versions) == {"0.01m", "0.02m", "all"}
+    assert [versions[k]["splats"] for k in ("0.01m", "0.02m", "all")] == [10000, 20000, total]
+    assert versions["0.01m"]["label"] == "Room · 0.01 M" and versions["all"]["label"] == "Room · all splats"
+    reduced = [c for c in tools_called() if c[0] == "splat-transform" and "--decimate" in c]
+    assert sorted(c[c.index("--decimate") + 1] for c in reduced) == ["10000", "20000"]     # "all" is not reduced
+    for key in versions:
+        v = run / "versions" / key
+        assert (v / "scene.sog").exists() and (v / f"room-{key}.sceneinfo.png").exists()
+        assert (v / f"room-{key}.gallery.png").exists()                           # the scene's preview
+        assert json.loads((v / "scene.xrSceneTransform.json").read_text())["worldScale"] == 1.0
+    assert server.scenes()[0]["versions"] == 3
+
+
+def test_a_size_above_the_scene_is_all_of_it():
+    run, total = room()
+    versions = make("Room", str(total * 2))
+    assert list(versions.values())[0]["splats"] == total
+
+
+def test_versions_in_the_originals_size(api):
+    run, _ = room()
+    api.post("/api/scale", {"slug": "Room", "scale": "87"})
+    versions = make("Room", "10000", "1,87")
+    assert set(versions) == {"0.01m", "0.01m-1x87"}
+    assert versions["0.01m-1x87"]["label"] == "Room · 0.01 M · 1:87"
+    worlds = {k: json.loads((run / "versions" / k / "scene.xrSceneTransform.json").read_text())["worldScale"]
+              for k in versions}
+    assert worlds == {"0.01m": 1.0, "0.01m-1x87": 87.0}
+
+
+def test_versions_side_by_side_on_the_frame(api, frame):
+    room()
+    make("Room", "10000,20000")
+    for key in ("0.01m", "0.02m"):
+        assert api.post("/api/upload", {"slug": "Room", "version": key})[0] == 200
+        end = time.time() + 60
+        while (u := server.upload_status(f"Room#{key}")) and u["running"] and time.time() < end:
+            time.sleep(0.2)
+        assert server.upload_status(f"Room#{key}")["ok"]
+    scenes = frame / server.FRAME_SCENES
+    assert sorted(p.name for p in scenes.iterdir()) == ["20_Room-0.01m", "21_Room-0.02m"]
+    assert sorted(p.name for p in (scenes / "21_Room-0.02m").iterdir()) == [
+        "room-0.02m.gallery.png", "room-0.02m.sceneinfo.png", "room-0.02m.sog", "room-0.02m.xrSceneTransform.json"]
+    folders = json.loads((RUNS / "Room.ui.json").read_text())["version_folders"]
+    assert folders == {"0.01m": "20_Room-0.01m", "0.02m": "21_Room-0.02m"}
+    versions = {v["key"]: v for v in server.versions_of("Room")}
+    assert versions["0.01m"]["on_frame"] and versions["0.02m"]["on_frame"]
+    assert api.post("/api/upload", {"slug": "Room", "version": "9m"})[1]["error"]["code"] == "err.no_version"
+
+
+def test_deleting_a_version(api):
+    run, _ = room()
+    make("Room", "10000,20000")
+    assert api.post("/api/version/delete", {"slug": "Room", "version": "0.01m"})[0] == 200
+    assert set(v["key"] for v in server.versions_of("Room")) == {"0.02m"}
+    assert (TRASH / "0.01m").exists() and (run / "spirula" / "scene.ply").exists()
+    assert api.post("/api/version/delete", {"slug": "Room", "version": "../spirula"})[0] == 400
+
+
+def test_versions_follow_a_renamed_scene(api):
+    room("Kitchen")
+    make("Kitchen", "10000")
+    assert api.post("/api/rename", {"slug": "Kitchen", "new": "Küche"})[0] == 200
+    v = RUNS / "Kueche" / "versions" / "0.01m"
+    assert (v / "kueche-0.01m.sceneinfo.png").exists() and not (v / "kitchen-0.01m.sceneinfo.png").exists()
+    assert [x["key"] for x in server.versions_of("Kueche")] == ["0.01m"]
+
+
+def test_a_version_older_than_its_scene():
+    run, _ = room()
+    make("Room", "10000")
+    assert not server.versions_of("Room")[0]["stale"]
+    time.sleep(0.05)
+    os.utime(run / "spirula" / "scene.ply")                       # the scene was computed again
+    assert server.versions_of("Room")[0]["stale"]
+
+
+@pytest.mark.parametrize("body,code", [
+    ({"sizes": "5"}, "err.range"), ({"sizes": "abc"}, "err.bad_value"), ({"sizes": ""}, "err.no_versions"),
+    ({"sizes": "10000", "scales": "0.5"}, "err.range"), ({"slug": "Nope", "sizes": "10000"}, "err.no_scene"),
+])
+def test_invalid_versions_are_refused(body, code):
+    room()
+    assert server.start_versions({"slug": "Room", **body})["code"] == code
+
+
+def test_versions_of_a_tour():
+    synth.make_room(RUNS, "Kitchen", "A", name="Kitchen", recording="2026-10-12_16-40-00_stereo.mp4")
+    synth.make_room(RUNS, "Hallway", "B", name="Hallway", recording="2026-10-12_16-43-00_stereo.mp4")
+    server.save_group("", "Flat", "Kitchen,Hallway")
+    assert server.start_combine({"slug": "Flat", "full": False}) is None
+    assert wait_job()["result"] == "ok"
+    versions = make("Flat", "10000,all")
+    assert set(versions) == {"0.01m", "all"}
+    assert versions["all"]["splats"] == server.groups()["groups"][0]["result"]["splats"]
+    assert server.groups()["groups"][0]["versions"] == 2
+
+
+def test_one_job_at_a_time():
+    room()
+    os.environ["FAKE_PIPELINE"] = "slow"
+    rec = recording()
+    assert server.start_job({"path": str(rec), "name": "Other", "quality": "fast", "upload": False}) is None
+    time.sleep(1)
+    assert server.start_versions({"slug": "Room", "sizes": "10000"})["code"] == "err.job_busy"
+
+
+def upload(api, slug, key):
+    assert api.post("/api/upload", {"slug": slug, "version": key})[0] == 200
+    end = time.time() + 60
+    while (u := server.upload_status(f"{slug}#{key}")) and u["running"] and time.time() < end:
+        time.sleep(0.2)
+    assert server.upload_status(f"{slug}#{key}")["ok"]
+
+
+def test_taking_a_version_off_the_frame_removes_only_that(api, frame):
+    room()
+    make("Room", "10000,20000")
+    upload(api, "Room", "0.01m")
+    upload(api, "Room", "0.02m")
+    scenes, backup = frame / server.FRAME_SCENES, frame / server.FRAME_BACKUP
+    (scenes / "04_BurtLakeHouse").mkdir()                      # an example scene of Gaussian XR
+    (scenes / "30_Room-0.01m-old").mkdir()                     # someone else's folder with a similar name
+    (backup / "20_Room-0.01m").mkdir(parents=True)             # a copy left by version 0.2.3 or older
+    (backup / "21_Room-0.02m").mkdir()
+    assert api.post("/api/frame/remove", {"slug": "Room", "version": "0.01m"})[0] == 200
+    assert sorted(p.name for p in scenes.iterdir()) == ["04_BurtLakeHouse", "21_Room-0.02m", "30_Room-0.01m-old"]
+    assert not (backup / "20_Room-0.01m").exists() and (backup / "21_Room-0.02m").exists()
+    assert "0.01m" not in json.loads((RUNS / "Room.ui.json").read_text())["version_folders"]
+    v = {x["key"]: x for x in server.versions_of("Room")}
+    assert v["0.01m"]["on_frame"] is False and v["0.02m"]["on_frame"]       # still on the PC, off the Frame
+    status, r = api.post("/api/frame/remove", {"slug": "Room", "version": "0.01m"})
+    assert status == 400 and r["error"]["code"] == "err.not_on_frame_version"
+
+
+@pytest.mark.parametrize("version", ["", "..", "../0.02m", ".hidden"])
+def test_taking_off_the_frame_only_with_a_proper_version(api, frame, version):
+    room()
+    assert api.post("/api/frame/remove", {"slug": "Room", "version": version})[0] == 400
+
+
+def test_taking_off_a_frame_that_is_off(api, frame):
+    room()
+    make("Room", "10000")
+    upload(api, "Room", "0.01m")
+    os.environ["FAKE_FRAME_OFF"] = "1"
+    status, r = api.post("/api/frame/remove", {"slug": "Room", "version": "0.01m"})
+    assert status == 400 and r["error"]["code"] == "err.frame_offline"
+    os.environ.pop("FAKE_FRAME_OFF")
+    assert (frame / server.FRAME_SCENES / "20_Room-0.01m").exists()
+
+
+def test_versions_sh_refuses_odd_version_names():
+    import subprocess
+    from conftest import ROOT
+    run, _ = room()
+    for spec in ("../x|10000|1|x", ".hidden|10000|1|x", "a/b|10000|1|x"):
+        r = subprocess.run([str(ROOT / "scripts" / "versions.sh"), str(run), spec], capture_output=True, text=True)
+        assert r.returncode == 1 and "Unusable version name" in r.stderr, spec
+    assert not (run / "x").exists() and not (run / "versions").exists()
+
+
+def test_an_old_copy_of_a_version_is_recognised_by_its_folder(api, frame):
+    room()
+    make("Room", "10000")                                       # not copied by this version: no version_folders
+    d = frame / server.FRAME_STEAM / "21_Room-0.01m"
+    d.mkdir()
+    (d / "room-0.01m.gallery.png").write_bytes(b"preview")
+    server.frame_cache["t"] = 0
+    assert server.versions_of("Room")[0]["on_frame"] is True
+    g = {x["folder"]: x for x in api.get("/api/frame/gallery?refresh=1")[1]["scenes"]}["21_Room-0.01m"]
+    assert (g["kind"], g["slug"], g["version"], g["place"]) == ("version", "Room", "0.01m", "steam")
+
+
+def test_nothing_is_moved_or_removed_on_the_frame_while_copying(api, frame):
+    room()
+    make("Room", "10000")
+    d = frame / server.FRAME_STEAM / "20_Room-0.01m"            # an old copy, being copied again right now
+    d.mkdir()
+    (d / "room-0.01m.gallery.png").write_bytes(b"preview")
+    os.environ["FAKE_SCP_SLOW"] = "1"
+    assert api.post("/api/upload", {"slug": "Room", "version": "0.01m"})[0] == 200
+    time.sleep(0.5)
+    for path, body in (("/api/frame/move", {}), ("/api/frame/remove", {"folder": "20_Room-0.01m"}),
+                       ("/api/version/delete", {"slug": "Room", "version": "0.01m"})):
+        status, r = api.post(path, body)
+        assert status == 400 and r["error"]["code"] in ("err.upload_busy", "err.scene_busy"), path
+    end = time.time() + 30
+    while (u := server.upload_status("Room#0.01m")) and u["running"] and time.time() < end:
+        time.sleep(0.2)
+    assert server.upload_status("Room#0.01m")["ok"]
@@ -34,6 +34,12 @@ const I18N = {
    "confirm.cancel": "Really cancel the conversion? With “Resume” you can continue later from the last saved state.",
    // step 1
    "s1.title": "Choose a recording", "tab.frame": "On the Frame", "tab.local": "On this PC",
+    "dl.all": "Fetch all ({n} · {size})", "dl.all.title": "Fetch every recording that is not on this PC yet, one after the other",
+    "dl.sel": "Fetch selection ({n} · {size})", "dl.sel.title": "Fetch the ticked recordings, one after the other",
+    "dl.pick": "Fetch this one too", "dl.queued": "waiting", "dl.cancel": "Cancel", "dl.cancelled": "Fetching cancelled",
+    "dl.progress": "Fetching {i} of {n} from the Frame · {done} of {total}",
+    "dl.done": "{n} recording(s) fetched – you can switch the Frame off", "dl.failed": "{n} recording(s) could not be fetched",
+    "err.no_download": "Nothing is being fetched",
    "checkAll": "Check all", "checkAll.title": "Check all recordings on this PC that have not been checked yet",
    "pick": "Choose file …", "refresh.title": "Reload list", "loading": "Loading …",
    "frame.unreachable": "The Frame is not reachable – is it on and in the same network?",
@@ -122,6 +128,14 @@ const I18N = {
    "sc.spirula.starting": "Starting Spirula …", "sc.uploadStarted": "Copying to the Frame …",
    "sc.splats": "{n} M splats",
    "sc.plan": "Floor plan",
+    "rdel.frame": "🗑 Delete from the Frame", "rdel.pc": "🗑 Delete from this PC",
+    "rdel.confirm.frame": "Delete “{name}” ({size}) from the Frame? This cannot be undone there – the copy on this PC stays.",
+    "rdel.confirm.frame.only": "“{name}” ({size}) is NOT on this PC yet! Delete it from the Frame anyway? It is then gone for good.",
+    "rdel.confirm.pc": "Move “{name}” ({size}) on this PC to the trash? Finished scenes stay.",
+    "rdel.confirm.pc.only": "Move “{name}” ({size}) to the trash? It is no longer on the Frame – the trash then holds the only copy.",
+    "rdel.done.frame": "“{name}” deleted from the Frame", "rdel.done.pc": "“{name}” moved to the trash",
+    "err.recording_fetching": "The recording is being fetched from the Frame right now",
+    "err.recording_needed": "“{name}” from this recording is not finished yet and still needs it",
    "ren.button": "✎ Rename", "ren.ok": "Rename", "ren.cancel": "Cancel", "ren.done": "Renamed",
    "ren.rec.title": "Rename recording",
    "ren.rec.hint": "Renames the file on this PC. The recording date is kept; the copy on the Frame keeps its name.",
@@ -184,7 +198,41 @@ const I18N = {
    "job.sub.combine": "{n} scenes · correction {align} · {target} · for {time}",
    "err.in_other_group": "“{group}” already contains one of these scenes",
    "err.combine_too_few": "Putting together needs at least two finished scenes",
-    "err.plan_failed": "The floor plan could not be drawn", "sc.replacing": "Being computed again – stays until the new one is done", "err.plan_busy": "Other floor plans are being drawn right now, try again in a moment",
+    "scale.button.title": "Scale – for models, e.g. a model railway", "scale.title": "Scale of “{name}”",
+    "scale.hint": "For models: floor plan, sizes and measurements then show the size of the original (H0: 10 cm in the model = 8.7 m).",
+    "scale.original": "Original size", "scale.custom": "Own scale",
+    "scale.xr": "Walk through it in Gaussian XR in the original's size (not tested on the Frame yet)",
+    "scale.members": "Also for all scenes in this group", "scale.frame": "Update it on the Frame too",
+    "scale.line": "Scale {ratio}", "scale.line.xr": "original size in XR", "scale.done": "Scale saved",
+    "ver.button": "Versions ({n})", "ver.button.title": "Versions with fewer splats for the Frame or all splats for the PC – several side by side",
+    "ver.title": "Versions of “{name}” ({n} splats)",
+    "ver.hint": "Every version is its own scene and gets its own place in the Frame's gallery – e.g. 0.75 M and 2 M side by side to compare.",
+    "ver.new": "New versions", "ver.frame": "For the Frame", "ver.pc": "For the PC", "ver.custom": "Own size", "ver.million": "million splats",
+    "ver.scales": "Scale", "ver.walk": "walk through it ({ratio})", "ver.all": "all splats",
+    "ver.measured": "Measured on a Steam Frame (Gaussian XR, 10/2026): 0.57 M ≈ 36 fps, 2 M ≈ 23 fps, 5 M ≈ 14 fps.",
+    "ver.make": "Make versions", "ver.pick": "Pick at least one size", "ver.started": "Making versions …",
+    "ver.none": "No versions yet.", "ver.stale": "older than the scene", "ver.delete": "Delete version",
+    "ver.confirm": "Move the version “{name}” ({size}) to the trash? A copy on the Frame is not touched.",
+    "job.sub.versions": "{n} versions · for {time}", "err.no_version": "This version does not exist",
+    "err.no_versions": "Pick at least one size",
+    "ver.unframe": "Off the Frame", "ver.unframe.title": "Remove this version from the Frame's gallery (it stays on the PC)",
+    "ver.unframe.confirm": "Remove “{name}” from the Frame? Its folder in the gallery and the backup copy on the Frame are deleted; the version stays on this PC.",
+    "ver.unframed": "“{name}” removed from the Frame", "err.not_on_frame_version": "This version is not on the Frame",
+    "err.frame_offline": "The Frame is not reachable", "err.frame_failed": "The Frame refused",
+    "stab.pc": "On this PC", "stab.frame": "On the Frame",
+    "fg.hint": "Everything in Gaussian XR's gallery on the Frame. Taking something off the Frame does not touch this PC.",
+    "fg.loading": "Asking the Frame …", "fg.empty": "The gallery on the Frame is empty.",
+    "fg.kind.scene": "Scene", "fg.kind.tour": "Tour", "fg.kind.version": "Version", "fg.kind.other": "Not from Splat Workshop",
+    "fg.remove": "Off the Frame", "fg.remove.title": "Delete this scene from the Frame's gallery",
+    "fg.confirm": "Take “{name}” ({size}) off the Frame? It stays on this PC and can be copied again any time.",
+    "fg.confirm.other": "“{name}” ({size}) was not made with Splat Workshop – e.g. one of Gaussian XR's examples. Delete it from the Frame anyway? Steam brings the examples back with “verify integrity of game files”.",
+    "fg.removed": "“{name}” taken off the Frame",
+    "fg.place.own": "Own scenes", "fg.place.own.title": "Documents/GaussianXR on the Frame – Steam updates leave it alone",
+    "fg.place.steam": "Gaussian XR folder", "fg.place.steam.title": "Gaussian XR's own gallery folder – a Steam update or “verify files” can reset it",
+    "fg.move.hint": "{n} scene(s) from Splat Workshop are still in Gaussian XR's own folder, where a Steam update can delete them.",
+    "fg.move": "Move to own scenes", "fg.moved": "Moved to the own scenes on the Frame",
+    "ver.recommended": "(recommended)",
+    "err.mixed_scale": "These scenes have different scales – set one scale for the group", "err.plan_failed": "The floor plan could not be drawn", "sc.replacing": "Being computed again – stays until the new one is done", "err.plan_busy": "Other floor plans are being drawn right now, try again in a moment",
    "plan.measure": "📏 Measure", "plan.measure.title": "Measure distances in the floor plan",
    "plan.measure.hint": "Click to set points · right-click removes the last one · horizontal distances, about ±5 cm",
    "plan.measure.undo": "Undo", "plan.measure.reset": "Reset",
@@ -231,6 +279,12 @@ const I18N = {
    "res.failed": "Fehlgeschlagen – die letzten Zeilen im Protokoll zeigen warum.",
    "confirm.cancel": "Umwandlung wirklich abbrechen? Mit „Fortsetzen“ geht es später ab dem letzten Zwischenstand weiter.",
    "s1.title": "Aufnahme wählen", "tab.frame": "Auf der Frame", "tab.local": "Auf dem PC",
+    "dl.all": "Alle holen ({n} · {size})", "dl.all.title": "Alle Aufnahmen, die noch nicht auf dem PC sind, nacheinander holen",
+    "dl.sel": "Auswahl holen ({n} · {size})", "dl.sel.title": "Die angehakten Aufnahmen nacheinander holen",
+    "dl.pick": "Diese auch holen", "dl.queued": "wartet", "dl.cancel": "Abbrechen", "dl.cancelled": "Holen abgebrochen",
+    "dl.progress": "Hole {i} von {n} von der Frame · {done} von {total}",
+    "dl.done": "{n} Aufnahme(n) geholt – du kannst die Frame abschalten", "dl.failed": "{n} Aufnahme(n) konnten nicht geholt werden",
+    "err.no_download": "Es wird nichts geholt",
    "checkAll": "Alle prüfen", "checkAll.title": "Alle Aufnahmen auf dem PC prüfen, die noch nicht geprüft sind",
    "pick": "Datei wählen …", "refresh.title": "Liste neu laden", "loading": "Lade …",
    "frame.unreachable": "Die Frame ist nicht erreichbar – ist sie an und im selben Netz?",
@@ -315,6 +369,14 @@ const I18N = {
    "sc.spirula.starting": "Spirula startet …", "sc.uploadStarted": "Übertrage auf die Frame …",
    "sc.splats": "{n} Mio. Splats",
    "sc.plan": "Grundriss",
+    "rdel.frame": "🗑 Von der Frame löschen", "rdel.pc": "🗑 Vom PC löschen",
+    "rdel.confirm.frame": "„{name}“ ({size}) von der Frame löschen? Dort lässt sich das nicht rückgängig machen – die Kopie auf dem PC bleibt.",
+    "rdel.confirm.frame.only": "„{name}“ ({size}) liegt noch NICHT auf dem PC! Trotzdem von der Frame löschen? Dann ist sie endgültig weg.",
+    "rdel.confirm.pc": "„{name}“ ({size}) auf dem PC in den Papierkorb verschieben? Fertige Szenen bleiben.",
+    "rdel.confirm.pc.only": "„{name}“ ({size}) in den Papierkorb verschieben? Auf der Frame liegt sie nicht mehr – der Papierkorb hat dann die einzige Kopie.",
+    "rdel.done.frame": "„{name}“ von der Frame gelöscht", "rdel.done.pc": "„{name}“ in den Papierkorb verschoben",
+    "err.recording_fetching": "Die Aufnahme wird gerade von der Frame geholt",
+    "err.recording_needed": "„{name}“ aus dieser Aufnahme ist noch nicht fertig und braucht sie noch",
    "ren.button": "✎ Umbenennen", "ren.ok": "Umbenennen", "ren.cancel": "Abbrechen", "ren.done": "Umbenannt",
    "ren.rec.title": "Aufnahme umbenennen",
    "ren.rec.hint": "Benennt die Datei auf dem PC um. Das Aufnahmedatum bleibt erhalten; die Kopie auf der Frame behält ihren Namen.",
@@ -377,7 +439,41 @@ const I18N = {
    "job.sub.combine": "{n} Szenen · Korrektur {align} · {target} · seit {time}",
    "err.in_other_group": "„{group}“ enthält schon eine dieser Szenen",
    "err.combine_too_few": "Zum Zusammensetzen braucht es mindestens zwei fertige Szenen",
-    "err.plan_failed": "Der Grundriss konnte nicht gezeichnet werden", "sc.replacing": "Wird neu gerechnet – bleibt, bis die neue fertig ist", "err.plan_busy": "Gerade werden andere Grundrisse gezeichnet, gleich noch einmal versuchen",
+    "scale.button.title": "Maßstab – für Modelle, z. B. eine Modelleisenbahn", "scale.title": "Maßstab von „{name}“",
+    "scale.hint": "Für Modelle: Grundriss, Größen und Messwerte zeigen dann die Größe des Originals (H0: 10 cm im Modell = 8,7 m).",
+    "scale.original": "Originalgröße", "scale.custom": "Eigener Maßstab",
+    "scale.xr": "In Gaussian XR in Originalgröße begehbar (an der Frame noch nicht getestet)",
+    "scale.members": "Auch für alle Szenen dieser Gruppe", "scale.frame": "Auch auf der Frame aktualisieren",
+    "scale.line": "Maßstab {ratio}", "scale.line.xr": "in XR in Originalgröße", "scale.done": "Maßstab gespeichert",
+    "ver.button": "Fassungen ({n})", "ver.button.title": "Fassungen mit weniger Splats für die Frame oder allen Splats für den PC – mehrere nebeneinander",
+    "ver.title": "Fassungen von „{name}“ ({n} Splats)",
+    "ver.hint": "Jede Fassung ist eine eigene Szene und bekommt einen eigenen Platz in der Galerie der Frame – z. B. 0,75 Mio. und 2 Mio. nebeneinander zum Vergleichen.",
+    "ver.new": "Neue Fassungen", "ver.frame": "Für die Frame", "ver.pc": "Für den PC", "ver.custom": "Eigene Größe", "ver.million": "Mio. Splats",
+    "ver.scales": "Maßstab", "ver.walk": "begehbar ({ratio})", "ver.all": "alle Splats",
+    "ver.measured": "Gemessen auf einer Steam Frame (Gaussian XR, 10/2026): 0,57 Mio. ≈ 36 fps, 2 Mio. ≈ 23 fps, 5 Mio. ≈ 14 fps.",
+    "ver.make": "Fassungen erstellen", "ver.pick": "Mindestens eine Größe wählen", "ver.started": "Erstelle Fassungen …",
+    "ver.none": "Noch keine Fassungen.", "ver.stale": "älter als die Szene", "ver.delete": "Fassung löschen",
+    "ver.confirm": "Fassung „{name}“ ({size}) in den Papierkorb verschieben? Eine Kopie auf der Frame bleibt unberührt.",
+    "job.sub.versions": "{n} Fassungen · seit {time}", "err.no_version": "Diese Fassung gibt es nicht",
+    "err.no_versions": "Mindestens eine Größe wählen",
+    "ver.unframe": "Von der Frame nehmen", "ver.unframe.title": "Diese Fassung aus der Galerie der Frame entfernen (auf dem PC bleibt sie)",
+    "ver.unframe.confirm": "„{name}“ von der Frame nehmen? Ihr Ordner in der Galerie und die Sicherungskopie auf der Frame werden gelöscht; auf dem PC bleibt die Fassung.",
+    "ver.unframed": "„{name}“ von der Frame genommen", "err.not_on_frame_version": "Diese Fassung liegt nicht auf der Frame",
+    "err.frame_offline": "Die Frame ist nicht erreichbar", "err.frame_failed": "Die Frame hat abgelehnt",
+    "stab.pc": "Auf dem PC", "stab.frame": "Auf der Frame",
+    "fg.hint": "Alles, was in der Galerie von Gaussian XR auf der Frame liegt. Von der Frame nehmen ändert nichts auf dem PC.",
+    "fg.loading": "Frage die Frame …", "fg.empty": "Die Galerie auf der Frame ist leer.",
+    "fg.kind.scene": "Szene", "fg.kind.tour": "Rundgang", "fg.kind.version": "Fassung", "fg.kind.other": "Nicht aus der Splat-Werkstatt",
+    "fg.remove": "Von der Frame nehmen", "fg.remove.title": "Diese Szene aus der Galerie der Frame löschen",
+    "fg.confirm": "„{name}“ ({size}) von der Frame nehmen? Auf dem PC bleibt sie und lässt sich jederzeit neu übertragen.",
+    "fg.confirm.other": "„{name}“ ({size}) stammt nicht aus der Splat-Werkstatt – z. B. ein Beispiel von Gaussian XR. Trotzdem von der Frame löschen? Steam stellt die Beispiele mit „Dateien auf Fehler überprüfen“ wieder her.",
+    "fg.removed": "„{name}“ von der Frame genommen",
+    "fg.place.own": "Eigene Szenen", "fg.place.own.title": "Documents/GaussianXR auf der Frame – Steam-Updates lassen den Ordner in Ruhe",
+    "fg.place.steam": "Ordner von Gaussian XR", "fg.place.steam.title": "Der Galerie-Ordner von Gaussian XR selbst – ein Steam-Update oder „Dateien überprüfen“ kann ihn zurücksetzen",
+    "fg.move.hint": "{n} Szene(n) aus der Werkstatt liegen noch im Ordner von Gaussian XR, wo ein Steam-Update sie löschen kann.",
+    "fg.move": "Zu den eigenen Szenen verschieben", "fg.moved": "Zu den eigenen Szenen auf der Frame verschoben",
+    "ver.recommended": "(empfohlen)",
+    "err.mixed_scale": "Die Szenen haben verschiedene Maßstäbe – einen Maßstab für die Gruppe setzen", "err.plan_failed": "Der Grundriss konnte nicht gezeichnet werden", "sc.replacing": "Wird neu gerechnet – bleibt, bis die neue fertig ist", "err.plan_busy": "Gerade werden andere Grundrisse gezeichnet, gleich noch einmal versuchen",
    "plan.measure": "📏 Messen", "plan.measure.title": "Abstände im Grundriss messen",
    "plan.measure.hint": "Klicken setzt Punkte · Rechtsklick nimmt den letzten zurück · waagerechte Abstände, etwa ±5 cm genau",
    "plan.measure.undo": "Rückgängig", "plan.measure.reset": "Zurücksetzen",
@@ -67,6 +67,8 @@ label.field small { font-size: 12px; color: var(--faint); line-height: 1.4; }
 .play:hover { transform: scale(1.08); }
 .cbadge { position: absolute; left: 8px; top: 8px; width: 24px; height: 24px; border-radius: 50%; display: grid; place-items: center;
  font-size: 13px; font-weight: 700; color: #0b0d12; }
+.dlpick { position: absolute; right: 6px; top: 6px; padding: 4px; border-radius: 8px; background: rgba(11,13,18,.6); line-height: 0; cursor: pointer; }
+.dlpick input { width: 18px; height: 18px; margin: 0; cursor: pointer; accent-color: var(--accent); }
 .cbadge.ok { background: var(--ok); } .cbadge.warn { background: var(--warn); } .cbadge.bad { background: var(--bad); }

 /* recording check */
@@ -155,6 +157,7 @@ dialog::backdrop { background: rgba(0,0,0,.55); }
  padding: 10px 16px; border-radius: 10px; font-size: 14px; opacity: 0; transition: opacity .2s; pointer-events: none; z-index: 10; }
 .toast.show { opacity: 1; }
 .hidden { display: none !important; }
+.invisible { visibility: hidden; }
 .group { background: var(--panel2); border: 1px solid var(--line); border-radius: 12px; padding: 12px; margin-bottom: 12px; }
 .ghead { display: flex; gap: 14px; flex-wrap: wrap; }
 .gthumb { width: 132px; height: 132px; flex: none; border-radius: 10px; background: #0b0d12 center/cover no-repeat; display: grid; place-items: center; font-size: 44px; }
@@ -166,6 +169,8 @@ dialog::backdrop { background: rgba(0,0,0,.55); }
 .suggest { border: 1px dashed var(--accent); border-radius: 12px; padding: 12px 14px; margin-bottom: 12px; font-size: 13.5px; }
 .suggest .row { margin-top: 8px; }
 dialog.wide { max-width: 560px; }
+.vgrid { display: grid; grid-template-columns: auto 1fr; gap: 8px 14px; align-items: center; font-size: 13.5px; }
+.vgrid label.chk { display: inline-flex; gap: 5px; align-items: center; padding: 4px 9px; border: 1px solid var(--line); border-radius: 8px; }
 dialog select { background: var(--panel2); color: var(--text); border: 1px solid var(--line); border-radius: 8px; padding: 7px 10px; font: inherit; }
 dialog h3 { font-size: 13.5px; margin: 16px 0 8px; }
 .opts { display: grid; gap: 6px; }
@@ -258,10 +263,15 @@ select.lang { font: inherit; font-size: 12.5px; color: var(--muted); background:
      <button class="tab active" data-tab="frame" data-i18n="tab.frame"></button>
      <button class="tab" data-tab="local" data-i18n="tab.local"></button>
      <span style="flex:1"></span>
+      <button class="small hidden" id="dlSelBtn" data-i18n-title="dl.sel.title"></button>
+      <button class="small hidden" id="dlAllBtn" data-i18n-title="dl.all.title"></button>
      <button class="small" id="checkAllBtn" data-i18n="checkAll" data-i18n-title="checkAll.title"></button>
      <button class="small pc-only" id="pickBtn" data-i18n="pick"></button>
      <button class="small" id="refreshBtn" data-i18n-title="refresh.title">↻</button>
    </div>
+    <div id="dlBar" class="hidden" style="display:flex;gap:10px;align-items:center;margin:0 0 12px">
+      <div style="flex:1"><span class="muted" id="dlText"></span><div class="bar"><div id="dlFill" style="width:0"></div></div></div>
+      <button class="small" id="dlCancel" data-i18n="dl.cancel"></button></div>
    <div id="recGrid" class="grid"></div>
    <div id="checkBox" class="hidden"></div>
    <div id="checkRes" class="hidden"></div>
@@ -320,9 +330,22 @@ select.lang { font: inherit; font-size: 12.5px; color: var(--muted); background:
      <h2 data-i18n="scenes.title" style="margin:0"></h2>
      <div class="row"><button class="small" id="groupNewBtn" data-i18n="grp.new" data-i18n-title="grp.new.tip"></button></div>
    </div>
-    <div id="groupSuggest" class="suggest hidden"></div>
-    <div id="groupList"></div>
-    <div id="sceneGrid" class="grid"></div>
+    <div class="tabs" id="sceneTabs">
+      <button class="tab active" data-stab="pc" data-i18n="stab.pc"></button>
+      <button class="tab" data-stab="frame" data-i18n="stab.frame"></button>
+      <button class="small hidden" id="frameRefresh" title="↻" aria-label="↻">↻</button>
+    </div>
+    <div id="pcView">
+      <div id="groupSuggest" class="suggest hidden"></div>
+      <div id="groupList"></div>
+      <div id="sceneGrid" class="grid"></div>
+    </div>
+    <div id="frameView" class="hidden">
+      <p class="faint" style="font-size:12.5px;margin:0 0 12px" data-i18n="fg.hint"></p>
+      <div id="frameMove" class="hidden" style="font-size:12.5px;margin:0 0 12px"><span id="frameMoveText"></span>
+        <button class="small" id="frameMoveBtn" data-i18n="fg.move"></button></div>
+      <div id="frameGrid" class="grid"></div>
+    </div>
  </section>

  <!-- cancelled / failed runs -->
@@ -361,7 +384,9 @@ select.lang { font: inherit; font-size: 12.5px; color: var(--muted); background:
  <h3 data-i18n="cmb.part"></h3>
  <div class="opts" id="cmbPart"></div>
  <h3 data-i18n="cmb.size"></h3>
-  <select id="cmbSize"><option value="2000000" data-i18n="cmb.size.2"></option><option value="3500000" data-i18n="cmb.size.35"></option><option value="5000000" data-i18n="cmb.size.5"></option></select>
+  <div class="row"><select id="cmbSize"></select>
+  <input id="cmbSizeCustom" class="hidden" type="number" min="0.5" max="10" step="0.05" style="width:90px"> <span class="hidden" id="cmbSizeUnit" data-i18n="ver.million"></span></div>
+  <p class="faint" style="font-size:12px;margin:6px 0 0" data-i18n="ver.measured"></p>
  <label class="row" style="margin-top:14px;gap:8px;font-size:13.5px"><input type="checkbox" id="cmbFull"> <span data-i18n="cmb.full"></span></label>
  <p class="faint" id="cmbMem" style="font-size:12.5px;margin:6px 0 0"></p>
  <div id="cmbMemLow" class="msg warn hidden" data-i18n="cmb.mem.low"></div>
@@ -372,6 +397,38 @@ select.lang { font: inherit; font-size: 12.5px; color: var(--muted); background:
  </div>
 </dialog>

+<dialog id="verDlg" class="wide">
+  <h2 style="margin-top:0" id="verTitle"></h2>
+  <p class="muted" style="font-size:13px;margin-top:0" data-i18n="ver.hint"></p>
+  <div id="verList" class="unfin"></div>
+  <h3 data-i18n="ver.new"></h3>
+  <div class="vgrid">
+    <b data-i18n="ver.frame"></b><div class="row" id="verFrame"></div>
+    <b data-i18n="ver.pc"></b><div class="row" id="verPc"></div>
+    <b data-i18n="ver.custom"></b><label class="row" style="gap:6px"><input id="verCustom" type="number" min="0.1" max="50" step="0.05" style="width:90px"> <span data-i18n="ver.million"></span></label>
+    <b class="hidden" id="verScaleHead" data-i18n="ver.scales"></b><div class="row hidden" id="verScales"></div>
+  </div>
+  <p class="faint" style="font-size:12px;margin:12px 0 0" data-i18n="ver.measured"></p>
+  <div class="row" style="justify-content:flex-end;margin-top:16px">
+    <button id="verClose" data-i18n="clean.close"></button>
+    <button class="primary" id="verMake" data-i18n="ver.make"></button>
+  </div>
+</dialog>
+
+<dialog id="scaleDlg">
+  <h2 style="margin-top:0" id="scaleTitle"></h2>
+  <p class="muted" style="font-size:13px;margin-top:0" data-i18n="scale.hint"></p>
+  <div class="opts" id="scaleOpts"></div>
+  <label class="row" style="margin-top:10px;gap:8px;font-size:13.5px">1 : <input id="scaleCustom" type="number" min="1" max="1000" step="any" style="width:110px"></label>
+  <label class="row" id="scaleXrRow" style="flex-wrap:nowrap;align-items:flex-start;margin-top:12px;gap:8px;font-size:13.5px"><input type="checkbox" id="scaleXr" style="margin-top:3px"> <span data-i18n="scale.xr"></span></label>
+  <label class="row hidden" id="scaleMembersRow" style="flex-wrap:nowrap;align-items:flex-start;margin-top:8px;gap:8px;font-size:13.5px"><input type="checkbox" id="scaleMembers" checked> <span data-i18n="scale.members"></span></label>
+  <label class="row hidden" id="scaleFrameRow" style="flex-wrap:nowrap;align-items:flex-start;margin-top:8px;gap:8px;font-size:13.5px"><input type="checkbox" id="scaleFrame" checked> <span data-i18n="scale.frame"></span></label>
+  <div class="row" style="justify-content:flex-end;margin-top:16px">
+    <button id="scaleCancel" data-i18n="grp.cancel"></button>
+    <button class="primary" id="scaleOk" data-i18n="grp.save"></button>
+  </div>
+</dialog>
+
 <dialog id="renDlg">
  <h2 style="margin-top:0" id="renTitle"></h2>
  <p class="muted" id="renHint" style="font-size:13px"></p>
@@ -424,7 +481,7 @@ const PRESETS = {
  high: d => ({frames: clamp(Math.round(d * 5), 100, 500), scale: 1, maxg: 2, iter: 30000}),
  max: d => ({frames: clamp(Math.round(d * 8), 100, 500), scale: 1, maxg: 3, iter: 50000}),
 };
-const S = { tab: "frame", recs: null, sel: null, probe: null, quality: "high", job: null, dl: null, dismissed: null,
+const S = { tab: "frame", recs: null, picked: new Set(), sel: null, probe: null, quality: "high", job: null, dl: null, dismissed: null,
            frameOnline: null, frameConfigured: true };

 function clamp(v, a, b) { return Math.max(a, Math.min(b, v)); }
@@ -516,15 +573,17 @@ function renderRecs() {
    const sel = S.sel && S.sel.name === f.name ? " sel" : "";
    const local = S.tab === "frame" && f.local ? `<span class="badge">${tr("onPc")}</span>` : "";
    const onPc = S.tab === "local" || f.local;
+    const pick = S.tab === "frame" && !f.local && !queued(f.name)
+      ? `<label class="dlpick" title="${tr("dl.pick")}"><input type="checkbox" data-pick="${esc(f.name)}"${S.picked.has(f.name) ? " checked" : ""}></label>` : "";
    const play = onPc ? `<button class="play pc-only" data-play="${esc(f.name)}" title="${tr("play.title")}" aria-label="${tr("play.title")}">${PLAY}</button>` : "";
    return `<div class="rec${sel}" data-i="${i}" role="button" tabindex="0">
-      <div class="thumb" data-src="/api/thumb?source=${onPc ? "local" : "frame"}&name=${encodeURIComponent(f.name)}">${badge(f)}${play}</div>
-      <div class="meta"><b>${esc(f.label || fmtDate(f.date) || f.name)}</b><span>${f.label && f.date ? esc(fmtDate(f.date)) + " · " : ""}${mb(f.size)} ${local}</span></div></div>`;
+      <div class="thumb" data-src="/api/thumb?source=${onPc ? "local" : "frame"}&name=${encodeURIComponent(f.name)}">${badge(f)}${play}${pick}</div>
+      <div class="meta"><b>${esc(f.label || fmtDate(f.date) || f.name)}</b><span>${f.label && f.date ? esc(fmtDate(f.date)) + " · " : ""}${mb(f.size)} ${local}${queued(f.name) ? `<span class="badge">${tr("dl.queued")}</span>` : ""}</span></div></div>`;
  }).join("");
  g.querySelectorAll(".thumb").forEach(t => {
    const url = t.dataset.src, img = new Image();
    img.onload = () => { t.style.backgroundImage = `url(${JSON.stringify(url)})`; };
-    img.onerror = () => { if (!t.querySelector(".play")) t.textContent = "◌"; };
+    img.onerror = () => { if (!t.querySelector(".play")) t.insertAdjacentHTML("afterbegin", "<span>◌</span>"); };
    img.src = url;
  });
  g.querySelectorAll(".rec").forEach(b => {
@@ -532,6 +591,47 @@ function renderRecs() {
    b.onkeydown = e => { if ((e.key === "Enter" || e.key === " ") && e.target === b) { e.preventDefault(); b.click(); } };
  });
  g.querySelectorAll("[data-play]").forEach(b => b.onclick = e => { e.stopPropagation(); play(b.dataset.play); });
+  g.querySelectorAll(".dlpick").forEach(b => { b.onclick = e => e.stopPropagation(); b.onkeydown = e => e.stopPropagation(); });
+  g.querySelectorAll("[data-pick]").forEach(c => c.onchange = () => {
+    c.checked ? S.picked.add(c.dataset.pick) : S.picked.delete(c.dataset.pick); renderDlButtons();
+  });
+  renderDlButtons();
+}
+
+/* ---------- fetching several recordings from the Frame, one after the other ---------- */
+function queued(name) { const d = S.dl; return !!(d && d.busy && ((d.name === name && !d.finished) || (d.queue || []).includes(name))); }
+function fetchable() { return S.recs && S.recs.frame_online ? (S.recs.frame || []).filter(f => !f.local && !queued(f.name)) : []; }
+function renderDlButtons() {
+  const onFrame = S.tab === "frame", all = fetchable();
+  for (const n of [...S.picked]) if (!all.some(f => f.name === n)) S.picked.delete(n);
+  const picked = all.filter(f => S.picked.has(f.name));
+  const size = list => mb(list.reduce((a, f) => a + f.size, 0));
+  $("#dlAllBtn").classList.toggle("hidden", !onFrame || !all.length);
+  $("#dlAllBtn").textContent = "⬇ " + tr("dl.all", {n: all.length, size: size(all)});
+  $("#dlSelBtn").classList.toggle("hidden", !onFrame || !picked.length);
+  $("#dlSelBtn").textContent = "⬇ " + tr("dl.sel", {n: picked.length, size: size(picked)});
+}
+async function fetchMany(list) {
+  if (!list.length) return;
+  const r = await api("/api/download", {names: list.map(f => f.name).join("\n")});
+  if (!r.ok) { toast(trErr(r.error)); return; }
+  S.picked.clear();
+  S.dl = {...(S.dl || {}), busy: true, queue: [...((S.dl && S.dl.queue) || []), ...list.map(f => f.name)]};
+  renderRecs(); renderDlBar();
+}
+$("#dlAllBtn").onclick = () => fetchMany(fetchable());
+$("#dlSelBtn").onclick = () => fetchMany(fetchable().filter(f => S.picked.has(f.name)));
+$("#dlCancel").onclick = async () => {
+  const r = await api("/api/download/cancel", {});
+  if (!r.ok) toast(trErr(r.error));
+};
+function renderDlBar() {
+  const d = S.dl, b = d && d.batch, on = !!(d && d.busy && b && b.files);
+  $("#dlBar").classList.toggle("hidden", !on);
+  if (!on) return;
+  const cur = d.finished ? 0 : d.done || 0, done = (b.done_bytes || 0) + cur;
+  $("#dlText").textContent = tr("dl.progress", {i: Math.min(b.done_files + 1, b.files), n: b.files, done: mb(done), total: mb(b.bytes)});
+  $("#dlFill").style.width = (done / Math.max(b.bytes, 1) * 100).toFixed(1) + "%";
 }
 function badge(f) {
  const lv = f.check || (S.recs?.local.find(x => x.name === f.name) || {}).check;
@@ -573,8 +673,9 @@ function renderCheck() {
    const dl = S.dl && S.dl.name === f.name && !S.dl.finished ? S.dl : null;
    box.innerHTML = dl
      ? `<div style="flex:1"><span class="muted">${tr("probe.fetching", {done: mb(dl.done), total: mb(dl.total)})}</span><div class="bar"><div style="width:${(dl.done / dl.total * 100).toFixed(1)}%"></div></div></div>`
-      : `<span class="muted">${tr("probe.onFrame", {size: mb(f.size)})}</span><button class="small" id="fetchBtn">${esc(tr("probe.fetch"))}</button>`;
+      : `<span class="muted">${tr("probe.onFrame", {size: mb(f.size)})}</span><button class="small" id="fetchBtn">${esc(tr("probe.fetch"))}</button>${delButton(f)}`;
    const b = $("#fetchBtn"); if (b) b.onclick = () => fetchSel();
+    if ($("#delSel")) $("#delSel").onclick = () => deleteRecording(f);
    return;
  }
  const p = S.probe;
@@ -588,13 +689,37 @@ function renderCheck() {
  box.insertAdjacentHTML("afterbegin", `<div class="row" style="order:9;margin-left:auto">
    <button class="small" id="checkSel" title="${tr("check.title")}">${tr("check.run")}</button>
    <button class="small pc-only" id="playSel">${tr("play.button")}</button>
-    ${S.recs?.local.find(x => x.name === f.name)?.renamable ? `<button class="small" id="renSel">${tr("ren.button")}</button>` : ""}</div>`);
+    ${S.recs?.local.find(x => x.name === f.name)?.renamable ? `<button class="small" id="renSel">${tr("ren.button")}</button>` : ""}${delButton(f)}</div>`);
+  if ($("#delSel")) $("#delSel").onclick = () => deleteRecording(f);
  $("#playSel").onclick = () => play(f.name);
  if ($("#renSel")) $("#renSel").onclick = () => renameRecording(f);
  $("#checkSel").onclick = () => runCheck(f.name);
  loadCheck(f.name);
 }

+/* ---------- deleting one recording: on the Frame (for good) or on this PC (trash) ---------- */
+function delWhere(f) {
+  if (f.source === "frame") return S.recs && S.recs.frame_online && !queued(f.name) ? "frame" : null;
+  return S.recs?.local.find(x => x.name === f.name)?.renamable && !queued(f.name) ? "pc" : null;
+}
+function delButton(f) {
+  const where = delWhere(f);
+  return where ? `<button class="small" id="delSel" title="${tr("rdel." + where)}">${tr("rdel." + where)}</button>` : "";
+}
+async function deleteRecording(f) {
+  const where = delWhere(f);
+  if (!where) return;
+  const loc = S.recs.local.find(x => x.name === f.name), orig = loc ? loc.orig : f.name;
+  const other = where === "frame" ? !!(f.local || loc) : !!(S.recs.frame || []).find(x => x.name === orig);
+  const name = f.label || fmtDate(f.date) || f.name;
+  if (!confirm(tr(`rdel.confirm.${where}${other ? "" : ".only"}`, {name, size: mb(f.size)}))) return;
+  const r = await api("/api/recording/delete", {name: f.name, where});
+  if (!r.ok) { toast(trErr(r.error)); return; }
+  toast(tr("rdel.done." + where, {name}));
+  S.sel = null; S.probe = null; $("#checkRes").className = "hidden";
+  renderCheck(); updateStart(); loadRecs(true);
+}
+
 /* ---------- recording check ---------- */
 const TL_COLOR = {ok: "var(--ok)", flat: "var(--warn)", dark: "#6b5cff", fast: "#ff8fd0", eye: "var(--bad)", over: "#f4f1c9"};
 function mmss(s) { return Math.floor(s / 60) + ":" + String(s % 60).padStart(2, "0"); }
@@ -658,7 +783,8 @@ async function checkAll() {
 async function fetchSel() {
  const r = await api("/api/download", {name: S.sel.name});
  if (!r.ok) { toast(trErr(r.error)); return false; }
-  S.dl = {name: S.sel.name, done: 0, total: S.sel.size, finished: false};
+  if (!S.dl || !S.dl.busy) S.dl = {name: S.sel.name, done: 0, total: S.sel.size, finished: false, busy: true, queue: []};
+  else S.dl.queue = [...(S.dl.queue || []), S.sel.name];
  renderCheck(); updateStart();
  return new Promise(res => { S.dlWait = res; });
 }
@@ -687,7 +813,7 @@ function updateStart() {
  const total = Math.round(train + s.frames * 2.5 / 60 + 1);
  const busy = S.job && S.job.running;
  const ready = S.sel && (!S.probe || S.probe.ok) && $("#name").value.trim();
-  $("#startBtn").disabled = !ready || busy || (S.dl && !S.dl.finished);
+  $("#startBtn").disabled = !ready || busy || !!(S.sel && queued(S.sel.name));
  $("#estimate").innerHTML = busy ? tr("est.busy") : !S.sel ? tr("est.none") :
    tr("est", {frames: s.frames, maxg: num(s.maxg, 1), iter: s.iter / 1000, mins: total});
 }
@@ -697,8 +823,8 @@ document.querySelectorAll("#quality button").forEach(b => b.onclick = () => {
 document.querySelectorAll("input[name=target]").forEach(r => r.onchange = () => { S.targetTouched = true; targetChanged(); });
 ["frames", "scale", "maxg", "iter"].forEach(id => $("#" + id).oninput = updateStart);
 $("#name").oninput = () => { $("#name").dataset.auto = "0"; updateStart(); };
-function setTab(tab) { S.tab = tab; document.querySelectorAll(".tab").forEach(x => x.classList.toggle("active", x.dataset.tab === tab)); }
-document.querySelectorAll(".tab").forEach(t => t.onclick = () => { setTab(t.dataset.tab); renderRecs(); });
+function setTab(tab) { S.tab = tab; document.querySelectorAll(".tab[data-tab]").forEach(x => x.classList.toggle("active", x.dataset.tab === tab)); }
+document.querySelectorAll(".tab[data-tab]").forEach(t => t.onclick = () => { setTab(t.dataset.tab); renderRecs(); });
 $("#refreshBtn").onclick = () => loadRecs(true);
 $("#pickBtn").onclick = async () => {
  const r = await api("/api/pick", {});
@@ -750,11 +876,14 @@ function renderJob() {
  $("#jobName").textContent = j.name;
  const qk = QUALITY_ALIAS[j.quality] || j.quality, combine = j.kind === "combine";
  const target = tr(j.upload ? "job.toFrame" : "job.pcOnly"), time = mins(Date.now() / 1000 - j.started);
-  $("#jobSub").textContent = combine ? tr("job.sub.combine", {n: j.rooms, align: ALIGN_LETTER[j.quality] || "?", target, time})
+  const versions = j.kind === "versions";
+  $("#jobSub").textContent = versions ? tr("job.sub.versions", {n: (j.steps || []).length, time})
+                           : combine ? tr("job.sub.combine", {n: j.rooms, align: ALIGN_LETTER[j.quality] || "?", target, time})
                                     : tr("job.sub", {rec: j.recording, q: tr("q." + qk), target, time});
  $("#cancelBtn").classList.toggle("hidden", !j.running);
  $("#dismissBtn").classList.toggle("hidden", j.running);
-  const phases = [0, 1, 2, 3, 4].slice(0, j.upload ? 5 : 4).map(i => tr((combine && i < 4 ? "cphase." : "phase.") + i));
+  const phases = versions ? (j.steps || [])
+               : [0, 1, 2, 3, 4].slice(0, j.upload ? 5 : 4).map(i => tr((combine && i < 4 ? "cphase." : "phase.") + i));
  const finished = !j.running && j.result === "ok";
  $("#steps").style.gridTemplateColumns = `repeat(${phases.length}, 1fr)`;
  $("#steps").innerHTML = phases.map((p, i) => {
@@ -821,8 +950,9 @@ function sceneCard(s) {
      <div class="meta"><b>${esc(s.name)}</b>
        <span>${new Date(s.mtime * 1000).toLocaleDateString(LANG)} · ${s.gaussians ? tr("sc.splats", {n: num(s.gaussians / 1e6, 2)}) + " · " : ""}${mb(s.size)}</span>
        ${s.disk ? `<span class="faint">${tr("sc.disk", {size: mb(s.disk.total)})}</span>` : ""}
+        ${scaleLine(s)}
        ${s.replacing ? `<div class="fstate faint">${tr("sc.replacing")}</div>` : frameState(s)}
-        <div class="acts${s.replacing ? " hidden" : ""}">${uploadBtn(s)}${s.ply ? `<button class="small" data-plan="${esc(s.slug)}">${tr("sc.plan")}</button>` : ""}<button class="small pc-only" data-open="${esc(s.slug)}">${tr("sc.folder")}</button>${s.ply ? `<button class="small pc-only" data-spirula="${esc(s.slug)}" title="${tr("sc.spirula.title")}">${tr("sc.spirula")}</button>` : ""}<button class="small" data-rename="${esc(s.slug)}">${tr("ren.button")}</button><button class="small" data-clean="${esc(s.slug)}" title="${tr("sc.clean.title")}" aria-label="${tr("sc.clean.title")}">${tr("sc.clean")}</button><button class="small" data-delete="${esc(s.slug)}" title="${tr("sc.delete.title")}" aria-label="${tr("sc.delete.title")}">${tr("sc.delete")}</button></div>
+        <div class="acts${s.replacing ? " hidden" : ""}">${uploadBtn(s)}${s.ply ? `<button class="small" data-plan="${esc(s.slug)}">${tr("sc.plan")}</button>` : ""}<button class="small pc-only" data-open="${esc(s.slug)}">${tr("sc.folder")}</button>${s.ply ? `<button class="small pc-only" data-spirula="${esc(s.slug)}" title="${tr("sc.spirula.title")}">${tr("sc.spirula")}</button>` : ""}<button class="small" data-rename="${esc(s.slug)}">${tr("ren.button")}</button><button class="small" data-scale="${esc(s.slug)}" title="${tr("scale.button.title")}">📏${s.scale !== 1 ? " " + ratioText(s.scale) : ""}</button><button class="small" data-versions="${esc(s.slug)}" title="${tr("ver.button.title")}">${tr("ver.button", {n: s.versions || 0})}</button><button class="small" data-clean="${esc(s.slug)}" title="${tr("sc.clean.title")}" aria-label="${tr("sc.clean.title")}">${tr("sc.clean")}</button><button class="small" data-delete="${esc(s.slug)}" title="${tr("sc.delete.title")}" aria-label="${tr("sc.delete.title")}">${tr("sc.delete")}</button></div>
      </div></div>`;
 }
 const ALIGN_LETTER = {frame: "A", images: "B", shift: "C", rigid: "D"};
@@ -854,6 +984,7 @@ function groupBlock(g, bySlug) {
      <div class="gthumb" ${thumb}>${r && r.preview ? "" : "📁"}</div>
      <div class="gmeta"><b>📁 ${esc(g.name)}</b>
        <span>${tr("grp.rooms", {n: rooms.length})} · ${tr("sc.disk", {size: mb(disk)})}</span>
+        ${scaleLine(g)}
        ${tour}${busy}
        <div class="acts">
          <button class="small" data-gtoggle="${esc(g.slug)}" aria-expanded="${open}">${tr(open ? "grp.hide" : "grp.show", {n: rooms.length})}</button>
@@ -863,6 +994,8 @@ function groupBlock(g, bySlug) {
          ${r && r.ply ? `<button class="small pc-only" data-spirula="${esc(g.slug)}" title="${tr("sc.spirula.title")}">${tr("sc.spirula")}</button>` : ""}
          ${r ? `<button class="small pc-only" data-open="${esc(g.slug)}">${tr("sc.folder")}</button>` : ""}
          <button class="small" data-gedit="${esc(g.slug)}">${tr("grp.edit")}</button>
+          <button class="small" data-scale="${esc(g.slug)}" title="${tr("scale.button.title")}" ${g.busy ? "disabled" : ""}>📏${g.scale !== 1 ? " " + ratioText(g.scale) : ""}</button>
+          ${r && r.ply ? `<button class="small" data-versions="${esc(g.slug)}" title="${tr("ver.button.title")}">${tr("ver.button", {n: g.versions || 0})}</button>` : ""}
          <button class="small" data-clean="${esc(g.slug)}" title="${tr("grp.clean.title")}" aria-label="${tr("grp.clean.title")}" ${g.busy ? "disabled" : ""}>${tr("sc.clean")}</button>
          <button class="small" data-gdelete="${esc(g.slug)}" title="${tr("grp.delete.title")}" aria-label="${tr("grp.delete.title")}">${tr("sc.delete")}</button>
        </div>
@@ -894,12 +1027,14 @@ async function loadScenes() {
  $("#sceneGrid").innerHTML = loose.length ? loose.map(sceneCard).join("")
    : S.groups.length ? "" : `<div class="empty" style="grid-column:1/-1">${tr("scenes.none")}</div>`;
  document.querySelectorAll("[data-gtoggle]").forEach(b => b.onclick = () => { groupOpen(b.dataset.gtoggle, !groupOpen(b.dataset.gtoggle)); loadScenes(); });
+  document.querySelectorAll("[data-scale]").forEach(b => b.onclick = () => openScale(b.dataset.scale));
+  document.querySelectorAll("[data-versions]").forEach(b => b.onclick = () => openVersions(b.dataset.versions));
  document.querySelectorAll("[data-gedit]").forEach(b => b.onclick = () => openGroupDlg(S.groups.find(g => g.slug === b.dataset.gedit)));
  document.querySelectorAll("[data-gdelete]").forEach(b => b.onclick = () => deleteGroup(S.groups.find(g => g.slug === b.dataset.gdelete)));
  document.querySelectorAll("[data-combine]").forEach(b => b.onclick = () => openCombine(S.groups.find(g => g.slug === b.dataset.combine)));
  document.querySelectorAll("[data-gplan]").forEach(b => b.onclick = () => {
    const g = S.groups.find(x => x.slug === b.dataset.gplan);
-    openPlan(g.members.filter(m => bySlug[m] && bySlug[m].ply), g.name);
+    openPlan(g.members.filter(m => bySlug[m] && bySlug[m].ply), g.name, g.slug);
  });
  document.querySelectorAll("[data-upload]").forEach(b => b.onclick = async () => {
    const r = await api("/api/upload", {slug: b.dataset.upload});
@@ -989,7 +1124,13 @@ function openCombine(g) {
  radios("#cmbAlign", "cmb.align", ["frame", "images", "shift", "rigid"], o.align || "images");
  radios("#cmbPart", "cmb.part", ["view", "nearest"], o.partition || "view");
  $("#cmbTitle").textContent = tr("cmb.title", {name: g.name});
-  $("#cmbSize").value = String(o.frame_splats || 3500000);
+  const last = o.frame_splats || 1000000, known = FRAME_SIZES.some(m => m * 1e6 === last);
+  $("#cmbSize").innerHTML = FRAME_SIZES.map(m => `<option value="${m * 1e6}">${sizeText(m)}${m === FRAME_RECOMMENDED ? " " + tr("ver.recommended") : ""}</option>`).join("")
+    + `<option value="custom">${tr("ver.custom")}</option>`;
+  $("#cmbSize").value = known ? String(last) : "custom";
+  $("#cmbSizeCustom").value = known ? "" : last / 1e6;
+  const showCustom = () => ["#cmbSizeCustom", "#cmbSizeUnit"].forEach(id => $(id).classList.toggle("hidden", $("#cmbSize").value !== "custom"));
+  $("#cmbSize").onchange = showCustom; showCustom();
  // memory, measured on six rooms: reduce ~0.45 GB per million splats, full SOG ~0.65 GB per million
  const total = (g.splats || 0) * 0.85 / 1e6, needFrame = Math.max(1.5, 0.45 * total), needFull = Math.max(needFrame, 0.65 * total);
  const avail = S.memGB || 0, lowFull = avail && needFull > avail;
@@ -1003,7 +1144,7 @@ function openCombine(g) {
  $("#cmbCancel").onclick = () => $("#combineDlg").close();
  $("#cmbStart").onclick = async () => {
    const r = await api("/api/combine", {slug: g.slug, align: $("input[name='cmb.align']:checked").value,
-      partition: $("input[name='cmb.part']:checked").value, frame_splats: $("#cmbSize").value,
+      partition: $("input[name='cmb.part']:checked").value, frame_splats: $("#cmbSize").value === "custom" ? String(Math.round(parseFloat($("#cmbSizeCustom").value) * 1e6)) : $("#cmbSize").value,
      full: $("#cmbFull").checked, upload: S.frameConfigured && $("#cmbUpload").checked});
    if (!r.ok) { toast(trErr(r.error)); return; }
    $("#combineDlg").close(); toast(tr("cmb.started")); await poll(); loadScenes();
@@ -1011,6 +1152,152 @@ function openCombine(g) {
  };
 }

+/* ---------- what is on the Frame ---------- */
+function setSceneTab(tab) {
+  S.stab = tab;
+  document.querySelectorAll(".tab[data-stab]").forEach(x => x.classList.toggle("active", x.dataset.stab === tab));
+  $("#pcView").classList.toggle("hidden", tab !== "pc");
+  $("#frameView").classList.toggle("hidden", tab !== "frame");
+  $("#frameRefresh").classList.toggle("hidden", tab !== "frame");
+  $("#groupNewBtn").classList.toggle("invisible", tab !== "pc");
+  if (tab === "frame") loadFrameGallery();
+}
+document.querySelectorAll(".tab[data-stab]").forEach(t => t.onclick = () => setSceneTab(t.dataset.stab));
+$("#frameRefresh").onclick = () => loadFrameGallery(true);
+$("#frameMoveBtn").onclick = async () => {
+  const res = await api("/api/frame/move", {});
+  if (!res.ok) { toast(trErr(res.error)); return; }
+  toast(tr("fg.moved")); loadFrameGallery(true); loadScenes();
+};
+async function loadFrameGallery(refresh) {
+  const grid = $("#frameGrid");
+  if (!grid.children.length) grid.innerHTML = `<div class="empty" style="grid-column:1/-1">${tr("fg.loading")}</div>`;
+  const r = await api("/api/frame/gallery" + (refresh ? "?refresh=1" : ""));
+  if (!r.configured) { grid.innerHTML = `<div class="empty" style="grid-column:1/-1">${tr("frame.none")}</div>`; return; }
+  if (!r.online) { grid.innerHTML = `<div class="empty" style="grid-column:1/-1">${tr("frame.unreachable")}</div>`; return; }
+  const list = (r.scenes || []).filter(x => x && x.folder);
+  S.frameGallery = list;
+  const old = list.filter(x => x.place === "steam" && x.kind !== "other").length;
+  $("#frameMove").classList.toggle("hidden", !old);
+  $("#frameMoveText").textContent = tr("fg.move.hint", {n: old}) + " ";
+  grid.innerHTML = list.length ? list.map(x => `
+    <div class="rec scene" style="cursor:default">
+      <div class="thumb" style="background-image:url('/api/frame/preview?folder=${encodeURIComponent(x.folder).replace(/'/g, "%27")}&amp;place=${x.place}&amp;s=${x.size}')"></div>
+      <div class="meta"><b>${esc(x.name)}</b>
+        <span>${tr("fg.kind." + x.kind)} · ${mb(x.size)}</span>
+        <span class="faint" style="overflow-wrap:anywhere" title="${tr("fg.place." + x.place + ".title")}">${tr("fg.place." + x.place)} · ${esc(x.folder)}</span>
+        <div class="acts"><button class="small" data-fgdel="${esc(x.place + "/" + x.folder)}" title="${tr("fg.remove.title")}">🗑 ${tr("fg.remove")}</button></div>
+      </div></div>`).join("") : `<div class="empty" style="grid-column:1/-1">${tr("fg.empty")}</div>`;
+  grid.querySelectorAll("[data-fgdel]").forEach(b => b.onclick = async () => {
+    const x = S.frameGallery.find(y => y.place + "/" + y.folder === b.dataset.fgdel);
+    if (!confirm(tr(x.kind === "other" ? "fg.confirm.other" : "fg.confirm", {name: x.name, size: mb(x.size)}))) return;
+    const res = await api("/api/frame/remove", {folder: x.folder, place: x.place});
+    if (!res.ok) { toast(trErr(res.error)); return; }
+    toast(tr("fg.removed", {name: x.name})); loadFrameGallery(true); loadScenes();
+  });
+}
+
+/* ---------- versions ---------- */
+const FRAME_SIZES = [0.75, 1, 1.5, 2], PC_SIZES = ["all", 3, 5, 8];          // million splats
+const FRAME_RECOMMENDED = 1;   // measured on the Frame: as fast as 0.75 M nearly, clearly sharper; 1.5 M already a little unsteady
+function sizeText(m) { return m === "all" ? tr("ver.all") : tr("million", {n: num(m, Math.round(m * 100) % 10 ? 2 : m % 1 ? 1 : 0)}); }
+async function openVersions(slug) {
+  const g = (S.groups || []).find(x => x.slug === slug), x = g || S.scenes.find(y => y.slug === slug);
+  if (!x) return;
+  const total = (g ? g.result && g.result.splats : x.gaussians) || 0, scale = x.scale || 1;
+  $("#verTitle").textContent = tr("ver.title", {name: x.name, n: tr("million", {n: num(total / 1e6, 2)})});
+  const chk = (val, text, on) => `<label class="chk"><input type="checkbox" value="${val}"${on ? " checked" : ""}> ${text}</label>`;
+  $("#verFrame").innerHTML = FRAME_SIZES.map(m => chk(m, sizeText(m) + (m === FRAME_RECOMMENDED ? " " + tr("ver.recommended") : ""), m === FRAME_RECOMMENDED)).join("");
+  $("#verPc").innerHTML = PC_SIZES.filter(m => m === "all" || m * 1e6 < total).map(m => chk(m, sizeText(m))).join("");
+  $("#verCustom").value = "";
+  $("#verScaleHead").classList.toggle("hidden", scale === 1);
+  $("#verScales").classList.toggle("hidden", scale === 1);
+  $("#verScales").innerHTML = scale === 1 ? "" : `<label class="chk"><input type="checkbox" value="1" checked> ${tr("scale.original")}</label>`
+    + `<label class="chk"><input type="checkbox" value="${scale}"> ${tr("ver.walk", {ratio: ratioText(scale)})}</label>`;
+  await drawVersions(slug);
+  $("#verDlg").showModal();
+  $("#verClose").onclick = () => $("#verDlg").close();
+  $("#verMake").onclick = async () => {
+    const sizes = [...document.querySelectorAll("#verFrame input:checked, #verPc input:checked")]
+      .map(i => i.value === "all" ? "all" : String(Math.round(parseFloat(i.value) * 1e6)));
+    const custom = parseFloat($("#verCustom").value);
+    if (custom > 0) sizes.push(String(Math.round(custom * 1e6)));
+    const scales = scale === 1 ? ["1"] : [...document.querySelectorAll("#verScales input:checked")].map(i => i.value);
+    if (!sizes.length || !scales.length) { toast(tr("ver.pick")); return; }
+    const r = await api("/api/versions", {slug, sizes: sizes.join(","), scales: scales.join(",")});
+    if (!r.ok) { toast(trErr(r.error)); return; }
+    $("#verDlg").close(); toast(tr("ver.started")); await poll();
+    $("#jobCard").scrollIntoView({behavior: "smooth", block: "start"});
+  };
+}
+async function drawVersions(slug) {
+  const r = await api("/api/versions?slug=" + encodeURIComponent(slug));
+  const list = r.versions || [];
+  $("#verList").innerHTML = list.length ? list.map(v => `<div class="row">
+      <b>${esc(v.label)}</b>
+      <span class="muted" style="font-size:12.5px">${tr("million", {n: num(v.splats / 1e6, 2)})} · ${mb(v.size)}${v.stale ? " · " + tr("ver.stale") : ""}</span>
+      <span class="sp"></span>${frameState({upload: v.upload, on_frame: v.on_frame})}
+      ${S.frameConfigured ? `<button class="small" data-vup="${esc(v.key)}" ${v.upload && v.upload.running ? "disabled" : ""}>${tr(v.on_frame ? "sc.reupload" : "sc.toFrame")}</button>` : ""}
+      ${v.on_frame ? `<button class="small" data-vunframe="${esc(v.key)}" title="${tr("ver.unframe.title")}">${tr("ver.unframe")}</button>` : ""}
+      <button class="small" data-vdel="${esc(v.key)}" title="${tr("ver.delete")}" aria-label="${tr("ver.delete")}">${tr("sc.delete")}</button>
+    </div>`).join("") : `<p class="faint" style="font-size:13px;margin:0">${tr("ver.none")}</p>`;
+  $("#verList").querySelectorAll("[data-vup]").forEach(b => b.onclick = async () => {
+    const res = await api("/api/upload", {slug, version: b.dataset.vup});
+    if (!res.ok) { toast(trErr(res.error)); return; }
+    toast(tr("sc.uploadStarted")); setTimeout(() => drawVersions(slug), 1500);
+  });
+  $("#verList").querySelectorAll("[data-vunframe]").forEach(b => b.onclick = async () => {
+    const v = list.find(x => x.key === b.dataset.vunframe);
+    if (!confirm(tr("ver.unframe.confirm", {name: v.label}))) return;
+    const res = await api("/api/frame/remove", {slug, version: v.key});
+    if (!res.ok) { toast(trErr(res.error)); return; }
+    toast(tr("ver.unframed", {name: v.label})); drawVersions(slug);
+  });
+  $("#verList").querySelectorAll("[data-vdel]").forEach(b => b.onclick = async () => {
+    const v = list.find(x => x.key === b.dataset.vdel);
+    if (!confirm(tr("ver.confirm", {name: v.label, size: mb(v.size)}))) return;
+    const res = await api("/api/version/delete", {slug, version: v.key});
+    if (!res.ok) { toast(trErr(res.error)); return; }
+    drawVersions(slug); loadScenes();
+  });
+}
+
+/* ---------- scale (models) ---------- */
+const GAUGES = [[1, "scale.original"], [220, "Z"], [160, "N"], [120, "TT"], [87, "H0"], [64, "S"], [45, "0"], [22.5, "G"]];
+function ratioText(r) { return "1:" + num(r, r % 1 ? 1 : 0); }
+function scaleLine(x) {
+  if (!x.scale || x.scale === 1) return "";
+  return `<span class="faint">${tr("scale.line", {ratio: ratioText(x.scale)})}${x.scale_xr ? " · " + tr("scale.line.xr") : ""}</span>`;
+}
+function openScale(slug) {
+  const g = (S.groups || []).find(x => x.slug === slug), x = g || S.scenes.find(y => y.slug === slug);
+  if (!x) return;
+  const cur = x.scale || 1, known = GAUGES.some(([r]) => r === cur);
+  $("#scaleTitle").textContent = tr("scale.title", {name: x.name});
+  $("#scaleOpts").innerHTML = GAUGES.map(([r, label]) => `<label class="opt${r === cur ? " active" : ""}">
+      <input type="radio" name="scaleR" value="${r}" ${r === cur ? "checked" : ""}><div><b>${r === 1 ? tr(label) : label} · ${ratioText(r)}</b></div></label>`).join("")
+    + `<label class="opt${known ? "" : " active"}"><input type="radio" name="scaleR" value="custom" ${known ? "" : "checked"}><div><b>${tr("scale.custom")}</b></div></label>`;
+  $("#scaleCustom").value = known ? "" : cur;
+  const value = () => { const v = $("input[name=scaleR]:checked").value; return v === "custom" ? parseFloat($("#scaleCustom").value) : parseFloat(v); };
+  const sync = () => { $("#scaleOpts").querySelectorAll(".opt").forEach(l => l.classList.toggle("active", l.querySelector("input").checked));
+                       const one = value() === 1; $("#scaleXr").disabled = one; if (one) $("#scaleXr").checked = false; };
+  $("#scaleOpts").querySelectorAll("input").forEach(i => i.onchange = sync);
+  $("#scaleCustom").oninput = () => { $("input[name=scaleR][value=custom]").checked = true; sync(); };
+  $("#scaleXr").checked = !!x.scale_xr;
+  const onFrame = g ? g.result && g.result.on_frame : x.on_frame;
+  $("#scaleMembersRow").classList.toggle("hidden", !g);
+  $("#scaleFrameRow").classList.toggle("hidden", !(S.frameConfigured && onFrame));
+  sync();
+  $("#scaleDlg").showModal();
+  $("#scaleCancel").onclick = () => $("#scaleDlg").close();
+  $("#scaleOk").onclick = async () => {
+    const r = await api("/api/scale", {slug, scale: String(value()), xr: $("#scaleXr").checked, with_scenes: !!g && $("#scaleMembers").checked,
+                                       update_frame: !$("#scaleFrameRow").classList.contains("hidden") && $("#scaleFrame").checked});
+    if (!r.ok) { toast(trErr(r.error)); return; }
+    $("#scaleDlg").close(); toast(tr("scale.done")); loadScenes();
+  };
+}
+
 /* ---------- renaming ---------- */
 function askName(title, hint, value, frameOption) {
  $("#renTitle").textContent = title; $("#renHint").textContent = hint;
@@ -1084,11 +1371,12 @@ const P = {slugs: [], name: "", style: "pretty"};
 function planUrl(download) {
  const q = new URLSearchParams({slugs: P.slugs.join(","), style: P.style, lang: LANG,
                                  title: P.slugs.length > 1 ? P.name : ""});
+  if (P.group) q.set("group", P.group);
  if (download) { q.set("download", "1"); q.set("name", `${P.name}-${tr("plan.file")}`); }
  return "/api/floorplan?" + q;
 }
-function openPlan(slugs, name) {
-  P.slugs = slugs; P.name = name;
+function openPlan(slugs, name, group) {
+  P.slugs = slugs; P.name = name; P.group = group || "";
  $("#planTitle").textContent = tr(slugs.length > 1 ? "plan.title.all" : "plan.title", {name});
  $("#planStyle").classList.remove("hidden"); $("#planSave").classList.remove("hidden"); $("#planMeasure").classList.remove("hidden");
  if (!$("#planDlg").open) $("#planDlg").showModal();
@@ -1182,12 +1470,23 @@ async function poll() {
  $("#offline").classList.toggle("hidden", !offline);
  document.body.classList.toggle("offline", offline);
  if (offline) return;
+  const wasFetching = !!(S.dl && S.dl.busy), doneFiles = S.dl && S.dl.batch ? S.dl.batch.done_files : 0;
  S.job = r.job; S.dl = r.download;
-  if (S.dl && S.dl.finished && S.dlWait && S.sel && S.dl.name === S.sel.name) {
+  renderDlBar();
+  const nowFetching = !!(S.dl && S.dl.busy);
+  if (wasFetching && (!nowFetching || (S.dl.batch && S.dl.batch.done_files !== doneFiles))) {
+    await loadRecs();
+    if (!nowFetching && S.dl && S.dl.batch) {
+      const b = S.dl.batch, failed = (b.failed || []).length;
+      toast(b.cancelled ? tr("dl.cancelled") : failed ? tr("dl.failed", {n: failed}) : tr("dl.done", {n: b.done_files}));
+    }
+  }
+  // The chosen recording was fetched (also as part of several – the next one may already be on its way)
+  if (S.dlWait && S.sel && !queued(S.sel.name)) {
    const res = S.dlWait; S.dlWait = null;
-    if (S.dl.error) { toast(tr("err.generic") + ": " + S.dl.error); renderCheck(); res(false); }
-    else { await loadRecs(); const f = S.recs.local.find(x => x.name === S.sel.name);
-           if (f) { S.sel.path = f.path; await runProbe(f.path); } res(true); }
+    await loadRecs(); const f = S.recs.local.find(x => x.name === S.sel.name);
+    if (f) { S.sel.path = f.path; await runProbe(f.path); res(true); }
+    else { toast(tr("err.generic") + ": " + ((S.dl && S.dl.name === S.sel.name && S.dl.error) || tr("dl.failed", {n: 1}))); renderCheck(); res(false); }
  } else if (S.dl && !S.dl.finished && S.sel && S.dl.name === S.sel.name) renderCheck();
  renderJob(); updateStart();
  const running = !!(S.job && S.job.running);
Author	SHA1	Message	Date
thunderheronightandClaude Opus 5.5	b5a9b5a0f1	Review fixes: group scale for floor plans, move waits for uploads, more tests Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-14 18:41:34 +02:00
thunderheronightandClaude Opus 5.5	a1f9df0d1f	Delete a single recording on the Frame or on this PC (trash) Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-14 17:35:53 +02:00
thunderheronightandClaude Opus 5.5	bc3345a5aa	Fetch several recordings from the Frame at once (all or a selection, one after the other) Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-14 17:30:21 +02:00
thunderheronightandClaude Opus 5.5	daf6a17241	Scenes go to Gaussian XR's personal scenes folder; 1 M splats recommended for the Frame Documents/GaussianXR is left alone by Steam updates. Old copies in the app's own Scenes folder move over when copied again, or all at once from the On the Frame tab. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-14 16:17:54 +02:00
thunderheronightandClaude Opus 5.5	e69961ad3e	"On the Frame" tab; no backup copies on the Frame any more The tab lists everything in Gaussian XR's gallery on the Frame with its preview image and what it is (scene, tour, version, or not from Splat Workshop) and takes any of it off the Frame. Scenes are copied straight into the gallery; copies left in Documents/GaussianSplats go along with their scene. The tour dialog offers 0.75–2 M or an own size. 250 tests. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-14 14:40:16 +02:00
thunderheronightandClaude Opus 5.5	dfaa6a4a1c	Versions: take a version off the Frame (its gallery folder and backup copy, nothing else) Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-14 14:32:10 +02:00
thunderheronightandClaude Opus 5.5	7e64f039d6	Versions: several sizes and scales of a scene or tour side by side, each copyable to the Frame For the Frame 0.75 / 1 / 1.5 / 2 M, for the PC all / 3 / 5 / 8 M, plus an own size; with a scale also walkable in the original's size. Every version is a complete scene in <run>/versions/<key>/ and gets its own scene folder on the Frame, so e.g. 0.75 M and 2 M can be compared in the gallery. The tour dialog offers 0.75–2 M or an own size for its Frame version. Measured frame rates are shown as information only. 14 new tests (240 in all). Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-14 14:15:44 +02:00
thunderheronightandClaude Opus 5.5	fb1c0ff515	0.2.3: scale for models (e.g. a model railway), for scenes and groups Floor plan, sizes, scale bar and measuring tool in the original's size; the floor plan measures walls and floors in the model's scale. Optionally Gaussian XR's worldScale is set when copying to the Frame (not tested on the Frame yet). The floor plan no longer fails without walls. 13 new tests (226 in all). Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-14 13:44:10 +02:00
thunderheronightandClaude Opus 5.5	fd8cd8dbb3	Tests, second review round: no desktop actions or silent exits from broken code; last gaps - Fakes for kdialog, zenity and xdg-open; every test catches shutdown/os._exit - Broken download, frame folder found on rename, nested values in non-text fields, Start over from the cancelled runs, the watcher's notification and tidying up (watcher split into watch_once for that) - Fake pipeline refuses to continue an unfinished extraction, like the real one 213 tests, every mutation of both review rounds is caught. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-14 13:22:52 +02:00
thunderheronightandClaude Opus 5.5	da00372c5a	0.2.2: tests hardened after an independent review; strict types for all text fields 206 tests instead of 57; every surviving mutation of the review is caught now. New fakes for ffprobe, ssh/scp (the Frame as a folder) and notify-send; synthetic rooms with tracking noise, scale error, turned splats, tracking turn and an adjustable walk-in. Fixed: wrongly typed members/key/align/partition gave a 500 or were stored. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-14 12:52:56 +02:00
thunderheronightandClaude Opus 5.5	a8a6aa5188	0.2.1: automated tests and GitHub Actions; a cancelled job only ends with its last process 57 tests without GPU, recordings or Frame: fake pipeline, fake splat-transform and trash, and synthetic rooms with a known error for putting rooms together. Found on the way: after cancelling, the job counted as finished when systemd-inhibit ended, while splat.sh was still putting the previous scene back – pid_alive now looks at the whole process group. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-14 12:22:30 +02:00
thunderheronightandClaude Opus 5.5	49124eacc8	README: "No root, no jailbreak" badges and note, release badge Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-14 12:03:28 +02:00
thunderheronightandClaude Opus 5.5	4f339b2150	README: screenshots of groups and tours (example data, placeholder art) Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-14 11:58:52 +02:00