feat: v0.14.0 — ISS-006 time-scale slider values up to 1000x; tests use fastest time

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