@rpgengine/system-5e 0.0.0-stage → 0.10.0

package/LICENSE.md

@@ -0,0 +1,47 @@
+# The 5e system: license
+
+This package holds material under three licenses. The chapter Combat Encounters in `rules/` is material from the System Reference Document 5.2.1, changed as said below, under the Creative Commons Attribution 4.0 International License (CC-BY-4.0); our changes to it are under the same license. The pages in `world/`, the rules in `rules/`, the game's data in `system.yaml` and `versions/` (its coins, conditions, the length of a round, the titles of its rules, its proficiency table, the names of its skills, how its numbers are worked out, and the uses of features with the rests that bring them back), and the words in `words/` are material from the System Reference Document 5.1, changed as said below, under the Creative Commons Attribution 4.0 International License (CC-BY-4.0); our changes to them are under the same license. The Italian text of the pages and rules in `translations/it/` is material from the official Italian translation of the System Reference Document 5.1, changed as said below, under the same license; our changes to it are under the same license. The icons in `images/` are under the Creative Commons Attribution 3.0 Unported License (CC-BY-3.0). The code (`src/`, built into `dist/`), the instructions in `instructions/`, the scripts in `build/` and the tests are under the MIT license, whose text is below.
+
+This work includes material taken from the System Reference Document 5.1 ("SRD 5.1") by Wizards of the Coast LLC and available at https://dnd.wizards.com/resources/systems-reference-document. The SRD 5.1 is licensed under the Creative Commons Attribution 4.0 International License available at https://creativecommons.org/licenses/by/4.0/legalcode.
+
+The SRD 5.1 notes: "Section 5 of CC-BY-4.0 includes a Disclaimer of Warranties and Limitation of Liability that limits our liability to you."
+
+This work includes material from the System Reference Document 5.2.1 (“SRD 5.2.1”) by Wizards of the Coast LLC, available at https://www.dndbeyond.com/srd. The SRD 5.2.1 is licensed under the Creative Commons Attribution 4.0 International License, available at https://creativecommons.org/licenses/by/4.0/legalcode.
+
+The SRD 5.2.1 notes: "Section 5 of CC-BY-4.0 includes a Disclaimer of Warranties and Limitation of Liability that limits our liability to you."
+
+The Italian words in `words/it.yaml` and the Italian text in `translations/it/` are taken from the official Italian translation of the SRD 5.1 by Wizards of the Coast LLC (https://media.wizards.com/2023/downloads/dnd/SRD_CC_v5.1_IT.pdf), licensed under CC-BY-4.0, which gives this attribution:
+
+Questo lavoro include materiale del System Reference Document 5.1 ("SRD 5.1") di Wizards of the Coast LLC disponibile al sito https://dnd.wizards.com/it/resources/systems-reference-document. L'SRD 5.1 è concesso in licenza sotto l'Attribuzione 4.0 Internazionale di Creative Commons disponibile al sito https://creativecommons.org/licenses/by/4.0/legalcode.it.
+
+The Italian SRD 5.1 notes: "La sezione 5 di CC-BY-4.0 include una Esclusione della garanzia e Limitazione di responsabilità che limita la nostra responsabilità nei tuoi confronti."
+
+Changes: `words/it.yaml` is a table of ours from the English names of this system to the words of the Italian SRD 5.1, for what the dashboard shows; a word that the Italian SRD does not have is ours, and marked as such in the file. Its measures in metres are not taken into the words, which leave measures to the engine.
+
+Changes: the Italian text in `translations/it/` was converted from the PDF into markdown by scripts and split into the pages and chapters of this package as the English text is: each page there holds the name the Italian SRD gives it and the Italian text of the English page of the same file name, while its fields, numbers included, are the English page's; each chapter of `rules/` but Combat Encounters, which the Italian SRD 5.1 lacks, has its Italian text by the same file name. Headings, tables, bold and italics are kept, and the words are unchanged, its measures in metres included, as are the slips of the PDF that change no rule; a header over a group of columns, as the spell slots by level, is given to each of its columns, as in English. Two errors that change a rule are corrected, as the English text has it: «TS Conoscenza» is «TS Costituzione» in Dragonborn's table of draconic ancestry, and the Orb of Dragonkind asks a «prova di Carisma con CD 15», not a saving throw. The conditions Prono, Spaventato, Stordito and Trattenuto, which the Italian SRD's Appendix A lacks, are our translation of the English SRD's, in the Italian SRD's terms. The running heads and footers of the PDF, its title page and its legal notes are left out. The two lines our converters add in English, on starting equipment and on spell lists, are ours in Italian too. The chapters Adventuring and Combat are titled Avventura and Combattimento, the names the Italian SRD gives them where it refers to them (page 2).
+
+The words in the other languages (`words/<code>.yaml`) are our translations of the same list, following the terms of the SRD 5.1's official translation in that language where there is one; they are material adapted from the SRD 5.1, under CC-BY-4.0 as above.
+
+Changes: the material was converted into pages with fields and sections. Names are written in natural order, with the name the SRD gives as an alias when it differs (Leather Armor for "Leather", Hempen Rope for "Rope, hempen (50 feet)", Sledgehammer for "Hammer, sledge", Stone of Good Luck for "Stone of Good Luck (Luckstone)"), a saddle with its kind (Exotic Saddle), and as the stat blocks write them. Units are written without the final period (40 ft, 3 lb). Potion of Healing joins the adventuring gear entry and the magic item, with the gear entry's sentence on drinking it after the magic item's text. A stat block within an item is set off as a quotation.
+
+Ability modifiers, the proficiency bonus, saving throws, skills, initiative, passive Perception, Insight and Investigation, the hit point maximum and the hit dice are written as formulas in `system.yaml`, with what Jack of All Trades, Remarkable Athlete and Aura of Protection add to them; the columns of a class's table become fields of the sheet at the character's level; a spellcasting class's page gives its kind of caster and its save DC, attack and prepared spells as formulas, and the Multiclass Spellcaster table gives the spell slots by caster level; a creature's saving throws and skills read from the totals its stat block lists, and its challenge and experience points are two fields, cr and xp-value; skill names become field names (Sleight of Hand becomes sleight-of-hand). Races and subraces are pages that give their traits as fields where they are numbers or lists, and keep their text; a subrace's Ability Score Increase is titled with its name, such as Ability Score Increase (Hill Dwarf), so that it stands beside its race's. A class page opens with its table, without the label over the spell slot columns; a subclass page names its class and lists its features with the level at which each comes, as its text gives them; the uses of Breath Weapon and Relentless Endurance are counters on their race's page; the Warlock's invocations stand under the feature that names them; the background is Acolyte (background), beside the creature Acolyte, its own parts as sections and the chapter's general text after it; the Feats chapter's text opens the page of Grappler. The spells were converted from the text of the SRD by a script: their fields come from the lines of their header, the spell lists (pages 105–113) become spell-lists, and their text is unchanged, without its italics, with its run-in titles in bold italics and its tables; Antipathy/Sympathy, Blindness/Deafness and Enlarge/Reduce are named with a hyphen for the slash, which a file name cannot hold, and Shield is Shield (spell), beside the item. Each class's spell list (pages 105–113) is a page of its own, such as Wizard Spells, with a section for each level and a link to each spell. The armor, the shield and the weapons of the Armor and Weapons tables (pages 63–66) are pages written by a script from those tables, named in natural order with the SRD's name as an alias (Light Crossbow for "Crossbow, light"): an armor's Armor Class, a shield's bonus, and a weapon's attack and damage are formulas on who wears or wields them, with a magic bonus of 0 that a magic item of the campaign writes; the Strength and Stealth columns are fields; the text of each armor and of the Lance and the Net is the SRD's. The rest of the Equipment chapter (pages 66–74) and the Magic Items chapter (pages 206–253) were converted by scripts from the lines of the PDF, with their fonts and positions. Each piece of adventuring gear, equipment pack, tool, tack and vehicle is a page with the columns of its table as fields (cost, weight, speed), the length its name gives (50 feet for a rope) and the uses of the healer's kit, and as text the description under its run-in title, or its group's (a crystal takes the Arcane Focus's, the keelboat and the rowboat Rowed Vessels'); the row that heads a group in a table gives its rows their category, such as arcane focus, but the disguise kit and the forgery kit, which the PDF indents under Artisan's tools, are tools of their own; the mounts, the trade goods, the expenses and the stabling are in the rules alone. Each magic item is a page with the category, rarity and attunement of its type line as fields, and its text unchanged, with its italics, run-in titles, lists, tables and the stat blocks set in it, such as the Avatar of Death; in the table of the Iron Flask, the PDF's figure dashes are en dashes, as in the other tables. The unarmed strike is a page with the paragraph of Melee Attacks that describes it (page 92), and its attack and damage as formulas; a monk weapon and the unarmed strike roll the Martial Arts die (page 26) when it is larger. The note on creating a character is ours.
+
+The creatures of the Monsters chapter (pages 261–357) and of appendices MM-A and MM-B (pages 366–403), 317 stat blocks, are pages written by a script from the SRD's PDF, with its italics. The lines of a stat block's header are fields: its type line as size, category and alignment, its Armor Class as ac with what follows the number as armor, its hit points as a counter with their dice as hp-dice, each speed and sense as a field of its own, its saving throws, skills, damage and condition lines and languages as lists, and the spell slots of its Spellcasting as counters, such as slots-1; the fields write the minus sign as a hyphen (1d4 - 1). A saving throw or skill with a note keeps its name and total in the field, and the stat block's line, with the note, opens the page: the Shadow's Stealth +4 (+6 in dim light or darkness). Its traits, actions, reactions and legendary actions are sections, each under a heading with its name, without the period after it, and with the SRD's text unchanged, a title in bold within it as the SRD has it. The description that follows a stat block in the appendices opens its page, without the bold that marks the creature's name. Druid is Druid (creature), beside the class, Succubus/Incubus has a hyphen for the slash, and the Unicorn's legendary action Hooves is Hooves (legendary action), beside its action. The variants Diseased Giant Rats and Insect Swarms (pages 378 and 391) are sections of the Giant Rat and of the Swarm of Insects.
+
+Changes: the chapter Combat Encounters in `rules/` is the section Combat Encounters of the SRD 5.2.1's Gameplay Toolbox (pages 202–203), with its Troubleshooting, in markdown, with its table XP Budget per Character and its words unchanged, its headings one level up as for the chapters below; the table's heading Encounter Difficulty over its three columns is left out, and a line of ours at its head says where the chapter comes from. It stands beside the rules of the SRD 5.1, the 2014 rules, whose creatures give their XP by challenge rating as the SRD 5.2.1's do.
+
+The rules in `rules/` but Combat Encounters are the text of the SRD 5.1 in markdown, with its headings, tables, bold and italics, and its words unchanged: a heading is one level below the nearest larger one above it in the PDF, and the title of a sidebar is at the level of the headings beside it. Adventuring and Combat are titles of ours: in the SRD their sections follow those of Using Ability Scores without a title of their own. Traps, Diseases, Madness, Objects and Poisons close Spellcasting in the SRD, after its spells, without a chapter of their own (pages 195–205): each is a chapter here, its headings one level up. Some chapters are taken in part: Spellcasting without its spell lists and spells (pages 100–104), and Magic Items without its items, which are pages, and so without the heading Artifacts, which holds only the Orb of Dragonkind. The sidebars Equipment Packs and Self-Sufficiency are sections, and a row that heads a group in a table, in italics in the PDF, is in bold, as in the Armor and Weapons tables. Beyond 1st Level is taken up to its backgrounds (pages 56–60), which the page Acolyte (background) holds; Races, Monsters and Appendix MM-B: Nonplayer Characters without their races and stat blocks, which are pages (pages 3, 254–260, 395), Monsters keeping as a section of its own the Half-Dragon Template that stands among its stat blocks (pages 320–321). In the Travel Pace table, the heading "Distance Traveled per..." is written out in each of its three columns. The tables Proficiency Bonus by Challenge Rating and Experience Points by Challenge Rating, printed in two halves side by side (pages 256, 258), are each one table of two columns, and in Appendix PH-B each table of deities follows its pantheon's text (pages 360–362). The run-in title X/Day (page 259) is not in bold italics, since a title cannot hold a slash. A sidebar that falls among the parts of a section closes it, at the section's level, as Armor, Weapon, and Tool Proficiencies after Senses (page 257). Appendix MM-A's creatures are pages; its two lines of introduction (page 366) are left out.
+
+The code, the instructions, the scripts and the tests are under the MIT license:
+
+Copyright (c) 2026 Stefano Caronia
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+The icons in `images/` are from game-icons.net (https://game-icons.net), under the Creative Commons Attribution 3.0 Unported License (CC-BY-3.0, https://creativecommons.org/licenses/by/3.0/): icons made by Carl Olsen, Caro Asercion, Cathelineau, DarkZaitzev, Delapouite, Faithtoken, John Redman, Kier Heyl, Lorc, Pierre Leducq, Sbed, Skoll, Sparker, Willdabeast and Zajkonur, available on https://game-icons.net. Changes: none; they are the white icons on a transparent background, named as on game-icons.net, with the author's name after it when two have the same.
+
+This system is compatible with fifth edition.

package/README.md

@@ -1,3 +1,36 @@
-# Temporary Holding Version
+# The 5e system
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+A game system for [RPG Engine](https://github.com/stefanocaronia/rpg-engine), compatible with fifth edition, from the System Reference Document 5.1: its rules as chapters the master looks up, its creatures, items, spells, classes, races and backgrounds as pages, and the numbers of a character's sheet worked out from them, as the abilities, the proficiency bonus, the saves and skills, the hit points, the spell slots and the uses of features that the rests bring back. The master rules with the exact text at hand; the engine keeps the sheet. On the dashboard it adds the death saves, the panel of a character at 0 hit points and the card of the hit dice in a short rest.
+
+This package works only inside [RPG Engine](https://github.com/stefanocaronia/rpg-engine): it is a game system the engine installs on this computer for a campaign, not a library of its own.
+
+## Install
+
+With RPG Engine 0.6.0 or later: the master offers it when a campaign is set up, or `rpg package install 5e`; then `rpg config system 5e` in the campaign. A campaign keeps its system once its first character is made.
+
+## Languages
+
+The dashboard shows the system's words in 26 languages. In a campaign in Italian, the master and the dashboard read the text of its pages and its rules in the official Italian translation of the SRD 5.1 (`translations/it/`, rebuilt with `build/lines-it.py` and `build/translations.mjs`); the pages keep their English names and fields.
+
+## Versions of the rules
+
+The rules of the SRD 5.1 are the version `srd-5.1`, and for now the only one. Each version is a folder in `versions/`, read over the common part; a campaign plays the one its `ruleset` setting names, which the player chooses.
+
+## Develop and test
+
+You need Node 22.4 or later, and the engine for its test kit, `rpg-engine/testing`:
+
+```sh
+npm install
+npm test
+```
+
+`npm test` builds `dist/` first: the kit runs the system as the engine installs it, and its campaigns play this folder (`systems: ["."]`), not a copy the engine brings. To test against an engine you are changing, link it: `npm link` in the engine's folder, then `npm link rpg-engine` here; or keep the engine beside this repository and run `npm run test:downstream` from it, which builds the engine and runs these tests against it. `npm run lint` checks the types. `build/` holds the scripts that wrote the pages from the SRD's PDF, which is not here; they are not published.
+
+## Publish
+
+Raise `version` in `package.json`, commit, and push a tag `v<version>`: the workflow `publish.yml` checks, builds, tests and publishes to npm with Trusted Publishing, from the environment `release`.
+
+## Licence
+
+The material from the SRD 5.1, in English and in its official Italian translation, and the chapter Combat Encounters from the SRD 5.2.1, and our changes to them, the words in every language included, are under CC BY 4.0; the icons from game-icons.net under CC BY 3.0; the code and the instructions under MIT. See [LICENSE.md](LICENSE.md) for the attribution, what was changed, and the MIT license's text. This package is compatible with fifth edition.

package/dist/dying.js

@@ -0,0 +1,278 @@
+// The game's numbers and names (p. 98), constants of its code: the sheet shows the same counters, as the system's data gives them to the dashboard.
+const hp = "hp";
+const unconscious = "Unconscious";
+const stableEffect = "Stable";
+const successes = { field: "death-successes", most: 3 };
+const failures = { field: "death-failures", most: 3 };
+const save = { dice: "1d20", sides: 20, atLeast: 10, highest: { field: hp, value: 1 }, lowest: 2 };
+const rules = { instant: "Instant Death", saves: "Death Saving Throws" };
+// The counters of the hit dice a rest spends, by the die of each class (p. 56).
+const hitDice = "hit-dice-";
+// The words of each state on the dashboard, translated by the 5e's words.
+const stateWords = { dying: "Dying", stable: "Stable", dead: "Dead" };
+/** The dying point's hooks and its widgets, and how its death saves and hit dice are asked on the dashboard. */
+export const dyingCode = {
+    counterChanged: (change, game) => afterHitPoints(change, game),
+    turnStarted: ({ who }, game) => turnOf(who, game),
+    rolled: (roll, game) => playersSave(roll, game),
+    effectAdded: ({ page, effect }, game) => (game.sameName(effect, stableEffect) ? stabilized(page, game) : []),
+    // A death save is asked in its card, with no button to turn it down (D-460); the hit dice of a rest in theirs (ASK-14).
+    asking: ({ who, checks, notations, recipe }, game) => recipe !== undefined
+        ? checks.length > 0 && checks.every((field) => field.toLowerCase().startsWith(hitDice)) ? { card: { widget: "hit-dice", key: `${who} ${game.now()?.date ?? ""}` } } : undefined
+        : saveAsking(who, notations, game),
+    widgets: {
+        "dying": (game, asked) => dyingWidget(game, asked?.who),
+        "death-save": (game, asked) => (asked?.key === undefined ? undefined : saveWidget(game, asked.who)),
+        "hit-dice": (_game, asked) => (asked?.key === undefined ? undefined : { body: "hit-dice", says: "Hit Dice" }),
+    },
+};
+/** Whether a party member is dying now (DIE-4): at 0 hit points, neither stable by its successes nor dead by its failures. */
+function isDying(page) {
+    const counter = page?.counter(hp);
+    return page !== undefined && page.party && counter !== undefined && counter.value <= 0 && counted(page, successes.field) < successes.most && !isDead(page);
+}
+/** Whether one of the party is dead (DIE-7): at their most failures, or written dead, as the master writes status=dead. */
+function isDead(page) {
+    return counted(page, failures.field) >= failures.most || page.value("status") === "dead";
+}
+function counted(page, field) {
+    return page.counter(field)?.value ?? 0;
+}
+/**
+ * What hit points changed on a party member bring (DIE-1–DIE-3, DIE-6): Unconscious at 0; a failure for damage there, all of them when what goes past is as
+ * large as the maximum; the counters back to 0 and the conditions ended when they rise, never for the dead.
+ */
+function afterHitPoints(change, game) {
+    const page = game.page(change.page);
+    if (page === undefined || !page.party || !game.sameName(change.field, hp)) {
+        return [];
+    }
+    const name = page.name;
+    const failed = counted(page, failures.field);
+    // The dead are not brought back by hit points: they go back to 0, and only what the rules say brings them back (DIE-7).
+    if (change.after > 0 && change.before <= 0 && isDead(page)) {
+        setCounters(game, name, { [hp]: 0 }, "the dead regain nothing");
+        const why = failed >= failures.most ? `with ${failures.field} ${failed}` : "written status=dead";
+        const first = failed >= failures.most ? `change ${failures.field} to 0` : "write status=alive";
+        return [
+            `${name} is dead, ${why}: what this change gave is undone, ${hp} back to 0, as ${hp} regained brings no one back. To bring ${name} back as the rules say, as a spell does: `
+                + `first ${first}, then give the ${hp}.`,
+        ];
+    }
+    // Above 0 again: the counters back to 0, the conditions ended (DIE-3).
+    if (change.after > 0 && change.before <= 0) {
+        return back(page, game);
+    }
+    // Nor do the dead take more failures, or die again (review of 17 October).
+    if (change.after > 0 || isDead(page)) {
+        return [];
+    }
+    const lines = [];
+    const wasStable = counted(page, successes.field) >= successes.most;
+    const past = change.lost - Math.max(change.before, 0);
+    // Damage past 0 as large as the maximum kills at once (DIE-2), one stable too (DIE-6).
+    if (change.lost > 0 && change.max !== undefined && past >= change.max) {
+        setCounters(game, name, { [failures.field]: failures.most, ...(wasStable ? { [successes.field]: 0 } : {}) }, "instant death");
+        const unstable = wasStable && game.endEffect(name, stableEffect, "instant death");
+        lines.push(`${name} dies at once: ${past} past 0 is at least the maximum, ${change.max}; ${failures.field} ${failed} → ${failures.most}${unstable ? `, ${stableEffect} ended` : ""}. Read rules ${rules.instant}.`);
+    }
+    else if (change.lost > 0 && change.before <= 0) {
+        // Damage at 0 counts a failure (DIE-2); a critical hit counts two, which only the master knows. One stable is dying again (DIE-6).
+        const after = Math.min(failed + 1, failures.most);
+        setCounters(game, name, { [failures.field]: after, ...(wasStable ? { [successes.field]: 0 } : {}) }, `damage at 0 ${hp}`);
+        const unstable = wasStable && game.endEffect(name, stableEffect, `damage at 0 ${hp}`);
+        const dead = after >= failures.most;
+        const again = wasStable
+            ? ` ${name} is no longer stable: ${successes.field} ${successes.most} → 0${unstable ? `, ${stableEffect} ended` : ""}${dead ? "" : "; its death saves start again"}.`
+            : "";
+        const dies = dead ? ` ${name} dies: a moment of its own in the story.` : "";
+        lines.push(`${failures.field} ${failed} → ${after}: damage at 0 ${hp}; a critical hit counts two, so add one more with change.${again}${dies}`);
+    }
+    // Reaching 0 brings Unconscious (DIE-1), and what that breaks of what one keeps.
+    if (change.before > 0) {
+        const notes = game.addEffect(name, unconscious, `0 ${hp}`);
+        if (notes !== undefined) {
+            lines.unshift(`${name} is ${unconscious} while ${hp} is 0.`, ...notes);
+        }
+    }
+    return lines;
+}
+/** One back above 0 (DIE-3): its death saves back to 0, Unconscious and Stable ended. */
+function back(page, game) {
+    const name = page.name;
+    const reset = [successes.field, failures.field].filter((field) => counted(page, field) !== 0);
+    const was = Object.fromEntries(reset.map((field) => [field, counted(page, field)]));
+    setCounters(game, name, Object.fromEntries(reset.map((field) => [field, 0])), `${hp} above 0`);
+    const ended = game.endEffect(name, unconscious, "hit points regained");
+    const stable = game.endEffect(name, stableEffect, "hit points regained");
+    const parts = [...reset.map((field) => `${field} ${was[field]} → 0`), ...(ended ? [`${unconscious} ended`] : []), ...(stable ? [`${stableEffect} ended`] : [])];
+    return parts.length === 0 ? [] : [`${name} is no longer dying: ${parts.join(", ")}.`];
+}
+/**
+ * The start of a dying party member's turn (DIE-5, D-460): the player character's death save is the player's moment, rolled with a button; anyone else's is
+ * rolled now and written, for the master to tell as the mentor setting asks.
+ */
+function turnOf(who, game) {
+    const page = game.page(who);
+    if (!isDying(page)) {
+        return [];
+    }
+    const read = ` Read rules ${rules.saves}.`;
+    // The master set the counters by hand before Stable, which sets them itself (playtest 11).
+    const stabilize = ` To stabilize ${page.name}, as Medicine or a spell does: effect add ${page.name} ${stableEffect}, which sets the death saves itself.`;
+    if (page.pc) {
+        return [`${page.name} is dying: the turn starts with their death save, the player's to roll: ask them, with ask, a check of ${save.dice}; the engine writes its outcome.${stabilize}${read}`];
+    }
+    const rolled = game.roll(save.dice, { who: page.name, why: "death save" });
+    const lines = saved(page, { ...rolled, who: page.name }, game);
+    const still = isDying(game.page(page.name)) ? stabilize : "";
+    return [`${page.name} is dying: the engine rolled its death save, ${rolled.text}, so never roll it again. ${lines.join(" ")} ${tellingOf(game.setting("mentor"))}${still}${read}`];
+}
+/**
+ * The death save the player rolled for their character, with ask or roll (DIE-4); anyone else's is rolled as its turn starts (DIE-5). A d20 with a number added
+ * is not counted, and the master is told so.
+ */
+function playersSave(roll, game) {
+    const page = game.page(roll.who);
+    if (page === undefined || !page.pc) {
+        return [];
+    }
+    if (isDying(page) && roll.dice.some((die) => die.sides === save.sides) && !isSaveRoll(roll.notation)) {
+        return [
+            `${page.name} is dying, and ${roll.notation} was not counted as a death save, which is ${save.dice} alone, with dice added but no number: nothing was written. `
+                + `If it was one, write its outcome with change ${successes.field} or ${failures.field}.`,
+        ];
+    }
+    return saved(page, roll, game);
+}
+/**
+ * A death save rolled for one dying (DIE-4, DIE-6): a total of at least 10 is a success, the third making it stable, its failures gone; less is a failure, two
+ * on a 1; a 20 brings 1 hit point back, which ends the dying.
+ */
+function saved(page, roll, game) {
+    const natural = roll.dice.find((die) => die.sides === save.sides && die.dropped !== true)?.value;
+    if (!isDying(page) || natural === undefined || !isSaveRoll(roll.notation)) {
+        return [];
+    }
+    const name = page.name;
+    if (natural === save.sides) {
+        const own = page.counter(hp);
+        setCounters(game, name, { [hp]: save.highest.value }, "death save");
+        const shown = (value) => `${value}${own?.max === undefined ? "" : `/${own.max}`}`;
+        return [`${name}'s death save: ${natural}, the highest face: ${hp} ${shown(own?.value ?? 0)} → ${shown(save.highest.value)}.`, ...back(page, game)];
+    }
+    if (roll.total >= save.atLeast) {
+        const before = counted(page, successes.field);
+        const after = Math.min(before + 1, successes.most);
+        const failed = counted(page, failures.field);
+        const stable = after >= successes.most;
+        setCounters(game, name, { [successes.field]: after, ...(stable && failed > 0 ? { [failures.field]: 0 } : {}) }, "death save");
+        if (stable) {
+            game.addEffect(name, stableEffect, "death save");
+        }
+        const cleared = stable && failed > 0 ? `, ${failures.field} ${failed} → 0` : "";
+        const said = stable ? ` ${name} is stable: no more death saves, still ${unconscious} until it regains ${hp}.` : "";
+        return [`${name}'s death save: ${roll.total}, a success; ${successes.field} ${before} → ${after}${cleared}.${said}`];
+    }
+    const before = counted(page, failures.field);
+    const lost = natural === 1 ? save.lowest : 1;
+    const after = Math.min(before + lost, failures.most);
+    setCounters(game, name, { [failures.field]: after }, "death save");
+    const dead = after >= failures.most ? ` ${name} dies: a moment of its own in the story.` : "";
+    return [`${name}'s death save: ${roll.total}, ${lost > 1 ? `the lowest face, ${lost} failures` : "a failure"}; ${failures.field} ${before} → ${after}.${dead}`];
+}
+/** Stable given, as by a companion's Medicine or a healer's kit (DIE-6): successes full, failures gone, no more death saves. */
+function stabilized(name, game) {
+    const page = game.page(name);
+    if (!isDying(page)) {
+        return [];
+    }
+    const succeeded = counted(page, successes.field);
+    const failed = counted(page, failures.field);
+    setCounters(game, page.name, { [successes.field]: successes.most, [failures.field]: 0 }, `${stableEffect} given`);
+    return [
+        `${page.name} is stable: ${successes.field} ${succeeded} → ${successes.most}, ${failures.field} ${failed} → 0; no more death saves, still ${unconscious} until it regains ${hp}.`,
+    ];
+}
+/** The death save a question asks of a dying player character (D-460): every check the save's die, asked in its card, forced. */
+function saveAsking(who, notations, game) {
+    const page = game.page(who);
+    if (!isDying(page) || !page.pc || notations.length === 0 || !notations.every(isSaveRoll)) {
+        return undefined;
+    }
+    const marks = `${counted(page, successes.field)}/${counted(page, failures.field)}`;
+    return { card: { widget: "death-save", key: `${page.name} ${game.now()?.date ?? ""} ${marks}` }, decline: false };
+}
+/** Where one of the party at 0 stands: dying, stable at the last success, dead at the last failure; none above 0, or marked dead. */
+function stateOf(page) {
+    const counter = page?.counter(hp);
+    if (page === undefined || !page.party || counter === undefined || counter.value > 0 || page.value("status") === "dead") {
+        return undefined;
+    }
+    return counted(page, failures.field) >= failures.most ? "dead" : counted(page, successes.field) >= successes.most ? "stable" : "dying";
+}
+/**
+ * One of the party at 0 hit points, on them (D-516): the word of their state, red dying, green stable, dead greyed; the successes on one side and the
+ * failures on the other, which leave the line of values; the line of the heart over the word.
+ */
+function dyingWidget(game, who) {
+    const page = who === undefined ? undefined : game.page(who);
+    const state = stateOf(page);
+    if (page === undefined || state === undefined) {
+        return undefined;
+    }
+    const [succeeded, failed] = [counted(page, successes.field), counted(page, failures.field)];
+    const data = { state };
+    return {
+        icon: "heartbeat",
+        chip: stateWords[state],
+        ...(state === "dead" ? { dead: true } : {}),
+        says: { text: "{who}: {state}", values: { who: page.name, state: stateWords[state] } },
+        data,
+        parts: [
+            { track: { label: "Successes", value: succeeded, max: successes.most, tone: "good", stage: "start", field: successes.field } },
+            { lead: stateWords[state], ...(state === "dead" ? {} : { tone: state === "stable" ? "good" : "bad" }), figure: "heartbeat" },
+            { track: { label: "Failures", value: failed, max: failures.most, tone: "bad", stage: "end", field: failures.field } },
+        ],
+    };
+}
+/** The card of a death save, for who rolls it, before and after the dice: their counters, whether still at 0 and whether dead, and what the save's faces do. */
+function saveWidget(game, who) {
+    const page = who === undefined ? undefined : game.page(who);
+    if (page === undefined) {
+        return undefined;
+    }
+    const failed = counted(page, failures.field);
+    const data = {
+        who: page.name,
+        successes: { value: counted(page, successes.field), most: successes.most },
+        failures: { value: failed, most: failures.most },
+        down: (page.counter(hp)?.value ?? 0) <= 0,
+        dead: isDead(page),
+        sides: save.sides,
+        atLeast: save.atLeast,
+        lowest: save.lowest,
+        highest: save.highest,
+    };
+    // The card in the tint of the moment (D-461, D-517): red while dying, green stable, gold back on their feet, grey dead.
+    const tint = data.dead ? "muted" : !data.down ? "gold" : data.successes.value >= successes.most ? "ally" : "low";
+    return { body: "death-save", says: "Death Saving Throw", tint, data };
+}
+/** How the master tells a companion's death save (D-460): with the mentor off, the story alone, never naming it; else the roll in brackets, explained once in the tutorial. */
+function tellingOf(mentor) {
+    return mentor === "off"
+        ? "Tell it in the story alone: never name the save or its roll."
+        : `Tell it in a sentence, the roll in brackets${mentor === "tutorial" ? ", and the first time what a death save is" : ""}.`;
+}
+/** Whether a roll is a death save (playtest 08): the d20 and maybe more dice, as a d4 of Bless, never a number added, as initiative or a skill adds. */
+function isSaveRoll(notation) {
+    // d20 is 1d20, as dice read it.
+    const compact = notation.toLowerCase().replace(/\s+/g, "").replace(/(^|[+-])d/g, "$11d");
+    return compact.startsWith(save.dice) && compact.slice(save.dice.length).split(/(?=[+-])/).filter((term) => term !== "").every((term) => /^[+-]\d*d\d+$/.test(term));
+}
+/** Counters changed as the change command changes them, one by one, each to its value: the rules watch them, so they are never just written (D-514). */
+function setCounters(game, page, values, why) {
+    for (const [field, value] of Object.entries(values)) {
+        game.change(page, field, { to: value }, why);
+    }
+}

package/dist/index.js

@@ -0,0 +1,3 @@
+import { dyingCode } from "./dying.js";
+const fifthEdition = () => dyingCode;
+export default fifthEdition;