Genesis: treasure chests, and the day's one piece of luck

A seed now buries nought, one or two chests in the deep wood or out on the
open moor, well off every road. Some days the crews walk right past them;
roughly two days in five with a chest to find, somebody's spade hits a lid,
and the valley gets a story — and sometimes rather more than a story.

  coin     the finding town raises one or two EXTRA plots today
  charter  the finding town raises a gildhall, gilt eaves and all
  trinket  a comb, a bad coin, forty years of damp

THE SCALE RULE. Chests are TERRAIN: position, contents, finder and the day's
luck are a pure function of the seed and are byte-identical at 0.25x and 4x
(genesis-stats now checks `chests` alongside river, trees and scatter). The
REWARD is not terrain — it goes through the existing siteBuilt prefix. Both
tiers put what the chest bought at roster index countAt(SCALE_MIN) and raise
siteBuilt by the same amount, so a prefix of length countAt(S) + grant always
reaches it and is still monotone in S. `grantIds` names those buildings, and
when a small pace trims the finding town (or its grant) out of the day the
timeline sees that and narrates at trinket tier: the find is real, the
windfall never arrives.

The map owns the luck because a hoard pays for BUILDINGS and buildings are
map data; the timeline owns the hour and every word, on its own substream, so
adding this left every existing ledger line exactly where it was. `dig` and
`discover` are appended to TYPE_RANK and are always laid down before the town
starts spending — cause, then effect.

  gen.ts       buryChests(): a derived substream, run after the chunks and the
               full road network, before the buildings it may have to pay for.
  timeline.ts  chestPass(): dig/discover events, five ledger pools, and a tease
               line for the chests nobody turns up.
  scene.ts     three chest states off the snapshot, a finder who walks out from
               the claiming town, and a handful of pixels at the moment.
  art.ts       buildChestMound / buildChest / drawChestGlint, and the gildhall
               role: gilt eaves, gilt ridge, a ridge lamp and a charter plaque.
  harness      chest invariants at every scale (t), discovery validity (n2),
               fixtures that carry chests, and a discovery-rate readout.

genesis:check and genesis:sweep 200 both pass; discovery lands on 41.4% of
chest-days (33.5% of all days).

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

Author: CodeManEthan

scripts/genesis-stats.mjs

@@ -187,6 +187,23 @@ function report(seed) {
       .map(([k, v]) => `${k} ${v}`)
       .join(', ');
   };
+  const chests = map.chests ?? [];
+  say(`\nCHESTS (${chests.length})`);
+  for (const c of chests) {
+    const p = uvOf(c);
+    let road = Infinity;
+    for (const r of map.roads) road = Math.min(road, polyDist(p, roadUV.get(r.id)));
+    const site = map.sites.find((s) => s.id === c.siteId);
+    const paid = site ? c.grantIds.filter((id) => site.buildings.some((b) => b.id === id)) : [];
+    say(
+      `  ${c.id} ${c.reward.padEnd(8)} u,v ${f1(p[0]).padStart(6)},${f1(p[1]).padStart(6)}  ` +
+        `${c.biome.padEnd(6)} ${('“' + c.where + '”').padEnd(18)} ` +
+        `road ${f1(road).padStart(5)}  river ${f1(polyDist(p, river)).padStart(5)}  ` +
+        `${c.found ? 'FOUND' : 'buried'} by ${c.siteId}${site ? '' : ' (trimmed)'}  ` +
+        `pays ${paid.length}/${c.grantIds.length}${c.grantIds.length ? ' [' + c.grantIds.join(' ') + ']' : ''}`
+    );
+  }
+
   say(`\nforest character: ${woodCharacter(seed)}`);
   say(`tree kinds: ${hist(map.trees, (t) => t.kind)}`);
   say(`scatter kinds: ${hist(map.scatter, (p) => p.kind)}`);
@@ -456,6 +473,78 @@ function checks(seed, map, scale = 1) {
     );
   }
 
+  /* (t) buried treasure: nought to two, in deep cover, well off every road,
+     and paying out only where the day's roster could carry the reward.
+     Chests are TERRAIN — the scale-identity half of that is in subsetChecks. */
+  {
+    const chests = map.chests ?? [];
+    const bad = [];
+    const ids = new Set();
+    let minRoad = Infinity;
+    let minRiver = Infinity;
+    let minSite = Infinity;
+    for (const c of chests) {
+      if (ids.has(c.id)) bad.push(`duplicate id ${c.id}`);
+      ids.add(c.id);
+      const p = uvOf(c);
+      const chunk = map.chunks.find(
+        (k) => p[0] >= k.u0 && p[0] < k.u1 && p[1] >= k.v0 && p[1] < k.v1
+      );
+      if (!chunk) bad.push(`${c.id} sits outside every chunk`);
+      else if (chunk.biome !== 'forest' && chunk.biome !== 'moor')
+        bad.push(`${c.id} buried in ${chunk.biome}`);
+      else if (chunk.biome !== c.biome) bad.push(`${c.id} says ${c.biome}, ground says ${chunk.biome}`);
+      if (!c.where) bad.push(`${c.id} has nowhere to be`);
+      for (const r of map.roads) minRoad = Math.min(minRoad, polyDist(p, roadUV.get(r.id)));
+      minRiver = Math.min(minRiver, polyDist(p, river));
+      for (const s of map.sites) minSite = Math.min(minSite, d2(p, uvOf(s)) - s.radius);
+      for (const o of chests) if (o !== c && d2(p, uvOf(o)) < 12 - 1e-9) bad.push(`${c.id} crowds ${o.id}`);
+
+      if (!(c.siteIndex >= 1)) bad.push(`${c.id} names s0 as its finder`);
+      if (c.siteId !== `s${c.siteIndex}`) bad.push(`${c.id} siteId/siteIndex disagree`);
+      if (!['coin', 'charter', 'trinket'].includes(c.reward)) bad.push(`${c.id} reward ${c.reward}`);
+      if (!c.found && c.grantIds.length) bad.push(`${c.id} was never found but pays out`);
+      if (c.reward === 'trinket' && c.grantIds.length) bad.push(`${c.id} is a trinket that pays out`);
+      if (c.reward === 'charter' && c.found && c.grantIds.length !== 1)
+        bad.push(`${c.id} charter grants ${c.grantIds.length}`);
+      for (const id of c.grantIds)
+        if (!id.startsWith(`${c.siteId}-`)) bad.push(`${c.id} grant ${id} is not ${c.siteId}'s`);
+
+      const site = map.sites.find((s) => s.id === c.siteId);
+      if (site && c.grantIds.length) {
+        const here = c.grantIds.filter((id) => site.buildings.some((b) => b.id === id));
+        // All of it, or (only where the pace control trimmed the town's roster
+        // back past the grant) none of it. Never half a windfall.
+        if (here.length && here.length !== c.grantIds.length)
+          bad.push(`${c.id} pays out ${here.length}/${c.grantIds.length} at ${scale}x`);
+        if (scale >= 1 && here.length !== c.grantIds.length)
+          bad.push(`${c.id} reward trimmed at ${scale}x — a normal day must always pay`);
+        if (c.reward === 'charter' && here.length && !site.buildings.some((b) => b.role === 'gildhall'))
+          bad.push(`${c.id} charter paid out with no gildhall in ${site.id}`);
+      }
+    }
+    // A gildhall exists for exactly one reason.
+    for (const s of map.sites)
+      for (const b of s.buildings)
+        if (
+          b.role === 'gildhall' &&
+          !chests.some((c) => c.found && c.reward === 'charter' && c.grantIds.includes(b.id))
+        )
+          bad.push(`${b.id} is a gildhall nobody found a charter for`);
+
+    check(
+      't  chests buried off the road',
+      chests.length <= 2 &&
+        bad.length === 0 &&
+        (!chests.length || (minRoad >= 2 && minRiver >= 3 && minSite >= 3)),
+      `${chests.length} chest(s)` +
+        (chests.length
+          ? `, nearest road ${f1(minRoad)}, river ${f1(minRiver)}, town rim ${f1(minSite)}`
+          : '') +
+        (bad.length ? ` — ${bad.join('; ')}` : '')
+    );
+  }
+
   /* (s) no two towns wear the same accent */
   {
     const acc = map.sites.map((s) => s.accent);
@@ -490,7 +579,11 @@ function subsetChecks(seed) {
   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']) {
+  // `chests` is in here on purpose: a chest is terrain. Where it is, what is in
+  // it, who finds it and whether the day's digging turns it up at all are all a
+  // pure function of the seed. Only the REWARD is allowed to notice the pace,
+  // and it does that through the ordinary site/building prefix below.
+  for (const field of ['river', 'riverWidth', 'chunks', 'trees', 'scatter', 'chests', 'bounds', 'content', 'valleyName']) {
     const ok = maps.every((m) => same(m[field], maps[0][field]));
     check(`terrain: ${field} identical`, ok);
   }
@@ -576,6 +669,64 @@ function subsetChecks(seed) {
   return pass;
 }
 
+/* ------------------------------ chest rates ------------------------------ */
+
+/**
+ * How often a day buries treasure, and how often the day's digging turns any of
+ * it up. The number that matters is the last one: a discovery on roughly one in
+ * three to one in two of the days that have a chest to find. Rarer than that and
+ * nobody ever sees the feature; commoner and it stops being luck.
+ */
+function chestReport(n) {
+  let chestDays = 0;
+  let findDays = 0;
+  let total = 0;
+  let found = 0;
+  const nHist = {};
+  const tier = {};
+  const paid = {};
+  const where = {};
+  for (let s = 1; s <= n; s++) {
+    const map = generateMap(s);
+    const chests = map.chests ?? [];
+    nHist[chests.length] = (nHist[chests.length] ?? 0) + 1;
+    if (chests.length) chestDays++;
+    let f = 0;
+    for (const c of chests) {
+      total++;
+      tier[c.reward] = (tier[c.reward] ?? 0) + 1;
+      where[c.where] = (where[c.where] ?? 0) + 1;
+      if (!c.found) continue;
+      found++;
+      f++;
+      const site = map.sites.find((x) => x.id === c.siteId);
+      const key =
+        c.reward === 'trinket'
+          ? 'trinket (nothing owed)'
+          : site && c.grantIds.every((id) => site.buildings.some((b) => b.id === id))
+            ? `${c.reward} paid`
+            : `${c.reward} TRIMMED`;
+      paid[key] = (paid[key] ?? 0) + 1;
+    }
+    if (f) findDays++;
+  }
+  const pct = (a, b) => (b ? `${((a / b) * 100).toFixed(1)}%` : '--');
+  const hist = (o) =>
+    Object.entries(o)
+      .sort((a, b) => b[1] - a[1])
+      .map(([k, v]) => `${k} ${v}`)
+      .join(', ');
+  console.log(`\nBURIED TREASURE over ${n} seeds`);
+  console.log(`  chests per day: ${hist(nHist)}   (${chestDays} days with a chest, ${total} chests)`);
+  console.log(`  rewards buried: ${hist(tier)}`);
+  console.log(`  ground:         ${hist(where)}`);
+  console.log(`  found at 1x:    ${found}/${total} chests (${pct(found, total)}), ${hist(paid)}`);
+  console.log(
+    `  => a discovery on ${findDays}/${chestDays} chest-days (${pct(findDays, chestDays)}), ` +
+      `${pct(findDays, n)} of all days`
+  );
+}
+
 /* ---------------------------------- main --------------------------------- */
 
 const argv = process.argv.slice(2);
@@ -618,6 +769,7 @@ if (argv[0] === '--sweep') {
   }
   console.log(`sweep ${Math.min(n, 60)} seeds subset stability: ${subFails.length ? `FAIL ${subFails.join(',')}` : 'ALL PASS'}`);
   if (subFails.length) allPass = false;
+  chestReport(n);
 } else {
   const seeds = argv.length ? argv.map(Number) : [1, 42, 20260802];
   for (const s of seeds) {

scripts/genesis-timeline-stats.mjs

@@ -191,6 +191,35 @@ function makeFixture(seed, opts) {
     });
   }
 
+  // Buried treasure. `opts.chests` is a list of {reward, site, found, grants}:
+  // the map's half of the feature, hand-authored so the timeline can be tested
+  // on shapes gen.ts will not always produce — a find with nothing owed, a
+  // reward the day's roster cannot carry, two chests in one valley.
+  const chests = [];
+  for (const [i, spec] of (opts.chests ?? []).entries()) {
+    const si = Math.min(spec.site ?? 1, nSites - 1);
+    const site = sites[si];
+    const n = spec.found && spec.reward !== 'trinket' ? (spec.grants ?? 1) : 0;
+    const grantIds = [];
+    for (let k = 0; k < n; k++) {
+      const b = site.buildings[site.buildings.length - 1 - k];
+      if (b) grantIds.unshift(b.id);
+    }
+    chests.push({
+      id: `ch${i}`,
+      gx: 74 + i * 9,
+      gy: 6 + i * 13,
+      seed: 4000 + i * 13,
+      biome: i % 2 ? 'moor' : 'forest',
+      where: i % 2 ? 'the high moor' : 'the fir wood',
+      reward: spec.reward,
+      siteIndex: si,
+      siteId: site.id,
+      found: !!spec.found,
+      grantIds: spec.orphanGrant ? [`${site.id}-b999`] : grantIds,
+    });
+  }
+
   return {
     version: 1,
     seed,
@@ -208,6 +237,7 @@ function makeFixture(seed, opts) {
     bridges,
     trees,
     scatter,
+    chests,
     valleyName: 'Ashmere Vale',
   };
 }
@@ -268,6 +298,7 @@ function serialize(snap) {
     roads: m(snap.roads),
     bridges: m(snap.bridges),
     props: s(snap.props),
+    chests: m(snap.chests),
     founded: s(snap.founded),
     population: m(snap.population),
     log: snap.log,
@@ -554,6 +585,49 @@ function run(label, map, pace = 1) {
   for (const [id, n] of startCount) if (n > 1) bad(`(m) tree ${id} felled ${n} times`);
   for (const [id, n] of doneCount) if (n > 1) bad(`(m) tree ${id} chop-done ${n} times`);
 
+  /* (n2) buried treasure: one dig and one lid per chest, only for the chests
+     the map actually buried and actually found, and always before the town
+     starts spending the proceeds */
+  const chests = map.chests ?? [];
+  const chestById = new Map(chests.map((c) => [c.id, c]));
+  const digT = new Map();
+  const discT = new Map();
+  for (const e of ev) {
+    if (e.type !== 'dig' && e.type !== 'discover') continue;
+    const into = e.type === 'dig' ? digT : discT;
+    if (!chestById.has(e.chestId)) bad(`(n2) unknown chestId ${e.chestId}`);
+    if (into.has(e.chestId)) bad(`(n2) ${e.chestId}: two ${e.type} events`);
+    else into.set(e.chestId, e.t);
+  }
+  for (const [id, t] of discT) {
+    const c = chestById.get(id);
+    if (!c) continue;
+    if (!c.found) bad(`(n2) ${id} was opened, but the map never found it`);
+    if (!digT.has(id)) bad(`(n2) ${id} was opened without anybody digging for it`);
+    else if (digT.get(id) > t + 1e-9)
+      bad(`(n2) ${id}: dug at ${hhmm(digT.get(id))}, already open at ${hhmm(t)}`);
+    // Cause, then effect: nothing a chest paid for may be staked out first.
+    for (const gid of c.grantIds) {
+      const sT = surveyT.get(gid);
+      if (sT === undefined) continue;
+      if (sT < t - 1e-9)
+        bad(`(n2) ${id}: reward ${gid} surveyed at ${hhmm(sT)}, chest not open until ${hhmm(t)}`);
+    }
+  }
+  for (const id of digT.keys())
+    if (!discT.has(id) && !truncated) bad(`(n2) ${id} was dug for and never opened`);
+  if (!truncated)
+    for (const c of chests)
+      if (c.found && !discT.has(c.id)) bad(`(n2) ${c.id} was found by the map but never opened`);
+  if (!truncated) {
+    for (const c of chests) {
+      const st = end.chests.get(c.id);
+      if (c.found && st !== 'open') bad(`(n2) ${c.id} is ${st ?? 'still buried'} at midnight`);
+      if (!c.found && st !== undefined) bad(`(n2) ${c.id} should have stayed buried, is ${st}`);
+    }
+  }
+  if (emptySnapshot(map).chests.size) bad(`(n2) chests are already disturbed at t=0`);
+
   /* (k) day arc: first road mid-morning, ledger well spread, quiet close */
   const roadEvents = ev.filter((e) => e.type === 'road');
   const firstRoad = roadEvents.length ? roadEvents[0].t : null;
@@ -608,6 +682,18 @@ function run(label, map, pace = 1) {
   );
   const foundLine = [...foundT.entries()].map(([k, v]) => `${k}@${hhmm(v)}`).join(' ');
   if (foundLine) console.log(`  foundings: ${foundLine}`);
+  if (chests.length) {
+    console.log(
+      `  chests: ` +
+        chests
+          .map(
+            (c) =>
+              `${c.id}/${c.reward}${c.grantIds.length ? `x${c.grantIds.length}` : ''}` +
+              (discT.has(c.id) ? `@${hhmm(discT.get(c.id))}` : c.found ? '@NEVER' : ' buried')
+          )
+          .join('  ')
+    );
+  }
   for (const m of fails) console.log(`  ! ${m}`);
   return { fails, ev, tl, map, lastBuild, pace };
 }
@@ -662,6 +748,39 @@ cases.push([
   makeFixture(5150, { buildings: [7, 6, 6, 6, 5], trees: 180, loopRoad: true, roadClears: 10 }),
 ]);
 cases.push(['fixture: one site only', makeFixture(31337, { buildings: [5], trees: 18 })]);
+cases.push([
+  'fixture: a coin hoard and a charter, both found',
+  makeFixture(60613, {
+    buildings: [5, 5, 4],
+    trees: 90,
+    roadClears: 6,
+    chests: [
+      { reward: 'coin', site: 1, found: true, grants: 2 },
+      { reward: 'charter', site: 2, found: true, grants: 1 },
+    ],
+  }),
+]);
+cases.push([
+  'fixture: chests nobody finds, and a trinket somebody does',
+  makeFixture(60614, {
+    buildings: [4, 4],
+    trees: 60,
+    chests: [
+      { reward: 'coin', site: 1, found: false, grants: 2 },
+      { reward: 'trinket', site: 1, found: true },
+    ],
+  }),
+]);
+cases.push([
+  // the pace control trimmed the reward out of the day: the find is real, the
+  // windfall never arrives, and the ledger has to cope
+  'fixture: a find whose reward is not in the map',
+  makeFixture(60615, {
+    buildings: [4, 3],
+    trees: 40,
+    chests: [{ reward: 'coin', site: 1, found: true, grants: 2, orphanGrant: true }],
+  }),
+]);
 
 if (generateMap) {
   for (const day of ['2026-08-02', '2026-08-03', '2026-12-25', '2027-01-01']) {

src/components/designs/genesis/Catalog.tsx

@@ -48,6 +48,7 @@ import type { Biome, RoofStyle, StructureRole, TreeKind, Vec2 } from './types';
 const ROLES: StructureRole[] = [
   'cottage', 'house', 'hall', 'barn', 'workshop', 'store', 'chapel', 'tower',
   'mill', 'granary', 'smithy', 'shed', 'bakery', 'brewhouse', 'homestead',
+  'gildhall',
 ];
 
 /**
@@ -78,6 +79,9 @@ const PROP_POOLS = [
   'bush', 'rock', 'flowers', 'reeds', 'stump', 'crop', 'haystack', 'fenceL',
   'fenceR', 'shed', 'cart', 'crates', 'lumber', 'barrels', 'well', 'lamp',
   'sheep', 'campfire',
+  // Buried treasure. Never a PropSpec — chests are their own list on the map —
+  // but pooled all the same, so they belong on this shelf.
+  'chest-buried', 'chest-closed', 'chest-open',
 ];
 
 /** Kinds not in the pools — built on demand by `propSprite()` in scene.ts. */
@@ -97,6 +101,9 @@ const EXTRA_PROPS = ['nameboard', 'signpost', 'stake', 'crane'];
 const GENERATED = new Set<string>([
   'bush', 'rock', 'stump', 'flowers', 'sheep', 'reeds', 'fenceL', 'fenceR',
   'well', 'nameboard', 'lamp', 'signpost', 'campfire', 'lumber',
+  // The three states of a buried chest. gen.ts emits 0..2 ChestSpecs a day and
+  // the timeline moves them between these sprites.
+  'chest-buried', 'chest-closed', 'chest-open',
   ...FLAVOUR_PROPS,
 ]);
 const SCENE_ONLY = new Set<string>(['crane']);
@@ -274,6 +281,7 @@ const SPECIMEN: Record<StructureRole, RoleSpec> = {
   bakery: { w: 40, floors: 1, roof: 'gable', chimney: true },
   brewhouse: { w: 44, floors: 2, roof: 'hip', chimney: true },
   homestead: { w: 44, floors: 2, roof: 'gable', chimney: true, banner: true },
+  gildhall: { w: 52, floors: 3, roof: 'gable', banner: true },
 };
 
 function structure(