Genesis: living details — crops ripen, logs lie, saplings come up

Props stop being one sprite for the whole day.

CROPS RIPEN. A crop plot is three sprites now: sprouts on bare drills
before ~10:00, the rows that have always been there until ~16:00, and
tall gold after. The stage is a pure function of the clock and a ±40
world-minute jitter off the plot's own seed, so a valley's fields do not
all turn on the same stroke. `buildCropRow` is untouched and is still the
middle stage; the two new sprites are built from the same pool seeds, so
a field keeps its colour and its earth as it ripens.

FELLED LOGS. A tree that goes over leaves its trunk beside the stump for
ninety world-minutes, then the yards haul it. The honest clock for that
needed the snapshot to say WHEN a tree became a stump, not just that it
had — scene-side it could only ever have been "the frame I noticed the
slot flip", which is a different world after a scrub. So WorldSnapshot
grows one field, `felled: Map<treeId, t>`, written by the `chop-done`
event that already existed: no new event type, TYPE_RANK untouched,
applyEvent/emptySnapshot updated in timeline.ts and fixture.ts alike, and
serialize() in the harness taught the field so check (j) still compares
all of the snapshot. A new check (j2) holds `felled` to the events and to
`trees` at midnight and at midday.

SAPLINGS. Three to five come up after ~18:00 on ground the day's axes
cleared — anchored to road clears standing clear of every town, so
regrowth lands on the lane through the wood and not under somebody's new
roof, and each one still gated on its anchor actually being a stump.

VEG CACHE. The layer's two fingerprints say "nothing changed unless the
snapshot grew", and all three of these change on the clock instead, so
each carries its own sweep: crops and saplings are recomputed outright
every sync (a dozen plots, five saplings), and a felled log turns ON
through the existing tree paths but OFF through `veg.logOn`, the short
list of trunks currently on the ground. None of the three caches a state
of its own — every one recomputes what it wants from (snapshot, t) and
lets `want` compare it against `veg.on` — so a backward scrub still needs
nothing beyond `invalidateVeg`. Log slots and sapling anchors are
allocated only for trees the map has already promised to a plot or a
road, which is the complete set that can ever become a stump; the other
two thousand trees are unchanged two-slot trees.

Gates: genesis:check 61/61, sweep 200 seeds 1x/4x, perf worst avg 2.6ms /
max 4.7ms against 4:8, astro build 7 pages, console clean. Scrubbing to
the same t twice gives identical pixels, and the veg layer at 08:00,
13:00 and 19:30 is identical whether reached by loading or by scrubbing
back from 21:00.

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

Author: CodeManEthan

scripts/genesis-timeline-stats.mjs

@@ -312,6 +312,9 @@ function serialize(snap) {
   return JSON.stringify({
     t: snap.t,
     trees: m(snap.trees),
+    // living details: fell times. Listed explicitly, because (j) compares
+    // serialisations and anything left out of here is silently not checked.
+    felled: m(snap.felled ?? new Map()),
     buildings: m(snap.buildings),
     roads: m(snap.roads),
     bridges: m(snap.bridges),
@@ -593,6 +596,26 @@ function run(label, map, pace = 1) {
   for (let t = 0.5; t <= 24.0001; t += 0.5) advance(hop3, tl, Math.min(t, 24));
   if (serialize(hop3) !== serialize(end)) bad(`(j) 48-hop advance != snapshotAt(24)`);
 
+  /* (j2) living details: fell times agree with the chop-done events, and with
+   * `trees` — the felled log's whole clock hangs off this map, so a stump with
+   * no fell time (or a fell time with no stump) is a log that never lies down
+   * or never gets hauled. Checked at mid-day too, where `felled` is partial. */
+  for (const [id, t] of end.felled ?? []) {
+    if (chopDone.get(id) !== t) bad(`(j2) felled[${id}] = ${t}, chop-done at ${chopDone.get(id)}`);
+    if (end.trees.get(id) !== 'stump') bad(`(j2) felled[${id}] but tree is ${end.trees.get(id)}`);
+  }
+  for (const [id, st] of end.trees) {
+    if (st === 'stump' && !(end.felled ?? new Map()).has(id))
+      bad(`(j2) tree ${id} is a stump at t=24 with no fell time`);
+  }
+  {
+    const mid = snapshotAt(map, tl, 12);
+    for (const [id, t] of mid.felled ?? []) {
+      if (!(t <= 12 + 1e-9)) bad(`(j2) felled[${id}] = ${t} present in the t=12 snapshot`);
+      if (mid.trees.get(id) !== 'stump') bad(`(j2) t=12: felled[${id}] but tree is not a stump`);
+    }
+  }
+
   /* (l) road felling: nothing is left standing on finished road surface */
   for (const r of map.roads) {
     const list = roadEv.get(r.id) ?? [];

src/components/designs/genesis/Catalog.tsx

@@ -730,14 +730,19 @@ const COVERAGE: { head: string; body: string }[] = [
       'seasonCanvas runs over the six DECIDUOUS pools and the ground tint. crop, haystack, reeds and flowers are summer art in every month, so a winter valley still has a green cornfield in it.',
   },
   {
-    head: 'Trees have two states and a nudge',
+    head: 'A tree still falls in one nudge',
     body:
-      'standing / stump, with felling drawn as the standing sprite shoved ±2px. No half-fallen trunk, no felled log on the ground, no sapling.',
+      'The ladder now runs standing → felling → stump → stump with its log → stump, and three to five saplings come up on cleared ground in the evening. The fall itself is still the standing sprite shoved ±2px: there is no half-fallen trunk, no lean, and nothing between “upright” and “gone”.',
   },
   {
-    head: 'Props are one sprite each',
+    head: 'Crops ripen; nothing else does',
     body:
-      'crop never ripens, haystack never shrinks, crates never stack higher as a town grows. Progress is expressed by buildings alone.',
+      'crop is three sprites now and moves through them on the clock. haystack, crates, barrels and cart are still one sprite for the whole day — a haystack never grows as it is built up, and a store’s crates never stack higher as the town around them does. Everything except the fields still expresses progress through buildings alone.',
+  },
+  {
+    head: 'The log is hauled by nobody',
+    body:
+      'A felled trunk lies for 90 world-minutes and then stops existing. No carrier walks out to it, no cart takes it, and the lumber pile in the yard does not grow by one when it goes — the two halves of the valley’s timber economy are drawn, and never joined up.',
   },
 ];
 
@@ -907,6 +912,40 @@ export default function Catalog() {
   const props = useMemo(() => poolItems(PROP_POOLS, 'pp'), [pools]);
   const treasure = useMemo(() => poolItems(TREASURE_POOLS, 'tz'), [pools]);
 
+  /* ---- living details (additive) ---------------------------------------- */
+
+  /** One field at three ages. Pool index is shared, so a plot keeps its
+   * colour and its earth as it ripens; two of the four seeds shown. */
+  const cropStages = useMemo(() => {
+    const out: Item[] = [];
+    const stages: [string, string][] = [
+      ['crop-sprout', 'sprout · before 10:00'],
+      ['crop', 'rows · 10:00–16:00'],
+      ['crop-tall', 'tall · after 16:00'],
+    ];
+    for (let v = 0; v < 2; v++) {
+      for (const [kind, sub] of stages) {
+        const p = pools[kind] ?? [];
+        if (p[v]) out.push(item(`cs-${v}-${kind}`, kind, spriteCanvas(p[v]), { sub }));
+      }
+    }
+    return out;
+  }, [pools]);
+
+  /** What a felling leaves on the ground, and what comes up after it. */
+  const treeAfter = useMemo(() => {
+    const out: Item[] = [];
+    (pools.log ?? []).forEach((sp, i) =>
+      out.push(item(`lg-${i}`, 'log', spriteCanvas(sp), { sub: TREE_KINDS[i] ?? `kind ${i}` }))
+    );
+    (pools.sapling ?? []).forEach((sp, i) =>
+      out.push(item(`sa-${i}`, 'sapling', spriteCanvas(sp), { sub: `seed ${i + 1}` }))
+    );
+    return out;
+  }, [pools]);
+
+  /* ---- end living details (additive) ------------------------------------ */
+
   const extras = useMemo(() => {
     const out: Item[] = [];
     out.push(item('ex-nameboard', 'nameboard', spriteCanvas(buildNameBoard(ACCENT))));
@@ -1244,8 +1283,8 @@ export default function Catalog() {
 
   const counts = {
     structures: structures.length + materials.length + stages.length + roofs.length,
-    trees: trees.length + treeStates.length,
-    props: props.length + treasure.length + extras.length,
+    trees: trees.length + treeStates.length + treeAfter.length,
+    props: props.length + treasure.length + extras.length + cropStages.length,
     inhabitants: anims.length,
     wildlife: wildlife.length,
     infra: bridges.length + roads.length + grounds.length,
@@ -1307,23 +1346,37 @@ export default function Catalog() {
           id="trees"
           title="Trees"
           count={counts.trees}
-          blurb="buildTree(kind, seed) — seven kinds, four seeds each, plus the two states a tree can be caught in."
+          blurb="buildTree(kind, seed) — seven kinds, four seeds each, the states a tree can be caught in, and what its felling leaves behind."
         >
           <Row title={`Kinds (${TREE_KINDS.length})`} items={trees} />
           <Row
             title="States"
             note="A tree under the axe is the standing sprite offset ±2px; once felled it is replaced by a stump."
             items={treeStates}
           />
+          {/* ---- living details (additive) ---- */}
+          <Row
+            title={`After the axe (${treeAfter.length})`}
+            note="The trunk lies beside its stump for 90 world-minutes and is then hauled off to the yards — one log per tree kind, because the bark is all that tells them apart at this size. Three to five saplings come up on the day's cleared ground after 18:00, each beside a stump the day actually made."
+            items={treeAfter}
+          />
+          {/* ---- end living details (additive) ---- */}
         </Section>
 
         <Section
           id="props"
           title="Props & scatter"
           count={counts.props}
-          blurb="Every pooled kind from makePools(), all pool variants, plus the four built on demand by propSprite(). “unused” means gen.ts never emits it."
+          blurb="Every pooled kind from makePools(), all pool variants, plus the four built on demand by propSprite(). “unused” means gen.ts never emits it. The log and sapling pools are shelved with the trees, whose felling is the only thing that asks for them."
         >
           <Row title={`Pools (${PROP_POOLS.length} kinds)`} items={props} />
+          {/* ---- living details (additive) ---- */}
+          <Row
+            title="Crop stages (3)"
+            note="The one prop that is not a single sprite. A plot is sprouts before ~10:00, the rows that have always been here until ~16:00, and tall gold after — the stage is a pure function of the clock and a ±40-minute jitter off the plot's own seed, so a valley's fields do not all turn on the same stroke. All three stages share a pool index, so a field keeps its colour and its earth as it ripens."
+            items={cropStages}
+          />
+          {/* ---- end living details (additive) ---- */}
           <Row
             title={`Treasure (${TREASURE_POOLS.length} states)`}
             note="Pooled, but never a PropSpec: chests are their own list on the map. The timeline walks a found chest along all three — mound, prised open, emptied."

src/components/designs/genesis/fixture.ts

@@ -610,6 +610,9 @@ export function fixtureEmptySnapshot(map: GenesisMap): WorldSnapshot {
   return {
     t: 0,
     trees: new Map(),
+    /* ---- living details (additive) ---- */
+    felled: new Map(),
+    /* ---- end living details (additive) ---- */
     buildings,
     roads: new Map(),
     bridges: new Map(),
@@ -657,6 +660,9 @@ function applyEvent(snap: WorldSnapshot, ev: GenesisEvent): void {
       break;
     case 'chop-done':
       snap.trees.set(ev.treeId, 'stump');
+      /* ---- living details (additive) ---- */
+      snap.felled.set(ev.treeId, ev.t);
+      /* ---- end living details (additive) ---- */
       break;
     case 'survey':
       snap.buildings.set(ev.buildingId, { status: 'surveyed', progress: 0.05 });