Genesis: pace now means more gets built, not finished sooner

generateMap(seed, scale) with subset stability: the full scale-4 roster
of town sites, buildings and names is generated deterministically on
every call, then trimmed to the requested scale — so the same seed at a
higher pace keeps identical terrain, river and founding towns, and
simply settles deeper into the valley (2 lonely sites at 0.25x, 5-7 at
1x, up to ~16 towns at 4x). Roads join each town to the nearest town
earlier in roster order (prefix-safe by construction, unlike Prim);
trees, scatter and biomes are computed against the full roster so the
landscape never shifts with pace.

The PACE button regenerates the map at the new scale; buildTimeline's
self-pacing absorbs the extra content and still lands the last roof
before dark (verified: 4x finishes ~20:49). The timeline pace parameter
is retired from the UI.

Harness: invariants at 5 scales x 3 seeds, cross-scale subset checks,
250-seed sweep at 1x and 4x, subset stability over 60 seeds - all pass.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01S5LX4oqPCScex4Eb41KDh4

Author: CodeManEthan

scripts/genesis-stats.mjs

@@ -7,6 +7,10 @@
 //   node scripts/genesis-stats.mjs 7 8 9
 //   node scripts/genesis-stats.mjs --sweep 200     # invariants only, 200 seeds
 //
+// Each seed is reported at scale 1 and then checked at every scale in
+// SCALES, plus the subset-stability checks that guarantee a smaller scale is a
+// strict prefix of a larger one.
+//
 // All distances below are measured in screen-aligned u/v units (u = gx - gy,
 // v = gx + gy) — the same space gen.ts plans in and the space site.radius is
 // compared against by the renderer.
@@ -161,7 +165,9 @@ function report(seed) {
 
 /* ------------------------------- invariants ------------------------------ */
 
-function checks(seed, map) {
+const SCALES = [0.25, 0.5, 1, 2, 4];
+
+function checks(seed, map, scale = 1) {
   const river = map.river.map(toUV);
   const roadUV = new Map(map.roads.map((r) => [r.id, r.pts.map(toUV)]));
   const results = [];
@@ -244,8 +250,8 @@ function checks(seed, map) {
 
   /* (f) determinism */
   {
-    const a = JSON.stringify(generateMap(seed));
-    const b = JSON.stringify(generateMap(seed));
+    const a = JSON.stringify(generateMap(seed, scale));
+    const b = JSON.stringify(generateMap(seed, scale));
     check('f  deterministic', a === b, `${a.length} bytes`);
   }
 
@@ -297,19 +303,22 @@ function checks(seed, map) {
     check('k  trees clear river/roads', bad === 0, `${bad} violations`);
   }
   {
+    const s0b = map.sites[0].buildings.length;
     const ok =
       map.trees.length >= 400 &&
-      map.trees.length <= 950 &&
+      map.trees.length <= 1100 &&
       map.scatter.length >= 90 &&
       map.scatter.length <= 220 &&
-      map.sites.length >= 5 &&
-      map.sites.length <= 7 &&
-      map.sites[0].buildings.length >= 8 &&
-      map.sites[0].buildings.length <= 10;
+      map.sites.length >= 2 &&
+      map.sites.length <= 16 &&
+      s0b >= 3 &&
+      s0b <= 14 &&
+      // Scale 1 must still land on the hand-tuned baseline.
+      (scale !== 1 || (map.sites.length >= 5 && map.sites.length <= 7 && s0b >= 8 && s0b <= 10));
     check(
       'l  populations in spec range',
       ok,
-      `${map.sites.length} sites, s0 ${map.sites[0].buildings.length} bldg, ${map.trees.length} trees, ${map.scatter.length} scatter, ${map.bridges.length} bridges`
+      `${map.sites.length} sites, s0 ${s0b} bldg, ${map.trees.length} trees, ${map.scatter.length} scatter, ${map.bridges.length} bridges`
     );
   }
   {
@@ -318,11 +327,94 @@ function checks(seed, map) {
   }
 
   const pass = results.every((r) => r.ok);
-  console.log('\nINVARIANTS');
+  console.log(`\nINVARIANTS  seed ${seed}  scale ${scale}`);
   for (const r of results) {
     console.log(`  ${r.ok ? 'PASS' : 'FAIL'}  ${r.name.padEnd(38)} ${r.detail}`);
   }
-  console.log(`  => seed ${seed}: ${pass ? 'ALL PASS' : 'FAILURES'}`);
+  console.log(`  => seed ${seed} @ ${scale}x: ${pass ? 'ALL PASS' : 'FAILURES'}`);
+  return pass;
+}
+
+/* --------------------------- subset stability ---------------------------- */
+
+/**
+ * A smaller scale must be a strict prefix of a larger one: same land, same
+ * names, same positions, with sites / roads / per-site buildings only ever
+ * appended. This is what makes the pace control a live knob instead of a
+ * reroll, so it is checked pairwise across every adjacent pair of scales.
+ */
+function subsetChecks(seed) {
+  const maps = SCALES.map((s) => generateMap(seed, s));
+  const results = [];
+  const check = (name, ok, detail = '') => results.push({ name, ok, detail });
+  const same = (a, b) => JSON.stringify(a) === JSON.stringify(b);
+
+  // Terrain is scale-invariant, full stop.
+  for (const field of ['river', 'riverWidth', 'chunks', 'trees', 'scatter', 'bounds', 'content', 'valleyName']) {
+    const ok = maps.every((m) => same(m[field], maps[0][field]));
+    check(`terrain: ${field} identical`, ok);
+  }
+
+  for (let k = 1; k < maps.length; k++) {
+    const lo = maps[k - 1];
+    const hi = maps[k];
+    const tag = `${SCALES[k - 1]}x < ${SCALES[k]}x`;
+
+    check(
+      `${tag}: sites grow`,
+      hi.sites.length >= lo.sites.length,
+      `${lo.sites.length} -> ${hi.sites.length}`
+    );
+    // Site identity, position, radius, accent, name and dressing must not move.
+    let bad = 0;
+    let bldBad = 0;
+    let bldShrink = 0;
+    for (let i = 0; i < lo.sites.length; i++) {
+      const a = lo.sites[i];
+      const b = hi.sites[i];
+      if (!b) {
+        bad++;
+        continue;
+      }
+      const meta = (x) => ({ id: x.id, name: x.name, gx: x.gx, gy: x.gy, radius: x.radius, accent: x.accent, props: x.props });
+      if (!same(meta(a), meta(b))) bad++;
+      if (b.buildings.length < a.buildings.length) bldShrink++;
+      for (let j = 0; j < a.buildings.length; j++) {
+        if (!same(a.buildings[j], b.buildings[j])) bldBad++;
+      }
+    }
+    check(`${tag}: site prefix identical`, bad === 0, `${bad} mismatched sites`);
+    check(`${tag}: buildings are a prefix`, bldBad === 0 && bldShrink === 0, `${bldBad} changed, ${bldShrink} shrank`);
+
+    const roadPrefix =
+      hi.roads.length >= lo.roads.length &&
+      lo.roads.every((r, i) => same(r, hi.roads[i]));
+    check(`${tag}: roads are a prefix`, roadPrefix, `${lo.roads.length} -> ${hi.roads.length}`);
+
+    const bridgePrefix =
+      hi.bridges.length >= lo.bridges.length &&
+      lo.bridges.every((b, i) => same(b, hi.bridges[i]));
+    check(`${tag}: bridges are a prefix`, bridgePrefix, `${lo.bridges.length} -> ${hi.bridges.length}`);
+  }
+
+  // The default argument must be exactly scale 1.
+  check(
+    'default scale === explicit 1',
+    JSON.stringify(generateMap(seed)) === JSON.stringify(generateMap(seed, 1))
+  );
+  // Out-of-range scales clamp rather than explode.
+  check(
+    'scale clamps to [0.25, 4]',
+    JSON.stringify(generateMap(seed, 0.01)) === JSON.stringify(generateMap(seed, 0.25)) &&
+      JSON.stringify(generateMap(seed, 99)) === JSON.stringify(generateMap(seed, 4))
+  );
+
+  const pass = results.every((r) => r.ok);
+  console.log(`\nSUBSET STABILITY  seed ${seed}`);
+  for (const r of results) {
+    console.log(`  ${r.ok ? 'PASS' : 'FAIL'}  ${r.name.padEnd(38)} ${r.detail}`);
+  }
+  console.log(`  => seed ${seed} subset: ${pass ? 'ALL PASS' : 'FAILURES'}`);
   return pass;
 }
 
@@ -331,28 +423,51 @@ function checks(seed, map) {
 const argv = process.argv.slice(2);
 let allPass = true;
 
+const quietly = (fn) => {
+  const out = [];
+  const orig = console.log;
+  console.log = (...a) => out.push(a.join(' '));
+  let ok;
+  try {
+    ok = fn();
+  } finally {
+    console.log = orig;
+  }
+  return { ok, out };
+};
+
 if (argv[0] === '--sweep') {
   const n = Number(argv[1] || 100);
-  const fails = [];
-  for (let s = 1; s <= n; s++) {
-    const map = generateMap(s);
-    const out = [];
-    const orig = console.log;
-    console.log = (...a) => out.push(a.join(' '));
-    const ok = checks(s, map);
-    console.log = orig;
-    if (!ok) {
-      fails.push(s);
-      console.log(out.join('\n'));
+  for (const scale of [1, 4]) {
+    const fails = [];
+    for (let s = 1; s <= n; s++) {
+      const r = quietly(() => checks(s, generateMap(s, scale), scale));
+      if (!r.ok) {
+        fails.push(s);
+        console.log(r.out.join('\n'));
+      }
+    }
+    console.log(`sweep ${n} seeds @ ${scale}x: ${fails.length ? `FAIL ${fails.join(',')}` : 'ALL PASS'}`);
+    if (fails.length) allPass = false;
+  }
+  const subFails = [];
+  for (let s = 1; s <= Math.min(n, 60); s++) {
+    const r = quietly(() => subsetChecks(s));
+    if (!r.ok) {
+      subFails.push(s);
+      console.log(r.out.join('\n'));
     }
   }
-  console.log(`\nsweep ${n} seeds: ${fails.length ? `FAIL ${fails.join(',')}` : 'ALL PASS'}`);
-  allPass = fails.length === 0;
+  console.log(`sweep ${Math.min(n, 60)} seeds subset stability: ${subFails.length ? `FAIL ${subFails.join(',')}` : 'ALL PASS'}`);
+  if (subFails.length) allPass = false;
 } else {
   const seeds = argv.length ? argv.map(Number) : [1, 42, 20260802];
   for (const s of seeds) {
-    const map = report(s);
-    if (!checks(s, map)) allPass = false;
+    report(s);
+    for (const scale of SCALES) {
+      if (!checks(s, generateMap(s, scale), scale)) allPass = false;
+    }
+    if (!subsetChecks(s)) allPass = false;
   }
 }
 

src/components/designs/genesis/TheGenesis.tsx

@@ -58,8 +58,6 @@ import {
 export interface World {
   map: GenesisMap;
   timeline: Timeline;
-  /** Re-lay the same map's day at a different work pace. */
-  retime: (map: GenesisMap, pace: number) => Timeline;
   emptySnapshot: (map: GenesisMap) => WorldSnapshot;
   snapshotAt: (map: GenesisMap, tl: Timeline, t: number) => WorldSnapshot;
   advance: (snap: WorldSnapshot, tl: Timeline, toT: number) => void;
@@ -78,26 +76,28 @@ import { advance, buildTimeline, emptySnapshot, snapshotAt } from './timeline';
 
 const USE_GENERATED = true;
 
+/**
+ * `pace` is how ambitious the day is, so it belongs to the *map*: a bigger pace
+ * generates more of the valley. The timeline then paces whatever it is handed
+ * across the same 24 hours, which is why nothing here passes it along.
+ */
 function loadWorld(seed: number, pace = 1): World {
   if (USE_GENERATED) {
-    const map = generateMap(seed);
+    const map = generateMap(seed, pace);
     return {
       map,
-      timeline: buildTimeline(map, pace),
-      retime: buildTimeline,
+      timeline: buildTimeline(map),
       emptySnapshot,
       snapshotAt,
       advance,
     };
   }
+  // The fixture is one hand-written valley; there is no more of it to build.
   const map = fixtureMap();
   map.seed = seed;
-  // The fixture is a hand-written day; there is nothing in it to re-pace.
-  const retime = (m: GenesisMap) => fixtureTimeline(m);
   return {
     map,
-    timeline: retime(map),
-    retime,
+    timeline: fixtureTimeline(map),
     emptySnapshot: fixtureEmptySnapshot,
     snapshotAt: fixtureSnapshotAt,
     advance: fixtureAdvance,
@@ -107,8 +107,9 @@ function loadWorld(seed: number, pace = 1): World {
 /* --------------------------------- helpers ------------------------------- */
 
 const SPEEDS = [60, 600, 3600];
-/** How hard the valley works, which is a different question from how fast the
- * clock runs. 1 is a full day's work; 4 has the last roof on by lunchtime. */
+/** How much the valley builds today, which is a different question from how
+ * fast the clock runs. The day is always a day; at 4 it simply fills with four
+ * times the settlement, and at ½ it stays a hamlet. */
 const PACES = [0.5, 1, 2, 4];
 const PACE_LABELS = ['½', '1', '2', '4'];
 const clamp = (n: number, lo: number, hi: number) => (n < lo ? lo : n > hi ? hi : n);
@@ -374,6 +375,30 @@ export default function TheGenesis() {
       dirtyRef.current = true;
       pushLog();
     };
+
+    /** A new seed or a new pace both mean a new map, and a new map is a whole
+     * new world: ledger, baked terrain, crowd and framing all go. The clock
+     * does not — the visitor keeps their hour, and LIVE stays LIVE. */
+    const rebuild = (s: number, p: number) => {
+      seedRef.current = s;
+      paceRef.current = p;
+      world = loadWorld(s, p);
+      worldRef.current = world;
+      scene = buildGenesisScene(world.map);
+      sceneRef.current = scene;
+      setAmbientPace(amb, p);
+      snapRef.current = world.snapshotAt(world.map, world.timeline, tRef.current);
+      resetAmbient(scene, amb, snapRef.current);
+      settleAmbient(scene, amb, snapRef.current);
+      camRef.current = clampCam(fitCam());
+      logLenRef.current = -1;
+      pushLog();
+      setSeed(s);
+      setValley(world.map.valleyName);
+      dirtyRef.current = true;
+      paintOnce();
+    };
+
     api.current = {
       applyT,
       paint: () => {
@@ -408,42 +433,17 @@ export default function TheGenesis() {
         dirtyRef.current = true;
         if (reducedRef.current) paintOnce();
       },
-      // A different valley is a whole new world: map, ledger, baked terrain and
-      // crowd all go. The clock does not — the visitor keeps their hour, and
-      // LIVE stays LIVE.
       chooseSeed: (nextSeed) => {
         const s = nextSeed >>> 0;
         if (s === seedRef.current) return;
-        seedRef.current = s;
-        world = loadWorld(s, paceRef.current);
-        worldRef.current = world;
-        scene = buildGenesisScene(world.map);
-        sceneRef.current = scene;
-        amb = makeAmbient(paceRef.current);
-        ambRef.current = amb;
-        snapRef.current = world.snapshotAt(world.map, world.timeline, tRef.current);
-        settleAmbient(scene, amb, snapRef.current);
-        camRef.current = clampCam(fitCam());
-        logLenRef.current = -1;
-        pushLog();
-        setSeed(s);
-        setValley(world.map.valleyName);
-        dirtyRef.current = true;
-        paintOnce();
+        rebuild(s, paceRef.current);
       },
-      // Same map, same hour, a different day's work in it.
+      // A bigger pace is a bigger valley, so it regenerates the map too. The
+      // seed guarantees everything already on screen stays exactly where it is
+      // and simply gains neighbours.
       choosePace: (nextPace) => {
         if (nextPace === paceRef.current) return;
-        paceRef.current = nextPace;
-        world.timeline = world.retime(world.map, nextPace);
-        setAmbientPace(amb, nextPace);
-        snapRef.current = world.snapshotAt(world.map, world.timeline, tRef.current);
-        resetAmbient(scene, amb, snapRef.current);
-        settleAmbient(scene, amb, snapRef.current);
-        logLenRef.current = -1;
-        pushLog();
-        dirtyRef.current = true;
-        paintOnce();
+        rebuild(seedRef.current, nextPace);
       },
     };
 
@@ -585,7 +585,8 @@ export default function TheGenesis() {
     const n = (paceIndex(paceRef.current) + 1) % PACES.length;
     setPaceIdx(n);
     api.current?.choosePace(PACES[n]);
-    syncUrl(seedRef.current, PACES[n], false);
+    // A different pace is a different map, so any hand-set camera is stale too.
+    syncUrl(seedRef.current, PACES[n], true);
   }, [syncUrl]);
 
   const goLive = useCallback(() => {
@@ -735,8 +736,8 @@ export default function TheGenesis() {
           type="button"
           className="gen-pace"
           onClick={cyclePace}
-          aria-label={`Work pace: ${PACE_LABELS[paceIdx]} times a normal day's work`}
-          title="Work pace — how much the valley gets built in a day"
+          aria-label={`Ambition: ${PACE_LABELS[paceIdx]}× as much valley built today`}
+          title="Ambition — how much the valley builds today"
         >
           <span className="gen-plab" aria-hidden="true">
             pace