roll-parser 3.2.2 → 3.3.1

package/CHANGELOG.md

@@ -7,6 +7,50 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [3.3.1] - 2026-08-20
+
+### Changed
+
+- performance: the evaluator does less work per node and per die. `EvalContext`'s `expression` and `rendered` fragment arrays are single strings carried on `EvalResult`, so no branch can omit one; `rewriteFlags` is one loop instead of a closure, a filter array and a spread; a modifier's target context no longer renders the pool it discards, with every pool render routed through `renderedPool`; and `renderGroup` looks kept indices up in a `Set` rather than an array. No notation evaluates differently and no public type changed ([#336](https://github.com/edloidas/roll-parser/issues/336))
+
+### Documentation
+
+- `package.json` metadata is tuned for npm search: the `description` leads with queryable nouns and names the systems, `roller`, `die`, `notation`, `pathfinder` and the space-separated `dice notation` join the keywords, and seven keywords that ranked outside the top 100 for their own chip are gone. `README.md` gains a `min+brotli ≤13.5 kB` badge linking to the size breakdown ([#333](https://github.com/edloidas/roll-parser/issues/333))
+
+## [3.3.0] - 2026-08-17
+
+Error-message work throughout: nine parse and lex errors now name the rule they
+enforce, or the token actually at fault, instead of reporting parser jargon.
+Every error code is unchanged and no notation evaluates differently — nothing
+that parsed before now throws, and nothing that threw before now parses. Code
+that matches on `code` is unaffected; code that matches on `message` is not.
+
+### Added
+
+- An expression that ends where an operand was required now names what it still owed, instead of reporting a bare unexpected end. `1d` reports `Expected a side count after 'd'`, `1d20 vs` reports `Expected a difficulty class after 'vs'`, `2d6r<` reports `Expected a value after '<'`, and a truncated `2d6>=4f` names the `f` rather than the comparison behind it. The code stays `UNEXPECTED_END`, the position still points past the last token, and empty input still reports `Empty notation` at position 0 ([#327](https://github.com/edloidas/roll-parser/issues/327))
+
+### Changed
+
+- Demo site: the five failure tints derive from `--failure` through `color-mix` instead of hard-coded `rgba()` literals, so they follow the token in both themes rather than painting the pre-`#322` dark red under the light palette ([#324](https://github.com/edloidas/roll-parser/issues/324))
+
+### Fixed
+
+- The hint for an identifier that merged two modifiers no longer suggests notation that does not parse. It is gated on both halves being separable modifiers — `flor` and `kx` merely start with one, so every split of them still failed — and the separator is picked by whether the first half takes a count, so the count-less `s`, `sa`, `sd`, `cs` and `cf` split on a space instead of `1`. `4d6khs` now suggests `kh1s`; a round-trip test asserts every hint the lexer emits parses ([#326](https://github.com/edloidas/roll-parser/issues/326))
+- `2d6constructor` reports `Unexpected identifier: 'constructor'` instead of lexing into a token typed with a function. The keyword and separator tables were plain objects, so `constructor` resolved to `Object`'s own; both now have a null prototype ([#326](https://github.com/edloidas/roll-parser/issues/326))
+- `Cannot apply modifier after success counting` is replaced by `Success counting is terminal: it cannot be part of a larger expression`, which holds for all three shapes that reach the rejection — a trailing modifier, arithmetic (`5d6>=5+3`), and meta-operand reuse (`4d(1d6>=3)`). The wording matches the **Pools and checks** callout in `README.md`, which carries the worked rewrites ([#326](https://github.com/edloidas/roll-parser/issues/326))
+- `UNEXPECTED_CHARACTER` appends the code point when the rejected character is not printable ASCII, so a pasted no-break space, zero-width space or BOM reads as `Unexpected character (U+00A0): ' '` rather than an empty pair of quotes. Printable ASCII stays unadorned ([#326](https://github.com/edloidas/roll-parser/issues/326))
+- `Empty @ variable name` is replaced by `@ variable name must start with a letter or '_'`, which was the rule all along — one check rejects a missing name and a wrongly-started one alike, so `@1` and `@力` were being called empty ([#326](https://github.com/edloidas/roll-parser/issues/326))
+- `()` reports `Empty parentheses` at the opener instead of `Unexpected token ')'` at the closer, the way `{}` already did — `parseGrouped` was missing the check `parseGroup` had ([#326](https://github.com/edloidas/roll-parser/issues/326))
+- A count after a modifier that takes none — `2d6s1`, `2d6cs1`, `2d6cf1`, `2d6!0` — reports `This modifier takes no count` instead of `Unexpected infix token '1'`. The digit is not the surprise, the modifier it follows is, and "infix token" is parser jargon. The check resolves down the right spine of binary, unary and versus nodes, so `1+2d6s1` is caught too, and it stops at any closer, so `2d(2d6s)1` keeps the generic wording — the stray token there follows the group, not the modifier inside it. Two juxtaposed values (`2d6 3`) and a modifier that already took a comparison (`2d6cs>5 3`) also keep the generic wording, since those are different mistakes ([#326](https://github.com/edloidas/roll-parser/issues/326), [#327](https://github.com/edloidas/roll-parser/issues/327))
+- `vs` with nothing on its left reports `Versus needs a roll on its left` instead of `Unexpected token 'vs'` ([#326](https://github.com/edloidas/roll-parser/issues/326))
+- Demo site: the palette meets WCAG AA. `--text-dim` and `--failure` were retuned in the dark palette, and `--text-dim`, `--accent`, `--accent-soft`, `--success` and `--failure` in both light blocks, each held on its own hue and measured against `--surface-strong`; the light `--gold-gradient` stops shifted by the same lightness delta as `--accent`, lifting the hero total's leading stop from 2.81 to 3.47 ([#322](https://github.com/edloidas/roll-parser/issues/322))
+- Demo site: `site/404.html` no longer carries a stale `--accent`. Its inline light palette kept the pre-`#322` `#a06b1f` while `style.css` moved on, leaving the `code` span and the link hover/focus colour at 3.88 against the page gradient; `#855512` lifts them to 5.42 ([#322](https://github.com/edloidas/roll-parser/issues/322))
+- Demo site: `--border` meets SC 1.4.11's 3:1 non-text bar on every fill it lands on — 3.37 dark and 3.30 light at the tightest adjacency, up from 1.47 and 1.33 against `--bg`. `.widget:hover` moved from `--accent-soft` to `--accent`, since the soft tint now composites fainter than the resting border and hover read as a de-emphasis ([#323](https://github.com/edloidas/roll-parser/issues/323))
+
+### Documentation
+
+- The README bundle-size figures match the current emit: `≈13.2 kB` for the full library and `≈6.1 kB` for `{ parse }` ([#326](https://github.com/edloidas/roll-parser/issues/326), [#327](https://github.com/edloidas/roll-parser/issues/327))
+
 ## [3.2.2] - 2026-08-14
 
 ### Changed
@@ -261,7 +305,9 @@ 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.2.2...HEAD
+[Unreleased]: https://github.com/edloidas/roll-parser/compare/v3.3.1...HEAD
+[3.3.1]: https://github.com/edloidas/roll-parser/releases/tag/v3.3.1
+[3.3.0]: https://github.com/edloidas/roll-parser/releases/tag/v3.3.0
 [3.2.2]: https://github.com/edloidas/roll-parser/releases/tag/v3.2.2
 [3.2.1]: https://github.com/edloidas/roll-parser/releases/tag/v3.2.1
 [3.2.0]: https://github.com/edloidas/roll-parser/releases/tag/v3.2.0

package/README.md

@@ -13,6 +13,7 @@ Dice notation for tabletop RPGs, rolled into structured results.
   <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>
   <a href="https://nodejs.org/"><img src="https://img.shields.io/node/v/roll-parser?color=5fa04e" alt="Node.js >= 22.12"></a>
+  <a href="https://github.com/edloidas/roll-parser#why-roll-parser"><img src="https://img.shields.io/badge/min%2Bbrotli-%E2%89%A413.5%20kB-8b5cf6" alt="min+brotli ≤13.5 kB"></a>
 </p>
 
 <p align="center">
@@ -51,11 +52,11 @@ roll('4d6kh3', { rng: createMockRng([3, 6, 2, 5]) }).total; // 14, every run
 
 ## Why roll-parser
 
-- **Complete notation.** Keep/drop, three flavours of exploding dice, rerolls,
-  min/max clamps, success pools, crit thresholds, sorting, grouped rolls, PF2e
-  degrees of success, math functions, variables, computed dice — enough for D&D 5e,
-  Pathfinder, World of Darkness, Shadowrun, Fate, Savage Worlds, and Call of
-  Cthulhu without escape hatches. Spelled the way
+- **Complete notation.** A dice roller that takes keep/drop, three flavours of
+  exploding dice, rerolls, min/max clamps, success pools, crit thresholds,
+  sorting, grouped rolls, PF2e degrees of success, math functions, variables,
+  computed dice — enough for D&D 5e, Pathfinder, World of Darkness, Shadowrun,
+  Fate, Savage Worlds, and Call of Cthulhu without escape hatches. Spelled the way
   [Roll20](https://help.roll20.net/hc/en-us/articles/360037773133-Dice-Reference)
   spells it wherever the two overlap, so the notation your table already uses
   keeps working.
@@ -68,7 +69,7 @@ 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.** ≈12.8 kB brotli for the whole library, ≈5.7 kB for just
+- **Small and fast.** ≈13.2 kB brotli for the whole library, ≈6.1 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.

package/dist/evaluator/evaluator.d.ts

@@ -24,7 +24,8 @@ export { EvaluatorError };
 export declare const DEFAULT_MAX_DICE = 10000;
 export { DEFAULT_MAX_EXPLODE_ITERATIONS, DEFAULT_MAX_REROLL_ITERATIONS };
 /**
- * Per-branch mutable accumulator for tracking rolls and output during recursion.
+ * Per-branch accumulator for what flows up a recursion unchanged or merged. A
+ * field a parent reformats instead belongs on {@link EvalResult}.
  *
  * Module-level export, deliberately absent from `src/index.ts` — the package
  * surface never mentions it. See {@link mergeMetaRolls} for why the export
@@ -32,8 +33,19 @@ export { DEFAULT_MAX_EXPLODE_ITERATIONS, DEFAULT_MAX_REROLL_ITERATIONS };
  */
 export type EvalContext = {
     rolls: DieResult[];
-    expressionParts: string[];
-    renderedParts: string[];
+    /**
+     * Set by a parent that discards its child's `rendered`. Every pool modifier
+     * does: it rebuilds the breakdown from the target's `expression` plus a
+     * `renderDice` pass of its own.
+     *
+     * ! In a chain each modifier's own context is the next one out's discarded
+     * ! target, so a render site that skips the check leaves every level above the
+     * ! innermost still rendering into the void.
+     *
+     * ! Does not propagate into nested contexts — `(4d6)kh1` evaluates into a
+     * ! fresh one, so only a modifier's direct dice-pool target is spared.
+     */
+    suppressRender?: boolean;
     /**
      * Populated by `evalVersus` with the resolved degree and natural value.
      * `evaluate()` reads this from the top-level ctx to surface `degree` and

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;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"}
+{"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;;;;;;;GAOG;AACH,MAAM,MAAM,WAAW,GAAG;IACxB,KAAK,EAAE,SAAS,EAAE,CAAC;IACnB;;;;;;;;;;;OAWG;IACH,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB;;;;;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;AAmoDF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,wBAAgB,QAAQ,CAAC,GAAG,EAAE,OAAO,EAAE,GAAG,EAAE,GAAG,EAAE,OAAO,GAAE,eAAoB,GAAG,UAAU,CAgE1F"}

package/dist/evaluator/evaluator.js

@@ -26,7 +26,15 @@ function resolveLimit(value, option, fallback, min) {
 }
 export { DEFAULT_MAX_EXPLODE_ITERATIONS, DEFAULT_MAX_REROLL_ITERATIONS };
 function createContext() {
-    return { rolls: [], expressionParts: [], renderedParts: [] };
+    return { rolls: [] };
+}
+function createDiscardedRenderContext() {
+    const ctx = createContext();
+    ctx.suppressRender = true;
+    return ctx;
+}
+function renderedPool(ctx, prefix, dice) {
+    return ctx.suppressRender ? '' : `${prefix}${renderDice(dice)}`;
 }
 function partSpan(node) {
     if (node.start == null || node.end == null)
@@ -97,7 +105,7 @@ function evalNode(node, rng, ctx, env) {
 function evalNodeInner(node, rng, ctx, env) {
     switch (node.type) {
         case 'Literal':
-            return evalLiteral(node, ctx);
+            return evalLiteral(node);
         case 'Dice':
             return evalDice(node, rng, ctx, env);
         case 'FateDice':
@@ -129,34 +137,38 @@ function evalNodeInner(node, rng, ctx, env) {
         case 'CritThreshold':
             return evalCritThreshold(node, rng, ctx, env);
         case 'Variable':
-            return evalVariable(node, ctx, env);
+            return evalVariable(node, env);
         default: {
             const exhaustive = node;
             throw new EvaluatorError(`Unknown node type: ${exhaustive.type}`, 'UNKNOWN_NODE_TYPE', exhaustive.type);
         }
     }
 }
-function evalLiteral(node, ctx) {
+function evalLiteral(node) {
     const { value } = node;
-    ctx.expressionParts.push(String(value));
-    ctx.renderedParts.push(String(value));
-    return { total: value, part: { type: 'literal', value, total: value, ...partSpan(node) } };
+    const text = String(value);
+    return {
+        total: value,
+        part: { type: 'literal', value, total: value, ...partSpan(node) },
+        expression: text,
+        rendered: text,
+    };
 }
 function variableNeedsBraces(name) {
     return !/^[A-Za-z_][A-Za-z0-9_]*$/.test(name);
 }
-function evalVariable(node, ctx, env) {
+function evalVariable(node, env) {
     const present = Object.hasOwn(env.context, node.name);
     if (!present) {
         if (env.onMissingVariable === 'throw') {
             throw new EvaluatorError(`Undefined variable: ${node.name}`, 'UNDEFINED_VARIABLE', 'Variable');
         }
         const display = variableNeedsBraces(node.name) ? `@{${node.name}}` : `@${node.name}`;
-        ctx.expressionParts.push('0');
-        ctx.renderedParts.push(`${display}[0]`);
         return {
             total: 0,
             part: { type: 'variable', name: node.name, value: 0, total: 0, ...partSpan(node) },
+            expression: '0',
+            rendered: `${display}[0]`,
         };
     }
     const value = env.context[node.name];
@@ -164,11 +176,11 @@ function evalVariable(node, ctx, env) {
         throw new EvaluatorError(`Invalid variable value: ${node.name} = ${value}`, 'INVALID_VARIABLE_VALUE', 'Variable');
     }
     const display = variableNeedsBraces(node.name) ? `@{${node.name}}` : `@${node.name}`;
-    ctx.expressionParts.push(String(value));
-    ctx.renderedParts.push(`${display}[${value}]`);
     return {
         total: value,
         part: { type: 'variable', name: node.name, value, total: value, ...partSpan(node) },
+        expression: String(value),
+        rendered: `${display}[${value}]`,
     };
 }
 function evalMetaOperand(node, rng, ctx, env) {
@@ -207,9 +219,12 @@ function rollPool(count, notation, rollDie, ctx) {
         total += die.result;
     }
     appendAll(ctx.rolls, dice);
-    ctx.expressionParts.push(notation);
-    ctx.renderedParts.push(`${notation}${renderDice(dice)}`);
-    return { total, rolls: dice };
+    return {
+        total,
+        rolls: dice,
+        expression: notation,
+        rendered: ctx.suppressRender ? '' : `${notation}${renderDice(dice)}`,
+    };
 }
 function evalDice(node, rng, ctx, env) {
     const count = evalMetaOperand(node.count, rng, ctx, env);
@@ -222,15 +237,25 @@ function evalDice(node, rng, ctx, env) {
         throw new EvaluatorError(`Dice sides ${sides} exceeds maximum of ${MAX_DICE_SIDES}`, 'INVALID_DICE_SIDES', 'Dice');
     }
     chargeDice(env, count, 'Dice');
-    const { total, rolls } = rollPool(count, `${count}d${sides}`, () => createDieResult(sides, rng.nextInt(1, sides), ['kept']), ctx);
-    return { total, part: { type: 'dice', count, sides, rolls, total, ...partSpan(node) } };
+    const { total, rolls, expression, rendered } = rollPool(count, `${count}d${sides}`, () => createDieResult(sides, rng.nextInt(1, sides), ['kept']), ctx);
+    return {
+        total,
+        part: { type: 'dice', count, sides, rolls, total, ...partSpan(node) },
+        expression,
+        rendered,
+    };
 }
 function evalFateDice(node, rng, ctx, env) {
     const count = evalMetaOperand(node.count, rng, ctx, env);
     requireDiceCount(count, 'FateDice');
     chargeDice(env, count, 'FateDice');
-    const { total, rolls } = rollPool(count, `${count}dF`, () => createFateDieResult(rng.nextInt(-1, 1), ['kept']), ctx);
-    return { total, part: { type: 'fateDice', count, rolls, total, ...partSpan(node) } };
+    const { total, rolls, expression, rendered } = rollPool(count, `${count}dF`, () => createFateDieResult(rng.nextInt(-1, 1), ['kept']), ctx);
+    return {
+        total,
+        part: { type: 'fateDice', count, rolls, total, ...partSpan(node) },
+        expression,
+        rendered,
+    };
 }
 function propagateMetadata(parent, metadata) {
     if (!metadata)
@@ -251,12 +276,6 @@ function evalBinaryOp(node, rng, ctx, env) {
     const right = evalNode(node.right, rng, rightCtx, env);
     mergeContext(ctx, leftCtx);
     mergeContext(ctx, rightCtx);
-    const leftExpr = leftCtx.expressionParts.join('');
-    const rightExpr = rightCtx.expressionParts.join('');
-    const leftRendered = leftCtx.renderedParts.join('');
-    const rightRendered = rightCtx.renderedParts.join('');
-    ctx.expressionParts.push(`${leftExpr} ${node.operator} ${rightExpr}`);
-    ctx.renderedParts.push(`${leftRendered} ${node.operator} ${rightRendered}`);
     const total = applyBinaryOperator(node.operator, left.total, right.total);
     return {
         total,
@@ -268,6 +287,8 @@ function evalBinaryOp(node, rng, ctx, env) {
             total,
             ...partSpan(node),
         },
+        expression: `${left.expression} ${node.operator} ${right.expression}`,
+        rendered: `${left.rendered} ${node.operator} ${right.rendered}`,
     };
 }
 function applyBinaryOperator(operator, left, right) {
@@ -300,25 +321,23 @@ function evalUnaryOp(node, rng, ctx, env) {
     const innerCtx = createContext();
     const inner = evalNode(node.operand, rng, innerCtx, env);
     mergeContext(ctx, innerCtx);
-    const innerExpr = innerCtx.expressionParts.join('');
-    const innerRendered = innerCtx.renderedParts.join('');
-    ctx.expressionParts.push(`-${innerExpr}`);
-    ctx.renderedParts.push(`-${innerRendered}`);
     const total = -inner.total;
     return {
         total,
         part: { type: 'unaryOp', operator: '-', operand: inner.part, total, ...partSpan(node) },
+        expression: `-${inner.expression}`,
+        rendered: `-${inner.rendered}`,
     };
 }
 function evalGrouped(node, rng, ctx, env) {
     const innerCtx = createContext();
     const inner = evalNode(node.expression, rng, innerCtx, env);
     mergeContext(ctx, innerCtx);
-    ctx.expressionParts.push(`(${innerCtx.expressionParts.join('')})`);
-    ctx.renderedParts.push(`(${innerCtx.renderedParts.join('')})`);
     return {
         total: inner.total,
         part: { type: 'grouped', inner: inner.part, total: inner.total, ...partSpan(node) },
+        expression: `(${inner.expression})`,
+        rendered: `(${inner.rendered})`,
     };
 }
 function evalGroup(node, rng, ctx, env) {
@@ -330,14 +349,17 @@ function evalGroup(node, rng, ctx, env) {
         const subCtx = createContext();
         const sub = evalNode(expr, rng, subCtx, env);
         mergeContext(ctx, subCtx);
-        subExprs.push(subCtx.expressionParts.join(''));
-        subRendered.push(subCtx.renderedParts.join(''));
+        subExprs.push(sub.expression);
+        subRendered.push(sub.rendered);
         subParts.push(sub.part);
         total += sub.total;
     }
-    ctx.expressionParts.push(`{${subExprs.join(', ')}}`);
-    ctx.renderedParts.push(`{${subRendered.join(', ')}}`);
-    return { total, part: { type: 'group', parts: subParts, total, ...partSpan(node) } };
+    return {
+        total,
+        part: { type: 'group', parts: subParts, total, ...partSpan(node) },
+        expression: `{${subExprs.join(', ')}}`,
+        rendered: `{${subRendered.join(', ')}}`,
+    };
 }
 function evalFunctionCall(node, rng, ctx, env) {
     const argCtxs = [];
@@ -350,10 +372,6 @@ function evalFunctionCall(node, rng, ctx, env) {
     for (const argCtx of argCtxs) {
         mergeContext(ctx, argCtx);
     }
-    const argExprs = argCtxs.map((c) => c.expressionParts.join(''));
-    const argRendereds = argCtxs.map((c) => c.renderedParts.join(''));
-    ctx.expressionParts.push(`${node.name}(${argExprs.join(', ')})`);
-    ctx.renderedParts.push(`${node.name}(${argRendereds.join(', ')})`);
     const total = applyFunction(node.name, argResults.map((r) => r.total));
     return {
         total,
@@ -364,6 +382,8 @@ function evalFunctionCall(node, rng, ctx, env) {
             total,
             ...partSpan(node),
         },
+        expression: `${node.name}(${argResults.map((r) => r.expression).join(', ')})`,
+        rendered: `${node.name}(${argResults.map((r) => r.rendered).join(', ')})`,
     };
 }
 function applyFunction(name, values) {
@@ -474,9 +494,9 @@ function formatExplodeCode(variant, threshold, thresholdValue) {
     return `${marker}${threshold.operator}${thresholdValue}`;
 }
 function evalExplode(node, rng, ctx, env) {
-    const targetCtx = createContext();
+    const targetCtx = createDiscardedRenderContext();
     const target = evalNode(node.target, rng, targetCtx, env);
-    const targetExpr = targetCtx.expressionParts.join('');
+    const targetExpr = target.expression;
     let thresholdValue;
     if (node.threshold != null) {
         thresholdValue = evalMetaOperand(node.threshold.value, rng, ctx, env);
@@ -497,31 +517,35 @@ function evalExplode(node, rng, ctx, env) {
         return part;
     };
     if (targetCtx.rolls.length === 0) {
-        ctx.expressionParts.push(`${targetExpr}${code}`);
-        ctx.renderedParts.push(`${targetExpr}${code}`);
-        return { total: target.total, part: buildPart(target.total, targetCtx.rolls) };
+        return {
+            total: target.total,
+            part: buildPart(target.total, targetCtx.rolls),
+            expression: `${targetExpr}${code}`,
+            rendered: ctx.suppressRender ? '' : `${targetExpr}${code}`,
+        };
     }
     const shouldExplode = buildShouldExplode(node.threshold?.operator, thresholdValue);
     const expanded = EXPLODE_APPLIERS[node.variant](targetCtx.rolls, shouldExplode, rng, env);
     appendAll(ctx.rolls, expanded);
-    ctx.expressionParts.push(`${targetExpr}${code}`);
-    ctx.renderedParts.push(`${targetExpr}${code}${renderDice(expanded)}`);
     const total = sumKeptDice(expanded, env.hasVersusDc);
-    return { total, part: buildPart(total, expanded) };
+    return {
+        total,
+        part: buildPart(total, expanded),
+        expression: `${targetExpr}${code}`,
+        rendered: renderedPool(ctx, `${targetExpr}${code}`, expanded),
+    };
 }
 function evalReroll(node, rng, ctx, env) {
-    const targetCtx = createContext();
+    const targetCtx = createDiscardedRenderContext();
     const target = evalNode(node.target, rng, targetCtx, env);
     const thresholdValue = evalMetaOperand(node.condition.value, rng, ctx, env);
     const code = `${node.once ? 'ro' : 'r'}${node.condition.operator}${thresholdValue}`;
-    const modifierExpr = joinModifierCode(targetCtx.expressionParts.join(''), code);
+    const modifierExpr = joinModifierCode(target.expression, code);
     const condition = {
         operator: node.condition.operator,
         value: thresholdValue,
     };
     if (targetCtx.rolls.length === 0) {
-        ctx.expressionParts.push(modifierExpr);
-        ctx.renderedParts.push(modifierExpr);
         const total = sumKeptDice(targetCtx.rolls, env.hasVersusDc);
         return {
             total,
@@ -534,14 +558,14 @@ function evalReroll(node, rng, ctx, env) {
                 total,
                 ...partSpan(node),
             },
+            expression: modifierExpr,
+            rendered: ctx.suppressRender ? '' : modifierExpr,
         };
     }
     const pool = node.once
         ? applyRerollOnce(targetCtx.rolls, node.condition.operator, thresholdValue, rng, env)
         : applyRecursiveReroll(targetCtx.rolls, node.condition.operator, thresholdValue, rng, env);
     appendAll(ctx.rolls, pool);
-    ctx.expressionParts.push(modifierExpr);
-    ctx.renderedParts.push(`${modifierExpr}${renderDice(pool)}`);
     const total = sumKeptDice(pool, env.hasVersusDc);
     return {
         total,
@@ -554,10 +578,12 @@ function evalReroll(node, rng, ctx, env) {
             total,
             ...partSpan(node),
         },
+        expression: modifierExpr,
+        rendered: renderedPool(ctx, modifierExpr, pool),
     };
 }
 function evalDieBound(node, rng, ctx, env) {
-    const targetCtx = createContext();
+    const targetCtx = createDiscardedRenderContext();
     const target = evalNode(node.target, rng, targetCtx, env);
     const boundValue = evalMetaOperand(node.value, rng, ctx, env);
     if (!Number.isFinite(boundValue)) {
@@ -566,11 +592,11 @@ function evalDieBound(node, rng, ctx, env) {
     applyDieBound(targetCtx.rolls, node.bound, boundValue, env.hasVersusDc);
     appendAll(ctx.rolls, targetCtx.rolls);
     const code = boundValue < 0 ? `${node.bound}(${boundValue})` : `${node.bound}${boundValue}`;
-    const modifierExpr = joinModifierCode(targetCtx.expressionParts.join(''), code);
-    ctx.expressionParts.push(modifierExpr);
-    ctx.renderedParts.push(`${modifierExpr}${renderDice(targetCtx.rolls)}`);
+    const modifierExpr = joinModifierCode(target.expression, code);
     const total = sumKeptDice(targetCtx.rolls, env.hasVersusDc);
     return {
+        expression: modifierExpr,
+        rendered: renderedPool(ctx, modifierExpr, targetCtx.rolls),
         total,
         part: {
             type: 'dieBound',
@@ -583,16 +609,16 @@ function evalDieBound(node, rng, ctx, env) {
     };
 }
 function evalSort(node, rng, ctx, env) {
-    const targetCtx = createContext();
+    const targetCtx = createDiscardedRenderContext();
     const target = evalNode(node.target, rng, targetCtx, env);
     const sortedRolls = sortDice(targetCtx.rolls, node.order, env.hasVersusDc);
     appendAll(ctx.rolls, sortedRolls);
     propagateMetadata(ctx, targetCtx.versusMetadata);
     const code = node.order === 'ascending' ? 's' : 'sd';
-    const modifierExpr = joinModifierCode(targetCtx.expressionParts.join(''), code);
-    ctx.expressionParts.push(modifierExpr);
-    ctx.renderedParts.push(`${modifierExpr}${renderDice(sortedRolls)}`);
+    const modifierExpr = joinModifierCode(target.expression, code);
     return {
+        expression: modifierExpr,
+        rendered: renderedPool(ctx, modifierExpr, sortedRolls),
         total: target.total,
         part: {
             type: 'sort',
@@ -605,7 +631,7 @@ function evalSort(node, rng, ctx, env) {
     };
 }
 function evalCritThreshold(node, rng, ctx, env) {
-    const targetCtx = createContext();
+    const targetCtx = createDiscardedRenderContext();
     const target = evalNode(node.target, rng, targetCtx, env);
     const successResolved = node.successThresholds.map((t) => resolveCritThreshold(t, rng, ctx, env));
     const failResolved = node.failThresholds.map((t) => resolveCritThreshold(t, rng, ctx, env));
@@ -617,10 +643,10 @@ function evalCritThreshold(node, rng, ctx, env) {
     const modifierExpr = [
         ...successResolved.map((t) => (t === 'default' ? 'cs' : `cs${t.operator}${t.value}`)),
         ...failResolved.map((t) => (t === 'default' ? 'cf' : `cf${t.operator}${t.value}`)),
-    ].reduce(joinModifierCode, targetCtx.expressionParts.join(''));
-    ctx.expressionParts.push(modifierExpr);
-    ctx.renderedParts.push(`${modifierExpr}${renderDice(targetCtx.rolls)}`);
+    ].reduce(joinModifierCode, target.expression);
     return {
+        expression: modifierExpr,
+        rendered: renderedPool(ctx, modifierExpr, targetCtx.rolls),
         total: target.total,
         part: {
             type: 'critThreshold',
@@ -646,15 +672,13 @@ function evalKeepDrop(node, rng, ctx, env) {
     if (baseTarget.type === 'Group' && baseTarget.expressions.length >= 2) {
         return evalGroupKeepDrop(node, baseTarget, specs, rng, ctx, env);
     }
-    const targetCtx = createContext();
+    const targetCtx = createDiscardedRenderContext();
     const target = evalNode(baseTarget, rng, targetCtx, env);
     const mergedDice = mergeDropSets(targetCtx.rolls, specs, env.hasVersusDc);
     appendAll(ctx.rolls, mergedDice);
     const total = sumKeptDice(mergedDice, env.hasVersusDc);
-    const targetExpr = targetCtx.expressionParts.join('');
+    const targetExpr = target.expression;
     const keepDropCodes = specs.map((s) => `${s.code}${s.count}`).join('');
-    ctx.expressionParts.push(joinModifierCode(targetExpr, keepDropCodes));
-    ctx.renderedParts.push(`${targetExpr}${renderDice(mergedDice)}`);
     return {
         total,
         part: {
@@ -664,6 +688,8 @@ function evalKeepDrop(node, rng, ctx, env) {
             total,
             ...partSpan(node),
         },
+        expression: joinModifierCode(targetExpr, keepDropCodes),
+        rendered: renderedPool(ctx, targetExpr, mergedDice),
     };
 }
 function stripInnerMarkers(rendered) {
@@ -682,8 +708,8 @@ function evalGroupKeepDrop(node, group, specs, rng, ctx, env) {
             subtotal: sub.total,
             part: sub.part,
             rolls: subCtx.rolls,
-            expr: subCtx.expressionParts.join(''),
-            rendered: subCtx.renderedParts.join(''),
+            expr: sub.expression,
+            rendered: sub.rendered,
             versusMetadata: subCtx.versusMetadata,
             scoredSuccesses: env.subtotalSuccesses - successTally,
             scoredFailures: env.subtotalFailures - failureTally,
@@ -725,8 +751,6 @@ function evalGroupKeepDrop(node, group, specs, rng, ctx, env) {
     }
     const subExprStrs = subRolls.map((s) => s.expr);
     const keepDropCodes = specs.map((s) => `${s.code}${s.count}`).join('');
-    ctx.expressionParts.push(`{${subExprStrs.join(', ')}}${keepDropCodes}`);
-    ctx.renderedParts.push(`{${outerRendered.join(', ')}}`);
     const groupPart = {
         type: 'group',
         parts: subRolls.map((s) => s.part),
@@ -743,6 +767,8 @@ function evalGroupKeepDrop(node, group, specs, rng, ctx, env) {
             total,
             ...partSpan(node),
         },
+        expression: `{${subExprStrs.join(', ')}}${keepDropCodes}`,
+        rendered: `{${outerRendered.join(', ')}}`,
     };
 }
 function resolveThreshold(value, rng, ctx, env, role) {
@@ -760,7 +786,7 @@ function evalSuccessCount(node, rng, ctx, env) {
     const failureTallyBefore = env.subtotalFailures;
     const targetCtx = createContext();
     const target = evalNode(node.target, rng, targetCtx, env);
-    const targetExpr = targetCtx.expressionParts.join('');
+    const targetExpr = target.expression;
     const poolAlreadyCounted = env.hasSuccessCount;
     env.hasSuccessCount = true;
     const thresholdValue = resolveThreshold(node.threshold.value, rng, ctx, env, 'threshold');
@@ -803,9 +829,12 @@ function evalSuccessCount(node, rng, ctx, env) {
         }
     }
     if (pool.length === 0) {
-        ctx.expressionParts.push(`${targetExpr}${code}`);
-        ctx.renderedParts.push(`${targetExpr}${code}`);
-        return { total: 0, part: buildPart(0, 0, 0) };
+        return {
+            total: 0,
+            part: buildPart(0, 0, 0),
+            expression: `${targetExpr}${code}`,
+            rendered: `${targetExpr}${code}`,
+        };
     }
     const result = countSuccesses(pool, { operator: node.threshold.operator, value: thresholdValue }, failValue != null && node.failThreshold != null
         ? { operator: node.failThreshold.operator, value: failValue }
@@ -815,13 +844,13 @@ function evalSuccessCount(node, rng, ctx, env) {
         env.subtotalFailures = failureTallyBefore + result.failures;
     }
     appendAll(ctx.rolls, targetCtx.rolls);
-    ctx.expressionParts.push(`${targetExpr}${code}`);
-    ctx.renderedParts.push(bySubtotal
-        ? `${stripTallyMarkers(targetCtx.renderedParts.join(''))}${code}`
-        : `${targetExpr}${code}${renderDice(targetCtx.rolls)}`);
     return {
         total: result.total,
         part: buildPart(result.total, result.successes, result.failures),
+        expression: `${targetExpr}${code}`,
+        rendered: bySubtotal
+            ? `${stripTallyMarkers(target.rendered)}${code}`
+            : renderedPool(ctx, `${targetExpr}${code}`, targetCtx.rolls),
     };
 }
 function extractNatural(rolls, env) {
@@ -879,12 +908,6 @@ function evalVersus(node, rng, ctx, env) {
         if (dcCtx.rolls.length > 0)
             env.hasVersusDc = true;
         appendAll(ctx.rolls, dcCtx.rolls);
-        const rollExpr = rollCtx.expressionParts.join('');
-        const dcExpr = dcCtx.expressionParts.join('');
-        const rollRendered = rollCtx.renderedParts.join('');
-        const dcRendered = dcCtx.renderedParts.join('');
-        ctx.expressionParts.push(`${rollExpr} vs ${dcExpr}`);
-        ctx.renderedParts.push(`${rollRendered} vs ${dcRendered}`);
         ctx.versusMetadata = { degree, natural, dcTotal: dcResult.total };
         return {
             total: rollResult.total,
@@ -896,6 +919,8 @@ function evalVersus(node, rng, ctx, env) {
                 total: rollResult.total,
                 ...partSpan(node),
             },
+            expression: `${rollResult.expression} vs ${dcResult.expression}`,
+            rendered: `${rollResult.rendered} vs ${dcResult.rendered}`,
         };
     }
     finally {
@@ -924,13 +949,12 @@ export function evaluate(ast, rng, options = {}) {
         onMissingVariable,
     };
     const ctx = createContext();
-    const { total, part } = evalNode(ast, rng, ctx, env);
+    const { total, part, expression, rendered: renderedBody } = evalNode(ast, rng, ctx, env);
     if (!Number.isFinite(total)) {
         throw new EvaluatorError(`Result is not a finite number: ${total}`, 'NON_FINITE_RESULT', ast.type);
     }
-    const expression = ctx.expressionParts.join('');
     const trailing = ctx.versusMetadata ? degreeLabel(ctx.versusMetadata.degree) : String(total);
-    const rendered = `${ctx.renderedParts.join('')} = ${trailing}`;
+    const rendered = `${renderedBody} = ${trailing}`;
     const versus = ctx.versusMetadata;
     return {
         total,