diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 519498d..3826687 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -40,6 +40,9 @@ jobs:
         working-directory: .
       - run: bun run typecheck
       - run: bun test
+      # scripts/dev.ts (bun run dev, bun run demo), with stand-ins for both apps
+      - run: bun test ./scripts
+        working-directory: .
 
   frontend:
     if: ${{ !github.event.pull_request.draft }}
diff --git a/.gitignore b/.gitignore
index f149d61..f52c271 100644
--- a/.gitignore
+++ b/.gitignore
@@ -15,7 +15,7 @@ scripts/dev/bin/
 scripts/dev/.cache/
 scripts/dev/sandbox/
 
-# Local data of scripts/start.sh (configs, schedules, logs)
+# Local data of scripts/dev.ts (configs, schedules, logs)
 /snapraid/
 !apps/server/src/parsers/__tests__/fixtures/*.log
 
diff --git a/README.md b/README.md
index 51ef7f7..42a616c 100644
--- a/README.md
+++ b/README.md
@@ -244,8 +244,7 @@ December 23.
 
 ## 🛠️ Development
 
-Requires Bun (the version in `package.json`) and the fish shell for `scripts/start.sh`;
-the end-to-end tests run on Bun too.
+Requires Bun (the version in `package.json`), nothing else; the end-to-end tests run on Bun too.
 
 ```bash
 git clone https://github.com/firsttris/snapraid-ui && cd snapraid-ui
diff --git a/apps/server/src/system/demo.ts b/apps/server/src/system/demo.ts
index 51477b9..6e44bac 100644
--- a/apps/server/src/system/demo.ts
+++ b/apps/server/src/system/demo.ts
@@ -1,4 +1,4 @@
-// Stand-ins for `snapraid smart` and `probe` in the demo sandbox (scripts/start.sh --demo).
+// Stand-ins for `snapraid smart` and `probe` in the demo sandbox (scripts/dev.ts --demo).
 // Its disks are directories, so SnapRAID finds no device to query. The output below has
 // the structured log format of the real commands and goes through the same parsers.
 // The sandbox disks also hold only a few KiB on the host's filesystem: `status` and the
diff --git a/apps/server/tsconfig.json b/apps/server/tsconfig.json
index 84f3c7b..c892897 100644
--- a/apps/server/tsconfig.json
+++ b/apps/server/tsconfig.json
@@ -14,5 +14,5 @@
       "@shared/*": ["./node_modules/@snapraid-ui/shared/src/*"]
     }
   },
-  "include": ["src", "scripts", "../../packages/shared/src"]
+  "include": ["src", "scripts", "../../packages/shared/src", "../../scripts/*.ts"]
 }
diff --git a/docs/development.md b/docs/development.md
index 5a463dc..8e74bdc 100644
--- a/docs/development.md
+++ b/docs/development.md
@@ -7,7 +7,6 @@ This page gets you from a fresh clone to a running development setup, and covers
 | Tool | Version | Needed for |
 |---|---|---|
 | [Bun](https://bun.com/) | the version in `packageManager` of the root `package.json` (1.4.4) | Everything JavaScript: runs the backend and its tests, installs the packages, runs Vite and Vitest and Playwright's test runner (`bun --bun playwright test`), compiles the standalone binary (CI and the image use the same version) |
-| [fish](https://fishshell.com/) | | `scripts/start.sh` is a fish script |
 | `curl`, `tar`, `gcc`, `make` | | Building SnapRAID for the demo sandbox (`scripts/dev/setup.sh`) |
 | SnapRAID | 14.0 or newer | Only for running against a real array without `--demo`; it has to be on your `PATH` or set via `SNAPRAID_BIN` |
 | Docker or Podman | | Only for building the image |
@@ -18,19 +17,19 @@ This page gets you from a fresh clone to a running development setup, and covers
 git clone https://github.com/firsttris/snapraid-ui
 cd snapraid-ui
 bun install           # all packages of the workspace, from the one bun.lock
-bun run demo          # scripts/start.sh --demo: sandbox with fake disks, no real array needed
+bun run demo          # scripts/dev.ts --demo: sandbox with fake disks, no real array needed
 ```
 
 Open **http://localhost:3000**. The frontend dev server runs on port 3000, the backend API and WebSocket on port 8080. `Ctrl+C` stops both.
 
-`scripts/start.sh` (`bun run dev`, `bun run demo`) has two modes:
+`scripts/dev.ts` (`bun run dev`, `bun run demo`) has two modes:
 
 | Command | Data directory | SnapRAID binary | Extra |
 |---|---|---|---|
-| `bun run dev` (`scripts/start.sh`) | `./snapraid/` (created on first start, ignored by git) | `snapraid` from your `PATH` | Works against your real configs |
-| `bun run demo` (`scripts/start.sh --demo`) | `scripts/dev/sandbox/` | `scripts/dev/bin/snapraid` | Sets `SNAPRAID_EXTRA_ARGS=--test-skip-device` and `SNAPRAID_DEMO=1` |
+| `bun run dev` (`bun scripts/dev.ts`) | `./snapraid/` (created on first start, ignored by git) | `snapraid` from your `PATH` | Works against your real configs |
+| `bun run demo` (`bun scripts/dev.ts --demo`) | `scripts/dev/sandbox/` | `scripts/dev/bin/snapraid` | Sets `SNAPRAID_EXTRA_ARGS=--test-skip-device` and `SNAPRAID_DEMO=1` |
 
-Under the hood it starts `bun run dev` in `apps/server/` (`bun --watch`, so the backend restarts on changes) and `bun run dev` in `apps/web/` (Vite with hot reload). You can run these two commands yourself in separate terminals; set `SNAPRAID_BASE_PATH` and friends first (see [Configuration](configuration.md)), otherwise the backend uses `snapraid/` in the repository's root (`../../snapraid` relative to `apps/server/`).
+Under the hood it starts `bun run dev` in `apps/server/` (`bun --watch`, so the backend restarts on changes) and `bun run dev` in `apps/web/` (Vite with hot reload), each in a process group of its own. `Ctrl+C`, closing the terminal or a `kill` (SIGINT, SIGHUP, SIGTERM) goes on to both groups, so everything they started stops too (whatever is still running after 5 seconds gets SIGKILL), and the script exits with 128 + the signal's number. `Ctrl+Z` stops both groups with the script, `fg` resumes them. When one of the two exits, the other is stopped and the script exits with the first one's code. You can run these two commands yourself in separate terminals; set `SNAPRAID_BASE_PATH` and friends first (see [Configuration](configuration.md)), otherwise the backend uses `snapraid/` in the repository's root (`../../snapraid` relative to `apps/server/`).
 
 > [!NOTE]
 > In development the frontend calls the backend directly at `http://localhost:8080` (`apps/web/src/lib/api/constants.ts`), and the backend only accepts credentials from the same hostname. Open the dev frontend as `http://localhost:3000`, not via a LAN IP.
@@ -121,7 +120,7 @@ packages/shared/       @snapraid-ui/shared: types and logic used by backend and
 docker/                Dockerfile, Compose file, Quadlet units
 scripts/build-binary.sh  the standalone binary (bun build --compile)
 scripts/install.sh     installer of the binary with a systemd service, attached to each release
-scripts/start.sh       local start (bun run dev, bun run demo)
+scripts/dev.ts         local start (bun run dev, bun run demo), tested by scripts/dev.test.ts
 scripts/dev/setup.sh   demo sandbox
 scripts/social-preview/  the social preview image
 e2e/                   end-to-end tests (Playwright) against real SnapRAID and snapraid-daemon
@@ -151,7 +150,7 @@ Backend (`apps/server/package.json`, run with `bun run <script>` in `apps/server
 |---|---|
 | `dev` | Run `src/main.ts` with `bun --watch` |
 | `start` | Run `src/main.ts`, as the image does |
-| `typecheck` | `tsc --noEmit` over `src/`, `scripts/` and `packages/shared/src/` |
+| `typecheck` | `tsc --noEmit` over `src/`, `scripts/`, `packages/shared/src/` and the root's `scripts/*.ts` |
 | `test` | `bun test` |
 
 Bun has no permission flags: the backend has the rights of the user that runs it, in the container as on the host.
@@ -160,6 +159,7 @@ Bun has no permission flags: the backend has the rights of the user that runs it
 
 ```bash
 cd apps/server && bun test             # as in CI
+bun test ./scripts                     # scripts/dev.ts (bun run dev/demo), as in CI
 cd apps/web && bun run test
 
 # Also run the engine contract against the SnapRAID CLI, with the binary from scripts/dev/setup.sh
@@ -176,6 +176,7 @@ cd apps/server && SNAPRAID_TEST_DAEMON_URL=http://127.0.0.1:7627 SNAPRAID_TEST_D
 The test adds files to the array's first data disk. In `snapraidd.conf` set `net_port = 127.0.0.1:7627` and leave `maintenance_schedule` empty. The daemon only runs a real binary as `sys_engine`, no script; for disks that share one filesystem, point it at a small compiled wrapper that adds `--test-skip-device`.
 
 - **Backend** tests use `bun:test` (`test`, `expect`; `assertThrows`/`assertRejects` from `__tests__/assert-error.ts` where a test needs the error). Parser tests in `apps/server/src/parsers/__tests__/` run against real SnapRAID logs in `fixtures/`; when SnapRAID's log format changes, add or update a fixture from a real run. The [engine contract](architecture.md#snapraid-engine) runs against the fake engine always and against the CLI engine when `SNAPRAID_BIN` and `--test-skip-device` are set (otherwise it shows as *skipped*); the scheduler is tested against the fake engine. Other tests cover auth, backup/restore, config paths, the disk wizards, `--force-*` detection, the log manager, notifications, the SMART baseline and history, and the usage history.
+- **Dev script** tests (`scripts/dev.test.ts`, `bun:test`) run `scripts/dev.ts` in a copy of the repository's layout with stand-ins for the two apps' `bun run dev` and for `scripts/dev/setup.sh`: SIGINT, SIGTERM and SIGHUP stop both process trees (grandchildren too, SIGKILL for one that ignores SIGTERM, and the script waits until that one is gone), Ctrl+Z (SIGTSTP) stops both and SIGCONT resumes them, one app exiting stops the other and passes on its exit code, the environment and base path with and without `--demo`, and a failing setup aborts. CI runs them in the backend job; the backend's `bun run typecheck` covers `scripts/*.ts`.
 - **Frontend** tests use Vitest and live in `apps/web/src/lib/__tests__/`: log parsing, progress, the job tracker, the changes, duplicates and protected files pages' logic and the i18n checks described [below](#translations). Run them from `apps/web/`, they read `messages/` and `../server/src` by relative path.
 
 ### End-to-end tests
@@ -323,7 +324,7 @@ GitHub Actions workflows in `.github/workflows/`:
 
 | Workflow | Trigger | What it does |
 |---|---|---|
-| `ci.yml` | Push and pull request to `master`; called by the release workflow | Backend: `bun install --frozen-lockfile` (the workspace, in the root), `bun run typecheck`, `bun test`. Frontend: `bun install --frozen-lockfile`, `bunx biome check`, `bun run typecheck`, `bun run test`, `bun run build`. [End-to-end tests](#end-to-end-tests) three times: against the local build, against the Docker image (built with the release's registry cache) and against the standalone binary (built for x86_64 and arm64, the tests run the x86_64 one), each split into two shards that run side by side; the built tools and apt packages are cached, a failure uploads traces and server logs. Installer: `shellcheck`, then `scripts/install.sh` on a runner with systemd against the binary built there (SnapRAID built from source, login, update, uninstall) |
+| `ci.yml` | Push and pull request to `master`; called by the release workflow | Backend: `bun install --frozen-lockfile` (the workspace, in the root), `bun run typecheck`, `bun test`, `bun test ./scripts` (in the root). Frontend: `bun install --frozen-lockfile`, `bunx biome check`, `bun run typecheck`, `bun run test`, `bun run build`. [End-to-end tests](#end-to-end-tests) three times: against the local build, against the Docker image (built with the release's registry cache) and against the standalone binary (built for x86_64 and arm64, the tests run the x86_64 one), each split into two shards that run side by side; the built tools and apt packages are cached, a failure uploads traces and server logs. Installer: `shellcheck`, then `scripts/install.sh` on a runner with systemd against the binary built there (SnapRAID built from source, login, update, uninstall) |
 | `release.yml` | Push of a `v*` tag; manual run | Runs CI unless `master`'s CI already passed for the same code (a *Bump version* commit only changes the version), then the shared Docker release workflow from `firsttris/workflows`. A tag `vX.Y.Z` publishes `tristanteu/snapraid-ui:X.Y.Z`, `:X.Y` and `:latest`, updates the Docker Hub description and creates the GitHub release, then the standalone binaries for x86_64 and arm64 are built and attached to it with their `SHA256SUMS` and `scripts/install.sh` as `install.sh`. A manual run on `master` runs the same checks and pushes `:edge`, without a release |
 | `bump.yml` | Manual run | Raises the version in `apps/web/package.json` (patch, minor or major), commits it, tags the commit `vX.Y.Z` and starts `release.yml` on it (shared [`bump-version`](https://github.com/firsttris/workflows#bump-version)) |
 | `upstream-release.yml` | Mondays 06:00 UTC; manual run | Opens an issue with a checklist when snapraid-daemon has a tag newer than `apps/server/src/engine/REVIEWED_DAEMON_VERSION`, release candidates included |
@@ -373,6 +374,7 @@ Issues and pull requests are welcome at [github.com/firsttris/snapraid-ui](https
 ```bash
 cd apps/web && bunx biome check && bun run typecheck && bun run test
 cd apps/server && bun run typecheck && bun test
+bun test ./scripts
 ```
 
 A few conventions that keep the code base consistent:
diff --git a/e2e/harness/demo-setup.ts b/e2e/harness/demo-setup.ts
index fea3aa1..df4235a 100644
--- a/e2e/harness/demo-setup.ts
+++ b/e2e/harness/demo-setup.ts
@@ -24,7 +24,7 @@ export default async function demoSetup() {
     for (const server of servers.reverse()) await server.stop()
   }
   try {
-    // As scripts/start.sh --demo
+    // As scripts/dev.ts --demo
     servers.push(
       await startBackend({
         SNAPRAID_BASE_PATH: SANDBOX,
diff --git a/package.json b/package.json
index 834707a..b76736e 100644
--- a/package.json
+++ b/package.json
@@ -10,7 +10,7 @@
     "e2e"
   ],
   "scripts": {
-    "dev": "fish scripts/start.sh",
-    "demo": "fish scripts/start.sh --demo"
+    "dev": "bun scripts/dev.ts",
+    "demo": "bun scripts/dev.ts --demo"
   }
 }
diff --git a/scripts/dev.test.ts b/scripts/dev.test.ts
new file mode 100644
index 0000000..5133eec
--- /dev/null
+++ b/scripts/dev.test.ts
@@ -0,0 +1,268 @@
+// scripts/dev.ts (`bun run dev`, `bun run demo`) in a copy of the repository's layout whose
+// apps/server and apps/web dev scripts and scripts/dev/setup.sh are stand-ins: each dev script
+// notes its pid, its parent's (`bun run`) and a grandchild's, so a test sees what is left running.
+import { afterEach, expect, test } from 'bun:test'
+import {
+  copyFileSync,
+  existsSync,
+  mkdirSync,
+  mkdtempSync,
+  readFileSync,
+  realpathSync,
+  rmSync,
+  writeFileSync,
+} from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+
+const DEV = join(import.meta.dir, 'dev.ts')
+const APPS = ['server', 'web'] as const
+type App = (typeof APPS)[number]
+
+let root = ''
+let pids: number[] = []
+
+afterEach(() => {
+  for (const pid of pids) {
+    try {
+      process.kill(pid, 'SIGKILL')
+    } catch {}
+  }
+  pids = []
+  if (root) rmSync(root, { recursive: true, force: true })
+  root = ''
+})
+
+/**
+ * The layout dev.ts expects. Each app's dev script records `bun run`'s pid ($PPID), its own and
+ * the one of a grandchild that sleeps, and the environment; `exit` makes the server's script
+ * exit with that code once the test writes server.exit; `stubborn` makes the web app's grandchild
+ * ignore SIGTERM, `heavy` additionally makes it a Bun process that holds 1.5 GiB, which takes
+ * the kernel a while to tear down after SIGKILL (it writes web.heavy when it holds them).
+ * `setup` is scripts/dev/setup.sh's body.
+ */
+function sandbox({
+  setup = 'exit 0',
+  exit,
+  stubborn = false,
+  heavy = false,
+}: {
+  setup?: string
+  exit?: number
+  stubborn?: boolean
+  heavy?: boolean
+} = {}) {
+  root = realpathSync(mkdtempSync(join(tmpdir(), 'snapraid-ui-dev-')))
+  mkdirSync(join(root, 'scripts/dev'), { recursive: true })
+  copyFileSync(DEV, join(root, 'scripts/dev.ts'))
+  writeFileSync(
+    join(root, 'scripts/dev/setup.sh'),
+    `echo ran > "${root}/setup.ran"\n${setup}\n`,
+  )
+  writeFileSync(
+    join(root, 'heavy.js'),
+    `const memory = Buffer.alloc(1536 * 1024 * 1024, 1)\nrequire('node:fs').writeFileSync(${JSON.stringify(join(root, 'web.heavy'))}, String(memory.length))\nsetInterval(() => memory[0]++, 1000)\n`,
+  )
+  for (const app of APPS) {
+    const dir = join(root, 'apps', app)
+    mkdirSync(dir, { recursive: true })
+    writeFileSync(
+      join(dir, 'package.json'),
+      JSON.stringify({ name: app, scripts: { dev: 'sh dev.sh' } }),
+    )
+    const body =
+      app === 'server' && exit !== undefined
+        ? `while [ ! -e "${root}/server.exit" ]; do sleep 0.05; done\nexit ${exit}`
+        : `sh -c '${(stubborn || heavy) && app === 'web' ? 'trap "" TERM; ' : ''}echo $$ > "${root}/${app}.grandchild.tmp"; mv "${root}/${app}.grandchild.tmp" "${root}/${app}.grandchild"; exec ${heavy && app === 'web' ? `"${process.execPath}" "${root}/heavy.js"` : 'sleep 600'}'`
+    writeFileSync(
+      join(dir, 'dev.sh'),
+      `env > "${root}/${app}.env"\necho $PPID $$ > "${root}/${app}.pids"\n${body}\n`,
+    )
+  }
+}
+
+const PROC = existsSync('/proc/self/stat')
+
+/** Running; on Linux not a zombie that init has not reaped yet (a SIGKILLed orphan is one at first) */
+function alive(pid: number) {
+  try {
+    if (PROC)
+      return (
+        readFileSync(`/proc/${pid}/stat`, 'utf8').split(') ')[1]?.[0] !== 'Z'
+      )
+    process.kill(pid, 0)
+    return true
+  } catch {
+    return false
+  }
+}
+
+async function until(check: () => boolean, ms = 10_000) {
+  const end = Date.now() + ms
+  while (!check()) {
+    if (Date.now() > end) throw new Error('timed out')
+    await Bun.sleep(50)
+  }
+}
+
+/** Runs dev.ts from another working directory than the root, as `bun scripts/dev.ts` does from anywhere */
+function start(...args: string[]) {
+  return Bun.spawn([process.execPath, join(root, 'scripts/dev.ts'), ...args], {
+    cwd: tmpdir(),
+    stdio: ['ignore', 'ignore', 'ignore'],
+  })
+}
+
+/** Waits until both apps run with their grandchildren and returns all their pids */
+async function running(apps: readonly App[] = APPS) {
+  const files = apps
+    .flatMap((app) => [`${app}.pids`, `${app}.grandchild`])
+    .map((name) => join(root, name))
+  await until(() =>
+    files.every(
+      (file) => existsSync(file) && readFileSync(file, 'utf8').trim() !== '',
+    ),
+  )
+  pids = files.flatMap((file) =>
+    readFileSync(file, 'utf8').trim().split(' ').map(Number),
+  )
+  expect(pids).toHaveLength(apps.length * 3)
+  expect(pids.filter(alive)).toEqual(pids)
+  return pids
+}
+
+function env(app: App) {
+  return Object.fromEntries(
+    readFileSync(join(root, `${app}.env`), 'utf8')
+      .split('\n')
+      .filter((line) => line.includes('='))
+      .map((line) => [
+        line.slice(0, line.indexOf('=')),
+        line.slice(line.indexOf('=') + 1),
+      ]),
+  )
+}
+
+for (const [signal, code] of [
+  ['SIGTERM', 143],
+  ['SIGINT', 130],
+  ['SIGHUP', 129],
+] as const) {
+  test(`${signal} stops both servers with everything they started, then exits ${code}`, async () => {
+    sandbox()
+    const dev = start()
+    const started = await running()
+
+    dev.kill(signal)
+    expect(await dev.exited).toBe(code)
+
+    expect(started.filter(alive)).toEqual([])
+  }, 20_000)
+}
+
+test('a process that ignores SIGTERM gets SIGKILL after the grace time', async () => {
+  sandbox({ stubborn: true })
+  const dev = start()
+  const started = await running()
+
+  dev.kill('SIGTERM')
+  expect(await dev.exited).toBe(143)
+
+  expect(started.filter(alive)).toEqual([])
+}, 20_000)
+
+test('after SIGKILL it waits until the group is gone before it exits', async () => {
+  // A process that holds a lot of memory is still running for some ms after SIGKILL
+  sandbox({ heavy: true })
+  const dev = start()
+  const started = await running()
+  await until(() => existsSync(join(root, 'web.heavy')))
+
+  dev.kill('SIGTERM')
+  expect(await dev.exited).toBe(143)
+
+  expect(started.filter(alive)).toEqual([])
+}, 20_000)
+
+/** The process's state letter from /proc (T: stopped), '' when it is gone */
+function state(pid: number) {
+  try {
+    return readFileSync(`/proc/${pid}/stat`, 'utf8').split(') ')[1]?.[0] ?? ''
+  } catch {
+    return ''
+  }
+}
+
+test.if(PROC)('Ctrl+Z (SIGTSTP) stops both servers with dev.ts, fg (SIGCONT) resumes them', async () => {
+  sandbox()
+  const dev = start()
+  const started = await running()
+
+  dev.kill('SIGTSTP')
+  await until(() => state(dev.pid) === 'T', 2_000)
+  await Bun.sleep(300)
+  expect(started.map(state)).toEqual(started.map(() => 'T'))
+
+  dev.kill('SIGCONT')
+  await until(() => [dev.pid, ...started].every((pid) => state(pid) !== 'T'), 2_000)
+
+  dev.kill('SIGTERM')
+  expect(await dev.exited).toBe(143)
+  expect(started.filter(alive)).toEqual([])
+}, 20_000)
+
+test('when one server exits, the other is stopped and its exit code is passed on', async () => {
+  sandbox({ exit: 7 })
+  const dev = start()
+  const web = await running(['web'])
+  writeFileSync(join(root, 'server.exit'), '')
+
+  expect(await dev.exited).toBe(7)
+
+  expect(web.filter(alive)).toEqual([])
+}, 20_000)
+
+test('without --demo both get ./snapraid as base path, which is created, and setup.sh does not run', async () => {
+  sandbox()
+  const dev = start()
+  await running()
+  dev.kill('SIGTERM')
+  await dev.exited
+
+  for (const app of APPS) {
+    expect(env(app).SNAPRAID_BASE_PATH).toBe(join(root, 'snapraid'))
+    expect(env(app).SNAPRAID_DEMO).toBeUndefined()
+  }
+  expect(existsSync(join(root, 'snapraid'))).toBe(true)
+  expect(existsSync(join(root, 'setup.ran'))).toBe(false)
+}, 20_000)
+
+test('--demo runs setup.sh and gives both the sandbox, its snapraid and the demo flags', async () => {
+  sandbox()
+  const dev = start('--demo')
+  await running()
+  dev.kill('SIGTERM')
+  await dev.exited
+
+  expect(existsSync(join(root, 'setup.ran'))).toBe(true)
+  for (const app of APPS) {
+    expect(env(app)).toMatchObject({
+      SNAPRAID_BASE_PATH: join(root, 'scripts/dev/sandbox'),
+      SNAPRAID_BIN: join(root, 'scripts/dev/bin/snapraid'),
+      SNAPRAID_EXTRA_ARGS: '--test-skip-device',
+      SNAPRAID_DEMO: '1',
+    })
+  }
+  expect(existsSync(join(root, 'snapraid'))).toBe(false)
+}, 20_000)
+
+test('--demo aborts with exit code 1 when setup.sh fails, before starting anything', async () => {
+  sandbox({ setup: 'exit 3' })
+  const dev = start('--demo')
+
+  expect(await dev.exited).toBe(1)
+
+  expect(existsSync(join(root, 'setup.ran'))).toBe(true)
+  for (const app of APPS)
+    expect(existsSync(join(root, `${app}.pids`))).toBe(false)
+}, 20_000)
diff --git a/scripts/dev.ts b/scripts/dev.ts
new file mode 100644
index 0000000..4d99bc8
--- /dev/null
+++ b/scripts/dev.ts
@@ -0,0 +1,149 @@
+// `bun run dev` / `bun run demo`: runs the backend (`bun run dev` in apps/server, :8080) and
+// the frontend (`bun run dev` in apps/web, Vite on :3000) side by side, with Bun alone.
+//
+//   bun scripts/dev.ts          -> uses ./snapraid and the system snapraid binary
+//   bun scripts/dev.ts --demo   -> uses the dev sandbox (see scripts/dev/setup.sh)
+//
+// Each command runs in a process group of its own (as ccu-addon-mui's scripts/dev.ts), so
+// stopping it stops everything it started too (bun --watch, Vite and their children). When
+// one of the two exits, the other is stopped and this script exits with the first one's code.
+// SIGINT (Ctrl+C), SIGTERM (kill, an IDE) and SIGHUP (closing the terminal) go on to both
+// groups; once they are gone the script exits with 128 + the signal's number (130 for Ctrl+C).
+// Ctrl+Z stops both groups with the script, `fg` resumes them.
+import { mkdirSync } from 'node:fs'
+import { constants } from 'node:os'
+import { dirname, join } from 'node:path'
+
+type Child = ReturnType<typeof Bun.spawn>
+
+const SIGNALS = ['SIGINT', 'SIGTERM', 'SIGHUP'] as const
+/** How long a group may take to exit after SIGTERM before it gets SIGKILL */
+const GRACE_MS = 5_000
+
+// The repository's root, one level above scripts/, whatever the working directory
+const root = dirname(import.meta.dir)
+const demo = process.argv[2] === '--demo'
+
+/** The environment both servers get, as the former fish script scripts/start.sh set it */
+const environment = (demo: boolean): Record<string, string> =>
+  demo
+    ? {
+        SNAPRAID_BASE_PATH: join(root, 'scripts/dev/sandbox'),
+        SNAPRAID_BIN: join(root, 'scripts/dev/bin/snapraid'),
+        // All sandbox "disks" live on one filesystem, which snapraid rejects without this
+        SNAPRAID_EXTRA_ARGS: '--test-skip-device',
+        // Sandbox disks are directories without SMART, the backend fakes smart and probe
+        SNAPRAID_DEMO: '1',
+      }
+    : { SNAPRAID_BASE_PATH: join(root, 'snapraid') }
+
+const children: Child[] = []
+/** Set once a signal arrived: the code to exit with */
+let stopping: number | undefined
+/** Resolves with that code once both groups are gone */
+const signalled = Promise.withResolvers<number>()
+
+/** Sends a signal to a child's whole process group; it may have exited already */
+const signalGroup = (child: Child, signal: NodeJS.Signals) => {
+  try {
+    process.kill(-child.pid, signal)
+  } catch {
+    // the group is gone
+  }
+}
+
+const groupAlive = (child: Child) => {
+  try {
+    process.kill(-child.pid, 0)
+    return true
+  } catch {
+    return false
+  }
+}
+
+/** How long a group may take to go after SIGKILL; an orphan stays in it as a zombie until init reaps it */
+const KILL_MS = 1_000
+
+/** Polls until a child's group is gone, at most `ms` */
+const groupGone = async (child: Child, ms: number) => {
+  const end = Date.now() + ms
+  while (groupAlive(child) && Date.now() < end) await Bun.sleep(50)
+}
+
+/** Waits until a child and everything in its group has exited, with SIGKILL after the grace time */
+const reap = async (child: Child) => {
+  await groupGone(child, GRACE_MS)
+  if (groupAlive(child)) {
+    signalGroup(child, 'SIGKILL')
+    // SIGKILL is not instant: the kernel still has to tear the processes down
+    await groupGone(child, KILL_MS)
+  }
+  await child.exited
+}
+
+const stopAll = async (signal: NodeJS.Signals) => {
+  for (const child of children) signalGroup(child, signal)
+  await Promise.all(children.map(reap))
+}
+
+for (const signal of SIGNALS) {
+  process.on(signal, async () => {
+    if (stopping !== undefined) return
+    stopping = 128 + constants.signals[signal]
+    await stopAll(signal)
+    signalled.resolve(stopping)
+  })
+}
+
+// Ctrl+Z (SIGTSTP) reaches only this script, the children's sessions are out of the terminal's
+// reach: stop their groups too, with SIGSTOP as the kernel drops SIGTSTP sent to an orphaned group
+// (a session of its own is one), then this script; `fg` (SIGCONT) resumes them (as in haul's dev.ts)
+process.on('SIGTSTP', () => {
+  for (const child of children) signalGroup(child, 'SIGSTOP')
+  process.kill(process.pid, 'SIGSTOP')
+})
+process.on('SIGCONT', () => {
+  for (const child of children) signalGroup(child, 'SIGCONT')
+})
+
+const exitIfSignalled = async () => {
+  if (stopping !== undefined) process.exit(await signalled.promise)
+}
+
+const spawn = (cmd: string[], cwd: string, env: Record<string, string>) => {
+  const child = Bun.spawn(cmd, {
+    cwd,
+    env: { ...process.env, ...env },
+    stdio: ['ignore', 'inherit', 'inherit'],
+    detached: true,
+  })
+  children.push(child)
+  return child
+}
+
+if (demo) {
+  // Build binary and sandbox on first run, no-op afterwards
+  const setup = spawn(['bash', join(root, 'scripts/dev/setup.sh')], root, {})
+  const code = await setup.exited
+  children.length = 0
+  await exitIfSignalled()
+  if (code !== 0) process.exit(1)
+}
+
+await exitIfSignalled()
+const env = environment(demo)
+// Local data directory, the backend fills it on first start
+if (!demo) mkdirSync(env.SNAPRAID_BASE_PATH, { recursive: true })
+
+// process.execPath is the Bun running this script, so no other Bun has to be on the PATH
+const servers = [
+  spawn([process.execPath, 'run', 'dev'], join(root, 'apps/server'), env),
+  spawn([process.execPath, 'run', 'dev'], join(root, 'apps/web'), env),
+]
+
+const code = await Promise.race(servers.map((child) => child.exited))
+await exitIfSignalled()
+// A signal from now on finds the stop under way and leaves the exit code alone
+stopping = code
+await stopAll('SIGTERM')
+process.exit(code)
diff --git a/scripts/dev/setup.sh b/scripts/dev/setup.sh
index 07e7869..a496d7a 100755
--- a/scripts/dev/setup.sh
+++ b/scripts/dev/setup.sh
@@ -188,4 +188,4 @@ snapraid_logged status
 (cd "$BACKEND_DIR" && bun scripts/seed-demo.ts "$SANDBOX")
 
 echo
-echo "Sandbox ready. Start the app with: bun run demo (scripts/start.sh --demo)"
+echo "Sandbox ready. Start the app with: bun run demo (scripts/dev.ts --demo)"
diff --git a/scripts/start.sh b/scripts/start.sh
deleted file mode 100755
index c7404cf..0000000
--- a/scripts/start.sh
+++ /dev/null
@@ -1,62 +0,0 @@
-#!/usr/bin/env fish
-
-# Usage: scripts/start.sh          -> uses ./snapraid and the system snapraid binary
-#        scripts/start.sh --demo   -> uses the dev sandbox (see scripts/dev/setup.sh)
-
-# The repository's root, one level above scripts/
-set root (dirname (dirname (realpath (status filename))))
-
-if test "$argv[1]" = "--demo"
-    # Build binary and sandbox on first run, no-op afterwards
-    bash $root/scripts/dev/setup.sh; or exit 1
-    set -x SNAPRAID_BASE_PATH $root/scripts/dev/sandbox
-    set -x SNAPRAID_BIN $root/scripts/dev/bin/snapraid
-    # All sandbox "disks" live on one filesystem, which snapraid rejects without this
-    set -x SNAPRAID_EXTRA_ARGS --test-skip-device
-    # Sandbox disks are directories without SMART, the backend fakes smart and probe
-    set -x SNAPRAID_DEMO 1
-else
-    set -x SNAPRAID_BASE_PATH $root/snapraid
-    # Local data directory, the backend fills it on first start
-    mkdir -p $SNAPRAID_BASE_PATH
-end
-
-if not command -q bun
-    echo "Bun not found. Install it: https://bun.sh" >&2
-    exit 1
-end
-
-# Stop a process and everything it started
-function kill_tree
-    for child in (pgrep -P $argv[1])
-        kill_tree $child
-    end
-    kill $argv[1] 2>/dev/null
-end
-
-# Stop both servers with SIGTERM, also on Ctrl+C
-function stop_servers --on-event fish_exit
-    for pid in $backend_pid $frontend_pid
-        kill_tree $pid
-    end
-end
-
-function on_interrupt --on-signal INT --on-signal TERM
-    exit 130
-end
-
-# Starte Backend im Hintergrund
-cd $root/apps/server
-bun run dev &
-set -g backend_pid $last_pid
-
-# Starte Frontend im Hintergrund
-cd $root/apps/web
-bun run dev &
-set -g frontend_pid $last_pid
-
-# Warte auf beide Prozesse. Polling statt wait, weil fish wait nur bei SIGINT unterbricht;
-# endet einer, stoppt fish_exit den anderen
-while kill -0 $backend_pid 2>/dev/null; and kill -0 $frontend_pid 2>/dev/null
-    sleep 1
-end