Merge pull request 'v0.14.0 — ISS-006 time-scale slider values up to 1000x; tests use fastest time' (#14) from feat/time-scale-slider-1000x into master

.dockerignore

@@ -1,4 +1,6 @@
-node_modules
+# node_modules is intentionally IN the build context: the Dockerfile copies it straight
+# into the image (deps are installed by the CI job / dev host, which have working network;
+# the runner's dind daemon has broken outbound DNS for build containers).
 .next
 data/*.db
 # game state DB (v0.6.0): host-side, volume-mounted at runtime — never baked in
@@ -8,7 +10,8 @@ test-results
 .git
 .env
 .codenomad
-# e2e harness: @playwright/test is a host-global install, not a project dependency
+# e2e harness: the suite runs on the host / CI job, never inside the image
+# (@playwright/test is a devDependency of the runner, excluded from prod-deps)
 e2e
 playwright.config.ts
 # docs/deployment files never affect the app build — excluding them keeps

.gitea/workflows/ci.yml

@@ -0,0 +1,200 @@
+name: CI
+
+on:
+  push:
+    branches: [master]
+  pull_request:
+    branches: [master]
+  workflow_dispatch:
+
+jobs:
+  ci:
+    name: build + unit + e2e
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      # The runner provides a working docker CLI out of the box (full-dind) — no endpoint
+      # resolution needed. Job and app containers share the daemon, so put them on one
+      # user-defined network with a pinned subnet; the app gets a STATIC IP (172.39.0.10,
+      # declared in docker-compose.ci.yml) because Chromium got ERR_SSL_PROTOCOL_ERROR via
+      # the DNS alias while node-side HTTP to the same name worked — bypassing DNS removes
+      # that variable entirely. A stale network with a different subnet is recreated.
+      - name: Prepare e2e network
+        run: |
+          set -u
+          SUBNET=172.39.0.0/24
+          if docker network inspect flight-ci-e2e >/dev/null 2>&1; then
+            cur=$(docker network inspect flight-ci-e2e --format '{{(index .IPAM.Config 0).Subnet}}')
+            if [ "$cur" != "$SUBNET" ]; then
+              echo "stale flight-ci-e2e with subnet $cur — recreating with $SUBNET"
+              docker network rm flight-ci-e2e || true
+              docker network create --subnet "$SUBNET" flight-ci-e2e
+            fi
+          else
+            docker network create --subnet "$SUBNET" flight-ci-e2e
+          fi
+          if ! docker network connect flight-ci-e2e "$(hostname)"; then
+            echo "::error::failed to attach job container '$(hostname)' to flight-ci-e2e — the job must run in a container on the shared daemon (check runner config)" >&2
+            exit 1
+          fi
+          docker network inspect flight-ci-e2e --format 'containers on flight-ci-e2e: {{range .Containers}}{{.Name}} {{end}}'
+          echo "E2E_BASE_URL=http://172.39.0.10:3000" >> "$GITHUB_ENV"
+
+      - name: Setup Node
+        uses: actions/setup-node@v4
+        with:
+          node-version: 22
+
+      # bun drives installs (repo ships bun.lock, no package-lock.json); pinned to 1.4.2.
+      # Retried: the runner's outbound network/DNS is flaky (transient EAI_AGAIN seen in CI).
+      - name: Install bun
+        run: |
+          set -u
+          ok=0
+          for i in 1 2 3; do
+            if npm i -g bun@1.4.2; then ok=1; break; fi
+            echo "::warning::bun install attempt $i/3 failed (likely transient network) — retrying in 5s" >&2
+            sleep 5
+          done
+          [ "$ok" = "1" ] || { echo "::error::bun install failed after 3 attempts" >&2; exit 1; }
+          bun --version
+
+      # Job-level dep cache via the runner's built-in cache server. continue-on-error on
+      # both steps: an unreachable/broken cache server must never break the run.
+      - name: Restore deps cache
+        uses: actions/cache@v4
+        continue-on-error: true
+        with:
+          path: |
+            node_modules
+            $HOME/.bun/install/cache
+          key: ${{ runner.os }}-deps-bun-${{ hashFiles('bun.lock') }}
+
+      # Retried: the runner's outbound network/DNS is flaky (transient EAI_AGAIN seen in CI).
+      - name: Install dependencies
+        run: |
+          set -u
+          ok=0
+          for i in 1 2 3; do
+            if bun install --frozen-lockfile; then ok=1; break; fi
+            echo "::warning::dependency install attempt $i/3 failed (likely transient network) — retrying in 5s" >&2
+            sleep 5
+          done
+          [ "$ok" = "1" ] || { echo "::error::dependency install failed after 3 attempts" >&2; exit 1; }
+
+      # No explicit save step: caches marked by the restore steps are uploaded automatically at job end.
+
+      # Map e2e tests abort ALL *.openfreemap.org traffic (page.route → route.abort()), assuming
+      # styles/fonts/sprites are SELF-HOSTED from /styles, /fonts, /sprites — locally that pack is
+      # produced by `npm run assets:download` and reaches the app via the compose volume mount.
+      # CI must reproduce it or lib/mapStyles.ts probes /map-assets-manifest.json, finds nothing,
+      # falls back to remote OFM styles — which the tests abort → style never loads (the
+      # deterministic map.spec.ts wheel-zoom + style-switcher failures). The script needs no env
+      # vars/args and writes into ./public (git-ignored, docker-excluded; the app container gets
+      # it via the volume mount in docker-compose.ci.yml).
+      - name: Restore map assets cache
+        uses: actions/cache@v4
+        continue-on-error: true
+        with:
+          path: public/
+          key: ${{ runner.os }}-map-assets-${{ hashFiles('scripts/download-map-assets.mjs') }}
+
+      # Retried: the runner's uplink is flaky (same transient EAI_AGAIN pattern as dep install).
+      # The job-end cache upload seeds public/ for future runs; a partial pack without
+      # map-assets-manifest.json is harmless — the app probes that manifest and falls back to
+      # remote styles when it's missing.
+      - name: Download map assets (retries)
+        run: |
+          set -u
+          ok=0
+          for i in 1 2 3 4 5 6; do
+            if npm run assets:download; then ok=1; break; fi
+            echo "::warning::map assets download attempt $i/6 failed (likely transient network) — retrying in 5s" >&2
+            sleep 5
+          done
+          [ "$ok" = "1" ] || { echo "::error::map assets download failed after 6 attempts" >&2; exit 1; }
+
+      - name: Build
+        run: npm run build
+
+      - name: Unit tests
+        run: npx vitest run
+
+      # Browsers run locally in CI (PW_REMOTE_BROWSER=0 below): the shared remote browser
+      # server at 192.168.1.4 cannot reach a stack inside dind, and local chromium keeps
+      # the job self-contained.
+      # Browser binaries (~187 MiB) cached across runs: the runner's uplink is flaky and
+      # cdn.playwright.dev downloads time out mid-transfer; once seeded, installs skip the download.
+      - name: Restore browser cache
+        uses: actions/cache@v4
+        continue-on-error: true
+        with:
+          path: $HOME/.cache/ms-playwright
+          key: ${{ runner.os }}-pw-browsers-${{ hashFiles('package.json') }}
+
+      # Retried: cdn.playwright.dev is flaky from this runner — Playwright's internal 5-retry
+      # window (~40-90s) is often not enough, but runs get through with a longer one. Progress
+      # accumulates across attempts: playwright skips already-installed browsers.
+      - name: Install browsers (local)
+        run: |
+          set -u
+          ok=0
+          for i in 1 2 3 4 5 6; do
+            if npx playwright install --with-deps chromium; then ok=1; break; fi
+            echo "::warning::browser install attempt $i/6 failed (flaky cdn.playwright.dev) — retrying in 5s" >&2
+            sleep 5
+          done
+          [ "$ok" = "1" ] || { echo "::error::browser install failed after 6 attempts" >&2; exit 1; }
+
+      # Cache the base image on the shared daemon up front: a single loud failure here
+      # beats a 6-minute BuildKit "failed to solve" when the daemon's outbound net is down.
+      - name: Pull e2e base image
+        run: docker pull node:22-slim
+
+      # Pre-build the e2e image with retries (flaky runner network); the E2E step's own
+      # build then becomes a fast no-op. Plain progress keeps BuildKit output visible.
+      - name: Build e2e image (retries)
+        run: |
+          set -u
+          ok=0
+          for i in 1 2 3; do
+            if docker compose -f docker-compose.ci.yml -p flight-ci build --progress=plain; then ok=1; break; fi
+            echo "::warning::e2e image build attempt $i/3 failed (likely transient network) — retrying in 5s" >&2
+            sleep 5
+          done
+          [ "$ok" = "1" ] || { echo "::error::e2e image build failed after 3 attempts" >&2; exit 1; }
+
+      # E2E against an isolated stack on the shared daemon — never the production instance.
+      # docker-compose.ci.yml joins the flight-ci-e2e network prepared above; project name
+      # flight-ci keeps it distinct from production. E2E_DEPLOY_CMD makes the config's
+      # webServer block deploy + wait for readiness (http://app:3000 via service DNS);
+      # E2E_COMPOSE_ARGS points state.spec.ts' mid-run `docker compose restart flight` at
+      # the same file + project. E2E_BASE_URL comes from GITHUB_ENV (Prepare e2e network).
+      - name: E2E (isolated stack in dind)
+        env:
+          PW_REMOTE_BROWSER: "0"
+          # Build separately with plain progress so BuildKit step output is visible in the
+          # job log (auto progress hides it). Playwright's webServer needs a long-running
+          # command — `up -d` returns immediately and triggers "exited early"; `logs -f`
+          # keeps it alive, streams app logs into CI output for debugging, and is killed with
+          # the job (an orphaned `logs -f` dies on its own when cleanup removes the container).
+          E2E_DEPLOY_CMD: "docker compose -f docker-compose.ci.yml -p flight-ci build --progress=plain && docker compose -f docker-compose.ci.yml -p flight-ci up -d && docker compose -f docker-compose.ci.yml -p flight-ci logs -f"
+          E2E_COMPOSE_ARGS: "-f docker-compose.ci.yml -p flight-ci"
+          # Chromium honors proxy env vars on Linux (node-side HTTP does not) — keep the
+          # in-network app host out of any proxy path.
+          NO_PROXY: app,localhost,127.0.0.1,.kkhost.pl
+          no_proxy: app,localhost,127.0.0.1,.kkhost.pl
+        # Connectivity diagnostics now run post-deploy in e2e/ci-diagnostics.ts (globalSetup).
+        # --reporter=list prints each test as it completes (name + ✓/× + duration) for progress
+        # visibility in the job log; failure error context/snapshots are unchanged.
+        run: npx playwright test --reporter=list
+
+      # The daemon is shared with production — never leave our stack or network behind.
+      # -v drops the named DB volume so every run seeds fresh (no schema drift between PRs).
+      - name: Cleanup e2e stack + network
+        if: always()
+        run: |
+          docker compose -f docker-compose.ci.yml -p flight-ci down --remove-orphans -v || true
+          docker network remove flight-ci-e2e 2>/dev/null || true

AGENTS.md

@@ -2,14 +2,17 @@
 
 ## Change process (mandatory)
 1. **Small, incremental changes** — work is done one change at a time, in smaller parts; each part must be tested thoroughly with unit and e2e tests covering it before moving on.
-2. **Changelog entry** — every such change is listed in `CHANGELOG.md` with date, time and version (format: `## v<version> — YYYY-MM-DD HH:MM`, then bullet points of what changed).
-3. **Version bump** — the version is updated in `package.json`.
-4. **Commit + tag** — a commit is created for each change, tagged with the version (e.g. `v0.1.0`), push it to remote repo.
+2. **Feature branch + PR** — every change lands on a feature branch off `master` (no direct pushes to master). The branch carries the commits below; open a pull request to `master`.
+3. **Changelog entry** — every such change is listed in `CHANGELOG.md` with date, time and version (format: `## v<version> — YYYY-MM-DD HH:MM`, then bullet points of what changed).
+4. **Version bump** — the version is updated in `package.json`.
+5. **CI must pass** — the PR's pipeline (build → unit tests → e2e, `.gitea/workflows/ci.yml`) must be green before merging. CI never deploys to production; its e2e runs against an isolated stack inside dind.
+6. **Tag + manual deploy after merge** — once merged, tag the version on `master` (e.g. `v0.13.0`). Production (`https://flight.dev.kkhost.pl`) is updated manually afterwards: `docker compose up -d --build` on the host.
 
 ## E2E tests (mandatory)
-1. **Docker compose instance is the app under test** — e2e always runs against the docker-compose build behind Traefik (`https://flight.dev.kkhost.pl`), never a local `next dev` on :3000 (dev builds don't render for non-loopback clients, and a second instance splits state).
-2. **Update before testing** — deploy current code first: `docker compose up -d --build`.
-3. **Remote browsers** — tests run through the shared Playwright server at `192.168.1.4:3000` (Docker image tag must match this repo's @playwright/test version); plain `npx playwright test` handles deploy + readiness + remote connect (see `playwright.config.ts`).
+1. **Docker compose instance is the app under test** — e2e always runs against a docker-compose build, never a local `next dev` on :3000 (dev builds don't render for non-loopback clients, and a second instance splits state). Locally that means the Traefik-routed instance at `https://flight.dev.kkhost.pl`; in CI it is an isolated stack inside dind (`docker-compose.ci.yml`) — **CI never deploys to or modifies production**.
+2. **Update before testing (local)** — deploy current code first: `docker compose up -d --build`, then run the suite with plain `npx playwright test`. The config's webServer block is off by default; set `E2E_DEPLOY_CMD` to have Playwright itself run a deploy command and wait for readiness.
+3. **Remote browsers** — local runs drive browsers through the shared Playwright server at `192.168.1.4:3000` (Docker image tag must match this repo's @playwright/test version, pinned in devDependencies). Set `PW_REMOTE_BROWSER=0` to run local chromium instead — CI does, because the remote server cannot reach a stack inside dind.
+4. **CI env vars** (`playwright.config.ts`, all optional; defaults preserve the local flow) — `E2E_BASE_URL` (app under test), `E2E_DEPLOY_CMD` (webServer deploy command), `PW_REMOTE_BROWSER=0` (local browsers); `e2e/state.spec.ts` reads `E2E_COMPOSE_ARGS` for its mid-run container restart.
 
 ## API
 1. **Live base URL** — `https://flight.dev.kkhost.pl` (the docker-compose build behind Traefik).

CHANGELOG.md

@@ -1,8 +1,32 @@
 # Changelog
 
+## v0.14.0 — 2026-09-19 08:45
+- **Time-scale slider reworked to a 10-step ladder up to 1000× (ISS-006).** The old power-of-two ladder `1/2/4/8/16/32/64` is replaced by the discrete values `1, 2, 5, 10, 25, 50, 100, 250, 500, 1000` (each step roughly doubles the speed). The server clamp range widens from `[1, 64]` to `[1, 1000]` (`MAX_TIME_SCALE` in `lib/sim/engine.ts`, enforced by `clampTimeScale`; out-of-range values are still clamped, never rejected), and the OpenAPI spec's `timeScale` bounds + description follow. The slider mapping helpers in `lib/timeScale.ts` now place off-ladder scales at the nearest ladder step **by log distance** (the old `log2` formula assumed a pure power-of-two ladder); round-trip, monotonicity and endpoint-exactness are preserved
+- **E2e suite runs at the fastest time.** Every spec's fast-forward scale moves from 60× to the new top of 1000× (`sim`, `actions`, `right-pane`, `map-interactions`), so flights/expiries resolve in seconds instead of minutes. The map mid-flight test (`map-interactions.spec.ts`) needed a longer leg to keep its click assertions inside the flight window at 1000×: destination moves EDDV (Hannover, ~2 s real) → LEMD (Madrid–Barajas, ~10 s real), with a full-tank refuel before departure so the ~4970 L round trip always fits the 6300 L tank. The slider e2e (`panes.spec.ts`) now asserts End→`1000×` / Home→`1×`, and the clamp tests post `2000` → expect `1000` (500 is a valid ladder value, so it passes through unclamped)
+- Tests: unit — `lib/timeScale.test.ts` covers the 10-position ladder + log-distance nearest-step mapping; new `clampTimeScale` boundary suite in `lib/sim/engine.test.ts` (`[1, 1000]`, full ladder pass-through); `app/api/sim/route.test.ts` and `lib/openapi.test.ts` updated to the new bounds. Verified: unit suite **238/238** green locally (was 234 before this change)
+- e2e `map-interactions.spec.ts`: the plane-popup test now pauses the sim around the marker click — at 1000× the rendered marker lags a fresh `/api/state` fetch by up to one map poll (~1 s), tens of px of drift on the EDDF→LEMD leg, so `page.mouse.click` missed the small circle layer (CI run #29); the sim is paused until the popup assertions pass, then resumed
+
+## v0.13.1 — 2026-09-19 08:09
+- CI e2e step now uses Playwright's list reporter so every test prints as it runs in the job log (progress visibility); failures still get full error context
+
 ## v0.12.3 — 2026-09-19 07:36
 - **e2e: removed the unreliable curved-route assertion from `map-interactions.spec.ts`.** The "route line has >2 coordinates in the routes source" check (added with v0.12.2) failed in CI and against the live instance even though the arc renders correctly — MapLibre's `querySourceFeatures` returns tile-simplified geometry at low zoom, so coordinate counts from it are not a reliable signal for what was pushed into the source. The curved arc remains fully covered by unit tests (`lib/mapData.test.ts`: 25 sampled coordinates, exact endpoints, curvature on long routes); the spec keeps all other steps (grounded plane draws no line, marker moves across polls, plane popup with status + route)
 
+## v0.13.0 — 2026-09-18 15:31
+- **CI + pull-request workflow** (process/infra): new `.gitea/workflows/ci.yml` runs build → unit tests → e2e on every PR to master and on push to master, in one job with a `docker:dind` service. E2E isolation: the suite targets a fresh compose stack inside dind (`docker-compose.ci.yml` — mirrors docker-compose.yml minus Traefik/dev_net; app served directly on port 3000 of the dind container; game state in a named volume so it is fresh per run and survives `state.spec.ts`'s mid-run restart) — **CI never deploys to or touches production**. The dind endpoint is resolved at job start (tries `tcp://localhost:2375`, then `tcp://docker:2375` — Gitea services are sibling containers reachable by service id on the job network) and exported as `DOCKER_HOST` + `E2E_BASE_URL`; build context is tarred by the compose client in the job, so nothing needs to be visible from inside dind
+- **Playwright config made CI-aware, backward-compatible** (`playwright.config.ts`): new optional env vars — `PW_REMOTE_BROWSER=0` (local chromium instead of the shared remote server at 192.168.1.4:3000), `E2E_DEPLOY_CMD` (runs as webServer + readiness wait; unset = current local behavior with no auto-deploy); `E2E_BASE_URL` already existed. `e2e/state.spec.ts` reads `E2E_COMPOSE_ARGS` for its mid-run `docker compose restart flight` (default empty → unchanged locally)
+- **@playwright/test pinned as devDependency** (`1.63.0`, matching the shared remote browser server image and the global install) so CI is self-contained; still excluded from the runtime image via .dockerignore (comment updated), prod-deps stage unaffected
+- `AGENTS.md`: "Change process" + "E2E tests" rewritten for the PR workflow — feature branch off master → commits with CHANGELOG entry + version bump → PR to master → CI (build→unit→e2e) green → merge → tag on master → manual production deploy via `docker compose up -d --build`; no direct pushes to master, CI never deploys
+- **CI build reliability + caching** (after first dind runs): the e2e image is now built with `--progress=plain` before `up -d` so BuildKit step output lands in job logs instead of being hidden by auto progress; Dockerfile bun installs use a BuildKit cache mount (`/root/.bun/install/cache`) that persists on the runner's shared daemon, and CI restores/saves node_modules + the bun cache via actions/cache around dependency install (both steps `continue-on-error` — safe while the runner's cache server is being fixed)
+- **CI flaky-network handling settled on retry wrappers** (transient EAI_AGAIN failures seen in runs #10/#11): bun install, dependency install and the e2e image build each retry up to 3× with 5s between attempts before failing — run #12 with this setup got furthest (build + unit + browsers green). A short-lived "DNS diagnostics" step was tried but removed: its daemon-side probe pulled an image not present on the runner's docker daemon and stalled runs #13/#14 at Setup Node
+- **E2e image build needs no outbound network from dind build containers** (DNSResolveFailed in `RUN bun install` across runs #10/#12/#15): node_modules is now installed in the CI job / dev host and copied into the build context (.dockerignore no longer excludes it; Dockerfile COPYs it instead of running any install inside the image); base images switched alpine → node:22-slim (glibc) for native-module ABI compatibility with the job-installed tree (@next/swc-*, sharp are prebuilt per platform — CI job and prod host are x86_64 glibc linux); a "Pull e2e base image" step fails fast if the daemon can't fetch node:22-slim
+- **CI e2e deploy command stays alive** (`E2E_DEPLOY_CMD` now ends with `docker compose … logs -f`): Playwright's webServer requires a long-running process — `up -d` returns immediately and triggered "Process from config.webServer exited early" (run #16); `logs -f` also streams app logs into CI output for debugging
+- **CI e2e step bypasses proxies for the in-network app host** (`NO_PROXY`/`no_proxy=app,localhost,127.0.0.1,.kkhost.pl`) and prints proxy/DNS/curl diagnostics before the suite — run #18 showed Chromium getting `ERR_SSL_PROTOCOL_ERROR` on http://app:3000 while node-side HTTP worked (9 API-only tests passed), pointing at a TLS-terminating proxy env var that Chromium honors but Node's HTTP client ignores
+- **CI e2e targets the app at a static in-network IP** (`172.39.0.10`, pinned subnet `172.39.0.0/24` created by "Prepare e2e network"; stale networks with other subnets are recreated) instead of the DNS alias — Chromium got `ERR_SSL_PROTOCOL_ERROR` via the hostname while node-side HTTP worked, so DNS is removed from the equation; post-deploy connectivity diagnostics added as a CI-gated globalSetup (`e2e/ci-diagnostics.ts`, no-op locally) comparing node resolution/HTTP against Chromium navigation on both hostname and static IP
+- **CI caches Playwright browser binaries across runs** (`$HOME/.cache/ms-playwright` via actions/cache): the flaky runner uplink makes the ~187 MiB Chrome-for-Testing download unreliable (runs #20/#21 died mid-download at "Install browsers"); also removed the no-op "Save deps cache" step — on this runner caches marked by a restore step are uploaded automatically at job end, so an explicit save never did anything
+- **CI browser install runs in a bounded 6-attempt loop** — cdn.playwright.dev is flaky from the runner and Playwright's internal retry window (~40–90s) was often insufficient (runs #21–#23), while longer windows get through (runs #12/#18); already-installed browsers are skipped so progress accumulates across attempts
+- Verified: unit suite 234 green locally; e2e not run locally by design (would deploy to production) — first real pass happens in the PR's CI run
+- **CI e2e now runs in self-hosted map-assets mode** — the workflow downloads the OpenFreeMap asset pack (`npm run assets:download` → styles/fonts/sprites into git-ignored `./public`, bounded 6-attempt retry like the other flaky-network steps) and caches it via actions/cache keyed on the download script (job-end upload seeds future runs; a partial pack without manifest is harmless — app falls back to remote); `docker-compose.ci.yml` mounts `./public:/app/public` mirroring docker-compose.yml, so map tests that abort all *.openfreemap.org traffic get self-hosted styles/fonts/sprites like local dev (fixes the deterministic map.spec.ts wheel-zoom + style-switcher failures)
 
 ## v0.12.2 — 2026-09-18 14:06
 - **Bugfix (ISS-003): route leg lines were drawn as straight two-point chords instead of following the curved great-circle path planes actually fly.** Root cause in `lib/mapData.ts`: `routesGeoJson` built each flying plane's leg LineString from only its origin and destination airport coordinates, so on long routes the drawn line cut across the chord (up to ~40 km off the true arc for a ~1400 km leg) while the plane marker moved along the curved path. Fix: new pure `greatCircleArc(from, to)` samples the same slerp used by the sim (`positionAt` in `lib/sim/movement.ts`) at t = i/24 for i = 0..24 — **25 coordinates** (exact endpoints + 23 intermediate points, `ROUTE_ARC_SEGMENTS = 24`) — so the drawn line matches the curved flight path; `routesGeoJson` now uses it instead of the two-point chord

Dockerfile

@@ -1,21 +1,14 @@
-# Multi-stage build: bun for installs (fast), node for build + runtime.
-# No BuildKit type=cache mounts: they don't persist across builds on this daemon
-# (Docker 29 + containerd image store), and bun install is fast enough (~3s cold)
-# that cross-build tarball caching isn't worth the complexity.
-FROM oven/bun:1.4.2-alpine AS deps
+# Two-stage build needing ZERO outbound network at image-build time:
+# (a) deps are installed by the CI job / dev host (`bun install`) and copied in via the
+#     build context — the runner's dind daemon has broken outbound DNS for build containers,
+#     so any RUN that fetches packages fails;
+# (b) base images must be glibc (node:22-slim), NOT alpine/musl: native modules (@next/swc-*,
+#     sharp) are prebuilt for the platform that ran `bun install` — CI job and prod host are
+#     x86_64 glibc linux. Building on another platform requires reinstalling node_modules there first.
+FROM node:22-slim AS build
 WORKDIR /app
 COPY package.json bun.lock ./
-RUN bun install --frozen-lockfile
-
-# Production dependencies only — devDeps (typescript, vitest, @types) are build-time only.
-FROM oven/bun:1.4.2-alpine AS prod-deps
-WORKDIR /app
-COPY package.json bun.lock ./
-RUN bun install --production --frozen-lockfile
-
-FROM node:22-alpine AS build
-WORKDIR /app
-COPY --from=deps /app/node_modules ./node_modules
+COPY node_modules ./node_modules
 COPY . .
 ENV NEXT_TELEMETRY_DISABLED=1
 RUN npm run build
@@ -23,10 +16,12 @@ RUN npm run build
 # No `output: 'standalone'`: the runtime stage keeps node_modules because
 # /api/mlworker/[file] reads maplibre-gl dist files from disk at runtime, and
 # /api/airports reads data/*.csv — both resolved relative to process.cwd().
-FROM node:22-alpine AS runtime
+FROM node:22-slim AS runtime
 WORKDIR /app
 ENV NODE_ENV=production NEXT_TELEMETRY_DISABLED=1
-COPY --from=prod-deps /app/node_modules ./node_modules
+# Full tree (dev+prod deps): a prod-only slimmed copy would need an extra install step,
+# revisit if image size matters.
+COPY --from=build /app/node_modules ./node_modules
 COPY --from=build /app/.next ./.next
 COPY --from=build /app/package.json ./package.json
 COPY --from=build /app/data ./data

PLAN.md

@@ -19,7 +19,7 @@ Accept job → dispatch a plane → watch it fly the route on the map → earn m
 
 ## Simulation engine
 - Server-authoritative state: sim ticks on the server, client polls and renders
-- Time scale 1x–60x + pause; sim clock persisted across sessions
+- Time scale 1x–1000x (discrete ladder 1/2/5/10/25/50/100/250/500/1000) + pause; sim clock persisted across sessions
 - SQLite via Drizzle ORM — schema designed to switch to Postgres later
 - Demand/revenue/cost formulas per contract leg; fuel burn by distance/plane type
 

app/api/sim/route.test.ts

@@ -31,19 +31,24 @@ describe('POST /api/sim', () => {
     expect(body.paused).toBe(false);
   });
 
-  it('sets and clamps timeScale into [1, 64]', async () => {
-    const hi = await post({ timeScale: 500 });
+  it('sets and clamps timeScale into [1, 1000]', async () => {
+    const hi = await post({ timeScale: 2000 });
     expect(hi.status).toBe(200);
-    expect(((await hi.json()) as { timeScale: number }).timeScale).toBe(64);
+    expect(((await hi.json()) as { timeScale: number }).timeScale).toBe(1000);
 
     const lo = await post({ timeScale: 0.1 });
     expect(lo.status).toBe(200);
     expect(((await lo.json()) as { timeScale: number }).timeScale).toBe(1);
 
-    // The top of the power-of-two ladder passes through unclamped (v0.9.2).
-    const max = await post({ timeScale: 64 });
+    // The top of the ladder passes through unclamped (v0.14.0).
+    const max = await post({ timeScale: 1000 });
     expect(max.status).toBe(200);
-    expect(((await max.json()) as { timeScale: number }).timeScale).toBe(64);
+    expect(((await max.json()) as { timeScale: number }).timeScale).toBe(1000);
+
+    // In-range values pass through unclamped — ladder and off-ladder alike.
+    const ladder = await post({ timeScale: 500 });
+    expect(ladder.status).toBe(200);
+    expect(((await ladder.json()) as { timeScale: number }).timeScale).toBe(500);
 
     const mid = await post({ timeScale: 37 });
     expect(mid.status).toBe(200);

app/api/sim/route.ts

@@ -1,6 +1,6 @@
 import { applyTimeControls } from '@/lib/sim/engine';
 
-// POST /api/sim — set sim time controls (v0.7.0). Body: { timeScale?: 1–64, paused?: boolean }.
+// POST /api/sim — set sim time controls (v0.7.0). Body: { timeScale?: 1–1000, paused?: boolean }.
 // Ticks the clock first (so the response reflects current game time), then applies
 // and persists the new controls. Returns the updated simState.
 
@@ -23,7 +23,7 @@ export async function POST(req: Request) {
     }
   }
   if (input.timeScale !== undefined && (typeof input.timeScale !== 'number' || !Number.isFinite(input.timeScale))) {
-    return Response.json({ error: 'timeScale must be a finite number (1–64)' }, { status: 400 });
+    return Response.json({ error: 'timeScale must be a finite number (1–1000)' }, { status: 400 });
   }
   if (input.paused !== undefined && typeof input.paused !== 'boolean') {
     return Response.json({ error: 'paused must be a boolean' }, { status: 400 });

app/api/test/expire-package/route.ts

@@ -17,7 +17,7 @@ import { tickNow } from '@/lib/sim/engine';
 //     (game time) so the next fast tick expires it; 404 if unknown/not open.
 //   - without: creates a fresh open package with the same short deadline.
 
-const HOOK_DEADLINE_MS = 10_000; // game ms past the current clock (~0.2 s real at 60×)
+const HOOK_DEADLINE_MS = 10_000; // game ms past the current clock (≈ 0.01 s real at the fastest 1000×)
 
 export async function POST(req: Request) {
   if (process.env.FLIGHT_TEST_HOOKS !== '1') {

bun.lock

@@ -13,6 +13,7 @@
         "sql.js": "^1.14.2",
       },
       "devDependencies": {
+        "@playwright/test": "1.63.0",
         "@types/node": "^22.20.3",
         "@types/react": "^19.3.0",
         "@types/react-dom": "^19.3.0",
@@ -123,6 +124,8 @@
 
     "@oxc-project/types": ["@oxc-project/types@0.150.0", "", {}, "sha512-rDS5/31E9HfPl/CIzGrn0DOlvBbXFseQ5URJ9sYMfstbKLD/c6Gm9vmRzRGDdAXyOIL4zmO37lc9RIwYqVruZw=="],
 
+    "@playwright/test": ["@playwright/test@1.63.0", "", { "dependencies": { "playwright": "1.63.0" }, "bin": { "playwright": "cli.js" } }, "sha512-oxMK4vllB9RK5NQ2l1pq1IfOf2AvnEuj/vYGDj0H2nMtmtZpKtCwt/l00GEO6xjGfpBNAvjovvYdCm50dRQkpQ=="],
+
     "@rolldown/binding-android-arm-eabi": ["@rolldown/binding-android-arm-eabi@1.2.9", "", { "os": "android", "cpu": "arm" }, "sha512-tNISae1QEf/vkb3xkRcjV5SEdzPE97We5IVaa2Z8jSszQPZ8U60B/YCYpw4QI7VidYsBtKavczXf+DyDs9WGxw=="],
 
     "@rolldown/binding-android-arm64": ["@rolldown/binding-android-arm64@1.2.9", "", { "os": "android", "cpu": "arm64" }, "sha512-YC8YsI30o606GTZi0VyzYlsDKFP8W61i/QzayHDkLbNEz/IShqAmTa+hsJRj13xTHA0H+6fk4b2UmGn+Q/cMlg=="],
@@ -299,6 +302,10 @@
 
     "picomatch": ["picomatch@4.0.7", "", {}, "sha512-qcJu88Q2IWqJsDD529JKMdwGm/dvInW4HvQnRwiH9JtihJvzGOscDtHE3x1pBKeUOTysQ8kVmLnJ2kJu7yhcGA=="],
 
+    "playwright": ["playwright@1.63.0", "", { "dependencies": { "playwright-core": "1.63.0" }, "bin": { "playwright": "cli.js" } }, "sha512-+7ziBLidS4NaNCdt57SUDT+wYmmd5fmiQejUic/kb+YsYSCPyOOE9sebzMjNmQrsnNpDJqd4WHvV/8lfKfUDUg=="],
+
+    "playwright-core": ["playwright-core@1.63.0", "", { "bin": { "playwright-core": "cli.js" } }, "sha512-rYCsBF/M5HjUch52bbtVONEFjv6Xu8sm8h72dNlR5bzIE1fvC/bxgspzkjSfU+MweEMmPM8KJebG6nnyxo5mCg=="],
+
     "postcss": ["postcss@8.5.23", "", { "dependencies": { "nanoid": "^3.3.16", "picocolors": "^1.1.1", "source-map-js": "^1.2.1" } }, "sha512-g50586zr4bZmwFiTlflMu8E0bDTb5I5gertgwAKmsdUlTQIhZtunzUlD1WSzwcVWPoAVpsrA6vlfCD7oXvRwgg=="],
 
     "potpack": ["potpack@2.1.0", "", {}, "sha512-pcaShQc1Shq0y+E7GqJqvZj8DTthWV1KeHGdi0Z6IAin2Oi3JnLCOfwnCo84qc+HAp52wT9nK9H7FAJp5a44GQ=="],

components/LeftPane.tsx

@@ -14,9 +14,10 @@ interface LeftPaneProps {
   onRefresh: () => void;
 }
 
-// Power-of-two slider (v0.9.2): position t ∈ [0,1] → nearest step of the ladder
-// 1×/2×/4×/8×/16×/32×/64× — each of the 7 positions doubles the speed.
-const SCALE_SLIDER_STEP = 1 / (TIME_SCALES.length - 1); // one doubling per keyboard-arrow step
+// Discrete ladder slider (v0.9.2, values reworked in v0.14.0): position t ∈ [0,1] → nearest
+// step of the ladder 1×/2×/5×/10×/25×/50×/100×/250×/500×/1000× — each of the 10 positions
+// roughly doubles the speed.
+const SCALE_SLIDER_STEP = 1 / (TIME_SCALES.length - 1); // one ladder step per keyboard-arrow step
 const SCALE_COMMIT_DEBOUNCE_MS = 250;
 
 // Flying planes show their current leg from the snapshot's dest fields (v0.12.0).
@@ -48,7 +49,7 @@ export default function LeftPane({ state, loading, error, onRefresh }: LeftPaneP
   // controls without waiting for the next poll tick. On failure keep the stale UI — the
   // running poll retries on its own and surfaces the error state. A commit that lands while
   // another POST is in flight is held in a single slot (last intent wins) and flushed by the
-  // in-flight call, so every user intent reaches the server (the [1,64] clamp stays as backstop).
+  // in-flight call, so every user intent reaches the server (the [1,1000] clamp stays as backstop).
   // The gate is a REF, not React state: closures never see a stale "busy" value, which used to
   // let a flush re-queue instead of send and silently drop a commit.
   const queuedRef = useRef<{ timeScale?: number; paused?: boolean } | null>(null);
@@ -101,7 +102,7 @@ export default function LeftPane({ state, loading, error, onRefresh }: LeftPaneP
   // Slider commit (v0.9.1): the displayed value follows the drag optimistically via
   // pendingScale; POST /api/sim fires after a 250 ms debounce, or immediately when the
   // user releases the slider (browsers fire a native 'change' on release). The server's
-  // [1,64] clamp stays as the backstop.
+  // [1,1000] clamp stays as the backstop.
   const [pendingScale, setPendingScaleState] = useState<number | null>(null);
   const pendingRef = useRef<number | null>(null);
   const commitTimerRef = useRef<ReturnType<typeof setTimeout> | null>(null);

docker-compose.ci.yml

@@ -0,0 +1,35 @@
+# Isolated e2e stack for CI (.gitea/workflows/ci.yml) — runs on the runner's shared dind
+# daemon under project name flight-ci (distinct from production). Joins the external
+# network flight-ci-e2e that the workflow attaches the job container to; the app is reached
+# at its STATIC IP http://172.39.0.10:3000 — DNS bypassed for the browser because Chromium
+# got ERR_SSL_PROTOCOL_ERROR via the hostname while node-side HTTP worked (the `app` alias
+# stays as a convenience). Single deterministic address; survives `docker compose restart flight`.
+# The build context is tarred by the compose client in the job and sent over DOCKER_HOST,
+# so nothing here needs to be visible from inside dind; game state lives in a named volume
+# (fresh per run — CI cleanup removes it — survives `docker compose restart flight` for
+# e2e/state.spec.ts).
+services:
+  flight:
+    build: .
+    image: flight-ops-ci
+    environment:
+      FLIGHT_TEST_HOOKS: "1"
+    volumes:
+      # Self-hosted map-asset pack (styles/fonts/sprites): the workflow downloads it into ./public
+      # before build; absent/empty → app falls back to remote OFM styles. Mirrors docker-compose.yml's
+      # mount so e2e runs in self-hosted mode like local dev (map tests abort openfreemap.org traffic).
+      - "./public:/app/public"
+      - flight-db:/app/db
+    networks:
+      flight-ci-e2e:
+        aliases:
+          - app
+        ipv4_address: 172.39.0.10
+
+networks:
+  flight-ci-e2e:
+    name: flight-ci-e2e
+    external: true
+
+volumes:
+  flight-db:

e2e/actions.spec.ts

@@ -3,12 +3,12 @@ import { expect, test } from '@playwright/test';
 
 // v0.12.0 package model against the live origin (https://flight.dev.kkhost.pl):
 // the full core loop through the UI — hook creates a short package at EDDF → Load
-// via the right pane → click its destination in the on-board list → fly at 60× →
+// via the right pane → click its destination in the on-board list → fly at 1000× →
 // arrival delivers EXACTLY the reward + rep; abandon deducts exactly the formula
 // penalty while grounded; expired packages deliver/abandon with no reward and no
 // penalty. Mirrors lib/game/penalty.ts for exact-value assertions.
 
-const SCALE = 60; // fastest sim speed — keeps flights to seconds of real time
+const SCALE = 1000; // fastest sim speed (v0.14.0 ladder top) — keeps flights to seconds of real time
 const HUB = 'EDDF'; // Frankfurt Main — the seeded starter plane's home base (lib/game/seed.ts)
 const FAR = 'LEZL'; // Seville — one-way burn 3174 L > half tank, so the return leg is unfuelable
 
@@ -93,7 +93,7 @@ async function flyHomeViaApi(page: Page): Promise<void> {
   const s0 = await getState(page);
   const plane = s0.planes.find((p) => p.id === 'plane-starter')!;
   if (plane.status === 'flying' || plane.locationIcao !== HUB) {
-    // Fast-forward any leftover leg / repositioning flight (~3 min real time worst case at 60×).
+    // Fast-forward any leftover leg / repositioning flight (~20 s real time worst case at 1000×).
     await setScale(page, SCALE);
   }
   if (plane.status === 'flying') {
@@ -119,7 +119,7 @@ async function flyHomeViaApi(page: Page): Promise<void> {
 
 
 test('full core loop via UI: load → fly to destination → exact reward + rep on arrival', async ({ page }) => {
-  test.setTimeout(300_000); // self-heal (worst case ~3 min at 60×) + two short flights + refuel
+  test.setTimeout(300_000); // self-heal (worst case ~20 s at 1000×) + two short flights + refuel
   // Self-heal: the starter plane may be anywhere from a previous run/spec.
   await flyHomeViaApi(page);
   const before = await getState(page);
@@ -154,7 +154,7 @@ test('full core loop via UI: load → fly to destination → exact reward + rep
   expect(s.planes.find((p) => p.id === planeId)!.status).toBe('flying');
   expect(s.planes.find((p) => p.id === planeId)!.destIcao).toBe(nearest.icao);
 
-  // Fast-forward to arrival (≤ ~10 min game time at 60× → seconds of real time).
+  // Fast-forward to arrival (a few seconds of real time at 1000×).
   await setScale(page, SCALE);
   await expect.poll(async () => ((await getState(page)).planes.find((p) => p.id === planeId)!.status), { timeout: 120_000 }).toBe('available');
 
@@ -230,7 +230,7 @@ test('abandon while grounded deducts exactly the formula penalty', async ({ page
 });
 
 test('expired packages deliver and abandon with no reward and no penalty', async ({ page }) => {
-  test.setTimeout(480_000); // two ~3 min real-time legs at 60× (HUB↔LEMD) plus expiry wait
+  test.setTimeout(480_000); // two ~10 s real-time legs at 1000× (HUB↔LEMD) plus expiry wait
   await flyHomeViaApi(page);
   const before = await getState(page);
 
@@ -281,7 +281,7 @@ test('expired packages deliver and abandon with no reward and no penalty', async
 });
 
 test('load and fly validation paths (404 / 409 / 400)', async ({ page }) => {
-  test.setTimeout(600_000); // the FAR round trip alone is ~7.5 min real time at 60×
+  test.setTimeout(600_000); // the FAR round trip alone is ~30 s real time at 1000×
   await flyHomeViaApi(page);
 
   // Load a package whose origin the plane is not at → 409.

e2e/ci-diagnostics.ts

@@ -0,0 +1,36 @@
+// CI-only connectivity diagnostics (globalSetup runs after the e2e stack is ready).
+// Evidence for the Chromium ERR_SSL_PROTOCOL_ERROR hunt: compares node-side resolution/HTTP
+// against Chromium's own navigation, hostname vs static IP. Never fails the run.
+import { promises as dnsPromises } from 'node:dns';
+import { chromium } from '@playwright/test';
+
+export default async function ciDiagnostics() {
+  if (process.env.PW_REMOTE_BROWSER !== '0') return; // local runs: no-op
+  const base = process.env.E2E_BASE_URL ?? '';
+  try {
+    console.log('[diag] node resolve4(app):', JSON.stringify(await dnsPromises.resolve4('app').catch((e) => `failed: ${e.code}`)));
+    try {
+      const r = await fetch(`${base}/api/version`);
+      console.log('[diag] node fetch', base, '->', r.status, JSON.stringify(await r.json().catch(() => null)));
+    } catch (e) {
+      console.log('[diag] node fetch failed:', String(e));
+    }
+    const browser = await chromium.launch();
+    try {
+      for (const url of ['http://app:3000/', base]) {
+        const page = await (await browser.newContext()).newPage();
+        try {
+          await page.goto(url, { timeout: 15_000 });
+          console.log('[diag] chromium goto', url, '-> OK, title:', await page.title().catch(() => '?'));
+        } catch (e) {
+          console.log('[diag] chromium goto', url, '-> FAILED:', String(e).split('\n')[0]);
+        }
+        await page.context().close();
+      }
+    } finally {
+      await browser.close();
+    }
+  } catch (e) {
+    console.log('[diag] diagnostics error (non-fatal):', String(e));
+  }
+}

e2e/map-interactions.spec.ts

@@ -5,14 +5,16 @@ import { test, expect, type Page } from '@playwright/test';
 // deterministic generated weather), plane markers whose positions come from the
 // /api/state polls, each FLYING plane's current leg as a route line (origin →
 // dest_icao; grounded planes draw nothing), and the plane status popup. Packages
-// are created on a known EDDF→EDDV route via POST /api/test/create-package
+// are created on a known EDDF→LEMD route via POST /api/test/create-package
 // (FLIGHT_TEST_HOOKS=1).
 
 const HUB = 'EDDF'; // must match HUB_ICAO in lib/game/seed.ts
-// Hannover — ~282 km from EDDF → ~33 min game time ≈ 33 s at scale 60, a comfortable
-// window for the click assertions below (the nearest airport would land too fast).
-const DEST = 'EDDV';
-const SCALE = 60;
+// Madrid–Barajas — ~1420 km from EDDF → ~2.8 h game time ≈ 10 s at scale 1000, a comfortable
+// window for the mid-flight click assertions below (at 1000× even Hannover's 33-min leg would
+// land in ~2 s — shorter than the map poll + click pipeline). Round-trip burn (~4970 L) fits
+// the 6300 L tank, so a full-tank departure always makes it home.
+const DEST = 'LEMD';
+const SCALE = 1000; // fastest sim speed (v0.14.0 ladder top)
 
 interface PlaneState {
   id: string;
@@ -91,7 +93,7 @@ async function createPackage(page: Page, fromIcao: string, toIcao: string): Prom
 }
 
 // Load a package onto plane-starter and fly it from → to via the API, then poll at
-// scale 60 until the plane lands at `to`. Same pattern as e2e/actions.spec.ts.
+// scale 1000 until the plane lands at `to`. Same pattern as e2e/actions.spec.ts.
 async function loadAndFly(page: Page, fromIcao: string, toIcao: string): Promise<PackageState> {
   const pkg = await createPackage(page, fromIcao, toIcao);
   const load = await page.request.post(`/api/packages/${pkg.id}/load`, { data: { planeId: 'plane-starter' } });
@@ -171,7 +173,7 @@ test('airport popup shows name, ICAO, local time and generated weather', async (
 });
 
 test('plane markers move while flying and the plane popup shows status + route', async ({ page }) => {
-  test.setTimeout(600_000); // self-heal from a far airport (~4 min worst case at 60×) + main flight + cleanup
+  test.setTimeout(600_000); // self-heal from a far airport (~20 s worst case at 1000×) + main flight + cleanup
 
   await page.goto('/');
   await waitForAirportCount(page);
@@ -195,6 +197,11 @@ test('plane markers move while flying and the plane popup shows status + route',
     await loadAndFly(page, starterLoc, HUB);
   }
 
+  // Full tank before departure — the EDDF↔LEMD round trip burns ~4970 L of the 6300 L tank,
+  // so a partially drained plane left by an earlier spec could not make it home.
+  const refuel = await page.request.post('/api/planes/plane-starter/refuel');
+  expect(refuel.status()).toBe(200);
+
   // 1) Load the hook-created package — a GROUNDED plane draws no route line yet.
   const pkg = await createPackage(page, HUB, DEST);
   const load = await page.request.post(`/api/packages/${pkg.id}/load`, { data: { planeId: 'plane-starter' } });
@@ -244,8 +251,23 @@ test('plane markers move while flying and the plane popup shows status + route',
   // The arc itself stays covered by unit tests: lib/mapData.test.ts.)
 
   // 4) Click the flying plane → status popup with model, status, fuel and the leg.
-  // Fetch + project in one evaluate so the click lands on a fresh position (the
-  // marker drifts only ~1 px/s of screen space at scale 60).
+  // Freeze the sim so the click can't miss a fast-moving marker: at scale 1000 the rendered
+  // marker lags our fresh /api/state fetch by up to one map poll (~1 s) — tens of px of drift
+  // on this leg. Pausing makes the position static; we resume right after the popup checks.
+  await postSim(page, { paused: true });
+  let prevPos: { lat: number; lon: number } | null = null;
+  await expect
+    .poll(async () => {
+      const p = (await getState(page)).planes.find((x) => x.id === 'plane-starter');
+      if (!p || p.status !== 'flying') return false;
+      if (prevPos && prevPos.lat === p.lat && prevPos.lon === p.lon) return true;
+      prevPos = { lat: p.lat, lon: p.lon };
+      return false;
+    }, { timeout: 15_000, message: 'waiting for the paused clock to freeze the plane position' })
+    .toBe(true);
+
+  // Fetch + project in one evaluate — with the sim paused above, the server's analytic
+  // position is static, so the projected point matches what the map renders.
   const pt = await page.evaluate(async () => {
     const m = (window as any).__flightMap;
     if (!m) return null;
@@ -257,7 +279,7 @@ test('plane markers move while flying and the plane popup shows status + route',
     const rect = m.getContainer().getBoundingClientRect();
     return { x: rect.left + projected.x, y: rect.top + projected.y };
   });
-  expect(pt).not.toBeNull(); // the flight (~33 s at scale 60) is still in progress here
+  expect(pt).not.toBeNull(); // the ~10 s window at scale 1000 is still open this early after departure
 
   await page.mouse.click(pt!.x, pt!.y);
   const popup = page.getByTestId('plane-popup');
@@ -270,6 +292,9 @@ test('plane markers move while flying and the plane popup shows status + route',
   // The popup's route line is the plane's own leg: origin name → destination name.
   await expect(page.getByTestId('plane-route')).toContainText(`${live.locationName} → ${live.destName}`);
 
+  // Resume before step 5 — the landing wait needs a running clock.
+  await postSim(page, { timeScale: SCALE, paused: false });
+
   // 5) Let the flight finish, then fly home so the live instance stays in its
   // onboarding state (starter grounded at EDDF) for the other specs. The loaded
   // package is delivered on arrival (in-deadline).

e2e/panes.spec.ts

@@ -69,7 +69,7 @@ test('left pane renders wallet, reputation and the starter fleet at Frankfurt',
   await expect(page.getByTestId('sim-clock')).toContainText(/UTC/);
 });
 
-test('time controls: pause freezes the sim and the power-of-two slider sets timeScale', async ({ page }) => {
+test('time controls: pause freezes the sim and the ladder slider sets timeScale', async ({ page }) => {
   await page.goto('/');
   const pauseBtn = page.getByTestId('pause-toggle');
   await expect(pauseBtn).toBeVisible({ timeout: 15_000 });
@@ -80,13 +80,13 @@ test('time controls: pause freezes the sim and the power-of-two slider sets time
   // …and in the pane itself (the refetch after POST flips the button to Resume).
   await expect(pauseBtn).toHaveText('Resume');
 
-  // Scale via the power-of-two slider. End jumps to max (t=1 → 64×): the label updates
+  // Scale via the ladder slider. End jumps to max (t=1 → 1000×): the label updates
   // optimistically on input, and release flushes the debounced POST immediately.
   const slider = page.getByTestId('time-scale-slider');
   await slider.focus();
   await page.keyboard.press('End');
-  await expect(page.getByTestId('time-scale-value')).toHaveText('64×', { timeout: 10_000 });
-  await expect.poll(async () => (await getState(page)).simState.timeScale, { timeout: 10_000 }).toBe(64);
+  await expect(page.getByTestId('time-scale-value')).toHaveText('1000×', { timeout: 10_000 });
+  await expect.poll(async () => (await getState(page)).simState.timeScale, { timeout: 10_000 }).toBe(1000);
 
   // Home jumps to min (t=0 → 1×).
   await page.keyboard.press('Home');
@@ -116,19 +116,19 @@ test('slider commit keeps the chosen scale on screen until confirmed — no snap
 
   // …and sample the displayed value rapidly across the whole commit→confirm window. With the
   // ISS-001 fix the optimistic value stays until a snapshot confirms it, so EVERY sample must
-  // be '64×' — never snapping back to the previous scale for one poll cycle (the old bug).
+  // be '1000×' — never snapping back to the previous scale for one poll cycle (the old bug).
   const seen: string[] = [];
   for (let i = 0; i < 30; i++) {
     seen.push(((await page.getByTestId('time-scale-value').textContent()) ?? '').trim());
     await new Promise((r) => setTimeout(r, 25));
   }
   expect(
-    seen.every((v) => v === '64×'),
-    `displayed scale must stay 64× during the commit window (saw: ${[...new Set(seen)].join(', ')})`,
+    seen.every((v) => v === '1000×'),
+    `displayed scale must stay 1000× during the commit window (saw: ${[...new Set(seen)].join(', ')})`,
   ).toBe(true);
 
   // …and the server confirms it.
-  await expect.poll(async () => (await getState(page)).simState.timeScale, { timeout: 10_000 }).toBe(64);
+  await expect.poll(async () => (await getState(page)).simState.timeScale, { timeout: 10_000 }).toBe(1000);
 
   // Restore to min for later tests (afterEach restores scale anyway).
   await page.keyboard.press('Home');

e2e/right-pane.spec.ts

@@ -8,7 +8,7 @@ import { expect, test } from '@playwright/test';
 // match the catalog + economy constants exposed in /api/state. Packages are created via
 // POST /api/test/create-package (FLIGHT_TEST_HOOKS=1), same pattern as e2e/actions.spec.ts.
 
-const SCALE = 60;
+const SCALE = 1000; // fastest sim speed (v0.14.0 ladder top) — keeps flights to seconds of real time
 const HUB = 'EDDF'; // must match HUB_ICAO in lib/game/seed.ts
 
 interface PlaneState {
@@ -98,7 +98,7 @@ function penaltyFor(reward: number, createdSimTime: number, deadlineSimTime: num
   return Math.round(reward * (0.15 + 0.45 * frac) * 100) / 100;
 }
 
-// Closest airport to EDDF from /api/airports → shortest possible arrival time at scale 60.
+// Closest airport to EDDF from /api/airports → shortest possible arrival time at scale 1000.
 async function nearestToHub(page: Page): Promise<{ icao: string; lat: number; lon: number }> {
   const fc = (await (await page.request.get('/api/airports')).json()) as {
     features: Array<{ properties: { icao: string; lat: number; lon: number } }>;
@@ -128,7 +128,7 @@ async function flyHomeViaApi(page: Page): Promise<void> {
   const s0 = await getState(page);
   const starter = s0.planes.find((p) => p.id === 'plane-starter')!;
   if (starter.status === 'flying' || starter.locationIcao !== HUB) {
-    // Fast-forward any leftover leg / repositioning flight (~3 min real time worst case at 60×).
+    // Fast-forward any leftover leg / repositioning flight (~20 s real time worst case at 1000×).
     await setScale(page, SCALE);
   }
   if (starter.status === 'flying') {
@@ -197,7 +197,7 @@ test('Load is disabled when no plane sits at the package origin', async ({ page
 });
 
 test('on-board list: fly-to-destination + abandon with penalty preview; flying planes show their leg', async ({ page }) => {
-  test.setTimeout(240_000); // one short flight at scale 60 plus UI steps — typical run well under three minutes
+  test.setTimeout(240_000); // one short flight at scale 1000 (seconds of real time) plus UI steps
   await flyHomeViaApi(page);
 
   const nearest = await nearestToHub(page);
@@ -241,7 +241,7 @@ test('on-board list: fly-to-destination + abandon with penalty preview; flying p
       const b = await getState(page);
       const p = b.planes.find((x) => x.id === 'plane-starter');
       return !!p && p.status === 'available' && p.locationIcao === nearest.icao;
-    }, { timeout: 120_000, message: `waiting for arrival at ${nearest.icao} (scale 60)` })
+    }, { timeout: 120_000, message: `waiting for arrival at ${nearest.icao} (scale 1000)` })
     .toBe(true);
 
   // The in-deadline package was delivered on arrival — it leaves the on-board list…

e2e/sim.spec.ts

@@ -6,8 +6,8 @@ import { test, expect, type Page } from '@playwright/test';
 
 // Must match lib/sim/engine.ts — kept in sync manually (same pattern as MIN_ZOOM/MAX_ZOOM in map.spec.ts).
 const MAX_TICK_ELAPSED_MS = 2_000;
-const SCALE = 60;
-const MAX_DELTA_PER_TICK = MAX_TICK_ELAPSED_MS * SCALE; // 120_000 game ms per tick at scale 60
+const SCALE = 1000; // fastest sim speed — top of the v0.14.0 ladder
+const MAX_DELTA_PER_TICK = MAX_TICK_ELAPSED_MS * SCALE; // 2_000_000 game ms per tick at scale 1000
 // Must match MARKET_TARGET_OPEN_PACKAGES in lib/game/seed.ts.
 const MARKET_TARGET = 10;
 
@@ -42,7 +42,7 @@ test.afterEach(async ({ page }) => {
   expect(res.status()).toBe(200);
 });
 
-test('timeScale 60 advances the clock by roughly real-time × 60 between polls', async ({ page }) => {
+test('timeScale 1000 advances the clock by roughly real-time × 1000 between polls', async ({ page }) => {
   const post = await postSim(page, { timeScale: SCALE });
   expect(post.status()).toBe(200);
   const s1 = (await post.json()) as SimState;
@@ -51,11 +51,11 @@ test('timeScale 60 advances the clock by roughly real-time × 60 between polls',
 
   let prev = s1.clockMs;
   for (let i = 0; i < 3; i++) {
-    await sleep(1_000); // one real second ≈ 60 game seconds at scale 60 — well under the clamp
+    await sleep(1_000); // one real second ≈ 1000 game seconds at scale 1000 — well under the clamp
     const body = await getState(page);
     const now = body.simState.clockMs;
     expect(now).toBeGreaterThan(prev); // strictly advances while actively polled
-    expect(now - prev).toBeGreaterThanOrEqual(30_000); // ≥ ~500 ms real × 60
+    expect(now - prev).toBeGreaterThanOrEqual(500_000); // ≥ ~500 ms real × 1000
     expect(now - prev).toBeLessThanOrEqual(MAX_DELTA_PER_TICK + 60); // clamp bounds each tick
     prev = now;
   }
@@ -82,7 +82,7 @@ test('an open package past its short deadline expires and the market stays toppe
   expect(victim).toBeDefined(); // steady state always has open packages
 
   // Test-only hook (FLIGHT_TEST_HOOKS=1 in docker-compose): move an existing open
-  // package's deadline ~10 game-seconds out so expiry is observable at scale 60.
+  // package's deadline ~10 game-seconds out so expiry is observable at scale 1000.
   const hook = await page.request.post('/api/test/expire-package', { data: { packageId: victim!.id } });
   expect(hook.status()).toBe(200);
   const moved = (await hook.json()) as { id: string; deadlineSimTime: number };
@@ -132,9 +132,13 @@ test('the hook can also create a fresh short-deadline package, which then expire
 });
 
 test('POST /api/sim validates and clamps its input', async ({ page }) => {
-  const clampHigh = await postSim(page, { timeScale: 500 });
+  const clampHigh = await postSim(page, { timeScale: 2000 });
   expect(clampHigh.status()).toBe(200);
-  expect(((await clampHigh.json()) as SimState).timeScale).toBe(64); // top of the power-of-two ladder (v0.9.2)
+  expect(((await clampHigh.json()) as SimState).timeScale).toBe(1000); // top of the ladder (v0.14.0)
+
+  const inRange = await postSim(page, { timeScale: 500 });
+  expect(inRange.status()).toBe(200);
+  expect(((await inRange.json()) as SimState).timeScale).toBe(500); // ladder value passes through unclamped
 
   const clampLow = await postSim(page, { timeScale: 0.1 });
   expect(clampLow.status()).toBe(200);

e2e/state.spec.ts

@@ -3,8 +3,10 @@ import path from 'node:path';
 import { test, expect } from '@playwright/test';
 
 // Repo root — docker-compose.yml lives here; `docker compose restart` runs on
-// this host (the test runner), browsers stay remote.
+// this host (the test runner), browsers stay remote. CI points E2E_COMPOSE_ARGS at the
+// isolated stack file + project (-f docker-compose.ci.yml -p flight-ci) instead of the default one.
 const repoRoot = path.join(__dirname, '..');
+const composeArgs = process.env.E2E_COMPOSE_ARGS ?? '';
 
 interface StateBody {
   account: { cash: number; reputation: number };
@@ -46,7 +48,7 @@ test('state survives a container restart (sim clock + account persisted)', async
   expect(resBefore.status()).toBe(200);
   const before = (await resBefore.json()) as StateBody;
 
-  execSync('docker compose restart flight', { cwd: repoRoot, stdio: 'pipe' });
+  execSync(`docker compose ${composeArgs} restart flight`, { cwd: repoRoot, stdio: 'pipe' });
 
   // Wait for the app to come back, capturing the post-restart snapshot.
   let after: StateBody | undefined;

lib/openapi.test.ts

@@ -153,7 +153,7 @@ describe('OpenAPI spec', () => {
     expect(Object.keys(controls).sort()).toEqual(['paused', 'timeScale']);
     expect(controls.timeScale.type).toBe('number');
     expect(controls.timeScale.minimum).toBe(1);
-    expect(controls.timeScale.maximum).toBe(64);
+    expect(controls.timeScale.maximum).toBe(1000);
     expect(controls.paused.type).toBe('boolean');
 
     const error = openApiSpec.components.schemas.Error.properties;

lib/openapi.ts

@@ -394,7 +394,7 @@ export const openApiSpec = {
         type: 'object',
         properties: {
           clockMs: { type: 'integer', description: 'Sim-clock epoch ms (game time)' },
-          timeScale: { type: 'number', minimum: 1, maximum: 64 },
+          timeScale: { type: 'number', minimum: 1, maximum: 1000 },
           paused: { type: 'boolean' },
         },
         required: ['clockMs', 'timeScale', 'paused'],
@@ -406,8 +406,8 @@ export const openApiSpec = {
           timeScale: {
             type: 'number',
             minimum: 1,
-            maximum: 64,
-            description: 'Game-time multiplier; values outside [1, 64] are clamped. The UI offers the power-of-two ladder 1/2/4/8/16/32/64.',
+            maximum: 1000,
+            description: 'Game-time multiplier; values outside [1, 1000] are clamped. The UI offers the ladder 1/2/5/10/25/50/100/250/500/1000.',
           },
           paused: { type: 'boolean' },
         },

lib/sim/engine.test.ts

@@ -11,9 +11,12 @@ import { PLANE_TYPES } from '@/lib/game/catalog';
 import { MARKET_TARGET_OPEN_PACKAGES, mulberry32 } from '@/lib/game/seed';
 import { arrivalTimeFor } from './movement';
 import {
+  clampTimeScale,
   deliverPackages,
   expirePackages,
   MAX_TICK_ELAPSED_MS,
+  MAX_TIME_SCALE,
+  MIN_TIME_SCALE,
   reputationGainFor,
   spawnCoveragePackages,
   spawnOpenPackages,
@@ -374,6 +377,32 @@ describe('spawnCoveragePackages (v0.8.0 spawn coverage rule)', () => {
   });
 });
 
+describe('clampTimeScale — v0.14.0 ladder bounds [1, 1000]', () => {
+  it('clamps below-minimum values to MIN_TIME_SCALE', () => {
+    expect(clampTimeScale(0)).toBe(MIN_TIME_SCALE);
+    expect(clampTimeScale(-5)).toBe(MIN_TIME_SCALE);
+    expect(clampTimeScale(0.1)).toBe(MIN_TIME_SCALE);
+  });
+
+  it('clamps above-maximum values to MAX_TIME_SCALE', () => {
+    expect(clampTimeScale(1001)).toBe(MAX_TIME_SCALE);
+    expect(clampTimeScale(2000)).toBe(MAX_TIME_SCALE);
+    expect(clampTimeScale(Number.MAX_SAFE_INTEGER)).toBe(MAX_TIME_SCALE);
+  });
+
+  it('passes in-range values through unclamped — ladder and off-ladder alike', () => {
+    for (const s of [1, 2, 5, 10, 25, 50, 100, 250, 500, 1000]) {
+      expect(clampTimeScale(s)).toBe(s); // the full v0.14.0 slider ladder
+    }
+    expect(clampTimeScale(37)).toBe(37); // off-ladder but in range (e.g. a legacy value)
+  });
+
+  it('keeps the endpoints exact', () => {
+    expect(clampTimeScale(MIN_TIME_SCALE)).toBe(MIN_TIME_SCALE);
+    expect(clampTimeScale(MAX_TIME_SCALE)).toBe(MAX_TIME_SCALE);
+  });
+});
+
 // Local helper mirroring lib/sim/movement.ts (kept private there on purpose — the
 // engine composes arrivalTimeFor; tests just need the duration for fixtures).
 function travelMs(km: number, speedKmh: number): number {

lib/sim/engine.ts

@@ -22,12 +22,12 @@ import { arrivalTimeFor, fuelAt } from './movement';
 // Clamp constant: max real-time gap counted by a single tick. Chosen at 2000 ms —
 // comfortably above a normal client poll interval (~1 s), so active play advances
 // ~real time × scale; small enough that one stale read after an absence moves game
-// time by at most 2 s × scale (≈ 2 min even at max scale 64). The sim therefore
+// time by at most 2 s × scale (≈ 33 min even at max scale 1000). The sim therefore
 // only meaningfully progresses while actively polled.
 export const MAX_TICK_ELAPSED_MS = 2_000;
 
 export const MIN_TIME_SCALE = 1;
-export const MAX_TIME_SCALE = 64; // top of the power-of-two ladder (v0.9.2)
+export const MAX_TIME_SCALE = 1000; // top of the slider ladder (v0.14.0)
 
 // Reputation gain per delivered package: BASE + PER_KM × great-circle km, rounded
 // to 2 decimals (reputation is REAL). A short hop (~300 km) earns ~1.15 rep, a
@@ -264,7 +264,7 @@ export function runAction<T>(fn: (inst: GameDb) => Promise<T>): Promise<T> {
 }
 
 // Tick first so the returned state reflects current time, then apply the new
-// controls. timeScale is clamped to [1, 64]; validation of raw input happens in
+// controls. timeScale is clamped to [1, 1000]; validation of raw input happens in
 // the route handler (400 on non-number / non-boolean).
 export function applyTimeControls(input: SimControlsInput): Promise<schema.SimStateRow> {
   return withLock(async () => {

lib/timeScale.test.ts

@@ -1,16 +1,16 @@
 import { describe, expect, it } from 'vitest';
 import { MAX_SCALE, MIN_SCALE, TIME_SCALES, scaleToSlider, sliderToScale } from './timeScale';
 
-const STEPS = TIME_SCALES.length - 1; // 6 intervals across the 7 ladder positions
+const STEPS = TIME_SCALES.length - 1; // 9 intervals across the 10 ladder positions (v0.14.0)
 
 describe('sliderToScale', () => {
-  it('is exact at the endpoints (0 → 1×, 1 → 64×)', () => {
+  it('is exact at the endpoints (0 → 1×, 1 → 1000×)', () => {
     expect(sliderToScale(0)).toBe(MIN_SCALE);
     expect(sliderToScale(1)).toBe(MAX_SCALE);
   });
 
-  it('maps each of the 7 positions to the power-of-two ladder', () => {
-    const expected = [1, 2, 4, 8, 16, 32, 64];
+  it('maps each of the 10 positions to the ladder', () => {
+    const expected = [1, 2, 5, 10, 25, 50, 100, 250, 500, 1000];
     for (let i = 0; i < TIME_SCALES.length; i++) {
       expect(sliderToScale(i / STEPS)).toBe(expected[i]);
     }
@@ -39,9 +39,9 @@ describe('sliderToScale', () => {
 });
 
 describe('scaleToSlider', () => {
-  it('is exact at the endpoints (1× → 0, 64× → 1)', () => {
+  it('is exact at the endpoints (1× → 0, 1000× → 1)', () => {
     expect(scaleToSlider(1)).toBe(0);
-    expect(scaleToSlider(64)).toBe(1);
+    expect(scaleToSlider(1000)).toBe(1);
   });
 
   it('places each ladder value on its own position', () => {
@@ -61,7 +61,7 @@ describe('scaleToSlider', () => {
   it('clamps out-of-range and non-finite input', () => {
     expect(scaleToSlider(0)).toBe(0);
     expect(scaleToSlider(-3)).toBe(0);
-    expect(scaleToSlider(65)).toBe(1);
+    expect(scaleToSlider(1001)).toBe(1); // above the ladder top → clamped to 1000× → t=1
     expect(scaleToSlider(NaN)).toBe(0);
   });
 });
@@ -73,8 +73,9 @@ describe('round-trip', () => {
     }
   });
 
-  it('maps off-ladder scales to the nearest power of two', () => {
-    expect(sliderToScale(scaleToSlider(3))).toBe(4); // log2(3) ≈ 1.58 → step 2 (4×)
-    expect(sliderToScale(scaleToSlider(60))).toBe(64); // legacy max from the v0.9.x era
+  it('maps off-ladder scales to the nearest ladder step by log distance', () => {
+    expect(sliderToScale(scaleToSlider(3))).toBe(2); // ln 3 ≈ 1.10 → closer to 2 (ln ≈ 0.69) than 5 (ln ≈ 1.61)
+    expect(sliderToScale(scaleToSlider(60))).toBe(50); // legacy max from the v0.9.x era sits between 50 and 100, nearer 50
+    expect(sliderToScale(scaleToSlider(200))).toBe(250); // ln 200 ≈ 5.30 → closer to 250 (ln ≈ 5.52) than 100 (ln ≈ 4.61)
   });
 });

lib/timeScale.ts

@@ -1,24 +1,33 @@
-// Pure mapping helpers for the time-scale slider (v0.9.2) — no game logic, unit-testable
-// in node. The slider has 7 discrete positions on a power-of-two ladder:
-// 1× → 2× → 4× → 8× → 16× → 32× → 64×, so each step doubles the speed (matching
-// POST /api/sim's clamp range [1, 64]).
+// Pure mapping helpers for the time-scale slider (v0.9.2, values reworked in v0.14.0) — no
+// game logic, unit-testable in node. The slider has 10 discrete positions on a mixed
+// ×2/×2.5 ladder: 1× → 2× → 5× → 10× → 25× → 50× → 100× → 250× → 500× → 1000×, so each
+// step roughly doubles the speed (matching POST /api/sim's clamp range [1, 1000]).
 
-export const TIME_SCALES = [1, 2, 4, 8, 16, 32, 64] as const;
+export const TIME_SCALES = [1, 2, 5, 10, 25, 50, 100, 250, 500, 1000] as const;
 export const MIN_SCALE: number = TIME_SCALES[0];
 export const MAX_SCALE: number = TIME_SCALES[TIME_SCALES.length - 1];
 
 const clamp = (v: number, lo: number, hi: number) => Math.min(hi, Math.max(lo, v));
 
 // t → scale: the position maps to the nearest ladder step. Exact at the endpoints:
-// sliderToScale(0) === 1, sliderToScale(1) === 64.
+// sliderToScale(0) === 1, sliderToScale(1) === 1000.
 export function sliderToScale(t: number): number {
   const tt = clamp(Number.isFinite(t) ? t : 0, 0, 1);
   return TIME_SCALES[clamp(Math.round(tt * (TIME_SCALES.length - 1)), 0, TIME_SCALES.length - 1)];
 }
 
-// scale → t: the nearest ladder position by log2 distance. Exact at the endpoints:
-// scaleToSlider(1) === 0, scaleToSlider(64) === 1; round-trips every value in TIME_SCALES.
+// scale → t: the nearest ladder position by log distance. Exact at the endpoints:
+// scaleToSlider(1) === 0, scaleToSlider(1000) === 1; round-trips every value in TIME_SCALES.
 export function scaleToSlider(scale: number): number {
   const s = clamp(Number.isFinite(scale) ? scale : MIN_SCALE, MIN_SCALE, MAX_SCALE);
-  return Math.log2(s) / Math.log2(MAX_SCALE);
+  let best = 0;
+  let bestDist = Infinity;
+  for (let i = 0; i < TIME_SCALES.length; i++) {
+    const d = Math.abs(Math.log(s) - Math.log(TIME_SCALES[i]));
+    if (d < bestDist) {
+      bestDist = d;
+      best = i;
+    }
+  }
+  return best / (TIME_SCALES.length - 1);
 }

package.json

@@ -1,6 +1,6 @@
 {
   "name": "flight-ops",
-  "version": "0.12.3",
+  "version": "0.14.0",
   "private": true,
   "scripts": {
     "dev": "next dev -p 3000",
@@ -19,6 +19,7 @@
     "sql.js": "^1.14.2"
   },
   "devDependencies": {
+    "@playwright/test": "1.63.0",
     "@types/node": "^22.20.3",
     "@types/react": "^19.3.0",
     "@types/react-dom": "^19.3.0",

playwright.config.ts

@@ -1,28 +1,33 @@
 import { defineConfig } from '@playwright/test';
 
-const remoteRunner = true;
+// Browsers run on the shared remote Playwright server by default (AGENTS.md).
+// PW_REMOTE_BROWSER=0 → local browsers instead (CI, or boxes without LAN access to 192.168.1.4).
+const remoteBrowser = process.env.PW_REMOTE_BROWSER !== '0';
 
-if (!process.env.PW_TEST_CONNECT_WS_ENDPOINT) {
+if (!process.env.PW_TEST_CONNECT_WS_ENDPOINT && remoteBrowser) {
   process.env.PW_TEST_CONNECT_WS_ENDPOINT = 'ws://192.168.1.4:3000/';
 }
 
+// App under test. Default: the live compose instance behind Traefik, deployed manually
+// before running the suite (AGENTS.md). When E2E_DEPLOY_CMD is set it runs as a webServer
+// and the suite waits for baseURL to come up — CI uses this to target an isolated stack
+// inside dind instead of production. All vars optional; unset = current local behavior.
+const deployCmd = process.env.E2E_DEPLOY_CMD;
+const baseUrl = process.env.E2E_BASE_URL ?? 'https://flight.dev.kkhost.pl';
+
 export default defineConfig({
   testDir: './e2e',
+  globalSetup: './e2e/ci-diagnostics.ts',
   // Serial execution: e2e/state.spec.ts restarts the compose container mid-run,
   // which would break any map test running concurrently in another worker.
   workers: 1,
   timeout: 300_000,
   retries: 1,
   use: {
-    baseURL: process.env.E2E_BASE_URL ?? 'https://flight.dev.kkhost.pl',
+    baseURL: baseUrl,
     trace: 'on-first-retry',
   },
-  webServer: remoteRunner
-    ? undefined
-    : {
-        command: 'docker compose up -d --build',
-        url: 'https://flight.dev.kkhost.pl',
-        reuseExistingServer: true,
-        timeout: 600_000,
-      },
-});
+  webServer: deployCmd
+    ? { command: deployCmd, url: baseUrl, reuseExistingServer: true, timeout: 600_000 }
+    : undefined,
+});