@adatechnology/game-stories 0.2.7 → 0.3.0

package/dist/chunk-27E2JRXQ.js

@@ -0,0 +1,1563 @@
+// src/bench/module.ts
+import { getProfession, getNamePools as getNamePools2, SHEET_RULESET as SHEET_RULESET3 } from "@adatechnology/game-characters-people";
+
+// src/sheet/sheet.ts
+import { SHEET_RULESET } from "@adatechnology/game-characters-people";
+
+// src/data/sheet.json
+var sheet_default = {
+  sources: {
+    page: 'site/pages/zumbis-personagens/personagens.html, "Mem\xF3ria e opini\xE3o" and "Modelo de dados"',
+    memories: '"Cada NPC guarda at\xE9 30 lembran\xE7as com peso e data"; memorias: [{ evento, alvoId, peso, dia }] // m\xE1x 30',
+    opinion: '"A opini\xE3o sobre cada jogador vai de \u2212100 a +100 e decai devagar para o neutro. Em +60 o NPC aceita entrar no grupo; abaixo de \u221260 pode roubar, delatar a base a outro grupo ou atacar \xE0 noite."',
+    decayPerDay: `not in the document ("decai devagar"): 1 point a day is the kit's reversible default, listed as a question`,
+    memoryDrop: "not in the document: past 30, the lightest memory goes (the oldest first on a tie), listed as a question"
+  },
+  memories: { max: 30 },
+  opinion: { min: -100, max: 100, joins: 60, hostile: -60, decayPerDay: 1 }
+};
+
+// src/sheet/sheet.ts
+function createSheet(options = {}) {
+  const rules = options.ruleset ?? SHEET_RULESET;
+  const N = { ...sheet_default, ...options.numbers };
+  const professionId = options.profession ?? rules.professions[rules.professions.length - 1].id;
+  const profession = rules.professions.find((p) => p.id === professionId);
+  if (!profession) throw new Error(`game-stories: unknown profession "${professionId}"`);
+  const attributes = Object.fromEntries(rules.attributes.map((a) => [a.id, options.attributes?.[a.id] ?? rules.pointBuy.start]));
+  const traits = [...options.traits ?? []];
+  for (const id of traits) if (!rules.traits.some((t) => t.id === id)) throw new Error(`game-stories: unknown trait "${id}"`);
+  const skills = { ...profession.skills };
+  for (const [id, level] of Object.entries(options.skills ?? {})) skills[id] = (skills[id] ?? 0) + level;
+  const memories = [];
+  const opinions = {};
+  const history = [];
+  const has = (id) => traits.includes(id);
+  const traitPoints = () => traits.reduce((sum, id) => sum + rules.traits.find((t) => t.id === id).cost, 0);
+  const spent = () => Object.values(attributes).reduce((sum, v) => sum + (v - rules.pointBuy.start), 0);
+  const clampOpinion = (v) => Math.max(N.opinion.min, Math.min(N.opinion.max, v));
+  return {
+    profession: professionId,
+    attributes,
+    traits,
+    skills,
+    milestones: (skill) => rules.milestoneLevels.map((level, index) => (skills[skill] ?? 0) >= level ? index : -1).filter((index) => index >= 0),
+    pool: () => rules.pointBuy.pool + profession.points + traitPoints() - spent(),
+    valid() {
+      const inRange = Object.values(attributes).every((v) => v >= rules.pointBuy.min && v <= rules.pointBuy.max);
+      const excluded = traits.some((id) => rules.traits.find((t) => t.id === id).excludes.some(has));
+      return inRange && !excluded && this.pool() >= 0;
+    },
+    derived() {
+      const out = {};
+      for (const rule of rules.derived) {
+        let value = rule.base;
+        for (const [attribute, factor] of Object.entries(rule.per)) value += factor * attributes[attribute];
+        for (const t of rule.traits) if (has(t.trait) && t.add !== void 0) value += t.add;
+        for (const t of rule.traits) if (has(t.trait) && t.mul !== void 0) value *= t.mul;
+        out[rule.id] = rule.scale === void 0 ? value : value * rule.scale;
+      }
+      return out;
+    },
+    personality: options.personality ?? [50, 50, 50, 50, 50],
+    memories,
+    opinions,
+    history,
+    record(entry) {
+      history.push(entry);
+      if (entry.weight === void 0) return;
+      memories.push({ id: entry.id, weight: entry.weight, day: entry.day, ...entry.about ? { about: entry.about } : {} });
+      while (memories.length > N.memories.max) {
+        let drop = 0;
+        for (let i = 1; i < memories.length; i++) if (Math.abs(memories[i].weight) < Math.abs(memories[drop].weight)) drop = i;
+        memories.splice(drop, 1);
+      }
+    },
+    remembers: (id) => history.some((entry) => entry.id === id),
+    opine: (about, delta) => opinions[about] = clampOpinion((opinions[about] ?? 0) + delta),
+    decay(days) {
+      for (const [about, value] of Object.entries(opinions)) {
+        const step = N.opinion.decayPerDay * days;
+        opinions[about] = value > 0 ? Math.max(0, value - step) : Math.min(0, value + step);
+      }
+    },
+    stance(about) {
+      const value = opinions[about] ?? 0;
+      return value >= N.opinion.joins ? "joins" : value < N.opinion.hostile ? "hostile" : "neutral";
+    }
+  };
+}
+function drawSheet(random, input = {}) {
+  const rules = input.ruleset ?? SHEET_RULESET;
+  const profession = input.profession && rules.professions.some((p) => p.id === input.profession) ? input.profession : rules.professions[Math.floor(random() * rules.professions.length)].id;
+  const sheet = createSheet({ ...input, profession });
+  const attributes = sheet.attributes;
+  let left = sheet.pool();
+  while (left > 0) {
+    const open = rules.attributes.filter((a) => attributes[a.id] < rules.pointBuy.max);
+    if (open.length === 0) break;
+    attributes[open[Math.floor(random() * open.length)].id] += 1;
+    left -= 1;
+  }
+  return sheet;
+}
+
+// src/world.ts
+import { createRng } from "@adatechnology/game-characters";
+import { getNamePools, SHEET_RULESET as SHEET_RULESET2 } from "@adatechnology/game-characters-people";
+
+// src/data/life.json
+var life_default = {
+  sources: {
+    file: "specs/001-migracao-entregas-dos-times/sources/sobreviventes__os-vivos-do-vale.js (site/pages/sobreviventes/os-vivos-do-vale.html)",
+    states: "LIVE (line 368) for living; life() alive (line 628) for active",
+    affinity: "life() aff, line 634: fam 80, ali 60, odio -60, seg 10, medo -20; unknown pairs 10 + ((empathy a + empathy b)/2 - 50)/5",
+    clocks: "life() step 1, lines 643-656: heal in 3 + floor(R\xB78) days, a bite turns in 2, the missing come back in 2 + floor(R\xB75) days with chance 0.6; birth with a midwife 3% mother / 5% baby, without 15% / 20%",
+    risk: "life() step 2, lines 660-668: base risk by place (REG, default 0.006), exposure by person (EXPO, default 0.3; newcomers 0.05 under 12, else 0.35), \xD7(1 - defence), \xD71.5 under 2 days of food, \xD72 hurt; draw < 0.5 hurt, < 0.8 bitten, < 0.95 dead, else missing",
+    bonds: "life() step 3, lines 671-692: from 16 years; drift ((empathy a + empathy c)/2 - 50)/120 + (food < 5 ? -(greed a + greed c)/250 : 0.1) + (R - 0.5)\xB73; quiet 2 days after news; couple from 18, at most 15 years apart, affinity 65, chance 3%, then 90; pregnancy with 8 days of food, mother up to 42, 2%, due in 45 days, no story beat in 20 days; adoption 1%; rivalry at -50; fight at -70 with courage 60, 20%, affinity -40, < 0.6 hurt (heal 3 + floor(R\xB75)), < 0.7 dead, else the less loyal leaves",
+    betrayal: "life() lines 694-697: loyalty < 35, greed > 60, food < 5, 3%; takes 4 days of food; affinity -40 with everyone of the base",
+    food: "life() step 4, line 701: each day -0.11 (by option per base), between 0 and 60",
+    caravan: "lines 703-708: a base under 5 days of food, a host base over 12, someone there with affinity 55, 12%; 5 days of food, affinity +10; 8% the carrier is hurt (heal in 4)",
+    raid: "lines 709-718: 3% a day, not within 10 days of the last, targets with 3 days of food, the weakest defence first with \xB10.15 of noise; up to 5 days of food; a hero with courage 70 and affinity 60 arrives with chance 50%; else 25% dead; heal in 5; affinity +20",
+    arrivals: "step 5, lines 721-737: every 5 days, chance 0.5 (0.25 after day 60) of 1 + (30% 1 more); population cap 104 (CAP), 8 per base (ROOM); first names unique up to 30; age 18 + floor(R\xB742); personality 20 + R\xB770 (greed 10 + R\xB770); the bond from 16 years; affinity 75; 20% a partner (age max(18, age + floor(R\xB79) - 4)), 35% pregnant if up to 42, due in 10 + floor(R\xB730)",
+    fill: "simulate() O.fill, lines 746-749: up to 8 per base, age 18 + floor(R\xB740), personality 20 + R\xB770",
+    infection: "the bitten band and the turn are the apocalypse layer: off by default (normal world first), the bitten band then hurts"
+  },
+  unknownAge: 8,
+  livingStates: ["ok", "hurt", "party", "hostile", "moved"],
+  activeStates: ["ok", "hurt", "moved", "hostile"],
+  affinity: { family: 80, trust: 60, hatred: -60, secret: 10, fear: -20 },
+  rivalKind: "hatred",
+  unknownAffinity: { base: 10, divisor: 5 },
+  clocks: { healBase: 3, healSpread: 8, turnDays: 2, backBase: 2, backSpread: 5, backChance: 0.6 },
+  birth: { motherWithMidwife: 0.03, motherAlone: 0.15, babyWithMidwife: 0.05, babyAlone: 0.2, girl: 0.5 },
+  risk: {
+    defaultPlace: 6e-3,
+    defaultExposure: 0.3,
+    newcomerChild: 0.05,
+    newcomerAdult: 0.35,
+    childAge: 12,
+    hungryBelow: 2,
+    hungry: 1.5,
+    hurt: 2,
+    bands: { hurt: 0.5, bitten: 0.8, dead: 0.95 }
+  },
+  bonds: {
+    minAge: 16,
+    quietDays: 2,
+    driftEmpathy: 120,
+    lowFood: 5,
+    driftGreed: 250,
+    driftFed: 0.1,
+    driftNoise: 3,
+    coupleAge: 18,
+    coupleGap: 15,
+    coupleAffinity: 65,
+    coupleChance: 0.03,
+    coupledAffinity: 90,
+    pregnancyFood: 8,
+    pregnancyAge: 42,
+    pregnancyChance: 0.02,
+    pregnancyDays: 45,
+    pregnancyStoryWindow: 20,
+    adoptionChance: 0.01,
+    rivalryAt: -50,
+    fightAt: -70,
+    fightCourage: 60,
+    fightChance: 0.2,
+    afterFight: -40,
+    fightHurt: 0.6,
+    fightDead: 0.7,
+    fightHealSpread: 5
+  },
+  betrayal: { loyaltyBelow: 35, greedAbove: 60, foodBelow: 5, chance: 0.03, takes: 4, affinity: -40 },
+  food: { drift: -0.11, max: 60 },
+  caravan: { below: 5, hostAbove: 12, affinity: 55, chance: 0.12, carries: 5, bond: 10, hurtChance: 0.08, healDays: 4 },
+  raid: { chance: 0.03, cooldown: 10, targetFood: 3, noise: 0.3, loot: 5, heroCourage: 70, heroAffinity: 60, heroChance: 0.5, deadChance: 0.25, healDays: 5, heroBond: 20 },
+  arrivals: {
+    every: 5,
+    chance: 0.5,
+    lateChance: 0.25,
+    lateAfter: 60,
+    secondChance: 0.3,
+    cap: 104,
+    room: 8,
+    uniqueNames: 30,
+    ageBase: 18,
+    ageSpread: 42,
+    bondAge: 16,
+    bondAffinity: 75,
+    pairChance: 0.2,
+    pairAgeSpread: 9,
+    pairAgeShift: 4,
+    pregnantChance: 0.35,
+    pregnantDueBase: 10,
+    pregnantDueSpread: 30
+  },
+  fill: { perBase: 8, ageBase: 18, ageSpread: 40 },
+  personality: { base: 20, spread: 70, greedBase: 10 },
+  infection: false
+};
+
+// src/casting.ts
+var fits = (person, role) => {
+  const needs = role.needs;
+  if (!needs) return true;
+  if (needs.sex && Boolean(person.female) !== (needs.sex === "f")) return false;
+  if (needs.age && (person.age === void 0 || person.age < needs.age[0] || person.age > needs.age[1])) return false;
+  if (needs.profession && (!person.profession || !needs.profession.includes(person.profession))) return false;
+  if (needs.base && person.base !== needs.base) return false;
+  if (needs.tags && !needs.tags.every((tag) => person.tags?.includes(tag))) return false;
+  return true;
+};
+function castStories(options) {
+  const R = options.random;
+  const pick = (list) => list[Math.floor(R() * list.length)];
+  const people = [...options.people ?? []];
+  const byId = new Map(people.map((person) => [person.id, person]));
+  const roles = {};
+  const made = /* @__PURE__ */ new Map();
+  const taken = /* @__PURE__ */ new Set();
+  const Q = life_default.personality;
+  const A = life_default.arrivals;
+  for (const story of options.stories) {
+    for (const role of story.roles) {
+      if (roles[role.id]) continue;
+      if (role.person) {
+        if (!byId.has(role.person)) throw new Error(`game-stories: role "${role.id}" of "${story.id}" names "${role.person}", who is not among the people`);
+        roles[role.id] = role.person;
+        taken.add(role.person);
+        continue;
+      }
+      const candidates = role.create ? [] : people.filter((person2) => !taken.has(person2.id) && !person2.extra && fits(person2, role));
+      if (candidates.length > 0) {
+        const chosen = pick(candidates);
+        roles[role.id] = chosen.id;
+        taken.add(chosen.id);
+        continue;
+      }
+      const bond = role.bond ? byId.get(roles[role.bond.role] ?? "") : void 0;
+      const female = role.needs?.sex ? role.needs.sex === "f" : R() < 0.5;
+      const first = pick(female ? options.names.female : options.names.male);
+      const surname = role.bond?.sameSurname && bond ? bond.name.split(" ").filter((x) => !/[“”]/.test(x)).slice(-1)[0] : pick(options.names.surnames);
+      const range = role.needs?.age;
+      const age = range ? range[0] + Math.floor(R() * (range[1] - range[0] + 1)) : A.ageBase + Math.floor(R() * A.ageSpread);
+      const base = role.needs?.base ?? (role.bond?.sameBase !== false && bond ? bond.base : options.defaultBase ?? people[0]?.base ?? "nomad");
+      const personality = [Q.base + R() * Q.spread, Q.base + R() * Q.spread, Q.base + R() * Q.spread, Q.greedBase + R() * Q.spread, Q.base + R() * Q.spread].map(Math.round);
+      const person = {
+        id: role.id,
+        name: `${first} ${surname}`,
+        age,
+        female,
+        base,
+        personality,
+        role: role.id,
+        generated: true,
+        ...role.needs?.profession?.length ? { profession: pick(role.needs.profession) } : {},
+        ...role.tags ? { tags: role.tags } : {},
+        ...bond ? { bond: bond.id } : {},
+        ...role.bond?.relation ? { relation: role.bond.relation } : {}
+      };
+      if (byId.has(person.id)) throw new Error(`game-stories: role "${role.id}" would make a person with the id of someone given`);
+      people.push(person);
+      byId.set(person.id, person);
+      roles[role.id] = person.id;
+      taken.add(person.id);
+      made.set(person.id, role.id);
+    }
+  }
+  const firstRole = /* @__PURE__ */ new Map();
+  for (const [role, id] of Object.entries(roles)) if (!firstRole.has(id)) firstRole.set(id, role);
+  return { roles, people, roleOf: (id) => made.get(id) ?? firstRole.get(id) };
+}
+
+// src/chronicle.ts
+function createChronicle() {
+  const entries = [];
+  const listeners = /* @__PURE__ */ new Set();
+  return {
+    entries,
+    add(entry) {
+      entries.push(entry);
+      for (const listener of listeners) listener(entry);
+    },
+    onDay: (day) => entries.filter((entry) => entry.day === day),
+    about: (id) => entries.filter((entry) => entry.people.includes(id) || entry.changes.some((change) => change.id === id)),
+    until: (day) => entries.filter((entry) => entry.day <= day),
+    on(listener) {
+      listeners.add(listener);
+      return () => void listeners.delete(listener);
+    }
+  };
+}
+
+// src/data/life-text.json
+var life_text_default = {
+  sources: {
+    file: "specs/001-migracao-entregas-dos-times/sources/sobreviventes__os-vivos-do-vale.js (site/pages/sobreviventes/os-vivos-do-vale.html), life(), lines 619-739",
+    "pt-BR": "the team's texts, verbatim; {name}, {a}, {b}... are the people's short names (NICK, short), {o} the gender ending (o(id))",
+    en: "translation of the pt-BR texts"
+  },
+  "pt-BR": {
+    titles: {
+      turn: "Reanima",
+      back: "Volta",
+      lost: "Sem volta",
+      birth: "Nascimento",
+      risk: "Risco",
+      bond: "La\xE7o",
+      pregnancy: "Gravidez",
+      adoption: "Ado\xE7\xE3o",
+      rivalry: "Rixa",
+      fight: "Briga",
+      betrayal: "Trai\xE7\xE3o",
+      caravan: "Entre bases",
+      raid: "Ataque",
+      arrival: "Chegada"
+    },
+    notes: {
+      healed: "curado",
+      undead_street: "zumbi nomeado na rua",
+      undead_near: "zumbi nomeado perto de {place}",
+      came_back: "voltou depois de sumir",
+      came_back_short: "voltou",
+      never_back: "nunca voltou",
+      newborn: "rec\xE9m-nascido",
+      childbirth: "no parto",
+      hurt_out: "ferido fora da base",
+      bitten_out: "mordido fora da base",
+      hides_bite: "esconde a mordida",
+      dead_out: "morto fora da base",
+      did_not_return: "n\xE3o voltou",
+      missing_out: "sumiu numa sa\xEDda",
+      missing_short: "sumiu",
+      fight_with: "briga com {other}",
+      fight: "briga",
+      dead_fight: "morto numa briga com {other}",
+      left_after_fight: "foi embora depois da briga",
+      betrayed: "roubou {from} e foi para {to}",
+      betrayed_short: "traiu a base",
+      hurt_caravan: "ferido na caravana",
+      caravan: "caravana",
+      hurt_raid: "ferido no ataque",
+      dead_raid: "morto no ataque de {from}",
+      raid: "ataque",
+      arrived: "chegou{origin}",
+      pair_of: "par de {first}"
+    },
+    lines: {
+      loses: " {partner} perde {name}.",
+      turn: "{name} reanima e passa a vagar pela rotina antiga.",
+      back: "{name} aparece no port\xE3o, magro e sem as botas, depois de dias sumido.",
+      lost: "Acham as coisas de {name} numa vala da estrada.{loss}",
+      birth: "{name} d\xE1 \xE0 luz em {place}{help}.",
+      birth_help: " com ajuda de quem sabe",
+      birth_alone: ", sem ningu\xE9m que saiba fazer parto",
+      baby_dies: " O beb\xEA n\xE3o respira. Enterram ao lado da base.",
+      baby_born: " Nasce {baby}.",
+      mother_dies: "{loss} {name} n\xE3o resiste ao parto.",
+      risk_hurt: "{name} volta ferid{o} de uma sa\xEDda perto de {place}.",
+      risk_bitten: "{name} volta com uma mordida no antebra\xE7o e n\xE3o conta a ningu\xE9m.",
+      risk_dead: "{name} n\xE3o volta de uma sa\xEDda perto de {place}.{loss}",
+      risk_missing: "{name} some numa sa\xEDda perto de {place}.",
+      couple: "{a} e {b} {line}.",
+      pregnancy: "{a} e {b} v\xE3o ter um beb\xEA. Nasce em uns {days} dias de jogo.",
+      adoption: "{a} e {b} adotam {child}.",
+      rivalry: "{a} e {b} {line}. Viraram rivais.",
+      fight_hurt: "A rixa explode: {winner} quebra o nariz de {loser} no p\xE1tio.",
+      fight_dead: "A rixa termina com faca: {loser} morre e {winner} carrega a morte para o resto da vida.{loss}",
+      fight_leaves: "{name} junta as coisas e vai para {to} depois da briga com {other}.",
+      betrayal: "{name} some de madrugada com a comida da despensa e o r\xE1dio de {from}. Dias depois \xE9 visto em {to}.",
+      caravan: "Caravana: {carrier} atravessa a cidade com comida de {from} para {to}, onde mora {host}.",
+      caravan_hurt: " Na volta, {carrier} \xE9 atacad{o} na avenida e chega ferid{o}.",
+      raid: "{who} atacam {target} de madrugada e levam {loot} dias de comida.",
+      raid_hero: " {hero}, de {heroBase}, ouve os tiros e chega a tempo: {victim} sai s\xF3 ferid{o}.",
+      raid_dead: "{loss} {victim} morre na porta.",
+      raid_grazed: " {victim} leva um tiro de rasp\xE3o.",
+      arrival: "{first}, {relation} de {bond}, chega{origin}{note}.",
+      arrival_gone: " Vinha procurando {bond} e descobre que {bond} {fate}. Fica em {base}.",
+      arrival_party: " Pergunta por {bond} e descobre que est\xE1 com o jogador. Fica em {base} esperando.",
+      arrival_found: " Encontra {bond} em {base} e fica.",
+      arrival_elsewhere: " Descobre que {bond} est\xE1 em {where} e prefere ficar em {base}.",
+      arrival_pair_pregnant: " Vem com {pair}, e {mother} est\xE1 gr\xE1vida.",
+      arrival_pair: " Vem com {pair}."
+    },
+    pools: {
+      couple: ["come\xE7am a dividir o turno de vigia, e depois o colch\xE3o", "se beijam no telhado durante a r\xE1dio das 20h", "assumem o namoro na frente da base inteira"],
+      rivalry: ["brigam pela \xFAltima lata de sardinha", "discutem aos gritos sobre quem dorme perto da porta", "se acusam de roubar ra\xE7\xE3o"]
+    },
+    fates: { dead: "morreu", undead: "virou um dos mortos", left: "saiu do vale no \xF4nibus", missing: "sumiu", bitten: "foi mordido", other: "n\xE3o est\xE1 mais aqui" },
+    places: { where_died: "onde morreu", road: "a estrada", open_field: "campo aberto", nowhere: "lugar nenhum" },
+    gender: { female: "a", male: "o" },
+    honorifics: ["Dona", "Seu", "Dr.", "Tenente", "Sargento", "Soldado", "Pastora", "Cabo", "Capit\xE3o", "Major"]
+  },
+  en: {
+    titles: {
+      turn: "Turns",
+      back: "Back",
+      lost: "Never back",
+      birth: "Birth",
+      risk: "Risk",
+      bond: "Bond",
+      pregnancy: "Pregnancy",
+      adoption: "Adoption",
+      rivalry: "Rivalry",
+      fight: "Fight",
+      betrayal: "Betrayal",
+      caravan: "Between bases",
+      raid: "Raid",
+      arrival: "Arrival"
+    },
+    notes: {
+      healed: "healed",
+      undead_street: "named undead in the street",
+      undead_near: "named undead near {place}",
+      came_back: "came back after going missing",
+      came_back_short: "came back",
+      never_back: "never came back",
+      newborn: "newborn",
+      childbirth: "in childbirth",
+      hurt_out: "hurt outside the base",
+      bitten_out: "bitten outside the base",
+      hides_bite: "hides the bite",
+      dead_out: "dead outside the base",
+      did_not_return: "did not return",
+      missing_out: "went missing on a run",
+      missing_short: "missing",
+      fight_with: "fight with {other}",
+      fight: "fight",
+      dead_fight: "killed in a fight with {other}",
+      left_after_fight: "left after the fight",
+      betrayed: "robbed {from} and went to {to}",
+      betrayed_short: "betrayed the base",
+      hurt_caravan: "hurt on the caravan",
+      caravan: "caravan",
+      hurt_raid: "hurt in the raid",
+      dead_raid: "killed in the raid of {from}",
+      raid: "raid",
+      arrived: "arrived{origin}",
+      pair_of: "partner of {first}"
+    },
+    lines: {
+      loses: " {partner} loses {name}.",
+      turn: "{name} comes back and wanders the old routine.",
+      back: "{name} shows up at the gate, thin and without boots, after days missing.",
+      lost: "They find {name}'s things in a ditch by the road.{loss}",
+      birth: "{name} gives birth at {place}{help}.",
+      birth_help: " with help from someone who knows how",
+      birth_alone: ", with no one who knows how to deliver a baby",
+      baby_dies: " The baby does not breathe. They bury it beside the base.",
+      baby_born: " {baby} is born.",
+      mother_dies: "{loss} {name} does not survive the birth.",
+      risk_hurt: "{name} comes back hurt from a run near {place}.",
+      risk_bitten: "{name} comes back with a bite on the forearm and tells no one.",
+      risk_dead: "{name} does not come back from a run near {place}.{loss}",
+      risk_missing: "{name} goes missing on a run near {place}.",
+      couple: "{a} and {b} {line}.",
+      pregnancy: "{a} and {b} are going to have a baby. Due in about {days} days.",
+      adoption: "{a} and {b} adopt {child}.",
+      rivalry: "{a} and {b} {line}. They are rivals now.",
+      fight_hurt: "The rivalry blows up: {winner} breaks {loser}'s nose in the yard.",
+      fight_dead: "The rivalry ends with a knife: {loser} dies and {winner} carries that death for the rest of their life.{loss}",
+      fight_leaves: "{name} packs up and goes to {to} after the fight with {other}.",
+      betrayal: "{name} vanishes before dawn with the pantry's food and the radio of {from}. Days later they are seen at {to}.",
+      caravan: "Caravan: {carrier} crosses town with food from {from} to {to}, where {host} lives.",
+      caravan_hurt: " On the way back, {carrier} is attacked on the avenue and arrives hurt.",
+      raid: "{who} raid {target} before dawn and take {loot} days of food.",
+      raid_hero: " {hero}, from {heroBase}, hears the shots and arrives in time: {victim} is only hurt.",
+      raid_dead: "{loss} {victim} dies at the door.",
+      raid_grazed: " {victim} is grazed by a bullet.",
+      arrival: "{first}, {relation} of {bond}, arrives{origin}{note}.",
+      arrival_gone: " They were looking for {bond} and learn that {bond} {fate}. They stay at {base}.",
+      arrival_party: " They ask for {bond} and learn that they are with the player. They stay at {base}, waiting.",
+      arrival_found: " They find {bond} at {base} and stay.",
+      arrival_elsewhere: " They learn that {bond} is at {where} and would rather stay at {base}.",
+      arrival_pair_pregnant: " They come with {pair}, and {mother} is pregnant.",
+      arrival_pair: " They come with {pair}."
+    },
+    pools: {
+      couple: ["start sharing the watch, and then the mattress", "kiss on the roof during the 8 pm radio", "go public in front of the whole base"],
+      rivalry: ["fight over the last tin of sardines", "shout about who sleeps by the door", "accuse each other of stealing rations"]
+    },
+    fates: { dead: "died", undead: "became one of the dead", left: "left on the bus", missing: "went missing", bitten: "was bitten", other: "is not here any more" },
+    places: { where_died: "where they died", road: "the road", open_field: "the open field", nowhere: "nowhere" },
+    gender: { female: "", male: "" },
+    honorifics: ["Mrs.", "Mr.", "Dr.", "Lieutenant", "Sergeant", "Private", "Pastor", "Corporal", "Captain", "Major"]
+  }
+};
+
+// src/conditions.ts
+var stateOf = (context, role) => context.states[context.cast(role)]?.state;
+function holds(condition, context) {
+  if ("all" in condition) return condition.all.every((c) => holds(c, context));
+  if ("any" in condition) return condition.any.some((c) => holds(c, context));
+  if ("not" in condition) return !holds(condition.not, context);
+  if ("action" in condition) return Boolean(context.actions[condition.action]);
+  if ("flag" in condition) return Boolean(context.flags[condition.flag]);
+  if ("state" in condition) {
+    const state = stateOf(context, condition.state);
+    return state !== void 0 && (typeof condition.is === "string" ? state === condition.is : condition.is.includes(state));
+  }
+  if ("living" in condition) {
+    const state = stateOf(context, condition.living);
+    return state !== void 0 && context.living.includes(state);
+  }
+  if ("base" in condition) return context.states[context.cast(condition.base)]?.base === condition.is;
+  if ("value" in condition) return Boolean(context.values?.[condition.value]);
+  if ("self" in condition) return context.self === context.cast(condition.self);
+  if ("changed" in condition) return (context.changes ?? []).some((change) => change.id === context.cast(condition.changed));
+  if ("remembers" in condition) return context.remembers?.(context.cast(condition.remembers), condition.entry) ?? false;
+  return false;
+}
+
+// src/story/apply.ts
+var FINAL_STATES = ["dead", "left"];
+function applyChanges(states, changes, playerBase) {
+  for (const { id, state, note, base } of changes ?? []) {
+    const current = states[id];
+    if (!current) continue;
+    if (FINAL_STATES.includes(current.state)) continue;
+    if (current.state === "undead" && state !== "dead") continue;
+    states[id] = { state, note, base: base || (state === "party" ? playerBase : current.base) };
+  }
+}
+function setState(states, id, state, note, base) {
+  const current = states[id];
+  if (FINAL_STATES.includes(current.state) || current.state === "undead" && state !== "dead") return;
+  states[id] = { state, note, base: base || current.base };
+}
+
+// src/text.ts
+var fillText = (template, values) => template.replace(/\{(\w+)\}/g, (_, key) => String(values[key] ?? ""));
+var escape = (text) => text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+function shortName(name, honorifics) {
+  const quoted = name.match(/“(.*?)”/);
+  if (quoted) return quoted[1];
+  const prefix = honorifics.length > 0 ? new RegExp(`^(${honorifics.map(escape).join("|")}) `) : null;
+  return (prefix ? name.replace(prefix, "") : name).split(" ")[0];
+}
+
+// src/life/life.ts
+var toChanges = (rows) => rows.map(([id, state, note, base]) => ({ id, state, note, ...base ? { base } : {} }));
+function createLifeWorld(options, numbers) {
+  const W = {
+    raid: {},
+    food: {},
+    defence: {},
+    affinity: {},
+    partner: {},
+    rival: {},
+    adopted: {},
+    timers: {},
+    made: {},
+    count: 0,
+    lastNews: {},
+    stats: { births: 0, arrivals: 0, deaths: 0, couples: 0, fights: 0, betrayals: 0, caravans: 0, raids: 0, pregnancies: 0 },
+    usedNames: /* @__PURE__ */ new Set()
+  };
+  for (const [id, group] of Object.entries(options.groups)) {
+    W.food[id] = group.food;
+    W.defence[id] = group.defence;
+  }
+  W.defence[options.playerBase ?? "player"] = 1;
+  for (const [a, b, kind] of options.relations ?? []) if (kind === numbers.rivalKind) W.rival[a < b ? `${a}|${b}` : `${b}|${a}`] = 1;
+  for (const [a, b] of options.couples ?? []) {
+    W.partner[a] = b;
+    W.partner[b] = a;
+  }
+  return W;
+}
+function lifeDay(d, W, host) {
+  const { states: S, flags: F, random: R, numbers: N, text: T, options: O } = host;
+  const nomad = O.nomadBase ?? "nomad";
+  const playerBase = O.playerBase ?? "player";
+  const closed = /* @__PURE__ */ new Set([nomad, ...O.closedBases ?? []]);
+  const groups = O.groups;
+  const P = (id) => host.people[id] ?? W.made[id];
+  const age = (id) => P(id).age ?? N.unknownAge;
+  const fem = (id) => Boolean(P(id).female);
+  const nm = (id) => P(id).nick ?? shortName(P(id).name, T.honorifics);
+  const o = (id) => fem(id) ? T.gender.female : T.gender.male;
+  const pers = (id) => {
+    const p = P(id).personality;
+    return p && p.some((v) => v) ? p : [50, 50, 50, 50, 50];
+  };
+  const groupName = (b, fallback) => b !== void 0 && groups[b] ? groups[b].name : fallback;
+  const conditionContext = () => ({ states: S, flags: F, actions: host.actions, cast: (id) => id, living: N.livingStates });
+  const anchorDays = (id, from, to) => host.beatDays(id).some((day) => day > from && day <= to);
+  const anchor = (id) => anchorDays(id, d, d + 7) || Boolean(W.timers[id]?.due) || (O.anchors ?? []).some((a) => a.id === id && d < a.beforeDay) || Boolean(W.made[id]?.baby);
+  const alive = (id) => N.activeStates.includes(S[id].state);
+  const ids = Object.keys(S).filter((id) => alive(id) && age(id) > 0);
+  const set = (id, state, note, base) => setState(S, id, state, note, base);
+  const say = (rule, text, rows, base, people) => {
+    host.log({ day: d, kind: "life", id: rule, title: T.titles[rule], text, changes: toChanges(rows), people, ...base ? { base } : {} });
+    if (base) W.lastNews[base] = d;
+  };
+  const kill = (id, note) => {
+    set(id, "dead", note);
+    W.stats.deaths++;
+    const p = W.partner[id];
+    if (p && alive(p)) return fillText(T.lines.loses, { partner: nm(p), name: nm(id) });
+    return "";
+  };
+  const cnt = (b) => Object.keys(S).filter((id) => alive(id) && S[id].base === b).length;
+  const pop = () => Object.keys(S).filter((id) => alive(id) || S[id].state === "party").length;
+  const key = (a, b) => a < b ? `${a}|${b}` : `${b}|${a}`;
+  const aff = (a, b) => {
+    const k = key(a, b);
+    if (W.affinity[k] === void 0) {
+      const r = (O.relations ?? []).find((rel) => rel[0] === a && rel[1] === b || rel[0] === b && rel[1] === a);
+      W.affinity[k] = r ? N.affinity[r[2]] : N.unknownAffinity.base + ((pers(a)[1] + pers(b)[1]) / 2 - 50) / N.unknownAffinity.divisor;
+    }
+    return W.affinity[k];
+  };
+  const addAff = (a, b, v) => {
+    const k = key(a, b);
+    W.affinity[k] = Math.max(-100, Math.min(100, aff(a, b) + v));
+  };
+  const pick = (a) => a[Math.floor(R() * a.length)];
+  const hostileNow = () => {
+    const out = {};
+    for (const [b, rule] of Object.entries(O.hostileBases ?? {})) out[b] = rule === true ? true : holds(rule, conditionContext());
+    return out;
+  };
+  const bestBase = () => {
+    const H2 = hostileNow();
+    const c = Object.keys(groups).filter((b) => !closed.has(b) && !H2[b] && cnt(b) > 0 && cnt(b) < N.arrivals.room);
+    c.sort((a, b) => W.food[b] * (0.5 + W.defence[b]) - W.food[a] * (0.5 + W.defence[a]));
+    return c.length ? c[Math.floor(R() * Math.min(3, c.length))] : nomad;
+  };
+  const newPerson = (person) => {
+    const id = `g${++W.count}`;
+    W.made[id] = { id, generated: true, ...person };
+    S[id] = { state: "ok", note: "", base: person.base };
+    return id;
+  };
+  const heal = (spread) => d + N.clocks.healBase + Math.floor(R() * spread);
+  for (const { flag, a, b } of O.flagCouples ?? []) {
+    if (F[flag] && !W.partner[a] && !W.partner[b]) {
+      W.partner[a] = b;
+      W.partner[b] = a;
+    }
+  }
+  for (const [id, t] of Object.entries(W.timers)) {
+    if (t.heal === d && S[id].state === "hurt") S[id].note = T.notes.healed;
+    if (t.heal === d && S[id].state === "hurt") S[id].state = "ok";
+    if (t.turn === d && S[id].state === "bitten") {
+      const b = S[id].base;
+      set(id, "undead", b === nomad ? T.notes.undead_street : fillText(T.notes.undead_near, { place: groupName(b, T.places.where_died) }));
+      say("turn", fillText(T.lines.turn, { name: nm(id) }), [[id, "undead", S[id].note]], S[id].base, [id]);
+    }
+    if (t.back === d && S[id].state === "missing") {
+      if (R() < N.clocks.backChance) {
+        set(id, "ok", T.notes.came_back);
+        say("back", fillText(T.lines.back, { name: nm(id) }), [[id, "ok", T.notes.came_back_short]], null, [id]);
+      } else {
+        const x = kill(id, T.notes.never_back);
+        say("lost", fillText(T.lines.lost, { name: nm(id), loss: x }), [[id, "dead", T.notes.never_back]], null, [id]);
+      }
+    }
+    if (t.due === d) {
+      t.due = 0;
+      if (!alive(id)) continue;
+      const b = S[id].base;
+      const med = (O.midwives ?? []).some((m) => S[m] && alive(m) && S[m].base === b);
+      const pm = med ? N.birth.motherWithMidwife : N.birth.motherAlone;
+      const pb = med ? N.birth.babyWithMidwife : N.birth.babyAlone;
+      const dad = t.father;
+      const sx = R() < N.birth.girl ? "f" : "m";
+      const bn = sx === "f" ? pick(host.names.babyFemale) : pick(host.names.babyMale);
+      const momDies = R() < pm && !anchor(id);
+      const babyDies = R() < pb;
+      let txt = fillText(T.lines.birth, { name: nm(id), place: groupName(b, T.places.open_field), help: med ? T.lines.birth_help : T.lines.birth_alone });
+      const ch = [];
+      const people = [id];
+      if (babyDies) txt += T.lines.baby_dies;
+      else {
+        const surname = P(id).name.split(" ").filter((x) => !/[“”]/.test(x)).slice(-1)[0];
+        const bid = newPerson({ name: `${bn} ${surname}`, age: 0, base: b, female: sx === "f", baby: true, mother: id, ...dad ? { father: dad } : {} });
+        W.stats.births++;
+        txt += fillText(T.lines.baby_born, { baby: bn });
+        ch.push([bid, "ok", T.notes.newborn, b]);
+        people.push(bid);
+      }
+      if (momDies) {
+        txt += fillText(T.lines.mother_dies, { loss: kill(id, T.notes.childbirth), name: nm(id) });
+        ch.push([id, "dead", T.notes.childbirth]);
+      }
+      say("birth", txt, ch, b, people);
+    }
+  }
+  for (const id of ids) {
+    if (S[id].state === "hurt" && !(W.timers[id] && W.timers[id].heal > d)) {
+      W.timers[id] = W.timers[id] || {};
+      W.timers[id].heal = heal(N.clocks.healSpread);
+    }
+  }
+  for (const id of ids) {
+    if (!alive(id) || anchor(id) || W.made[id] && W.made[id].baby) continue;
+    const b = S[id].base;
+    if (b === playerBase) continue;
+    const ex = W.made[id] ? age(id) < N.risk.childAge ? N.risk.newcomerChild : N.risk.newcomerAdult : O.exposure?.[id] ?? N.risk.defaultExposure;
+    let r = (O.placeRisk?.[b] ?? N.risk.defaultPlace) * ex * (1 - (W.defence[b] ?? 0)) * (W.food[b] < N.risk.hungryBelow ? N.risk.hungry : 1) * (S[id].state === "hurt" ? N.risk.hurt : 1);
+    for (const [flag, factor] of Object.entries(O.riskFlags ?? {})) r *= F[flag] ? factor : 1;
+    if (R() >= r) continue;
+    const x = R();
+    const where = groupName(b, T.places.road);
+    const hurtBand = N.infection ? N.risk.bands.hurt : N.risk.bands.bitten;
+    if (x < hurtBand) {
+      set(id, "hurt", T.notes.hurt_out);
+      W.timers[id] = { ...W.timers[id], heal: heal(N.clocks.healSpread) };
+      say("risk", fillText(T.lines.risk_hurt, { name: nm(id), o: o(id), place: where }), [[id, "hurt", T.notes.hurt_out]], null, [id]);
+    } else if (x < N.risk.bands.bitten) {
+      set(id, "bitten", T.notes.bitten_out);
+      W.timers[id] = { ...W.timers[id], turn: d + N.clocks.turnDays };
+      say("risk", fillText(T.lines.risk_bitten, { name: nm(id) }), [[id, "bitten", T.notes.hides_bite]], b, [id]);
+    } else if (x < N.risk.bands.dead) {
+      const t = kill(id, T.notes.dead_out);
+      say("risk", fillText(T.lines.risk_dead, { name: nm(id), place: where, loss: t }), [[id, "dead", T.notes.did_not_return]], b, [id]);
+    } else {
+      set(id, "missing", T.notes.missing_out);
+      W.timers[id] = { ...W.timers[id], back: d + N.clocks.backBase + Math.floor(R() * N.clocks.backSpread) };
+      say("risk", fillText(T.lines.risk_missing, { name: nm(id), place: where }), [[id, "missing", T.notes.missing_short]], null, [id]);
+    }
+  }
+  const B = N.bonds;
+  const by = {};
+  for (const id of Object.keys(S)) {
+    if (!alive(id) || age(id) < B.minAge) continue;
+    const b = S[id].base;
+    if (!b || b === playerBase || b === nomad) continue;
+    (by[b] = by[b] || []).push(id);
+  }
+  for (const [b, m] of Object.entries(by)) {
+    const quiet = W.lastNews[b] >= d - B.quietDays;
+    for (let i = 0; i < m.length; i++) {
+      for (let j = i + 1; j < m.length; j++) {
+        const a = m[i];
+        const c = m[j];
+        const pa = pers(a);
+        const pc = pers(c);
+        addAff(a, c, ((pa[1] + pc[1]) / 2 - 50) / B.driftEmpathy + (W.food[b] < B.lowFood ? -(pa[3] + pc[3]) / B.driftGreed : B.driftFed) + (R() - 0.5) * B.driftNoise);
+        const v = aff(a, c);
+        const k = key(a, c);
+        if (quiet || W.lastNews[b] >= d) continue;
+        if (!W.partner[a] && !W.partner[c] && age(a) >= B.coupleAge && age(c) >= B.coupleAge && Math.abs(age(a) - age(c)) <= B.coupleGap && v >= B.coupleAffinity && R() < B.coupleChance) {
+          W.partner[a] = c;
+          W.partner[c] = a;
+          W.affinity[k] = B.coupledAffinity;
+          W.stats.couples++;
+          say("bond", fillText(T.lines.couple, { a: nm(a), b: nm(c), line: pick(T.pools.couple) }), [], b, [a, c]);
+          continue;
+        }
+        if (W.partner[a] === c && W.food[b] >= B.pregnancyFood) {
+          const f = fem(a) && !fem(c) ? a : fem(c) && !fem(a) ? c : null;
+          if (f && age(f) <= B.pregnancyAge && !W.timers[f]?.due && !(anchorDays(a, d, d + B.pregnancyStoryWindow) || anchorDays(c, d, d + B.pregnancyStoryWindow)) && R() < B.pregnancyChance) {
+            W.timers[f] = { ...W.timers[f], due: d + B.pregnancyDays, father: f === a ? c : a };
+            W.stats.pregnancies++;
+            say("pregnancy", fillText(T.lines.pregnancy, { a: nm(a), b: nm(c), days: B.pregnancyDays }), [], b, [a, c]);
+            continue;
+          }
+          if (!f && !W.adopted[k] && R() < B.adoptionChance) {
+            const orphan = Object.keys(S).find((x) => alive(x) && S[x].base === b && (O.orphans?.[x] !== void 0 || W.made[x]?.baby && !alive(W.made[x].mother)));
+            if (orphan) {
+              W.adopted[k] = 1;
+              say("adoption", fillText(T.lines.adoption, { a: nm(a), b: nm(c), child: O.orphans?.[orphan] ?? nm(orphan) }), [], b, [a, c, orphan]);
+              continue;
+            }
+          }
+        }
+        if (!W.rival[k] && v <= B.rivalryAt) {
+          W.rival[k] = 1;
+          say("rivalry", fillText(T.lines.rivalry, { a: nm(a), b: nm(c), line: pick(T.pools.rivalry) }), [], b, [a, c]);
+          continue;
+        }
+        if (W.rival[k] && v <= B.fightAt && Math.max(pa[0], pc[0]) >= B.fightCourage && R() < B.fightChance) {
+          W.stats.fights++;
+          W.affinity[k] = B.afterFight;
+          const x = R();
+          const lo = pa[0] < pc[0] ? a : c;
+          const hi = lo === a ? c : a;
+          if (x < B.fightHurt && !anchor(lo)) {
+            set(lo, "hurt", fillText(T.notes.fight_with, { other: nm(hi) }));
+            W.timers[lo] = { ...W.timers[lo], heal: heal(B.fightHealSpread) };
+            say("fight", fillText(T.lines.fight_hurt, { winner: nm(hi), loser: nm(lo) }), [[lo, "hurt", T.notes.fight]], b, [hi, lo]);
+          } else if (x < B.fightDead && !anchor(lo)) {
+            const t = kill(lo, fillText(T.notes.dead_fight, { other: nm(hi) }));
+            say("fight", fillText(T.lines.fight_dead, { loser: nm(lo), winner: nm(hi), loss: t }), [[lo, "dead", T.notes.fight]], b, [hi, lo]);
+          } else {
+            const out = pa[2] < pc[2] ? a : c;
+            const dest = bestBase();
+            if (dest !== b && !anchor(out)) {
+              set(out, "moved", T.notes.left_after_fight, dest);
+              say("fight", fillText(T.lines.fight_leaves, { name: nm(out), to: groupName(dest, dest), other: nm(out === a ? c : a) }), [[out, "moved", groupName(dest, dest), dest]], b, [out, out === a ? c : a]);
+            }
+          }
+        }
+      }
+    }
+    const V2 = N.betrayal;
+    for (const id of m) {
+      const p = pers(id);
+      if (quiet || W.lastNews[b] >= d || !alive(id) || anchor(id)) continue;
+      if (p[2] < V2.loyaltyBelow && p[3] > V2.greedAbove && W.food[b] < V2.foodBelow && R() < V2.chance) {
+        const dest = (O.traitorDestinations ?? []).find((t) => t.base !== b && (!t.when || holds(t.when, conditionContext())))?.base ?? nomad;
+        W.food[b] = Math.max(0, W.food[b] - V2.takes);
+        W.stats.betrayals++;
+        set(id, host.people[id] ? "hostile" : "moved", fillText(T.notes.betrayed, { from: groupName(b, b), to: groupName(dest, dest) }), dest);
+        for (const other of m) if (other !== id) addAff(id, other, V2.affinity);
+        say("betrayal", fillText(T.lines.betrayal, { name: nm(id), from: groupName(b, b), to: groupName(dest, dest) }), [[id, S[id].state, T.notes.betrayed_short, dest]], b, [id]);
+      }
+    }
+  }
+  for (const b of Object.keys(W.food)) {
+    const rule = O.foodDrift?.[b];
+    const drift = rule === void 0 ? N.food.drift : typeof rule === "number" ? rule : F[rule.flag] ? rule.value : N.food.drift;
+    W.food[b] = Math.max(0, Math.min(N.food.max, W.food[b] + drift));
+  }
+  const H = hostileNow();
+  const C = N.caravan;
+  for (const [b, m] of Object.entries(by)) {
+    if (W.food[b] >= C.below || W.lastNews[b] >= d - B.quietDays) continue;
+    caravan: for (const x of m) {
+      for (const [c, mc] of Object.entries(by)) {
+        if (c === b || H[c] || W.food[c] <= C.hostAbove) continue;
+        const y = mc.find((member) => aff(x, member) >= C.affinity);
+        if (!y || R() >= C.chance) continue;
+        W.food[b] += C.carries;
+        W.food[c] -= C.carries;
+        addAff(x, y, C.bond);
+        W.stats.caravans++;
+        let t = fillText(T.lines.caravan, { carrier: nm(y), from: groupName(c, c), to: groupName(b, b), host: nm(x) });
+        const ch = [];
+        if (R() < C.hurtChance && !anchor(y)) {
+          set(y, "hurt", T.notes.hurt_caravan);
+          W.timers[y] = { ...W.timers[y], heal: d + C.healDays };
+          t += fillText(T.lines.caravan_hurt, { carrier: nm(y), o: o(y) });
+          ch.push([y, "hurt", T.notes.caravan]);
+        }
+        say("caravan", t, ch, b, [y, x]);
+        break caravan;
+      }
+    }
+  }
+  const A = N.raid;
+  const raids = (O.raids ?? []).map((raid) => ({ ...raid, on: holds(raid.when, conditionContext()) }));
+  for (const { from: src, on, who } of raids) {
+    if (!on || R() >= A.chance || (W.raid[src] || 0) > d - A.cooldown) continue;
+    const alvo = Object.keys(by).filter((b) => b !== src && !H[b] && !(O.raidImmune ?? []).includes(b) && W.food[b] >= A.targetFood).sort((a, b) => W.defence[a] - W.defence[b] + (R() - 0.5) * A.noise)[0];
+    if (!alvo || W.lastNews[alvo] >= d - B.quietDays) continue;
+    W.raid[src] = d;
+    const v = pick(by[alvo]);
+    W.stats.raids++;
+    const loot = Math.min(A.loot, W.food[alvo]);
+    W.food[alvo] -= loot;
+    W.food[src] = (W.food[src] || 0) + loot;
+    const hero = Object.entries(by).filter(([b]) => b !== alvo && !H[b]).flatMap(([, mm]) => mm).find((h) => pers(h)[0] >= A.heroCourage && by[alvo].some((other) => aff(h, other) >= A.heroAffinity));
+    let t = fillText(T.lines.raid, { who, target: groupName(alvo, alvo), loot: Math.round(loot) });
+    const ch = [];
+    const people = [v];
+    if (hero && R() < A.heroChance) {
+      t += fillText(T.lines.raid_hero, { hero: nm(hero), heroBase: groupName(S[hero].base, S[hero].base), victim: nm(v), o: o(v) });
+      set(v, "hurt", T.notes.hurt_raid);
+      W.timers[v] = { ...W.timers[v], heal: d + A.healDays };
+      addAff(hero, v, A.heroBond);
+      ch.push([v, "hurt", T.notes.raid]);
+      people.push(hero);
+    } else if (R() < A.deadChance && !anchor(v)) {
+      t += fillText(T.lines.raid_dead, { loss: kill(v, fillText(T.notes.dead_raid, { from: groupName(src, src) })), victim: nm(v) });
+      ch.push([v, "dead", T.notes.raid]);
+    } else if (!anchor(v)) {
+      set(v, "hurt", T.notes.hurt_raid);
+      W.timers[v] = { ...W.timers[v], heal: d + A.healDays };
+      t += fillText(T.lines.raid_grazed, { victim: nm(v) });
+      ch.push([v, "hurt", T.notes.raid]);
+    }
+    say("raid", t, ch, alvo, people);
+  }
+  const V = N.arrivals;
+  const pool = Object.values(host.people).filter((x) => !x.extra && typeof x.age === "number" && x.age >= V.bondAge);
+  if (O.arrivals !== false && d % V.every === 0 && pool.length > 0) {
+    const origins = O.arrivals?.origins?.length ? O.arrivals.origins : [""];
+    let n = R() < (d > V.lateAfter ? V.lateChance : V.chance) ? 1 + (R() < V.secondChance ? 1 : 0) : 0;
+    while (n-- > 0 && pop() < V.cap) {
+      const f = R() < 0.5;
+      let nome;
+      do
+        nome = `${pick(f ? host.names.female : host.names.male)} ${pick(host.names.surnames)}`;
+      while (W.usedNames.has(nome.split(" ")[0]) && W.usedNames.size < V.uniqueNames);
+      const first = nome.split(" ")[0];
+      W.usedNames.add(first);
+      const origem = pick(origins);
+      const bond = pick(pool).id;
+      const rel = pick(host.names.kinship[f ? "female" : "male"]);
+      const st = S[bond].state;
+      const live = alive(bond) || st === "party";
+      const bondBase = S[bond].base;
+      const b = live && bondBase !== playerBase && bondBase !== nomad && !H[bondBase] && cnt(bondBase) < V.room ? bondBase : bestBase();
+      const Q = N.personality;
+      const id = newPerson({
+        name: nome,
+        age: V.ageBase + Math.floor(R() * V.ageSpread),
+        base: b,
+        female: f,
+        personality: [Q.base + R() * Q.spread, Q.base + R() * Q.spread, Q.base + R() * Q.spread, Q.greedBase + R() * Q.spread, Q.base + R() * Q.spread].map(Math.round),
+        bond,
+        relation: rel
+      });
+      W.stats.arrivals++;
+      const way = origem ? ` ${origem}` : "";
+      const note = (O.arrivals ? O.arrivals.notes ?? [] : []).filter((x) => x.origin === origem && holds(x.when, conditionContext())).map((x) => x.text).join("");
+      let t = fillText(T.lines.arrival, { first, relation: rel, bond: nm(bond), origin: way, note });
+      if (!live) {
+        const fate = T.fates[st] ?? T.fates.other;
+        t += fillText(T.lines.arrival_gone, { bond: nm(bond), fate, base: groupName(b, b) });
+      } else {
+        t += st === "party" ? fillText(T.lines.arrival_party, { bond: nm(bond), base: groupName(b, b) }) : b === S[bond].base ? fillText(T.lines.arrival_found, { bond: nm(bond), base: groupName(b, b) }) : fillText(T.lines.arrival_elsewhere, { bond: nm(bond), where: groupName(S[bond].base, T.places.nowhere), base: groupName(b, b) });
+        W.affinity[key(id, bond)] = V.bondAffinity;
+      }
+      for (const a of O.arrivals ? O.arrivals.announcements ?? [] : []) if (holds(a.when, conditionContext())) t += a.text;
+      const arrived = fillText(T.notes.arrived, { origin: way });
+      const ch = [[id, "ok", arrived, b]];
+      const people = [id, bond];
+      if (R() < V.pairChance && pop() < V.cap) {
+        const pf = !f;
+        let n2;
+        do
+          n2 = pick(pf ? host.names.female : host.names.male);
+        while (W.usedNames.has(n2) && W.usedNames.size < V.uniqueNames);
+        W.usedNames.add(n2);
+        const surname = nome.split(" ").slice(-1)[0];
+        const id2 = newPerson({
+          name: `${n2} ${surname}`,
+          age: Math.max(V.ageBase, W.made[id].age + Math.floor(R() * V.pairAgeSpread) - V.pairAgeShift),
+          base: b,
+          female: pf,
+          personality: [1, 2, 3, 4, 5].map(() => Math.round(Q.base + R() * Q.spread)),
+          bond,
+          relation: fillText(T.notes.pair_of, { first })
+        });
+        W.stats.arrivals++;
+        W.partner[id] = id2;
+        W.partner[id2] = id;
+        ch.push([id2, "ok", arrived, b]);
+        people.push(id2);
+        const mae = pf ? id2 : id;
+        if (R() < V.pregnantChance && W.made[mae].age <= B.pregnancyAge) {
+          W.timers[mae] = { due: d + V.pregnantDueBase + Math.floor(R() * V.pregnantDueSpread), father: mae === id ? id2 : id };
+          W.stats.pregnancies++;
+          t += fillText(T.lines.arrival_pair_pregnant, { pair: n2, mother: nm(mae) });
+        } else t += fillText(T.lines.arrival_pair, { pair: n2 });
+      }
+      say("arrival", t, ch, null, people);
+    }
+  }
+}
+function fillWorld(W, host, target) {
+  const { states: S, random: R, numbers: N, options: O } = host;
+  const closed = /* @__PURE__ */ new Set([O.nomadBase ?? "nomad", ...O.closedBases ?? []]);
+  const bases = Object.keys(O.groups).filter((b) => !closed.has(b));
+  const living = () => Object.keys(S).filter((id) => N.livingStates.includes(S[id].state));
+  let i = 0;
+  let idle = 0;
+  while (living().length < target && bases.length > 0) {
+    const b = bases[i++ % bases.length];
+    if (living().filter((id2) => S[id2].base === b).length >= N.fill.perBase) {
+      if (++idle >= bases.length) break;
+      continue;
+    }
+    idle = 0;
+    const id = `g${++W.count}`;
+    const f = R() < 0.5;
+    const first = f ? host.names.female : host.names.male;
+    W.made[id] = {
+      id,
+      generated: true,
+      name: `${first[W.count % first.length]} ${host.names.surnames[W.count % host.names.surnames.length]}`,
+      age: N.fill.ageBase + Math.floor(R() * N.fill.ageSpread),
+      base: b,
+      female: f,
+      personality: [1, 2, 3, 4, 5].map(() => Math.round(N.personality.base + R() * N.personality.spread))
+    };
+    S[id] = { state: "ok", note: "", base: b };
+  }
+}
+
+// src/story/beat.ts
+var resolveChanges = (items, context, out) => {
+  for (const item of items) {
+    const here = { ...context, changes: out };
+    if ("when" in item) {
+      if (holds(item.when, here)) resolveChanges(item.changes, context, out);
+      continue;
+    }
+    if ("each" in item) {
+      const { roles, cast, where, except } = item.each;
+      const ids = roles ? roles.map((role) => context.cast(role)) : cast ? context.castList : [];
+      const skip = new Set((except ?? []).map((role) => context.cast(role)));
+      for (const id2 of ids) {
+        if (skip.has(id2) || !context.states[id2]) continue;
+        if (where && !holds(where, { ...here, self: id2, cast: (role) => role === "self" ? id2 : context.cast(role) })) continue;
+        out.push({ id: id2, state: item.change.state, note: item.change.note, ...item.change.base ? { base: item.change.base } : {} });
+      }
+      continue;
+    }
+    const id = context.cast(item.role);
+    const base = item.base === void 0 ? void 0 : typeof item.base === "string" ? item.base : context.states[context.cast(item.base.baseOf)]?.base;
+    out.push({ id, state: item.state, note: item.note, ...base ? { base } : {} });
+  }
+};
+var renderText = (parts, context, changes, join) => {
+  const piece = (part) => {
+    if (typeof part === "string") return part;
+    if ("when" in part) {
+      const chosen = holds(part.when, { ...context, changes }) ? part.text : part.else;
+      if (chosen === void 0) return "";
+      return typeof chosen === "string" ? chosen : renderText(chosen, context, changes, void 0);
+    }
+    if ("value" in part) return context.values?.[part.value] ?? "";
+    if ("count" in part) return String(changes.length);
+    return context.nameOf(context.cast(part.name));
+  };
+  const pieces = parts.map(piece);
+  return join === void 0 ? pieces.join("") : pieces.filter((text) => text !== "").join(join);
+};
+function runBeat(beat, context) {
+  if (beat.run) {
+    const code = context.codeBeats?.[beat.run];
+    if (!code) throw new Error(`game-stories: code beat "${beat.run}" of "${beat.id}" is not registered`);
+    return code({ states: context.states, actions: context.actions, flags: context.flags, cast: context.cast });
+  }
+  const values = {};
+  for (const [name, options] of Object.entries(beat.values ?? {})) values[name] = options.find((option) => !option.when || holds(option.when, context))?.value ?? null;
+  const here = { ...context, values };
+  const variant = (beat.variants ?? []).find((v) => !v.when || holds(v.when, here));
+  if (!variant || variant.none) return null;
+  const changes = [];
+  resolveChanges(variant.changes ?? [], here, changes);
+  if (variant.needsChanges && changes.length === 0) return null;
+  return {
+    text: renderText(variant.text ?? [], here, changes, variant.join),
+    ...variant.alt ? { alt: true } : {},
+    ...variant.changes ? { changes } : {},
+    ...variant.flags ? { flags: variant.flags } : {}
+  };
+}
+
+// src/world.ts
+var hashId = (text) => {
+  let hash = 2166136261;
+  for (let i = 0; i < text.length; i++) hash = Math.imul(hash ^ text.charCodeAt(i), 16777619);
+  return hash >>> 0;
+};
+var lifeTextOf = (locale, patch) => {
+  const table = life_text_default[locale] ?? life_text_default["pt-BR"];
+  if (!patch) return table;
+  const out = { ...table };
+  for (const [key, value] of Object.entries(patch)) out[key] = Array.isArray(value) ? value : { ...table[key], ...value };
+  return out;
+};
+var mergeNumbers = (base, patch) => {
+  if (!patch) return base;
+  const out = { ...base };
+  for (const [key, value] of Object.entries(patch)) {
+    out[key] = value !== null && typeof value === "object" && !Array.isArray(value) ? mergeNumbers(base[key], value) : value;
+  }
+  return out;
+};
+var lifeNumbersOf = (patch) => {
+  const { sources: _sources, ...defaults } = life_default;
+  void _sources;
+  return mergeNumbers(defaults, patch);
+};
+function createStoryWorld(options = {}) {
+  const seed = options.seed ?? 1;
+  const locale = options.locale ?? "pt-BR";
+  const names = options.names ?? getNamePools(locale);
+  const ruleset = options.ruleset ?? SHEET_RULESET2;
+  const stories = options.stories ?? [];
+  const castRandom = createRng((seed ^ 2654435769) >>> 0);
+  const casting = castStories({ stories, ...options.people ? { people: options.people } : {}, names, random: castRandom, ...options.life?.nomadBase ? { defaultBase: options.life.nomadBase } : {} });
+  const given = Object.fromEntries(casting.people.map((person2) => [person2.id, person2]));
+  const numbers = lifeNumbersOf(options.life?.numbers);
+  const text = lifeTextOf(locale, options.life?.text);
+  const states = {};
+  for (const person2 of casting.people) states[person2.id] = { state: person2.start?.state ?? "ok", note: person2.start?.note ?? "", base: person2.base };
+  const flags = {};
+  const actions = { ...options.actions };
+  const chronicle = createChronicle();
+  const cast = (role) => casting.roles[role] ?? role;
+  const beats = stories.flatMap((story) => story.beats).map((beat, order) => ({ beat, order })).sort((a, b) => a.beat.day - b.beat.day || a.order - b.order).map(({ beat }) => beat);
+  const beatDays = /* @__PURE__ */ new Map();
+  for (const beat of beats) for (const role of beat.roles) (beatDays.get(cast(role)) ?? beatDays.set(cast(role), []).get(cast(role))).push(beat.day);
+  const random = options.random ?? createRng(seed);
+  const life = options.life ? createLifeWorld(options.life, numbers) : null;
+  const sheets = /* @__PURE__ */ new Map();
+  const castList = casting.people.filter((person2) => !person2.extra).map((person2) => person2.id);
+  const person = (id) => given[id] ?? life?.made[id];
+  const nameOf = (id) => {
+    const p = person(id);
+    return p ? p.nick ?? shortName(p.name, text.honorifics) : id;
+  };
+  const sheet = (id) => {
+    let made = sheets.get(id);
+    if (!made) {
+      const p = person(id);
+      made = drawSheet(createRng((seed ^ hashId(id)) >>> 0), { ruleset, ...p?.profession ? { profession: p.profession } : {}, ...p?.personality ? { personality: p.personality } : {} });
+      sheets.set(id, made);
+    }
+    return made;
+  };
+  const living = numbers.livingStates;
+  const playerBase = options.playerBase ?? options.life?.playerBase ?? "player";
+  let day = 0;
+  let next = 0;
+  if (life && options.fill) fillWorld(life, { states, random, names, numbers, options: options.life }, options.fill);
+  const log = (entry) => {
+    chronicle.add(entry);
+    for (const id of entry.people) if (person(id)) sheet(id).record({ kind: entry.kind === "story" ? "story" : "event", id: entry.id, day: entry.day });
+  };
+  const world = {
+    states,
+    flags,
+    actions,
+    casting,
+    chronicle,
+    life,
+    get day() {
+      return day;
+    },
+    person,
+    people: () => [...casting.people, ...Object.values(life?.made ?? {})],
+    nameOf,
+    cast,
+    act(id) {
+      actions[id] = 1;
+    },
+    advance() {
+      day += 1;
+      const d = day;
+      while (next < beats.length && beats[next].day === d) {
+        const beat = beats[next++];
+        const outcome = runBeat(beat, { states, flags, actions, cast, living, castList, nameOf, remembers: (id, entry) => sheet(id).remembers(entry), ...options.codeBeats ? { codeBeats: options.codeBeats } : {} });
+        if (!outcome) continue;
+        applyChanges(states, outcome.changes, playerBase);
+        Object.assign(flags, outcome.flags ?? {});
+        log({ day: d, kind: "story", id: beat.id, title: beat.title, text: outcome.text, ...outcome.alt ? { alt: true } : {}, changes: outcome.changes ?? [], people: beat.roles.map(cast) });
+      }
+      while (next < beats.length && beats[next].day < d) next++;
+      if (life) lifeDay(d, life, { states, flags, actions, people: given, beatDays: (id) => beatDays.get(id) ?? [], random, names, numbers, text, options: options.life, log });
+    },
+    runTo(target) {
+      while (day < target) world.advance();
+    },
+    sheet
+  };
+  return world;
+}
+function simulateStories(days, options = {}) {
+  const world = createStoryWorld(options);
+  world.runTo(days);
+  return world;
+}
+
+// src/bench/example.ts
+var content = (t) => ({
+  example: true,
+  days: 30,
+  actions: [
+    { id: "welcome", name: t.welcome },
+    { id: "fix_well", name: t.fixWell }
+  ],
+  stories: [
+    {
+      id: "stranger",
+      example: true,
+      roles: [
+        { id: "host", needs: { age: [30, 70], base: "town" }, create: true },
+        { id: "newcomer", create: true, bond: { role: "host", relation: t.cousin, sameSurname: false, sameBase: true } }
+      ],
+      beats: [
+        { id: "stranger_arrives", day: 3, title: t.stranger, roles: ["newcomer", "host"], variants: [{ text: [{ name: "newcomer" }, t.arrives[0], { name: "host" }, t.arrives[1]] }] },
+        {
+          id: "stranger_stays",
+          day: 7,
+          title: t.stay,
+          roles: ["newcomer", "host"],
+          variants: [
+            { when: { action: "welcome" }, alt: true, text: [{ name: "newcomer" }, t.staysText[0]], changes: [{ role: "newcomer", state: "ok", note: t.stays }] },
+            { text: [{ name: "newcomer" }, t.goesText[0]], changes: [{ role: "newcomer", state: "moved", note: t.goes, base: "nomad" }] }
+          ]
+        }
+      ]
+    },
+    {
+      id: "well",
+      example: true,
+      crosses: ["stranger"],
+      roles: [{ id: "keeper", needs: { base: "farm" }, create: true }],
+      beats: [
+        { id: "well_dry", day: 10, title: t.well, roles: ["keeper"], variants: [{ text: [{ name: "keeper" }, t.dryText[0]], flags: { well_dry: 1 } }] },
+        {
+          id: "well_after",
+          day: 14,
+          title: t.wellDry,
+          roles: ["keeper", "newcomer"],
+          variants: [
+            { when: { all: [{ action: "fix_well" }, { living: "newcomer" }, { state: "newcomer", is: "ok" }] }, alt: true, text: [{ name: "newcomer" }, t.fixedText[0], { name: "keeper" }, t.fixedText[1]], changes: [] },
+            { text: [{ name: "keeper" }, t.carriedText[0]], changes: [{ role: "keeper", state: "hurt", note: t.carried }] }
+          ]
+        }
+      ]
+    }
+  ],
+  life: {
+    groups: { farm: { name: t.farm, defence: 0.5, food: 20 }, town: { name: t.town, defence: 0.4, food: 10 }, nomad: { name: t.nomads, defence: 0, food: 0 } },
+    nomadBase: "nomad"
+  },
+  fill: 14
+});
+var STORIES_EXAMPLE = {
+  "pt-BR": content({
+    farm: "S\xEDtio (exemplo)",
+    town: "Vila (exemplo)",
+    nomads: "Estrada",
+    stranger: "Um estranho no port\xE3o",
+    stay: "Fica ou vai",
+    stays: "ficou",
+    goes: "seguiu pela estrada",
+    well: "O po\xE7o secou",
+    wellDry: "Depois do po\xE7o",
+    fixed: "consertou o po\xE7o",
+    carried: "carregou \xE1gua de longe",
+    welcome: "Acolher o estranho",
+    fixWell: "Consertar o po\xE7o",
+    cousin: "primo",
+    arrives: [" bate no port\xE3o de ", " pedindo abrigo por uma noite.", ""],
+    staysText: [" fica e passa a ajudar na horta.", ""],
+    goesText: [" junta as coisas e segue pela estrada.", ""],
+    dryText: [" acorda e o balde volta vazio do po\xE7o.", ""],
+    fixedText: [" desce no po\xE7o com uma corda e destrava a bomba. ", " agradece com um prato de comida.", ""],
+    carriedText: [" passa a semana carregando \xE1gua do rio e machuca as costas.", ""]
+  }),
+  en: content({
+    farm: "Farm (example)",
+    town: "Town (example)",
+    nomads: "Road",
+    stranger: "A stranger at the gate",
+    stay: "Stay or go",
+    stays: "stayed",
+    goes: "went down the road",
+    well: "The well ran dry",
+    wellDry: "After the well",
+    fixed: "fixed the well",
+    carried: "carried water from afar",
+    welcome: "Welcome the stranger",
+    fixWell: "Fix the well",
+    cousin: "cousin",
+    arrives: [" knocks at the gate of ", " asking for a night of shelter.", ""],
+    staysText: [" stays and starts helping in the garden.", ""],
+    goesText: [" packs up and goes down the road.", ""],
+    dryText: [" wakes up and the bucket comes back empty from the well.", ""],
+    fixedText: [" goes down the well on a rope and frees the pump. ", " says thanks with a plate of food.", ""],
+    carriedText: [" spends the week carrying water from the river and hurts their back.", ""]
+  })
+};
+
+// src/bench/locale.ts
+var EN = {
+  group: "Stories",
+  name: "Stories area",
+  controls: { seed: "Seed", day: "Day", life: "Life simulation", infection: "Bites and the turned", person: "Sheet of", next_day: "Next day", reset: "Start again" },
+  hints: {
+    seed: "The world drawn again: who plays each role, their names and every chance of the life simulation.",
+    day: "The world runs to this day; the sheet and the chronicle show it.",
+    life: "Off, only the stories happen; on, people also get hurt, fall in love, have children, fight, betray, trade and arrive.",
+    infection: "The apocalypse layer of the life simulation: a run can end in a bite, and a bite turns in two days. Off by default: a normal world.",
+    person: "Whose sheet the panel shows.",
+    action: "A player action: the stories read it from its day on."
+  },
+  metrics: { day: "Day", people: "People", living: "Living", dead: "Dead", births: "Births", arrivals: "Arrivals", lines: "Chronicle lines", last: "Last line" },
+  scenarios: {
+    determinism: "The same seed, the same chronicle",
+    casting: "Another seed casts other names",
+    normal_world: "A normal world: nobody is bitten",
+    sheet_keeps: "The sheet keeps the stories the person lived",
+    point_buy: "Point buy: 14 points, the profession and traits",
+    crossing: "An action in one story changes another"
+  },
+  sheet: { kicker: "Character sheet", state: "State", base: "Lives at", age: "Age", profession: "Profession", pool: "Points left", lived: "Lived", none: "Nothing yet", day: "Day" },
+  states: { ok: "well", hurt: "hurt", bitten: "bitten", undead: "turned", dead: "dead", missing: "missing", party: "with the player", hostile: "hostile", moved: "moved", left: "left", unborn: "not born yet" },
+  derived: { health: "Max health", stamina: "Stamina", carry: "Max load (kg)", run_speed: "Running speed (m/s)", detection: "Detection radius (m)", noise: "Footstep noise (%)", learning: "Learning speed (%)", composure: "Composure", melee: "Melee damage (%)" }
+};
+var PT_BR = {
+  group: "Hist\xF3rias",
+  name: "\xC1rea das hist\xF3rias",
+  controls: { seed: "Semente", day: "Dia", life: "Vida sorteada", infection: "Mordidas e reanimados", person: "Ficha de", next_day: "Pr\xF3ximo dia", reset: "Recome\xE7ar" },
+  hints: {
+    seed: "O mundo sorteado de novo: quem faz cada papel, os nomes e cada chance da vida sorteada.",
+    day: "O mundo corre at\xE9 esse dia; a ficha e a cr\xF4nica mostram.",
+    life: "Desligada, s\xF3 as hist\xF3rias acontecem; ligada, as pessoas tamb\xE9m se ferem, se apaixonam, t\xEAm filhos, brigam, traem, trocam e chegam.",
+    infection: "A camada do apocalipse na vida sorteada: uma sa\xEDda pode acabar em mordida, e a mordida reanima em dois dias. Desligada por padr\xE3o: mundo normal.",
+    person: "De quem \xE9 a ficha no painel.",
+    action: "Uma a\xE7\xE3o do jogador: as hist\xF3rias leem a partir do dia dela."
+  },
+  metrics: { day: "Dia", people: "Pessoas", living: "Vivos", dead: "Mortos", births: "Nascimentos", arrivals: "Chegadas", lines: "Linhas da cr\xF4nica", last: "\xDAltima linha" },
+  scenarios: {
+    determinism: "A mesma semente, a mesma cr\xF4nica",
+    casting: "Outra semente escala outros nomes",
+    normal_world: "Mundo normal: ningu\xE9m \xE9 mordido",
+    sheet_keeps: "A ficha guarda as hist\xF3rias que a pessoa viveu",
+    point_buy: "Compra de pontos: 14 pontos, a profiss\xE3o e os tra\xE7os",
+    crossing: "Uma a\xE7\xE3o numa hist\xF3ria muda outra"
+  },
+  sheet: { kicker: "Ficha do personagem", state: "Estado", base: "Mora em", age: "Idade", profession: "Profiss\xE3o", pool: "Pontos livres", lived: "Viveu", none: "Nada ainda", day: "Dia" },
+  states: { ok: "vivo", hurt: "ferido", bitten: "mordido", undead: "zumbi nomeado", dead: "morto", missing: "sumido", party: "com o jogador", hostile: "hostil", moved: "mudou de base", left: "saiu do vale", unborn: "ainda n\xE3o nasceu" },
+  derived: { health: "Vida m\xE1xima", stamina: "F\xF4lego", carry: "Carga m\xE1xima (kg)", run_speed: "Velocidade de corrida (m/s)", detection: "Raio de detec\xE7\xE3o (m)", noise: "Ru\xEDdo dos passos (%)", learning: "Velocidade de aprendizado (%)", composure: "Compostura", melee: "Dano corpo a corpo (%)" }
+};
+var TEXT = { en: EN, "pt-BR": PT_BR };
+var storiesBenchTextOf = (locale) => TEXT[locale] ?? PT_BR;
+
+// src/bench/module.ts
+var defaultProfessionName = (professionId, language) => getProfession(professionId)?.name[language === "en" ? "en" : "pt-BR"];
+var STORIES_AREA_ID = "stories_area";
+var MAX_DAYS = 365;
+var actionControl = (id) => `act_${id.toLowerCase().replace(/[^a-z0-9]+/g, "_")}`;
+function createStoriesTestModule(options = {}) {
+  const locale = options.locale ?? "pt-BR";
+  const ruleset = options.ruleset ?? SHEET_RULESET3;
+  const names = options.names ?? getNamePools2(locale);
+  const text = storiesBenchTextOf(locale);
+  let content2 = options.content ?? STORIES_EXAMPLE[locale === "en" ? "en" : "pt-BR"];
+  const settings = { seed: options.seed ?? 1, day: Math.min(30, content2.days ?? 90), life: true, infection: false, person: "" };
+  let actions = {};
+  let host = null;
+  const worldOptions = (seed, withLife, infection, acts) => {
+    const life = withLife && content2.life ? { ...content2.life, numbers: { ...content2.life.numbers, infection } } : void 0;
+    return {
+      names,
+      ruleset,
+      stories: content2.stories,
+      ...content2.people ? { people: content2.people } : {},
+      seed,
+      ...life ? { life } : {},
+      ...life && content2.fill ? { fill: content2.fill } : {},
+      ...content2.playerBase ? { playerBase: content2.playerBase } : {},
+      actions: acts,
+      locale
+    };
+  };
+  const run = (seed, day, withLife = settings.life, infection = settings.infection, acts = actions) => {
+    const made = createStoryWorld(worldOptions(seed, withLife, infection, acts));
+    made.runTo(day);
+    return made;
+  };
+  let world = run(settings.seed, settings.day);
+  const personOptions = () => world.people().filter((p) => !p.extra || world.states[p.id]?.state !== "unborn").map((p) => ({ id: p.id, name: p.name }));
+  const groupName = (base) => content2.life?.groups[base]?.name ?? base;
+  const showSheet = () => {
+    if (!host?.bench?.sheet) return;
+    const id = settings.person && world.person(settings.person) ? settings.person : personOptions()[0]?.id ?? "";
+    const person = world.person(id);
+    if (!person) {
+      host.bench.sheet(null);
+      return;
+    }
+    const sheet = world.sheet(id);
+    const derived = sheet.derived();
+    const state = world.states[id];
+    const lived = world.chronicle.about(id);
+    const card = {
+      kicker: `${text.sheet.kicker} \xB7 ${text.sheet.day} ${world.day}`,
+      title: person.name,
+      ...state?.note ? { body: state.note } : {},
+      facts: [
+        { label: text.sheet.state, value: state ? text.states[state.state] : "" },
+        { label: text.sheet.base, value: state ? groupName(state.base) : "" },
+        ...person.age !== void 0 ? [{ label: text.sheet.age, value: String(person.age) }] : [],
+        { label: text.sheet.profession, value: (options.professionName ?? defaultProfessionName)(sheet.profession, locale === "en" ? "en" : "pt-BR") ?? sheet.profession },
+        { label: text.sheet.pool, value: String(sheet.pool()) },
+        ...Object.entries(derived).map(([key, value]) => ({ label: text.derived[key] ?? key, value: String(Math.round(value * 100) / 100) }))
+      ],
+      steps: lived.length > 0 ? lived.slice(-8).map((entry) => ({ at: `${text.sheet.day} ${entry.day}`, text: `${entry.title}: ${entry.text}` })) : [{ at: "", text: text.sheet.none }]
+    };
+    host.bench.sheet(card);
+  };
+  const rebuild = () => {
+    world = run(settings.seed, settings.day);
+    host?.bench?.patch("person", { options: personOptions(), ...settings.person ? { value: settings.person } : {} });
+    showSheet();
+  };
+  const onChange = (change) => {
+    if (change.kind === "action") {
+      if (change.id === "next_day") {
+        settings.day = Math.min(MAX_DAYS, settings.day + 1);
+        host?.bench?.patch("day", { value: settings.day });
+      } else if (change.id === "reset") actions = {};
+      rebuild();
+      return;
+    }
+    if (change.kind !== "control") return;
+    const { id, value } = change;
+    if (id === "seed" && typeof value === "number") settings.seed = value;
+    else if (id === "day" && typeof value === "number") settings.day = value;
+    else if (id === "life" && typeof value === "boolean") settings.life = value;
+    else if (id === "infection" && typeof value === "boolean") settings.infection = value;
+    else if (id === "person" && typeof value === "string") {
+      settings.person = value;
+      showSheet();
+      return;
+    } else {
+      const act = (content2.actions ?? []).find((a) => actionControl(a.id) === id);
+      if (!act || typeof value !== "boolean") return;
+      if (value) actions = { ...actions, [act.id]: 1 };
+      else {
+        const { [act.id]: _off, ...rest } = actions;
+        void _off;
+        actions = rest;
+      }
+    }
+    rebuild();
+  };
+  const controls = () => {
+    const people = personOptions();
+    return [
+      { kind: "number", id: "seed", name: text.controls.seed, hint: text.hints.seed, min: 1, max: 9999, step: 1, default: settings.seed },
+      { kind: "number", id: "day", name: text.controls.day, hint: text.hints.day, min: 0, max: MAX_DAYS, step: 1, default: settings.day },
+      { kind: "boolean", id: "life", name: text.controls.life, hint: text.hints.life, default: settings.life },
+      { kind: "boolean", id: "infection", name: text.controls.infection, hint: text.hints.infection, default: settings.infection },
+      { kind: "choice", id: "person", name: text.controls.person, hint: text.hints.person, options: people.length > 0 ? people : [{ id: "", name: "-" }], default: people[0]?.id ?? "" },
+      ...(content2.actions ?? []).map((a) => ({ kind: "boolean", id: actionControl(a.id), name: a.name, hint: text.hints.action, default: false })),
+      { kind: "action", id: "next_day", name: text.controls.next_day },
+      { kind: "action", id: "reset", name: text.controls.reset }
+    ];
+  };
+  const count = (states) => Object.values(world.states).filter((s) => states.includes(s.state)).length;
+  const metrics = () => [
+    { id: "current_day", name: text.metrics.day, digits: 0, read: () => world.day },
+    { id: "people", name: text.metrics.people, digits: 0, read: () => world.people().length },
+    { id: "living", name: text.metrics.living, digits: 0, read: () => count(["ok", "hurt", "party", "hostile", "moved"]) },
+    { id: "dead", name: text.metrics.dead, digits: 0, read: () => count(["dead"]) },
+    { id: "births", name: text.metrics.births, digits: 0, read: () => world.life?.stats.births ?? 0 },
+    { id: "arrivals", name: text.metrics.arrivals, digits: 0, read: () => world.life?.stats.arrivals ?? 0 },
+    { id: "lines", name: text.metrics.lines, digits: 0, read: () => world.chronicle.entries.length },
+    { id: "last", name: text.metrics.last, read: () => world.chronicle.entries.at(-1)?.title ?? "" }
+  ];
+  const days = () => content2.days ?? 90;
+  const lines = (made) => made.chronicle.entries.map((e) => `${e.day}|${e.id}|${e.text}`).join("\n");
+  const scenarios = () => [
+    {
+      id: "stories_determinism",
+      name: text.scenarios.determinism,
+      run: ({ expect }) => {
+        const a = lines(run(7, days(), true, false, {}));
+        expect(a === lines(run(7, days(), true, false, {})) && a.length > 0, "the same seed gives the same chronicle");
+      }
+    },
+    {
+      id: "stories_casting",
+      name: text.scenarios.casting,
+      run: ({ expect }) => {
+        const names2 = (seed) => run(seed, 0, false, false, {}).people().map((p) => p.name).join(",");
+        const drawn = new Set([1, 2, 3, 4, 5].map(names2));
+        expect(drawn.size > 1, "five seeds do not all cast the same names", { casts: drawn.size });
+      }
+    },
+    {
+      id: "stories_normal_world",
+      name: text.scenarios.normal_world,
+      run: ({ expect }) => {
+        let bites = 0;
+        for (let seed = 1; seed <= 10; seed++) bites += run(seed, days(), true, false, {}).chronicle.entries.filter((e) => e.kind === "life" && e.changes.some((c) => c.state === "bitten" || c.state === "undead")).length;
+        expect(bites === 0, "ten worlds without the infection layer: no bite, nobody turns", { bites });
+      }
+    },
+    {
+      id: "stories_sheet_keeps",
+      name: text.scenarios.sheet_keeps,
+      run: ({ expect }) => {
+        const made = run(3, days(), false, false, {});
+        const entry = made.chronicle.entries.find((e) => e.kind === "story");
+        const id = entry?.people[0];
+        expect(Boolean(entry && id && made.sheet(id).remembers(entry.id)), "whoever a beat is about keeps it in their sheet", { beat: entry?.id, person: id });
+      }
+    },
+    {
+      id: "stories_point_buy",
+      name: text.scenarios.point_buy,
+      run: ({ expect }) => {
+        const nurse = createSheet({ ruleset, profession: "nurse" });
+        expect(nurse.pool() === 12, "a nurse starts with 14 \u2212 2 = 12 points", { pool: nurse.pool() });
+        const spent = createSheet({ ruleset, profession: "nurse", attributes: { agility: 8 }, traits: ["athlete", "smoker"] });
+        expect(spent.pool() === 6 && spent.valid(), "agility 8 (\u22125), athlete (\u22124), smoker (+3): 6 left", { pool: spent.pool() });
+        const clash = createSheet({ ruleset, traits: ["athlete", "asthmatic"] });
+        expect(!clash.valid(), "athlete and asthmatic exclude each other");
+      }
+    },
+    {
+      id: "stories_crossing",
+      name: text.scenarios.crossing,
+      run: ({ expect }) => {
+        const differ = (content2.actions ?? []).some((a) => lines(run(5, days(), false, false, {})) !== lines(run(5, days(), false, false, { [a.id]: 1 })));
+        expect(differ, "some player action changes the chronicle");
+      }
+    }
+  ];
+  const module = {
+    id: STORIES_AREA_ID,
+    name: text.name,
+    group: text.group,
+    get world() {
+      return world;
+    },
+    load(next) {
+      content2 = next;
+      actions = {};
+      settings.person = "";
+      rebuild();
+    },
+    items: () => [],
+    controls: () => controls(),
+    metrics: () => metrics(),
+    scenarios: () => scenarios(),
+    attach(lent) {
+      host = lent;
+      const off = lent.bench?.onChange(onChange);
+      showSheet();
+      return () => {
+        off?.();
+        host?.bench?.sheet?.(null);
+        host = null;
+      };
+    }
+  };
+  return module;
+}
+
+export {
+  life_default,
+  life_text_default,
+  sheet_default,
+  castStories,
+  createChronicle,
+  holds,
+  FINAL_STATES,
+  applyChanges,
+  setState,
+  fillText,
+  shortName,
+  createLifeWorld,
+  lifeDay,
+  fillWorld,
+  runBeat,
+  createSheet,
+  drawSheet,
+  lifeTextOf,
+  lifeNumbersOf,
+  createStoryWorld,
+  simulateStories,
+  STORIES_EXAMPLE,
+  STORIES_AREA_ID,
+  createStoriesTestModule
+};
+//# sourceMappingURL=chunk-27E2JRXQ.js.map