roll-parser 3.0.0 → 3.2.0

package/src/evaluator/evaluator.ts

@@ -5,6 +5,7 @@
  */
 
 import { describeValue, EvaluatorError, RollParserError, stampEvaluatorSpan } from '../errors.js';
+import { joinModifierCode } from '../notation.js';
 import type {
   ASTNode,
   BinaryOpNode,
@@ -55,9 +56,12 @@ import {
 } from './modifiers/explode.js';
 import {
   isVersusDc,
+  META_MERGE_FLAGS,
   rewriteFlags,
   SELECTION_AND_TALLY_FLAGS,
   SELECTION_FLAGS,
+  stripFlags,
+  TALLY_FLAGS,
 } from './modifiers/flags.js';
 import { markDroppedIndices, sumKeptDice } from './modifiers/keep-drop.js';
 import {
@@ -263,6 +267,10 @@ function renderDie(result: number, modifiers: readonly DieModifier[]): string {
  * `sumKeptDice`; `'meta'` lets renderers hide them and lets callers
  * distinguish them from ordinary pool dice.
  *
+ * `'meta'` is stripped before being re-added: meta operands nest
+ * (`((1d2)d4)d6`), so the innermost dice pass through here once per level and
+ * an append-only rewrite would leave them carrying the tag once per level.
+ *
  * `'success'`/`'failure'` tags are stripped here as defense-in-depth against
  * a SuccessCount leaking into a meta sub-expression (parser rejects all such
  * wrappings; this strip ensures a future parse regression cannot leak tags
@@ -279,7 +287,7 @@ export function mergeMetaRolls(parent: EvalContext, source: EvalContext): void {
   for (const die of source.rolls) {
     parent.rolls.push({
       ...die,
-      modifiers: rewriteFlags(die.modifiers, SELECTION_AND_TALLY_FLAGS, 'meta', 'dropped'),
+      modifiers: rewriteFlags(die.modifiers, META_MERGE_FLAGS, 'meta', 'dropped'),
     });
   }
 }
@@ -475,11 +483,31 @@ function evalMetaOperand(node: ASTNode, rng: RNG, ctx: EvalContext, env: EvalEnv
   }
 
   const metaCtx = createContext();
-  const value = evalNode(node, rng, metaCtx, env).total;
+  // The tally counterpart of the `TALLY_FLAGS` strip in `mergeMetaRolls`.
+  const value = evalDiscardingSubtotals(node, rng, metaCtx, env).total;
   mergeMetaRolls(ctx, metaCtx);
   return value;
 }
 
+/**
+ * Evaluates a node whose result is consumed as a scalar — a meta operand or a
+ * `vs` DC — rolling back any subtotal verdicts it scored so they never reach
+ * the top-level tally.
+ */
+function evalDiscardingSubtotals(
+  node: ASTNode,
+  rng: RNG,
+  ctx: EvalContext,
+  env: EvalEnv,
+): EvalResult {
+  const successTally = env.subtotalSuccesses;
+  const failureTally = env.subtotalFailures;
+  const result = evalNode(node, rng, ctx, env);
+  env.subtotalSuccesses = successTally;
+  env.subtotalFailures = failureTally;
+  return result;
+}
+
 /** Rejects dice counts that cannot address a pool. */
 function requireDiceCount(count: number, nodeType: 'Dice' | 'FateDice'): void {
   if (!Number.isInteger(count) || count < 0) {
@@ -952,11 +980,15 @@ function flattenKeepDropChain(
  * selects against the unmodified pool: `markDroppedIndices` reads results and
  * writes only into `droppedMask`, so no spec can observe another's outcome.
  */
-function mergeDropSets(baseDice: DieResult[], specs: KeepDropChainEntry[]): DieResult[] {
+function mergeDropSets(
+  baseDice: DieResult[],
+  specs: KeepDropChainEntry[],
+  hasVersusDc: boolean,
+): DieResult[] {
   const droppedMask = new Uint8Array(baseDice.length);
 
   for (const spec of specs) {
-    markDroppedIndices(baseDice, spec.count, spec.kind, spec.selector, droppedMask);
+    markDroppedIndices(baseDice, spec.count, spec.kind, spec.selector, droppedMask, hasVersusDc);
   }
 
   for (let index = 0; index < baseDice.length; index++) {
@@ -1019,10 +1051,11 @@ function evalExplode(node: ExplodeNode, rng: RNG, ctx: EvalContext, env: EvalEnv
 
   const code = formatExplodeCode(node.variant, node.threshold, thresholdValue);
 
-  const buildPart = (total: number): RollPart => {
+  const buildPart = (total: number, rolls: DieResult[]): RollPart => {
     const part: RollPart = {
       type: 'explode',
       variant: node.variant,
+      rolls,
       target: target.part,
       total,
       ...partSpan(node),
@@ -1037,7 +1070,7 @@ function evalExplode(node: ExplodeNode, rng: RNG, ctx: EvalContext, env: EvalEnv
   if (targetCtx.rolls.length === 0) {
     ctx.expressionParts.push(`${targetExpr}${code}`);
     ctx.renderedParts.push(`${targetExpr}${code}`);
-    return { total: target.total, part: buildPart(target.total) };
+    return { total: target.total, part: buildPart(target.total, targetCtx.rolls) };
   }
 
   const shouldExplode = buildShouldExplode(node.threshold?.operator, thresholdValue);
@@ -1050,18 +1083,18 @@ function evalExplode(node: ExplodeNode, rng: RNG, ctx: EvalContext, env: EvalEnv
   // are self-evident, explosion origin is otherwise invisible.
   ctx.renderedParts.push(`${targetExpr}${code}${renderDice(expanded)}`);
 
-  const total = sumKeptDice(expanded);
-  return { total, part: buildPart(total) };
+  const total = sumKeptDice(expanded, env.hasVersusDc);
+  return { total, part: buildPart(total, expanded) };
 }
 
 function evalReroll(node: RerollNode, rng: RNG, ctx: EvalContext, env: EvalEnv): EvalResult {
   const targetCtx = createContext();
   const target = evalNode(node.target, rng, targetCtx, env);
-  const targetExpr = targetCtx.expressionParts.join('');
 
   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 condition: ResolvedComparePoint = {
     operator: node.condition.operator,
     value: thresholdValue,
@@ -1069,15 +1102,16 @@ function evalReroll(node: RerollNode, rng: RNG, ctx: EvalContext, env: EvalEnv):
 
   // No-op when the target produced no dice (e.g., `(1+2)r<5`).
   if (targetCtx.rolls.length === 0) {
-    ctx.expressionParts.push(`${targetExpr}${code}`);
-    ctx.renderedParts.push(`${targetExpr}${code}`);
-    const total = sumKeptDice(targetCtx.rolls);
+    ctx.expressionParts.push(modifierExpr);
+    ctx.renderedParts.push(modifierExpr);
+    const total = sumKeptDice(targetCtx.rolls, env.hasVersusDc);
     return {
       total,
       part: {
         type: 'reroll',
         once: node.once,
         condition,
+        rolls: targetCtx.rolls,
         target: target.part,
         total,
         ...partSpan(node),
@@ -1090,16 +1124,17 @@ function evalReroll(node: RerollNode, rng: RNG, ctx: EvalContext, env: EvalEnv):
     : applyRecursiveReroll(targetCtx.rolls, node.condition.operator, thresholdValue, rng, env);
 
   appendAll(ctx.rolls, pool);
-  ctx.expressionParts.push(`${targetExpr}${code}`);
-  ctx.renderedParts.push(`${targetExpr}${code}${renderDice(pool)}`);
+  ctx.expressionParts.push(modifierExpr);
+  ctx.renderedParts.push(`${modifierExpr}${renderDice(pool)}`);
 
-  const total = sumKeptDice(pool);
+  const total = sumKeptDice(pool, env.hasVersusDc);
   return {
     total,
     part: {
       type: 'reroll',
       once: node.once,
       condition,
+      rolls: pool,
       target: target.part,
       total,
       ...partSpan(node),
@@ -1126,22 +1161,22 @@ function evalDieBound(node: DieBoundNode, rng: RNG, ctx: EvalContext, env: EvalE
     );
   }
 
-  applyDieBound(targetCtx.rolls, node.bound, boundValue);
+  applyDieBound(targetCtx.rolls, node.bound, boundValue, env.hasVersusDc);
 
   appendAll(ctx.rolls, targetCtx.rolls);
   // ! No `propagateMetadata` here: clamping re-sums, so a propagated `degree`
   // ! would have been resolved against a total this node just replaced.
   // ! See the rule on `propagateMetadata`.
 
-  const targetExpr = targetCtx.expressionParts.join('');
   // Negative bounds render parenthesized so `result.expression` re-parses
   // (`4d6min-2` is a syntax error; `4d6min(-2)` is not).
   const code = boundValue < 0 ? `${node.bound}(${boundValue})` : `${node.bound}${boundValue}`;
+  const modifierExpr = joinModifierCode(targetCtx.expressionParts.join(''), code);
 
-  ctx.expressionParts.push(`${targetExpr}${code}`);
-  ctx.renderedParts.push(`${targetExpr}${code}${renderDice(targetCtx.rolls)}`);
+  ctx.expressionParts.push(modifierExpr);
+  ctx.renderedParts.push(`${modifierExpr}${renderDice(targetCtx.rolls)}`);
 
-  const total = sumKeptDice(targetCtx.rolls);
+  const total = sumKeptDice(targetCtx.rolls, env.hasVersusDc);
   return {
     total,
     part: {
@@ -1175,16 +1210,16 @@ function evalSort(node: SortNode, rng: RNG, ctx: EvalContext, env: EvalEnv): Eva
   const targetCtx = createContext();
   const target = evalNode(node.target, rng, targetCtx, env);
 
-  const sortedRolls = sortDice(targetCtx.rolls, node.order);
+  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 targetExpr = targetCtx.expressionParts.join('');
+  const modifierExpr = joinModifierCode(targetCtx.expressionParts.join(''), code);
 
-  ctx.expressionParts.push(`${targetExpr}${code}`);
-  ctx.renderedParts.push(`${targetExpr}${code}${renderDice(sortedRolls)}`);
+  ctx.expressionParts.push(modifierExpr);
+  ctx.renderedParts.push(`${modifierExpr}${renderDice(sortedRolls)}`);
 
   return {
     total: target.total,
@@ -1210,8 +1245,12 @@ function evalSort(node: SortNode, rng: RNG, ctx: EvalContext, env: EvalEnv): Eva
  * crit criteria and `cf` thresholds replace only the fumble criteria. When a
  * side has no explicit threshold, the `'default'` rule applies — so
  * `1d20cf<3` keeps the default nat-20 crit. Bare `cs`/`cf` uses the
- * `'default'` sentinel resolved per-die to `result === sides` or
- * `result === 1`.
+ * `'default'` sentinel, resolved per-die against the natural face
+ * (`initialResult ?? result`) rather than the possibly-rewritten `result`.
+ *
+ * The resolved rule is recorded per die, so an enclosing explode or reroll
+ * judges the dice it mints by it too — `1d6cs<2!` no longer reports the
+ * default-rule crit the user overrode.
  *
  * Renders `<targetExpr><codes>[<dice>]`, mirroring `evalSort`/`evalExplode`.
  */
@@ -1233,19 +1272,18 @@ function evalCritThreshold(
     successResolved.length > 0 ? successResolved : ['default'];
   const failApplied: ResolvedCritThreshold[] = failResolved.length > 0 ? failResolved : ['default'];
 
-  applyCritThresholds(targetCtx.rolls, successApplied, failApplied);
+  applyCritThresholds(targetCtx.rolls, successApplied, failApplied, env);
 
   appendAll(ctx.rolls, targetCtx.rolls);
   propagateMetadata(ctx, targetCtx.versusMetadata);
 
-  const targetExpr = targetCtx.expressionParts.join('');
-  const codes = [
+  const modifierExpr = [
     ...successResolved.map((t) => (t === 'default' ? 'cs' : `cs${t.operator}${t.value}`)),
     ...failResolved.map((t) => (t === 'default' ? 'cf' : `cf${t.operator}${t.value}`)),
-  ].join('');
+  ].reduce(joinModifierCode, targetCtx.expressionParts.join(''));
 
-  ctx.expressionParts.push(`${targetExpr}${codes}`);
-  ctx.renderedParts.push(`${targetExpr}${codes}${renderDice(targetCtx.rolls)}`);
+  ctx.expressionParts.push(modifierExpr);
+  ctx.renderedParts.push(`${modifierExpr}${renderDice(targetCtx.rolls)}`);
 
   return {
     total: target.total,
@@ -1296,16 +1334,16 @@ function evalKeepDrop(node: KeepDropNode, rng: RNG, ctx: EvalContext, env: EvalE
   const targetCtx = createContext();
   const target = evalNode(baseTarget, rng, targetCtx, env);
 
-  const mergedDice = mergeDropSets(targetCtx.rolls, specs);
+  const mergedDice = mergeDropSets(targetCtx.rolls, specs, env.hasVersusDc);
 
   appendAll(ctx.rolls, mergedDice);
 
-  const total = sumKeptDice(mergedDice);
+  const total = sumKeptDice(mergedDice, env.hasVersusDc);
 
   const targetExpr = targetCtx.expressionParts.join('');
   const keepDropCodes = specs.map((s) => `${s.code}${s.count}`).join('');
 
-  ctx.expressionParts.push(`${targetExpr}${keepDropCodes}`);
+  ctx.expressionParts.push(joinModifierCode(targetExpr, keepDropCodes));
   ctx.renderedParts.push(`${targetExpr}${renderDice(mergedDice)}`);
 
   return {
@@ -1328,10 +1366,17 @@ function evalKeepDrop(node: KeepDropNode, rng: RNG, ctx: EvalContext, env: EvalE
  * success highlights inside a dropped span.
  */
 function stripInnerMarkers(rendered: string): string {
-  return rendered
-    .replace(/\*\*(-?\d+)\*\*/g, '$1')
-    .replace(/__(-?\d+)__/g, '$1')
-    .replace(/~~(-?\d+)~~/g, '$1');
+  return stripTallyMarkers(rendered).replace(/~~(-?\d+)~~/g, '$1');
+}
+
+/**
+ * Strips success (`**`) and failure (`__`) markers from an already-rendered
+ * sub-roll, leaving dropped dice struck. Pairs with a `TALLY_FLAGS` strip: the
+ * tags and the text they produced have to go together, or `renderBreakdown`
+ * stops reproducing `rendered`.
+ */
+function stripTallyMarkers(rendered: string): string {
+  return rendered.replace(/\*\*(-?\d+)\*\*/g, '$1').replace(/__(-?\d+)__/g, '$1');
 }
 
 /**
@@ -1358,10 +1403,16 @@ function evalGroupKeepDrop(
     expr: string;
     rendered: string;
     versusMetadata: EvalContext['versusMetadata'];
+    scoredSuccesses: number;
+    scoredFailures: number;
   };
 
   const subRolls: SubRoll[] = group.expressions.map((expr) => {
     const subCtx = createContext();
+    // What a subtotal count inside this sub-roll scored, so a drop can take it
+    // back — the tally counterpart of the `TALLY_FLAGS` rewrite below.
+    const successTally = env.subtotalSuccesses;
+    const failureTally = env.subtotalFailures;
     const sub = evalNode(expr, rng, subCtx, env);
     return {
       subtotal: sub.total,
@@ -1370,6 +1421,8 @@ function evalGroupKeepDrop(
       expr: subCtx.expressionParts.join(''),
       rendered: subCtx.renderedParts.join(''),
       versusMetadata: subCtx.versusMetadata,
+      scoredSuccesses: env.subtotalSuccesses - successTally,
+      scoredFailures: env.subtotalFailures - failureTally,
     };
   });
 
@@ -1383,7 +1436,7 @@ function evalGroupKeepDrop(
     fumble: false,
   }));
 
-  const mergedSynthetic = mergeDropSets(syntheticDice, specs);
+  const mergedSynthetic = mergeDropSets(syntheticDice, specs, env.hasVersusDc);
 
   const outerRendered: string[] = [];
   const keptIndices: number[] = [];
@@ -1402,6 +1455,10 @@ function evalGroupKeepDrop(
       for (const die of sub.rolls) {
         die.modifiers = rewriteFlags(die.modifiers, SELECTION_AND_TALLY_FLAGS, 'dropped');
       }
+      // A count on subtotals left no tag for the rewrite above to strip, so its
+      // verdicts come back from the env tally instead.
+      env.subtotalSuccesses -= sub.scoredSuccesses;
+      env.subtotalFailures -= sub.scoredFailures;
       appendAll(ctx.rolls, sub.rolls);
       outerRendered.push(`~~${stripInnerMarkers(sub.rendered)}~~`);
     } else {
@@ -1489,14 +1546,24 @@ function evalSuccessCount(
   ctx: EvalContext,
   env: EvalEnv,
 ): EvalResult {
-  // Flag tracks syntactic presence of success-count notation, not pool size —
-  // set before any early return so empty pools still populate successes/failures.
-  env.hasSuccessCount = true;
+  // Rolled back below, so a subtotal count nested in the target
+  // (`{{2d6, 2d6}>=10, 1d8}>=1`) is not reported alongside the subtotal this
+  // pass re-scores it into.
+  const successTallyBefore = env.subtotalSuccesses;
+  const failureTallyBefore = env.subtotalFailures;
 
   const targetCtx = createContext();
   const target = evalNode(node.target, rng, targetCtx, env);
   const targetExpr = targetCtx.expressionParts.join('');
 
+  // True once any count has run: an inner one that tagged this very pool (only
+  // a group can arrange that — `{4d6>=5}<=2f5`), or an unrelated earlier one,
+  // which costs a redundant strip over dice nothing tagged. The flag otherwise
+  // tracks syntactic presence of success-count notation, not pool size — set
+  // before any early return so empty pools still populate successes/failures.
+  const poolAlreadyCounted = env.hasSuccessCount;
+  env.hasSuccessCount = true;
+
   const thresholdValue = resolveThreshold(node.threshold.value, rng, ctx, env, 'threshold');
   const failValue =
     node.failThreshold != null
@@ -1514,6 +1581,7 @@ function evalSuccessCount(
     const part: RollPart = {
       type: 'successCount',
       threshold: { operator: node.threshold.operator, value: thresholdValue },
+      rolls: targetCtx.rolls,
       target: target.part,
       successes,
       failures,
@@ -1526,26 +1594,66 @@ function evalSuccessCount(
     return part;
   };
 
-  // No-op when the target produced no dice (`0d6>=4`); `containsDicePool`
-  // should already reject dice-less targets at parse time. `target.total` is 0
-  // for an empty pool, so `total === successes - failures` still holds.
-  if (targetCtx.rolls.length === 0) {
+  // Multi-sub-roll group: the units are sub-roll subtotals, not dice. The
+  // `sides = 0` synthetics are `evalGroupKeepDrop`'s sentinel and never reach
+  // `ctx.rolls`. Only a direct group target arrives here — the parser refuses
+  // every form that would reach the count with the subtotals already gone.
+  const bySubtotal = node.target.type === 'Group' && node.target.expressions.length >= 2;
+  const pool: DieResult[] = bySubtotal
+    ? (target.part as Extract<RollPart, { type: 'group' }>).parts.map((sub) => ({
+        sides: 0,
+        result: sub.total,
+        modifiers: [],
+        critical: false,
+        fumble: false,
+      }))
+    : targetCtx.rolls;
+
+  // ! Releases every die an inner count tagged, `vs` DC dice included, though
+  // ! `countSuccesses` spares those. The marker strip below reads rendered text
+  // ! and cannot tell a DC die apart, so sparing one here leaves a tag whose
+  // ! `**` is already gone and `renderBreakdown` stops reproducing `rendered`.
+  if (bySubtotal && poolAlreadyCounted) {
+    for (const die of targetCtx.rolls) {
+      die.modifiers = stripFlags(die.modifiers, TALLY_FLAGS);
+    }
+  }
+
+  // An empty pool (`0d6>=4`) scores zero of both, so its total is 0 — never
+  // `target.total`, which would break `total === successes - failures`.
+  // Reachable only through a zero-count pool — a target holding no dice node at
+  // all is rejected at parse time.
+  if (pool.length === 0) {
     ctx.expressionParts.push(`${targetExpr}${code}`);
     ctx.renderedParts.push(`${targetExpr}${code}`);
-    return { total: target.total, part: buildPart(target.total, 0, 0) };
+    return { total: 0, part: buildPart(0, 0, 0) };
   }
 
   const result = countSuccesses(
-    targetCtx.rolls,
+    pool,
     { operator: node.threshold.operator, value: thresholdValue },
     failValue != null && node.failThreshold != null
       ? { operator: node.failThreshold.operator, value: failValue }
       : undefined,
+    !bySubtotal && env.hasVersusDc,
+    !bySubtotal && poolAlreadyCounted,
   );
 
+  if (bySubtotal) {
+    env.subtotalSuccesses = successTallyBefore + result.successes;
+    env.subtotalFailures = failureTallyBefore + result.failures;
+  }
+
   appendAll(ctx.rolls, targetCtx.rolls);
   ctx.expressionParts.push(`${targetExpr}${code}`);
-  ctx.renderedParts.push(`${targetExpr}${code}${renderDice(targetCtx.rolls)}`);
+  // A subtotal count renders through the group — its sub-rolls carry their own
+  // brackets, and one flat bracket would spell out the units it never used. The
+  // strip pairs with the tag release above: markers and tags go together.
+  ctx.renderedParts.push(
+    bySubtotal
+      ? `${stripTallyMarkers(targetCtx.renderedParts.join(''))}${code}`
+      : `${targetExpr}${code}${renderDice(targetCtx.rolls)}`,
+  );
 
   return {
     total: result.total,
@@ -1563,22 +1671,18 @@ function evalSuccessCount(
  * `undefined`.
  *
  * Excludes dropped (`kh`/`kl`/`dh`/`dl`/`r`/`ro`) dice — these aren't the
- * final kept result. Explosion continuation dice (appended by standard/
- * penetrating explode, tagged `'exploded'` with no `initialResult`) are not
- * primaries either — `1d20! vs DC` keeps the natural from the original d20.
- * Compound explode accumulates into the original die and sets
- * `initialResult`, so it stays a primary and the raw first face is used.
- * Multiple primary kept d20s (e.g., `1d20+1d20`) yield `undefined` so no
- * ambiguous upgrade/downgrade is applied.
+ * final kept result — and the continuation dice `env.explosionDice` marks, so
+ * `1d20! vs DC` keeps the natural from the original d20. A compound explode
+ * accumulates into that original instead of appending, so it stays a primary
+ * and its raw first face is used. Multiple primary kept d20s (e.g.,
+ * `1d20+1d20`) yield `undefined` so no ambiguous upgrade/downgrade is applied.
  */
-function extractNatural(rolls: DieResult[]): number | undefined {
+function extractNatural(rolls: DieResult[], env: EvalEnv): number | undefined {
   // Rerolled intermediates are always stamped `['rerolled', 'dropped']`
   // (see `modifiers/reroll.ts`), so filtering by `'dropped'` covers them.
+  const appended = env.explosionDice;
   const primaries = rolls.filter(
-    (d) =>
-      d.sides === 20 &&
-      !d.modifiers.includes('dropped') &&
-      !(d.modifiers.includes('exploded') && d.initialResult == null),
+    (d) => d.sides === 20 && !d.modifiers.includes('dropped') && !appended?.has(d),
   );
   if (primaries.length !== 1) return undefined;
   const die = primaries[0];
@@ -1624,19 +1728,26 @@ function evalVersus(node: VersusNode, rng: RNG, ctx: EvalContext, env: EvalEnv):
   try {
     const rollCtx = createContext();
     const rollResult = evalNode(node.roll, rng, rollCtx, env);
-    const natural = extractNatural(rollCtx.rolls);
+    const natural = extractNatural(rollCtx.rolls, env);
 
     const dcCtx = createContext();
-    const dcResult = evalNode(node.dc, rng, dcCtx, env);
+    // A subtotal count on the DC side (`1d20 vs {{2d6, 2d6}>=10}`) is rolled
+    // back for the same reason `countTaggedDice` skips DC dice: no pool pass
+    // may tally that side.
+    const dcResult = evalDiscardingSubtotals(node.dc, rng, dcCtx, env);
 
     const degree = calculateDegree(rollResult.total, dcResult.total, natural);
 
     appendAll(ctx.rolls, rollCtx.rolls);
     // ! Tag before merging: past this point the DC dice are indistinguishable
     // ! from the roll side, and every pool modifier walks the merged array.
+    // ! Bare push, deliberately: `insideVersus` above rejects every nesting, so
+    // ! each die reaches exactly one `dcCtx` and cannot be tagged twice.
     for (const die of dcCtx.rolls) {
       die.modifiers.push('dc');
     }
+    // Arms the exclusion checks every enclosing pool operation skips by default.
+    if (dcCtx.rolls.length > 0) env.hasVersusDc = true;
     appendAll(ctx.rolls, dcCtx.rolls);
 
     const rollExpr = rollCtx.expressionParts.join('');
@@ -1729,7 +1840,12 @@ export function evaluate(ast: ASTNode, rng: RNG, options: EvaluateOptions = {}):
     maxRerollIterations,
     totalDiceRolled: 0,
     hasSuccessCount: false,
+    subtotalSuccesses: 0,
+    subtotalFailures: 0,
     insideVersus: false,
+    hasVersusDc: false,
+    critRules: undefined,
+    explosionDice: undefined,
     context,
     onMissingVariable,
   };
@@ -1761,21 +1877,27 @@ export function evaluate(ast: ASTNode, rng: RNG, options: EvaluateOptions = {}):
     rendered,
     rolls: ctx.rolls,
     parts: part,
-    ...(env.hasSuccessCount ? countTaggedDice(ctx.rolls) : {}),
+    ...(env.hasSuccessCount ? countTaggedDice(ctx.rolls, env) : {}),
     ...(versus ? { degree: versus.degree } : {}),
     ...(versus?.natural != null ? { natural: versus.natural } : {}),
   };
 }
 
-/** Tallies the `'success'` / `'failure'` tags across a whole roll. */
-function countTaggedDice(rolls: DieResult[]): { successes: number; failures: number } {
-  let successes = 0;
-  let failures = 0;
+/**
+ * Tallies the `'success'` / `'failure'` tags across a whole roll, on top of
+ * what a group count scored on subtotals — those carry no tag to find.
+ */
+function countTaggedDice(
+  rolls: DieResult[],
+  env: EvalEnv,
+): { successes: number; failures: number } {
+  let successes = env.subtotalSuccesses;
+  let failures = env.subtotalFailures;
 
   for (const die of rolls) {
     // A success-count inside the DC sub-expression tags its own dice before
     // `evalVersus` marks them `'dc'`, so they arrive here already tagged.
-    if (isVersusDc(die)) continue;
+    if (env.hasVersusDc && isVersusDc(die)) continue;
     if (die.modifiers.includes('success')) successes += 1;
     else if (die.modifiers.includes('failure')) failures += 1;
   }