roll-parser 3.0.0 → 3.1.0

package/src/evaluator/evaluator.ts

@@ -55,6 +55,7 @@ import {
 } from './modifiers/explode.js';
 import {
   isVersusDc,
+  META_MERGE_FLAGS,
   rewriteFlags,
   SELECTION_AND_TALLY_FLAGS,
   SELECTION_FLAGS,
@@ -263,6 +264,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 +284,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'),
     });
   }
 }
@@ -952,11 +957,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 +1028,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 +1047,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,8 +1060,8 @@ 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 {
@@ -1071,13 +1081,14 @@ function evalReroll(node: RerollNode, rng: RNG, ctx: EvalContext, env: EvalEnv):
   if (targetCtx.rolls.length === 0) {
     ctx.expressionParts.push(`${targetExpr}${code}`);
     ctx.renderedParts.push(`${targetExpr}${code}`);
-    const total = sumKeptDice(targetCtx.rolls);
+    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),
@@ -1093,13 +1104,14 @@ function evalReroll(node: RerollNode, rng: RNG, ctx: EvalContext, env: EvalEnv):
   ctx.expressionParts.push(`${targetExpr}${code}`);
   ctx.renderedParts.push(`${targetExpr}${code}${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,7 +1138,7 @@ 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`
@@ -1141,7 +1153,7 @@ function evalDieBound(node: DieBoundNode, rng: RNG, ctx: EvalContext, env: EvalE
   ctx.expressionParts.push(`${targetExpr}${code}`);
   ctx.renderedParts.push(`${targetExpr}${code}${renderDice(targetCtx.rolls)}`);
 
-  const total = sumKeptDice(targetCtx.rolls);
+  const total = sumKeptDice(targetCtx.rolls, env.hasVersusDc);
   return {
     total,
     part: {
@@ -1175,7 +1187,7 @@ 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);
@@ -1210,8 +1222,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,7 +1249,7 @@ 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);
@@ -1296,11 +1312,11 @@ 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('');
@@ -1383,7 +1399,7 @@ function evalGroupKeepDrop(
     fumble: false,
   }));
 
-  const mergedSynthetic = mergeDropSets(syntheticDice, specs);
+  const mergedSynthetic = mergeDropSets(syntheticDice, specs, env.hasVersusDc);
 
   const outerRendered: string[] = [];
   const keptIndices: number[] = [];
@@ -1514,6 +1530,7 @@ function evalSuccessCount(
     const part: RollPart = {
       type: 'successCount',
       threshold: { operator: node.threshold.operator, value: thresholdValue },
+      rolls: targetCtx.rolls,
       target: target.part,
       successes,
       failures,
@@ -1541,6 +1558,7 @@ function evalSuccessCount(
     failValue != null && node.failThreshold != null
       ? { operator: node.failThreshold.operator, value: failValue }
       : undefined,
+    env.hasVersusDc,
   );
 
   appendAll(ctx.rolls, targetCtx.rolls);
@@ -1634,9 +1652,13 @@ function evalVersus(node: VersusNode, rng: RNG, ctx: EvalContext, env: EvalEnv):
     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('');
@@ -1730,6 +1752,8 @@ export function evaluate(ast: ASTNode, rng: RNG, options: EvaluateOptions = {}):
     totalDiceRolled: 0,
     hasSuccessCount: false,
     insideVersus: false,
+    hasVersusDc: false,
+    critRules: undefined,
     context,
     onMissingVariable,
   };
@@ -1761,21 +1785,24 @@ 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.hasVersusDc) : {}),
     ...(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 } {
+function countTaggedDice(
+  rolls: DieResult[],
+  hasVersusDc: boolean,
+): { successes: number; failures: number } {
   let successes = 0;
   let failures = 0;
 
   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 (hasVersusDc && isVersusDc(die)) continue;
     if (die.modifiers.includes('success')) successes += 1;
     else if (die.modifiers.includes('failure')) failures += 1;
   }

package/src/evaluator/modifiers/crit-threshold.ts

@@ -9,6 +9,40 @@
  * Meta dice (rolled to compute counts/sides/modifier args) are skipped so
  * their bookkeeping stays untouched.
  *
+ * The two threshold kinds deliberately read different values. `'default'`
+ * reads `initialResult ?? result`, the same source as the versus `natural`,
+ * so "rolled the maximum face" survives the two modifiers that overwrite
+ * `result` while recording the face they replaced — compound explode and
+ * `minN`/`maxN`. An explicit threshold (`cs>4`, `cf<=2`) reads the die's
+ * current `result`: it is a predicate over the die's value, and postfix
+ * modifiers are order-sensitive by design, so `4d6min5cs>4` is meant to
+ * see the clamped faces. The two can therefore disagree on one die —
+ * `4d6min5cs>4` flags a clamped natural 1 as both critical and fumble.
+ *
+ * They also diverge on Fate dice. `'default'` carries a `sides > 1` guard, so
+ * it never fires on a `sides = 0` pool; an explicit threshold has none and
+ * compares the raw {-1, 0, +1} face, so `4dFcs>0` and `4dFcf=-1` do set the
+ * flags. The missing guard is deliberate — the parser rejects the bare
+ * `cs`/`cf` forms instead, since they would resolve to `'default'` and
+ * silently do nothing.
+ *
+ * ! Penetrating explode is not covered: it stores `raw - 1` in `result`
+ * ! without recording `initialResult`, so `1d6!pcs` still judges a natural
+ * ! 6 by its decremented 5. An *inherited* rule is handed the raw roll
+ * ! instead, which keeps `1d6cf>5!p` agreeing with `1d6!p` on the side the
+ * ! user never overrode — at the cost of `1d6cf>5!p` and `1d6!pcf>5`
+ * ! disagreeing on it. Recording `initialResult` here would settle both, but
+ * ! `extractNatural` reads that field to tell an appended explosion die from
+ * ! a compounded one, and would start counting these as versus primaries.
+ *
+ * The rule is recorded per die on `env.critRules`, so dice that explode and
+ * reroll mint *after* the crit node has run inherit it from the die they
+ * descended from. `cs`/`cf` therefore covers the whole pool wherever it sits
+ * in the postfix chain — `1d6cs<2!` and `1d6!cs<2` agree. Two things stay
+ * outside that: compound explode, which mints no die and so keeps the flags
+ * its accumulated `result` had when the crit node ran, and `minN`/`maxN`,
+ * which rewrites `result` under an explicit threshold's feet.
+ *
  * Display-only: does not alter `total`, explosion triggers, success
  * counting, or any other modifier flag. Dropped dice still participate —
  * their `critical`/`fumble` metadata reflects what they rolled, not
@@ -18,39 +52,90 @@
  */
 
 import type { DieResult, ResolvedCritThreshold } from '../../types.js';
+import type { CritRule, EvalEnv } from '../env.js';
 import { matchesCondition } from './compare.js';
 import { isVersusDc } from './flags.js';
 
 /**
  * Applies success/fail threshold arrays to a dice pool, overriding each
- * die's `critical` and `fumble` flags in place. A die matches `'default'`
- * on the success side when `result === sides && sides > 1`, and on the
- * fail side when `result === 1`. Meta dice are skipped.
+ * die's `critical` and `fumble` flags in place. Writing `natural` for
+ * `initialResult ?? result`, a die matches `'default'` on the success side
+ * when `natural === sides && sides > 1`, and on the fail side when
+ * `natural === 1 && sides > 1`. Meta dice are skipped.
+ *
+ * Also records the rule against every die it touched, so later explode and
+ * reroll dice can inherit it via {@link inheritCritRule}.
  */
 export function applyCritThresholds(
   dice: DieResult[],
   successThresholds: ResolvedCritThreshold[],
   failThresholds: ResolvedCritThreshold[],
+  env: EvalEnv,
 ): void {
+  const rule: CritRule = { success: successThresholds, fail: failThresholds };
+  env.critRules ??= new WeakMap();
+  const rules = env.critRules;
+
   for (const die of dice) {
-    if (die.modifiers.includes('meta') || isVersusDc(die)) continue;
+    if (die.modifiers.includes('meta')) continue;
+    if (env.hasVersusDc && isVersusDc(die)) continue;
 
-    die.critical = successThresholds.some((t) => matchesCrit(t, die));
-    die.fumble = failThresholds.some((t) => matchesFumble(t, die));
+    applyCritRule(die, rule, die.initialResult ?? die.result);
+    rules.set(die, rule);
   }
 }
 
-function matchesCrit(threshold: ResolvedCritThreshold, die: DieResult): boolean {
+/**
+ * Judges one die by a recorded rule, overwriting both flags. A side always
+ * carries at least `'default'` — `evalCritThreshold` fills the side the user
+ * left out — so neither flag is silently left untouched. `natural` is the face
+ * the `'default'` sentinel reads; an explicit threshold always reads `result`.
+ */
+function applyCritRule(die: DieResult, rule: CritRule, natural: number): void {
+  die.critical = rule.success.some((t) => matchesCrit(t, die, natural));
+  die.fumble = rule.fail.some((t) => matchesFumble(t, die, natural));
+}
+
+/**
+ * Passes the crit rule recorded for `parent` down to a die minted from it,
+ * judging the child by that rule and recording it so a further explode or
+ * reroll inherits it in turn. No-op when no `cs`/`cf` governs `parent`, which
+ * leaves the `createDieResult` default rule in place.
+ *
+ * `natural` is the face the `'default'` sentinel reads, defaulting to the
+ * child's own. Penetrating explode passes its raw roll — see the module note.
+ *
+ * ! Call this only once the child's final `result` is stored — an explicit
+ * ! threshold is a predicate over `result`, so a penetrating die is judged by
+ * ! its decremented value, matching `1d6!pcs<2`.
+ */
+export function inheritCritRule(
+  env: EvalEnv,
+  parent: DieResult,
+  child: DieResult,
+  natural = child.initialResult ?? child.result,
+): void {
+  const rules = env.critRules;
+  if (rules === undefined) return;
+
+  const rule = rules.get(parent);
+  if (rule === undefined) return;
+
+  applyCritRule(child, rule, natural);
+  rules.set(child, rule);
+}
+
+function matchesCrit(threshold: ResolvedCritThreshold, die: DieResult, natural: number): boolean {
   if (threshold === 'default') {
-    return die.result === die.sides && die.sides > 1;
+    return natural === die.sides && die.sides > 1;
   }
   return matchesCondition(die.result, threshold.operator, threshold.value);
 }
 
-function matchesFumble(threshold: ResolvedCritThreshold, die: DieResult): boolean {
+function matchesFumble(threshold: ResolvedCritThreshold, die: DieResult, natural: number): boolean {
   if (threshold === 'default') {
     // Mirrors `createDieResult` — a d1 always rolls 1, never a fumble.
-    return die.result === 1 && die.sides > 1;
+    return natural === 1 && die.sides > 1;
   }
   return matchesCondition(die.result, threshold.operator, threshold.value);
 }

package/src/evaluator/modifiers/die-bound.ts

@@ -6,10 +6,13 @@
  * `initialResult` (first writer wins, so a compound-explode accumulation
  * that was clamped afterwards still reports its original first roll), and
  * the die is tagged `'min'` / `'max'` so parts consumers can tell a clamped
- * value from a natural one.
+ * value from a natural one. The tag is written at most once, so a chain of
+ * same-kind bounds (`4d6min3min4`) leaves a die carrying a single `'min'`.
  *
  * `critical` / `fumble` keep reflecting the natural face — a clamped 1 is
  * still a fumble, matching the raw-face crit semantics used everywhere else.
+ * A following bare `cs`/`cf` agrees; a following *explicit* threshold
+ * (`4d6min5cs>4`) is a predicate over the clamped value and overrides it.
  * Meta dice (rolled to compute counts/sides/modifier args) are skipped.
  * Dropped dice are clamped too — they are excluded from totals anyway, and
  * clamping them keeps the rendered pool consistent.
@@ -25,15 +28,21 @@ import { isVersusDc } from './flags.js';
  * `bound: 'min'` lifts lower results up to `value`; `'max'` caps higher
  * results down to it. Untouched dice keep their tags.
  */
-export function applyDieBound(dice: DieResult[], bound: 'min' | 'max', value: number): void {
+export function applyDieBound(
+  dice: DieResult[],
+  bound: 'min' | 'max',
+  value: number,
+  hasVersusDc: boolean,
+): void {
   for (const die of dice) {
-    if (die.modifiers.includes('meta') || isVersusDc(die)) continue;
+    if (die.modifiers.includes('meta')) continue;
+    if (hasVersusDc && isVersusDc(die)) continue;
 
     const clamped = bound === 'min' ? Math.max(die.result, value) : Math.min(die.result, value);
     if (clamped === die.result) continue;
 
     die.initialResult ??= die.result;
     die.result = clamped;
-    die.modifiers.push(bound);
+    if (!die.modifiers.includes(bound)) die.modifiers.push(bound);
   }
 }

package/src/evaluator/modifiers/explode.ts

@@ -13,6 +13,7 @@ import type { RNG } from '../../rng/types.js';
 import type { CompareOp, DieResult } from '../../types.js';
 import { createDieResult } from '../die.js';
 import { chargeDie, type EvalEnv } from '../env.js';
+import { inheritCritRule } from './crit-threshold.js';
 import { isVersusDc } from './flags.js';
 
 /**
@@ -84,8 +85,8 @@ function explodeLimitError(maxIterations: number): EvaluatorError {
  * never fire during normal flow. Keeping it ensures `rng.nextInt(1, 0)`
  * can never be reached if a future AST path slips past the parser gate.
  */
-function canExplode(die: DieResult): boolean {
-  if (isVersusDc(die)) return false;
+function canExplode(die: DieResult, hasVersusDc: boolean): boolean {
+  if (hasVersusDc && isVersusDc(die)) return false;
   if (die.modifiers.includes('dropped')) return false;
   if (die.sides < 1) return false;
   return true;
@@ -99,6 +100,9 @@ function canExplode(die: DieResult): boolean {
  *
  * `critical`/`fumble` are likewise derived from the raw roll — a penetrating
  * die that rolled its max face is still a crit even though it stores one less.
+ * An inherited `cs`/`cf` keeps that: it is applied after `storeResult`, so an
+ * explicit threshold reads the stored value, while the raw roll is handed over
+ * for the `'default'` sentinel to read.
  */
 function applyAppendingExplode(
   pool: DieResult[],
@@ -111,7 +115,7 @@ function applyAppendingExplode(
 
   for (const original of pool) {
     result.push(original);
-    if (!canExplode(original)) continue;
+    if (!canExplode(original, env.hasVersusDc)) continue;
 
     const sides = original.sides;
     let lastRaw = original.result;
@@ -124,6 +128,7 @@ function applyAppendingExplode(
       const raw = rollExplosion(sides, rng, env);
       const die = createDieResult(sides, raw, ['exploded', 'kept']);
       die.result = storeResult(raw);
+      inheritCritRule(env, original, die, raw);
       result.push(die);
       lastRaw = raw;
       iterations += 1;
@@ -172,7 +177,7 @@ export function applyCompoundExplode(
   env: EvalEnv,
 ): DieResult[] {
   for (const original of pool) {
-    if (!canExplode(original)) continue;
+    if (!canExplode(original, env.hasVersusDc)) continue;
 
     const sides = original.sides;
     let accumulated = original.result;
@@ -194,8 +199,9 @@ export function applyCompoundExplode(
     if (!exploded) continue;
 
     // `critical` and `fumble` keep referring to the original triggering
-    // roll — after compounding the `result` is a sum.
-    original.initialResult = original.result;
+    // roll — after compounding the `result` is a sum. First writer wins, so
+    // a preceding `minN`/`maxN` clamp keeps its record of the raw face.
+    original.initialResult ??= original.result;
     original.result = accumulated;
     if (!original.modifiers.includes('exploded')) {
       original.modifiers = [...original.modifiers, 'exploded'];

package/src/evaluator/modifiers/flags.ts

@@ -20,6 +20,10 @@ import type { DieModifier, DieResult } from '../../types.js';
  * operates on. Nothing may sum, select, clamp, reroll, explode, or tally them
  * — a `d10` on the DC side must never come back clamped to 20, and
  * `{1d20 vs 2d10, 1d4}>=5` must not count the DC faces as successes.
+ *
+ * ! Call this behind the shared `hasVersusDc` env flag, never bare. Unguarded
+ * ! inside a per-die loop it cost 11-38% on notation that cannot carry the tag
+ * ! (#281); the flag is `false` until a `vs` has actually tagged something.
  */
 export function isVersusDc(die: DieResult): boolean {
   return die.modifiers.includes('dc');
@@ -40,6 +44,19 @@ export const SELECTION_AND_TALLY_FLAGS: readonly DieModifier[] = [
   'failure',
 ];
 
+/**
+ * {@link SELECTION_AND_TALLY_FLAGS} plus `'meta'`, for a meta context merging
+ * into a parent. Meta operands nest (`((1d2)d4)d6`), so a die passes through
+ * the merge once per level and the tag must be rebuilt, not appended.
+ */
+export const META_MERGE_FLAGS: readonly DieModifier[] = [
+  'kept',
+  'dropped',
+  'success',
+  'failure',
+  'meta',
+];
+
 /** Selection flags plus `rerolled` — reassigned on every reroll pass. */
 export const REROLL_SLOT_FLAGS: readonly DieModifier[] = ['kept', 'dropped', 'rerolled'];
 

package/src/evaluator/modifiers/keep-drop.ts

@@ -29,9 +29,10 @@ export function markDroppedIndices(
   kind: KeepDropSpec['kind'],
   selector: KeepDropSpec['selector'],
   droppedMask: Uint8Array,
+  hasVersusDc: boolean,
 ): void {
   if (count === 1) {
-    markSingleExtreme(dice, kind, selector, droppedMask);
+    markSingleExtreme(dice, kind, selector, droppedMask, hasVersusDc);
     return;
   }
 
@@ -40,7 +41,7 @@ export function markDroppedIndices(
   for (let index = 0; index < dice.length; index++) {
     const die = dice[index];
     if (die == null) continue;
-    if (isVersusDc(die)) continue;
+    if (hasVersusDc && isVersusDc(die)) continue;
 
     if (die.modifiers.includes('dropped')) {
       droppedMask[index] = 1;
@@ -91,6 +92,7 @@ function markSingleExtreme(
   kind: KeepDropSpec['kind'],
   selector: KeepDropSpec['selector'],
   droppedMask: Uint8Array,
+  hasVersusDc: boolean,
 ): void {
   const isKeep = kind === 'keep';
   const wantHighest = selector === 'highest';
@@ -101,7 +103,7 @@ function markSingleExtreme(
   for (let index = 0; index < dice.length; index++) {
     const die = dice[index];
     if (die == null) continue;
-    if (isVersusDc(die)) continue;
+    if (hasVersusDc && isVersusDc(die)) continue;
 
     if (die.modifiers.includes('dropped')) {
       droppedMask[index] = 1;
@@ -135,13 +137,15 @@ function markSingleExtreme(
  * Calculates total from dice, excluding dropped dice.
  *
  * @param dice - Array of die results
+ * @param hasVersusDc - Shared env flag; skips the DC exclusion when no `vs` has
+ *   tagged anything
  * @returns Sum of non-dropped dice
  */
-export function sumKeptDice(dice: DieResult[]): number {
+export function sumKeptDice(dice: DieResult[], hasVersusDc: boolean): number {
   let total = 0;
 
   for (const die of dice) {
-    if (isVersusDc(die)) continue;
+    if (hasVersusDc && isVersusDc(die)) continue;
     if (!die.modifiers.includes('dropped')) total += die.result;
   }
 

package/src/evaluator/modifiers/reroll.ts

@@ -15,6 +15,7 @@ import type { CompareOp, DieResult } from '../../types.js';
 import { createDieResult, createFateDieResult } from '../die.js';
 import { chargeDie, type EvalEnv } from '../env.js';
 import { matchesCondition } from './compare.js';
+import { inheritCritRule } from './crit-threshold.js';
 import { isVersusDc, REROLL_SLOT_FLAGS, rewriteFlags } from './flags.js';
 
 /**
@@ -31,15 +32,22 @@ import { isVersusDc, REROLL_SLOT_FLAGS, rewriteFlags } from './flags.js';
 export const DEFAULT_MAX_REROLL_ITERATIONS = 1_000;
 
 /**
- * Rolls a replacement die for the given sides, charging it against the global
- * dice limit. Fate dice (sides === 0) re-roll on the {-1, 0, +1} range.
+ * Rolls a replacement for `parent`, charging it against the global dice limit.
+ * Fate dice (sides === 0) re-roll on the {-1, 0, +1} range. Any `cs`/`cf`
+ * governing `parent` carries over, so a replacement is judged by the rule the
+ * user declared rather than the built-in default.
  */
-function rollReplacement(sides: number, rng: RNG, env: EvalEnv): DieResult {
+function rollReplacement(parent: DieResult, rng: RNG, env: EvalEnv): DieResult {
   chargeDie(env, 'Reroll');
 
-  if (sides === 0) return createFateDieResult(rng.nextInt(-1, 1), []);
+  const sides = parent.sides;
+  const die =
+    sides === 0
+      ? createFateDieResult(rng.nextInt(-1, 1), [])
+      : createDieResult(sides, rng.nextInt(1, sides), []);
 
-  return createDieResult(sides, rng.nextInt(1, sides), []);
+  inheritCritRule(env, parent, die);
+  return die;
 }
 
 function rerollLimitError(maxIterations: number): EvaluatorError {
@@ -54,8 +62,9 @@ function rerollLimitError(maxIterations: number): EvaluatorError {
  * True for dice eligible to start rerolling. Dropped dice (from a preceding
  * keep/drop modifier) are left alone.
  */
-function canReroll(die: DieResult): boolean {
-  return !die.modifiers.includes('dropped') && !isVersusDc(die);
+function canReroll(die: DieResult, hasVersusDc: boolean): boolean {
+  if (hasVersusDc && isVersusDc(die)) return false;
+  return !die.modifiers.includes('dropped');
 }
 
 /**
@@ -76,7 +85,7 @@ export function applyRecursiveReroll(
   const result: DieResult[] = [];
 
   for (const original of pool) {
-    if (!canReroll(original)) {
+    if (!canReroll(original, env.hasVersusDc)) {
       result.push(original);
       continue;
     }
@@ -94,7 +103,7 @@ export function applyRecursiveReroll(
       current.modifiers = rewriteFlags(current.modifiers, REROLL_SLOT_FLAGS, 'rerolled', 'dropped');
       result.push(current);
 
-      current = rollReplacement(current.sides, rng, env);
+      current = rollReplacement(current, rng, env);
       iterations += 1;
     }
 
@@ -120,7 +129,7 @@ export function applyRerollOnce(
   const result: DieResult[] = [];
 
   for (const original of pool) {
-    if (!canReroll(original)) {
+    if (!canReroll(original, env.hasVersusDc)) {
       result.push(original);
       continue;
     }
@@ -135,7 +144,7 @@ export function applyRerollOnce(
     original.modifiers = rewriteFlags(original.modifiers, REROLL_SLOT_FLAGS, 'rerolled', 'dropped');
     result.push(original);
 
-    const replacement = rollReplacement(original.sides, rng, env);
+    const replacement = rollReplacement(original, rng, env);
     replacement.modifiers = rewriteFlags(replacement.modifiers, REROLL_SLOT_FLAGS, 'kept');
     result.push(replacement);
   }