roll-parser 3.3.0 → 3.3.1

package/CHANGELOG.md

@@ -7,6 +7,16 @@ 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
@@ -295,7 +305,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.3.0...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

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.

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,