roll-parser 3.0.0 → 3.1.0

package/CHANGELOG.md

@@ -7,6 +7,40 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [3.1.0] - 2026-08-08
+
+### Added
+
+- `roll-parser/render`, a subpath export holding `renderBreakdown(result, marks?)`, `DieMarks`, and `MARKDOWN_MARKS`. It rebuilds the `RollResult.rendered` breakdown from `RollResult.parts` with markers the caller chooses, so consumers targeting anything other than Discord markdown no longer regex-parse the baked string. Six slots — `dropped`, `success`, `failure`, `critical`, `fumble`, and `droppedGroup` — compose in a fixed order; `critical`/`fumble` read the `DieResult` booleans, which `rendered` has no marker for. With no `marks` the output is byte-identical to `rendered`, pinned by a property test. Budgeted separately at 2 kB, leaving the `index.js` and `{ roll }` budgets to the library ([#292](https://github.com/edloidas/roll-parser/issues/292))
+
+### Changed
+
+- The `explode`, `reroll`, and `successCount` members of `RollPart` now carry `rolls: DieResult[]`, the pool the modifier produced — mirroring what `sort` already did. Standard and penetrating explosions and both reroll forms append dice that appear nowhere under `target`, so the part tree could not previously describe its own output ([#292](https://github.com/edloidas/roll-parser/issues/292))
+
+  Reading `parts` is unaffected. Three things do change:
+
+  - Code that **constructs** one of those three parts stops compiling — `TS2322: Property 'rolls' is missing in type … but required`. Add the pool, or widen the annotation.
+  - Deep-equality assertions against those parts need the new field.
+  - `--json` and `JSON.stringify(result)` payloads grow for expressions using explode, reroll, or success counting, since the pool is serialized on the modifier as well as its target — roughly +40% to +96% depending on pool size. Expressions without those modifiers are unchanged.
+
+- performance: the per-die `isVersusDc` check is now skipped entirely for notation that cannot carry a `'dc'` tag, `sortDice` scans before allocating instead of running an unconditional `filter`, and `countSuccesses` filters DC dice up front rather than guarding inside the loop. Sort notation had no benchmark coverage, which is why the regression shipped unseen; `4d6sd`, `10d10sd`, `100d6sa`, and `10d10sd>=6f1` now have bench cases ([#281](https://github.com/edloidas/roll-parser/issues/281))
+
+### Fixed
+
+- Bare `cs`/`cf` now judge the natural face (`initialResult ?? result`) rather than a value a preceding modifier rewrote, matching what the documentation always claimed. Compound explode also stopped clobbering the raw face recorded by an earlier `minN`/`maxN` clamp, which made `1d6min6!!cs` report a false critical. Explicit thresholds deliberately keep reading `result`, so the two kinds can disagree on one die ([#288](https://github.com/edloidas/roll-parser/issues/288))
+- `cs`/`cf` thresholds now apply to dice minted by explode and reroll, which previously fell back to the built-in default rule. Each resolved rule is recorded per die and inherited by appended and replacement dice, so a further explode or reroll inherits it in turn. Overriding one side no longer moves the other: `1d6cf>5!p` keeps the `critical` that plain `1d6!p` gives the appended die ([#289](https://github.com/edloidas/roll-parser/issues/289))
+- Chained same-kind bounds (`1d6min2min3`) no longer push duplicate `'min'`/`'max'` modifiers onto a die, and `initialResult` still comes from the first bound that moved it. The same duplication is fixed for `'success'`/`'failure'` on a group counted after its members (`{4d6>=5}>=1`) and for `'meta'` on nested meta operands (`((1d2)d4)d6`) ([#290](https://github.com/edloidas/roll-parser/issues/290))
+- CLI `--verbose` no longer mangles a dropped group sub-roll nested inside another dropped group sub-roll. `{{1d6, 1d8}kh1, {1d10, 1d12}kh1}kh1` rendered as `({)1d10[1](, 1d12[3]})`; the marker rewrite was a regex over the flat string and stopped at the first inner `~~`. It now reads the structure and emits `({(1d10[1]), 1d12[3]})` ([#292](https://github.com/edloidas/roll-parser/issues/292))
+- Demo site: fractional totals are rounded to four decimals — falling back to exponential where rounding would show a non-zero total as `0` — with the exact value on a `title` attribute, instead of overflowing the result card ([#285](https://github.com/edloidas/roll-parser/issues/285))
+- Demo site: the total count-up is gated on `Number.isSafeInteger`, so an astronomical total lands without animating rather than interpolating through to `0` ([#286](https://github.com/edloidas/roll-parser/issues/286))
+
+### Documentation
+
+- `MIGRATION.md` gains a 3.0.0 → 3.1.0 section covering the `RollPart` field, the three ways it can surface, and the new render subpath. The file is now ordered newest-first with an index, and `README.md` points at it for every upgrade path rather than only for 2.x ([#292](https://github.com/edloidas/roll-parser/issues/292))
+- `DieResult.critical` and `DieResult.fumble` now scope the max-face/1 default to `sides > 1`, so neither claims to fire on `d1` or Fate dice, and the `FateDiceNode` / `createFateDieResult` TSDoc no longer states the flags are never set on Fate dice — an explicit `4dFcs>0` or `4dFcf=-1` does set them ([#291](https://github.com/edloidas/roll-parser/issues/291))
+- The README no longer implies success counting rejects every enclosing expression — it is terminal only against direct wrapping
+- The README performance table gained a `4d6sd` row and links the published benchmark trend, and the Node badge reads from the published `engines` range
+
 ## [3.0.0] - 2026-08-06
 
 First stable release of the v3 rewrite. This section covers what changed since
@@ -183,7 +217,8 @@ Dice mechanics (Stage 2):
 - Dice count safety limit via `maxDice` option (default 10,000), enforced across the whole expression to prevent DoS via additive groups like `5000d6+5000d6` ([#19](https://github.com/edloidas/roll-parser/issues/19))
 - Parser and evaluator correctness: duplicate `kept` modifier entries, implicit modifier count defaulting to 1 (`4d6kh` → `4d6kh1`), `critical` flag suppression when `sides === 1`, negative `--seed` CLI values ([#21](https://github.com/edloidas/roll-parser/issues/21))
 
-[Unreleased]: https://github.com/edloidas/roll-parser/compare/v3.0.0...HEAD
+[Unreleased]: https://github.com/edloidas/roll-parser/compare/v3.1.0...HEAD
+[3.1.0]: https://github.com/edloidas/roll-parser/releases/tag/v3.1.0
 [3.0.0]: https://github.com/edloidas/roll-parser/releases/tag/v3.0.0
 [3.0.0-beta.0]: https://github.com/edloidas/roll-parser/releases/tag/v3.0.0-beta.0
 [3.0.0-alpha.0]: https://github.com/edloidas/roll-parser/releases/tag/v3.0.0-alpha.0

package/MIGRATION.md

@@ -1,4 +1,76 @@
-# Migrating from v2 to v3
+# Migration notes
+
+Newest first. [Upgrading from 3.0.0 to 3.1.0](#upgrading-from-300-to-310) ·
+[Migrating from v2 to v3](#migrating-from-v2-to-v3) ·
+[Upgrading from a v3 pre-release](#upgrading-from-a-v3-pre-release)
+
+## Upgrading from 3.0.0 to 3.1.0
+
+Nothing was removed and no behaviour changed: `total`, `expression`, `rendered`,
+`rolls`, and `degree` are byte-identical to 3.0.0 for every expression. The
+whole of this section is about one added field.
+
+**`RollPart` gained `rolls` on three variants.** The `explode`, `reroll`, and
+`successCount` members now carry `rolls: DieResult[]` — the pool the modifier
+produced — joining `sort`, which always had it. They needed it: standard and
+penetrating explosions and both reroll forms *append* dice, and those dice
+appeared nowhere in the part tree, so a part could not describe its own output.
+
+<!-- readme-test: skip -->
+```typescript
+// 3.0.0 — the explosion die is missing from the tree
+roll('2d6!').parts.target.rolls.length; // 2, but `rendered` shows three dice
+
+// 3.1.0 — the modifier carries the pool it actually rendered
+roll('2d6!').parts.rolls.length; // 3
+```
+
+Per the [versioning policy](README.md#versioning), adding a field to a returned
+object is a minor. Reading `parts` is unaffected and needs no change. Three
+things can still bite:
+
+- **Constructing one of those parts stops compiling** — `TS2322: Property
+  'rolls' is missing in type … but required`. This is only reachable in test
+  fixtures and mocks, since no library function accepts a `RollPart`. Add the
+  pool, or widen the annotation.
+- **Deep-equality assertions against those parts fail.** Add `rolls` to the
+  expected object, or assert on the fields you care about instead of the whole
+  part.
+- **`--json` and `JSON.stringify(result)` payloads grow** for expressions using
+  explode, reroll, or success counting, because the pool is serialized on the
+  modifier as well as on its target — roughly +40% to +96% depending on pool
+  size. Expressions without those modifiers are unchanged. Budget for it if you
+  log, cache, or ship results over a wire.
+
+**The CLI renders nested dropped sub-rolls correctly.** `--verbose` on a dropped
+group sub-roll nested inside another one used to emit mismatched delimiters —
+`{{(1d6[1]), 1d8[4]}, ({)1d10[1](, 1d12[3]})}`. It now emits
+`{{(1d6[1]), 1d8[4]}, ({(1d10[1]), 1d12[3]})}`. Anything parsing that output
+should be reading `--json` instead.
+
+**New, optional: `roll-parser/render`.** A subpath export whose
+`renderBreakdown(result, marks?)` rebuilds the breakdown from `result.parts`
+with markers you choose, so you no longer have to regex the markdown out of
+`rendered`. With no marks its output is byte-identical to `rendered`, which
+makes it a drop-in starting point:
+
+```typescript
+import { roll } from 'roll-parser';
+import { renderBreakdown } from 'roll-parser/render';
+import { createMockRng } from 'roll-parser/testing';
+
+const result = roll('4d6kh3', { rng: createMockRng([3, 6, 2, 5]) });
+
+renderBreakdown(result) === result.rendered; // true
+renderBreakdown(result, { dropped: (_die, text) => `(${text})` });
+// '4d6[3, 6, (2), 5] = 14'
+```
+
+See [Custom markers](README.md#custom-markers) for the six slots and the order
+they compose in. Nothing forces you to adopt it — `rendered` is unchanged and
+is not deprecated.
+
+## Migrating from v2 to v3
 
 v3 is a full rewrite. Nothing in the 2.x API carries over — the entry points,
 the result shape, the error behaviour, and parts of the notation all changed. To

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">
@@ -98,7 +97,7 @@ roll('4d6kh3', { rng: createMockRng([3, 6, 2, 5]) }).total; // 14, every run
 - [Performance](#performance)
 - [Known limitations](#known-limitations)
 - [Versioning](#versioning)
-- [Upgrading from 2.x](#upgrading-from-2x)
+- [Upgrading](#upgrading)
 - [Contributing](#contributing)
 - [License](#license)
 
@@ -144,10 +143,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 — 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`.
 
 ## Notation reference
 
@@ -220,6 +220,16 @@ 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.
+
 ### Pools and checks
 
 | Notation | Meaning |
@@ -231,8 +241,10 @@ the Roll20 rule.
 | `{a+b}khN` | Single-sub-roll group: keep/drop selects across the flattened pool |
 
 > [!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`.
 
 > [!WARNING]
 > A bare `d` after a dice expression is rejected: `4d6d1` throws
@@ -342,9 +354,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
@@ -369,6 +394,36 @@ 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.
+
 ## Randomness
 
 Every die is drawn through the `RNG` interface — no roll path bypasses the RNG
@@ -891,7 +946,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 +963,21 @@ 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 `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.
+
 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,8 +989,10 @@ 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
 
@@ -940,7 +1006,7 @@ budgets live in `package.json`.
 - **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)`.
+  `1d6>=(5+2)`, or `{1d6>=5}+2` to add to the count itself.
 - **`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

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).
  *
@@ -32,6 +42,27 @@ 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 (#281).
+     *
+     * ! 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;
     /**
      * 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;;;;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"}

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;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"}

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;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"}