0.4.2

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Unfold groups and versions at once; Frame listing renewed in the background; version upload off while the Frame is offline
2026-10-18 16:01:32 +02:00 · 2026-10-15 16:43:38 +02:00 · 2026-10-15 16:42:36 +02:00 · 2026-10-15 16:26:02 +02:00 · 2026-10-15 16:23:38 +02:00 · 2026-10-15 16:06:01 +02:00
20 changed files with 1285 additions and 119 deletions
@@ -2,6 +2,49 @@

 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.4.2] – 2026-10-15
+
+### Fixed
+
+- **Unfolding recordings or versions sometimes did nothing**: every click loaded the whole scene list again, which took about 3 seconds while the Frame was switched off – clicking again in that time folded it back. Now it opens and closes at once, and an expired listing of the Frame is renewed in the background instead of holding up the scene list.
+- **"To the Frame" on a version** could be clicked while the Frame was not reachable; now it is greyed out like the one on the scene.
+
+## [0.4.1] – 2026-10-15
+
+Setup made clearer – thanks to the first two issues from outside (#1, #2).
+
+### Fixed
+
+- **A typo in the config is pointed out**: a setting Splat Workshop does not know – such as `splat-transform =` instead of `splat_transform =` – used to be ignored silently, so splat-transform stayed "not found" without a reason. Now the setup hints name it, with the right spelling. `install.sh` does too.
+- **splat-transform on the shell's PATH only**: `install.sh` checked the PATH of the shell it runs in, but Splat Workshop, started from the desktop or the tray, does not read `.bashrc`/`.zshrc` – the installer said ✓, the app said "not found". Now `install.sh` writes the full path into a new config, or prints the line to add to an existing one; the hint in the app explains why and how.
+- **The npm instructions** in the setup guide installed into a folder whose path did not match the one given for the config. Now: `npm install -g --prefix ~/arcturus/node @playcanvas/splat-transform` (no root needed) and `~/arcturus/node/bin/splat-transform`.
+- **The Arcturus pipeline and PyAV 19** ("unexpected keyword argument 'metadata_errors'"): Splat Workshop now spots a pipeline that is not pinned to PyAV below 19 before you start, and names the cause and the fix when a conversion fails because of it – instead of only a traceback. It does not change the pipeline itself.
+
+## [0.4.0] – 2026-10-15
+
+### Added
+
+- **Clean up a version** (experimental): in the versions dialog, four sliders from *off* to 100 % – the scene itself stays as it is, only the new version is cleaned up, so it can be compared side by side with one without (e.g. *all splats* for the PC).
+  - **Ceiling**: a white ceiling gives the reconstruction nothing to hold on to – it stays thin, with a dark veil under it. Takes out the veil (deeper with more strength; dark things within 50 cm of a wall, like a cupboard top or a bird cage, stay) and what lies above the ceiling, and puts in a closed ceiling in the colour of what there is of it. The ceiling's height is found where walls and ceiling meet. In a real living room: the veil of about 210,000 splats gone, the ceiling closed with 72,000.
+  - **Floor**: fills holes in the floor in the colour of the floor around them, and takes out what lies under it.
+  - **Haze**: takes out big, nearly transparent blobs floating in the room – measured by their *smallest* axis, so long thin things (the bars of a bird cage, cables) are no haze and stay.
+  - **Edges**: takes out what lies well outside the room – beyond the walls, above the ceiling, under the floor.
+  - Also on the command line: `scripts/clean.py`.
+- **The versions dialog, reworked** – by purpose instead of by size: *for the Frame* (one size, each with its frame rate as measured: 0.75 M ≈ 36 fps, 1 M ≈ 35 fps and clearly sharper, 1.5 M ≈ 29 fps, 2 M ≈ 24 fps) or *for the PC* (all splats). One version per click, optionally the same *without cleaning up* next to it to compare. Before making, the dialog shows what it will make – and when that replaces an existing version.
+  - Versions are named by what was cleaned up and how strongly (*all splats · ceiling 50 % · haze 30 %*), so two tries never look alike.
+  - **As template** takes a version's settings into the form: change one slider and make the next.
+  - A cleaned version for the PC keeps its own file for **Spirula Studio** and opens there with one click.
+  - **Versions unfold under their scene or tour** (*▸ 3 versions*), with Spirula, copying to the Frame (with a warning above 2.5 M splats), template and delete.
+  - **Tidier action bars** on scenes and tours: what you do (put together, copy to the Frame) – what you look at (Spirula, floor plan, folder) – what you change (rename, scale, clean up, delete, as icons with tooltips); the unfolding lists (*▸ 3 recordings*, *▸ 1 version* or *＋ Versions …*) on a line of their own. One versions button instead of two.
+  - The PC sizes 3, 5 and 8 M are gone – on the PC all splats is what counts; any other size goes through *own size*.
+- `scripts/freespace.py` (experimental, command line only): takes out splats in space the cameras looked through, from the recordings' sparse models. On a real living room it found only 0.4 % – white walls and ceilings have too few points to tell – but looked a little better; kept for trying.
+
+## [0.3.1] – 2026-10-15
+
+### Fixed
+
+- **Folder names without a dot at the end**: a name like "Tour 12.10." gave the folder `Tour-12.10.`, which Windows file systems (NTFS, e.g. a second disk the runs are moved to) refuse – the copy silently lacked that tour. Now it is `Tour-12.10`. Existing folders keep their names.
+
 ## [0.3.0] – 2026-10-15

 ### Added
@@ -113,6 +156,10 @@ First release.
 - **Floor plans** (experimental) in two styles with a measuring tool.
 - Configurable video player; English and German interface.

+[0.4.2]: https://github.com/thunderheronight/splat-workshop/compare/v0.4.1...v0.4.2
+[0.4.1]: https://github.com/thunderheronight/splat-workshop/compare/v0.4.0...v0.4.1
+[0.4.0]: https://github.com/thunderheronight/splat-workshop/compare/v0.3.1...v0.4.0
+[0.3.1]: https://github.com/thunderheronight/splat-workshop/compare/v0.3.0...v0.3.1
 [0.3.0]: https://github.com/thunderheronight/splat-workshop/compare/v0.2.3...v0.3.0
 [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,0 +1,33 @@
+# Notes for working on Splat Workshop
+
+## Releasing – every release, also a patch
+
+1. Only with the maintainer's explicit OK for each step: push, tag, GitHub release, editing release notes.
+2. `VERSION` in `splat_workshop/server.py`, a `## [x.y.z] – date` section and the compare link in `CHANGELOG.md`.
+3. Tests green locally and in GitHub Actions before tagging.
+4. **Release notes always have this shape** (a patch release too – people who only read the latest
+   release must still see what the series brought):
+   - one bold line: what the series is about, plus what this release adds;
+   - the screenshot (`docs/groups.png`, example data only);
+   - `## Highlights of x.y` – the highlights of the whole minor series, copied from the `x.y.0` release;
+   - a link to the `x.y.0` release for all details;
+   - `## New in x.y.z` – what this release adds or fixes (for `x.y.0` itself: `## New in x.y`);
+   - `**Full changelog:**` compare link to the previous tag.
+   Check the finished notes against this list before publishing.
+
+## Tests
+
+`uv run --no-project --with pytest --with numpy --with scipy --with pillow pytest`
+
+Expectations come from how the synthetic data is built (`tests/synth.py`), not from the code. Tests must
+never touch real data, the Frame or this PC's power state (`systemctl`, `ssh`, `notify-send` are faked).
+
+## Running scripts
+
+`splat.sh`, `to-frame.sh`, `combine.sh`, `versions.sh` run as one `{ … exit; }` block; still, never edit
+one in place while a job uses it – write a new file and `mv` it over.
+
+## File systems
+
+Runs may live on NTFS: no folder or file name may end with a dot or contain `:`; git there needs
+`core.fileMode false`.
@@ -22,6 +22,12 @@ Arcturus Vision stellt die Rekonstruktions-Skripte und einen Spirula-Studio-Fork
 4. **In die Galerie**: Vorschaubild und Namensschild im Stil der Beispielszenen, kopiert in den Ordner für eigene Szenen von Gaussian XR auf der Frame (`Documents/GaussianXR`).
 5. **Die Wohnung zusammensetzen**: Räume gruppieren – ein Raum darf aus mehreren Aufnahmen bestehen – und zu einem Rundgang machen, durch den du gehst, voll für den PC, kleiner für die Frame.

+## Neu in 0.4
+
+- 🧽 **Fassungen bereinigen** *(experimentell)* – vier Schieberegler im Fassungen-Dialog: **Decke** (eine weiße Decke wird zum dunklen Schleier – der Schleier kommt weg, die Decke wird in ihrer eigenen Farbe geschlossen), **Boden** (Löcher gefüllt), **Dunst** (große durchsichtige Wolken; dünne Gitter und Kabel bleiben), **Rand** (was außerhalb des Raums liegt). Die Szene selbst bleibt; die bereinigte Fassung neben einer ohne vergleichen.
+- 🎚️ **Fassungen nach Zweck** – *für die Frame* (eine Größe, mit den auf einer Steam Frame gemessenen fps) oder *für den PC* (alle Splats); auf Wunsch dieselbe ohne Bereinigung daneben; vorher eine Vorschau, was entsteht. Fassungen heißen nach ihren Bereinigungsstärken, *Als Vorlage* übernimmt die Einstellungen für den nächsten Versuch, eine PC-Fassung öffnet sich mit einem Klick in **Spirula Studio**, und Fassungen **klappen unter ihrer Szene oder ihrem Rundgang auf**.
+- 🧭 **Aufgeräumte Knopfleisten** – was du tust, was du anschaust, was du änderst; das Aufklappen in einer eigenen Zeile.
+
 ## Neu in 0.3

 - 🚪 **Räume aus mehreren Aufnahmen** – eine Gruppe als *Ein Raum aus mehreren Aufnahmen* markieren, z. B. zwei kurze Runden durchs Wohnzimmer. Beim Zusammensetzen kommt jeder Teil des Raums aus der Aufnahme, die ihn am besten gesehen hat. Die Arcturus-Pipeline nimmt höchstens 500 Bildpaare pro Aufnahme – mehrere kurze Aufnahmen geben einem Raum also deutlich mehr Detail als eine lange.
@@ -59,7 +65,7 @@ Alle Änderungen: [CHANGELOG.md](CHANGELOG.md) (englisch)
 - **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.
+- **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. Eine Fassung lässt sich auch **bereinigen** *(0.4, experimentell)*: Decke, Boden, Dunst und Rand, jeweils mit eigener Stärke.
 - **Alle holen**: Aufnahmen von der Frame alle oder als Auswahl nacheinander holen – mit einer Benachrichtigung, sobald die Frame aus darf.
 - **Aufnahmen löschen**, einzeln: auf der Frame (mit deutlicher Warnung, wenn sie noch nicht auf dem PC liegt) oder auf dem PC (in den Papierkorb).
 - Reiter **Auf der Frame**: alles, was in der Galerie von Gaussian XR auf der Frame liegt, mit Vorschaubildern – und von dort aufräumen.
@@ -24,6 +24,12 @@ Arcturus Vision publishes the reconstruction scripts and a Spirula Studio fork,
 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 – a room may be several recordings – and turn them into one tour you walk through, full size for the PC, smaller for the Frame.

+## New in 0.4
+
+- 🧽 **Clean up a version** *(experimental)* – four sliders in the versions dialog: **Ceiling** (a white ceiling turns into a dark veil – the veil goes, the ceiling is closed in its own colour), **Floor** (holes filled), **Haze** (big transparent blobs; thin bars and cables stay), **Edges** (what lies outside the room). The scene itself stays; compare the cleaned version with one without.
+- 🎚️ **Versions by purpose** – *for the Frame* (one size, with the frame rate measured on a Steam Frame) or *for the PC* (all splats); optionally the same without cleaning up next to it; a preview of what will be made. Versions are named by their clean-up strengths, *As template* takes a version's settings for the next try, a PC version opens in **Spirula Studio** with one click, and versions **unfold under their scene or tour**.
+- 🧭 **Tidier action bars** – what you do, what you look at, what you change; the unfolding lists on a line of their own.
+
 ## New in 0.3

 - 🚪 **Rooms made of several recordings** – mark a group as *one room made of several recordings*, e.g. two short rounds through the living room. When put together, every part of the room comes from the recording that saw it best. The Arcturus pipeline uses at most 500 image pairs per recording, so several short recordings give a room far more detail than one long one.
@@ -57,7 +63,7 @@ All changes: [CHANGELOG.md](CHANGELOG.md)
 - **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.
+- **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. A version can also be **cleaned up** *(0.4, experimental)*: ceiling, floor, haze and edges, each with its own strength.
 - **Fetch all** recordings from the Frame, or a selection, one after the other – with a notification when the Frame can be switched off.
 - **Delete a recording**, one at a time: on the Frame (with a clear warning if it is not on the PC yet) or on the PC (to the trash).
 - **On the Frame** tab: everything in Gaussian XR's gallery on the Frame with preview images, and taking things off it.
@@ -88,7 +88,15 @@ Wandelt das Ergebnis in das kompakte SOG-Format, das Gaussian XR lädt:
 npm install -g @playcanvas/splat-transform
 ```

-Ohne globale Installation: `npm install --prefix ~/arcturus/node @playcanvas/splat-transform` und in der Config `splat_transform = "~/arcturus/node/bin/splat-transform"` eintragen.
+Scheitert `npm install -g` an fehlenden Rechten, ins eigene Home installieren – ohne root:
+
+```bash
+npm install -g --prefix ~/arcturus/node @playcanvas/splat-transform
+```
+
+und in der Config unter `[paths]` `splat_transform = "~/arcturus/node/bin/splat-transform"` eintragen (mit Unterstrich – `splat-transform =` ist keine Einstellung und wird ignoriert; die Splat-Werkstatt weist darauf hin).
+
+**Immer den vollen Pfad in die Config schreiben**, wenn splat-transform nur im PATH deiner Shell steht (`.bashrc`, `.zshrc`): Vom Desktop oder Tray gestartet liest die Splat-Werkstatt diese Dateien nicht und findet es sonst nicht. `install.sh` trägt die Zeile ein oder gibt sie aus.

 ## 5. Der Splat-Werkstatt sagen, wo alles liegt

@@ -106,7 +114,7 @@ Splat-Werkstatt neu starten (Tray → Beenden, dann wieder starten). Fehlt noch

 | Meldung / Problem | Ursache / Lösung |
 |---|---|
-| `av.open() got an unexpected keyword argument 'metadata_errors'` | PyAV 19 hat diese Option entfernt. Ältere Version festlegen: im `# /// script`-Kopf oben in `av1_to_3dgs.py` und `av1_colmap.py` `"av>=18.1"` in `"av>=18.1,<19"` ändern. (Mit der Pipeline vom Herbst 2026 nötig; neuere Versionen haben es evtl. behoben.) |
+| `av.open() got an unexpected keyword argument 'metadata_errors'` | PyAV 19 hat diese Option entfernt. **Behoben in der Pipeline ab Oktober 2026 (`av1-3dgs-pipeline-faad5aac4.zip`)** – sie kann PyAV 18.1 und 19; einfach die aktuelle herunterladen (danke an [@andzejsp](https://github.com/andzejsp) für den Hinweis, #2). Nur bei einer älteren Pipeline die ältere Version festlegen: im `# /// script`-Kopf oben in `av1_to_3dgs.py` und `av1_colmap.py` `"av>=18.1"` in `"av>=18.1,<19"` ändern. (Mit der Pipeline vom Herbst 2026 nötig; neuere Versionen haben es evtl. behoben.) Die Splat-Werkstatt (ab 0.4.1) weist schon vor dem Start in ihren Einrichtungshinweisen darauf hin und nennt den Grund, falls eine Umwandlung daran scheitert. |
 | `Could not select unique evenly spaced capture instants` | Aufnahme zu kurz. Die Pipeline braucht mindestens 100 Aufnahmezeitpunkte – mindestens 10 Sekunden aufnehmen, besser 30+. |
 | Spirula findet keine GPU / nutzt llvmpipe | Vulkan-Treiber fehlt, siehe Schritt 1. |
 | Die Szene taucht in Gaussian XR nicht auf | Sie muss als echter Ordner (kein Symlink) mit den Galeriebildern in `Scenes/` von Gaussian XR liegen – das macht der Knopf *Auf die Frame*. Ein Steam-Update oder „Dateien überprüfen“ von Gaussian XR kann den Ordner zurücksetzen; dann die Szene einfach neu übertragen. |
@@ -88,7 +88,15 @@ Converts the result into the compact SOG format that Gaussian XR loads:
 npm install -g @playcanvas/splat-transform
 ```

-If you can't or don't want to install globally: `npm install --prefix ~/arcturus/node @playcanvas/splat-transform` and set `splat_transform = "~/arcturus/node/bin/splat-transform"` in the config.
+If `npm install -g` fails with a permission error, install it into your home instead – no root needed:
+
+```bash
+npm install -g --prefix ~/arcturus/node @playcanvas/splat-transform
+```
+
+and set `splat_transform = "~/arcturus/node/bin/splat-transform"` under `[paths]` in the config (with an underscore – `splat-transform =` is not a setting and is ignored; Splat Workshop points that out).
+
+**Always set the full path in the config** if splat-transform is only on the PATH of your shell (`.bashrc`, `.zshrc`): started from the desktop or the tray, Splat Workshop does not read those files and would not find it. `install.sh` writes or prints the line for you.

 ## 5. Tell Splat Workshop where everything is

@@ -106,7 +114,7 @@ Restart Splat Workshop (tray → Quit, then start it again). If something is sti

 | Symptom | Cause / fix |
 |---|---|
-| `av.open() got an unexpected keyword argument 'metadata_errors'` | PyAV 19 removed that option. Pin the older version: in the `# /// script` header at the top of `av1_to_3dgs.py` and `av1_colmap.py`, change `"av>=18.1"` to `"av>=18.1,<19"`. (Was needed with the pipeline from autumn 2026; newer versions may have fixed it.) |
+| `av.open() got an unexpected keyword argument 'metadata_errors'` | PyAV 19 removed that option. **Fixed in the pipeline from October 2026 on (`av1-3dgs-pipeline-faad5aac4.zip`)** – it supports PyAV 18.1 and 19; just download the current one (thanks to [@andzejsp](https://github.com/andzejsp) for spotting it, #2). Only with an older pipeline: pin the older version: in the `# /// script` header at the top of `av1_to_3dgs.py` and `av1_colmap.py`, change `"av>=18.1"` to `"av>=18.1,<19"`. (Was needed with the pipeline from autumn 2026; newer versions may have fixed it.) Splat Workshop (0.4.1 and newer) points this out in its setup hints before you start, and names it if a conversion fails because of it. |
 | `Could not select unique evenly spaced capture instants` | Recording too short. The pipeline needs at least 100 capture instants – record at least 10 seconds, better 30+. |
 | Spirula finds no GPU / uses llvmpipe | Vulkan driver missing, see step 1. |
 | The scene does not appear in Gaussian XR | It must be a real folder in Gaussian XR's `Scenes/` (no symlink) with the gallery images – Splat Workshop's *To the Frame* button does this for you. A Steam update or “verify files” of Gaussian XR can reset that folder; just copy the scene again. |
@@ -26,19 +26,40 @@ for tool in ffmpeg ffprobe uv ssh curl; do
    command -v "$tool" >/dev/null && echo "  ✓ $tool" || { echo "  ✗ $tool"; missing=1; }
 done
 command -v splat-transform >/dev/null && echo "  ✓ splat-transform" ||
-    echo "  ! splat-transform not on PATH (npm install -g @playcanvas/splat-transform, or set it in the config)"
+    echo "  ! splat-transform not on PATH (npm install -g --prefix ~/.local @playcanvas/splat-transform needs no root; or set its path in the config)"
 python3 -c 'import PySide6' 2>/dev/null && echo "  ✓ PySide6 (tray icon)" ||
    echo "  · PySide6 not installed – uv will fetch it on first start for the tray icon"
 [ $missing = 0 ] || echo "Install the missing tools first (see README)."

 mkdir -p "$CONF" "$APPS" "$ICONS"
+created=0
 if [ ! -f "$CONF/config.toml" ]; then
    cp "$ROOT/config.example.toml" "$CONF/config.toml"
-    echo "Created $CONF/config.toml – set the paths to the Arcturus pipeline and Spirula, and your Frame's address."
+    created=1
+    echo "Created $CONF/config.toml from config.example.toml – set the paths to the Arcturus pipeline and Spirula, and your Frame's address."
 else
-    echo "Keeping existing $CONF/config.toml"
+    echo "Keeping existing $CONF/config.toml (all settings with explanations: $ROOT/config.example.toml)"
 fi

+# Started from the desktop, Splat Workshop does not see a PATH set in .bashrc/.zshrc: give it the full path
+st=$(command -v splat-transform || true)
+conf_st=$(python3 -c 'import sys, tomllib
+print(tomllib.load(open(sys.argv[1], "rb")).get("paths", {}).get("splat_transform", ""))' "$CONF/config.toml" 2>/dev/null || true)
+if [ -n "$st" ] && [ -z "$conf_st" ]; then
+    if [ $created = 1 ]; then
+        sed -i "s|^splat_transform = \"\"|splat_transform = \"$st\"|" "$CONF/config.toml"
+        echo "  ✓ splat_transform = \"$st\" written to the config"
+    else
+        echo "  ! Add this line under [paths] in $CONF/config.toml – started from the desktop,"
+        echo "    Splat Workshop does not see the PATH of your shell:"
+        echo "      splat_transform = \"$st\""
+    fi
+fi
+# Settings Splat Workshop does not know (typos such as "splat-transform" instead of "splat_transform")
+(cd "$ROOT" && python3 -c 'from splat_workshop import config
+for key, hint in config.load().unknown:
+    print(f"  ! Unknown setting \"{key}\" in the config" + (f" – did you mean \"{hint}\"?" if hint else " – it is ignored"))') || true
+
 cp "$ROOT/web/icon.svg" "$ICONS/splat-workshop.svg"
 entry() {
    cat <<EOF
@@ -0,0 +1,209 @@
+# /// script
+# requires-python = ">=3.11"
+# dependencies = ["numpy", "scipy", "pillow"]
+# ///
+"""Clean up a finished scene or room: the things a reconstruction of a real room tends to get wrong.
+
+Usage: uv run clean.py <in.ply> <out.ply> [--ceiling S] [--floor S] [--haze S] [--outside S]
+
+Every strength S runs from 0 (off) to 1 (strongest). The room is found as for the floor plan (walls 0.9 to
+1.9 m above the floor, turned to them; Y points down).
+  --ceiling  A white ceiling has no texture: the reconstruction finds nothing to hold on to, leaves the
+             ceiling thin and hangs a dark veil under it. Takes out the veil (dark or thin splats from
+             10 cm to 60 cm under the ceiling – how deep grows with S; dark but solid things like a cupboard
+             top or a bird cage stay if they are within 50 cm of a wall) and everything above the ceiling
+             (found where walls and ceiling meet), and puts in a closed ceiling in the colour of what there
+             is of it nearby.
+  --floor    Fills holes in the floor (where the floor itself has too little: more with S) in the colour of
+             the floor nearby, and takes out what lies under it.
+  --haze     Takes out big, nearly transparent blobs floating in the room. Measured by their *smallest*
+             axis: long thin splats (wires, bars of a cage, cables) are no haze. More with S.
+  --outside  Takes out what lies well outside the room (beyond the walls, above the ceiling, under the
+             floor): from 1 m beyond it (S near 0) to 30 cm (S = 1).
+Prints what it did; the input is never changed.
+"""
+import argparse
+import sys
+from pathlib import Path
+
+import numpy as np
+from scipy.spatial import cKDTree
+
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+import floorplan as F                                              # noqa: E402  (room box, wall angle)
+
+C0 = 0.28209479177387814
+STEP = 0.02                               # grid of a filled ceiling or floor (m)
+
+
+def read_ply(path):
+    with open(path, "rb") as f:
+        header = b""
+        while not header.endswith(b"end_header\n"):
+            line = f.readline()
+            if not line:
+                sys.exit(f"Not a PLY file: {path}")
+            header += line
+        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])
+        v = np.fromfile(f, dtype=np.dtype([(p, "<f4") for p in props]), count=n)
+    return header, v
+
+
+def write_ply(path, header, v):
+    lines = [b"element vertex %d\n" % len(v) if l.startswith(b"element vertex") else l
+             for l in header.splitlines(keepends=True)]
+    tmp = Path(str(path) + ".tmp")
+    with open(tmp, "wb") as f:
+        f.write(b"".join(lines))
+        v.tofile(f)
+    tmp.replace(path)
+
+
+class Room:
+    """Where floor, ceiling and walls are, from the solid splats."""
+    def __init__(self, xyz, alpha):
+        solid = xyz[alpha > 0.5]
+        if len(solid) < 1000:
+            sys.exit("Too few solid splats to find the room")
+        self.floor, _ = F.heights(solid[:, 1])
+        up = self.floor - solid[:, 1]
+        walls = solid[(up > 0.9) & (up < 1.9)][:, [0, 2]]
+        sub = walls[np.random.default_rng(0).choice(len(walls), min(len(walls), 150_000), replace=False)]
+        self.angle = F.wall_angle(sub, 0.03)
+        box = F.room_box(F.rotate(walls, self.angle), 0.05)
+        if box is None:
+            sys.exit("No walls found")
+        self.lo, self.hi = box
+        self.up = self.floor - xyz[:, 1]                       # height above the floor of every splat
+        self.p = F.rotate(xyz[:, [0, 2]], self.angle)         # floor plan position, walls axis-aligned
+
+    def within(self, margin):
+        """Splats inside the walls, `margin` metres away from them (negative: beyond them)."""
+        return np.all((self.p > self.lo + margin) & (self.p < self.hi - margin), axis=1)
+
+    def grid(self):
+        g0, g1 = np.meshgrid(np.arange(self.lo[0], self.hi[0], STEP), np.arange(self.lo[1], self.hi[1], STEP),
+                             indexing="ij")
+        return np.stack([g0.ravel(), g1.ravel()], 1)
+
+
+def layer(room, v, at, cells, ref, rgb, alpha):
+    """Flat splats (3 cm wide, 2 mm thick) at height `at` above the floor in the floor plan cells, in the
+    colour of the reference splats `ref` nearby (half of it the overall colour: calm, no blotches)."""
+    overall = np.average(rgb[ref], weights=alpha[ref], axis=0) if ref.any() else np.array([0.8, 0.8, 0.8])
+    col = np.tile(overall, (len(cells), 1))
+    if ref.sum() >= 10:
+        d, j = cKDTree(room.p[ref]).query(cells, k=32, distance_upper_bound=0.5, workers=-1)
+        ok = np.isfinite(d)
+        j = np.where(ok, j, 0)
+        w = np.where(ok, alpha[ref][j] / (0.05 + np.where(ok, d, 1)), 0)
+        near = (w[:, :, None] * rgb[ref][j]).sum(1) / np.maximum(w.sum(1, keepdims=True), 1e-9)
+        col = np.where(w.sum(1, keepdims=True) > 0, 0.5 * near + 0.5 * overall, overall)
+    new = np.zeros(len(cells), dtype=v.dtype)
+    xz = F.rotate(cells, -room.angle)
+    new["x"], new["z"], new["y"] = xz[:, 0], xz[:, 1], room.floor - at
+    for k in range(3):
+        new[f"f_dc_{k}"] = (np.clip(col[:, k], 0, 1) - 0.5) / C0
+    new["opacity"] = np.log(0.98 / 0.02)
+    new["scale_0"] = new["scale_2"] = np.log(0.015)
+    new["scale_1"] = np.log(0.002)                              # flat: y is up/down
+    new["rot_0"] = 1.0
+    return new
+
+
+def ceiling(room, v, rgb, lum, alpha, s):
+    """Height of the ceiling, what to take out (veil, above it), the new ceiling."""
+    inside = room.within(0)
+    # where walls and ceiling meet, solid splats pile up: the strongest line near the walls above 2 m
+    # (the ceiling itself, white and thin, is no good to find it)
+    corner = inside & ~room.within(0.3) & (alpha > 0.5) & (room.up > 2.0) & (room.up < 3.5)
+    if corner.sum() < 100:
+        print("Ceiling: not found, left as it is")
+        return np.zeros(len(v), bool), v[:0]
+    h, edges = np.histogram(room.up[corner], bins=np.arange(2.0, 3.5, 0.02))
+    h = np.convolve(h, [1, 2, 1], "same")
+    # the highest strong line: a cupboard or shelf top by the wall can be strong, too, but lies lower
+    H = float(edges[np.flatnonzero(h >= 0.5 * h.max())[-1]] + 0.01)
+    bright = inside & (lum > 0.3) & (room.up > 2.0)
+    depth = 0.1 + 0.5 * s
+    under = (room.up > H - depth) & (room.up < H - 0.03)
+    veil = under & ((room.within(0.15) & (alpha < 0.3)) | (room.within(0.5) & (lum < 0.3)))
+    above = inside & (room.up > H + 0.05)
+    new = layer(room, v, H, room.grid(), bright & (np.abs(room.up - H) < 0.08), rgb, alpha)
+    print(f"Ceiling {H:.2f} m above the floor: veil ({depth:.2f} m deep) {veil.sum():,} splats and "
+          f"{above.sum():,} above it out, closed with {len(new):,}")
+    return veil | above, new
+
+
+def floor(room, v, rgb, alpha, s):
+    """Holes in the floor filled, what lies under it out."""
+    inside = room.within(0)
+    below = inside & (room.up < -0.05)
+    near = inside & (np.abs(room.up) < 0.04)
+    cells = room.grid()
+    n = (len(np.arange(room.lo[0], room.hi[0], STEP)), len(np.arange(room.lo[1], room.hi[1], STEP)))
+    idx = np.clip(np.floor((room.p[near] - room.lo) / STEP).astype(np.int64), 0, np.array(n) - 1)
+    n0 = n[1]
+    cover = np.bincount(idx[:, 0] * n0 + idx[:, 1], alpha[near], len(cells))
+    # a cell and its neighbours: a floor a centimetre off still counts
+    c2 = cover.reshape(-1, n0)
+    pad = np.pad(c2, 1)
+    around = sum(pad[1 + dx:1 + dx + c2.shape[0], 1 + dy:1 + dy + c2.shape[1]]
+                 for dx in (-1, 0, 1) for dy in (-1, 0, 1)).ravel()
+    hole = around < 1.5 * s
+    new = layer(room, v, 0.0, cells[hole], near & (alpha > 0.3), rgb, alpha)
+    print(f"Floor: {below.sum():,} splats under it out, {hole.sum():,} holes ({100 * hole.mean():.0f} %) filled")
+    return below, new
+
+
+def haze(v, alpha, s):
+    smallest = np.exp(np.stack([v["scale_0"], v["scale_1"], v["scale_2"]], 1).astype(np.float64)).min(1)
+    size, opacity = 0.04 - 0.025 * s, 0.05 + 0.15 * s
+    out = (smallest > size) & (alpha < opacity)
+    print(f"Haze: {out.sum():,} splats out (all axes over {size * 100:.1f} cm, under {opacity * 100:.0f} % opaque)")
+    return out
+
+
+def main():
+    ap = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
+    ap.add_argument("src")
+    ap.add_argument("dst")
+    for k in ("ceiling", "floor", "haze", "outside"):
+        ap.add_argument(f"--{k}", type=float, default=0.0)
+    args = ap.parse_args()
+    for k in ("ceiling", "floor", "haze", "outside"):
+        if not 0 <= getattr(args, k) <= 1:
+            sys.exit(f"--{k} must be between 0 and 1")
+    header, v = read_ply(args.src)
+    xyz = np.stack([v["x"], v["y"], v["z"]], 1).astype(np.float64)
+    alpha = 1 / (1 + np.exp(-v["opacity"].astype(np.float64)))
+    rgb = 0.5 + C0 * np.stack([v["f_dc_0"], v["f_dc_1"], v["f_dc_2"]], 1).astype(np.float64)
+    lum = rgb @ [0.299, 0.587, 0.114]
+    room = Room(xyz, alpha)
+    print(f"Room {room.hi[0] - room.lo[0]:.1f} × {room.hi[1] - room.lo[1]:.1f} m, {len(v):,} splats")
+    drop, added = np.zeros(len(v), bool), []
+    if args.ceiling:
+        d, new = ceiling(room, v, rgb, lum, alpha, args.ceiling)
+        drop |= d
+        added.append(new)
+    if args.floor:
+        d, new = floor(room, v, rgb, alpha, args.floor)
+        drop |= d
+        added.append(new)
+    if args.haze:
+        drop |= haze(v, alpha, args.haze)
+    if args.outside:
+        m = 1.0 - 0.7 * args.outside
+        solid_in = room.up[room.within(0) & (alpha > 0.5)]
+        top = max(np.percentile(solid_in, 99.5), 2.0) if len(solid_in) else 2.5
+        out = ~room.within(-m) | (room.up < -m) | (room.up > top + m)
+        print(f"Outside: {out.sum():,} splats more than {m:.2f} m outside the room out")
+        drop |= out
+    result = np.concatenate([v[~drop], *added])
+    write_ply(args.dst, header, result)
+    print(f"{len(result):,} splats ({drop.sum():,} out, {sum(len(a) for a in added):,} in)")
+
+
+if __name__ == "__main__":
+    main()
@@ -0,0 +1,167 @@
+# /// script
+# requires-python = ">=3.11"
+# dependencies = ["numpy", "scipy"]
+# ///
+"""EXPERIMENTAL, not wired into the interface yet (0.4): splats in space the cameras looked through.
+
+For every (sampled) image: the SfM points it saw give a coarse depth map (per cell the nearest seen
+surface). A splat that projects into such a cell clearly in front of that surface sat in the line of sight
+of a camera that saw something behind it: free space. Removed when enough images say so.
+Usage: freespace.py <scene.ply> <out.ply> <run>[,<run>...] [--every N] [--strength S] [--solid A]
+  <run>     the recordings the scene was made of (their sparse model and the Frame's tracking); the
+            scene must be in their fitted frame, as combine.py makes it (alignment "images")
+  --solid A where the SfM points say nothing (white walls and ceilings), use the splats more opaque than A
+
+First try on a real living room (15.10.2026): only 0.4 % of the splats found, mostly faint ones. The SfM
+points – the only reliable "something is here" – are missing exactly on white surfaces, and the dark veil
+under a white ceiling hangs closer to it (10–35 cm) than this can tell apart; scripts/clean.py --ceiling
+is the tool for that.
+"""
+import argparse
+import json
+import struct
+import sys
+from pathlib import Path
+
+import numpy as np
+from scipy.spatial.transform import Rotation
+
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+import combine as C                                                   # noqa: E402
+
+NP = {0: 3, 1: 4, 2: 4, 3: 5, 4: 8, 5: 8, 6: 12, 7: 5, 8: 4, 9: 5, 10: 12}
+GRID = 48                                   # depth cells per image side
+
+
+def read_cams(path):
+    out = {}
+    with open(path, "rb") as f:
+        n, = struct.unpack("<Q", f.read(8))
+        for _ in range(n):
+            cid, model, w, h = struct.unpack("<iiQQ", f.read(24))
+            out[cid] = (model, w, h, np.array(struct.unpack("<%dd" % NP[model], f.read(8 * NP[model]))))
+    return out
+
+
+def read_images(path):
+    out = []
+    with open(path, "rb") as f:
+        n, = struct.unpack("<Q", f.read(8))
+        for _ in range(n):
+            _, qw, qx, qy, qz, tx, ty, tz, cid = struct.unpack("<i7di", f.read(64))
+            name = b""
+            while (ch := f.read(1)) != b"\0":
+                name += ch
+            k, = struct.unpack("<Q", f.read(8))
+            obs = np.frombuffer(f.read(24 * k), dtype=np.dtype([("x", "<f8"), ("y", "<f8"), ("id", "<i8")]))
+            R = Rotation.from_quat([qx, qy, qz, qw]).as_matrix()
+            out.append((name.decode(), R, np.array([tx, ty, tz]), cid, obs[obs["id"] >= 0].copy()))
+    return out
+
+
+def read_points3d(path):
+    ids, xyz = [], []
+    with open(path, "rb") as f:
+        n, = struct.unpack("<Q", f.read(8))
+        for _ in range(n):
+            pid, x, y, z, _, _, _, e, k = struct.unpack("<Q3d3BdQ", f.read(51))
+            f.seek(8 * k, 1)
+            ids.append(pid)
+            xyz.append((x, y, z))
+    ids = np.array(ids)
+    table = np.full(ids.max() + 1, -1)
+    table[ids] = np.arange(len(ids))
+    return table, np.array(xyz)
+
+
+def project(cam, pc):
+    """Camera coordinates -> pixels (OPENCV_FISHEYE or pinhole); valid only for z > 0."""
+    model, w, h, p = cam
+    x, y = pc[:, 0] / pc[:, 2], pc[:, 1] / pc[:, 2]
+    if model == 5:
+        fx, fy, cx, cy, k1, k2, k3, k4 = p
+        r = np.sqrt(x * x + y * y)
+        th = np.arctan(r)
+        thd = th * (1 + k1 * th**2 + k2 * th**4 + k3 * th**6 + k4 * th**8)
+        s = np.where(r > 1e-9, thd / np.maximum(r, 1e-9), 1.0)
+        return fx * x * s + cx, fy * y * s + cy
+    fx, fy, cx, cy = (p[0], p[0], p[1], p[2]) if model in (0, 2, 3) else p[:4]
+    return fx * x + cx, fy * y + cy
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("src")
+    ap.add_argument("dst")
+    ap.add_argument("runs")
+    ap.add_argument("--every", type=int, default=4)
+    ap.add_argument("--strength", type=float, default=0.5)
+    ap.add_argument("--solid", type=float, default=0.0)
+    args = ap.parse_args()
+    header, v = C.read_ply(Path(args.src))
+    P = np.stack([v["x"], v["y"], v["z"]], 1).astype(np.float64)
+    A = 1 / (1 + np.exp(-v["opacity"].astype(np.float64)))
+    free = np.zeros(len(v), np.int32)
+    seen = np.zeros(len(v), np.int32)
+    for run in args.runs.split(","):
+        run = Path(run)
+        sp = run / "dataset/sparse/0"
+        cams, imgs = read_cams(sp / "cameras.bin"), read_images(sp / "images.bin")
+        table, X = read_points3d(sp / "points3D.bin")
+        # the room's frame: fitted to the Frame's tracking, as combine.py does (alignment "images")
+        ai = json.loads((run / "dataset/main.aiscene").read_text())
+        rec = {f["path"].removeprefix("images/"): np.array(f["worldFromCam"])[:3, 3] for f in ai["frames"]}
+        names = [i[0].replace("\\", "/") for i in imgs]
+        centres = np.array([-i[1].T @ i[2] for i in imgs])
+        both = [k for k, nm in enumerate(names) if nm in rec]
+        fit = C.umeyama(centres[both], np.array([rec[names[k]] for k in both]))
+        # splats into this recording's own frame (inverse of the fit), cameras stay as they are
+        Q = (fit.R.T @ ((P - fit.t) / fit.s).T).T
+        for name, R, t, cid, obs in imgs[::args.every]:
+            cam = cams[cid]
+            _, w, h, _ = cam
+            pts = X[table[obs["id"]]]
+            pc = (R @ pts.T).T + t
+            ok = pc[:, 2] > 0.05
+            cx = np.clip((obs["x"][ok] / w * GRID).astype(int), 0, GRID - 1)
+            cy = np.clip((obs["y"][ok] / h * GRID).astype(int), 0, GRID - 1)
+            depth = np.full(GRID * GRID, np.inf)
+            np.minimum.at(depth, cy * GRID + cx, pc[ok, 2])
+            sc = (R @ Q.T).T + t
+            front = sc[:, 2] > 0.1
+            if args.solid:                      # where SfM saw nothing (a white ceiling): the solid splats
+                so = front & (A > args.solid)
+                us, vs = project(cam, sc[so])
+                ins = (us >= 0) & (us < w) & (vs >= 0) & (vs < h)
+                cs = (np.clip((vs[ins] / h * GRID).astype(int), 0, GRID - 1) * GRID
+                      + np.clip((us[ins] / w * GRID).astype(int), 0, GRID - 1))
+                sd = np.full(GRID * GRID, np.inf)
+                np.minimum.at(sd, cs, sc[so][ins, 2])
+                depth = np.where(np.isfinite(depth), depth, sd)
+            u, vv = project(cam, sc[front])
+            inside = (u >= 0) & (u < w) & (vv >= 0) & (vv < h)
+            idx = np.flatnonzero(front)[inside]
+            cell = (np.clip((vv[inside] / h * GRID).astype(int), 0, GRID - 1) * GRID
+                    + np.clip((u[inside] / w * GRID).astype(int), 0, GRID - 1))
+            d = depth[cell]
+            known = np.isfinite(d)
+            z = sc[idx, 2]
+            seen[idx[known]] += 1
+            margin = 0.15 + 0.1 * d[known]
+            free[idx[known][z[known] < d[known] - margin]] += 1
+        print(run.name, "images used:", len(imgs[::args.every]), flush=True)
+    s = args.strength
+    need = int(round(6 - 4 * s))                      # images that looked through it
+    frac = 0.7 - 0.3 * s                              # of those that saw the place at all
+    drop = (free >= need) & (free >= frac * np.maximum(seen, 1)) & (A < 0.9)
+    print(f"free-space splats: {drop.sum():,} of {len(v):,} ({100 * drop.mean():.1f} %), "
+          f"opacity median {np.median(A[drop]) if drop.any() else 0:.2f}")
+    lines = [b"element vertex %d\n" % (~drop).sum() if l.startswith(b"element vertex") else l
+             for l in header.splitlines(keepends=True)]
+    with open(args.dst, "wb") as f:
+        f.write(b"".join(lines))
+        v[~drop].tofile(f)
+
+
+if __name__ == "__main__":
+    main()
@@ -3,11 +3,13 @@
 # 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>" ...
+# Usage: scripts/versions.sh <run folder> "<key>|<splats>|<scale>|<name plate>[|<clean-up>]" ...
 #   <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"
+#   <clean-up>    optional, e.g. "ceiling=0.5,haze=0.3": cleaned up first (scripts/clean.py; ceiling,
+#                 floor, haze, outside, each 0 to 1), then reduced
 # 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
@@ -39,7 +41,7 @@ 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"
+    IFS='|' read -r key splats scale plate clean <<< "$spec"
    case "$key" in ''|.*|*/*) echo "Unusable version name: $key" >&2; exit 1 ;; esac
    echo "@@ vstep $i $# $key"
    dir=$out/versions/$key
@@ -47,17 +49,40 @@ for spec in "$@"; do
    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
+    from=$src
+    have=$total
+    if [ -n "${clean:-}" ]; then
+        args=()
+        IFS=',' read -ra parts <<< "$clean"
+        for kv in "${parts[@]}"; do
+            k=${kv%%=*} v=${kv#*=}
+            case "$k" in ceiling|floor|haze|outside) ;; *) echo "Unknown clean-up: $k" >&2; exit 1 ;; esac
+            [[ "$v" =~ ^(0(\.[0-9]+)?|1(\.0+)?)$ ]] || { echo "Clean-up strength must be 0 to 1: $kv" >&2; exit 1; }
+            args+=("--$k" "$v")
+        done
+        echo "$key: cleaning up ($clean)"
+        uv run -q "$HERE/clean.py" "$src" "$tmp/clean.ply" "${args[@]}"
+        from=$tmp/clean.ply
+        have=$(python3 -c 'import sys
+with open(sys.argv[1], "rb") as f:
+    print(next(int(l.split()[-1]) for l in f if l.startswith(b"element vertex")))' "$from")
+    fi
+    if [ "$splats" = all ] || [ "$splats" -ge "$have" ]; then
+        echo "$key: all $have splats"
+        "$SPLAT_TRANSFORM" -w "$from" "$tmp/scene.sog"
+        made=$have
    else
-        echo "$key: reducing $total to $splats splats"
-        "$SPLAT_TRANSFORM" -w "$src" --decimate "$splats" "$tmp/reduced.ply"
+        echo "$key: reducing $have to $splats splats"
+        "$SPLAT_TRANSFORM" -w "$from" --decimate "$splats" "$tmp/reduced.ply"
        "$SPLAT_TRANSFORM" -w "$tmp/reduced.ply" "$tmp/scene.sog"
        rm -f "$tmp/reduced.ply"
        made=$splats
    fi
+    if [ -f "$tmp/clean.ply" ] && [ "$splats" = all ]; then
+        mkdir -p "$tmp/spirula"                 # for the PC: Spirula Studio opens the ply
+        mv "$tmp/clean.ply" "$tmp/spirula/scene.ply"
+    fi
+    rm -f "$tmp/clean.ply"
    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
@@ -69,11 +94,14 @@ PY
        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'
+    python3 - "$tmp/version.json" "$key" "$made" "$splats" "$scale" "$plate" "${clean:-}" <<'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)
+path, key, made, target, scale, plate, clean = sys.argv[1:]
+info = {"key": key, "splats": int(made), "target": target, "scale": float(scale), "label": plate,
+        "created": time.time()}
+if clean:
+    info["clean"] = {k: float(v) for k, v in (kv.split("=") for kv in clean.split(","))}
+json.dump(info, open(path, "w"), indent=1)
 PY
    rm -rf "$dir"
    mv "$tmp" "$dir"
@@ -5,7 +5,9 @@ Order: built-in defaults < ~/.config/splat-workshop/config.toml (or $SPLAT_WORKS

 `python3 -m splat_workshop.config --shell` prints the values as shell assignments for scripts/.
 """
+import difflib
 import os
+import re
 import shlex
 import shutil
 import sys
@@ -32,9 +34,47 @@ DEFAULTS = {
 }


+def unknown_keys(data: dict) -> list[tuple[str, str]]:
+    """Settings in the config file that Splat Workshop does not know (e.g. a typo: "splat-transform"),
+    as ("section.key", suggestion or "")."""
+    out = []
+    for section, values in data.items():
+        if section not in DEFAULTS:
+            close = difflib.get_close_matches(section, DEFAULTS, n=1, cutoff=0.6)
+            out.append((section, close[0] if close else ""))
+            continue
+        if not isinstance(values, dict):
+            continue
+        for key in values:
+            if key not in DEFAULTS[section]:
+                close = difflib.get_close_matches(key.replace("-", "_"), DEFAULTS[section], n=1, cutoff=0.6)
+                out.append((f"{section}.{key}", f"{section}.{close[0]}" if close else ""))
+    return out
+
+
+# PyAV 19 removed av.open(metadata_errors=...), which the Arcturus pipeline (autumn 2026) uses
+PYAV_FILES = ("av1_to_3dgs.py", "av1_colmap.py")
+RX_AV_DEP = re.compile(r'^#\s*"av(?P<spec>[^"]*)"', re.M)
+
+
+def pyav_unpinned(pipeline: Path) -> list[str]:
+    """Pipeline scripts that use metadata_errors but allow PyAV 19 or newer."""
+    out = []
+    for name in PYAV_FILES:
+        try:
+            text = (pipeline / name).read_text(errors="replace")
+        except OSError:
+            continue
+        m = RX_AV_DEP.search(text)
+        if "metadata_errors" in text and m and "<19" not in m["spec"].replace(" ", ""):
+            out.append(name)
+    return out
+
+
 class Config:
-    def __init__(self, data: dict, source: Path | None):
+    def __init__(self, data: dict, source: Path | None, unknown=()):
        self.source = source
+        self.unknown = list(unknown)
        base = source.parent if source else Path.home()

        def path(v: str) -> Path:
@@ -63,12 +103,17 @@ class Config:
    def problems(self) -> list[tuple[str, dict]]:
        """Missing prerequisites as (message key, params) for the setup hints in the UI."""
        out = []
+        for key, suggestion in self.unknown:
+            out.append(("setup.unknown_key" if suggestion else "setup.unknown_key.plain",
+                        {"key": key, "suggestion": suggestion, "file": str(self.source)}))
        if not (self.pipeline / "av1_to_3dgs.py").is_file():
            out.append(("setup.pipeline", {"path": str(self.pipeline)}))
+        elif bad := pyav_unpinned(self.pipeline):
+            out.append(("setup.pyav", {"files": ", ".join(bad), "path": str(self.pipeline)}))
        if not os.access(self.spirula, os.X_OK):
            out.append(("setup.spirula", {"path": str(self.spirula)}))
        if not self.splat_transform:
-            out.append(("setup.splat_transform", {}))
+            out.append(("setup.splat_transform", {"file": str(self.source or CONFIG_FILE)}))
        for tool in ("ffmpeg", "ffprobe", "uv"):
            if not shutil.which(tool):
                out.append(("setup.tool", {"tool": tool}))
@@ -76,7 +121,8 @@ class Config:


 def slugify(name: str) -> str:
-    """Folder/file name from a display name: ä→ae etc., accents dropped, only [A-Za-z0-9._-]."""
+    """Folder/file name from a display name: ä→ae etc., accents dropped, only [A-Za-z0-9._-]; no dot or
+    dash at the ends ("Tour 12.10." → Tour-12.10: Windows file systems such as NTFS refuse a trailing dot)."""
    for a, b in (("ä", "ae"), ("ö", "oe"), ("ü", "ue"), ("Ä", "Ae"), ("Ö", "Oe"), ("Ü", "Ue"), ("ß", "ss")):
        name = name.replace(a, b)
    name = unicodedata.normalize("NFKD", name).encode("ascii", "ignore").decode()
@@ -88,7 +134,7 @@ def slugify(name: str) -> str:
        elif not dash:
            out.append("-")
            dash = True
-    return "".join(out).strip("-")
+    return "".join(out).strip("-.")


 def _merge(base: dict, over: dict) -> dict:
@@ -102,12 +148,12 @@ def _merge(base: dict, over: dict) -> dict:


 def load() -> Config:
-    data, source = DEFAULTS, None
+    data, source, unknown = DEFAULTS, None, []
    if CONFIG_FILE.is_file():
        with open(CONFIG_FILE, "rb") as fh:
-            data = _merge(DEFAULTS, tomllib.load(fh))
-        source = CONFIG_FILE
-    return Config(data, source)
+            own = tomllib.load(fh)
+        data, source, unknown = _merge(DEFAULTS, own), CONFIG_FILE, unknown_keys(own)
+    return Config(data, source, unknown)


 def shell(cfg: Config) -> str:
@@ -17,6 +17,7 @@ TEXTS = {
        "notify.standby.title": "Everything done", "notify.standby": "The PC goes to standby in {s} seconds – to stop it, untick “Standby when done” in Splat Workshop.",
        "notify.standby_failed.title": "No standby", "notify.standby_failed": "The PC could not go to standby: {why}",
        "inhibit.versions": "Making versions of “{name}”", "ver.all": "all splats", "ver.size": "{n} M",
+        "ver.clean.ceiling": "ceiling", "ver.clean.floor": "floor", "ver.clean.haze": "haze", "ver.clean.outside": "edges",
        "notify.failed.title": "Conversion failed",
        "notify.failed": "“{name}” – details in Splat Workshop",
        "notify.download.title": "Fetched from the Frame",
@@ -80,6 +81,7 @@ TEXTS = {
        "notify.standby.title": "Alles fertig", "notify.standby": "Der PC geht in {s} Sekunden in den Standby – zum Abbrechen in der Splat-Werkstatt den Haken bei „Danach in den Standby“ entfernen.",
        "notify.standby_failed.title": "Kein Standby", "notify.standby_failed": "Der PC konnte nicht in den Standby: {why}",
        "inhibit.versions": "Erstellt Fassungen von „{name}“", "ver.all": "alle Splats", "ver.size": "{n} Mio.",
+        "ver.clean.ceiling": "Decke", "ver.clean.floor": "Boden", "ver.clean.haze": "Dunst", "ver.clean.outside": "Rand",
        "notify.failed.title": "Umwandlung fehlgeschlagen",
        "notify.failed": "„{name}“ – Details in der Splat-Werkstatt",
        "notify.download.title": "Von der Frame geholt",
@@ -29,7 +29,7 @@ from pathlib import Path
 from . import check, config
 from .i18n import T, detect

-VERSION = "0.3.0"
+VERSION = "0.4.2"
 CFG = config.load()
 ROOT = config.ROOT
 WEB = ROOT / "web"
@@ -176,11 +176,29 @@ def err(code: str, **params) -> dict:
 # ---------------------------------------------------------------- recordings

 def frame_listing(force=False):
-    """Recordings on the Frame (cached). None = no Frame configured or not reachable."""
+    """Recordings on the Frame (cached). None = no Frame configured or not reachable.
+    An expired listing is renewed in the background and the last one answered meanwhile: asking a Frame
+    that is switched off takes seconds, and the scene list (which asks too) would hang that long."""
    if not FRAME:
        return None
    if not force and time.time() - frame_cache["t"] < 20:
        return frame_cache["data"]
+    if not force and frame_cache["t"]:
+        if not frame_cache.get("renewing"):
+            frame_cache["renewing"] = True
+            threading.Thread(target=renew_frame_listing, daemon=True).start()
+        return frame_cache["data"]
+    return read_frame_listing()
+
+
+def renew_frame_listing():
+    try:
+        read_frame_listing()
+    finally:
+        frame_cache["renewing"] = False
+
+
+def read_frame_listing():
    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}; ls {FRAME_STEAM}) 2>/dev/null')
    try:
@@ -594,9 +612,16 @@ def parse_output(text: str) -> dict:
        info["done"] = True
        if d[1] == "frame" and d[2]:
            info["folder"] = d[2]
+    for needle, hint in KNOWN_FAILURES:
+        if needle in text:
+            info["hint"] = hint
    return {"phase": phase, "pct": pct, "eta": eta, "info": info}


+# Failures with a known cause: a line of the pipeline's output -> a hint in the interface (web/i18n.js)
+KNOWN_FAILURES = (("unexpected keyword argument 'metadata_errors'", "hint.pyav"),)
+
+
 def job_status(tail=True) -> dict | None:
    st = load_state().get("job")
    if not st:
@@ -974,10 +999,36 @@ def read_version(vdir: Path) -> dict:
        return {}


-def version_key(splats, scale: float) -> str:
-    """Folder name of a version: 1m, 0.75m, all; with a scale e.g. 1m-1x87."""
+CLEANUPS = ("ceiling", "floor", "haze", "outside")        # scripts/clean.py, each 0 (off) to 1
+
+
+def version_key(splats, scale: float, clean: dict = None) -> str:
+    """Folder name of a version: 1m, 0.75m, all; with a scale e.g. 1m-1x87; cleaned up e.g. all-c50h30."""
    key = "all" if splats == "all" else f"{splats / 1e6:g}m"
-    return key + (f"-1x{scale:g}" if scale != 1 else "")
+    key += f"-1x{scale:g}" if scale != 1 else ""
+    return key + ("-" + "".join(f"{k[0]}{round(v * 100)}" for k, v in clean.items()) if clean else "")
+
+
+def parse_cleanup(raw: str):
+    """"ceiling=0.5,haze=0.3" -> {"ceiling": 0.5, "haze": 0.3}, the ones switched on (0 < S <= 1); or an error."""
+    if not raw:
+        return {}
+    pairs = dict(kv.partition("=")[::2] for kv in raw.split(","))
+    if set(pairs) - set(CLEANUPS):
+        return err("err.bad_value", key="clean")
+    out = {}
+    for k in CLEANUPS:
+        try:
+            v = float(pairs.get(k) or 0)
+        except ValueError:
+            return err("err.bad_value", key=k)
+        if v != v:
+            return err("err.bad_value", key=k)
+        if not 0 <= v <= 1:
+            return err("err.range", key=k, lo=0, hi=1)
+        if v:
+            out[k] = round(v, 2)
+    return out


 def versions_of(slug: str) -> list:
@@ -1000,7 +1051,12 @@ def versions_of(slug: str) -> list:
            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"])
+        clean = info.get("clean") or {}
+        target = info.get("target", "")
        out.append({"key": key, "label": info.get("label"), "splats": info.get("splats"), "scale": info.get("scale", 1),
+                    "clean": clean, "purpose": "pc" if target == "all" else "frame",
+                    # Spirula opens a ply: a cleaned PC version keeps its own, a plain one is the scene's own
+                    "ply": (vdir / "spirula" / "scene.ply").exists() or (target == "all" and not clean and source.exists()),
                    "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}")})
@@ -1039,14 +1095,22 @@ def start_versions(p: dict):
        scales.append(sc)
    if not sizes:
        return err("err.no_versions")
+    clean = parse_cleanup(p.get("clean"))
+    if "code" in clean:
+        return clean
    meta = read_meta(slug)
    name = meta.get("name") or slug
    specs = []
+    # with a clean-up, optionally the same without, to compare side by side
+    variants = [clean, {}] if clean and p.get("also_plain") else [clean]
    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}")
+            for cl in variants:
+                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 "")
+                         + "".join(f" · {t('ver.clean.' + k)} {round(v * 100)} %" for k, v in cl.items()))
+                specs.append(f"{version_key(n, sc, cl)}|{n}|{sc:g}|{plate}"
+                             + ("|" + ",".join(f"{k}={v:g}" for k, v in cl.items()) if cl else ""))
    with lock:
        if (cur := load_state().get("job")) and pid_alive(cur["pid"]):
            return err("err.job_busy")
@@ -2288,7 +2352,7 @@ class Handler(http.server.BaseHTTPRequestHandler):
        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", "members", "key", "version", "sizes", "scales", "folder",
                                                           "names", "place", "where",
-                                                           "align", "partition")):
+                                                           "align", "partition", "clean")):
            return self.send(400, {"error": err("err.bad_request")})
        path = urllib.parse.urlparse(self.path).path
        e = None
@@ -2378,8 +2442,16 @@ class Handler(http.server.BaseHTTPRequestHandler):
            if not d:
                e = err("err.no_scene")
            elif p.get("what") == "spirula":
-                subprocess.Popen([str(CFG.spirula), str(d / "spirula" / "scene.ply")], cwd=d,
-                                 start_new_session=True, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+                ply = d / "spirula" / "scene.ply"
+                if p.get("version"):                    # a version: its own ply, or the scene's for a plain "all"
+                    v = {x["key"]: x for x in versions_of(p.get("slug", ""))}.get(p["version"])
+                    own = d / "versions" / p["version"] / "spirula" / "scene.ply"
+                    ply = own if v and own.exists() else ply if v and v["ply"] else None
+                if ply is None:
+                    e = err("err.no_version")
+                else:
+                    subprocess.Popen([str(CFG.spirula), str(ply)], cwd=ply.parent.parent,
+                                     start_new_session=True, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
            else:
                subprocess.Popen(["xdg-open", str(d)], start_new_session=True,
                                 stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
@@ -0,0 +1,236 @@
+"""Cleaning up a scene (0.4, scripts/clean.py): ceiling, floor, haze, outside – and as part of its versions.
+
+The synthetic room is built so every kind of splat can be told apart afterwards by its colour: a white
+ceiling that the reconstruction left thin, a dark veil under it, a dark cupboard top by the wall, a bird
+cage of long thin bars, fat transparent blobs (haze), a floor with a hole, and things beyond the walls.
+The expectations come from how it is built, not from the code."""
+import json
+import subprocess
+import sys
+
+import numpy as np
+import pytest
+
+from conftest import ROOT, RUNS, server, wait_job
+import synth
+
+CLEAN = ROOT / "scripts" / "clean.py"
+FLOOR, CEILING = 1.6, -0.9                 # y points down: the room is 2.5 m high
+W, D = 4.0, 5.0                            # x and z extent of the room
+WALL, FLOORC, CEILC = (0.6, 0.6, 0.6), (0.45, 0.3, 0.2), (0.85, 0.85, 0.82)
+VEIL, CUPBOARD, CAGE, HAZE, OUT = (0.12, 0.12, 0.13), (0.2, 0.1, 0.05), (0.3, 0.3, 0.35), (0.5, 0.5, 0.9), (0.9, 0.1, 0.9)
+LOGIT = lambda a: float(np.log(a / (1 - a)))
+
+
+def splats(pts, colour, opacity=0.95, scale=(0.02, 0.02, 0.02)):
+    v = np.zeros(len(pts), dtype=np.dtype([(p, "<f4") for p in synth.PROPS]))
+    v["x"], v["y"], v["z"] = np.asarray(pts).T
+    for k in range(3):
+        v[f"f_dc_{k}"] = (colour[k] - 0.5) / 0.28209479177387814
+        v[f"scale_{k}"] = np.log(scale[k])
+    v["opacity"] = LOGIT(opacity)
+    v["rot_0"] = 1.0
+    return v
+
+
+def grid(a0, a1, b0, b1, step):
+    a, b = np.meshgrid(np.arange(a0, a1 + 1e-9, step), np.arange(b0, b1 + 1e-9, step), indexing="ij")
+    return a.ravel(), b.ravel()
+
+
+def room(path):
+    """The living room as a reconstruction of a white ceiling tends to come out."""
+    rng = np.random.default_rng(1)
+    parts = []
+    ys = np.arange(CEILING, FLOOR + 1e-9, 0.04)
+    for x in (0.0, W):                                         # walls
+        z, y = grid(0, D, CEILING, FLOOR, 0.04)
+        parts.append(splats(np.stack([np.full_like(z, x), y, z], 1), WALL))
+    for z in (0.0, D):
+        x, y = grid(0, W, CEILING, FLOOR, 0.04)
+        parts.append(splats(np.stack([x, y, np.full_like(x, z)], 1), WALL))
+    x, z = grid(0, W, 0, D, 0.03)                              # floor with a hole of 1 x 1 m
+    hole = (x > 1.5) & (x < 2.5) & (z > 2.0) & (z < 3.0)
+    parts.append(splats(np.stack([x[~hole], np.full((~hole).sum(), FLOOR), z[~hole]], 1), FLOORC))
+    x, z = grid(0, W, 0, D, 0.12)                              # thin ceiling: little, half transparent ...
+    parts.append(splats(np.stack([x, np.full_like(x, CEILING), z], 1), CEILC, opacity=0.4))
+    x, z = grid(0, W, 0, D, 0.03)                              # ... but solid where it meets the walls
+    edge = (x < 0.25) | (x > W - 0.25) | (z < 0.25) | (z > D - 0.25)
+    parts.append(splats(np.stack([x[edge], np.full(edge.sum(), CEILING), z[edge]], 1), CEILC))
+    n = 4000                                                   # the veil: dark, thin, 10–30 cm under it
+    veil = np.stack([rng.uniform(0.8, W - 0.8, n), CEILING + rng.uniform(0.1, 0.3, n), rng.uniform(0.8, D - 0.8, n)], 1)
+    parts.append(splats(veil, VEIL, opacity=0.2, scale=(0.03, 0.03, 0.03)))
+    x, z = grid(0.05, 0.4, 1.0, 2.0, 0.03)                     # a dark cupboard top at the wall, 2.2 m high
+    parts.append(splats(np.stack([x, np.full_like(x, FLOOR - 2.2), z], 1), CUPBOARD))
+    bars = []                                                  # a bird cage: long thin bars, faint
+    for bx in np.arange(1.8, 2.2, 0.02):
+        for by in np.arange(FLOOR - 2.0, FLOOR - 1.2, 0.08):
+            bars.append((bx, by, 2.5))
+    parts.append(splats(bars, CAGE, opacity=0.15, scale=(0.001, 0.06, 0.001)))
+    n = 300                                                    # haze: fat, transparent blobs in the room
+    blobs = np.stack([rng.uniform(1, 3, n), rng.uniform(FLOOR - 1.6, FLOOR - 0.6, n), rng.uniform(1, 4, n)], 1)
+    parts.append(splats(blobs, HAZE, opacity=0.06, scale=(0.06, 0.06, 0.06)))
+    n = 500                                                    # beyond the walls, seen through the window
+    out = np.stack([rng.uniform(-3, -1.5, n), rng.uniform(FLOOR - 2, FLOOR, n), rng.uniform(0, D, n)], 1)
+    parts.append(splats(out, OUT))
+    v = np.concatenate(parts)
+    header = "ply\nformat binary_little_endian 1.0\nelement vertex %d\n%send_header\n" % (
+        len(v), "".join(f"property float {p}\n" for p in synth.PROPS))
+    path.parent.mkdir(parents=True, exist_ok=True)
+    with open(path, "wb") as f:
+        f.write(header.encode())
+        v.tofile(f)
+    return v
+
+
+def read(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 colour_of(v):
+    return 0.5 + 0.28209479177387814 * np.stack([v["f_dc_0"], v["f_dc_1"], v["f_dc_2"]], 1)
+
+
+def count(v, rgb):
+    return int(np.all(np.abs(colour_of(v) - rgb) < 0.01, axis=1).sum())
+
+
+def clean(tmp_path, *args):
+    src, dst = tmp_path / "in.ply", tmp_path / "out.ply"
+    before = room(src)
+    r = subprocess.run([sys.executable, str(CLEAN), str(src), str(dst), *args], capture_output=True, text=True)
+    assert r.returncode == 0, r.stderr
+    return before, read(dst), r.stdout
+
+
+def test_ceiling_veil_out_ceiling_closed(tmp_path):
+    before, after, out = clean(tmp_path, "--ceiling", "0.5")
+    assert "Ceiling 2.5" in out                                    # found where walls and ceiling meet
+    assert count(after, VEIL) == 0                                 # the veil is gone
+    assert count(after, CUPBOARD) == count(before, CUPBOARD)       # the dark cupboard top by the wall stays
+    assert count(after, CAGE) == count(before, CAGE)               # and the cage, far below the ceiling
+    flat = after[np.isclose(after["y"], CEILING, atol=0.03) & (after["opacity"] > 3)]
+    # closed: a solid layer over the whole room, in the ceiling's own colour
+    assert len(flat) > (W / 0.02) * (D / 0.02) * 0.9
+    assert np.allclose(np.median(colour_of(flat), 0), CEILC, atol=0.05)
+    for k in ("x", "y", "z", "f_dc_0", "opacity", "scale_0"):
+        assert np.isfinite(after[k]).all()
+
+
+def test_floor_holes_filled_in_the_floors_colour(tmp_path):
+    before, after, out = clean(tmp_path, "--floor", "0.5")
+    added = after[len(before):]
+    inside = (added["x"] > 1.6) & (added["x"] < 2.4) & (added["z"] > 2.1) & (added["z"] < 2.9)
+    assert inside.sum() > 0.8 * (0.8 / 0.02) ** 2                  # the hole is closed ...
+    assert len(added) < 1.3 * (1 / 0.02) ** 2                      # ... and little more than the hole
+    assert np.allclose(np.median(colour_of(added), 0), FLOORC, atol=0.05)
+    assert np.allclose(added["y"], FLOOR, atol=0.01)
+
+
+def test_haze_goes_but_not_thin_bars(tmp_path):
+    before, after, _ = clean(tmp_path, "--haze", "1")
+    assert count(after, HAZE) == 0
+    assert count(after, CAGE) == count(before, CAGE)               # long and thin is no haze
+    assert count(after, VEIL) == 0                                 # at full strength the veil is haze, too
+    assert count(after, WALL) == count(before, WALL) and count(after, CUPBOARD) == count(before, CUPBOARD)
+
+
+def test_outside_goes(tmp_path):
+    before, after, _ = clean(tmp_path, "--outside", "1")
+    assert count(after, OUT) == 0 and count(after, WALL) == count(before, WALL)
+
+
+def test_nothing_switched_on_changes_nothing(tmp_path):
+    before, after, _ = clean(tmp_path)
+    assert len(after) == len(before) and np.array_equal(after["x"], before["x"])
+
+
+@pytest.mark.parametrize("args", [["--haze", "2"], ["--ceiling", "-0.1"]])
+def test_strengths_from_0_to_1(tmp_path, args):
+    src = tmp_path / "in.ply"
+    room(src)
+    r = subprocess.run([sys.executable, str(CLEAN), str(src), str(tmp_path / "o.ply"), *args], capture_output=True, text=True)
+    assert r.returncode != 0 and "between 0 and 1" in r.stderr
+
+
+# ---------------------------------------------------------------- as part of the versions
+
+def scene(slug="Living"):
+    run = RUNS / slug
+    (run / "spirula").mkdir(parents=True, exist_ok=True)
+    room(run / "spirula" / "scene.ply")
+    (run / "scene.sog").write_bytes(b"sog")
+    (run / "scene.xrSceneTransform.json").write_text(json.dumps({"worldScale": 1.0}))
+    server.write_meta(slug, name="Living room")
+    return run
+
+
+def test_a_cleaned_version(api):
+    run = scene()
+    total = len(read(run / "spirula" / "scene.ply"))
+    status, r = api.post("/api/versions", {"slug": "Living", "sizes": "all", "clean": "ceiling=0.5,haze=0.3"})
+    assert status == 200, r
+    js = wait_job()
+    assert js["result"] == "ok", js["tail"]
+    v = {x["key"]: x for x in server.versions_of("Living")}
+    assert list(v) == ["all-c50h30"]
+    x = v["all-c50h30"]
+    assert x["clean"] == {"ceiling": 0.5, "haze": 0.3} and x["label"] == "Living room · all splats · ceiling 50 % · haze 30 %"
+    assert x["purpose"] == "pc" and x["ply"]                                 # Spirula Studio can open it
+    info = json.loads((run / "versions" / "all-c50h30" / "version.json").read_text())
+    assert info["splats"] != total                                       # counted after cleaning
+    assert not (run / "versions" / "all-c50h30" / "clean.ply").exists()
+    assert len(read(run / "versions" / "all-c50h30" / "spirula" / "scene.ply")) == info["splats"]
+    assert len(read(run / "spirula" / "scene.ply")) == total               # the scene itself is untouched
+
+
+def test_a_cleaned_and_a_plain_version_side_by_side(api):
+    scene()
+    api.post("/api/versions", {"slug": "Living", "sizes": "all"})
+    wait_job()
+    api.post("/api/versions", {"slug": "Living", "sizes": "all", "clean": "floor=1"})
+    wait_job()
+    assert sorted(x["key"] for x in server.versions_of("Living")) == ["all", "all-f100"]
+
+
+@pytest.mark.parametrize("clean,code", [("roof=0.5", "err.bad_value"), ("haze=2", "err.range"), ("haze=x", "err.bad_value"),
+                                        ("haze=nan", "err.bad_value"), ({"haze": 1}, "err.bad_request")])
+def test_odd_clean_ups_are_refused(api, clean, code):
+    scene()
+    status, r = api.post("/api/versions", {"slug": "Living", "sizes": "all", "clean": clean})
+    assert status == 400 and r["error"]["code"] == code
+
+
+def test_cleaned_and_plain_in_one_go(api):
+    """For the Frame, with and without cleaning up, to compare: two versions, named by their strengths."""
+    run = scene()
+    status, r = api.post("/api/versions", {"slug": "Living", "sizes": "20000", "clean": "haze=0.4", "also_plain": True})
+    assert status == 200, r
+    assert wait_job()["result"] == "ok"
+    v = {x["key"]: x for x in server.versions_of("Living")}
+    assert set(v) == {"0.02m", "0.02m-h40"}
+    assert v["0.02m-h40"]["label"] == "Living room · 0.02 M · haze 40 %" and v["0.02m"]["label"] == "Living room · 0.02 M"
+    assert all(x["purpose"] == "frame" and not x["ply"] for x in v.values())   # Frame versions keep no ply
+    assert not (run / "versions" / "0.02m-h40" / "spirula").exists()
+
+
+def test_a_version_opens_in_spirula(api, monkeypatch):
+    run = scene()
+    api.post("/api/versions", {"slug": "Living", "sizes": "all", "clean": "ceiling=0.5"})
+    wait_job()
+    api.post("/api/versions", {"slug": "Living", "sizes": "20000"})
+    wait_job()
+    opened = []
+    monkeypatch.setattr(server.subprocess, "Popen", lambda cmd, **kw: opened.append(cmd))
+    assert api.post("/api/open", {"slug": "Living", "version": "all-c50", "what": "spirula"})[0] == 200
+    assert opened[-1][1] == str(run / "versions" / "all-c50" / "spirula" / "scene.ply")
+    status, r = api.post("/api/open", {"slug": "Living", "version": "0.02m", "what": "spirula"})   # no ply
+    assert status == 400 and r["error"]["code"] == "err.no_version"
+    status, r = api.post("/api/open", {"slug": "Living", "version": "../x", "what": "spirula"})
+    assert status == 400 and len(opened) == 1
@@ -130,3 +130,18 @@ def test_the_same_folder_in_both_places(api, frame):
    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
+
+
+def test_an_old_frame_listing_is_answered_at_once_and_renewed_behind(frame):
+    """Asking a Frame that is switched off takes seconds; the scene list must not wait for it every time."""
+    import time as _t
+    first = server.frame_listing()
+    assert first is not None
+    server.frame_cache.update(t=_t.time() - 60, data={"files": [], "thumbs": [], "scenes": ["old"]})
+    start = _t.time()
+    assert server.frame_listing()["scenes"] == ["old"]                 # the last one, without waiting
+    assert _t.time() - start < 0.5
+    end = _t.time() + 10
+    while server.frame_cache.get("renewing") and _t.time() < end:
+        _t.sleep(0.05)
+    assert server.frame_listing()["scenes"] != ["old"]                 # renewed in the background
@@ -1,5 +1,6 @@
 """Groups of scenes: one group per scene, suggestions, renaming, cleaning up together."""
 import json
+import pytest

 from conftest import RUNS, server
 import synth
@@ -78,3 +79,18 @@ def test_dissolving_a_group_keeps_its_scenes(api):
    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()}
+
+
+@pytest.mark.parametrize("name,slug", [("Rundgang 12.10.", "Rundgang-12.10"), ("Küche", "Kueche"),
+                                       ("...", ""), (".hidden", "hidden"), ("Flur 2", "Flur-2")])
+def test_folder_names_suit_every_file_system(name, slug):
+    """No dot at the end: NTFS (e.g. runs on a Windows disk) refuses it, and the copy loses the tour."""
+    from splat_workshop import config
+    assert config.slugify(name) == slug
+
+
+def test_a_tour_named_with_a_date_gets_a_folder_ntfs_accepts(api):
+    synth.make_room(RUNS, "Kitchen", "A", name="Kitchen")
+    synth.make_room(RUNS, "Hall", "B", name="Hall")
+    status, r = api.post("/api/group", {"name": "Tour 12.10.", "members": "Kitchen,Hall"})
+    assert status == 200 and r["slug"] == "Tour-12.10"
@@ -23,13 +23,13 @@ def test_renaming_moves_folder_files_and_log(api):
    (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."
+    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 (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
+    assert server.no_resume("Buero-12.10") == "renamed"        # the pipeline remembers the old path


 def test_renaming_to_a_taken_name_is_refused(api):
@@ -0,0 +1,71 @@
+"""Setup hints (0.4.1, from issues #1 and #2): typos in the config, splat-transform only on the shell's PATH,
+an Arcturus pipeline that PyAV 19 breaks."""
+import os
+import subprocess
+
+import pytest
+
+from conftest import ROOT, server
+from splat_workshop import config
+
+UNPINNED = '''#!/usr/bin/env -S uv run --script
+# /// script
+# dependencies = [
+#   "av>=18.1",
+#   "numpy",
+# ]
+# ///
+import av
+av.open("x", metadata_errors="strict")
+'''
+
+
+def test_a_typo_in_the_config_is_named_with_the_right_spelling():
+    unknown = config.unknown_keys({"paths": {"splat-transform": "/x", "pipeline": "/p"}, "frmae": {"host": ""}})
+    assert unknown == [("paths.splat-transform", "paths.splat_transform"), ("frmae", "frame")]
+    c = config.Config(config._merge(config.DEFAULTS, {}), None, unknown)
+    keys = [k for k, _ in c.problems()]
+    assert keys[:2] == ["setup.unknown_key", "setup.unknown_key"]
+
+
+def test_a_pipeline_that_pyav_19_breaks_is_found(tmp_path):
+    for name in config.PYAV_FILES:
+        (tmp_path / name).write_text(UNPINNED)
+    assert config.pyav_unpinned(tmp_path) == list(config.PYAV_FILES)
+    (tmp_path / "av1_colmap.py").write_text(UNPINNED.replace('"av>=18.1"', '"av>=18.1,<19"'))
+    assert config.pyav_unpinned(tmp_path) == ["av1_to_3dgs.py"]
+    c = config.Config(config._merge(config.DEFAULTS, {"paths": {"pipeline": str(tmp_path)}}), None)
+    hint = dict(c.problems())["setup.pyav"]
+    assert hint["files"] == "av1_to_3dgs.py"
+
+
+def test_a_conversion_failing_on_pyav_says_why():
+    out = server.parse_output("Traceback ...\nTypeError: open() got an unexpected keyword argument 'metadata_errors'\n")
+    assert out["info"]["hint"] == "hint.pyav"
+    assert "hint" not in server.parse_output("Traceback ...\nValueError: something else\n")["info"]
+
+
+@pytest.mark.parametrize("existing", [False, True])
+def test_install_gives_the_full_path_of_splat_transform(tmp_path, existing):
+    """install.sh finds splat-transform on the shell's PATH: a new config gets the full path, an existing one
+    a line to add – the app, started from the desktop, does not see that PATH."""
+    home, xdg, bin_ = tmp_path / "home", tmp_path / "xdg", tmp_path / "bin"
+    for d in (home, xdg, bin_):
+        d.mkdir()
+    (bin_ / "splat-transform").write_text("#!/bin/sh\n")
+    (bin_ / "splat-transform").chmod(0o755)
+    conf = xdg / "splat-workshop" / "config.toml"
+    if existing:
+        conf.parent.mkdir()
+        conf.write_text('[paths]\nsplat-transform = "/typo"\n')
+    env = {**os.environ, "HOME": str(home), "XDG_CONFIG_HOME": str(xdg), "XDG_DATA_HOME": str(tmp_path / "data"),
+           "PATH": f"{bin_}:{os.environ['PATH']}"}
+    env.pop("SPLAT_WORKSHOP_CONFIG", None)
+    r = subprocess.run([str(ROOT / "install.sh")], env=env, capture_output=True, text=True, timeout=120)
+    assert r.returncode == 0, r.stderr
+    line = f'splat_transform = "{bin_ / "splat-transform"}"'
+    if existing:
+        assert line in r.stdout and line not in conf.read_text()
+        assert 'Unknown setting "paths.splat-transform"' in r.stdout and '"paths.splat_transform"' in r.stdout
+    else:
+        assert line in conf.read_text() and "written to the config" in r.stdout
@@ -15,7 +15,10 @@ const I18N = {
    "setup.hint": "Settings are in {file}. Restart Splat Workshop after changing them.",
    "setup.pipeline": "Arcturus pipeline not found in {path} (av1_to_3dgs.py). Download it from arcturus.vision/apps.",
    "setup.spirula": "Spirula Studio not found at {path}. Build it as described in the pipeline README.",
-    "setup.splat_transform": "splat-transform not found – install it with: npm install -g @playcanvas/splat-transform",
+    "setup.splat_transform": "splat-transform not found. Install it (without root: npm install -g --prefix ~/.local @playcanvas/splat-transform) and put its full path into {file}, e.g. splat_transform = \"/home/you/.local/bin/splat-transform\" – started from the desktop, Splat Workshop does not see a PATH set in .bashrc or .zshrc.",
+    "setup.unknown_key": "Unknown setting “{key}” in {file} – did you mean “{suggestion}”? (Splat Workshop ignores it.)",
+    "setup.unknown_key.plain": "Unknown setting “{key}” in {file} – Splat Workshop ignores it.",
+    "setup.pyav": "The Arcturus pipeline in {path} will fail with “unexpected keyword argument 'metadata_errors'” (PyAV 19). In the # /// script header of {files}, change \"av>=18.1\" to \"av>=18.1,<19\" – see Troubleshooting in docs/arcturus-setup.md.",
    "setup.tool": "{tool} is not installed.",
    // job card
    "job.cancel": "Cancel", "job.dismiss": "Hide", "job.log": "Log",
@@ -33,6 +36,7 @@ const I18N = {
    "res.cancelled": "Cancelled. Start again with the same name and choose “Resume” to continue.",
    "res.upload_failed": "The scene is finished, but copying to the Frame did not work (Frame off?). Use “To the Frame” in the list of finished scenes once it is on.",
    "res.failed": "Failed – the last lines of the log show why.",
+    "hint.pyav": "Failed: the Arcturus pipeline does not work with PyAV 19 (“unexpected keyword argument 'metadata_errors'”). In the # /// script header of av1_to_3dgs.py and av1_colmap.py, change \"av>=18.1\" to \"av>=18.1,<19\", then resume – see Troubleshooting in docs/arcturus-setup.md.",
    "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",
@@ -230,10 +234,19 @@ const I18N = {
    "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.new": "New version", "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.measured": "Measured on a Steam Frame (Gaussian XR, 10/2026): 0.75 M ≈ 36 fps, 1 M ≈ 35 fps, 1.5 M ≈ 29 fps, 2 M ≈ 24 fps, 5 M ≈ 14 fps.",
+    "ver.for": "For", "ver.for.frame": "🥽 the Frame (headset)", "ver.for.pc": "🖥️ the PC (all splats, e.g. Spirula Studio)",
+    "ver.size.head": "Size", "ver.fps.0_75": "≈ {fps} fps", "ver.fps.1": "≈ {fps} fps, clearly sharper", "ver.fps.1_5": "≈ {fps} fps, a little unsteady", "ver.fps.2": "≈ {fps} fps",
+    "ver.plain": "Also make it without cleaning up, to compare",
+    "ver.clean.none": "not cleaned up", "ver.slow": "{n} M splats: on the Frame only about 14 fps",
+    "ver.template": "As template", "ver.template.title": "Put this version's settings into the form below – change one slider and make the next one",
+    "ver.template.done": "Settings taken over – change what you want to compare",
+    "ver.replaces": "{what} (replaces the existing one)", "ver.same.all": "All splats without cleaning up is the scene itself – open it in Spirula from the scene, or set a slider.",
+    "ver.makes.1": "Makes:", "ver.makes.n": "Makes {n} versions:", "ver.make.1": "Make version", "ver.make.n": "Make {n} versions",
+    "ver.show": "▸ Show {n} versions", "ver.first": "＋ Versions …", "ver.show.1": "▸ Show 1 version", "ver.new.button": "＋ New version …", "ver.hide": "▾ Hide versions", "ver.of": "Versions of “{name}”",
+    "ver.pick": "Enter a size (at least 0.01 million)", "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",
@@ -255,6 +268,12 @@ const I18N = {
    "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)",
+    "ver.clean": "Clean up", "ver.clean.off": "off",
+    "ver.clean.hint": "Experimental. The scene itself stays as it is; only this version is cleaned up – compare it with one without.",
+    "ver.clean.ceiling": "Ceiling", "ver.clean.ceiling.title": "A white ceiling gives the reconstruction nothing to hold on to: it stays thin, with a dark veil under it. Takes out the veil (deeper with more strength; dark things within 50 cm of a wall stay) and what lies above the ceiling, and puts in a closed ceiling in its own colour.",
+    "ver.clean.floor": "Floor", "ver.clean.floor.title": "Fills holes in the floor in the colour of the floor around them (more holes count with more strength) and takes out what lies under the floor.",
+    "ver.clean.haze": "Haze", "ver.clean.haze.title": "Takes out big, nearly transparent blobs floating in the room. Long thin things (bars, cables, wires) are no haze and stay. At full strength smaller and less transparent blobs go, too.",
+    "ver.clean.outside": "Edges", "ver.clean.outside.title": "Takes out what lies well outside the room: beyond the walls, above the ceiling, under the floor – from 1 m beyond them to 30 cm at full strength. Also the view through a window.",
    "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",
@@ -285,7 +304,10 @@ const I18N = {
    "setup.hint": "Die Einstellungen stehen in {file}. Nach Änderungen die Splat-Werkstatt neu starten.",
    "setup.pipeline": "Arcturus-Pipeline nicht gefunden in {path} (av1_to_3dgs.py). Download: arcturus.vision/apps.",
    "setup.spirula": "Spirula Studio nicht gefunden unter {path}. Bauen wie in der Pipeline-README beschrieben.",
-    "setup.splat_transform": "splat-transform fehlt – installieren mit: npm install -g @playcanvas/splat-transform",
+    "setup.splat_transform": "splat-transform nicht gefunden. Installieren (ohne root: npm install -g --prefix ~/.local @playcanvas/splat-transform) und den vollen Pfad in {file} eintragen, z. B. splat_transform = \"/home/du/.local/bin/splat-transform\" – vom Desktop gestartet sieht die Splat-Werkstatt keinen PATH aus .bashrc oder .zshrc.",
+    "setup.unknown_key": "Unbekannte Einstellung „{key}“ in {file} – meintest du „{suggestion}“? (Die Splat-Werkstatt ignoriert sie.)",
+    "setup.unknown_key.plain": "Unbekannte Einstellung „{key}“ in {file} – die Splat-Werkstatt ignoriert sie.",
+    "setup.pyav": "Die Arcturus-Pipeline in {path} wird mit „unexpected keyword argument 'metadata_errors'“ scheitern (PyAV 19). Im # /// script-Kopf von {files} \"av>=18.1\" in \"av>=18.1,<19\" ändern – siehe Troubleshooting in docs/arcturus-setup.md.",
    "setup.tool": "{tool} ist nicht installiert.",
    "job.cancel": "Abbrechen", "job.dismiss": "Ausblenden", "job.log": "Protokoll",
    "job.standby": "💤 Danach in den Standby", "job.standby.in": "💤 Standby in {s} s",
@@ -302,6 +324,7 @@ const I18N = {
    "res.cancelled": "Abgebrochen. Mit gleichem Namen erneut starten und „Fortsetzen“ wählen, um weiterzumachen.",
    "res.upload_failed": "Die Szene ist fertig gerechnet, aber das Kopieren auf die Frame hat nicht geklappt (Frame aus?). In der Liste der fertigen Szenen „Auf die Frame“ nutzen, sobald sie an ist.",
    "res.failed": "Fehlgeschlagen – die letzten Zeilen im Protokoll zeigen warum.",
+    "hint.pyav": "Fehlgeschlagen: Die Arcturus-Pipeline läuft nicht mit PyAV 19 („unexpected keyword argument 'metadata_errors'“). Im # /// script-Kopf von av1_to_3dgs.py und av1_colmap.py \"av>=18.1\" in \"av>=18.1,<19\" ändern und fortsetzen – siehe Troubleshooting in docs/arcturus-setup.md.",
    "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",
@@ -494,10 +517,19 @@ const I18N = {
    "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.new": "Neue Fassung", "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.measured": "Gemessen auf einer Steam Frame (Gaussian XR, 10/2026): 0,75 Mio. ≈ 36 fps, 1 Mio. ≈ 35 fps, 1,5 Mio. ≈ 29 fps, 2 Mio. ≈ 24 fps, 5 Mio. ≈ 14 fps.",
+    "ver.for": "Wofür", "ver.for.frame": "🥽 die Frame (Brille)", "ver.for.pc": "🖥️ den PC (alle Splats, z. B. Spirula Studio)",
+    "ver.size.head": "Größe", "ver.fps.0_75": "≈ {fps} fps", "ver.fps.1": "≈ {fps} fps, deutlich schärfer", "ver.fps.1_5": "≈ {fps} fps, leicht unruhig", "ver.fps.2": "≈ {fps} fps",
+    "ver.plain": "Zusätzlich ohne Bereinigung erstellen, zum Vergleichen",
+    "ver.clean.none": "nicht bereinigt", "ver.slow": "{n} Mio. Splats: auf der Frame nur etwa 14 fps",
+    "ver.template": "Als Vorlage", "ver.template.title": "Die Einstellungen dieser Fassung ins Formular unten übernehmen – einen Regler ändern und die nächste erstellen",
+    "ver.template.done": "Einstellungen übernommen – ändere, was du vergleichen willst",
+    "ver.replaces": "{what} (ersetzt die vorhandene)", "ver.same.all": "Alle Splats ohne Bereinigung ist die Szene selbst – öffne sie bei der Szene in Spirula oder stell einen Regler.",
+    "ver.makes.1": "Erstellt:", "ver.makes.n": "Erstellt {n} Fassungen:", "ver.make.1": "Fassung erstellen", "ver.make.n": "{n} Fassungen erstellen",
+    "ver.show": "▸ {n} Fassungen zeigen", "ver.first": "＋ Fassungen …", "ver.show.1": "▸ 1 Fassung zeigen", "ver.new.button": "＋ Neue Fassung …", "ver.hide": "▾ Fassungen ausblenden", "ver.of": "Fassungen von „{name}“",
+    "ver.pick": "Eine Größe angeben (mindestens 0,01 Mio.)", "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",
@@ -519,6 +551,12 @@ const I18N = {
    "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)",
+    "ver.clean": "Bereinigen", "ver.clean.off": "aus",
+    "ver.clean.hint": "Experimentell. Die Szene selbst bleibt, wie sie ist; nur diese Fassung wird bereinigt – am besten neben einer ohne vergleichen.",
+    "ver.clean.ceiling": "Decke", "ver.clean.ceiling.title": "Eine weiße Decke gibt der Rekonstruktion keinen Halt: Sie bleibt dünn, darunter hängt ein dunkler Schleier. Nimmt den Schleier heraus (je stärker, desto tiefer; Dunkles bis 50 cm an einer Wand bleibt) und was über der Decke liegt, und setzt eine geschlossene Decke in ihrer eigenen Farbe ein.",
+    "ver.clean.floor": "Boden", "ver.clean.floor.title": "Füllt Löcher im Boden in der Farbe des Bodens drumherum (je stärker, desto mehr gilt als Loch) und nimmt heraus, was unter dem Boden liegt.",
+    "ver.clean.haze": "Dunst", "ver.clean.haze.title": "Nimmt große, fast durchsichtige Wolken heraus, die im Raum schweben. Lange dünne Dinge (Gitter, Kabel, Drähte) sind kein Dunst und bleiben. Je stärker, desto kleinere und weniger durchsichtige Wolken gehen mit.",
+    "ver.clean.outside": "Rand", "ver.clean.outside.title": "Nimmt heraus, was deutlich außerhalb des Raums liegt: hinter den Wänden, über der Decke, unter dem Boden – von 1 m Abstand bis 30 cm bei voller Stärke. Auch der Blick durchs Fenster.",
    "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",
@@ -172,6 +172,22 @@ dialog::backdrop { background: rgba(0,0,0,.55); }
 .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; }
+.vlist .vrow { display: flex; flex-wrap: wrap; gap: 6px 12px; align-items: center; justify-content: space-between; padding: 8px 0; border-bottom: 1px solid var(--line); }
+.vlist .vwhat { display: flex; flex-direction: column; gap: 2px; font-size: 13px; min-width: 0; }
+.vlist .vacts { display: flex; flex-wrap: wrap; gap: 6px; align-items: center; }
+.vinline { grid-column: 1 / -1; margin-top: 8px; padding: 8px 12px; border: 1px solid var(--line); border-radius: 10px; }
+.vinline .vhead { display: flex; justify-content: space-between; align-items: center; gap: 10px; font-size: 13px; }
+.scene .acts.rows { flex-direction: column; align-items: flex-start; gap: 6px; }
+.acts .arow { display: flex; gap: 6px; flex-wrap: wrap; }
+.acts .sep { width: 1px; align-self: stretch; margin: 2px 3px; background: var(--line); }
+.acts button.icon { min-width: 34px; }
+.toggles { display: flex; gap: 6px; margin-top: 6px; flex-wrap: wrap; }
+.toggles button.link { background: none; border-color: transparent; color: var(--muted, #9aa3b2); padding-left: 2px; padding-right: 8px; }
+.toggles button.link:hover { color: inherit; border-color: var(--line); }
+.vsizes { display: grid; grid-template-columns: repeat(auto-fill, minmax(150px, 1fr)); gap: 6px; }
+.vpreview { font-size: 13px; margin: 14px 0 0; min-height: 1.4em; }
+.cleanup .slide { display: grid; grid-template-columns: 7.5em 1fr 4.5em; gap: 10px; align-items: center; margin: 2px 0; }
+.cleanup .slide output { text-align: right; color: var(--muted, #9aa3b2); font-variant-numeric: tabular-nums; }
 .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; }
@@ -416,18 +432,24 @@ select.lang { font: inherit; font-size: 12.5px; color: var(--muted); background:
 <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>
+  <div id="verList" class="vlist"></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 data-i18n="ver.for"></b>
+    <div class="row" id="verFor">
+      <label class="chk"><input type="radio" name="verFor" value="frame" checked> <span data-i18n="ver.for.frame"></span></label>
+      <label class="chk"><input type="radio" name="verFor" value="pc"> <span data-i18n="ver.for.pc"></span></label>
+    </div>
+    <b id="verSizeHead" data-i18n="ver.size.head"></b><div id="verSizes" class="vsizes"></div>
    <b class="hidden" id="verScaleHead" data-i18n="ver.scales"></b><div class="row hidden" id="verScales"></div>
+    <b data-i18n="ver.clean"></b>
+    <div><div id="verClean" class="cleanup"></div>
+      <label class="chk hidden" id="verPlainBox" style="margin-top:6px"><input type="checkbox" id="verPlain"> <span data-i18n="ver.plain"></span></label></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">
+  <p id="verPreview" class="vpreview"></p>
+  <div class="row" style="justify-content:flex-end;margin-top:12px">
    <button id="verClose" data-i18n="clean.close"></button>
-    <button class="primary" id="verMake" data-i18n="ver.make"></button>
+    <button class="primary" id="verMake"></button>
  </div>
 </dialog>

@@ -994,7 +1016,7 @@ function renderJob() {
                                 : tr("res.ok.local", {name: j.name, path: "runs/" + j.slug}); }
    else if (j.result === "cancelled") { res.className = "result warn"; res.textContent = tr("res.cancelled"); }
    else if (j.phase === 4) { res.className = "result warn"; res.textContent = tr("res.upload_failed"); }
-    else { res.className = "result bad"; res.textContent = tr("res.failed"); }
+    else { res.className = "result bad"; res.textContent = i.hint ? tr(i.hint) : tr("res.failed"); }
  }
  const log = $("#log"), atBottom = log.scrollTop + log.clientHeight >= log.scrollHeight - 20;
  log.textContent = j.tail || ""; if (atBottom) log.scrollTop = log.scrollHeight;
@@ -1024,8 +1046,14 @@ function sceneCard(s) {
        ${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-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>`;
+        <div class="acts rows${s.replacing ? " hidden" : ""}">
+          ${S.frameConfigured ? `<div class="arow">${uploadBtn(s)}</div>` : ""}
+          <div class="arow">${s.ply ? `<button class="small pc-only" data-spirula="${esc(s.slug)}" title="${tr("sc.spirula.title")}">${tr("sc.spirula")}</button>` : ""}${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></div>
+          <div class="arow"><button class="small icon" data-rename="${esc(s.slug)}" title="${tr("ren.button")}" aria-label="${tr("ren.button")}">✎</button><button class="small icon" data-scale="${esc(s.slug)}" title="${tr("scale.button.title")}">📏${s.scale !== 1 ? " " + ratioText(s.scale) : ""}</button><button class="small icon" data-clean="${esc(s.slug)}" title="${tr("sc.clean.title")}" aria-label="${tr("sc.clean.title")}">${tr("sc.clean")}</button><button class="small icon" data-delete="${esc(s.slug)}" title="${tr("sc.delete.title")}" aria-label="${tr("sc.delete.title")}">${tr("sc.delete")}</button></div></div>
+        <div class="toggles${s.replacing ? " hidden" : ""}">${versionsToggle(s.slug, s.versions)}</div>
+      </div></div>
+    ${s.versions && versionsOpen(s.slug) ? `<div class="vinline"><div class="vhead"><b>${tr("ver.of", {name: esc(s.name)})}</b><button class="small" data-versions="${esc(s.slug)}">${tr("ver.new.button")}</button></div>
+      <div class="vlist" data-vlist="${esc(s.slug)}"></div></div>` : ""}`;
 }
 const ALIGN_LETTER = {frame: "A", images: "B", shift: "C", rigid: "D"};
 function groupOpen(slug, set) {
@@ -1065,27 +1093,40 @@ function groupBlock(g, bySlug, byGroup) {
        ${scaleLine(g)}
        ${tour}${busy}
        <div class="acts">
-          <button class="small" data-gtoggle="${esc(g.slug)}" aria-expanded="${open}">${tr(open ? "grp.hide" : g.room ? "grp.show.recordings" : inner.length ? "grp.show.rooms" : "grp.show", {n: inner.length + own.length})}</button>
          <button class="small${!r || r.stale ? " primary" : ""}" data-combine="${esc(g.slug)}" ${g.busy || scenes.length < 2 ? "disabled" : ""}>${tr(r ? "grp.recombine" : g.room ? "grp.room.combine" : "grp.combine")}</button>
-          ${r ? uploadBtn({slug: g.slug, on_frame: r.on_frame, upload: r.upload}) : ""}
-          ${scenes.some(s => s.ply) ? `<button class="small" data-gplan="${esc(g.slug)}">${tr("sc.plan")}</button>` : ""}
+          ${r ? uploadBtn({slug: g.slug, on_frame: r.on_frame, upload: r.upload}) : ""}<i class="sep"></i>
          ${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>
+          ${scenes.some(s => s.ply) ? `<button class="small" data-gplan="${esc(g.slug)}">${tr("sc.plan")}</button>` : ""}
+          ${r ? `<button class="small pc-only" data-open="${esc(g.slug)}">${tr("sc.folder")}</button>` : ""}<i class="sep"></i>
+          <button class="small icon" data-gedit="${esc(g.slug)}" title="${tr("grp.edit")}" aria-label="${tr("grp.edit")}">✎</button>
+          <button class="small icon" data-scale="${esc(g.slug)}" title="${tr("scale.button.title")}" ${g.busy ? "disabled" : ""}>📏${g.scale !== 1 ? " " + ratioText(g.scale) : ""}</button>
+          <button class="small icon" 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 icon" data-gdelete="${esc(g.slug)}" title="${tr("grp.delete.title")}" aria-label="${tr("grp.delete.title")}">${tr("sc.delete")}</button>
+        </div>
+        <div class="toggles">
+          <button class="small link" data-gtoggle="${esc(g.slug)}" aria-expanded="${open}">${tr(open ? "grp.hide" : g.room ? "grp.show.recordings" : inner.length ? "grp.show.rooms" : "grp.show", {n: inner.length + own.length})}</button>
+          ${r && r.ply ? versionsToggle(g.slug, g.versions) : ""}
        </div>
      </div>
    </div>
+    ${g.versions && versionsOpen(g.slug) ? `<div class="vinline"><div class="vhead"><b>${tr("ver.of", {name: esc(g.name)})}</b><button class="small" data-versions="${esc(g.slug)}">${tr("ver.new.button")}</button></div>
+      <div class="vlist" data-vlist="${esc(g.slug)}"></div></div>` : ""}
    ${open ? `<div class="grid ginner">${inner.map(x => groupBlock(x, bySlug, byGroup)).join("")}${own.map(sceneCard).join("")}</div>` : ""}
  </div>`;
 }
 async function loadScenes() {
+  const seq = S.sceneSeq = (S.sceneSeq || 0) + 1;
  const [list, gr] = await Promise.all([api("/api/scenes"), api("/api/groups")]);
-  const arr = Array.isArray(list) ? list : Object.values(list).filter(x => x && typeof x === "object" && x.slug);
-  S.scenes = arr; S.groups = gr.groups || []; S.memGB = gr.mem_available_gb;
+  if (seq !== S.sceneSeq) return;                // a newer load is on its way: its answer counts
+  S.scenes = Array.isArray(list) ? list : Object.values(list).filter(x => x && typeof x === "object" && x.slug);
+  S.sceneData = gr;
+  renderScenes();
+}
+// Draws the list from what was loaded last – opening or closing a group or the versions needs no new
+// load (the scene list can take seconds on a slow disk; clicks during it used to toggle back and forth)
+function renderScenes() {
+  const gr = S.sceneData || {}, arr = S.scenes || [];
+  S.groups = gr.groups || []; S.memGB = gr.mem_available_gb;
  const bySlug = Object.fromEntries(arr.map(s => [s.slug, s]));
  const inGroup = new Set(S.groups.flatMap(g => g.members));
  $("#groupNewBtn").classList.toggle("hidden", !arr.some(s => !inGroup.has(s.slug)));
@@ -1105,7 +1146,9 @@ async function loadScenes() {
  const loose = arr.filter(s => !inGroup.has(s.slug));
  $("#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-gtoggle]").forEach(b => b.onclick = () => { groupOpen(b.dataset.gtoggle, !groupOpen(b.dataset.gtoggle)); renderScenes(); });
+  document.querySelectorAll("[data-vtoggle]").forEach(b => b.onclick = () => { versionsOpen(b.dataset.vtoggle, !versionsOpen(b.dataset.vtoggle)); renderScenes(); });
+  fillVersionLists();
  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)));
@@ -1292,33 +1335,139 @@ async function loadFrameGallery(refresh) {
 }

 /* ---------- 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
+// Frame sizes as measured on a Steam Frame (Gaussian XR, 10/2026): 1 M is nearly as fast as 0.75 M and clearly sharper
+const FRAME_SIZES = [[0.75, 36], [1, 35], [1.5, 29], [2, 24]], FRAME_RECOMMENDED = 1;   // million splats, fps
+const CLEANUPS = ["ceiling", "floor", "haze", "outside"];                                // scripts/clean.py
 function sizeText(m) { return m === "all" ? tr("ver.all") : tr("million", {n: num(m, Math.round(m * 100) % 10 ? 2 : m % 1 ? 1 : 0)}); }
+function versionKey(splats, scale, clean) {                 // as version_key() in server.py
+  let key = splats === "all" ? "all" : `${+(splats / 1e6).toPrecision(6)}m`;
+  if (scale !== 1) key += `-1x${scale}`;
+  const parts = CLEANUPS.filter(k => clean[k]).map(k => k[0] + Math.round(clean[k] * 100));
+  return parts.length ? key + "-" + parts.join("") : key;
+}
+function cleanText(clean) {
+  return CLEANUPS.filter(k => clean && clean[k]).map(k => `${tr("ver.clean." + k)} ${Math.round(clean[k] * 100)} %`).join(" · ");
+}
+function versionRow(v) {
+  const what = (v.purpose === "pc" ? tr("ver.all") : tr("million", {n: num(v.splats / 1e6, 2)})) + (v.scale !== 1 ? " · " + ratioText(v.scale) : "");
+  const slow = v.purpose === "pc" && v.splats > 2.5e6;
+  return `<div class="vrow">
+    <div class="vwhat"><b>${v.purpose === "pc" ? "🖥️" : "🥽"} ${esc(what)}</b>
+      <span class="muted">${cleanText(v.clean) || tr("ver.clean.none")}</span>
+      <span class="faint">${tr("million", {n: num(v.splats / 1e6, 2)})} · ${mb(v.size)}${v.stale ? " · " + tr("ver.stale") : ""}</span></div>
+    <div class="vacts">${v.on_frame === null && !(v.upload && (v.upload.running || v.upload.error)) ? "" : frameState({upload: v.upload, on_frame: v.on_frame})}
+      ${v.ply ? `<button class="small pc-only" data-vspirula="${esc(v.key)}" title="${tr("sc.spirula.title")}">${tr("sc.spirula")}</button>` : ""}
+      ${S.frameConfigured ? `<button class="small" data-vup="${esc(v.key)}" ${(v.upload && v.upload.running) || v.on_frame === null ? "disabled" : ""} ${slow ? `title="${tr("ver.slow", {n: num(v.splats / 1e6, 1)})}"` : ""}>${tr(v.on_frame ? "sc.reupload" : "sc.toFrame")}${slow ? " ⚠️" : ""}</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-vtemplate="${esc(v.key)}" title="${tr("ver.template.title")}">${tr("ver.template")}</button>
+      <button class="small" data-vdel="${esc(v.key)}" title="${tr("ver.delete")}" aria-label="${tr("ver.delete")}">${tr("sc.delete")}</button></div>
+  </div>`;
+}
+function bindVersionRows(box, slug, list, redraw) {
+  const find = key => list.find(x => x.key === key);
+  box.querySelectorAll("[data-vspirula]").forEach(b => b.onclick = async () => {
+    const res = await api("/api/open", {slug, version: b.dataset.vspirula, what: "spirula"});
+    toast(res.ok === false ? trErr(res.error) : tr("sc.spirula.starting"));
+  });
+  box.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(redraw, 1500);
+  });
+  box.querySelectorAll("[data-vunframe]").forEach(b => b.onclick = async () => {
+    const v = find(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})); redraw();
+  });
+  box.querySelectorAll("[data-vtemplate]").forEach(b => b.onclick = async () => {
+    if (!$("#verDlg").open) await openVersions(slug);
+    useTemplate(find(b.dataset.vtemplate));
+  });
+  box.querySelectorAll("[data-vdel]").forEach(b => b.onclick = async () => {
+    const v = find(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; }
+    redraw(); loadScenes();
+  });
+}
+function verForm() {                                        // what the form would make
+  const pc = document.querySelector('input[name="verFor"]:checked').value === "pc";
+  let size = "all";
+  if (!pc) {
+    const pick = document.querySelector('input[name="verSize"]:checked');
+    size = pick.value === "custom" ? Math.round(parseFloat($("#verCustom").value) * 1e6) || 0 : Math.round(parseFloat(pick.value) * 1e6);
+  }
+  const sc = document.querySelector('input[name="verScale"]:checked');
+  const clean = {};
+  document.querySelectorAll("#verClean input").forEach(i => { if (+i.value) clean[i.dataset.clean] = i.value / 100; });
+  const any = Object.keys(clean).length > 0;
+  return {pc, size, scale: sc ? parseFloat(sc.value) : 1, clean, plain: any && $("#verPlain").checked, any};
+}
+function verPreview() {
+  const f = verForm(), V = S.verList || [], made = [];
+  $("#verPlainBox").classList.toggle("hidden", !f.any);
+  $("#verSizes").classList.toggle("hidden", f.pc); $("#verSizeHead").classList.toggle("hidden", f.pc);
+  $("#verSizes").querySelectorAll("label.opt").forEach(l => l.classList.toggle("active", l.querySelector("input").checked));
+  if (!f.pc && !(f.size >= 10000)) { $("#verPreview").textContent = tr("ver.pick"); $("#verMake").disabled = true; return; }
+  for (const cl of f.plain ? [f.clean, {}] : [f.clean]) {
+    const key = versionKey(f.size, f.scale, cl), old = V.find(v => v.key === key);
+    const text = (f.pc ? tr("ver.all") : sizeText(f.size / 1e6)) + (f.scale !== 1 ? " · " + ratioText(f.scale) : "") + " · " + (cleanText(cl) || tr("ver.clean.none"));
+    made.push(old ? tr("ver.replaces", {what: text}) : text);
+  }
+  const same = !f.any && f.pc && S.verScene.hasAll;           // all splats, not cleaned: the scene itself
+  $("#verPreview").innerHTML = same ? esc(tr("ver.same.all"))
+    : esc(tr(made.length > 1 ? "ver.makes.n" : "ver.makes.1", {n: made.length})) + made.map(x => "<br>• " + esc(x)).join("");
+  $("#verMake").disabled = same;
+  $("#verMake").textContent = tr(made.length > 1 ? "ver.make.n" : "ver.make.1", {n: made.length});
+}
+function useTemplate(v) {
+  if (!v) return;
+  document.querySelector(`input[name="verFor"][value="${v.purpose}"]`).checked = true;
+  if (v.purpose === "frame") {
+    const m = v.splats / 1e6, known = FRAME_SIZES.find(([x]) => Math.abs(x - m) < 0.01);
+    document.querySelector(`input[name="verSize"][value="${known ? known[0] : "custom"}"]`).checked = true;
+    if (!known) $("#verCustom").value = num(m, 2).replace(",", ".");
+  }
+  const sc = document.querySelector(`input[name="verScale"][value="${v.scale}"]`);
+  if (sc) sc.checked = true;
+  document.querySelectorAll("#verClean input").forEach(i => { i.value = Math.round((v.clean[i.dataset.clean] || 0) * 100); i.oninput(); });
+  verPreview();
+  toast(tr("ver.template.done"));
+}
 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;
+  S.verScene = {slug, hasAll: true};
  $("#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 = "";
+  $("#verSizes").innerHTML = FRAME_SIZES.map(([m, fps]) => `<label class="opt${m === FRAME_RECOMMENDED ? " active" : ""}">
+      <input type="radio" name="verSize" value="${m}" ${m === FRAME_RECOMMENDED ? "checked" : ""}>
+      <div><b>${sizeText(m)}${m === FRAME_RECOMMENDED ? " " + tr("ver.recommended") : ""}</b><span>${tr("ver.fps." + String(m).replace(".", "_"), {fps})}</span></div></label>`).join("")
+    + `<label class="opt"><input type="radio" name="verSize" value="custom"><div><b>${tr("ver.custom")}</b>
+      <span><input id="verCustom" type="number" min="0.1" max="50" step="0.05" style="width:80px"> ${tr("ver.million")}</span></div></label>`;
+  $("#verClean").innerHTML = `<p class="faint" style="font-size:12px;margin:0 0 6px">${tr("ver.clean.hint")}</p>` + CLEANUPS.map(k => `
+    <label class="slide" title="${esc(tr("ver.clean." + k + ".title"))}"><span>${tr("ver.clean." + k)}</span>
+      <input type="range" min="0" max="100" step="10" value="0" data-clean="${k}"><output>${tr("ver.clean.off")}</output></label>`).join("");
+  $("#verClean").querySelectorAll("input").forEach(i => i.oninput = () => {
+    i.nextElementSibling.textContent = +i.value ? i.value + " %" : tr("ver.clean.off"); verPreview(); });
+  $("#verPlain").checked = false;
  $("#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>`;
+  $("#verScales").innerHTML = scale === 1 ? "" : `<label class="chk"><input type="radio" name="verScale" value="1" checked> ${tr("scale.original")}</label>`
+    + `<label class="chk"><input type="radio" name="verScale" value="${scale}"> ${tr("ver.walk", {ratio: ratioText(scale)})}</label>`;
+  $("#verDlg").querySelectorAll('input[type="radio"], #verPlain, #verCustom').forEach(i => { i.onchange = verPreview; i.oninput = verPreview; });
+  $("#verCustom").onfocus = () => { document.querySelector('input[name="verSize"][value="custom"]').checked = true; verPreview(); };
  await drawVersions(slug);
-  $("#verDlg").showModal();
+  verPreview();
+  if (!$("#verDlg").open) $("#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(",")});
+    const f = verForm();
+    const clean = Object.entries(f.clean).map(([k, v]) => `${k}=${v}`).join(",");
+    const r = await api("/api/versions", {slug, sizes: String(f.size), scales: String(f.scale), clean, also_plain: f.plain});
    if (!r.ok) { toast(trErr(r.error)); return; }
    $("#verDlg").close(); toast(tr("ver.started")); await poll();
    $("#jobCard").scrollIntoView({behavior: "smooth", block: "start"});
@@ -1326,34 +1475,22 @@ async function openVersions(slug) {
 }
 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();
-  });
+  const list = S.verList = r.versions || [];
+  $("#verList").innerHTML = list.length ? list.map(versionRow).join("") : `<p class="faint" style="font-size:13px;margin:0">${tr("ver.none")}</p>`;
+  bindVersionRows($("#verList"), slug, list, () => drawVersions(slug).then(verPreview));
+}
+async function fillVersionLists() {                         // the opened lists under scenes and groups
+  for (const box of document.querySelectorAll("[data-vlist]")) {
+    const slug = box.dataset.vlist, r = await api("/api/versions?slug=" + encodeURIComponent(slug)), list = r.versions || [];
+    box.innerHTML = list.map(versionRow).join("") || `<p class="faint" style="font-size:13px;margin:0">${tr("ver.none")}</p>`;
+    bindVersionRows(box, slug, list, fillVersionLists);
+  }
+}
+function versionsOpen(slug, set) { return groupOpen("ver:" + slug, set); }
+function versionsToggle(slug, n) {
+  if (!n) return `<button class="small link" data-versions="${esc(slug)}" title="${tr("ver.button.title")}">${tr("ver.first")}</button>`;
+  const open = versionsOpen(slug);
+  return `<button class="small link" data-vtoggle="${esc(slug)}" aria-expanded="${open}" title="${tr("ver.button.title")}">${tr(open ? "ver.hide" : n === 1 ? "ver.show.1" : "ver.show", {n})}</button>`;
 }

 /* ---------- scale (models) ---------- */
Author	SHA1	Message	Date
thunderheronightandClaude Opus 5.5	cc6c96b242	0.4.2 Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-15 16:43:38 +02:00
thunderheronightandClaude Opus 5.5	08f049c7be	Unfold groups and versions at once; Frame listing renewed in the background; version upload off while the Frame is offline Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-15 16:42:36 +02:00
thunderheronightandClaude Opus 5.5	376d197f47	Docs: thanks to @andzejsp for spotting the fixed pipeline (#2 ) Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-15 16:26:02 +02:00
thunderheronightandClaude Opus 5.5	e0f8e92c5d	Docs: the pipeline from October 2026 (faad5aac4) fixes the PyAV 19 error; the pin is only for older ones Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-15 16:23:38 +02:00
thunderheronightandClaude Opus 5.5	20b1262fa9	0.4.1: clearer setup – config typos named, full path for splat-transform, PyAV 19 spotted From issues #1 and #2: - Unknown settings in config.toml (e.g. splat-transform instead of splat_transform) show up in the setup hints and in install.sh, with the right spelling. - install.sh writes the full path of splat-transform into a new config or prints the line for an existing one: started from the desktop, the app does not see the shell's PATH. - The setup guide's npm --prefix instructions match the path they tell you to configure. - A pipeline not pinned below PyAV 19 is spotted before a run; a run failing on it says why. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-15 16:06:01 +02:00
thunderheronightandClaude Opus 5.5	080e9d0b97	0.4.0 Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-15 15:20:17 +02:00
thunderheronightandClaude Opus 5.5	536340e468	0.4: tidier action bars – do, look, change; unfolding lists on their own line; one versions button Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-15 15:14:19 +02:00
thunderheronightandClaude Opus 5.5	6a62720554	0.4: versions by purpose, unfolding under their scene, openable in Spirula - Dialog: for the Frame (one size, with measured fps) or for the PC (all splats); clean-up; optionally the same without; a preview of what will be made and what it replaces; one version per click. - Names carry the clean-up strengths; As template takes a version's settings into the form. - A cleaned PC version keeps its ply; /api/open opens a version in Spirula Studio. - Versions unfold under their scene or tour, with Spirula, Frame, template and delete. - The PC sizes 3/5/8 M are gone; measured frame rates updated. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-15 13:37:36 +02:00
thunderheronightandClaude Opus 5.5	7e1b7fecf8	0.4: changelog and READMEs for cleaning up versions Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-15 13:21:14 +02:00
thunderheronightandClaude Opus 5.5	addb45e2c2	0.4: free space from the cameras' lines of sight – experimental, not wired in A splat clearly in front of what an image saw (its SfM points; optionally the solid splats where SfM saw nothing) sat in the camera's line of sight: free space. On a real living room only 0.4 % were found. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-15 13:13:17 +02:00
thunderheronightandClaude Opus 5.5	b44e4de901	0.4: clean-up sliders in the versions dialog, tests for clean.py and cleaned versions - clean.py: the ceiling is the highest strong line where walls meet it (a cupboard top lies lower). - The API takes the clean-up as a flat string (ceiling=0.5,haze=0.3), like every other field. - tests/test_clean.py: a synthetic living room with thin ceiling, veil, cupboard top, bird cage, haze, a hole in the floor and things beyond the walls – each told apart by its colour. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-15 13:00:23 +02:00
thunderheronightandClaude Opus 5.5	fca8e81422	WIP 0.4: clean up a scene (ceiling, floor, haze, outside) as part of its versions scripts/clean.py and an optional clean-up field for versions.sh and /api/versions. No interface and no tests yet; tried on a real living room (the ceiling as liked in the Studio; haze now by the smallest axis, so the bars of a bird cage are no haze any more – not checked yet). Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-15 13:00:23 +02:00
thunderheronightandClaude Opus 5.5	d34c68a553	CLAUDE.md: release checklist (notes keep the series' highlights), tests, scripts, file systems Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-15 12:58:03 +02:00
thunderheronightandClaude Opus 5.5	2ce2c5696b	0.3.1 Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-15 12:04:24 +02:00
thunderheronightandClaude Opus 5.5	fccaf4afc6	Folder names without a trailing dot (NTFS refuses them) Found moving the runs to an NTFS disk: the tour "Rundgang 12.10." (folder Rundgang-12.10.) was not copied. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-15 12:02:35 +02:00