{"version":3,"sources":["seedlings.mjs"],"sourcesContent":["// TREE SEEDLINGS (the owner's confirmed proposal of Oct 22, with the owner's three notes over the page's wording: \"Scratch\n// sapling terminology and use seedling instead\", \"walkthrough unless there's a collision at eye level\", \"Animate smoothly\n// between all stages of growth\").\n//\n//   * DROP: felling a WHOLE tree (its foot cut, nothing of it left standing on its footing) gives ONE seedling, credited by\n//     the server, on top of the bits it always gave. Trees are the thirteen tree forms (organics.mjs TREE_FORMS), the\n//     thorn shrub (a woody shrub: Gloam wood under its star's leaves), and the five trees of before version 7, whose\n//     seedling is the tree form that took each one's place in the owner's pool of Oct 2 (SUCCESSOR_FORM). Not the reeds,\n//     lattices, fungi, coral or anything else of bits: nothing of wood and leaf.\n//   * NAME: one item per pigment and form, \"<Pigment> <Form> Seedling\" (an \"Aura Cone Seedling\"), for each pair that can\n//     occur: a carbon tree form takes any of the leaf pigments its star's class grows (biomes.mjs LEAF_BY_CLASS, as\n//     organics.mjs pgFor picks them), the cloud thicket tree only the Solis of its tholin crown. It always grows its\n//     parent's form in its pigment.\n//   * WHERE: on the top of a regolith (turfed or bare, the seed's or placed: soil, never a building kube or a metal), in the\n//     air cell over it, on a claim the player may build on (as every edit). CLIMATE: its chemistry's, as turf's\n//     (turf.mjs CHEM_RANGE_C); the page says why it will not.\n//   * GROWTH: four stages, seedling → shoot (about a kube) → young tree (about half its height) → tree, over GROW_MINUTES of\n//     real time with no speed-ups, and SMOOTH between them: the plant is its full tree scaled about its foot, the scale\n//     running continuously through the four stages' sizes (scaleAt). Its clock PAUSES while anything stands in the space\n//     its next size needs (ROOM: it never grows into a block) and while anything is over it (SKY), and runs on once they\n//     are cleared.\n//   * FULL: at full size it is a real tree, its bits written into the world as placed bits of its wood and leaves\n//     (materialised by a server's next write, and drawn so by the page from the minute it is due), which mine and fall\n//     as the seed's trees do, and felled whole drop a seedling again. BREAK before then gives the seedling back, at any\n//     stage. WALK: a growing plant is walked through, unless some part of it stands at the walker's eye level.\n//\n// THE RECORD: the seedling's name at '…_29' of the cell it grows in (bit-slot.js SEEDLING_SEAT), and its clock in the\n// chunk's `t` at the same key: one number, the minute it was last settled, and the light-minutes it had grown by then\n// and its bark (seedStamp; all whole numbers, so all exact). Nothing ticks a world: growth is a pure function of that\n// clock, the world as it stands and the sun (growthOf), and a server re-settles a seedling's clock only when a write\n// changes what it may grow into or whether it has sky (seedlingSession), so every page and both servers work out the\n// same plant at every minute.\n//\n// GROWN BY THE LIGHT IT RECEIVES (the owner, Oct 23: \"tree growth rate to match how much light the tree has received\",\n// for example slower in winter and none on a tidally locked world's night side; the Tree Light and Bark picks, confirmed\n// 15:01Z, artifact C4UNDwLujm5XJThCaEuD6G). Its clock no longer counts minutes but LIGHT-MINUTES:\n//   g_light  the sunlight on its own face, exactly as the suit charges by it (energy.mjs: each lighting star's flux at the\n//            world times the height of its sun over the face, from the same stored sun descriptor, sunlight.mjs\n//            sunDescriptorFor), so its sun climbs and sets with the day, rides higher in summer and lower in winter, and\n//            never rises on a locked world's night side;\n//   g_scale  ABSOLUTE: a light-minute is a minute of a bright sun's full light (flux 1, the habitable-zone centre's, its\n//            sun straight overhead), and GROW_MINUTES of them make a tree, the same on every world, so a dim world grows\n//            slowly (the median life world gets about a quarter of that flux, by day only: about 25 hours);\n//   g_fast   never faster than LIGHT_CAP times that rate, however bright its sun;\n//   g_dusk   the twilight band counts by its share (energy.mjs daylightFrom's soft terminator);\n//   g_show   the page shows its stage, as before, and no meter of its light;\n//   g_now    one planted before this (a stamp of the old kind) keeps what it had grown and, after LIGHT_SINCE_MIN, follows\n//            the light.\n// Blocks overhead pause it, as ever (SKY), and so does anything in its room (ROOM).\n// …AND ITS BARK (w_seed, the owner's pick: \"a planted tree keeps its parent's bark\"): a felled tree's seedling carries the\n// bark its wood was (the stack's `x.k`, tool-tiers.mjs), and is planted with it, its record keeping it in its stamp; one\n// with no bark of its own grows the bark the world's starlight rule gives its form on that face (organics.mjs barkOf, a\n// world of version 23 or later) or, on an older world, its leaves' pigment, as every seedling did before.\n//\n// THREE BYTE-IDENTICAL COPIES: public/, functions/lib/ and zone-server/lib/, checked by generate-version-hash.js. Its\n// imports are twins in all three directories.\nimport { growOrganic, organicMaterial, FAMILIES, LEAF_BY_CLASS, PART, SPECIES, sizeKOf } from './organics.mjs';\nimport { supportedOf } from './life-seats.mjs';\nimport { CHEM_RANGE_C, upOf, isRegolithName } from './turf.mjs';\nimport { starlightSum, daylightFrom, AIR_TRANSMISSION } from './energy.mjs';\n\nexport const SEEDLING_SEAT = 29;          // bit-slot.js SEEDLING_SEAT\nexport const SEEDLING_SINCE = 9;          // planted on worlds whose servers read every chunk (turf.mjs TURF_SINCE)\nexport const GROW_MINUTES = 120;          // the owner's picks: two hours of a bright sun's full light from planting to a tree (Oct 22, Oct 23)\nexport const STAGE_MINUTES = Object.freeze([0, 40, 80, 120]);   // …in light-minutes\nexport const STAGE_NAMES = Object.freeze(['seedling', 'shoot', 'young tree', 'tree']);\nconst STAMP_Q = 256;                      // an old stamp's growth minutes ride its fraction in 256ths (exact in binary)\n// THE BARKS, IN THE ORDER A STACK (x.k) AND A STAMP SAVE THEM: frozen, as an item's id is (the 32 pigments as organics.mjs\n// ALL_PIGMENTS listed them on Oct 23; a test holds this to that list's set). Never reorder it: the place is the saved data.\nexport const BARK_ORDER = Object.freeze(['Lumina', 'Gleam', 'Drift', 'Void', 'Cinder', 'Arid', 'Scorched', 'Radiance', 'Nova', 'Solis',\n  'Corona', 'Farout', 'Starlight', 'Flash', 'Wisp', 'Spirit', 'Fathom', 'Gloam', 'Halo', 'Bloom', 'Verge', 'Tide', 'Aura', 'Ether',\n  'Glint', 'Echo', 'Lull', 'Veil', 'Haze', 'Ignition', 'Surge', 'Reach']);\nconst BARK_INDEX = new Map(BARK_ORDER.map((v, i) => [v, i]));\nexport const barkIndexOf = (pig) => (BARK_INDEX.has(pig) ? BARK_INDEX.get(pig) : null);\nexport const barkNameOf = (k) => (Number.isInteger(k) && k >= 0 && k < BARK_ORDER.length ? BARK_ORDER[k] : null);\n// A PLANTED TREE FELLED WHOLE keeps its record, its clock at FELLED, so that what falls of it after the cut is still its\n// own (credited free, in a later call too) and it never drops a second seedling; its cell takes a new seedling.\nexport const FELLED = GROW_MINUTES + 1;\n\n// THE FORMS a seedling grows, by species id, and the word its name carries.\nexport const SEEDLING_FORMS = Object.freeze({\n  treeRound: 'Round', treeOval: 'Oval', treeCone: 'Cone', treeUmbrella: 'Umbrella', treeDome: 'Dome', treeTiered: 'Tiered',\n  treePalm: 'Palm', treeWeeping: 'Weeping', treeFork: 'Fork', treeShrub: 'Shrub', treeBirch: 'Birch', treeCloud: 'Cloud',\n  treeBlossom: 'Blossom', thornShrub: 'Thorn' });\n// The trees of before version 7 (claims still on versions 4 to 6), each by the form that took its place in its biomes\n// (organics.mjs BIOME_ORGANICS v7): the crown tree's woods grew round crowns, the rime woods' needle trees conifers, the\n// parkland's flat crowns umbrella trees, the fens' stiltroots weeping trees, the hothouse canopy's trees palms.\nexport const SUCCESSOR_FORM = Object.freeze({ crownTree: 'treeRound', needleTree: 'treeCone', flatCrown: 'treeUmbrella', stiltroot: 'treeWeeping', hothouseTree: 'treePalm' });\nexport const formOfSpecies = (id) => (SEEDLING_FORMS[id] ? id : SUCCESSOR_FORM[id] || null);\nexport const isTreeSpecies = (id) => formOfSpecies(id) != null;\nconst CLOUD_PIGMENT = 'Solis';            // the cloud thicket tree's tholin crown (organics.mjs THO.treeCloud)\n// Every leaf pigment a star grows, in its classes' order (O B A F G K M), each once.\nexport const SEEDLING_PIGMENTS = Object.freeze([...new Set(Object.values(LEAF_BY_CLASS).flat())]);\nexport const chemOfForm = (form) => (form === 'treeCloud' ? 'methane' : 'carbon');\nconst pigmentsOfForm = (form) => (form === 'treeCloud' ? [CLOUD_PIGMENT] : SEEDLING_PIGMENTS);\n\nfunction hash32(s) {\n  let h = 2166136261;\n  for (let i = 0; i < s.length; i++) h = Math.imul(h ^ s.charCodeAt(i), 16777619);\n  h ^= h >>> 15; h = Math.imul(h, 0x2c1b3c6d); h ^= h >>> 12;\n  return h >>> 0;\n}\n// A planted blossom tree's flowers: one of the petals, by its pigment (a seedling carries only its leaves' pigment).\nconst petalOf = (pig) => FAMILIES.petal.variants[hash32(pig + '#seedling-petal') % FAMILIES.petal.variants.length];\n// WHAT A PLANTED TREE IS MADE OF, by part (organics.mjs PART): its own pigment's leaves and its bark's wood (`bark`, a\n// pigment: its parent's, or its world's rule's; none, its leaves' pigment, as every planted tree was before Oct 23), as\n// the seed's are made.\nexport function seedlingMaterials(form, pig, bark = null) {\n  const m = {};\n  if (form === 'treeCloud') { m[PART.WOOD] = 'Gloam Tholin Biomass'; m[PART.BODY] = `${CLOUD_PIGMENT} Tholin Biomass`; return m; }\n  m[PART.WOOD] = form === 'thornShrub' ? 'Gloam Wood' : `${bark || pig} Wood`;\n  m[PART.LEAF] = `${pig} Leaf Biomass`;\n  m[PART.FROST] = m[PART.LEAF];                            // a conifer's rime rings are its own leaves (the owner, Oct 26: no white bands)\n  m[PART.PETAL] = `${petalOf(pig)} Petal`;\n  return m;\n}\n\n// THE CATALOGUE: every seedling, in form order then pigment order. { name, pigment, form, chem, hex, label }.\nexport const seedlingName = (pig, form) => `${pig} ${SEEDLING_FORMS[form]} Seedling`;\nconst LABEL = new Map(SPECIES.map((s) => [s.id, s.label]));\nexport const SEEDLINGS = Object.freeze(Object.keys(SEEDLING_FORMS).flatMap((form) => pigmentsOfForm(form).map((pig) => {\n  const mats = seedlingMaterials(form, pig), crown = organicMaterial(mats[PART.LEAF] || mats[PART.BODY]);\n  return Object.freeze({ name: seedlingName(pig, form), pigment: pig, form, chem: chemOfForm(form), hex: crown ? crown.hex : '#228B22', label: LABEL.get(form) || form });\n})));\nconst BY_NAME = new Map(SEEDLINGS.map((s) => [s.name, s]));\nexport const seedlingInfo = (name) => BY_NAME.get(name) || null;\nexport const isSeedlingName = (name) => BY_NAME.has(name);\n\n// THE SEEDLING A FELLED TREE OF THE SEED DROPS: its form's, in the pigment its leaves were grown in. `bitNames` are the\n// structure's bits' names (\"Verge Leaf Biomass Bit\"). Null for anything that is not a tree, or a pigment no seedling is\n// made in. Its leaves are the pigment most of its leaf bits are (a conifer's rime, Halo Leaf Biomass, is a few of them).\n// UNTIL OCT 23 this read the pigment of its WOOD, which was always its leaves' then; from version 23 a wood is its bark's\n// (organics.mjs barkOf), so it reads the leaves themselves. A shrub of bare twigs is Gloam, its wood's own pigment.\nconst WOOD_BIT_RE = /^(\\S+) Wood Bit$/, LEAF_BIT_RE = /^(\\S+) Leaf Biomass Bit$/;\n// (A tie goes to the pigment its wood is, which before version 23 was always its leaves', then to the first.)\nfunction leafPigmentOf(bitNames) {\n  const n = new Map();\n  let wood = null;\n  for (const b of bitNames) { const s = String(b || ''), m = LEAF_BIT_RE.exec(s);\n    if (m) n.set(m[1], (n.get(m[1]) || 0) + 1); else if (!wood) { const w = WOOD_BIT_RE.exec(s); if (w) wood = w[1]; } }\n  let best = null, top = 0;\n  for (const [p, c] of n) if (c > top || (c === top && p === wood)) { top = c; best = p; }\n  return best;\n}\nexport function treeSeedlingOf(speciesId, bitNames) {\n  const form = formOfSpecies(speciesId);\n  if (!form) return null;\n  if (form === 'treeCloud') return seedlingName(CLOUD_PIGMENT, form);\n  const pig = leafPigmentOf(bitNames) || (form === 'thornShrub' ? 'Gloam' : null);\n  const name = pig ? seedlingName(pig, form) : null;\n  return name && BY_NAME.has(name) ? name : null;\n}\n// …AND THE BARK IT CARRIES (w_seed): the pigment of its tree's wood, as a place in BARK_ORDER, or null for a tree whose\n// wood is not its own to give (the thorn shrub's is always Gloam, the cloud tree's tholin) or that has none left.\nexport function treeBarkOf(speciesId, bitNames) {\n  const form = formOfSpecies(speciesId);\n  if (!form || form === 'treeCloud' || form === 'thornShrub') return null;\n  for (const b of bitNames) { const m = WOOD_BIT_RE.exec(String(b || '')); if (m) return barkIndexOf(m[1]); }\n  return null;\n}\n// A seedling's name with its bark, as the page shows a stack of it: \"Verge Round Seedling · Gloam bark\".\nexport const seedlingLabel = (name, k) => (barkNameOf(k) ? `${name} · ${barkNameOf(k)} bark` : name);\n\n// THE SEEDLINGS OF A WORLD'S OWN TREES, from its generator's organics (organics.mjs organicsOf: org, mat, names, orgSp):\n// what the Loamwrights give (alien-peoples.mjs requestsOf). Each once, in catalogue order.\nexport function worldSeedlingsOf(o) {\n  if (!o || !o.n || !o.orgSp) return [];\n  const byOrg = new Map();\n  for (let i = 0; i < o.n; i++) { const g = o.org[i]; let a = byOrg.get(g); if (!a) byOrg.set(g, a = []); a.push(o.names[o.mat[i]] + ' Bit'); }\n  const got = new Set();\n  for (const [g, names] of byOrg) { const sp = SPECIES[o.orgSp[g]]; const n = sp && treeSeedlingOf(sp.id, names); if (n) got.add(n); }\n  return SEEDLINGS.filter((sd) => got.has(sd.name)).map((sd) => sd.name);\n}\n\n// ITS ICON (the 'mini' look): a miniature of the tree it grows, in its own wood's and leaves' colours, as a list of cubes\n// [x, y, z, hex, glow] in the tree's own frame (y up), for the page's model icons (app.js hotbarDrawModel).\nexport function seedlingIconCubes(name) {\n  const sd = BY_NAME.get(name);\n  if (!sd) return [];\n  const raw = growOrganic(sd.form, 'seedling-icon#' + sd.form, 1), mats = seedlingMaterials(sd.form, sd.pigment), out = [];\n  for (let i = 0; i < raw.length; i += 4) { const m = organicMaterial(mats[raw[i + 3]] || ''); if (m) out.push([raw[i], raw[i + 1], raw[i + 2], m.hex, 0]); }\n  return out;\n}\n\n// ─────────────────────────────── THE TREE IT GROWS ───────────────────────────────\n// A cell as one number (life-seats.mjs cellKey's packing) and back.\nexport const seedCellKey = (x, y, z) => ((x + 256) * 512 + (y + 256)) * 512 + (z + 256);\nexport const seedCellXYZ = (k) => [Math.floor(k / 262144) - 256, Math.floor(k / 512) % 512 - 256, k % 512 - 256];\nconst slotOfHalf = (hx, hy, hz) => ((hx & 1) * 2 * 3 + (hy & 1) * 2) * 3 + (hz & 1) * 2;   // life-seats.mjs's lattice seat\n// THE PLAN of a seedling planted in cell (x, y, z) of world `addr` (radius R): the full tree, grown from the cell (the seed's\n// own grower, organics.mjs growOrganic, at its world's size) along the cell's up, and how it grows to it.\n//   bits: [{ cell: [x, y, z], slot, name (a bit), part, lvl, c: [cx, cy, cz] (its centre at full size) }], rooted, in\n//         the order they grew; foot: the trunk's foot on the ground (the point it is scaled about); up: { a, s };\n//   H: its height and half: its widest reach from the trunk, in kubes; s: the scale at each stage (STAGE_MINUTES);\n//   entry: Map cellKey → the first whole minute of growth its model stands in that cell.\n// `bark`: its wood's pigment (seedlingMaterials), or none for its leaves'; P.bark keeps it.\nconst _plans = new Map();\nexport function seedlingPlan(name, addr, x, y, z, R, bark = null) {\n  const sd = BY_NAME.get(name);\n  if (!sd) return null;\n  const key = name + '|' + addr + '|' + x + '.' + y + '.' + z + '|' + R + (bark ? '|' + bark : '');\n  let P = _plans.get(key);\n  if (P) return P;\n  const raw = growOrganic(sd.form, `${addr}#seedling#${x}.${y}.${z}`, sizeKOf(R)), mats = seedlingMaterials(sd.form, sd.pigment, bark);\n  const u = upOf(x, y, z), a = u.a, ta = (a + 1) % 3, tb = (a + 2) % 3, C = [x, y, z];\n  const base = u.s > 0 ? 2 * C[a] : 2 * C[a] + 1;\n  const foot = [0, 0, 0]; foot[a] = u.s > 0 ? C[a] : C[a] + 1; foot[ta] = C[ta] + 0.25; foot[tb] = C[tb] + 0.25;\n  const bits = [], seen = new Set();\n  let H = 0.5, half = 0.25;\n  for (let i = 0; i < raw.length; i += 4) {\n    const mat = mats[raw[i + 3]];\n    if (!mat) continue;\n    const hp = [0, 0, 0]; hp[a] = base + u.s * raw[i + 1]; hp[ta] = 2 * C[ta] + raw[i]; hp[tb] = 2 * C[tb] + raw[i + 2];\n    const cell = [Math.floor(hp[0] / 2), Math.floor(hp[1] / 2), Math.floor(hp[2] / 2)], slot = slotOfHalf(hp[0], hp[1], hp[2]);\n    const sk = seedCellKey(cell[0], cell[1], cell[2]) * 32 + slot;\n    if (seen.has(sk)) continue;\n    seen.add(sk);\n    const c = [hp[0] / 2 + 0.25, hp[1] / 2 + 0.25, hp[2] / 2 + 0.25];\n    bits.push({ cell, slot, name: mat + ' Bit', part: raw[i + 3], lvl: raw[i + 1], c });\n    H = Math.max(H, Math.abs(c[a] - foot[a]) + 0.25);\n    half = Math.max(half, Math.abs(c[ta] - foot[ta]) + 0.25, Math.abs(c[tb] - foot[tb]) + 0.25);\n  }\n  // THE FOUR STAGES' SIZES: a seedling that stands within 80% of its kube's width and 90% of its height; a shoot a kube\n  // tall; a young tree half its height; the tree. Never smaller than the stage before.\n  const s0 = Math.min(0.9 / H, 0.4 / half, 1), s1 = Math.min(1, Math.max(s0, 1 / H)), s2 = Math.min(1, Math.max(s1, 0.5));\n  P = { name, form: sd.form, pigment: sd.pigment, bark: bark || null, cell: C, up: u, face: u.a * 2 + (u.s > 0 ? 0 : 1), foot, bits, H, half, s: [s0, s1, s2, 1], entry: null };\n  const entry = new Map();\n  for (let m = 0; m <= GROW_MINUTES; m++) for (const k of cellsAt(P, m)) if (!entry.has(k)) entry.set(k, m);\n  P.entry = entry;\n  if (_plans.size > 512) _plans.clear();\n  _plans.set(key, P);\n  return P;\n}\n// THE SCALE at `m` minutes of growth (fractional): through the four stages' sizes, a straight run between each two, so it\n// never jumps and never stops while it grows.\nexport function scaleAt(P, m) {\n  const t = m <= 0 ? 0 : m >= GROW_MINUTES ? GROW_MINUTES : m;\n  for (let i = 0; i < 3; i++) if (t <= STAGE_MINUTES[i + 1]) {\n    const f = (t - STAGE_MINUTES[i]) / (STAGE_MINUTES[i + 1] - STAGE_MINUTES[i]);\n    return P.s[i] + (P.s[i + 1] - P.s[i]) * f;\n  }\n  return 1;\n}\n// The stage it is in: 0 seedling, 1 shoot, 2 young tree, 3 tree.\nexport const stageAt = (m) => (m >= GROW_MINUTES ? 3 : m >= STAGE_MINUTES[2] ? 2 : m >= STAGE_MINUTES[1] ? 1 : 0);\n// WHERE IT IS SCALED FROM: the trunk's foot, but a seedling stands in the middle of its kube, sliding to the trunk's place\n// as it grows to a shoot.\nexport function anchorAt(P, m) {\n  const s = scaleAt(P, m), [s0, s1] = P.s, a = P.up.a;\n  const blend = s1 > s0 ? Math.max(0, Math.min(1, (s - s0) / (s1 - s0))) : 1;\n  const out = P.foot.slice();\n  for (const t of [(a + 1) % 3, (a + 2) % 3]) out[t] += 0.25 * (1 - blend);\n  return out;\n}\n// THE MODEL at `m` minutes: each bit's box, its centre and its half-side, in grid coordinates. At full size, exactly the\n// tree's bits.\nexport function boxesAt(P, m) {\n  const s = scaleAt(P, m), A = anchorAt(P, m), F = P.foot, h = 0.25 * s, out = [];\n  for (const b of P.bits) out.push({ c: [A[0] + s * (b.c[0] - F[0]), A[1] + s * (b.c[1] - F[1]), A[2] + s * (b.c[2] - F[2])], h, bit: b });\n  return out;\n}\nconst EPS = 1e-7;\n// The cells the model at `m` (whole minutes) stands in.\nexport function cellsAt(P, m) {\n  const out = new Set();\n  for (const q of boxesAt(P, m)) {\n    const lo = q.c.map((v) => Math.floor(v - q.h + EPS)), hi = q.c.map((v) => Math.floor(v + q.h - EPS));\n    for (let x = lo[0]; x <= hi[0]; x++) for (let y = lo[1]; y <= hi[1]; y++) for (let z = lo[2]; z <= hi[2]; z++) out.add(seedCellKey(x, y, z));\n  }\n  return out;\n}\n\n// ─────────────────────────────── THE CLOCK ───────────────────────────────\n// ONE NUMBER: the minute it was settled (m0, whole), and in the fraction the light-minutes it had grown by then (g0, a\n// whole number to FELLED) and its bark (k, a place in BARK_ORDER, or none), as m0 + ½ + ((k + 1)·128 + g0) / 16384 (k + 1\n// = 0 for none): 39 bits, exact in a double. A stamp of before Oct 23 is m0 + g0/256, its fraction under a half (121/256\n// at most), so the half tells the two apart: an OLD stamp (`legacy`) counted real minutes, and keeps them (LIGHT_SINCE_MIN).\nconst STAMP_NEW = 16384;\nexport function seedStamp(m0, g0, k = null) {\n  const kk = Number.isInteger(k) && k >= 0 && k < BARK_ORDER.length ? k + 1 : 0;\n  return m0 + 0.5 + (kk * 128 + Math.max(0, Math.min(FELLED, Math.round(g0)))) / STAMP_NEW;\n}\n// { m0, g0 } and, when it says so, k (its bark) and legacy (a stamp of the old kind).\nexport function seedClock(t) {\n  if (!Number.isFinite(t)) return { m0: 0, g0: 0 };\n  const m0 = Math.floor(t), f = t - m0;\n  if (f < 0.5) return { m0, g0: Math.max(0, Math.min(FELLED, Math.round(f * STAMP_Q))), legacy: true };\n  const r = Math.round((f - 0.5) * STAMP_NEW), kk = Math.floor(r / 128), out = { m0, g0: Math.max(0, Math.min(FELLED, r % 128)) };\n  if (kk >= 1 && kk <= BARK_ORDER.length) out.k = kk - 1;\n  return out;\n}\n\n// ─────────────────────────────── THE LIGHT IT GROWS BY ───────────────────────────────\n// THE RATE, in light-minutes a minute, from a face's sun descriptor (energy.mjs): each lighting star's flux at the world\n// times its share of light on the face (daylightFrom: Lambert's cosine of its height, eased across the terminator band, so\n// twilight counts by its share: g_dusk), never above LIGHT_CAP (g_fast). No descriptor (no star: a rogue's world), none.\nexport const LIGHT_CAP = 2;\nconst growPrice = (f, s) => (f > 0 ? f * daylightFrom(s) * AIR_TRANSMISSION : 0);\nexport function growLightAt(desc, ms) {\n  if (!desc || typeof desc !== 'object') return 0;\n  const r = starlightSum(desc, ms, growPrice);\n  return r > LIGHT_CAP ? LIGHT_CAP : r;\n}\n// THE LIGHT RECEIVED OVER AN INTERVAL, walked minute by minute from its anchor (each minute priced at its middle, so any\n// two ends with the same anchor walk exactly the same steps: the grid starts at the anchor, never at a round number), for\n// at most LIGHT_MAX_STEPS (a week); past that the rest is credited at the average of what was walked: still exact on\n// every end, and a fixed price however long a world was left. A world's day is twenty minutes to an hour, so a minute\n// resolves a dawn; its year is days, so a week's average is a season's. Remembered per descriptor and anchor (by the\n// descriptor itself where the caller keeps it, as the page does, and else by its numbers), so a page asking every two\n// seconds, or a server on every write, walks each minute once.\nexport const LIGHT_STEP_MIN = 1, LIGHT_MAX_STEPS = 7 * 1440;\n// THE MINUTE THE LIGHT TOOK OVER (g_now, the owner's pick: \"seedlings already planted keep what they have grown, then\n// follow light from the deploy on\"): an old stamp's clock counts real minutes up to here, and light after it. It is the\n// minute version 23 was deployed (2026-10-23 18:00 UTC, set at the deploy).\nexport const LIGHT_SINCE_MIN = Math.floor(Date.UTC(2026, 9, 23, 18, 0, 0) / 60000);\nlet _walkByDesc = new WeakMap(), _walkByKey = new Map(), _walkSteps = 0;\nconst WALK_KEEP = 2000000;                                 // minutes remembered in all (16 MB) before the memory starts again\nfunction walkOf(desc, a) {\n  if (_walkSteps > WALK_KEEP) { _walkByDesc = new WeakMap(); _walkByKey = new Map(); _walkSteps = 0; }\n  let m = _walkByDesc.get(desc);\n  if (!m) {\n    const key = JSON.stringify(desc);\n    m = _walkByKey.get(key);\n    if (!m) { if (_walkByKey.size > 256) _walkByKey.clear(); m = new Map(); _walkByKey.set(key, m); }\n    _walkByDesc.set(desc, m);\n  }\n  let w = m.get(a);\n  if (!w) { if (m.size > 64) m.clear(); w = { cum: [0] }; m.set(a, w); }\n  return w;\n}\nexport function lightBetween(desc, a, T) {\n  if (!(T > a) || !desc || typeof desc !== 'object') return 0;\n  const w = walkOf(desc, a), span = T - a, whole = Math.floor(span / LIGHT_STEP_MIN), upto = Math.min(whole, LIGHT_MAX_STEPS), cum = w.cum;\n  for (let i = cum.length - 1; i < upto; i++) { cum.push(cum[i] + growLightAt(desc, (a + (i + 0.5) * LIGHT_STEP_MIN) * 60000) * LIGHT_STEP_MIN); _walkSteps++; }\n  if (whole >= LIGHT_MAX_STEPS) return cum[LIGHT_MAX_STEPS] + (cum[LIGHT_MAX_STEPS] / (LIGHT_MAX_STEPS * LIGHT_STEP_MIN)) * (span - LIGHT_MAX_STEPS * LIGHT_STEP_MIN);\n  const rest = span - whole * LIGHT_STEP_MIN;\n  return cum[whole] + (rest > 0 ? growLightAt(desc, (a + whole * LIGHT_STEP_MIN + rest / 2) * 60000) * rest : 0);\n}\n// THE LIGHT-MINUTES A CLOCK HAS RECEIVED from its minute to T, on its face. `sun` is the face's descriptor, null for no\n// star, or undefined where a caller says nothing of the sky (a model, a test of the shape): a full sun's minute a minute,\n// as the clock ran before Oct 23. An old stamp counts real minutes up to LIGHT_SINCE_MIN (g_now).\nexport function lightRun(clock, sun, T) {\n  const m0 = clock.m0;\n  if (!(T > m0)) return 0;\n  if (sun === undefined) return T - m0;\n  if (clock.legacy && m0 < LIGHT_SINCE_MIN) {\n    const real = Math.min(T, LIGHT_SINCE_MIN) - m0;\n    return real + (T > LIGHT_SINCE_MIN ? lightBetween(sun, LIGHT_SINCE_MIN, T) : 0);\n  }\n  return lightBetween(sun, m0, T);\n}\nconst sunOfEnv = (env, P) => (env && typeof env.sun === 'function' ? env.sun(P.face) : undefined);\n// ROOM: the last whole minute it may grow to before its model would stand in a cell something already holds (`blocked`).\nexport function roomCap(P, blocked) {\n  let first = GROW_MINUTES + 1;\n  for (const [k, m] of P.entry) if (m < first) { const c = seedCellXYZ(k); if (blocked(c[0], c[1], c[2])) first = m; }\n  return first > GROW_MINUTES ? GROW_MINUTES : Math.max(0, first - 1);\n}\n// SKY: nothing whole over it, along its up, to the grid's edge (`full`, `inside`), as turf's sky.\nexport function skyOpen(P, full, inside) {\n  const u = P.up, c = P.cell.slice();\n  for (let j = 1; j < 512; j++) { c[u.a] = P.cell[u.a] + u.s * j; if (!inside(c[0], c[1], c[2])) return true; if (full(c[0], c[1], c[2])) return false; }\n  return true;\n}\n// HOW FAR IT HAS GROWN at minute T (fractional or whole), from its clock { m0, g0 } and the world as it stands (`env`:\n// blocked, full, inside, and sun(face): its face's sun descriptor, lightRun). { grown (light-minutes), cap, sky, full,\n// paused: 'sky' | 'room' | null, stage, next: the minute its state next changes by itself (it reaches its room's end, or a\n// tree), or Infinity (never, as on a locked world's night side, or not within a week's walk) }.\nexport function growthOf(P, clock, env, T) {\n  if (clock.g0 >= GROW_MINUTES) return { grown: GROW_MINUTES, cap: GROW_MINUTES, sky: true, full: true, felled: clock.g0 > GROW_MINUTES, paused: null, stage: 3, next: Infinity };\n  const cap = roomCap(P, env.blocked), sky = skyOpen(P, env.full, env.inside), sun = sunOfEnv(env, P);\n  const run = sky ? lightRun(clock, sun, T) : 0, grown = sky ? Math.max(clock.g0, Math.min(clock.g0 + run, cap)) : clock.g0;\n  const full = grown >= GROW_MINUTES;\n  const paused = full ? null : !sky ? 'sky' : grown >= cap ? 'room' : null;\n  const out = { grown, cap, sky, full, paused, stage: stageAt(grown) };\n  // `next` is worked out only when asked (it may walk a week of sky): the first minute its light reaches what it needs.\n  let next;\n  Object.defineProperty(out, 'next', { enumerable: false, get() {\n    if (next !== undefined) return next;\n    next = Infinity;\n    if (!full && !paused) {\n      const need = Math.min(cap, GROW_MINUTES) - clock.g0, far = clock.m0 + LIGHT_MAX_STEPS * LIGHT_STEP_MIN;\n      if (lightRun(clock, sun, far) >= need) {\n        let lo = Math.max(clock.m0, T), hi = far;\n        for (let i = 0; i < 40 && hi - lo > 1 / 64; i++) { const mid = (lo + hi) / 2; if (lightRun(clock, sun, mid) >= need) hi = mid; else lo = mid; }\n        next = hi;\n      }\n    }\n    return next;\n  } });\n  return out;\n}\n\n// ─────────────────────────────── FERTILIZER ───────────────────────────────\n// FERTILIZER (the owner's Alien Animals items, Oct 29: Bone ground at a Workbench, \"call it fertilizer\"): used on a growing\n// seedling it HALVES WHAT IS LEFT TO ITS NEXT STAGE. A seedling grows by the light it receives (light-minutes, above), so what\n// is left is light, not time: its clock is settled at this minute with half of the light-minutes it still needed to reach its\n// next stage given at once, rounded to the whole light-minute its stamp keeps (never less than it has). Under a steady sun that\n// is exactly half the time; a dusk or a winter makes the rest slower, as it would have anyway. Refused, with why, for a tree,\n// for one that is not growing (no sky over it, or no room for its next size: it would not grow anyway), and on the very edge\n// of a tree (nothing whole to give). Never past the minute before a tree: the tree itself is written by the next server write\n// that finds it due, as every planted tree is. { g0, before, stage, next } (its new growth, what it had, the stage it is in and\n// the one it grows toward), or { why }.\nexport const FERTILIZER = 'Fertilizer';\nexport function fertilizeOf(P, clock, env, T) {\n  if (!P || !clock) return { why: 'No seedling grows there now.' };\n  if (clock.g0 >= GROW_MINUTES) return { why: 'That is a tree already: Fertilizer helps a seedling grow.' };\n  const g = growthOf(P, clock, env, T);\n  if (g.full) return { why: 'That is a tree already: Fertilizer helps a seedling grow.' };\n  if (g.paused === 'sky') return { why: 'It is not growing under cover: clear what is over it first.' };\n  if (g.paused === 'room') return { why: 'It has no room to grow: clear the space round it first.' };\n  const next = STAGE_MINUTES[g.stage + 1], half = g.grown + (next - g.grown) / 2;\n  const g0 = Math.min(GROW_MINUTES - 1, g.cap, Math.max(Math.ceil(g.grown), Math.round(half)));\n  if (!(g0 > g.grown)) return { why: 'It is about to become a tree anyway.' };\n  return { g0, before: g.grown, stage: g.stage, next: g.stage + 1 };\n}\n\n// ─────────────────────────────── WHERE IT MAY BE PLANTED ───────────────────────────────\n// Why a seedling cannot be planted in cell (x, y, z), or null. `env`: inside, full, blocked, liquid, kubeAt (the kube in a\n// full cell, by name), climate(x, y, z) → { chem, tempC }; `others`: the plans of the seedlings and planted trees already\n// on the world, whose room it may not share.\nexport function plantWhy(name, P, env, others = []) {\n  const sd = BY_NAME.get(name);\n  if (!sd || !P) return 'That is not a seedling.';\n  const [x, y, z] = P.cell, u = P.up, g = [x, y, z]; g[u.a] -= u.s;\n  if (!env.inside(x, y, z) || !env.inside(g[0], g[1], g[2])) return 'That is past the edge of the world.';\n  if (!env.full(g[0], g[1], g[2]) || !isRegolithName(env.kubeAt(g[0], g[1], g[2]))) return 'A seedling takes root only in soil: plant it on the top of regolith or turf.';\n  if (env.blocked(x, y, z)) return 'Something is already there.';\n  if (env.liquid && env.liquid(x, y, z)) return 'It would drown there.';\n  const cl = env.climate(x, y, z) || {}, chem = sd.chem, r = CHEM_RANGE_C[chem];\n  if (!cl.chem) return `Nothing grows on this world: a ${name} needs ${chem} life's air and ground.`;\n  if (cl.chem !== chem) return `A ${name} is ${chem} life, and this world's life is ${cl.chem}: it will not grow here.`;\n  if (!(cl.tempC >= r[0] && cl.tempC <= r[1])) return `Too ${cl.tempC > r[1] ? 'hot' : 'cold'} for a ${name} here (${Math.round(cl.tempC)} °C): ${chem} life grows from ${r[0]} to ${r[1]} °C.`;\n  for (const O of others) { if (!O || O === P) continue; for (const k of O.entry.keys()) if (P.entry.has(k)) return 'Too close to another tree: a seedling needs room to grow.'; }\n  // ROOM TO BECOME A TREE (the owner's play review, Oct 23, f3): a seedling whose grown model would meet leaves, ground or\n  // a build stops growing there for good (growthOf's 'room'), so it is refused at planting rather than left to stall.\n  if (roomCap(P, env.blocked) < GROW_MINUTES) return 'Not enough room to grow into a tree here: plant it in the open.';\n  return null;\n}\n\n// ─────────────────────────────── WALKING THROUGH IT ───────────────────────────────\n// THE EYE-LEVEL RULE (the owner, Oct 22: \"walkthrough unless there's a collision at eye level\"): a growing plant never\n// stops the body, but a part of it in the band round the walker's eyes does, so the camera never goes into its leaves.\n// Does any of `boxes` (boxesAt) meet the column of half-width `r` round `feet` along `up` (a unit axis vector) between\n// `lo` and `hi` kubes over the feet? The column is taken as its square across: a box test on all three axes.\nexport const EYE_BAND = Object.freeze({ below: 0.3, above: 0.3 });   // kubes either side of the eye\nexport function eyeLevelHit(boxes, feet, up, r, lo, hi) {\n  const a = Math.abs(up[0]) > 0.5 ? 0 : Math.abs(up[1]) > 0.5 ? 1 : 2, sg = up[a] >= 0 ? 1 : -1;\n  const mn = [feet[0] - r, feet[1] - r, feet[2] - r], mx = [feet[0] + r, feet[1] + r, feet[2] + r];\n  const e0 = feet[a] + sg * lo, e1 = feet[a] + sg * hi;\n  mn[a] = Math.min(e0, e1); mx[a] = Math.max(e0, e1);\n  for (const q of boxes) {\n    if (q.c[0] + q.h > mn[0] && q.c[0] - q.h < mx[0] && q.c[1] + q.h > mn[1] && q.c[1] - q.h < mx[1] && q.c[2] + q.h > mn[2] && q.c[2] - q.h < mx[2]) return true;\n  }\n  return false;\n}\n\n// ─────────────────────────────── A FELLED PLANTED TREE ───────────────────────────────\n// A full planted tree as a structure supportedOf reads (life-seats.mjs): its bits' cells and seats, and its foot.\nexport function plantedStructure(P) {\n  const n = P.bits.length, cell = new Int16Array(3 * n), slot = new Uint8Array(n), base = new Uint8Array(n);\n  let low = Infinity;\n  for (const b of P.bits) if (b.lvl < low) low = b.lvl;\n  P.bits.forEach((b, k) => { cell[3 * k] = b.cell[0]; cell[3 * k + 1] = b.cell[1]; cell[3 * k + 2] = b.cell[2]; slot[k] = b.slot; base[k] = b.lvl === low ? 1 : 0; });\n  return { cell, slot, base, orgStart: Int32Array.from([0, n]) };\n}\n// What still stands of it on its foot, given `present(k)`: a Set of its bits.\nexport const plantedStanding = (S, present) => supportedOf(S, 0, present);\n\n// ─────────────────────────────── THE SERVERS' SESSION ───────────────────────────────\n// One edit call's seedlings, for functions/index.js submitEdits and zone-server/lib/edits.js alike, so the two cannot\n// weigh a seedling differently. `ctx`:\n//   addr, R, HALF, VOX_CHUNK, now (the server minute);\n//   chunks: { id: { blocks, t } }, every chunk of the world's edits as the call sees them (the touched ones live, so each\n//     edit is seen by the next), or only the touched ones on a world too old to plant on (records: false);\n//   records: whether to read and settle seedlings (a world of SEEDLING_SINCE or later);\n//   full(x, y, z), inside(x, y, z), kubeAt(x, y, z), liquid(x, y, z): the world's ground (turf.mjs serverTurfView);\n//   natural(x, y, z) → a seeded rock's { slot } or null; life (life-seats.mjs) and lifeBlocks(w, lk, x, y, z): whether\n//     the seed's life stands in a cell; climate(x, y, z) → { chem, tempC };\n//   sun(face) → the sun descriptor of that face of the world (energy.mjs), or null for no star: what its seedlings grow by\n//     (the claim's record of them, functions/index.js claimFaceSun), the same numbers on both servers and the page;\n//   write(id, key, value) and stamp(id, key, t): what the call will write (its newBlocks and newTimes).\n// Call begin() before the edits, the hooks as they are applied, and finish() after them: it returns the seedlings to\n// credit for trees felled whole. A seedling given or taken is { n: its name, k: its bark (a place in BARK_ORDER) or null }:\n// a stack of that name with that bark (tool-tiers.mjs x.k), or a plain one.\nexport function seedlingSession(ctx) {\n  const { HALF, VOX_CHUNK, now, chunks } = ctx;\n  const loc = (x, y, z) => {\n    const ax = x + HALF, ay = y + HALF, az = z + HALF;\n    const cx = Math.floor(ax / VOX_CHUNK), cy = Math.floor(ay / VOX_CHUNK), cz = Math.floor(az / VOX_CHUNK);\n    const lx = ax - cx * VOX_CHUNK, ly = ay - cy * VOX_CHUNK, lz = az - cz * VOX_CHUNK;\n    return { id: cx + '_' + cy + '_' + cz, lk: lx + '_' + ly + '_' + lz, l: { lx, ly, lz } };\n  };\n  const NONE = {};\n  const blocksOf = (id) => (chunks[id] ? chunks[id].blocks : NONE);\n  const val = (x, y, z, slot) => { const p = loc(x, y, z); return blocksOf(p.id)[slot == null ? p.lk : p.lk + '_' + slot]; };\n  const inside = (x, y, z) => x >= -HALF && x < HALF && y >= -HALF && y < HALF && z >= -HALF && z < HALF;\n  const put = (id, key, v) => { if (!chunks[id]) chunks[id] = { blocks: {}, t: {} }; chunks[id].blocks[key] = v; ctx.write(id, key, v); };\n  const stampAt = (id, key, t) => { if (!chunks[id]) chunks[id] = { blocks: {}, t: {} }; if (!chunks[id].t) chunks[id].t = {}; chunks[id].t[key] = t; ctx.stamp(id, key, t); };\n  // A CELL SOMETHING HOLDS: ground, a kube, any bit or record of a bit placed there, a seeded rock, the seed's life.\n  const blocked = (x, y, z) => {\n    if (!inside(x, y, z) || ctx.full(x, y, z)) return true;\n    const p = loc(x, y, z), w = blocksOf(p.id);\n    if (typeof w[p.lk] === 'string') return true;\n    for (let s = 0; s < 27; s++) if (typeof w[p.lk + '_' + s] === 'string') return true;\n    const nat = ctx.natural ? ctx.natural(x, y, z) : null;\n    if (nat && w[p.lk + '_' + nat.slot] !== null) return true;\n    return !!(ctx.life && ctx.lifeBlocks(w, p.l, x, y, z));\n  };\n  const env = { blocked, full: (x, y, z) => inside(x, y, z) && ctx.full(x, y, z), inside, liquid: ctx.liquid || null,\n                kubeAt: ctx.kubeAt, climate: ctx.climate, ...(typeof ctx.sun === 'function' ? { sun: ctx.sun } : {}) };\n  const recs = [];                                        // { x, y, z, id, key, name, P, clock, pre, gone, fresh }\n  const at = new Map();                                   // plant cellKey → rec\n  const plantedSeat = new Map();                          // seatKey of a full planted tree's bit → [rec, k]\n  const seatKey = (x, y, z, slot) => seedCellKey(x, y, z) * 32 + slot;\n  const R = ctx.R, addr = ctx.addr;\n  const barkOfRec = (r) => (r.clock.k != null ? r.clock.k : null);\n  const give = (r) => ({ n: r.name, k: barkOfRec(r) });\n  const indexPlanted = (r) => {\n    r.S = plantedStructure(r.P);\n    r.P.bits.forEach((b, k) => plantedSeat.set(seatKey(b.cell[0], b.cell[1], b.cell[2], b.slot), [r, k]));\n  };\n  const addRec = (id, key, name, t) => {\n    const lk = key.split('_').map(Number), [cx, cy, cz] = id.split('_').map(Number);\n    const x = cx * VOX_CHUNK + lk[0] - HALF, y = cy * VOX_CHUNK + lk[1] - HALF, z = cz * VOX_CHUNK + lk[2] - HALF;\n    const clock = seedClock(t), P = seedlingPlan(name, addr, x, y, z, R, barkNameOf(clock.k));   // its bark rides in its stamp\n    if (!P) return null;\n    const r = { x, y, z, id, key, name, P, clock, pre: null, gone: false, fresh: false };\n    recs.push(r); at.set(seedCellKey(x, y, z), r);\n    return r;\n  };\n  const touched = new Map();                              // 'g' + structure | 'p' + cellKey → { kind, g | r, before }\n  const presentGen = (k) => { const L = ctx.life, x = L.cell[3 * k], y = L.cell[3 * k + 1], z = L.cell[3 * k + 2];\n    return val(x, y, z, L.slot[k]) === undefined && val(x, y, z, null) === undefined; };\n  const presentPlanted = (r) => (k) => { const b = r.P.bits[k]; return val(b.cell[0], b.cell[1], b.cell[2], b.slot) === b.name; };\n  const growingAt = (x, y, z) => { const r = at.get(seedCellKey(x, y, z)); return r && !r.gone && r.pre && !r.pre.full ? r : null; };\n  return {\n    env, records: recs,\n    begin() {\n      if (!ctx.records) return;\n      for (const id in chunks) { const w = chunks[id].blocks || NONE, t = chunks[id].t || NONE;\n        for (const key in w) { if (!key.endsWith('_' + SEEDLING_SEAT) || typeof w[key] !== 'string' || !BY_NAME.has(w[key])) continue;\n          if (key.split('_').length !== 4) continue;\n          addRec(id, key, w[key], t[key]); } }\n      recs.sort((a, b) => (a.id < b.id ? -1 : a.id > b.id ? 1 : a.key < b.key ? -1 : a.key > b.key ? 1 : 0));\n      // Each one as it stands before this call, at this minute; a tree that has come due is written into the world now.\n      for (const r of recs) {\n        r.pre = growthOf(r.P, r.clock, env, now);\n        if (r.pre.full && r.clock.g0 < GROW_MINUTES) {\n          for (const b of r.P.bits) { const p = loc(b.cell[0], b.cell[1], b.cell[2]), k = p.lk + '_' + b.slot;\n            if (!inside(b.cell[0], b.cell[1], b.cell[2]) || typeof blocksOf(p.id)[k] === 'string') continue;\n            put(p.id, k, b.name); }\n          r.clock = { m0: now, g0: GROW_MINUTES, ...(r.clock.k != null ? { k: r.clock.k } : {}) };\n          stampAt(r.id, r.key, seedStamp(now, GROW_MINUTES, barkOfRec(r)));\n        }\n        if (r.pre.full) indexPlanted(r);\n      }\n    },\n    // Is a cell where a growing plant already stands (nothing may be put there)?\n    protects(x, y, z) {\n      const k = seedCellKey(x, y, z);\n      for (const r of recs) { if (r.gone || !r.pre || r.pre.full) continue;\n        const m = r.P.entry.get(k); if (m != null && m <= Math.ceil(r.pre.grown)) return true; }\n      return false;\n    },\n    // A SEEDLING PICKED UP (a break at its seat): before it is a tree, at any stage, it comes back, with its bark. { n, k },\n    // or null.\n    pickUp(x, y, z, expect) {\n      const r = growingAt(x, y, z);\n      if (!r || (expect != null && expect !== r.name)) return null;\n      r.gone = true; put(r.id, r.key, null); stampAt(r.id, r.key, now);\n      return give(r);\n    },\n    // PLANTED: null when it is, else why not (nothing is written then). `bark`: the planted stack's (a place in\n    // BARK_ORDER), or null for a seedling with none, which grows the bark its world's starlight gives its form on this\n    // face (ctx.barkAt: organics.mjs barkOf, version 23) or, on an older world, its leaves' pigment.\n    plant(x, y, z, name, bark = null) {\n      if (!ctx.records) return 'Nothing can be planted on this world yet.';\n      const p = loc(x, y, z), key = p.lk + '_' + SEEDLING_SEAT;\n      const old = at.get(seedCellKey(x, y, z));\n      if (typeof blocksOf(p.id)[key] === 'string' && !(old && !old.gone && old.pre && old.pre.felled)) return 'Something is already planted there.';\n      const sd = BY_NAME.get(name);\n      if (!sd) return 'That is not a seedling.';\n      const own = sd.form !== 'thornShrub' && sd.form !== 'treeCloud';   // (those two grow the wood their kind always has)\n      const u = upOf(x, y, z), face = u.a * 2 + (u.s > 0 ? 0 : 1);\n      let k = own && barkNameOf(bark) ? bark : null;\n      if (k == null && own && ctx.barkAt) k = barkIndexOf(ctx.barkAt(sd.form, face));\n      const P = seedlingPlan(name, addr, x, y, z, R, barkNameOf(k));\n      const why = plantWhy(name, P, env, recs.filter((r) => !r.gone && r !== old && !(r.pre && r.pre.felled)).map((r) => r.P));\n      if (why) return why;\n      if (old) { old.gone = true; for (const [k2, v] of plantedSeat) if (v[0] === old) plantedSeat.delete(k2); }   // a felled tree's remains are its no more\n      put(p.id, key, name); stampAt(p.id, key, seedStamp(now, 0, k));\n      const r = addRec(p.id, key, name, seedStamp(now, 0, k));\n      r.fresh = true; r.pre = growthOf(P, r.clock, env, now);\n      return null;\n    },\n    // FERTILIZED (fertilizeOf, Oct 29): null when it took, else why not (nothing is written then). `name` is the seedling the\n    // player aimed at, which must still be the one growing there. Its clock is settled at this minute with what the Fertilizer\n    // gave, and its record written again with it, so the chunk (and its new stamp) goes out to every page.\n    fertilize(x, y, z, name) {\n      if (!ctx.records) return 'Nothing grows on this world yet.';\n      const r = at.get(seedCellKey(x, y, z));\n      if (!r || r.gone || !r.pre || (name != null && name !== r.name)) return 'No seedling grows there now.';\n      if (r.pre.felled) return 'That tree has been felled.';\n      const f = fertilizeOf(r.P, r.clock, env, now);\n      if (f.why) return f.why;\n      r.clock = { m0: now, g0: f.g0, ...(r.clock.k != null ? { k: r.clock.k } : {}) };\n      put(r.id, r.key, r.name); stampAt(r.id, r.key, seedStamp(now, f.g0, barkOfRec(r)));\n      r.pre = growthOf(r.P, r.clock, env, now); r.fresh = true;   // settled here: finish() leaves it as it is\n      return null;\n    },\n    // BEFORE A BREAK at (x, y, z) (a seat, or the whole cell for null): the trees it touches, as they stood.\n    beforeBreak(x, y, z, slot) {\n      const L = ctx.life;\n      if (L && L.sp && L.cells) for (const i of L.cells.get(seedCellKey(x, y, z)) || []) {\n        if (slot != null && L.slot[i] !== slot) continue;\n        const g = L.org[i], tk = 'g' + g;\n        if (touched.has(tk) || !isTreeSpecies((SPECIES[L.sp[g]] || {}).id)) continue;\n        touched.set(tk, { kind: 'gen', g, before: supportedOf(L, g, presentGen).size > 0 });\n      }\n      for (let s = 0; s < 27; s++) {\n        if (slot != null && s !== slot) continue;\n        const hit = plantedSeat.get(seatKey(x, y, z, s));\n        if (!hit) continue;\n        const [r] = hit, tk = 'p' + seedCellKey(r.x, r.y, r.z);\n        if (touched.has(tk) || r.gone || r.pre.felled) continue;   // felled already: what is left of it drops nothing\n        touched.set(tk, { kind: 'planted', r, before: plantedStanding(r.S, presentPlanted(r)).size > 0 });\n      }\n    },\n    // A PLACED BIT OF A PLANTED TREE that no longer stands on its foot falls (credited, free), as the seed's do.\n    plantedFallen(x, y, z, slot) {\n      const hit = plantedSeat.get(seatKey(x, y, z, slot));\n      if (!hit) return false;\n      const [r, k] = hit, b = r.P.bits[k];\n      if (val(x, y, z, slot) !== b.name || r.S.base[k]) return false;\n      return !plantedStanding(r.S, presentPlanted(r)).has(k);\n    },\n    // THE GROUND UNDER A GROWING SEEDLING BROKEN: it comes off with it, back to whoever broke it. { n, k }, or null.\n    groundBroken(x, y, z) {\n      const u = upOf(x, y, z), c = [x, y, z]; c[u.a] += u.s;\n      const r = growingAt(c[0], c[1], c[2]);\n      if (!r) return null;\n      r.gone = true; put(r.id, r.key, null); stampAt(r.id, r.key, now);\n      return give(r);\n    },\n    // AFTER THE EDITS: the seedlings to credit for trees felled whole ({ n, k }: each with its parent's bark), and each\n    // growing seedling's clock settled afresh where this call changed the room it may grow into or its sky.\n    finish() {\n      const drops = [];\n      for (const T of touched.values()) {\n        if (!T.before) continue;\n        if (T.kind === 'gen') {\n          const L = ctx.life;\n          if (supportedOf(L, T.g, presentGen).size) continue;\n          const names = []; for (let k = L.orgStart[T.g]; k < L.orgStart[T.g + 1]; k++) names.push(L.bits[L.bit[k]]);\n          const id = SPECIES[L.sp[T.g]].id, n = treeSeedlingOf(id, names);\n          if (n) drops.push({ n, k: treeBarkOf(id, names) });\n        } else {\n          const r = T.r;\n          if (r.gone || plantedStanding(r.S, presentPlanted(r)).size) continue;\n          drops.push(give(r));\n          r.pre = { ...r.pre, felled: true }; r.clock = { ...r.clock, m0: now, g0: FELLED }; stampAt(r.id, r.key, seedStamp(now, FELLED, barkOfRec(r)));   // felled whole (see FELLED)\n        }\n      }\n      for (const r of recs) {\n        if (r.gone || r.fresh || !r.pre || r.pre.full) continue;\n        const cap = roomCap(r.P, blocked), sky = skyOpen(r.P, env.full, inside);\n        if (cap === r.pre.cap && sky === r.pre.sky) continue;\n        const g = Math.round(r.pre.grown);\n        r.clock = { m0: now, g0: g, ...(r.clock.k != null ? { k: r.clock.k } : {}) }; stampAt(r.id, r.key, seedStamp(now, g, barkOfRec(r)));\n      }\n      return { drops };\n    },\n  };\n}\n"],"mappings":"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","names":["r"],"file":"seedlings.mjs"}