CHANGELOG.md

@@ -1,5 +1,10 @@
 # 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)
+
 ## 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
 

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') {

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);

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/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,8 @@ 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).
+  // Fetch + project in one evaluate so the click lands on a fresh position (at scale
+  // 1000 the marker moves fast — a stale projection would miss it).
   const pt = await page.evaluate(async () => {
     const m = (window as any).__flightMap;
     if (!m) return null;
@@ -257,7 +264,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');

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);

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.13.1",
+  "version": "0.14.0",
   "private": true,
   "scripts": {
     "dev": "next dev -p 3000",