roll-parser 3.0.0 → 3.2.0

package/README.md

@@ -12,8 +12,7 @@ Dice notation for tabletop RPGs, rolled into structured results.
   <a href="https://www.npmjs.com/package/roll-parser"><img src="https://img.shields.io/npm/v/roll-parser?color=cb3837" alt="npm version"></a>
   <a href="https://github.com/edloidas/roll-parser/actions/workflows/ci.yml"><img src="https://img.shields.io/github/actions/workflow/status/edloidas/roll-parser/ci.yml?branch=master&label=CI" alt="CI status"></a>
   <a href="https://github.com/edloidas/roll-parser/blob/master/LICENSE"><img src="https://img.shields.io/npm/l/roll-parser?color=blue" alt="MIT license"></a>
-  <!-- TODO: switch to img.shields.io/node/v/roll-parser once 3.0.0 is npm `latest` — until then it reads 2.x engines -->
-  <a href="https://nodejs.org/"><img src="https://img.shields.io/badge/node-%3E%3D22.12-5fa04e" alt="Node.js >= 22.12"></a>
+  <a href="https://nodejs.org/"><img src="https://img.shields.io/node/v/roll-parser?color=5fa04e" alt="Node.js >= 22.12"></a>
 </p>
 
 <p align="center">
@@ -69,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.7 kB brotli for the whole library, ≈5.5 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
@@ -85,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 from 2.x](#upgrading-from-2x)
-- [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
 
@@ -144,10 +150,11 @@ as one request:
 `https://esm.sh/roll-parser` works the same way. Raw file URLs
 (`unpkg.com/roll-parser`) also work but fetch each module separately.
 
-### Upgrading from 2.x
+### Upgrading
 
-v3 is a complete rewrite and the API is not compatible — see
-[MIGRATION.md](MIGRATION.md). 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,6 +228,18 @@ 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, 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
 
 | Notation | Meaning |
@@ -228,11 +248,19 @@ the Roll20 rule.
 | `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** — nothing may wrap it, so `10d10>=6 + 2` is
-> a parse error. Put the arithmetic inside the threshold: `10d10>=(4+2)`.
+> 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
@@ -281,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` |
@@ -312,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.
@@ -342,9 +376,22 @@ describe(roll('4d6kh3 + 2', { rng: createMockRng([3, 6, 2, 5]) }).parts);
 
 Invariants worth relying on: `result.parts.total === result.total`,
 `successCount.total === successes - failures`, and every part's `rolls[]`
-sharing references with `result.rolls`. A `sort` part's `rolls[]` is its
-target's pool in sorted order — chained sorts (`4d6s sd`) nest, and the
-outermost one holds the order `rendered` shows.
+sharing references with `result.rolls`.
+
+Four variants carry a `rolls[]` of their own, holding the pool the modifier
+produced rather than the one its target rolled — read those instead of
+descending into `target` when you want what was rendered:
+
+- `sort` — the target's pool in sorted order. Chained sorts (`4d6s sd`) nest,
+  and the outermost one holds the order `rendered` shows.
+- `explode` — the expanded pool. Standard and penetrating explosions append
+  dice that exist nowhere under `target`.
+- `reroll` — discarded intermediates and their replacements, both appended
+  rather than substituted.
+- `successCount` — the tallied pool.
+
+Unlike the pool on a `dice` part, those four keep `'meta'` dice, so filter them
+before counting or displaying.
 
 Meta-expressions do **not** appear as nested parts. `(1d4)d6`, `4d6kh(1d2)`, and
 `1d6!>(1d2+3)` surface only their resolved numbers in the owning part; their
@@ -354,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'
@@ -369,6 +418,109 @@ success-count modifiers, but **not** keep/drop — `4d6kh3` renders as `4d6[…]
 while `8d6!` renders as `8d6![…]`. Read `result.expression` when you need the
 modifier back.
 
+#### Custom markers
+
+Markdown is one dialect, and `rendered` bakes it in. `roll-parser/render` is a
+≈1.4 kB entry point that rebuilds the same breakdown from `result.parts` with
+markers you choose — no regex round-trip through the baked string.
+
+```typescript
+import { renderBreakdown } from 'roll-parser/render';
+
+const result = roll('4d6kh3', { seed: 'demo' });
+
+renderBreakdown(result); // '4d6[1, 6, ~~1~~, 3] = 10'
+renderBreakdown(result, {}); // '4d6[1, 6, 1, 3] = 10'
+renderBreakdown(result, {
+  dropped: (_die, text) => `<s>${text}</s>`,
+  critical: (_die, text) => `<b>${text}</b>`,
+}); // '4d6[1, <b>6</b>, <s>1</s>, 3] = 10'
+```
+
+Six slots are available — `dropped`, `success`, `failure`, `critical`,
+`fumble`, and `droppedGroup` for a whole sub-roll struck by `{…}kh1`. An
+omitted slot renders plain, so pass `{}` to strip markup entirely or spread
+`MARKDOWN_MARKS` to keep the rest. `critical` and `fumble` read the
+`DieResult` booleans, which `rendered` has no marker for at all.
+
+Marks compose in a fixed order: `critical` then `fumble` innermost, then
+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
@@ -891,7 +1043,8 @@ precedes them. Errors go to stderr; only the result goes to stdout.
 | `1d20` | 85 ns | 164 ns | **0.49 µs** (~2.0M rolls/s) |
 | `2d6+3` | 98 ns | 215 ns | **0.77 µs** |
 | `4d6kh3` | 122 ns | 245 ns | **1.2 µs** |
-| `10d10>=6f1` | 161 ns | 336 ns | **2.0 µs** |
+| `4d6sd` | 101 ns | 211 ns | **0.84 µs** |
+| `10d10>=6f1` | 161 ns | 336 ns | **1.6 µs** |
 | `100d6` | 82 ns | 168 ns | **2.6 µs** |
 
 The `roll` column pays for a fresh `SeededRNG` per call, which an injected RNG
@@ -907,13 +1060,17 @@ Values are **p50**, from
 (`.gc('inner')`), taken as the per-record median of four full
 `bun run bench:json` passes, every row agreeing within 5% except
 `lex / 4d6kh3` at 7%. Measured 2026-08-05 on Bun
-1.3.14, Apple M2 Pro, macOS, idle and on AC power. The `4d6kh3` and
-`10d10>=6f1` `roll` figures were re-measured 2026-08-06 over three passes
-agreeing within 4%, after per-die `'dc'` tag checks entered the keep/drop and
-success-count paths; the remaining rows re-measured within noise. Read them as
+1.3.14, Apple M2 Pro, macOS, idle and on AC power. Read them as
 two significant digits: another machine shifts every row, and a busy one
 inflates the heavy cases most.
 
+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
 before measurement and pinned to mitata's batched sampling mode, so all cases
@@ -925,37 +1082,71 @@ mis-times mid-weight cases by 10-30x.
 Run `bun run bench` for the full suite, or `bench:lex` / `bench:parse` /
 `bench:evaluate` / `bench:roll` for one stage. Cross-library numbers live in
 the [competitor suite](https://github.com/edloidas/roll-parser/tree/master/bench/competitors)
-(`bun run bench:competitors`). Bundle size is gated in CI by `size-limit`; the
-budgets live in `package.json`.
+(`bun run bench:competitors`). Every push to `master` publishes its p50s to a
+[trend chart](https://edloidas.io/roll-parser/dev/bench/), and CI comments on
+any commit that regresses a case past 1.75x. Bundle size is gated in CI by
+`size-limit`; the budgets live in `package.json`.
 
 ## 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)`.
+### 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`.
 - **The power operator has no overflow guard.** `2**999` totals `5.357…e+300`.

package/dist/cli/format.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"format.d.ts","sourceRoot":"","sources":["../../src/cli/format.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAE9C;;GAEG;AACH,MAAM,MAAM,aAAa,GAAG;IAC1B,8EAA8E;IAC9E,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,kEAAkE;IAClE,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB,CAAC;AAEF;;;;;;;;;;;;GAYG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,UAAU,EAAE,OAAO,GAAE,aAAkB,GAAG,MAAM,CAYpF"}
+{"version":3,"file":"format.d.ts","sourceRoot":"","sources":["../../src/cli/format.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAGH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAe9C;;GAEG;AACH,MAAM,MAAM,aAAa,GAAG;IAC1B,8EAA8E;IAC9E,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,kEAAkE;IAClE,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB,CAAC;AAEF;;;;;;;;;;;;GAYG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,UAAU,EAAE,OAAO,GAAE,aAAkB,GAAG,MAAM,CAYpF"}

package/dist/cli/format.js

@@ -1,3 +1,10 @@
+import { renderBreakdown } from '../render.js';
+const TERMINAL_MARKS = {
+    dropped: (_die, text) => `(${text})`,
+    success: (_die, text) => `[${text}]`,
+    failure: (_die, text) => `{${text}}`,
+    droppedGroup: (inner) => `(${inner})`,
+};
 export function formatResult(result, options = {}) {
     const { json = false, verbose = false } = options;
     if (json) {
@@ -6,12 +13,6 @@ export function formatResult(result, options = {}) {
     if (!verbose) {
         return String(result.total);
     }
-    return formatRendered(result.rendered);
-}
-function formatRendered(rendered) {
-    return rendered
-        .replace(/\*\*(-?\d+)\*\*/g, '[$1]')
-        .replace(/__(-?\d+)__/g, '{$1}')
-        .replace(/~~([^~]+)~~/g, '($1)');
+    return renderBreakdown(result, TERMINAL_MARKS);
 }
 //# sourceMappingURL=format.js.map

package/dist/cli/format.js.map

@@ -1 +1 @@
-{"version":3,"file":"format.js","sourceRoot":"","sources":["../../src/cli/format.ts"],"names":[],"mappings":"AAiCA,MAAM,UAAU,YAAY,CAAC,MAAkB,EAAE,OAAO,GAAkB,EAAE;IAC1E,MAAM,EAAE,IAAI,GAAG,KAAK,EAAE,OAAO,GAAG,KAAK,EAAE,GAAG,OAAO,CAAC;IAElD,IAAI,IAAI,EAAE,CAAC;QACT,OAAO,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC;IAChC,CAAC;IAED,IAAI,CAAC,OAAO,EAAE,CAAC;QACb,OAAO,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;IAC9B,CAAC;IAED,OAAO,cAAc,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;AACzC,CAAC;AAiBD,SAAS,cAAc,CAAC,QAAgB;IACtC,OAAO,QAAQ;SACZ,OAAO,CAAC,kBAAkB,EAAE,MAAM,CAAC;SACnC,OAAO,CAAC,cAAc,EAAE,MAAM,CAAC;SAC/B,OAAO,CAAC,cAAc,EAAE,MAAM,CAAC,CAAC;AACrC,CAAC"}
+{"version":3,"file":"format.js","sourceRoot":"","sources":["../../src/cli/format.ts"],"names":[],"mappings":"AAQA,OAAO,EAAiB,eAAe,EAAE,MAAM,cAAc,CAAC;AAS9D,MAAM,cAAc,GAAa;IAC/B,OAAO,EAAE,CAAC,IAAI,EAAE,IAAI,EAAE,EAAE,CAAC,IAAI,IAAI,GAAG;IACpC,OAAO,EAAE,CAAC,IAAI,EAAE,IAAI,EAAE,EAAE,CAAC,IAAI,IAAI,GAAG;IACpC,OAAO,EAAE,CAAC,IAAI,EAAE,IAAI,EAAE,EAAE,CAAC,IAAI,IAAI,GAAG;IACpC,YAAY,EAAE,CAAC,KAAK,EAAE,EAAE,CAAC,IAAI,KAAK,GAAG;CACtC,CAAC;AAyBF,MAAM,UAAU,YAAY,CAAC,MAAkB,EAAE,OAAO,GAAkB,EAAE;IAC1E,MAAM,EAAE,IAAI,GAAG,KAAK,EAAE,OAAO,GAAG,KAAK,EAAE,GAAG,OAAO,CAAC;IAElD,IAAI,IAAI,EAAE,CAAC;QACT,OAAO,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC;IAChC,CAAC;IAED,IAAI,CAAC,OAAO,EAAE,CAAC;QACb,OAAO,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;IAC9B,CAAC;IAED,OAAO,eAAe,CAAC,MAAM,EAAE,cAAc,CAAC,CAAC;AACjD,CAAC"}

package/dist/evaluator/die.d.ts

@@ -20,7 +20,8 @@ import type { DieModifier, DieResult } from '../types.js';
 export declare function createDieResult(sides: number, result: number, modifiers: DieModifier[]): DieResult;
 /**
  * Creates a Fate/Fudge die result. Uses `sides = 0` as a sentinel — Fate dice
- * have no max-face concept, so `critical` and `fumble` are always `false`.
+ * have no max-face concept, so `critical` and `fumble` start `false` and the
+ * default rule never sets them. An explicit `cs`/`cf` threshold still can.
  */
 export declare function createFateDieResult(result: number, modifiers: DieModifier[]): DieResult;
 //# sourceMappingURL=die.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"die.d.ts","sourceRoot":"","sources":["../../src/evaluator/die.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAE1D;;;;;;GAMG;AACH,wBAAgB,eAAe,CAC7B,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,EACd,SAAS,EAAE,WAAW,EAAE,GACvB,SAAS,CAUX;AAED;;;GAGG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,WAAW,EAAE,GAAG,SAAS,CAQvF"}
+{"version":3,"file":"die.d.ts","sourceRoot":"","sources":["../../src/evaluator/die.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAE1D;;;;;;GAMG;AACH,wBAAgB,eAAe,CAC7B,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,EACd,SAAS,EAAE,WAAW,EAAE,GACvB,SAAS,CAUX;AAED;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,WAAW,EAAE,GAAG,SAAS,CAQvF"}

package/dist/evaluator/die.js.map

@@ -1 +1 @@
-{"version":3,"file":"die.js","sourceRoot":"","sources":["../../src/evaluator/die.ts"],"names":[],"mappings":"AAqBA,MAAM,UAAU,eAAe,CAC7B,KAAa,EACb,MAAc,EACd,SAAwB;IAIxB,OAAO;QACL,KAAK;QACL,MAAM;QACN,SAAS;QACT,QAAQ,EAAE,MAAM,KAAK,KAAK,IAAI,KAAK,GAAG,CAAC;QACvC,MAAM,EAAE,MAAM,KAAK,CAAC,IAAI,KAAK,GAAG,CAAC;KAClC,CAAC;AACJ,CAAC;AAMD,MAAM,UAAU,mBAAmB,CAAC,MAAc,EAAE,SAAwB;IAC1E,OAAO;QACL,KAAK,EAAE,CAAC;QACR,MAAM;QACN,SAAS;QACT,QAAQ,EAAE,KAAK;QACf,MAAM,EAAE,KAAK;KACd,CAAC;AACJ,CAAC"}
+{"version":3,"file":"die.js","sourceRoot":"","sources":["../../src/evaluator/die.ts"],"names":[],"mappings":"AAqBA,MAAM,UAAU,eAAe,CAC7B,KAAa,EACb,MAAc,EACd,SAAwB;IAIxB,OAAO;QACL,KAAK;QACL,MAAM;QACN,SAAS;QACT,QAAQ,EAAE,MAAM,KAAK,KAAK,IAAI,KAAK,GAAG,CAAC;QACvC,MAAM,EAAE,MAAM,KAAK,CAAC,IAAI,KAAK,GAAG,CAAC;KAClC,CAAC;AACJ,CAAC;AAOD,MAAM,UAAU,mBAAmB,CAAC,MAAc,EAAE,SAAwB;IAC1E,OAAO;QACL,KAAK,EAAE,CAAC;QACR,MAAM;QACN,SAAS;QACT,QAAQ,EAAE,KAAK;QACf,MAAM,EAAE,KAAK;KACd,CAAC;AACJ,CAAC"}

package/dist/evaluator/env.d.ts

@@ -8,6 +8,16 @@
  * @module evaluator/env
  */
 import type { ASTNode } from '../parser/ast.js';
+import type { DieResult, ResolvedCritThreshold } from '../types.js';
+/**
+ * A resolved `cs`/`cf` pair, recorded per die so that dice minted later by
+ * explode or reroll can be judged by the rule the user declared instead of
+ * the built-in default.
+ */
+export type CritRule = {
+    readonly success: readonly ResolvedCritThreshold[];
+    readonly fail: readonly ResolvedCritThreshold[];
+};
 /**
  * Per-evaluation shared environment (created once, shared across all branches).
  *
@@ -23,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
@@ -32,6 +54,41 @@ export type EvalEnv = {
      * left-chain check.
      */
     insideVersus: boolean;
+    /**
+     * `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.
+     *
+     * ! Monotonic: set by `evalVersus`, never cleared. `insideVersus` is not a
+     * ! model for it — that flag resets in a `finally`, and it is false exactly
+     * ! when the tagged DC dice become visible to the enclosing pool.
+     */
+    hasVersusDc: boolean;
+    /**
+     * Crit rule per die, keyed on the `DieResult` object itself. Populated by
+     * `applyCritThresholds`; read by explode and reroll so a die they mint
+     * inherits the rule of the die it descended from.
+     *
+     * Out of band rather than a `DieResult` field because `DieResult` is public
+     * and serialized. `undefined` until the first `cs`/`cf` node — declared here
+     * 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;AAEhD;;;;;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;;;;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;AAgD9C,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;AAQhC,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;AA++CF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,wBAAgB,QAAQ,CAAC,GAAG,EAAE,OAAO,EAAE,GAAG,EAAE,GAAG,EAAE,OAAO,GAAE,eAAoB,GAAG,UAAU,CA4D1F"}
+{"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;AA0lDF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,wBAAgB,QAAQ,CAAC,GAAG,EAAE,OAAO,EAAE,GAAG,EAAE,GAAG,EAAE,OAAO,GAAE,eAAoB,GAAG,UAAU,CAiE1F"}