roll-parser 3.1.0 → 3.2.1

package/README.md

@@ -68,8 +68,9 @@ roll('4d6kh3', { rng: createMockRng([3, 6, 2, 5]) }).total; // 14, every run
 - **Safe on untrusted input.** Dice count, explosion depth, reroll depth, and
   parse depth are all bounded, and every failure is a typed error with a stable
   code and a source span.
-- **Small and fast.** ≈11.9 kB brotli for the whole library, ≈5.5 kB for just
-  `parse`, ≈213 B for the testing entry point. Zero runtime dependencies, zero
+- **Small and fast.** ≈12.8 kB brotli for the whole library, ≈5.7 kB for just
+  `parse`, ≈1.4 kB for `roll-parser/render`, ≈213 B for the testing entry
+  point. Zero runtime dependencies, zero
   `node:` imports. A `1d20` round trip takes about 0.5 µs.
 - **Tested.** 1,500+ tests behind CI-enforced coverage floors — 100% of
   functions, 98% of lines — including every code example in this README, which
@@ -84,22 +85,28 @@ roll('4d6kh3', { rng: createMockRng([3, 6, 2, 5]) }).total; // 14, every run
 
 ## Contents
 
-- [Install](#install)
-- [Notation reference](#notation-reference)
+**Start here**
+
+- [Install](#install) — [CDN](#cdn--browser-without-a-bundler) · [Upgrading](#upgrading)
+- [Notation reference](#notation-reference) — [Dice](#dice) · [Arithmetic](#arithmetic-and-functions) · [Modifiers](#modifiers) · [Pools and checks](#pools-and-checks)
 - [Recipes by game system](#recipes-by-game-system)
-- [Working with results](#working-with-results)
-- [Randomness](#randomness)
-- [Options](#options)
-- [Error handling](#error-handling)
-- [Using the parser directly](#using-the-parser-directly)
-- [TypeScript](#typescript)
-- [CLI](#cli)
-- [Performance](#performance)
-- [Known limitations](#known-limitations)
-- [Versioning](#versioning)
-- [Upgrading](#upgrading)
-- [Contributing](#contributing)
-- [License](#license)
+
+**Using results**
+
+- [Working with results](#working-with-results) — [RollResult](#rollresult) · [The parts tree](#the-parts-tree)
+- [Rendering](#rendering) — [Custom markers](#custom-markers) · [Reading crit and fumble](#reading-crit-and-fumble)
+
+**Configuring a roll**
+
+- [Options](#options) — [Safety limits](#safety-limits)
+- [Randomness](#randomness) — [Seeded rolls](#seeded-rolls) · [Replay](#replay-and-saveresume) · [Custom RNGs](#custom-rngs) · [Testing](#testing)
+
+**Reference**
+
+- [Error handling](#error-handling) — [Notation errors](#notation-errors) · [Error classes](#error-classes) · [Error codes](#error-codes)
+- [Using the parser directly](#using-the-parser-directly) · [TypeScript](#typescript)
+- [CLI](#cli) · [Performance](#performance) · [Known limitations](#known-limitations)
+- [Versioning](#versioning) · [Contributing](#contributing) · [License](#license)
 
 ## Install
 
@@ -145,9 +152,9 @@ as one request:
 
 ### Upgrading
 
-[MIGRATION.md](MIGRATION.md) covers every upgrade path, newest first — 3.0.0 to
-3.1.0, v2 to v3, and the v3 pre-releases. v3 is a complete rewrite and the 2.x
-API is not compatible; to stay on the old line, pin `roll-parser@2.3.2`.
+[MIGRATION.md](MIGRATION.md) covers every upgrade path, newest first. v3 is a
+complete rewrite and the 2.x API is not compatible; to stay on the old line,
+pin `roll-parser@2.3.2`.
 
 ## Notation reference
 
@@ -157,8 +164,9 @@ wherever the two overlap: `kh`/`kl`/`dh`/`dl`, `!`/`!!`/`!p`, `r`/`ro`, success
 and failure counting, `cs`/`cf`, grouped rolls, and `floor`/`ceil`/`round`/`abs`
 all use Roll20's spelling and semantics. It is not a strict superset — sorting
 (`s`), PF2e `vs` checks, `max`/`min`, and computed dice counts and sides are
-additions, and two Roll20 forms are deliberately rejected (`4d6d1`, arithmetic
-after a success count) — see [Known limitations](#known-limitations).
+additions, and three Roll20 forms are deliberately rejected (`4d6d1`, arithmetic
+after a success count, and a counted single-sub-roll group folding its own math
+into each die, `{3d20+5}>=21`) — see [Known limitations](#known-limitations).
 
 Notation is case-insensitive and whitespace-tolerant — `2 D 20 KH 1` and
 `2d20kh1` are the same expression, newlines included. The one exception is
@@ -220,15 +228,17 @@ Chained keep/drop modifiers do **not** nest. `4d6kh3dl1` flattens into two
 specs applied independently to the same pool, with the dropped sets unioned —
 the Roll20 rule.
 
-`cs` / `cf` covers the whole pool, including dice that `!`, `!p`, `r`, and `ro`
-add after it — `1d6cs<2!` and `1d6!cs<2` flag the same dice. Two cases stay
-order-sensitive. Modifiers that rewrite a die's value rather than add one (`!!`,
-`minN`, `maxN`) are judged on whatever that value is when the threshold runs:
-with `[6, 6, 3]`, `1d6cs>10!!` reports no critical while `1d6!!cs>10` reports
-one, judging the compounded 15. And because `!p`'s added dice store one less
-than they rolled, the side you *don't* override moves with position —
-`1d6cf>5!p` keeps the critical that plain `1d6!p` gives the added 6, where
-`1d6!pcf>5` does not.
+`cs` / `cf` covers the whole pool, dice that `!`, `!p`, `r`, and `ro` add
+included, and position does not matter — `1d6cs<2!` and `1d6!cs<2` flag the
+same dice. The side you leave alone keeps the default rule, reading each die's
+natural face, so writing `cf>5` does not disturb `critical`: `1d6cf>5!p` and
+`1d6!pcf>5` both agree with plain `1d6!p` on the appended die.
+
+One case stays order-sensitive: an explicit threshold reads a die's current
+value, so modifiers that rewrite it rather than add a die (`!!`, `minN`,
+`maxN`) are judged on whatever that value is when the threshold runs. With
+`[6, 6, 3]`, `1d6cs>10!!` reports no critical while `1d6!!cs>10` reports one,
+judging the compounded 15.
 
 ### Pools and checks
 
@@ -238,13 +248,19 @@ than they rolled, the side you *don't* override moves with position —
 | `fT` / `f<cmp>T` | Subtract dice meeting the failure threshold — `10d10>=6f1`, `10d10>=6f<=2` |
 | `<roll> vs <dc>` | PF2e degree of success, with nat-20/nat-1 upgrade and downgrade |
 | `{a, b}khN` | Grouped roll: each sub-roll's subtotal competes as one compound die |
-| `{a+b}khN` | Single-sub-roll group: keep/drop selects across the flattened pool |
+| `{a+b}khN` | Single-sub-roll group: keep/drop selects across the flattened pool — `+`-joined pools only, a literal or any math throws |
+| `{a, b}<cmp>T` | Grouped roll: each sub-roll's subtotal is counted, not its dice — `{2d6, 2d6}>=10` |
+| `{a+b}<cmp>T` | Single-sub-roll group: counts across the flattened pool — `+`-joined pools only, a literal or any math throws |
 
 > [!IMPORTANT]
 > Success counting is **terminal** — no modifier or arithmetic applies to it
 > directly, so `10d10>=6 + 2` is a parse error. Put the arithmetic inside the
 > threshold, `10d10>=(4+2)`, or wrap the count in group braces to operate on its
 > result: `{10d10>=6}+2`.
+>
+> Braces also let a second count re-score the same pool — `{4d6>=5}<=2f5`. The
+> outermost count owns the result; see
+> [RollResult](#rollresult) for what that means for the fields you read.
 
 > [!WARNING]
 > A bare `d` after a dice expression is rejected: `4d6d1` throws
@@ -293,7 +309,7 @@ pool.total; // 5 — successes minus failures
 | `notation` | `string` | Exactly what you passed in |
 | `expression` | `string` | Normalized form; meta-expressions appear as their resolved values |
 | `rendered` | `string` | Markdown breakdown with per-die markers |
-| `rolls` | `DieResult[]` | Every die in order: `sides`, `result`, `modifiers`, `critical`, `fumble` |
+| `rolls` | `DieResult[]` | Every die in order, meta-expression dice included: `sides`, `result`, `modifiers`, `critical`, `fumble` |
 | `parts` | `RollPart` | Typed evaluation tree mirroring the AST 1:1 |
 | `successes` / `failures` | `number?` | Present only when success counting was used |
 | `degree` / `natural` | `DegreeOfSuccess?` / `number?` | Present only for a top-level `vs` |
@@ -324,6 +340,12 @@ JSON.stringify(roll('3d6', { rng: createMockRng([4, 2, 6]) }));
 > `rolls[]` and the `rolls[]` inside `parts` hold the *same* `DieResult`
 > objects — no deep clone, so annotating a die is visible through both views.
 
+When counts nest through braces (`{4d6>=5}<=2f5`), the outermost one owns the
+result: every die is judged against its thresholds alone, so `successes`,
+`failures`, `rolls[].modifiers`, and `rendered` all agree with it, and dice it
+does not count come out untagged. The DC side of a `vs` is the exception — it
+sits outside every pool pass and keeps whatever tagged it.
+
 ### The parts tree
 
 `result.parts` is a 16-variant discriminated union mirroring the AST one-to-one.
@@ -379,7 +401,9 @@ dice land in `result.rolls` tagged `'meta'` so an audit log can still show them.
 
 `result.rendered` uses markdown markers, so a Discord bot or chat log can print
 it as-is: `~~n~~` for a die dropped by keep/drop or group selection, `**n**` for
-a success, `__n__` for a failure.
+a success, `__n__` for a failure. The dialect is Discord's, not a universal one
+— Telegram MarkdownV2 rejects `**bold**` and spells strike `~n~` — so expect a
+transform, or emit your own dialect with [`renderBreakdown`](#custom-markers).
 
 ```typescript
 roll('4d6kh3', { seed: 'demo' }).rendered; // '4d6[1, 6, ~~1~~, 3] = 10'
@@ -424,6 +448,79 @@ exactly one of `dropped`, `success`, or `failure` — a dropped die is never
 also shown as a success. With no marks the output is byte-identical to
 `result.rendered`; a property test pins that.
 
+#### Reading crit and fumble
+
+`rendered` carries no marker for a crit or a fumble — those live on the dice.
+`die.critical` and `die.fumble` already reflect any `cs` / `cf` override, so a
+UI that builds its own elements reads the booleans rather than the string.
+
+```typescript
+const result = roll('4d20cs>=19', { rng: createMockRng([20, 19, 7, 1]) });
+
+const marked = result.rolls
+  .filter((die) => !die.modifiers.includes('meta'))
+  .map((die) => {
+    let text = String(die.result);
+    if (die.critical) text = `<b>${text}</b>`;
+    if (die.fumble) text = `<i>${text}</i>`;
+    return text;
+  });
+
+marked.join(', '); // '<b>20</b>, <b>19</b>, 7, <i>1</i>'
+```
+
+The 19 is critical only because `cs>=19` said so — the booleans are where the
+override lands. Compose the two marks rather than branching on one: overlapping
+thresholds set both, and `1d6cs>=3cf<=4` rolling a 3 does exactly that.
+
+The [playground](https://roll-parser.edloidas.io/) does exactly this — its
+[source](https://github.com/edloidas/roll-parser/blob/master/site/src/dice.ts)
+turns the same booleans into CSS classes, a tooltip, and a legend.
+
+That loop is right for a plain pool. Four decisions it cannot dodge:
+
+- **`'meta'` dice are not yours to show.** They resolve counts, sides, and
+  modifier arguments, and they carry ordinary crit flags — in `4d6kh(1d2)` the
+  `1d2` rolling a 2 hits its max face and arrives `critical: true`. The filter
+  above is not optional.
+- **`'dc'` dice are a judgment call.** They do render — `1d20 vs 2d10` shows
+  `1d20[5] vs 2d10[10, 10]` — but they sit outside the roll-side pool while
+  still taking the default crit rule, so that `[10, 10]` arrives as two crits
+  nobody rolled for. Drop them and a per-die zip has no dice left for a
+  two-number bracket; keep them and the DC side lights up on its own faces.
+  [`renderBreakdown`](#custom-markers) does not decide this for you — it marks
+  every flagged die — but its callbacks receive the die, so gate on the tag.
+  For a hand-rolled walk, `result.parts` keeps the two sides apart: the
+  `versus` part carries `roll` and `dc` as separate subtrees.
+- **Never splice `rendered` by bracket position.** `{2d6, 2d8}kh1` strikes the
+  dropped sub-roll as a whole, `{2d6[6, 6], ~~2d8[1, 1]~~}`, yet its inner dice
+  each carry `'dropped'` too — marking every `'dropped'` die into that string
+  yields `~~2d8[~~1~~, ~~1~~]~~`. Rebuild with
+  [`renderBreakdown`](#custom-markers) instead of patching the baked string.
+- **Density is your call.** The default rule flags the max face of any pool,
+  not just d20s — `3d6` rolling a 6 is `critical: true` — so marking it
+  unconditionally makes ordinary pools glitter. Gate on `die.sides === 20`, or
+  on whatever your table's rule is. `d1` and Fate dice are the exceptions:
+  having no exceptional face, they stay `false` unless `cs` / `cf` says so.
+
+The claims above, in code:
+
+```typescript
+import { renderBreakdown } from 'roll-parser/render';
+
+roll('1d6cs>=3cf<=4', { rng: createMockRng([3]) }).rolls[0]?.fumble; // true
+roll('4d6kh(1d2)', { rng: createMockRng([2, 3, 6, 2, 5]) }).rolls[0]?.critical; // true
+roll('1d20 vs 2d10', { rng: createMockRng([5, 10, 10]) }).rolls[2]?.critical; // true
+roll('3dF', { rng: createMockRng([1, 0, -1]) }).rolls[0]?.critical; // false
+roll('{2d6, 2d8}kh1', { rng: createMockRng([6, 6, 1, 1]) }).rendered;
+// '{2d6[6, 6], ~~2d8[1, 1]~~} = 12'
+
+// Gating a mark on the `'dc'` tag keeps the DC side unmarked
+renderBreakdown(roll('1d20 vs 2d10', { rng: createMockRng([5, 10, 10]) }), {
+  critical: (die, text) => (die.modifiers.includes('dc') ? text : `<b>${text}</b>`),
+}); // '1d20[5] vs 2d10[10, 10] = Critical Failure'
+```
+
 ## Randomness
 
 Every die is drawn through the `RNG` interface — no roll path bypasses the RNG
@@ -967,16 +1064,12 @@ Values are **p50**, from
 two significant digits: another machine shifts every row, and a busy one
 inflates the heavy cases most.
 
-The `10d10>=6f1` `roll` figure and the `4d6sd` row come from a later
-five-pass measurement on the same machine, after the per-die `'dc'` tag checks
-that had entered the keep/drop, success-count, and sort paths were hoisted out
-of those loops. That session was not idle: `evaluate / 10d10>=6f1` and
-`evaluate / 10d10sd` each read bimodally across passes with roughly 10% between
-the two modes, so those two are quoted as "recovered to the pre-exclusion
-range" rather than to a point value. The rows this hoist does not touch
-(`1d20`, `2d6+3`, `4d6kh3`, `100d6`) re-measured within noise of the figures
-above and are left as first measured, since the earlier idle session is the
-better data for them.
+The `4d6sd` row and the `10d10>=6f1` `roll` figure come from a later five-pass
+measurement on the same machine, after the per-die `'dc'` tag checks were
+hoisted out of the keep/drop, success-count, and sort loops. That session was
+not idle and those two read bimodally with roughly 10% between the modes, so
+take them as a recovered range rather than point values. Every other row is as
+first measured.
 
 p50 rather than mean, because the mean here is effectively a GC-pause
 histogram and swings ±40% between processes. Every bench body is JIT-primed
@@ -996,34 +1089,69 @@ any commit that regresses a case past 1.75x. Bundle size is gated in CI by
 
 ## Known limitations
 
-- **Keep/drop does not echo into the render prefix.** `4d6kh3` renders as
-  `4d6[1, 6, ~~1~~, 3] = 10`, while every other modifier family does echo
-  (`8d6![…]`, `4d6sd[…]`, `10d10>=6f1[…]`). The dropped die is still marked;
-  only the `kh3` is missing, and `result.expression` has it.
-- **`4d6d1` is a parse error, not "drop 1".** The bare `d` is the dice
-  operator, and reading `4d6d1` as "roll 4d6, then roll that many d1" is a
-  silent trap, so it throws `AMBIGUOUS_DICE_CHAIN`.
-- **Threshold comparisons bind tight.** `1d6!>=5+2` parses as `(1d6!>=5)+2`;
-  parenthesize for a computed threshold, `1d6!>=(5+2)`. Success counts bind the
-  same way but are terminal, so `1d6>=5+2` errors outright — write
-  `1d6>=(5+2)`, or `{1d6>=5}+2` to add to the count itself.
+### Notation the parser rejects
+
+| Form | Throws | Write instead |
+|------|--------|---------------|
+| `{2d6+3}kh2`, `{2d6-1d4}kh3`, `{2d6*2}kh2`, `{2d6+0}kh2` | `INVALID_KEEP_DROP_TARGET` | `{2d6}kh2 + 3`, or one sub-roll per term: `{2d6+3, 1d8}kh1` |
+| `{3d20+5}>=21`, `{2d6-1d4}>=3`, `{2d6*2}>=4`, `{floor(2d6/2)}>=2` | `INVALID_SUCCESS_COUNT_TARGET` | fold the scalar into the threshold: `3d20>=16` |
+| `{3, 5, 7}>=4` | `INVALID_SUCCESS_COUNT_TARGET` | give the group a pool: `3d6>=4` |
+| `{{2d6, 2d8}}>=4`, `({2d6, 2d8})>=4`, `{2d6, 2d8}kh1>=4` | `INVALID_SUCCESS_COUNT_TARGET` | count the group directly: `{2d6, 2d8}>=4` |
+| `{4d6>=5}kh1` | `INVALID_SUCCESS_COUNT_TARGET` | the count is already terminal — select first, `{4d6kh1}>=5` |
+| `{2d6, 1d8}s` | `INVALID_SORT_TARGET` | flatten to one sub-roll: `{2d6+1d8}s` |
+| `4d6d1` | `AMBIGUOUS_DICE_CHAIN` | `4d6dl1` to drop a die, `(4d6)d1` for nested dice |
+
+The first two rows share one cause: a single-sub-roll group compares dice one
+face at a time, so a literal, a subtracted or scaled pool, or a function wrapper
+never reaches the comparison. The check is structural rather than arithmetic, so
+an identity term (`{2d6+0}kh2`) is refused with the rest. Adding pools
+(`{4d6+2d8}kh3`, `{2d6+1d8}>=5`) is the form these braces exist for and always
+works.
+
+A counted group needs at least one die somewhere in it — one real pool is
+enough, and the other sub-rolls may be literals: `{3, 1d6}>=4` scores both
+subtotals, the literal `3` included. A pool that is merely empty at run time
+(`0d6>=4`) still parses and totals 0. Subtotals exist only while the count holds
+the group directly, which is why the fourth row throws rather than falling back
+to loose faces; the DC side of a `vs` is exempt (`{1d20 vs {2d6, 2d8}}>=5`
+counts the d20), since no pool pass tallies a DC.
+
+Sorting a multi-sub-roll group is refused rather than shipped wrong: spec-correct
+sorting there is hierarchical — dice within each sub-roll, then sub-rolls by
+total — and the evaluator only flat-sorts.
+
+### Rendering and `expression`
+
+- **Keep/drop does not echo into the render prefix** — see
+  [Rendering](#rendering). The dropped die is still marked; only the `kh3` is
+  missing, and `result.expression` has it.
 - **`result.expression` substitutes meta-expressions with their resolved
   values,** so it does not round-trip through `parse` when they are present:
   `roll('(1d4)d6').expression` is `'4d6'` when the `1d4` rolled 4, and
   `roll('1d6!>(1d2+3)').expression` is `'1d6!>5'`.
+- **Adjacent bare modifiers keep a space.** `cs`, `cf`, `s`, and `sd` without a
+  threshold or count end an identifier the lexer would extend into whatever
+  follows, so `expression` and `rendered` separate them the way the input had
+  to: `roll('1d20cs cf').expression` is `'1d20cs cf'`, and `4d6 s kh2` comes
+  back as `'4d6s kh2'`. Everything else stays flush — `4d6cs>4cf<2`.
 - **Sort flattens additive pools.** `(2d6+1d8)s` renders as one combined sorted
   list, `(2d6 + 1d8)s[2, 3, 6] = 11`, rather than `2d6[2, 6] + 1d8[3]`. Totals
   are unaffected; only the breakdown loses pool boundaries.
 - **Outer parentheses drop when crit thresholds collapse.** `(1d20cs>19)cs=1`
   reports `expression: '1d20cs>19cs=1'` because chained `cs`/`cf` fold into one
   node. It re-parses to the same AST; only the text differs.
-- **Sorting a multi-sub-roll group is rejected.** `{2d6, 1d8}s` throws
-  `INVALID_SORT_TARGET`. Spec-correct sorting there is hierarchical — dice
-  within each sub-roll, then sub-rolls by total — and the evaluator only
-  flat-sorts, so the syntax is refused rather than shipped wrong. Single
-  sub-roll groups (`{2d6+1d8}s`) still work as the flat-pool escape hatch.
+
+### Arithmetic and precedence
+
+- **Threshold comparisons bind tight.** `1d6!>=5+2` parses as `(1d6!>=5)+2`;
+  parenthesize for a computed threshold, `1d6!>=(5+2)`. Success counts bind the
+  same way but are terminal, so `1d6>=5+2` errors outright — write
+  `1d6>=(5+2)`, or `{1d6>=5}+2` to add to the count itself.
 - **Division does not floor.** `7/2` totals `3.5`, not `3` — arithmetic is plain
   IEEE-754 throughout. Wrap it when you need an integer: `floor(7/2)` totals `3`.
+  Operands that must be whole numbers — dice count, dice sides, keep/drop count —
+  reject a fraction instead of rounding it for you: `5d(20/3)` throws
+  `INVALID_DICE_SIDES`, `5d(round(20/3))` rolls `5d7`.
 - **The power operator has no overflow guard.** `2**999` totals `5.357…e+300`.
   Only a non-finite result throws `NON_FINITE_RESULT`, so finite-but-enormous
   totals pass through unflagged.

package/dist/evaluator/env.d.ts

@@ -33,8 +33,20 @@ export type EvalEnv = {
      * Set to `true` by `evalSuccessCount`. Propagates through the shared env
      * so `evaluate()` can include `successes`/`failures` fields even when no
      * die was tagged (impossible threshold).
+     *
+     * ! Set *after* the target is evaluated, not before. `evalSuccessCount` reads
+     * ! the pre-set value to learn whether an inner count already tagged its pool
+     * ! — moving the assignment back to the top makes it read its own write.
      */
     hasSuccessCount: boolean;
+    /**
+     * What a multi-sub-roll group count (`{2d6, 2d6}>=10`) scored. Its units are
+     * subtotals, which exist only as throwaway synthetic dice, so these verdicts
+     * reach the top-level tally here rather than as tags on a die. Every path
+     * that releases `TALLY_FLAGS` releases these too.
+     */
+    subtotalSuccesses: number;
+    subtotalFailures: number;
     /**
      * `true` while the evaluator is inside a `VersusNode`'s roll or DC
      * sub-evaluation. `evalVersus` rejects nesting via this flag — catches
@@ -46,7 +58,7 @@ export type EvalEnv = {
      * `true` once a `vs` has tagged its DC dice `'dc'`. Lets every pool
      * operation skip its per-die `isVersusDc` check outright — the tag exists in
      * a small minority of notation, and the call inside the loop cost 11-38% on
-     * keep/drop, success, and sort notation that can never carry one (#281).
+     * keep/drop, success, and sort notation that can never carry one.
      *
      * ! Monotonic: set by `evalVersus`, never cleared. `insideVersus` is not a
      * ! model for it — that flag resets in a `finally`, and it is false exactly
@@ -63,6 +75,20 @@ export type EvalEnv = {
      * so the shape stays stable for notation that has none.
      */
     critRules: WeakMap<DieResult, CritRule> | undefined;
+    /**
+     * Dice minted as explosion continuations by `!` / `!p`, keyed on the
+     * `DieResult` object itself. Read by `extractNatural`, which counts them out
+     * of the versus primaries — the `'exploded'` tag cannot say it alone, since
+     * a compound explode stamps it on the original die it accumulated into.
+     *
+     * Out of band for the same reason as {@link EvalEnv.critRules}: `DieResult`
+     * is public and serialized.
+     *
+     * ! Only populated while {@link EvalEnv.insideVersus} — nothing outside a
+     * ! `vs` reads it, and the `add` per appended die is not free. Any new
+     * ! reader must be on a versus path too.
+     */
+    explosionDice: WeakSet<DieResult> | undefined;
     /**
      * User-supplied variable map for `@name` / `@{name}` references. Always
      * defined — `evaluate()` defaults to an empty object so lookups can be

package/dist/evaluator/env.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"env.d.ts","sourceRoot":"","sources":["../../src/evaluator/env.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAGH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,kBAAkB,CAAC;AAChD,OAAO,KAAK,EAAE,SAAS,EAAE,qBAAqB,EAAE,MAAM,aAAa,CAAC;AAEpE;;;;GAIG;AACH,MAAM,MAAM,QAAQ,GAAG;IACrB,QAAQ,CAAC,OAAO,EAAE,SAAS,qBAAqB,EAAE,CAAC;IACnD,QAAQ,CAAC,IAAI,EAAE,SAAS,qBAAqB,EAAE,CAAC;CACjD,CAAC;AAEF;;;;;GAKG;AACH,MAAM,MAAM,OAAO,GAAG;IACpB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,oBAAoB,EAAE,MAAM,CAAC;IACtC,QAAQ,CAAC,mBAAmB,EAAE,MAAM,CAAC;IACrC,eAAe,EAAE,MAAM,CAAC;IACxB;;;;OAIG;IACH,eAAe,EAAE,OAAO,CAAC;IACzB;;;;;OAKG;IACH,YAAY,EAAE,OAAO,CAAC;IACtB;;;;;;;;;OASG;IACH,WAAW,EAAE,OAAO,CAAC;IACrB;;;;;;;;OAQG;IACH,SAAS,EAAE,OAAO,CAAC,SAAS,EAAE,QAAQ,CAAC,GAAG,SAAS,CAAC;IACpD;;;;OAIG;IACH,QAAQ,CAAC,OAAO,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;IACnD;;;OAGG;IACH,QAAQ,CAAC,iBAAiB,EAAE,OAAO,GAAG,MAAM,CAAC;CAC9C,CAAC;AAEF;;;;;;;GAOG;AACH,wBAAgB,UAAU,CAAC,GAAG,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,OAAO,CAAC,MAAM,CAAC,GAAG,IAAI,CASvF;AAED,mDAAmD;AACnD,wBAAgB,SAAS,CAAC,GAAG,EAAE,OAAO,EAAE,QAAQ,EAAE,OAAO,CAAC,MAAM,CAAC,GAAG,IAAI,CAEvE"}
+{"version":3,"file":"env.d.ts","sourceRoot":"","sources":["../../src/evaluator/env.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAGH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,kBAAkB,CAAC;AAChD,OAAO,KAAK,EAAE,SAAS,EAAE,qBAAqB,EAAE,MAAM,aAAa,CAAC;AAEpE;;;;GAIG;AACH,MAAM,MAAM,QAAQ,GAAG;IACrB,QAAQ,CAAC,OAAO,EAAE,SAAS,qBAAqB,EAAE,CAAC;IACnD,QAAQ,CAAC,IAAI,EAAE,SAAS,qBAAqB,EAAE,CAAC;CACjD,CAAC;AAEF;;;;;GAKG;AACH,MAAM,MAAM,OAAO,GAAG;IACpB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,oBAAoB,EAAE,MAAM,CAAC;IACtC,QAAQ,CAAC,mBAAmB,EAAE,MAAM,CAAC;IACrC,eAAe,EAAE,MAAM,CAAC;IACxB;;;;;;;;OAQG;IACH,eAAe,EAAE,OAAO,CAAC;IACzB;;;;;OAKG;IACH,iBAAiB,EAAE,MAAM,CAAC;IAC1B,gBAAgB,EAAE,MAAM,CAAC;IACzB;;;;;OAKG;IACH,YAAY,EAAE,OAAO,CAAC;IACtB;;;;;;;;;OASG;IACH,WAAW,EAAE,OAAO,CAAC;IACrB;;;;;;;;OAQG;IACH,SAAS,EAAE,OAAO,CAAC,SAAS,EAAE,QAAQ,CAAC,GAAG,SAAS,CAAC;IACpD;;;;;;;;;;;;OAYG;IACH,aAAa,EAAE,OAAO,CAAC,SAAS,CAAC,GAAG,SAAS,CAAC;IAC9C;;;;OAIG;IACH,QAAQ,CAAC,OAAO,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;IACnD;;;OAGG;IACH,QAAQ,CAAC,iBAAiB,EAAE,OAAO,GAAG,MAAM,CAAC;CAC9C,CAAC;AAEF;;;;;;;GAOG;AACH,wBAAgB,UAAU,CAAC,GAAG,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,OAAO,CAAC,MAAM,CAAC,GAAG,IAAI,CASvF;AAED,mDAAmD;AACnD,wBAAgB,SAAS,CAAC,GAAG,EAAE,OAAO,EAAE,QAAQ,EAAE,OAAO,CAAC,MAAM,CAAC,GAAG,IAAI,CAEvE"}

package/dist/evaluator/env.js.map

@@ -1 +1 @@
-{"version":3,"file":"env.js","sourceRoot":"","sources":["../../src/evaluator/env.ts"],"names":[],"mappings":"AAUA,OAAO,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAgF9C,MAAM,UAAU,UAAU,CAAC,GAAY,EAAE,KAAa,EAAE,QAAyB;IAC/E,IAAI,GAAG,CAAC,eAAe,GAAG,KAAK,GAAG,GAAG,CAAC,OAAO,EAAE,CAAC;QAC9C,MAAM,IAAI,cAAc,CACtB,oBAAoB,GAAG,CAAC,eAAe,GAAG,KAAK,qBAAqB,GAAG,CAAC,OAAO,EAAE,EACjF,qBAAqB,EACrB,QAAQ,CACT,CAAC;IACJ,CAAC;IACD,GAAG,CAAC,eAAe,IAAI,KAAK,CAAC;AAC/B,CAAC;AAGD,MAAM,UAAU,SAAS,CAAC,GAAY,EAAE,QAAyB;IAC/D,UAAU,CAAC,GAAG,EAAE,CAAC,EAAE,QAAQ,CAAC,CAAC;AAC/B,CAAC"}
+{"version":3,"file":"env.js","sourceRoot":"","sources":["../../src/evaluator/env.ts"],"names":[],"mappings":"AAUA,OAAO,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AA0G9C,MAAM,UAAU,UAAU,CAAC,GAAY,EAAE,KAAa,EAAE,QAAyB;IAC/E,IAAI,GAAG,CAAC,eAAe,GAAG,KAAK,GAAG,GAAG,CAAC,OAAO,EAAE,CAAC;QAC9C,MAAM,IAAI,cAAc,CACtB,oBAAoB,GAAG,CAAC,eAAe,GAAG,KAAK,qBAAqB,GAAG,CAAC,OAAO,EAAE,EACjF,qBAAqB,EACrB,QAAQ,CACT,CAAC;IACJ,CAAC;IACD,GAAG,CAAC,eAAe,IAAI,KAAK,CAAC;AAC/B,CAAC;AAGD,MAAM,UAAU,SAAS,CAAC,GAAY,EAAE,QAAyB;IAC/D,UAAU,CAAC,GAAG,EAAE,CAAC,EAAE,QAAQ,CAAC,CAAC;AAC/B,CAAC"}

package/dist/evaluator/evaluator.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"evaluator.d.ts","sourceRoot":"","sources":["../../src/evaluator/evaluator.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAiB,cAAc,EAAuC,MAAM,cAAc,CAAC;AAClG,OAAO,KAAK,EACV,OAAO,EAmBR,MAAM,kBAAkB,CAAC;AAG1B,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,iBAAiB,CAAC;AAC3C,OAAO,KAAK,EAIV,SAAS,EACT,eAAe,EAKf,UAAU,EACX,MAAM,aAAa,CAAC;AACrB,OAAO,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAK9C,OAAO,EAKL,8BAA8B,EAC/B,MAAM,wBAAwB,CAAC;AAShC,OAAO,EAGL,6BAA6B,EAC9B,MAAM,uBAAuB,CAAC;AAM/B,OAAO,EAAE,cAAc,EAAE,CAAC;AAM1B;;;;;;;;;GASG;AACH,eAAO,MAAM,gBAAgB,QAAS,CAAC;AAmCvC,OAAO,EAAE,8BAA8B,EAAE,6BAA6B,EAAE,CAAC;AAMzE;;;;;;GAMG;AACH,MAAM,MAAM,WAAW,GAAG;IACxB,KAAK,EAAE,SAAS,EAAE,CAAC;IACnB,eAAe,EAAE,MAAM,EAAE,CAAC;IAC1B,aAAa,EAAE,MAAM,EAAE,CAAC;IACxB;;;;;OAKG;IACH,cAAc,CAAC,EAAE;QACf,MAAM,EAAE,eAAe,CAAC;QACxB,OAAO,EAAE,MAAM,GAAG,SAAS,CAAC;QAC5B,OAAO,EAAE,MAAM,CAAC;KACjB,CAAC;CACH,CAAC;AAogDF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,wBAAgB,QAAQ,CAAC,GAAG,EAAE,OAAO,EAAE,GAAG,EAAE,GAAG,EAAE,OAAO,GAAE,eAAoB,GAAG,UAAU,CA8D1F"}
+{"version":3,"file":"evaluator.d.ts","sourceRoot":"","sources":["../../src/evaluator/evaluator.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAiB,cAAc,EAAuC,MAAM,cAAc,CAAC;AAElG,OAAO,KAAK,EACV,OAAO,EAmBR,MAAM,kBAAkB,CAAC;AAG1B,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,iBAAiB,CAAC;AAC3C,OAAO,KAAK,EAIV,SAAS,EACT,eAAe,EAKf,UAAU,EACX,MAAM,aAAa,CAAC;AACrB,OAAO,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAK9C,OAAO,EAKL,8BAA8B,EAC/B,MAAM,wBAAwB,CAAC;AAWhC,OAAO,EAGL,6BAA6B,EAC9B,MAAM,uBAAuB,CAAC;AAM/B,OAAO,EAAE,cAAc,EAAE,CAAC;AAM1B;;;;;;;;;GASG;AACH,eAAO,MAAM,gBAAgB,QAAS,CAAC;AAmCvC,OAAO,EAAE,8BAA8B,EAAE,6BAA6B,EAAE,CAAC;AAMzE;;;;;;GAMG;AACH,MAAM,MAAM,WAAW,GAAG;IACxB,KAAK,EAAE,SAAS,EAAE,CAAC;IACnB,eAAe,EAAE,MAAM,EAAE,CAAC;IAC1B,aAAa,EAAE,MAAM,EAAE,CAAC;IACxB;;;;;OAKG;IACH,cAAc,CAAC,EAAE;QACf,MAAM,EAAE,eAAe,CAAC;QACxB,OAAO,EAAE,MAAM,GAAG,SAAS,CAAC;QAC5B,OAAO,EAAE,MAAM,CAAC;KACjB,CAAC;CACH,CAAC;AAsnDF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,wBAAgB,QAAQ,CAAC,GAAG,EAAE,OAAO,EAAE,GAAG,EAAE,GAAG,EAAE,OAAO,GAAE,eAAoB,GAAG,UAAU,CAiE1F"}