Centre the NOW tag; the type badge was already fine

Re-measuring the badges properly changed the answer. The earlier reading
that said the type badge sat 0.52px high was measuring the wrong glyphs: it
fed the canvas the element's raw text ("Song", "Media") while the page
renders text-transform: uppercase ("SONG", "MEDIA"), and a lowercase 'd' or
'g' has an ascender and a descender the capitals never draw.

Measured against the text as actually rendered, the type badge is within
0.10px of centred and wants nothing. The NOW tag was the one off, by 0.59px,
the same way the section chips were. So: the badge padding added in the last
commit is reverted, and the NOW tag gets the correction instead.

That line now reads, in px off centre: NOW 0.01, type badge 0.10, key badge
0.16, section chip -0.01.

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

CLAUDE.md

@@ -3,8 +3,7 @@
 Modular production dashboard web app for Waters Church, developed in this repo.
 The app lives at the repo root and is built: zero-dependency Node server
 (`server.js`, Node 18+), dashboard shell client in `public/`, admin page at
-`/admin`, modules in `modules/` (the repo's copies — a packaged install ships
-none and installs them from the admin page's catalog), and a native macOS menu-bar launcher in
+`/admin`, modules in `modules/`, and a native macOS menu-bar launcher in
 `launcher/macos/` (Swift, no dependencies — the shipped macOS app: it carries
 the server and its own Node runtime, supervises them, and owns the macOS
 permissions modules declare; see its README). Runtime state (module
@@ -29,12 +28,7 @@ title-bar controls). The rules that matter most:
   ship inside the module folder** (zero deps is the norm). **Everything the
   module does runs inside its server entry** — no helper scripts, companion
   programs or daemons the operator starts by hand; a listener or decoder is
-  started in `init()` and stopped in `stop()`. **A native helper ships
-  prebuilt inside the module folder for Apple silicon macOS and 64-bit
-  Windows** (`bin/<name>-macos-arm64`, `bin/<name>-win-x64.exe`, source and
-  build script under `native/`); nothing is ever compiled on the machine
-  running ProdDash, and a missing binary means the feature reports itself
-  off, not a broken module. Declare `"proddash": ">=x.y.z"`
+  started in `init()` and stopped in `stop()`. Declare `"proddash": ">=x.y.z"`
   and bump the module's `version` on every change.
 - Browsers never call upstream services directly; the module's server routes
   proxy everything (no CORS, secrets stay server-side).

README.md

@@ -34,9 +34,7 @@ and a clear degraded state, then recover on their own.
 
 Open the disk image and drag **ProdDash** to Applications. That's the whole
 installation: the app carries the dashboard and its own Node runtime, so
-nothing else has to be installed. It carries no modules — open **Admin →
-Available modules**, tick the ones this machine needs and press **Install
-selected**; each updates on its own from then on. It lives in the
+nothing else has to be installed and nothing can be missing. It lives in the
 menu bar, starts and stops the server, can open at login, and holds the
 permissions the modules need — the microphone the LTC listener reads, and
 local network access for ProdCom and ProPresenter. macOS grants those to the
@@ -181,15 +179,13 @@ below. Nothing is installed without someone clicking.
 - **Available modules** lists modules in the repo that aren't installed
   here. **Install** downloads the module into the data directory's `modules/`
   and starts it right away — nothing is written into the app folder, and no
-  restart is needed. Tick several and press **Install selected** to fetch
-  them in one go. A packaged ProdDash (the app, the Windows bundle) ships
-  with no modules at all: this list is how every one of them arrives, and a
-  ProdDash update never brings one along. A git checkout also runs the
-  modules in its own tree ("bundled"); if both exist, the newer version runs.
+  restart is needed. Modules that ship with your copy of ProdDash are
+  "bundled"; ones you installed are "installed"; if both exist, the newer
+  version runs.
 - **Uninstall** on a module card removes an installed module's files. For a
-  checkout's bundled module (its folder belongs to the repo) it hides the
-  module from every dashboard instead; it reappears under Available modules
-  and can be brought back without downloading. Settings are kept either way.
+  bundled module (its folder belongs to the app) it hides the module from
+  every dashboard instead; it reappears under Available modules and can be
+  brought back without downloading. Settings are kept either way.
 - **Module updates**: when the repo has a newer version of an installed
   module, its card shows **Update to vX**.
 - **Version requirements**: every module declares the ProdDash versions it
@@ -307,11 +303,9 @@ below. Nothing is installed without someone clicking.
   status, NOW and NEXT labels, slide count, progress bar, the next list and
   its item tags, plus tidy titles.
 - **Timers** — live ProPresenter timers (countdown, countdown-to-time,
-  elapsed), the **video countdown** (time left on what ProPresenter is
-  playing, with a per-tile "Looping videos" switch so looping backgrounds
-  stay hidden) and LTC timecode as auto-sized cards. The ＋ picker lists
-  every discovered timer (and the LTC card) as its own tile, or add "All
-  timers" and pick a selection via the tile's "Timers ▾" menu; overruns are
+  elapsed) and LTC timecode as auto-sized cards. The ＋ picker lists every
+  discovered timer (and the LTC card) as its own tile, or add "All timers"
+  and pick a selection via the tile's "Timers ▾" menu; overruns are
   unmistakably red. Read-only — no start/stop controls. Admin config is in
   three groups: **ProPresenter** (endpoint host : port, API password),
   **LTC Timecode** (the listener switch, and — when it's on — the audio

docs/MODULE-GUIDE.md

@@ -28,10 +28,7 @@ people running the booth depend on them.
    ProdDash. If your feature needs a listener, a decoder or a worker, your
    server entry owns it: start it in `init()`, stop it in `stop()`, report
    it in `health()`. A child process the module itself spawns and supervises
-   is fine; a program someone launches by hand is not. **A native helper —
-   anything that is not JavaScript — ships prebuilt inside the module folder,
-   for Apple silicon macOS and 64-bit Windows; nothing is ever compiled on
-   the machine running ProdDash** (see "Native helpers" below).
+   is fine; a program someone launches by hand is not.
 4. **Declare the ProdDash version you need** (`"proddash": ">=1.1.0"` in the
    manifest) and **bump your own `version`** whenever you change the module.
    The admin page refuses to install a module whose requirement the running
@@ -86,86 +83,19 @@ modules/<id>/
 ├── module.json      manifest (required)
 ├── client.js        ES module, client entry (required)
 ├── server.js        server entry (optional — only if you need server code)
-├── bin/             native helpers, prebuilt per platform (only if you need one)
-│   ├── <name>-macos-arm64
-│   └── <name>-win-x64.exe
-├── native/          their source and the script that builds every bin/ file
 └── ... assets       (css, images…) served statically at /modules/<id>/
 ```
 
 **Installation is exactly this:** in the admin page, open **Available
 modules** and press **Install** — the module is downloaded from the ProdDash
 repo into the server's data directory (`<data dir>/modules/<id>/`) and starts
-immediately. A packaged ProdDash — the macOS app, the Windows bundle — ships
-with **no modules at all**: every one of them arrives this way, and the
-shell's own update never brings one along, so what is in git is exactly what
-runs on a booth. Developing locally? A git checkout runs whatever is in its
-own `modules/` folder (the repo's copies, "bundled"), or drop a folder into
-the data directory's `modules/` and restart. No shell code changes, ever. In
-a checkout the two live side by side; when both have the same id the newer
-version runs. **Uninstall** in the admin page removes an installed module's
-files (in a checkout, the tree's copy is hidden instead, since that folder
-belongs to the repo); its settings are kept for a later reinstall.
-
-### Native helpers
-
-Some features need a program JavaScript cannot be: reading an audio input,
-decoding timecode, measuring sound. Rule 3 says the module owns that program;
-this section says how it ships: **already built, for every platform it runs
-on, inside the module folder.** The machine running ProdDash is a packaged
-app or the Windows bundle plus modules from the admin page's catalog. It has
-no compiler and never will — the catalog delivers exactly the folder that is
-in the repo, so the binaries live in git next to the code.
-
-- **Platforms.** Apple silicon macOS and 64-bit Windows are required. Intel
-  macOS is welcome but optional. One file per platform in `bin/`, named for
-  what it is:
-
-  | Platform | File |
-  | --- | --- |
-  | macOS, Apple silicon | `bin/<name>-macos-arm64` |
-  | Windows, 64-bit | `bin/<name>-win-x64.exe` |
-  | macOS, Intel (optional) | `bin/<name>-macos-x86_64` |
-
-- **Pick it at runtime, and cope without it.** Choose by `process.platform`
-  and `process.arch`; when there is no file for this machine, the feature
-  says so — in `health()` and in the tile's `setStatus` — and everything else
-  in the module keeps working. Never try to build it, never look for a copy
-  elsewhere on the machine, never tell the operator to install anything.
-
-  ```js
-  const HELPERS = {
-    darwin: { arm64: 'ltc-capture-macos-arm64', x64: 'ltc-capture-macos-x86_64' },
-    win32: { x64: 'ltc-capture-win-x64.exe' },
-  };
-  const name = HELPERS[process.platform]?.[process.arch];
-  const helper = name ? path.join(__dirname, 'bin', name) : '';
-  if (!helper || !fs.existsSync(helper)) {
-    // Timecode is off on this platform. Say it once, keep the clock running.
-  }
-  ```
-
-- **One contract, any language.** Every platform's binary speaks the same
-  command line and output format, so `server.js` has one code path. What is
-  behind it is your choice per platform — Swift against CoreAudio on macOS,
-  C#, C or Rust on Windows — the module does not care.
-- **Source and build beside it.** Keep the source under `native/` with one
-  script that produces every `bin/` file from a checkout, so any binary can be
-  rebuilt from what is committed. A helper that cannot be rebuilt does not
-  ship.
-- **Bump the module version whenever a binary changes**, like any other
-  file — that is how installs learn about it.
-- **Keep them lean.** Optimised builds, no debug symbols, a few megabytes at
-  most: the catalog fetches the whole repo as one archive, capped at 80 MB.
-- **Signing.** Apple silicon refuses unsigned code, so sign the macOS binary
-  — Developer ID when you have it, ad-hoc at least. Windows needs nothing:
-  files the app writes carry no download mark, so SmartScreen never sees
-  them. Permissions come from the launcher (see "Permissions macOS has to
-  grant"), not from the binary.
-
-A helper that ends up existing for one platform only is an exception made
-on purpose, not a default: say so in the module's README and in the health
-line, so a Windows booth knows why the feature is off.
+immediately. Developing locally? Drop the folder into `modules/` (bundled
+with the checkout) or into the data directory's `modules/` and restart. No
+shell code changes, ever. Modules bundled with a checkout and modules
+installed from the admin page live side by side; when both have the same id
+the newer version runs. **Uninstall** in the admin page removes an installed
+module's files (a bundled one is hidden instead, since its folder belongs to
+the app); its settings are kept for a later reinstall.
 
 ## module.json
 

launcher/macos/README.md

@@ -68,10 +68,9 @@ Builds for **Apple Silicon**. To change that, or to move to a newer Node, edit
 against nodejs.org's published checksums either way.
 
 The app icon is built from `public/icons/icon-512.png`, so ProdDash's own icon
-is the app's icon. The app carries no modules: they are installed from the
-admin page's catalog into the data directory, and a module's native helper
-ships prebuilt inside it (see the module guide), so the Mac running ProdDash
-never needs a compiler.
+is the app's icon. A module's native helper is compiled during the build
+(`<name>.swift` beside a module's files becomes `<name>`), so the Mac running
+ProdDash never needs a compiler.
 
 ## Signing
 

launcher/macos/build.sh

@@ -1,8 +1,6 @@
 #!/bin/zsh
 # Build ProdDash.app — the whole application: launcher, server and its own
-# Node runtime, with nothing to install first. It carries no modules: those
-# come from the admin page's catalog into the data directory, and a module's
-# native helper ships prebuilt inside it (docs/MODULE-GUIDE.md).
+# Node runtime, with nothing to install first.
 #
 #   ./build.sh                 build/ProdDash.app, self-contained
 #   ./build.sh --dmg           …and build/ProdDash-<version>-arm64.dmg
@@ -129,14 +127,23 @@ if [[ $DEV -eq 0 ]]; then
   tar -xzf "$CACHE_DIR/$TARBALL" -C "$CONTENTS/Resources/node/bin" --strip-components 2 \
     "node-$NODE_VERSION-darwin-$ARCH/bin/node"
 
-  echo "  embedding ProdDash $VERSION (no modules — the catalog installs them)"
+  echo "  embedding ProdDash $VERSION"
   mkdir -p "$PAYLOAD/config"
   cp "$REPO_ROOT/server.js" "$REPO_ROOT/package.json" "$PAYLOAD/"
-  cp -R "$REPO_ROOT/public" "$PAYLOAD/"
+  cp -R "$REPO_ROOT/public" "$REPO_ROOT/modules" "$PAYLOAD/"
   # Only the checked-in defaults: config/ also holds this machine's own
   # modules.json and layouts when ProdDash has ever run from the checkout.
   cp "$REPO_ROOT/config/proddash.json" "$PAYLOAD/config/"
   find "$PAYLOAD" -name '.DS_Store' -delete
+
+  # A module's native helper is built here, so the Mac running ProdDash needs
+  # no compiler: <name>.swift beside a module's files becomes <name>.
+  for source in "$PAYLOAD"/modules/*/*.swift; do
+    [[ -e "$source" ]] || continue
+    helper="${source%.swift}"
+    echo "  compiling $(basename "$(dirname "$source")")/$(basename "$helper")"
+    swiftc -O -target "$ARCH-apple-macos$DEPLOYMENT_TARGET" -o "$helper" "$source"
+  done
 fi
 
 # ── signing ──────────────────────────────────────────────────────────────
@@ -158,6 +165,16 @@ fi
 if [[ -f "$CONTENTS/Resources/node/bin/node" ]]; then
   codesign "${SIGN[@]}" --entitlements Resources/node.entitlements "$CONTENTS/Resources/node/bin/node"
 fi
+if [[ $DEV -eq 0 ]]; then
+  for helper in "$PAYLOAD"/modules/*/*; do
+    # A compiled helper is the extensionless executable beside a module's
+    # sources — test the name, not the path, which has dots all over it.
+    name=$(basename "$helper")
+    [[ -f "$helper" && -x "$helper" && "$name" != *.* ]] || continue
+    echo "  signing $name"
+    codesign "${SIGN[@]}" --entitlements Resources/helper.entitlements "$helper"
+  done
+fi
 codesign "${SIGN[@]}" --entitlements Resources/ProdDash.entitlements --identifier "$BUNDLE_ID" "$APP"
 codesign --verify --deep --strict "$APP" && echo "  signature verifies"
 

modules/propresenter-timers/client.js

@@ -70,7 +70,6 @@ const DEFAULTS = {
   showDetail: true,
   showSeconds: true,
   leadingZeros: false,
-  showLoops: false,
   clock24h: true,
   clockSeconds: true,
   clockDate: false,
@@ -385,12 +384,7 @@ export default function create({ root, moduleApi }) {
       for (const source of state.sources) {
         for (const timer of source.timers) {
           if (keyOf(source, timer) !== solo) continue;
-          // A solo video tile with looping media hidden must not sit empty:
-          // it shows a quiet card instead of a countdown nobody should read.
-          const shown = timer.looping && pref('showLoops') !== true
-            ? { ...timer, state: 'idle', remainingMs: null, elapsedMs: null, startedAt: null, asOf: null, status: { text: 'Looping', tone: 'muted' } }
-            : timer;
-          return [{ id: source.id, source, items: [{ key: solo, source, timer: shown }] }];
+          return [{ id: source.id, source, items: [{ key: solo, source, timer }] }];
         }
       }
       // The timer this tile was added for is not offered right now. Nothing is
@@ -404,11 +398,7 @@ export default function create({ root, moduleApi }) {
       const items = [];
       for (const timer of source.timers) {
         const key = keyOf(source, timer);
-        if (hidden.has(key)) continue;
-        // A looping background's time means nothing — the card sits out
-        // while a loop plays (per tile: the "Looping videos" switch).
-        if (timer.looping && pref('showLoops') !== true) continue;
-        items.push({ key, source, timer });
+        if (!hidden.has(key)) items.push({ key, source, timer });
       }
       // Every timer of a live source hidden on purpose: nothing to say.
       if (!items.length && source.timers.length) continue;
@@ -676,9 +666,7 @@ export default function create({ root, moduleApi }) {
           card.mono = null;
         }
         text = value === null ? '—' : fmtDuration(value, { ...digits, up: timer.kind === 'countdown' });
-        // A shown loop never warns or overruns — it wraps at zero by design,
-        // and a background flashing red every pass would cry wolf all service.
-        tone = timer.looping ? (timer.state === 'running' ? 'ok' : 'muted') : toneFor(timer, value);
+        tone = toneFor(timer, value);
         statusText = timer.status?.text || defaultStatus(timer, value, tone);
         statusTone = timer.status?.tone || tone;
         detailText = timer.detail || '';

modules/propresenter-timers/ltc-listener.js

@@ -10,23 +10,13 @@
  * onUpdate roughly 4×/s:
  *
  *   { state: 'running'|'stopped'|'nosignal', time, fps, df }   healthy
- *   { error: '<short, for the tiles>', detail: '<for admin/log>' }  not capturing
+ *   { error: '<what is wrong and how to fix it>' }             not capturing
  *
- * Error strings are two-tier on purpose: `error` is what a dashboard tile
- * shows (short — "Not configured — see Admin"), `detail` is the full story
- * for the admin health line and the log.
- *
- * The capture binary is per-machine (gitignored), and a catalog install or
- * update ships source only — the update even wipes a previously built
- * binary. ensureCaptureBinary() therefore rebuilds it with swiftc in the
- * background as part of coming up: kicked when the LTC source starts and by
- * the admin device picker, never on the event loop (a blocking build once
- * froze the whole server — see spl-meter's history), built to a temp name
- * and renamed so a killed build can't leave a half-written "binary", and
- * rebuilt when a module update leaves the source newer than the binary.
- * A dead capture child is restarted with backoff — fast for a crash, slow
- * for config-shaped failures (unknown device, ambiguity) that never fix
- * themselves.
+ * The capture binary is per-machine (gitignored): if it is missing this
+ * tries one swiftc compile of the source next to it, and otherwise says to
+ * build it on any same-architecture Mac and copy it over. A dead child is
+ * restarted with backoff — fast for a crash, slow for config-shaped
+ * failures (unknown device, ambiguous name) that never fix themselves.
  *
  * macOS gotcha this file can't fix: microphone permission. A ProdDash
  * server launched over SSH or from a bare launchd job gets SILENT ZEROS
@@ -37,7 +27,7 @@
 
 const path = require('path');
 const fs = require('fs');
-const { spawn } = require('child_process');
+const { spawn, spawnSync } = require('child_process');
 const { LtcDecoder, ChannelExtractor, fmtTc } = require('./ltc');
 
 const RESTART_MS = 5000;
@@ -51,100 +41,6 @@ const RUNNING_WINDOW_MS = 400;
 /** stderr line the capture prints once the device is open. */
 const CAPTURING_RE = /capturing "(.+)": (\d+) channels @ (\d+) Hz/;
 
-/* ── the capture tool: build it when the install didn't bring one ──────── */
-
-/** Tile-facing words (short); the detail goes to admin health and the log. */
-const TOOL_BUILDING = 'Capture tool building…';
-const TOOL_MISSING = 'Capture tool unavailable — see Admin';
-const BUILD_HELP = 'LTC capture tool could not be built here — build it on any Mac of the '
-  + 'same architecture with `swiftc -O -o ltc-capture ltc-capture.swift` (both files are in '
-  + 'the module folder) and copy the binary next to ltc-capture.swift';
-
-let building = false;
-let buildFailed = false;
-
-/**
- * Make sure the capture tool exists, building it in the background when it
- * does not — module scope, so the LTC source can kick it the moment it
- * starts and the admin device picker can kick it before any device is
- * configured (a listener-only build would deadlock: no tool → no device
- * list → no device → no listener). A catalog install ships source only and
- * a catalog update deletes the module folder (old binary included), so this
- * IS the install step for the tool.
- *
- * Never blocks (a synchronous build once held the whole server's event loop
- * — every module — for the duration). Builds to a temp name and renames, so
- * a killed or crashed build can't leave a truncated file that looks like a
- * ready binary. A binary older than the source (a module update over an
- * existing folder) keeps serving while a replacement builds behind it.
- *
- * @returns {{ready:boolean, error:string, detail:string}} `ready` = a binary
- *   is usable right now; otherwise `error` is the short tile text and
- *   `detail` the full one.
- */
-function ensureCaptureBinary({ moduleDir, log, onReady }) {
-  const bin = path.join(moduleDir, 'ltc-capture');
-  const src = bin + '.swift';
-  const ok = { ready: true, error: '', detail: '' };
-  let haveBin = false;
-  let stale = false;
-  try {
-    haveBin = fs.existsSync(bin);
-    if (haveBin && fs.existsSync(src)) stale = fs.statSync(src).mtimeMs > fs.statSync(bin).mtimeMs;
-  } catch { /* treat as missing */ }
-  if (haveBin && !stale) return ok;
-  if (!fs.existsSync(src)) {
-    return haveBin ? ok : { ready: false, error: TOOL_MISSING, detail: 'ltc-capture.swift is missing from the module folder' };
-  }
-  const notYet = haveBin ? ok : {
-    ready: false,
-    error: building || !buildFailed ? TOOL_BUILDING : TOOL_MISSING,
-    detail: building || !buildFailed ? 'Building the LTC capture tool — ready in a moment' : BUILD_HELP,
-  };
-  if (building || buildFailed) return notYet;
-
-  building = true;
-  const tmp = bin + '.building';
-  log(stale ? 'ltc-capture is older than its source — rebuilding it in the background'
-    : 'ltc-capture binary missing — building it in the background');
-  const build = spawn('swiftc', ['-O', '-o', tmp, src], { stdio: ['ignore', 'ignore', 'pipe'] });
-  let buildErr = '';
-  build.stderr.setEncoding('utf8');
-  build.stderr.on('data', (t) => { buildErr = (buildErr + t).slice(-800); });
-  const giveUp = setTimeout(() => {
-    try { build.kill('SIGKILL'); } catch { /* already gone */ }
-  }, 300000);
-  giveUp.unref?.();
-  build.on('error', (err) => {
-    clearTimeout(giveUp);
-    building = false;
-    buildFailed = true;
-    try { fs.rmSync(tmp, { force: true }); } catch { /* nothing to clean */ }
-    log(`swiftc could not be run: ${err.message}`);
-  });
-  build.on('exit', (code) => {
-    clearTimeout(giveUp);
-    building = false;
-    if (code === 0 && fs.existsSync(tmp)) {
-      try {
-        fs.renameSync(tmp, bin);
-      } catch (err) {
-        buildFailed = true;
-        log(`ltc-capture built but could not be moved into place: ${err.message}`);
-        return;
-      }
-      buildFailed = false;
-      log('ltc-capture built');
-      if (typeof onReady === 'function') onReady();
-      return;
-    }
-    buildFailed = true;
-    try { fs.rmSync(tmp, { force: true }); } catch { /* nothing to clean */ }
-    log(`ltc-capture build failed (exit ${code})` + (buildErr ? `: ${buildErr.trim().split('\n').pop()}` : ''));
-  });
-  return notYet;
-}
-
 /**
  * @param {{device:string, channel:number, moduleDir:string, log:Function,
  *          onUpdate:(u:object)=>void}} opts
@@ -179,24 +75,25 @@ function createLtcListener({ device, channel, moduleDir, log, onUpdate }) {
     return 'nosignal';
   }
 
+  function ensureBinary() {
+    if (fs.existsSync(bin)) return '';
+    const src = bin + '.swift';
+    log('ltc-capture binary missing — trying a one-time swiftc build');
+    const built = spawnSync('swiftc', ['-O', '-o', bin, src], { timeout: 120000 });
+    if (built.status === 0 && fs.existsSync(bin)) {
+      log('ltc-capture compiled');
+      return '';
+    }
+    return 'LTC capture tool missing — build it on any Apple Silicon Mac with '
+      + '`swiftc -O -o modules/propresenter-timers/ltc-capture modules/propresenter-timers/ltc-capture.swift` '
+      + 'and copy it here';
+  }
+
   function start() {
     if (stopped) return;
-    const tool = ensureCaptureBinary({
-      moduleDir,
-      log,
-      onReady() {
-        // The build this start() was waiting on landed — go now.
-        if (!stopped) { clearTimeout(restartTimer); restartTimer = null; start(); }
-      },
-    });
-    if (!tool.ready) {
-      report({ error: tool.error, detail: tool.detail });
-      // onReady is only the FAST path (a successful build restarts us at
-      // once). The slow retry must stay armed regardless: a failed build
-      // never calls back, and a binary can also arrive from outside — scp'd
-      // in on a machine whose toolchain can't build (AB's broken CLT).
-      // Waiting on onReady alone deadlocked exactly that way in production:
-      // "Capture tool building…" forever, with a working binary on disk.
+    const missing = ensureBinary();
+    if (missing) {
+      report({ error: missing });
       scheduleRestart(BAD_CONFIG_RETRY_MS);
       return;
     }
@@ -216,10 +113,7 @@ function createLtcListener({ device, channel, moduleDir, log, onUpdate }) {
       const channels = Number(m[2]);
       const rate = Number(m[3]);
       if (channel > channels) {
-        report({
-          error: 'Channel not on this device — see Admin',
-          detail: `"${m[1]}" has ${channels} input channels — channel ${channel} is configured. Fix it in Admin.`,
-        });
+        report({ error: `"${m[1]}" has ${channels} input channels — channel ${channel} is configured. Fix it in Admin.` });
         try { child.kill(); } catch { /* exiting anyway */ }
         return;
       }
@@ -241,21 +135,17 @@ function createLtcListener({ device, channel, moduleDir, log, onUpdate }) {
     });
 
     child.on('error', (err) => {
-      report({ error: TOOL_MISSING, detail: `LTC capture failed to start: ${err.message}` });
+      report({ error: `LTC capture failed to start: ${err.message}` });
     });
 
     child.on('exit', (code) => {
       child = null;
       if (stopped) return;
       // The capture's own failure text (unknown device, ambiguous name,
-      // permission hint) is the most useful DETAIL we have; the tile just
-      // needs to know the input is down and where to fix it.
+      // permission hint) is the most useful thing we can show.
       const said = stderrTail.split('\n').reverse().find((l) => l.includes('ltc-capture:') && !CAPTURING_RE.test(l));
       const quickDeath = Date.now() - startedAt < 3000;
-      report({
-        error: quickDeath ? 'Audio device unavailable — see Admin' : 'Audio capture restarting…',
-        detail: (said ? said.replace(/^.*ltc-capture:\s*/, '') : `LTC capture exited (code ${code})`) + (quickDeath ? '' : ' — restarting'),
-      });
+      report({ error: (said ? said.replace(/^.*ltc-capture:\s*/, '') : `LTC capture exited (code ${code})`) + (quickDeath ? '' : ' — restarting') });
       scheduleRestart(quickDeath ? BAD_CONFIG_RETRY_MS : RESTART_MS);
     });
   }
@@ -298,4 +188,4 @@ function createLtcListener({ device, channel, moduleDir, log, onUpdate }) {
   };
 }
 
-module.exports = { createLtcListener, ensureCaptureBinary };
+module.exports = { createLtcListener };

modules/propresenter-timers/module.json

@@ -1,7 +1,7 @@
 {
   "id": "propresenter-timers",
   "name": "Timers",
-  "version": "1.6.0",
+  "version": "1.4.2",
   "proddash": ">=1.4.0",
   "description": "Timers, Clocks, and LTC From configured Modules",
   "provides": [
@@ -161,12 +161,6 @@
       "default": false,
       "group": "Show"
     },
-    "showLoops": {
-      "type": "switch",
-      "label": "Looping videos",
-      "default": false,
-      "group": "Show"
-    },
     "showHeadings": {
       "type": "switch",
       "label": "Source headings",

modules/propresenter-timers/server.js

@@ -81,7 +81,7 @@
 const http = require('http');
 const path = require('path');
 const { spawn } = require('child_process');
-const { createLtcListener, ensureCaptureBinary } = require('./ltc-listener');
+const { createLtcListener } = require('./ltc-listener');
 const { createTimerPhase } = require('./phase');
 const manifest = require('./module.json');
 
@@ -255,21 +255,6 @@ function createProPresenterSource({ config, log }) {
   /** uuid → phase tracker: whole-second reports → one stable anchor (see phase.js). */
   const phases = new Map();
 
-  /* The video countdown — time left on what the presentation layer is
-     playing, from the transport routes (verified live on ProPresenter 21.4):
-       GET /v1/transport/presentation/current → { is_playing, uuid, name,
-         artist, audio_only, duration }   (no looping flag exists — inferred)
-       GET /v1/transport/presentation/time    → bare seconds, sub-second
-         float — better than /v1/timer/video_countdown's whole-second string,
-         so no quantization phase lock is needed, only an anchor hold. */
-  let media = null;      // { uuid, name, duration, playing } from the slow lane
-  let mediaAt = 0;
-  let transportOk = null; // null until the first answer; false = no transport route (older ProPresenter)
-  let videoPos = null;   // playback position in seconds (float)
-  let videoAsOf = 0;     // server ms when videoPos was measured
-  let videoAnchor = null; // published { remainingMs, asOf }, held while it predicts the measurements
-  let loopingUuid = '';  // media seen wrapping — a looping background
-
   function url(target) {
     const built = new URL(`http://${host}:${port}${target}`);
     if (password) built.searchParams.set('password', password);
@@ -405,137 +390,13 @@ function createProPresenterSource({ config, log }) {
     return out;
   }
 
-  /**
-   * Follow the presentation transport layer. Failures here only drop the
-   * video card, never the whole source — the timers must survive a
-   * ProPresenter build with transport quirks.
-   */
-  async function pollVideo() {
-    if (tick % SLOW_EVERY === 1) {
-      try {
-        const raw = await requestJson('/v1/transport/presentation/current');
-        const uuid = String(raw?.uuid || '');
-        if (!media || media.uuid !== uuid) {
-          if (media && media.uuid !== uuid) loopingUuid = '';
-          videoPos = null;
-          videoAnchor = null;
-        }
-        media = uuid ? {
-          uuid,
-          name: String(raw.name || ''),
-          duration: Number(raw.duration) > 0 ? Number(raw.duration) : 0,
-          playing: Boolean(raw.is_playing),
-        } : null;
-        mediaAt = Date.now();
-        transportOk = true;
-      } catch (err) {
-        media = null; // the slow lane retries in ~2 s
-        if (err && err.status === 404) transportOk = false; // no transport route on this build
-      }
-    }
-    if (!media) {
-      videoPos = null;
-      videoAnchor = null;
-      return;
-    }
-    try {
-      const pos = Number(await requestJson('/v1/transport/presentation/time'));
-      if (Number.isFinite(pos) && pos >= 0) {
-        // Same media, position jumped back by more than a stutter: it
-        // wrapped — a looping background. Sticks until the media changes.
-        // (A video manually re-triggered from the start looks the same and
-        // is mislabeled for that pass; loops re-wrap, replays don't recur.)
-        if (videoPos !== null && media.playing && videoPos - pos > 1.5) loopingUuid = media.uuid;
-        videoPos = pos;
-        videoAsOf = Date.now();
-      } else {
-        videoPos = null;
-      }
-    } catch {
-      videoPos = null;
-    }
-  }
-
-  /** The video countdown as one synthetic timer card (id 'video'). The card
-      persists as an idle "—" between videos — a wall tile must not appear
-      and vanish with the media — and is only absent entirely on a
-      ProPresenter without transport routes. */
-  function videoTimer() {
-    if (transportOk !== true) return null;
-    if (!media) {
-      return {
-        id: 'video',
-        label: 'Video',
-        kind: 'countdown',
-        state: 'idle',
-        asOf: mediaAt || updatedAt,
-        startedAt: null,
-        elapsedMs: null,
-        remainingMs: null,
-        targetMs: null,
-        looping: false,
-        status: null,
-        detail: '',
-      };
-    }
-    const playing = media.playing;
-    const dur = media.duration > 0 ? media.duration * 1000 : null;
-    let remainingMs = null;
-    let asOf = videoAsOf || mediaAt;
-    if (videoPos !== null && dur !== null) {
-      remainingMs = Math.max(0, dur - videoPos * 1000);
-      if (playing) {
-        // Hold the published anchor while it still predicts the measured
-        // position: the tiles extrapolate locally, and a fresh anchor per
-        // poll would broadcast a frame every 500 ms for nothing.
-        const p = videoAnchor;
-        const predicted = p ? p.remainingMs - (videoAsOf - p.asOf) : NaN;
-        if (p && Math.abs(predicted - remainingMs) < 120) {
-          remainingMs = p.remainingMs;
-          asOf = p.asOf;
-        } else {
-          videoAnchor = { remainingMs, asOf };
-        }
-      } else {
-        videoAnchor = null;
-      }
-    } else {
-      videoAnchor = null;
-    }
-    const looping = media.uuid === loopingUuid;
-    return {
-      id: 'video',
-      label: 'Video',
-      kind: 'countdown',
-      state: playing ? 'running' : videoPos > 0 ? 'paused' : 'idle',
-      asOf,
-      startedAt: null,
-      elapsedMs: remainingMs !== null && dur !== null ? dur - remainingMs : null,
-      remainingMs,
-      targetMs: dur,
-      looping,
-      status: looping ? { text: playing ? 'Looping' : 'Paused', tone: 'muted' } : null,
-      // The media name, without the file extension nobody reads on a wall.
-      detail: media.name.replace(/\.(mp4|mov|m4v|mxf|avi|mkv|mp3|wav|aiff?)$/i, ''),
-    };
-  }
-
   function status() {
     if (!configured) return 'error';
     if (reachable) return 'ok';
     return lastError ? 'error' : 'connecting';
   }
 
-  /** Short, for the tiles — a dashboard warns, the admin page explains.
-      The client prefixes the source label, so no "ProPresenter" here. */
-  function tileMessage() {
-    if (!configured) return 'Not configured — see Admin';
-    if (reachable) return `${timers.length} timer${timers.length === 1 ? '' : 's'}`;
-    return 'Unreachable';
-  }
-
-  /** The full story, for the admin health line. */
-  function adminMessage() {
+  function message() {
     if (!configured) return 'No ProPresenter host configured — set one in Admin, or switch ProPresenter timers off';
     if (reachable) return `Polling ${host}:${port}, ${timers.length} timer${timers.length === 1 ? '' : 's'}`;
     return lastError ? `Unreachable at ${host}:${port} — ${lastError}` : `Reaching ${host}:${port}…`;
@@ -543,7 +404,7 @@ function createProPresenterSource({ config, log }) {
 
   function publish() {
     if (stopped) return;
-    emit({ status: status(), message: tileMessage(), timers, updatedAt });
+    emit({ status: status(), message: message(), timers, updatedAt });
   }
 
   async function pollTick() {
@@ -559,9 +420,6 @@ function createProPresenterSource({ config, log }) {
       const currentTimes = await requestJson('/v1/timers/current');
       updatedAt = Date.now();
       timers = mergeTimers(currentTimes, updatedAt);
-      await pollVideo();
-      const video = videoTimer();
-      if (video) timers.push(video);
       reachable = true;
       lastError = '';
     } catch (err) {
@@ -592,7 +450,7 @@ function createProPresenterSource({ config, log }) {
       clearTimeout(pollTimer);
     },
     health() {
-      return { status: status(), message: adminMessage() };
+      return { status: status(), message: message() };
     },
   };
 }
@@ -606,9 +464,7 @@ function createLtcSource({ config, log, moduleDir }) {
   let emit = () => {};
   let listener = null;
   let stopped = false;
-  /** The listener's latest word: { state, time, fps, df, ageMs } |
-      { error, detail } (error = short tile text, detail = the admin/log
-      story) | null while starting. */
+  /** The listener's latest word: { state, time, fps, df, ageMs } | { error } | null while starting. */
   let word = null;
 
   function rateText() {
@@ -660,16 +516,8 @@ function createLtcSource({ config, log, moduleDir }) {
     kind: 'ltc',
     start(e) {
       emit = e;
-      // Kick the capture-tool build right away: a catalog install ships
-      // source only and a catalog update wipes any previously built binary,
-      // so coming up after an install/update must rebuild it without
-      // waiting for a device to be picked or a listener to need it.
-      ensureCaptureBinary({ moduleDir, log });
       if (!device) {
-        word = {
-          error: 'Not configured — see Admin',
-          detail: 'LTC timecode is on but no audio device is selected — pick one in Admin',
-        };
+        word = { error: 'LTC timecode is on but no audio device is selected — pick one in Admin' };
         publish();
         return;
       }
@@ -691,8 +539,7 @@ function createLtcSource({ config, log, moduleDir }) {
       listener = null;
     },
     health() {
-      // The admin page gets the full story; the tiles got the short one.
-      return { status: status(), message: (word && word.error && word.detail) || message() };
+      return { status: status(), message: message() };
     },
   };
 }
@@ -741,15 +588,7 @@ function createModuleSource({ moduleId, name, shellPort, log }) {
   let silenceTimer = null;
   let backoff = BACKOFF_MIN_MS;
 
-  /** Short, for the tiles; the lastError detail belongs to the admin line.
-      The client prefixes the source label, so it isn't repeated here. */
-  function tileMessage() {
-    if (state === 'ok') return `${timers.length} timer${timers.length === 1 ? '' : 's'}`;
-    if (state === 'connecting') return 'Connecting…';
-    return 'Unavailable';
-  }
-
-  function adminMessage() {
+  function message() {
     if (state === 'ok') return `${timers.length} timer${timers.length === 1 ? '' : 's'}${via ? ` (${via})` : ''}`;
     if (state === 'connecting') return lastError ? `reconnecting — ${lastError}` : 'connecting…';
     return `unreachable — ${lastError}`;
@@ -757,7 +596,7 @@ function createModuleSource({ moduleId, name, shellPort, log }) {
 
   function publish() {
     if (stopped) return;
-    emit({ label, status: state, message: tileMessage(), timers, updatedAt });
+    emit({ label, status: state, message: message(), timers, updatedAt });
   }
 
   function accept(raw) {
@@ -935,7 +774,7 @@ function createModuleSource({ moduleId, name, shellPort, log }) {
       if (!stopped && !stream && via === 'poll') connectStream();
     },
     health() {
-      return { status: state, message: adminMessage() };
+      return { status: state, message: message() };
     },
   };
 }
@@ -1103,8 +942,6 @@ const GEAR = {
   all: { instanceSchema: FULL_SCHEMA, instanceGroups: FULL_GROUPS },
   /** One ProPresenter or module timer: its elements, and the tone its digits take per state. */
   timer: gearOf([...TIMER_ELEMENTS, ...COLOURS], OPEN_COLOURS),
-  /** The video countdown: a timer card, plus whether looping media counts. */
-  video: gearOf([...TIMER_ELEMENTS, 'showLoops', ...COLOURS], OPEN_COLOURS),
   /** The timecode: running, no signal (warning) and stopped (idle) — it never overruns, and frames are frames. */
   ltc: gearOf(['showNames', 'showStatus', 'runningColor', 'warningColor', 'idleColor'], OPEN_COLOURS),
   /** The time of day: plain digits, so only how they read. */
@@ -1118,7 +955,6 @@ function gearFor(source, timer) {
   if (source.kind === 'ltc') return GEAR.ltc;
   if (source.kind === 'clock') return GEAR.clock;
   if (timer.kind === 'clock') return GEAR.providerClock;
-  if (source.id === 'propresenter' && timer.id === 'video') return GEAR.video;
   return GEAR.timer;
 }
 
@@ -1327,8 +1163,7 @@ module.exports = {
       for (const t of src.timers) {
         const description = src.kind === 'ltc' ? 'The incoming LTC timecode on its own'
           : src.kind === 'clock' ? 'The time of day on its own'
-            : src.id === 'propresenter' && t.id === 'video' ? 'Time left on the video ProPresenter is playing'
-              : `This ${src.label} ${KIND_WORD[t.kind] || 'timer'} on its own`;
+            : `This ${src.label} ${KIND_WORD[t.kind] || 'timer'} on its own`;
         // Layouts from before 1.3.0 hold 'timer:<uuid>' / 'ltc' — the same tiles.
         const aliases = src.id === 'propresenter' ? [`timer:${t.id}`] : src.kind === 'ltc' ? ['ltc'] : [];
         out.push({ id: `solo:${src.id}:${t.id}`, name: t.label, description, ...oneCard, ...gearFor(src, t), ...(aliases.length ? { aliases } : {}) });
@@ -1337,7 +1172,7 @@ module.exports = {
     return out;
   },
 
-  routes({ log }) {
+  routes() {
     return {
       'GET /state': (req, res) => {
         sendJson(res, 200, { state: current ? current.getState() : emptyState() });
@@ -1360,15 +1195,7 @@ module.exports = {
 
       // The admin device picker asks this machine what it can hear. The
       // options shape matches the admin select's optionsRoute contract.
-      // Opening the picker also kicks the capture-tool build when a catalog
-      // install/update left only the source — without this, no tool meant
-      // no device list, and no device meant nothing would ever build it.
       'GET /ltc/devices': (req, res) => {
-        const tool = ensureCaptureBinary({ moduleDir: __dirname, log });
-        if (!tool.ready) {
-          sendJson(res, 200, { options: [], error: tool.detail || tool.error });
-          return;
-        }
         const bin = path.join(__dirname, 'ltc-capture');
         const child = spawn(bin, ['--list'], { stdio: ['ignore', 'ignore', 'pipe'], timeout: 4000 });
         let err = '';

modules/spl-meter/module.json

@@ -1,7 +1,7 @@
 {
   "id": "spl-meter",
   "name": "SPL Meter",
-  "version": "0.4.3",
+  "version": "0.4.1",
   "proddash": ">=1.5.0",
   "description": "Calibrated sound level, Leq and RTA from an audio input on this machine",
   "permissions": [

modules/spl-meter/server.js

@@ -20,7 +20,7 @@
  */
 
 const path = require('path');
-const { createSplListener, ensureCaptureBinary } = require('./spl-listener');
+const { createSplListener } = require('./spl-listener');
 
 /** Reference level of a sound level calibrator. Effectively always 94 dB. */
 const CALIBRATOR_DB = 94;
@@ -114,19 +114,11 @@ module.exports = {
       error: '',
       streams: new Set(),
       silentSince: null,
-      toolMissing: '',
       listener: null,
       lastSent: '',
       pinger: null,
     };
 
-    // Before anything else: the device picker shells out to this tool, so a
-    // machine that installed the module from the catalog (source only — the
-    // binary is gitignored) needs the build kicked off here. Waiting for a
-    // listener would never happen: no tool means no device list, and no
-    // device means no listener.
-    state.toolMissing = ensureCaptureBinary({ moduleDir, log });
-
     if (!config.enabled) {
       state.error = 'Sound level measurement is off — turn it on in ProdDash settings';
       return { stop() { teardown(); }, health: () => ({ status: 'error', message: state.error }) };
@@ -185,9 +177,6 @@ module.exports = {
     return {
       stop() { teardown(); },
       health() {
-        if (state.toolMissing && !fsExists(path.join(moduleDir, 'spl-capture'))) {
-          return { status: 'error', message: state.toolMissing };
-        }
         if (state.error) return { status: 'error', message: state.error };
         if (!state.frame) return { status: 'connecting', message: 'waiting for the first reading' };
         const quiet = silentMs();
@@ -311,13 +300,6 @@ module.exports = {
       /** Device list for the admin page. Runs the capture tool's --list,
           which is the only thing that knows what CoreAudio can see. */
       'GET /devices': async (req, res) => {
-        const missing = ensureCaptureBinary({ moduleDir: __dirname, log });
-        if (missing) {
-          if (state) state.toolMissing = missing;
-          log(`device list unavailable — ${missing}`);
-          json(res, 200, { options: [] });
-          return;
-        }
         try {
           const devices = await listDevices();
           json(res, 200, {
@@ -456,10 +438,6 @@ function listDevices() {
   });
 }
 
-function fsExists(p) {
-  try { return require('fs').existsSync(p); } catch { return false; }
-}
-
 function json(res, code, body) {
   const text = JSON.stringify(body);
   res.writeHead(code, {

modules/spl-meter/spl-listener.js

@@ -17,8 +17,7 @@
  * module's ltc-capture. It normally arrives already built — compiled beside
  * the app, or copied from any Mac of the same architecture. When it is
  * missing this will build it, but in the background and never on the event
- * loop, and from module scope so the device picker can trigger it too — see
- * ensureCaptureBinary for what both of those cost the first time round.
+ * loop: see ensureBinary for what that cost the first time it was wrong.
  *
  * The same macOS gotcha applies as for LTC, and is worth repeating because
  * it costs an afternoon every time: a ProdDash launched over SSH or from a
@@ -31,74 +30,6 @@ const path = require('path');
 const fs = require('fs');
 const { spawn } = require('child_process');
 
-const BUILD_HELP = 'Sound level capture tool missing — build it on any Apple Silicon Mac with '
-  + '`swiftc -O -o modules/spl-meter/spl-capture modules/spl-meter/spl-capture.swift` '
-  + 'and copy it next to spl-capture.swift';
-const BUILDING = 'Building the capture tool — this takes a minute or two';
-
-/**
- * Build the capture tool if it is missing, WITHOUT blocking, and shared by
- * everything that needs it.
- *
- * This lives at module scope rather than inside a listener because of a trap
- * the first version walked into: the admin page's device picker runs the tool
- * with --list, but the build only ran when a listener started, and a listener
- * only starts once a device has been picked. On a machine that got the module
- * from the catalog — source only, the binary being gitignored — the picker
- * was empty, and nothing would ever fill it.
- *
- * It also must never block. It was a spawnSync once, copied from the LTC
- * listener where the source is a third the size and builds in seconds. Here
- * it took nearly two minutes on the production Mac and held the Node event
- * loop for all of it, freezing every other module, then did it again on the
- * next retry.
- *
- * The binary should normally already be there: built beside the app, or
- * copied from any Mac of the same architecture. This is the fallback.
- *
- * @returns {string} '' when the tool is ready, otherwise what to say.
- */
-let building = false;
-let buildFailed = false;
-
-function ensureCaptureBinary({ moduleDir, log, onReady }) {
-  const bin = path.join(moduleDir, 'spl-capture');
-  if (fs.existsSync(bin)) return '';
-  const src = bin + '.swift';
-  if (!fs.existsSync(src)) return 'spl-capture.swift is missing from the module folder';
-  if (building) return BUILDING;
-  if (buildFailed) return BUILD_HELP;
-
-  building = true;
-  log('spl-capture binary missing — building it in the background');
-  const build = spawn('swiftc', ['-O', '-o', bin, src], { stdio: ['ignore', 'ignore', 'pipe'] });
-  let buildErr = '';
-  build.stderr.setEncoding('utf8');
-  build.stderr.on('data', (t) => { buildErr = (buildErr + t).slice(-800); });
-  const giveUp = setTimeout(() => {
-    try { build.kill('SIGKILL'); } catch { /* already gone */ }
-  }, 300000);
-  build.on('error', (err) => {
-    clearTimeout(giveUp);
-    building = false; buildFailed = true;
-    log(`swiftc could not be run: ${err.message}`);
-  });
-  build.on('exit', (code) => {
-    clearTimeout(giveUp);
-    building = false;
-    if (code === 0 && fs.existsSync(bin)) {
-      log('spl-capture built');
-      buildFailed = false;
-      if (typeof onReady === 'function') onReady();
-      return;
-    }
-    buildFailed = true;
-    log(`spl-capture build failed (exit ${code})`
-      + (buildErr ? `: ${buildErr.trim().split('\n').pop()}` : ''));
-  });
-  return BUILDING;
-}
-
 const RESTART_MS = 5000;
 /** An immediate exit is config-shaped (bad device, channel out of range) —
     retrying every 5 s would only fill the log with the same sentence. */
@@ -122,13 +53,64 @@ function createSplListener(opts) {
   let stallTimer = null;
   let startedAt = 0;
   let meta = null;
+  let building = false;
+  let buildFailed = false;
   let lastFrameWall = 0;
 
-  /** '' when the tool is ready, otherwise what to say about it. */
+  const BUILD_HELP = 'Sound level capture tool missing — build it on any Apple Silicon Mac with '
+    + '`swiftc -O -o modules/spl-meter/spl-capture modules/spl-meter/spl-capture.swift` '
+    + 'and copy it next to spl-capture.swift';
+
+  /**
+   * Build the capture tool if it is missing, WITHOUT blocking.
+   *
+   * This used to be a spawnSync, copied from the LTC listener where the
+   * source is a third the size and builds in a few seconds. Here it took
+   * nearly two minutes on the production Mac and froze the entire ProdDash
+   * server for every second of it — one module's optional helper took the
+   * whole dashboard down, then did it again on every retry. Nothing that
+   * runs while a service might be on is allowed to hold the event loop.
+   *
+   * The build is a fallback for a module installed from the catalog on a
+   * machine with a Swift toolchain. The normal path is a binary built
+   * alongside the app, or copied from any same-architecture Mac.
+   *
+   * @returns {string} '' when the binary is ready, otherwise what to say.
+   */
   function ensureBinary() {
-    return ensureCaptureBinary({ moduleDir, log, onReady() {
-      if (!stopped) { clearTimeout(restartTimer); restartTimer = null; start(); }
-    } });
+    if (fs.existsSync(bin)) return '';
+    const src = bin + '.swift';
+    if (!fs.existsSync(src)) return 'spl-capture.swift is missing from the module folder';
+    if (building) return 'Building the capture tool — this takes a minute or two';
+    if (buildFailed) return BUILD_HELP;
+
+    building = true;
+    log('spl-capture binary missing — building it in the background');
+    const build = spawn('swiftc', ['-O', '-o', bin, src], { stdio: ['ignore', 'ignore', 'pipe'] });
+    let buildErr = '';
+    build.stderr.setEncoding('utf8');
+    build.stderr.on('data', (t) => { buildErr = (buildErr + t).slice(-800); });
+    const giveUp = setTimeout(() => {
+      try { build.kill('SIGKILL'); } catch { /* already gone */ }
+    }, 300000);
+    build.on('error', (err) => {
+      clearTimeout(giveUp);
+      building = false; buildFailed = true;
+      log(`swiftc could not be run: ${err.message}`);
+    });
+    build.on('exit', (code) => {
+      clearTimeout(giveUp);
+      building = false;
+      if (code === 0 && fs.existsSync(bin)) {
+        log('spl-capture built');
+        buildFailed = false;
+        if (!stopped) { clearTimeout(restartTimer); restartTimer = null; start(); }
+        return;
+      }
+      buildFailed = true;
+      log(`spl-capture build failed (exit ${code})` + (buildErr ? `: ${buildErr.trim().split('\n').pop()}` : ''));
+    });
+    return 'Building the capture tool — this takes a minute or two';
   }
 
   function scheduleRestart(ms) {
@@ -153,13 +135,9 @@ function createSplListener(opts) {
     const missing = ensureBinary();
     if (missing) {
       onUpdate({ error: missing });
-      // onReady is only the FAST path (a successful build restarts us at
-      // once). The slow retry must stay armed regardless: a failed build
-      // never calls back, and a binary can also arrive from outside — scp'd
-      // in on a machine whose toolchain can't build (AB's broken CLT).
-      // Waiting on onReady alone deadlocked exactly that way in the Timers
-      // module: "building…" forever, with a working binary on disk.
-      scheduleRestart(BAD_CONFIG_RETRY_MS);
+      // A build in flight calls start() itself when it lands; anything else
+      // is config-shaped and should back off hard rather than spin.
+      if (!building) scheduleRestart(BAD_CONFIG_RETRY_MS);
       return;
     }
 
@@ -258,4 +236,4 @@ function createSplListener(opts) {
   };
 }
 
-module.exports = { createSplListener, ensureCaptureBinary };
+module.exports = { createSplListener };

package.json

@@ -1,6 +1,6 @@
 {
   "name": "proddash",
-  "version": "1.10.0",
+  "version": "1.9.0",
   "private": true,
   "description": "Modular production dashboard for Waters Church \u2014 zero-dependency Node server + vanilla client",
   "license": "UNLICENSED",

public/admin/admin.css

@@ -443,7 +443,6 @@ a.btn { text-decoration: none; }
   margin-bottom: 10px;
 }
 .catalog-main { flex: 1; min-width: 0; }
-.catalog-pick { margin: 5px 10px 0 0; flex: none; }
 .catalog-title { display: flex; align-items: center; gap: 8px; }
 .catalog-row .module-desc { margin: 4px 0 2px; }
 .catalog-row .module-health { margin-top: 2px; }

public/admin/admin.js

@@ -962,13 +962,6 @@ async function loadState() {
   for (const mod of state.modules || []) {
     modulesList.appendChild(buildModuleCard(mod));
   }
-  if (!(state.modules || []).length) {
-    // A packaged ProdDash starts like this: the catalog below is the way in.
-    const none = document.createElement('div');
-    none.className = 'layouts-empty';
-    none.textContent = 'Nothing installed yet — pick from Available modules below.';
-    modulesList.appendChild(none);
-  }
   renderPin(state);
   loadTheme();
   loadLayouts();
@@ -1170,7 +1163,6 @@ function renderAvailable(cat) {
     els.updateSlot.appendChild(btn);
   }
   const available = cat.available || [];
-  installSelectedBtn.hidden = available.filter((a) => a.compatible).length < 2;
   if (!available.length) {
     const none = document.createElement('div');
     none.className = 'layouts-empty';
@@ -1213,46 +1205,11 @@ function renderAvailable(cat) {
     btn.disabled = !item.compatible;
     btn.title = item.compatible ? '' : item.reason;
     btn.addEventListener('click', () => installFromCatalog(item, btn));
-    if (item.compatible) {
-      const pick = document.createElement('input');
-      pick.type = 'checkbox';
-      pick.className = 'catalog-pick';
-      pick.dataset.id = item.id;
-      pick.dataset.name = item.name;
-      pick.title = 'Tick several, then Install selected';
-      row.append(pick);
-    }
     row.append(main, btn);
     availableList.appendChild(row);
   }
 }
 
-const installSelectedBtn = document.getElementById('install-selected');
-
-/** The ticked modules, in one request; the answer says which ones landed. */
-async function installSelected() {
-  const picks = [...availableList.querySelectorAll('.catalog-pick:checked')];
-  if (!picks.length) return toast('Tick the modules to install first', true);
-  installSelectedBtn.disabled = true;
-  installSelectedBtn.textContent = `Installing ${picks.length}…`;
-  try {
-    const r = await api('/api/admin/modules/install', { method: 'POST', body: JSON.stringify({ ids: picks.map((p) => p.dataset.id) }) });
-    const done = (r.results || []).filter((x) => x.ok).length;
-    const failed = (r.results || []).filter((x) => !x.ok);
-    toast(failed.length
-      ? `${done} installed; ${failed.map((f) => `${f.id}: ${f.error}`).join(' · ')}`
-      : `${done} module${done === 1 ? '' : 's'} installed`, failed.length > 0);
-    await loadState();
-  } catch (e) {
-    if (e.authRequired) showLogin();
-    else toast(e.message, true);
-  } finally {
-    installSelectedBtn.disabled = false;
-    installSelectedBtn.textContent = 'Install selected';
-  }
-}
-installSelectedBtn.addEventListener('click', installSelected);
-
 async function installFromCatalog(item, btn) {
   btn.disabled = true;
   const label = btn.textContent;

public/admin/index.html

@@ -58,7 +58,6 @@
     <section id="available-section" hidden>
       <h1 class="admin-h1">Available modules</h1>
       <div class="catalog-toolbar">
-        <button class="btn small primary" id="install-selected" hidden>Install selected</button>
         <button class="btn small" id="catalog-refresh">Check again</button>
         <span class="admin-status" id="catalog-status"></span>
       </div>

public/shell.js

@@ -510,7 +510,6 @@ function reconcileOfferedTiles() {
   }
   if (changed) rebuildDividers();
   scheduleOfferedRecheck();
-  refreshEmptyState(); // the registry may have gone from nothing to something
 }
 
 /* A module's entry list can change without anyone saving admin config: PCO
@@ -677,15 +676,6 @@ function buildTile(tile) {
 
 function refreshEmptyState() {
   emptyEl.hidden = tiles.length > 0;
-  if (emptyEl.hidden) return;
-  // Two different empties: a bare board, and a ProdDash with nothing to put
-  // on one — a packaged install starts without modules until Admin adds some.
-  const noModules = registry.size === 0;
-  if (noModules === emptyEl.classList.contains('no-modules')) return;
-  emptyEl.classList.toggle('no-modules', noModules);
-  emptyEl.innerHTML = noModules
-    ? 'No modules yet — <a href="/admin">open Admin</a> and install some under Available modules.'
-    : 'No tiles yet — use “＋ Add tile” to build this dashboard.<br>Every browser keeps its own layout.';
 }
 
 /* ── drag to move ───────────────────────────────────────────────────── */

server.js

@@ -277,52 +277,6 @@ function isUninstalled(id) {
   return moduleState(id).uninstalled === true;
 }
 
-/**
- * A packaged install that still carries modules in its app folder — every
- * install made before 1.10.0 does — moves them into the data directory
- * once, as installed copies, and drops the app-folder copies. Nothing
- * changes for the operator: the same modules run with the same settings
- * (config is keyed by module id), and from now on each updates on its own
- * from the catalog. A compiled helper sitting in a bundled folder travels
- * with it. A module the operator had uninstalled is simply dropped — the
- * catalog still offers it, and its settings stay in modules.json.
- */
-function unbundleModules() {
-  if (!PACKAGED || !fs.existsSync(BUNDLED_MODULES_DIR)) return;
-  const installed = new Map(readManifests(INSTALLED_MODULES_DIR, 'installed').map((m) => [m.id, m]));
-  let moved = 0;
-  let failed = 0;
-  for (const man of readManifests(BUNDLED_MODULES_DIR, 'bundled')) {
-    if (isUninstalled(man.id)) continue;
-    const copy = installed.get(man.id);
-    if (copy && compareVersions(copy.version, man.version) >= 0) continue; // the data directory already has as good or better
-    const dest = path.join(INSTALLED_MODULES_DIR, man.id);
-    const staging = path.join(INSTALLED_MODULES_DIR, `.${man.id}.moving`);
-    try {
-      fs.mkdirSync(INSTALLED_MODULES_DIR, { recursive: true });
-      fs.rmSync(staging, { recursive: true, force: true });
-      fs.cpSync(man.dir, staging, { recursive: true }); // keeps modes: a compiled helper stays executable
-      fs.rmSync(dest, { recursive: true, force: true });
-      fs.renameSync(staging, dest);
-      moved += 1;
-      console.log(`[proddash] moved bundled module "${man.id}" v${man.version} into the data directory${copy ? ` (over the installed v${copy.version})` : ''}`);
-    } catch (err) {
-      failed += 1;
-      console.error(`[proddash] could not move bundled module "${man.id}" into the data directory:`, err?.message || err);
-    }
-  }
-  if (failed) {
-    console.warn(`[proddash] ${failed} bundled module${failed === 1 ? '' : 's'} stay in the app folder for now — tried again at the next start`);
-    return;
-  }
-  try {
-    fs.rmSync(BUNDLED_MODULES_DIR, { recursive: true, force: true });
-    console.log(`[proddash] the app folder carries no modules now${moved ? ` — ${moved} moved into the data directory` : ''}; the admin page's catalog installs and updates them`);
-  } catch (err) {
-    console.warn("[proddash] could not remove the app folder's modules:", err?.message || err);
-  }
-}
-
 function moduleState(id) {
   const s = modulesConfig[id];
   return s && typeof s === 'object' ? s : {};
@@ -419,18 +373,7 @@ function mountModule(id) {
   const log = makeLog(id);
   try {
     const serverPath = path.join(man.dir, man.server);
-    // Drop the module's code from the require cache so every (re)mount runs
-    // the files on disk. Without this a module UPDATE swaps the folder while
-    // the process keeps executing the old code until ProdDash itself
-    // restarts — the manifest (read fresh from disk) then reports a version
-    // the running code isn't, and anything new in the update silently
-    // doesn't happen. Modules already have to come up clean on re-init
-    // (module guide), so a fresh load on config remounts is the same
-    // contract without the trap.
-    const cachePrefix = man.dir.endsWith(path.sep) ? man.dir : man.dir + path.sep;
-    for (const key of Object.keys(require.cache)) {
-      if (key.startsWith(cachePrefix)) delete require.cache[key];
-    }
+    // Re-require fresh config on every (re)mount; the module code itself stays cached.
     const mod = require(serverPath);
     const config = effectiveConfig(id);
     // What a module needs to reach the rest of ProdDash — another module's
@@ -1117,22 +1060,13 @@ async function installModule(id) {
   if (download) {
     const staging = path.join(INSTALLED_MODULES_DIR, `.${id}.installing`);
     fs.rmSync(staging, { recursive: true, force: true });
-    const shipped = new Set();
     for (const [rel, data] of remoteEntry.files) {
       if (!safeRelPath(rel)) continue;
-      shipped.add(rel);
       const target = path.join(staging, rel);
       fs.mkdirSync(path.dirname(target), { recursive: true });
       fs.writeFileSync(target, data);
     }
     const dest = path.join(INSTALLED_MODULES_DIR, id);
-    // Per-machine executables — a capture tool compiled here, or copied in
-    // by hand on a machine whose toolchain can't build it — are gitignored,
-    // so the repo never ships them. Replacing the folder must not destroy
-    // them: carry executables the download doesn't include over from the
-    // copy being replaced (or from the app's bundled copy on a first
-    // install), or "update" quietly kills a working module.
-    carryOverExecutables([dest, path.join(BUNDLED_MODULES_DIR, id)], staging, shipped);
     unmountModule(id);
     fs.rmSync(dest, { recursive: true, force: true });
     fs.renameSync(staging, dest);
@@ -1149,43 +1083,6 @@ async function installModule(id) {
   return { id, version: String(now?.version || ''), source: now?.source || '', downloaded: download };
 }
 
-/**
- * Copy executable files (any execute bit) that `shipped` does not include
- * from the first existing source dir into `staging`, keeping their relative
- * path and mode. Executables only, on purpose: they are the per-machine
- * build artifacts (gitignored, so never in a download), while stray text
- * files from an old version — code an update deliberately removed — must
- * NOT be resurrected.
- */
-function carryOverExecutables(sourceDirs, staging, shipped) {
-  const from = sourceDirs.find((d) => {
-    try { return fs.statSync(d).isDirectory(); } catch { return false; }
-  });
-  if (!from) return;
-  const walk = (rel) => {
-    for (const e of fs.readdirSync(path.join(from, rel), { withFileTypes: true })) {
-      const relPath = rel ? `${rel}/${e.name}` : e.name;
-      if (e.isDirectory()) {
-        walk(relPath);
-        continue;
-      }
-      if (!e.isFile() || shipped.has(relPath) || !safeRelPath(relPath)) continue;
-      try {
-        const stat = fs.statSync(path.join(from, relPath));
-        if (!(stat.mode & 0o111)) continue;
-        const target = path.join(staging, relPath);
-        fs.mkdirSync(path.dirname(target), { recursive: true });
-        fs.copyFileSync(path.join(from, relPath), target);
-        fs.chmodSync(target, stat.mode);
-        console.log(`[proddash] module update kept per-machine executable "${relPath}"`);
-      } catch (err) {
-        console.error(`[proddash] could not carry "${relPath}" across the update:`, err?.message || err);
-      }
-    }
-  };
-  walk('');
-}
-
 /** Remove a module: an installed copy is deleted; a bundled one is switched
     off and hidden (its folder belongs to the app). Settings are kept so a
     later reinstall picks them up again. */
@@ -1281,18 +1178,9 @@ const DATA_DIR_INSIDE_ROOT = (() => {
   return rel.split(path.sep).join('/') + '/';
 })();
 
-/* A packaged install — the macOS app, the Windows bundle: anything that is
-   not a git checkout, the same test the updater uses to choose the archive
-   over git pull — carries no modules of its own. Every module comes from
-   the catalog into the data directory, and the shell's own update never
-   brings one along. A checkout keeps running the modules in its tree, which
-   is what development wants. */
-const PACKAGED = !fs.existsSync(path.join(ROOT, '.git'));
-
 function isKeptOnUpdate(rel) {
   if (rel.startsWith('.git/')) return true;
   if (rel === 'config/modules.json' || rel.startsWith('config/layouts/')) return true;
-  if (PACKAGED && (rel === 'modules' || rel.startsWith('modules/'))) return true;
   return Boolean(DATA_DIR_INSIDE_ROOT) && `${rel}/`.startsWith(DATA_DIR_INSIDE_ROOT);
 }
 
@@ -1635,29 +1523,6 @@ async function handleAdminApi(req, res, urlPath) {
     return;
   }
 
-  // Several at once — a fresh install picking its set. One result per id;
-  // a failure stops nothing else.
-  if (urlPath === '/api/admin/modules/install' && req.method === 'POST') {
-    if (refuseAdminWrite(req, res)) return;
-    let body = {};
-    try {
-      body = JSON.parse((await readBody(req)) || '{}');
-    } catch {
-      return sendJson(res, 400, { error: 'Malformed request.' });
-    }
-    const ids = Array.isArray(body.ids) ? [...new Set(body.ids.map((id) => String(id)))] : [];
-    if (!ids.length) return sendJson(res, 400, { error: 'Nothing to install.' });
-    const results = [];
-    for (const id of ids) {
-      try {
-        results.push({ ok: true, ...(await installModule(id)) });
-      } catch (err) {
-        results.push({ ok: false, id, error: err?.message || String(err) });
-      }
-    }
-    return sendJson(res, 200, { ok: results.every((r) => r.ok), results });
-  }
-
   const install = urlPath.match(/^\/api\/admin\/modules\/([^/]+)\/install$/);
   if (install && req.method === 'POST') {
     if (refuseAdminWrite(req, res)) return;
@@ -2152,7 +2017,6 @@ server.requestTimeout = 0;
 
 /* ── boot ───────────────────────────────────────────────────────────── */
 
-unbundleModules();
 discoverModules();
 mountAllModules();
 

tools/pp-timers-mock.js

@@ -152,39 +152,10 @@ const server = http.createServer((req, res) => {
   if (p === '/v1/timers') return sendJson(res, TIMERS.filter((t) => !DROP.has(t.id.uuid)));
   if (p === '/v1/timers/current') return sendJson(res, currentTimes().filter((t) => !DROP.has(t.id.uuid)));
   if (p === '/v1/timecode/status' && !NO_LTC) return sendJson(res, timecodeStatus());
-  if (p === '/v1/transport/presentation/current') return sendJson(res, transport().current);
-  if (p === '/v1/transport/presentation/time') return sendJson(res, transport().time);
 
   sendJson(res, { error: 'not found' }, 404);
 });
 
-/* ── transport (video countdown): a 4-minute cycle ─────────────────
-   0–60 s   "Sermon Bumper.mp4" (3:00) playing
-   60–75 s  the same bumper paused at 1:00
-   75–90 s  playing again
-   90–120 s nothing loaded
-   120–240 s "Autumn Loop.mp4" (0:15) playing and wrapping — the module
-             must infer looping from the position jumping back.
-   Shapes match ProPresenter 21.4 live: `current` = { is_playing, uuid,
-   name, artist, audio_only, duration }, `time` = bare seconds (float). */
-function transport() {
-  const phase = ((Date.now() - startedAt) / 1000) % 240;
-  const none = { current: { is_playing: false, uuid: '', name: '', artist: '', audio_only: false, duration: 0 }, time: -1 };
-  if (phase < 90) {
-    const playing = phase < 60 || phase >= 75;
-    const pos = Math.min(phase, 60) + (phase >= 75 ? phase - 75 : 0);
-    return {
-      current: { is_playing: playing, uuid: 'MEDIA-BUMPER', name: 'Sermon Bumper.mp4', artist: '', audio_only: false, duration: 180 },
-      time: Math.round(pos * 10) / 10,
-    };
-  }
-  if (phase < 120) return none;
-  return {
-    current: { is_playing: true, uuid: 'MEDIA-LOOP', name: 'Autumn Loop.mp4', artist: '', audio_only: false, duration: 15 },
-    time: Math.round(((phase - 120) % 15) * 10) / 10,
-  };
-}
-
 /* ── stage-display websocket (/stagedisplay) ─────────────────────── */
 
 const cryptoMod = require('crypto');

tools/unbundled.test.js

@@ -1,203 +0,0 @@
-'use strict';
-
-/**
- * A packaged ProdDash carries no modules. This drives a packaged copy of the
- * shell — server.js and its client in a folder with no .git — through the
- * three things that make that true:
- *
- *   1. an install made before 1.10.0 still has modules in its app folder:
- *      at boot they move into the data directory once, executables keeping
- *      their mode, an uninstalled one is dropped, and the app folder's
- *      modules/ is gone;
- *   2. a shell update from an archive that carries modules/ never writes
- *      them into the app folder — they show up in the catalog instead;
- *   3. a fresh install lists everything the repo offers, and installing
- *      several at once lands them in the data directory and mounts them.
- *
- *   node tools/unbundled.test.js
- *
- * Plain Node, no dependencies: a mock forge, a temp app folder, a temp data
- * directory. Exits non-zero on the first failure and cleans up after itself.
- */
-
-const assert = require('node:assert/strict');
-const { spawn, execFileSync } = require('node:child_process');
-const fs = require('node:fs');
-const http = require('node:http');
-const net = require('node:net');
-const os = require('node:os');
-const path = require('node:path');
-
-const REPO = path.join(__dirname, '..');
-
-function freePort() {
-  return new Promise((resolve, reject) => {
-    const probe = net.createServer();
-    probe.listen(0, '127.0.0.1', () => {
-      const { port } = probe.address();
-      probe.close(() => resolve(port));
-    });
-    probe.on('error', reject);
-  });
-}
-
-async function waitFor(url, ms = 15000) {
-  const deadline = Date.now() + ms;
-  let last = '';
-  while (Date.now() < deadline) {
-    try {
-      const r = await fetch(url);
-      if (r.ok) return;
-      last = 'HTTP ' + r.status;
-    } catch (err) {
-      last = err.message;
-    }
-    await new Promise((r) => setTimeout(r, 200));
-  }
-  throw new Error('server did not come up: ' + last);
-}
-
-function writeModule(dir, id, version, extra = {}) {
-  fs.mkdirSync(dir, { recursive: true });
-  fs.writeFileSync(path.join(dir, 'module.json'), JSON.stringify({ id, name: id[0].toUpperCase() + id.slice(1), version, client: 'client.js', ...extra }));
-  fs.writeFileSync(path.join(dir, 'client.js'), 'export default function () {}\n');
-}
-
-/** The repo as a forge would archive it: one top-level folder, the shell files, and modules/. */
-function buildArchive(dir) {
-  const top = path.join(dir, 'ProdDash-main');
-  fs.mkdirSync(top, { recursive: true });
-  fs.copyFileSync(path.join(REPO, 'server.js'), path.join(top, 'server.js'));
-  fs.writeFileSync(path.join(top, 'package.json'), JSON.stringify({ name: 'proddash', version: '9.9.9' }));
-  writeModule(path.join(top, 'modules', 'demo'), 'demo', '2.0.0');
-  writeModule(path.join(top, 'modules', 'other'), 'other', '1.0.0');
-  writeModule(path.join(top, 'modules', 'third'), 'third', '1.0.0');
-  const out = path.join(dir, 'main.tar.gz');
-  execFileSync('tar', ['-czf', out, '-C', dir, 'ProdDash-main']);
-  return fs.readFileSync(out);
-}
-
-/** A packaged install as it was before 1.10.0: the shell plus bundled modules, no .git. */
-function buildPackagedApp(app) {
-  fs.mkdirSync(path.join(app, 'config'), { recursive: true });
-  fs.copyFileSync(path.join(REPO, 'server.js'), path.join(app, 'server.js'));
-  fs.copyFileSync(path.join(REPO, 'package.json'), path.join(app, 'package.json'));
-  fs.cpSync(path.join(REPO, 'public'), path.join(app, 'public'), { recursive: true });
-  fs.writeFileSync(path.join(app, 'config', 'proddash.json'), JSON.stringify({ port: 24500 }));
-  writeModule(path.join(app, 'modules', 'demo'), 'demo', '1.0.0');
-  fs.mkdirSync(path.join(app, 'modules', 'demo', 'bin'));
-  fs.writeFileSync(path.join(app, 'modules', 'demo', 'bin', 'demo-helper'), '#!/bin/sh\necho helper\n');
-  fs.chmodSync(path.join(app, 'modules', 'demo', 'bin', 'demo-helper'), 0o755);
-  writeModule(path.join(app, 'modules', 'gone'), 'gone', '1.0.0');
-}
-
-(async () => {
-  const work = fs.mkdtempSync(path.join(os.tmpdir(), 'proddash-unbundled-'));
-  const app = path.join(work, 'app');
-  const dataDir = path.join(work, 'data');
-  fs.mkdirSync(dataDir);
-  buildPackagedApp(app);
-  // The operator had uninstalled "gone" before this update.
-  fs.writeFileSync(path.join(dataDir, 'modules.json'), JSON.stringify({ gone: { uninstalled: true } }));
-  const archive = buildArchive(path.join(work, 'forge'));
-
-  const forge = http.createServer((req, res) => {
-    if (req.url.startsWith('/michael/ProdDash/archive/main.tar.gz')) {
-      res.writeHead(200, { 'Content-Type': 'application/gzip' });
-      return res.end(archive);
-    }
-    res.writeHead(404);
-    res.end();
-  });
-  const forgePort = await freePort();
-  await new Promise((r) => forge.listen(forgePort, '127.0.0.1', r));
-
-  const port = await freePort();
-  const base = `http://127.0.0.1:${port}`;
-  const env = {
-    ...process.env,
-    PRODDASH_DATA_DIR: dataDir,
-    PORT: String(port),
-    PRODDASH_FORGE: `http://127.0.0.1:${forgePort}`,
-    PRODDASH_REPO: 'michael/ProdDash',
-    PRODDASH_NO_REMOTE_CHECK: '1',
-    PRODDASH_LAUNCHER: '1', // a supervisor is watching: an update exits 75 instead of respawning
-  };
-  let log = '';
-  let child = null;
-  const start = () => {
-    child = spawn(process.execPath, ['server.js'], { cwd: app, env, stdio: ['ignore', 'pipe', 'pipe'] });
-    child.stdout.on('data', (d) => { log += d; });
-    child.stderr.on('data', (d) => { log += d; });
-    return child;
-  };
-  const exited = (proc) => new Promise((resolve) => proc.on('exit', resolve));
-  const api = async (p, init = {}) => {
-    const r = await fetch(base + p, { headers: { 'Content-Type': 'application/json' }, ...init });
-    return { status: r.status, body: await r.json().catch(() => ({})) };
-  };
-  const moduleIds = async () => (await api('/api/modules')).body.modules.map((m) => m.id).sort();
-
-  let failed = false;
-  try {
-    // ── 1. the move ──
-    start();
-    await waitFor(base + '/api/theme');
-    const moved = path.join(dataDir, 'modules', 'demo');
-    assert.ok(fs.existsSync(path.join(moved, 'module.json')), 'demo moved into the data directory');
-    const helper = path.join(moved, 'bin', 'demo-helper');
-    assert.ok(fs.existsSync(helper), 'its compiled helper came along');
-    assert.ok(fs.statSync(helper).mode & 0o111, 'and is still executable');
-    assert.equal(fs.existsSync(path.join(dataDir, 'modules', 'gone')), false, 'an uninstalled module is dropped, not moved');
-    assert.equal(fs.existsSync(path.join(app, 'modules')), false, "the app folder's modules/ is gone");
-    assert.deepEqual(await moduleIds(), ['demo'], 'demo runs, gone does not');
-    assert.match(log, /moved bundled module "demo" v1\.0\.0 into the data directory/);
-    assert.match(log, /the app folder carries no modules now/);
-    const state = (await api('/api/admin/state')).body;
-    assert.equal(state.modules.find((m) => m.id === 'demo')?.source, 'installed', 'demo is an installed copy now');
-
-    // The catalog sees the repo's modules/ — as offers, not as a bundle.
-    let cat = (await api('/api/admin/catalog?refresh=1')).body;
-    assert.equal(cat.shell.remote.error, '', 'the mock forge answers: ' + cat.shell.remote.error);
-    assert.deepEqual(cat.updates.map((u) => `${u.id} ${u.installedVersion}->${u.version}`), ['demo 1.0.0->2.0.0']);
-    assert.deepEqual(cat.available.map((a) => a.id).sort(), ['gone', 'other', 'third'].filter((id) => id !== 'gone'), 'other and third are on offer');
-
-    // ── 2. a shell update carries no modules ──
-    const running = child;
-    const up = await api('/api/admin/update', { method: 'POST', body: '{}' });
-    assert.equal(up.status, 200, 'update: ' + JSON.stringify(up.body));
-    assert.equal(await exited(running), 75, 'the server asks its supervisor for a restart');
-    assert.equal(fs.existsSync(path.join(app, 'modules')), false, 'the archive\'s modules/ was not written into the app folder');
-    assert.equal(JSON.parse(fs.readFileSync(path.join(app, 'package.json'), 'utf8')).version, '9.9.9', 'but the shell itself was updated');
-
-    log = '';
-    start();
-    await waitFor(base + '/api/theme');
-    assert.doesNotMatch(log, /moved bundled module/, 'nothing left to move on the second start');
-    assert.deepEqual(await moduleIds(), ['demo'], 'still just demo, from the data directory');
-    cat = (await api('/api/admin/catalog')).body;
-    assert.deepEqual(cat.available.map((a) => a.id).sort(), ['other', 'third'], 'the new modules are offers, not installs');
-
-    // ── 3. several at once ──
-    const many = await api('/api/admin/modules/install', { method: 'POST', body: JSON.stringify({ ids: ['other', 'third', 'nope'] }) });
-    assert.equal(many.status, 200);
-    assert.equal(many.body.ok, false, 'one of them does not exist');
-    assert.deepEqual(many.body.results.map((r) => `${r.id}:${r.ok}`), ['other:true', 'third:true', 'nope:false']);
-    assert.ok(fs.existsSync(path.join(dataDir, 'modules', 'other', 'module.json')), 'other landed in the data directory');
-    assert.deepEqual(await moduleIds(), ['demo', 'other', 'third'], 'and both are mounted');
-    const empty = await api('/api/admin/modules/install', { method: 'POST', body: '{}' });
-    assert.equal(empty.status, 400, 'nothing to install is said');
-
-    console.log('unbundled shell: every check passed');
-  } catch (err) {
-    failed = true;
-    console.error('FAIL:', err.message);
-    console.error('--- last of the server log ---\n' + log.slice(-2500));
-  } finally {
-    try { child?.kill('SIGTERM'); } catch { /* gone */ }
-    forge.close();
-    await new Promise((r) => setTimeout(r, 400));
-    fs.rmSync(work, { recursive: true, force: true });
-  }
-  process.exit(failed ? 1 : 0);
-})();