@adatechnology/game-stories 0.2.8 → 0.3.0

package/dist/testing-ezx8QVeB.d.ts

@@ -0,0 +1,1124 @@
+import { TestableModule } from '@adatechnology/game-contracts';
+
+/** Where a person stands in the world. The kit's ids; a game names them in its own words through the text tables. */
+type StateId = 'ok' | 'hurt' | 'bitten' | 'undead' | 'dead' | 'missing' | 'party' | 'hostile' | 'moved' | 'left' | 'unborn';
+type PersonState = {
+    state: StateId;
+    note: string;
+    base: string;
+};
+/** Every person's state, by id, in the order they came into the world. */
+type States = Record<string, PersonState>;
+/**
+ * A person of the world: someone the game wrote, someone the casting drew from the name pools, or someone the life simulation brought (a
+ * newcomer, a baby). `personality` is courage, empathy, loyalty, greed and stability, 0 to 100 (the Personagens axes).
+ */
+type Person = {
+    readonly id: string;
+    readonly name: string;
+    /** The name the texts use (default: the quoted nickname, else the first name after an honorific). */
+    readonly nick?: string;
+    /** Years; a person without a number counts as `LifeNumbers.unknownAge`. */
+    readonly age?: number;
+    readonly female?: boolean;
+    readonly personality?: readonly number[];
+    /** The base (group) the person lives in. */
+    readonly base: string;
+    /** How the person starts the world (default ok, no note). */
+    readonly start?: {
+        readonly state: StateId;
+        readonly note: string;
+    };
+    /** Not in the pool of people a newcomer is related to (a baby to be born, a group of children). */
+    readonly extra?: boolean;
+    readonly profession?: string;
+    readonly tags?: readonly string[];
+    /** Who the casting or the life simulation made them for, and how. */
+    readonly bond?: string;
+    readonly relation?: string;
+    readonly baby?: boolean;
+    readonly mother?: string;
+    readonly father?: string;
+    /** The role this person was cast for, when the casting made them. */
+    readonly role?: string;
+    /** True for people made during the world (casting, newcomers, babies). */
+    readonly generated?: boolean;
+};
+/** A base: where people live together, with its defence (0 to 1, lowers the daily risk inside) and food in days. */
+type Group = {
+    readonly name: string;
+    readonly defence: number;
+    readonly food: number;
+};
+/** A relation the world starts with: the two people, the kind (`LifeNumbers.affinity` keys) and a note. */
+type Relation = readonly [a: string, b: string, kind: string, note?: string];
+/** The player's actions so far, by id (an action that was done is truthy). */
+type Actions = Readonly<Record<string, unknown>>;
+/** The flags the stories raised, by id. */
+type Flags = Record<string, unknown>;
+/**
+ * A test on the world, as data: on the states of the people (through their roles), on the flags the stories raised and on the player's actions.
+ * Inside a beat, `value` asks whether a named value is set, `self` whether the person being listed plays that role, and `changed` whether the beat's
+ * changes so far name that role. Inside an `each`, the role `self` is the person being listed.
+ */
+type Condition = {
+    readonly all: readonly Condition[];
+} | {
+    readonly any: readonly Condition[];
+} | {
+    readonly not: Condition;
+} | {
+    readonly action: string;
+} | {
+    readonly flag: string;
+} | {
+    readonly state: string;
+    readonly is: StateId | readonly StateId[];
+} | {
+    readonly living: string;
+} | {
+    readonly base: string;
+    readonly is: string;
+} | {
+    readonly value: string;
+} | {
+    readonly self: string;
+} | {
+    readonly changed: string;
+} | {
+    readonly remembers: string;
+    readonly entry: string;
+};
+/** A piece of a beat's text: plain text, a conditional piece, a named value, the number of the beat's changes, or a person's short name. */
+type TextPart = string | {
+    readonly when: Condition;
+    readonly text: string | readonly TextPart[];
+    readonly else?: string | readonly TextPart[];
+} | {
+    readonly value: string;
+} | {
+    readonly count: 'changes';
+} | {
+    readonly name: string;
+};
+/** A change the beat makes: the role, the new state, the note, and optionally the new base (or the base another role is in now). */
+type Change = {
+    readonly role: string;
+    readonly state: StateId;
+    readonly note: string;
+    readonly base?: string | {
+        readonly baseOf: string;
+    };
+};
+/** A change, a group of changes under a condition, or one change for each of a list of people that pass a test. */
+type ChangeItem = Change | {
+    readonly when: Condition;
+    readonly changes: readonly ChangeItem[];
+} | {
+    readonly each: {
+        readonly roles?: readonly string[];
+        readonly cast?: boolean;
+        readonly where?: Condition;
+        readonly except?: readonly string[];
+    };
+    readonly change: {
+        readonly state: StateId;
+        readonly note: string;
+        readonly base?: string;
+    };
+};
+/** One way a beat can go: the first variant whose `when` holds is taken; `none` means the beat does not happen. */
+type BeatVariant = {
+    readonly when?: Condition;
+    readonly none?: boolean;
+    readonly text?: readonly TextPart[];
+    /** Joins the text parts (default nothing: the parts carry their own spaces). */
+    readonly join?: string;
+    readonly changes?: readonly ChangeItem[];
+    readonly flags?: Readonly<Record<string, unknown>>;
+    /** The other path: the one a player action opened (the team's `alt`). */
+    readonly alt?: boolean;
+    /** The beat happens only if it changes someone. */
+    readonly needsChanges?: boolean;
+};
+/** A beat of a story on a day: who it is about, named values, the variants, or a code beat the game registered (`run`). */
+type StoryBeat = {
+    readonly id: string;
+    readonly day: number;
+    readonly title: string;
+    /** The roles the beat is about (the team's `who`): they are held out of the life simulation's risks for the week before it. */
+    readonly roles: readonly string[];
+    readonly values?: Readonly<Record<string, readonly {
+        readonly when?: Condition;
+        readonly value: string;
+    }[]>>;
+    readonly variants?: readonly BeatVariant[];
+    readonly run?: string;
+};
+/** A role a story needs: a person the game names (`person`), or one the casting draws, from the people or the name pools. */
+type Role = {
+    readonly id: string;
+    readonly person?: string;
+    readonly tags?: readonly string[];
+    readonly needs?: {
+        readonly age?: readonly [number, number];
+        readonly sex?: 'f' | 'm';
+        readonly profession?: readonly string[];
+        readonly base?: string;
+        readonly tags?: readonly string[];
+    };
+    /** Made for someone already cast: their kinship word, the same surname, the same base. */
+    readonly bond?: {
+        readonly role: string;
+        readonly relation?: string;
+        readonly sameSurname?: boolean;
+        readonly sameBase?: boolean;
+    };
+    /** Never drawn from the people: always a new person from the name pools. */
+    readonly create?: boolean;
+};
+/** A story: its roles, its beats and the stories it crosses (they share roles and flags). */
+type Story = {
+    readonly id: string;
+    readonly roles: readonly Role[];
+    readonly beats: readonly StoryBeat[];
+    readonly crosses?: readonly string[];
+    readonly example?: boolean;
+};
+/** What a code beat sees and gives back: the states, the actions, the flags; null when it does not happen. */
+type CodeBeat = (context: {
+    readonly states: States;
+    readonly actions: Actions;
+    readonly flags: Flags;
+    readonly cast: (role: string) => string;
+}) => BeatOutcome | null;
+type BeatOutcome = {
+    readonly text: string;
+    readonly alt?: boolean;
+    readonly changes?: readonly ResolvedChange[];
+    readonly flags?: Readonly<Record<string, unknown>>;
+};
+/** A change on a person (the role already resolved). */
+type ResolvedChange = {
+    readonly id: string;
+    readonly state: StateId;
+    readonly note: string;
+    readonly base?: string;
+};
+/** One line of the chronicle: a story beat or a rule of the life simulation, its text and what it changed. */
+type ChronicleEntry = {
+    readonly day: number;
+    readonly kind: 'story' | 'life';
+    /** The beat id, or the life rule (`risk`, `bond`, `birth`...). */
+    readonly id: string;
+    readonly title: string;
+    readonly text: string;
+    readonly alt?: boolean;
+    readonly changes: readonly ResolvedChange[];
+    /** The people it is about (the beat's cast, or who the rule touched). */
+    readonly people: readonly string[];
+    /** The life rules mark the base whose news it is (none for comings and goings). */
+    readonly base?: string;
+};
+
+var sources$2 = {
+	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·8) days, a bite turns in 2, the missing come back in 2 + floor(R·5) 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), ×(1 - defence), ×1.5 under 2 days of food, ×2 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)·3; 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·5)), < 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 ±0.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·42); personality 20 + R·70 (greed 10 + R·70); the bond from 16 years; affinity 75; 20% a partner (age max(18, age + floor(R·9) - 4)), 35% pregnant if up to 42, due in 10 + floor(R·30)",
+	fill: "simulate() O.fill, lines 746-749: up to 8 per base, age 18 + floor(R·40), personality 20 + R·70",
+	infection: "the bitten band and the turn are the apocalypse layer: off by default (normal world first), the bitten band then hurts"
+};
+var unknownAge = 8;
+var livingStates = [
+	"ok",
+	"hurt",
+	"party",
+	"hostile",
+	"moved"
+];
+var activeStates = [
+	"ok",
+	"hurt",
+	"moved",
+	"hostile"
+];
+var affinity = {
+	family: 80,
+	trust: 60,
+	hatred: -60,
+	secret: 10,
+	fear: -20
+};
+var rivalKind = "hatred";
+var unknownAffinity = {
+	base: 10,
+	divisor: 5
+};
+var clocks = {
+	healBase: 3,
+	healSpread: 8,
+	turnDays: 2,
+	backBase: 2,
+	backSpread: 5,
+	backChance: 0.6
+};
+var birth = {
+	motherWithMidwife: 0.03,
+	motherAlone: 0.15,
+	babyWithMidwife: 0.05,
+	babyAlone: 0.2,
+	girl: 0.5
+};
+var risk = {
+	defaultPlace: 0.006,
+	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
+	}
+};
+var 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
+};
+var betrayal = {
+	loyaltyBelow: 35,
+	greedAbove: 60,
+	foodBelow: 5,
+	chance: 0.03,
+	takes: 4,
+	affinity: -40
+};
+var food = {
+	drift: -0.11,
+	max: 60
+};
+var caravan = {
+	below: 5,
+	hostAbove: 12,
+	affinity: 55,
+	chance: 0.12,
+	carries: 5,
+	bond: 10,
+	hurtChance: 0.08,
+	healDays: 4
+};
+var 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
+};
+var 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
+};
+var fill = {
+	perBase: 8,
+	ageBase: 18,
+	ageSpread: 40
+};
+var personality = {
+	base: 20,
+	spread: 70,
+	greedBase: 10
+};
+var infection = false;
+var lifeNumbers = {
+	sources: sources$2,
+	unknownAge: unknownAge,
+	livingStates: livingStates,
+	activeStates: activeStates,
+	affinity: affinity,
+	rivalKind: rivalKind,
+	unknownAffinity: unknownAffinity,
+	clocks: clocks,
+	birth: birth,
+	risk: risk,
+	bonds: bonds,
+	betrayal: betrayal,
+	food: food,
+	caravan: caravan,
+	raid: raid,
+	arrivals: arrivals,
+	fill: fill,
+	personality: personality,
+	infection: infection
+};
+
+var sources$1 = {
+	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"
+};
+var 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"
+	]
+};
+var lifeText = {
+	sources: sources$1,
+	"pt-BR": {
+	titles: {
+		turn: "Reanima",
+		back: "Volta",
+		lost: "Sem volta",
+		birth: "Nascimento",
+		risk: "Risco",
+		bond: "Laço",
+		pregnancy: "Gravidez",
+		adoption: "Adoção",
+		rivalry: "Rixa",
+		fight: "Briga",
+		betrayal: "Traição",
+		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ém-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ão voltou",
+		missing_out: "sumiu numa saída",
+		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ão, magro e sem as botas, depois de dias sumido.",
+		lost: "Acham as coisas de {name} numa vala da estrada.{loss}",
+		birth: "{name} dá à luz em {place}{help}.",
+		birth_help: " com ajuda de quem sabe",
+		birth_alone: ", sem ninguém que saiba fazer parto",
+		baby_dies: " O bebê não respira. Enterram ao lado da base.",
+		baby_born: " Nasce {baby}.",
+		mother_dies: "{loss} {name} não resiste ao parto.",
+		risk_hurt: "{name} volta ferid{o} de uma saída perto de {place}.",
+		risk_bitten: "{name} volta com uma mordida no antebraço e não conta a ninguém.",
+		risk_dead: "{name} não volta de uma saída perto de {place}.{loss}",
+		risk_missing: "{name} some numa saída perto de {place}.",
+		couple: "{a} e {b} {line}.",
+		pregnancy: "{a} e {b} vão ter um bebê. 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átio.",
+		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ádio de {from}. Dias depois é visto em {to}.",
+		caravan: "Caravana: {carrier} atravessa a cidade com comida de {from} para {to}, onde mora {host}.",
+		caravan_hurt: " Na volta, {carrier} é 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ó ferid{o}.",
+		raid_dead: "{loss} {victim} morre na porta.",
+		raid_grazed: " {victim} leva um tiro de raspão.",
+		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á com o jogador. Fica em {base} esperando.",
+		arrival_found: " Encontra {bond} em {base} e fica.",
+		arrival_elsewhere: " Descobre que {bond} está em {where} e prefere ficar em {base}.",
+		arrival_pair_pregnant: " Vem com {pair}, e {mother} está grávida.",
+		arrival_pair: " Vem com {pair}."
+	},
+	pools: {
+		couple: [
+			"começam a dividir o turno de vigia, e depois o colchão",
+			"se beijam no telhado durante a rádio das 20h",
+			"assumem o namoro na frente da base inteira"
+		],
+		rivalry: [
+			"brigam pela última lata de sardinha",
+			"discutem aos gritos sobre quem dorme perto da porta",
+			"se acusam de roubar ração"
+		]
+	},
+	fates: {
+		dead: "morreu",
+		undead: "virou um dos mortos",
+		left: "saiu do vale no ônibus",
+		missing: "sumiu",
+		bitten: "foi mordido",
+		other: "não está 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ão",
+		"Major"
+	]
+},
+	en: en
+};
+
+type Numbers = Omit<typeof lifeNumbers, 'sources' | 'livingStates' | 'activeStates' | 'infection'>;
+/** Every number of the life simulation (`data/life.json`, each with its source line). */
+type LifeNumbers = Numbers & {
+    readonly livingStates: readonly StateId[];
+    readonly activeStates: readonly StateId[];
+    readonly infection: boolean;
+};
+type DeepPartial<T> = {
+    [K in keyof T]?: T[K] extends readonly unknown[] ? T[K] : T[K] extends object ? DeepPartial<T[K]> : T[K];
+};
+type LifeNumbersPatch = DeepPartial<LifeNumbers>;
+/** The texts of the life simulation in one language (`data/life-text.json`). */
+type LifeText = (typeof lifeText)['pt-BR'];
+type LifeTextPatch = {
+    [K in keyof LifeText]?: Partial<LifeText[K]>;
+};
+/** A rule of the life simulation: what each chronicle line of the simulation is. */
+type LifeRule = keyof LifeText['titles'];
+/**
+ * What a game tells the life simulation about its world. All of it is optional: without places, exposure, raids or origins the simulation runs on the
+ * defaults (a normal world: no bites, no raids unless the game lists them).
+ */
+type LifeOptions = {
+    readonly numbers?: LifeNumbersPatch;
+    readonly text?: LifeTextPatch;
+    /** The bases people live in (the team's `GROUPS`). The nomads' base is one of them. */
+    readonly groups: Readonly<Record<string, Group>>;
+    /** The relations the world starts with (`RELS`); `kind` is a key of `numbers.affinity`. */
+    readonly relations?: readonly Relation[];
+    /** Couples the world starts with. */
+    readonly couples?: readonly (readonly [string, string])[];
+    /** Couples a flag forms (the team's `F.casalRT`), when neither has a partner. */
+    readonly flagCouples?: readonly {
+        readonly flag: string;
+        readonly a: string;
+        readonly b: string;
+    }[];
+    /** The daily risk of each base (`REG`); others take `numbers.risk.defaultPlace`. */
+    readonly placeRisk?: Readonly<Record<string, number>>;
+    /** How much each person goes out (`EXPO`); others take `numbers.risk.defaultExposure`. */
+    readonly exposure?: Readonly<Record<string, number>>;
+    /** Flags that multiply everyone's risk (the team's `F.radioMuda ? 1.3 : 1`). */
+    readonly riskFlags?: Readonly<Record<string, number>>;
+    /** Bases nobody moves to or trades with: always (`true`) or while a condition holds (`HOSTB`). */
+    readonly hostileBases?: Readonly<Record<string, true | Condition>>;
+    /** Bases nobody is sent to by the simulation (besides the nomads' own). */
+    readonly closedBases?: readonly string[];
+    /** Bases a raid never targets. */
+    readonly raidImmune?: readonly string[];
+    readonly nomadBase?: string;
+    /** The base of the people who are with the player (`grupo` → `jogador`). */
+    readonly playerBase?: string;
+    /** The people whose presence at a base makes a birth safe. */
+    readonly midwives?: readonly string[];
+    /** People kept out of the daily risk until a day (the team's `id === 'taina' && d < 38`). */
+    readonly anchors?: readonly {
+        readonly id: string;
+        readonly beforeDay: number;
+    }[];
+    /** People who stand for orphans a couple can adopt, with the words the text uses for one of them. */
+    readonly orphans?: Readonly<Record<string, string>>;
+    /** Each base's daily food change instead of `numbers.food.drift`; `{ flag, value }` applies while the flag is set. */
+    readonly foodDrift?: Readonly<Record<string, number | {
+        readonly flag: string;
+        readonly value: number;
+    }>>;
+    /** Where a traitor goes: the first whose condition holds and is not their own base; else the nomads. */
+    readonly traitorDestinations?: readonly {
+        readonly base: string;
+        readonly when?: Condition;
+    }[];
+    /** The raiders: from which base, while what holds, and who they are in the text. */
+    readonly raids?: readonly {
+        readonly from: string;
+        readonly when: Condition;
+        readonly who: string;
+    }[];
+    /** Newcomers: the ways in, a note a way in adds while a condition holds, and the announcements. `false` turns arrivals off. */
+    readonly arrivals?: false | {
+        readonly origins?: readonly string[];
+        readonly notes?: readonly {
+            readonly origin: string;
+            readonly when: Condition;
+            readonly text: string;
+        }[];
+        readonly announcements?: readonly {
+            readonly when: Condition;
+            readonly text: string;
+        }[];
+    };
+};
+type LifeStats = {
+    births: number;
+    arrivals: number;
+    deaths: number;
+    couples: number;
+    fights: number;
+    betrayals: number;
+    caravans: number;
+    raids: number;
+    pregnancies: number;
+};
+type LifeTimer = {
+    heal?: number;
+    turn?: number;
+    back?: number;
+    due?: number;
+    father?: string;
+};
+/** The world the life simulation keeps (the team's `W`). */
+type LifeWorld = {
+    readonly raid: Record<string, number>;
+    readonly food: Record<string, number>;
+    readonly defence: Record<string, number>;
+    readonly affinity: Record<string, number>;
+    readonly partner: Record<string, string>;
+    readonly rival: Record<string, 1>;
+    readonly adopted: Record<string, 1>;
+    readonly timers: Record<string, LifeTimer>;
+    /** The people the simulation made (newcomers, babies, the fill), by id. */
+    readonly made: Record<string, Person>;
+    count: number;
+    readonly lastNews: Record<string, number>;
+    readonly stats: LifeStats;
+    readonly usedNames: Set<string>;
+};
+
+/** A text in each language the content ships (`en` and `pt-BR` in `game-characters-people`). */
+type LocalizedText = Readonly<Record<string, string>>;
+/** The name pools of one language: first names, surnames, babies' names and the kinship words a newcomer is introduced with. */
+type NamePools = {
+    readonly male: readonly string[];
+    readonly female: readonly string[];
+    readonly surnames: readonly string[];
+    readonly babyMale: readonly string[];
+    readonly babyFemale: readonly string[];
+    readonly kinship: {
+        readonly male: readonly string[];
+        readonly female: readonly string[];
+    };
+};
+type SheetAttributeId = 'strength' | 'vigor' | 'agility' | 'perception' | 'intellect' | 'presence';
+type SheetAttribute = {
+    readonly id: SheetAttributeId;
+    readonly key: string;
+    readonly name: LocalizedText;
+    readonly description: LocalizedText;
+};
+type SheetSkillGroup = {
+    readonly id: string;
+    readonly name: LocalizedText;
+    readonly skills: readonly string[];
+};
+/** A skill with what it unlocks at each milestone level (`SheetRuleset.milestoneLevels`). */
+type SheetSkill = {
+    readonly id: string;
+    readonly group: string;
+    readonly name: LocalizedText;
+    readonly milestones: readonly LocalizedText[];
+};
+/** A profession's sheet rule: its points in the point buy (negative costs, positive gives), the starting skill levels, its bonus and kit. */
+type SheetProfession = {
+    readonly id: string;
+    readonly key: string;
+    readonly points: number;
+    readonly skills: Readonly<Record<string, number>>;
+    readonly bonus: LocalizedText;
+    readonly kit: string;
+};
+/** A trait: its cost in the point buy (negative costs points, positive gives them) and the traits it cannot be taken with. */
+type SheetTrait = {
+    readonly id: string;
+    readonly key: string;
+    readonly cost: number;
+    readonly excludes: readonly string[];
+    readonly name: LocalizedText;
+    readonly effect: LocalizedText;
+};
+/** A derived value: `(base + Σ per[attribute]·value + Σ add) · Π mul · scale`, the adds and products of the traits the sheet has, in order. */
+type SheetDerived = {
+    readonly id: string;
+    readonly base: number;
+    readonly per: Readonly<Partial<Record<SheetAttributeId, number>>>;
+    readonly traits: readonly {
+        readonly trait: string;
+        readonly add?: number;
+        readonly mul?: number;
+    }[];
+    readonly scale?: number;
+    readonly unit?: string;
+    readonly name: LocalizedText;
+    readonly source: string;
+};
+type SheetRuleset = {
+    readonly pointBuy: {
+        readonly start: number;
+        readonly pool: number;
+        readonly min: number;
+        readonly max: number;
+    };
+    readonly milestoneLevels: readonly number[];
+    readonly attributes: readonly SheetAttribute[];
+    readonly skillGroups: readonly SheetSkillGroup[];
+    readonly skills: readonly SheetSkill[];
+    readonly professions: readonly SheetProfession[];
+    readonly traits: readonly SheetTrait[];
+    readonly derived: readonly SheetDerived[];
+};
+
+/** Who plays each role, and everyone in the world after the casting (the people given, then the people it made). */
+type Casting = {
+    readonly roles: Readonly<Record<string, string>>;
+    readonly people: readonly Person[];
+    /** The role of a person the casting made, or the first role a given person plays. */
+    readonly roleOf: (id: string) => string | undefined;
+};
+type CastOptions = {
+    readonly stories: readonly Story[];
+    readonly people?: readonly Person[];
+    readonly names: NamePools;
+    readonly random: () => number;
+    /** The base of a made person whose role names none and has no bond (default the first base of a given person, else 'nomad'). */
+    readonly defaultBase?: string;
+};
+/**
+ * Casts every story's roles at the world's creation (decision P9: who plays each role is drawn, so every game is different). A role the game pins
+ * (`person`) is that person; another is drawn among the people not cast yet who fit its needs; with none (or `create`), a new person is made from the
+ * name pools: the sex and age the role needs (else drawn as a newcomer's: half and half, 18 + 0..41 years), the bond's surname and base when the role
+ * asks, the newcomer's personality draw. Roles with the same id in two stories are the same person: that is how stories cross.
+ */
+declare function castStories(options: CastOptions): Casting;
+
+/** The world's chronicle: every story beat and every rule of the life simulation that happened, in order. */
+type Chronicle = {
+    readonly entries: readonly ChronicleEntry[];
+    add(entry: ChronicleEntry): void;
+    /** The lines of one day. */
+    onDay(day: number): readonly ChronicleEntry[];
+    /** The lines about a person: those that name them or change them. */
+    about(id: string): readonly ChronicleEntry[];
+    /** The lines up to a day. */
+    until(day: number): readonly ChronicleEntry[];
+    /** Follows the new lines. Returns the unsubscribe function. */
+    on(listener: (entry: ChronicleEntry) => void): () => void;
+};
+declare function createChronicle(): Chronicle;
+
+var sources = {
+	page: "site/pages/zumbis-personagens/personagens.html, \"Memória e opinião\" and \"Modelo de dados\"",
+	memories: "\"Cada NPC guarda até 30 lembranças com peso e data\"; memorias: [{ evento, alvoId, peso, dia }] // máx 30",
+	opinion: "\"A opinião sobre cada jogador vai de −100 a +100 e decai devagar para o neutro. Em +60 o NPC aceita entrar no grupo; abaixo de −60 pode roubar, delatar a base a outro grupo ou atacar à 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"
+};
+var memories = {
+	max: 30
+};
+var opinion = {
+	min: -100,
+	max: 100,
+	joins: 60,
+	hostile: -60,
+	decayPerDay: 1
+};
+var sheetNumbers = {
+	sources: sources,
+	memories: memories,
+	opinion: opinion
+};
+
+type SheetNumbers = Omit<typeof sheetNumbers, 'sources'>;
+/** One thing the person lived: a decision, a story beat, an event of the world. Every one is kept (P13). */
+type SheetEntry = {
+    readonly kind: 'decision' | 'story' | 'event';
+    readonly id: string;
+    readonly day: number;
+    readonly weight?: number;
+    readonly about?: string;
+};
+/** A memory (Personagens "Memória e opinião"): what happened, about whom, how much it weighs and when. */
+type Memory = {
+    readonly id: string;
+    readonly about?: string;
+    readonly weight: number;
+    readonly day: number;
+};
+type SheetInput = {
+    readonly profession?: string;
+    readonly attributes?: Partial<Record<SheetAttributeId, number>>;
+    readonly traits?: readonly string[];
+    readonly personality?: readonly number[];
+    readonly skills?: Readonly<Record<string, number>>;
+};
+type CharacterSheet = {
+    readonly profession: string;
+    readonly attributes: Readonly<Record<SheetAttributeId, number>>;
+    readonly traits: readonly string[];
+    /** Skill levels: the profession's start, plus what was given. */
+    readonly skills: Readonly<Record<string, number>>;
+    /** The milestones reached at the current skill levels. */
+    milestones(skill: string): readonly number[];
+    /** Points left in the point buy (Personagens `pool()`): base + profession + traits − spent. Negative means the sheet is over budget. */
+    pool(): number;
+    /** Whether the sheet follows the point buy (attributes in range, points not over, no excluded traits together). */
+    valid(): boolean;
+    /** Every derived value of the ruleset (`derived()`), by id. */
+    derived(): Readonly<Record<string, number>>;
+    /** Courage, empathy, loyalty, greed, stability, 0..100. */
+    readonly personality: readonly number[];
+    readonly memories: readonly Memory[];
+    /** What this person thinks of others, −100..100. */
+    readonly opinions: Readonly<Record<string, number>>;
+    /** Everything the person lived, in order. */
+    readonly history: readonly SheetEntry[];
+    /** Keeps an entry; one with a weight is also a memory (the lightest, then the oldest, goes past the limit). */
+    record(entry: SheetEntry): void;
+    /** Whether the person lived this entry id. */
+    remembers(id: string): boolean;
+    /** Moves the opinion of someone by `delta`, inside −100..100. */
+    opine(about: string, delta: number): number;
+    /** The opinions decay towards neutral by `days` (Personagens: "decai devagar para o neutro"). */
+    decay(days: number): void;
+    /** What the opinion means: joins the group at +60, may rob, betray or attack below −60. */
+    stance(about: string): 'joins' | 'hostile' | 'neutral';
+};
+/** `ruleset` is content: `SHEET_RULESET` of `game-characters-people`, or `defaultStoryContent().ruleset` of `game-kit-defaults`. Default `SHEET_RULESET`; the default is deprecated and removed in the next major. */
+type SheetOptions = SheetInput & {
+    readonly ruleset?: SheetRuleset;
+    readonly numbers?: Partial<SheetNumbers>;
+};
+/** A character sheet on a ruleset (the Personagens one is `SHEET_RULESET` of `game-characters-people`), with the memory and opinion rules of the document. */
+declare function createSheet(options?: SheetOptions): CharacterSheet;
+/**
+ * A sheet drawn at a person's creation (P13: drawn on creation): the person's profession or one drawn, the pool spent one point at a time on an
+ * attribute drawn among those under the maximum. No traits unless given.
+ */
+declare function drawSheet(random: () => number, input?: SheetInput & {
+    readonly ruleset?: SheetRuleset;
+}): CharacterSheet;
+
+type StoryWorldOptions = {
+    readonly stories?: readonly Story[];
+    /** The people the game wrote, in order (named people first; `extra` ones are left out of the newcomers' bonds). */
+    readonly people?: readonly Person[];
+    /** The name pools of the language (`getNamePools` of `game-characters-people`, or `defaultStoryContent(locale).names` of `game-kit-defaults`). Default `getNamePools(locale)`; the default is deprecated and removed in the next major. */
+    readonly names?: NamePools;
+    /** The character sheet ruleset (`SHEET_RULESET` of `game-characters-people`, or `defaultStoryContent().ruleset`). Default `SHEET_RULESET`; the default is deprecated and removed in the next major. */
+    readonly ruleset?: SheetRuleset;
+    /** The seed of the world's stream (default 1). The life simulation draws from it as the team's page draws from `rng(seed)`. */
+    readonly seed?: number;
+    /** The life simulation's own stream, instead of `createRng(seed)` (a game with one stream for everything passes it). */
+    readonly random?: () => number;
+    /** The life simulation; without it only the stories happen (the team's page without "vale vivo"). */
+    readonly life?: LifeOptions;
+    /** Fills the world with ordinary people up to this many living ones (the team's `fill`). Needs `life`. */
+    readonly fill?: number;
+    /** Code beats the game registers, by id (a beat with `run`). */
+    readonly codeBeats?: Readonly<Record<string, CodeBeat>>;
+    /** The base of the people who join the player (default the life simulation's `playerBase`, else 'player'). */
+    readonly playerBase?: string;
+    /** The player's actions at the start (more come through `act`). */
+    readonly actions?: Actions;
+    readonly locale?: string;
+};
+type StoryWorld = {
+    readonly states: States;
+    readonly flags: Flags;
+    readonly actions: Actions;
+    readonly casting: Casting;
+    readonly chronicle: Chronicle;
+    /** The life simulation's world (food, affinities, partners, the people it made), or null without `life`. */
+    readonly life: LifeWorld | null;
+    /** The last day run (0 before the first). */
+    readonly day: number;
+    /** The person, given, cast or made by the life simulation. */
+    person(id: string): Person | undefined;
+    /** Everyone, in the order they came into the world. */
+    people(): readonly Person[];
+    /** The short name the texts use. */
+    nameOf(id: string): string;
+    /** The person who plays a role. */
+    cast(role: string): string;
+    /** A player action: from now on the stories see it. */
+    act(id: string): void;
+    /** Runs the next day: that day's beats of every story, in order, then a day of the life simulation. */
+    advance(): void;
+    /** Runs days up to `day`. */
+    runTo(day: number): void;
+    /** The person's sheet (drawn on first ask from the person's own stream: the same world, the same sheet). */
+    sheet(id: string): CharacterSheet;
+};
+/** The text table of a locale with a game's patch over it. */
+declare const lifeTextOf: (locale: string, patch?: LifeOptions["text"]) => LifeText;
+/** The life numbers with a game's patch over them. */
+declare const lifeNumbersOf: (patch?: LifeOptions["numbers"]) => LifeNumbers;
+/**
+ * A world of stories (Os Vivos do Vale `simulate`, lines 744-756, made generic): the stories cast at creation, then day by day every story's beats of
+ * that day in order (each beat's changes applied, its flags raised, its line in the chronicle) and a day of the life simulation. What each person
+ * lived goes into their sheet, so the next stories can read it.
+ */
+declare function createStoryWorld(options?: StoryWorldOptions): StoryWorld;
+/** Runs a world `days` days (the team's `simulate(day, A, O)`). */
+declare function simulateStories(days: number, options?: StoryWorldOptions): StoryWorld;
+
+/** What the bench runs: people, stories, the player's actions it offers and the life simulation. */
+type StoriesContent = {
+    readonly people?: readonly Person[];
+    readonly stories: readonly Story[];
+    readonly actions?: readonly {
+        readonly id: string;
+        readonly name: string;
+    }[];
+    readonly life?: LifeOptions;
+    readonly fill?: number;
+    readonly playerBase?: string;
+    /** How many days the scenarios run (default 90). */
+    readonly days?: number;
+    /** The kit's own example content (not a game's). */
+    readonly example?: boolean;
+};
+/** The content packs the bench runs on: the name pools and the sheet ruleset, and how a profession is called (`defaultStoryContent` of `game-kit-defaults` has the kit's own). */
+type StoriesTestModuleOptions = {
+    readonly names?: NamePools;
+    readonly ruleset?: SheetRuleset;
+    /** The name of a profession in the language; default its id. */
+    readonly professionName?: (professionId: string, locale: string) => string | undefined;
+    readonly content?: StoriesContent;
+    readonly locale?: string;
+    readonly seed?: number;
+};
+interface StoriesScenarioLike {
+    expect(condition: boolean, label: string, data?: Record<string, unknown>): void;
+}
+type StoriesTestModule = TestableModule<StoriesScenarioLike> & {
+    /** The world as the bench left it (seed, day, actions). */
+    readonly world: StoryWorld;
+    /** Swaps the content (a game's stories, the zombiada slice) and starts again. */
+    load(content: StoriesContent): void;
+};
+declare const STORIES_AREA_ID = "stories_area";
+/**
+ * The stories area of a test room, against the generic contracts only, with no 3D: the seed and the day slider run a world of stories, the chronicle
+ * of the day and one person's character sheet go to the host's sheet panel. The player's actions are switches. The kit ships two tiny example stories
+ * (marked `example`); `load` takes a game's own content.
+ */
+declare function createStoriesTestModule(options?: StoriesTestModuleOptions): StoriesTestModule;
+
+declare const STORIES_EXAMPLE: Readonly<Record<'pt-BR' | 'en', StoriesContent>>;
+
+export { type StoryWorldOptions as $, type Actions as A, type BeatOutcome as B, type Condition as C, type SheetAttributeId as D, type SheetDerived as E, type Flags as F, type Group as G, type SheetEntry as H, type SheetInput as I, type SheetNumbers as J, type SheetOptions as K, type LifeOptions as L, type Memory as M, type NamePools as N, type SheetProfession as O, type Person as P, type SheetRuleset as Q, type ResolvedChange as R, type States as S, type SheetSkill as T, type SheetSkillGroup as U, type SheetTrait as V, type StoriesContent as W, type StoriesTestModule as X, type StoriesTestModuleOptions as Y, type Story as Z, type StoryWorld as _, type StateId as a, type TextPart as a0, castStories as a1, createChronicle as a2, createSheet as a3, createStoriesTestModule as a4, createStoryWorld as a5, drawSheet as a6, lifeNumbersOf as a7, lifeTextOf as a8, simulateStories as a9, type CodeBeat as b, type StoryBeat as c, type LifeNumbers as d, type LifeWorld as e, type LifeText as f, type ChronicleEntry as g, type BeatVariant as h, type CastOptions as i, type Casting as j, type Change as k, type ChangeItem as l, type CharacterSheet as m, type Chronicle as n, type LifeNumbersPatch as o, type LifeRule as p, type LifeStats as q, type LifeTextPatch as r, type LifeTimer as s, type LocalizedText as t, type PersonState as u, type Relation as v, type Role as w, STORIES_AREA_ID as x, STORIES_EXAMPLE as y, type SheetAttribute as z };