roll-parser 3.0.0 → 3.2.0

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

@@ -9,6 +9,31 @@
  * 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 every modifier that overwrites
+ * `result` while recording the face it replaced — compound explode,
+ * penetrating 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.
+ *
+ * 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 +43,80 @@
  */
 
 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.
+ * Applies success/fail threshold arrays to a dice pool, overriding each die's
+ * `critical` and `fumble` flags in place. Meta and DC 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 {
-  if (threshold === 'default') {
-    return die.result === die.sides && die.sides > 1;
-  }
-  return matchesCondition(die.result, threshold.operator, threshold.value);
+/**
+ * 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.
+ */
+function applyCritRule(die: DieResult, rule: CritRule, natural: number): void {
+  die.critical = rule.success.some((t) => matchesThreshold(t, die, natural, die.sides));
+  die.fumble = rule.fail.some((t) => matchesThreshold(t, die, natural, 1));
 }
 
-function matchesFumble(threshold: ResolvedCritThreshold, die: DieResult): boolean {
+/**
+ * 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.
+ *
+ * ! Call this only once the child's final `result` and `initialResult` are
+ * ! 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): void {
+  const rules = env.critRules;
+  if (rules === undefined) return;
+
+  const rule = rules.get(parent);
+  if (rule === undefined) return;
+
+  applyCritRule(child, rule, child.initialResult ?? child.result);
+  rules.set(child, rule);
+}
+
+/**
+ * `defaultFace` is the face the `'default'` sentinel looks for — `die.sides`
+ * on the success side, `1` on the fail side. The `sides > 1` guard mirrors
+ * `createDieResult`: a d1 always rolls 1, so it is neither.
+ */
+function matchesThreshold(
+  threshold: ResolvedCritThreshold,
+  die: DieResult,
+  natural: number,
+  defaultFace: number,
+): boolean {
   if (threshold === 'default') {
-    // Mirrors `createDieResult` — a d1 always rolls 1, never a fumble.
-    return die.result === 1 && die.sides > 1;
+    return natural === defaultFace && 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;
@@ -97,8 +98,14 @@ function canExplode(die: DieResult): boolean {
  * the value recorded on the appended die, which is the only thing standard
  * and penetrating explosions disagree about.
  *
+ * A die whose stored value differs from its raw roll records the raw face in
+ * `initialResult`, so `initialResult ?? result` recovers what was rolled.
+ *
  * `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.
+ * A `cs`/`cf` rule keeps that: it is applied after `storeResult`, so an
+ * explicit threshold reads the stored value while the `'default'` sentinel
+ * reads `initialResult`.
  */
 function applyAppendingExplode(
   pool: DieResult[],
@@ -111,7 +118,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 +131,13 @@ function applyAppendingExplode(
       const raw = rollExplosion(sides, rng, env);
       const die = createDieResult(sides, raw, ['exploded', 'kept']);
       die.result = storeResult(raw);
+      if (die.result !== raw) die.initialResult = raw;
+      // Only `extractNatural` reads this, and only inside a `vs`.
+      if (env.insideVersus) {
+        env.explosionDice ??= new WeakSet();
+        env.explosionDice.add(die);
+      }
+      inheritCritRule(env, original, die);
       result.push(die);
       lastRaw = raw;
       iterations += 1;
@@ -172,7 +186,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 +208,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; the flag is `false` until a `vs` has actually tagged something.
  */
 export function isVersusDc(die: DieResult): boolean {
   return die.modifiers.includes('dc');
@@ -28,18 +32,31 @@ export function isVersusDc(die: DieResult): boolean {
 /** Kept/dropped selection flags — rebuilt by every keep/drop pass. */
 export const SELECTION_FLAGS: readonly DieModifier[] = ['kept', 'dropped'];
 
+/**
+ * Success-count tally flags — rebuilt by every counting pass. A group lets a
+ * second count reach a pool the first one already tagged (`{4d6>=5}<=2f5`);
+ * stripping these first is what keeps the outermost count the only one the
+ * tags describe.
+ */
+export const TALLY_FLAGS: readonly DieModifier[] = ['success', 'failure'];
+
 /**
  * Selection flags plus the success-count tally flags. Stripped when a die
  * leaves the pool that tagged it (meta sub-expressions, dropped group
  * sub-rolls) so the top-level successes/failures scan cannot count it.
  */
 export const SELECTION_AND_TALLY_FLAGS: readonly DieModifier[] = [
-  'kept',
-  'dropped',
-  'success',
-  'failure',
+  ...SELECTION_FLAGS,
+  ...TALLY_FLAGS,
 ];
 
+/**
+ * {@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[] = [...SELECTION_AND_TALLY_FLAGS, '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;
@@ -132,16 +134,16 @@ function markSingleExtreme(
 }
 
 /**
- * Calculates total from dice, excluding dropped dice.
+ * Sums the dice a keep/drop pass left standing.
  *
- * @param dice - Array of die results
- * @returns Sum of non-dropped dice
+ * @param hasVersusDc - Shared env flag; skips the DC exclusion when no `vs` has
+ *   tagged anything
  */
-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);
   }

package/src/evaluator/modifiers/sort.ts

@@ -26,17 +26,23 @@ import { isVersusDc } from './flags.js';
  * Relies on `Array.prototype.sort` being stable — equal-valued dice retain
  * their original insertion order.
  */
-export function sortDice(dice: DieResult[], order: 'ascending' | 'descending'): DieResult[] {
+export function sortDice(
+  dice: DieResult[],
+  order: 'ascending' | 'descending',
+  hasVersusDc: boolean,
+): DieResult[] {
   const cmp =
     order === 'ascending'
       ? (a: DieResult, b: DieResult) => a.result - b.result
       : (a: DieResult, b: DieResult) => b.result - a.result;
 
-  const sortable = dice.filter((die) => !isVersusDc(die));
-  if (sortable.length === dice.length) return [...dice].sort(cmp);
+  // Scan before allocating: the `filter` this replaced built a throwaway array
+  // on every sort to serve a case only a `vs` can produce.
+  if (!hasVersusDc || !dice.some(isVersusDc)) return [...dice].sort(cmp);
 
   // Sort only the pool members, then lay them back into the slots they came
   // from, leaving every DC die exactly where it was.
+  const sortable = dice.filter((die) => !isVersusDc(die));
   sortable.sort(cmp);
   let next = 0;
   return dice.map((die) => (isVersusDc(die) ? die : (sortable[next++] as DieResult)));

package/src/evaluator/modifiers/success-count.ts

@@ -10,14 +10,18 @@
  * excluded from counting and are never tagged.
  *
  * Mutates the input pool in place to add `'success'` / `'failure'` modifier
- * flags — mirrors the mutation pattern of explode and reroll modifiers.
+ * flags — mirrors the mutation pattern of explode and reroll modifiers. The
+ * tags are rebuilt, not appended: a group counted after its members
+ * (`{4d6>=5}<=2f5`) runs this pass twice over the same dice, and the outermost
+ * pass is the one whose arithmetic `RollResult.successes` / `failures` and the
+ * rendered markers report.
  *
  * @module evaluator/modifiers/success-count
  */
 
 import type { DieResult, ResolvedComparePoint } from '../../types.js';
 import { matchesCondition } from './compare.js';
-import { isVersusDc } from './flags.js';
+import { isVersusDc, stripFlags, TALLY_FLAGS } from './flags.js';
 
 export type SuccessCountResult = {
   total: number;
@@ -28,13 +32,31 @@ export type SuccessCountResult = {
 export function countSuccesses(
   dice: DieResult[],
   threshold: ResolvedComparePoint,
-  failThreshold?: ResolvedComparePoint,
+  failThreshold: ResolvedComparePoint | undefined,
+  hasVersusDc: boolean,
+  poolAlreadyCounted: boolean,
 ): SuccessCountResult {
   let successes = 0;
   let failures = 0;
 
-  for (const die of dice) {
-    if (isVersusDc(die)) continue;
+  // ! Excluded up front, never inside the loop below. Even short-circuited on a
+  // ! false flag, a `hasVersusDc && isVersusDc(die)` guard in this loop costs
+  // ! ~9% on `10d10>=6f1` — measured, not assumed. Filtering keeps the
+  // ! hot body identical to the pre-exclusion one and pays an allocation only
+  // ! on the `vs` path. The dice are the same objects either way, so the
+  // ! `'success'` / `'failure'` tags written below still land on the pool.
+  const pool = hasVersusDc ? dice.filter((die) => !isVersusDc(die)) : dice;
+
+  // ! Dropped dice are stripped too, not just the ones re-tagged below. This
+  // ! pass skips them, so an inner count's tag would otherwise survive into the
+  // ! top-level successes/failures scan and break `total === successes - failures`.
+  if (poolAlreadyCounted) {
+    for (const die of pool) {
+      die.modifiers = stripFlags(die.modifiers, TALLY_FLAGS);
+    }
+  }
+
+  for (const die of pool) {
     if (die.modifiers.includes('dropped')) continue;
 
     if (matchesCondition(die.result, threshold.operator, threshold.value)) {

package/src/notation.ts

@@ -0,0 +1,24 @@
+/**
+ * Notation serialization shared by the two breakdown builders — the
+ * evaluator's `expression`/`rendered` strings and `render.ts`.
+ *
+ * @module notation
+ */
+
+// ! `cs`, `cf`, `s`, and `sd` are the only codes ending in a letter the lexer
+// ! scans as an identifier — maximal munch then swallows what follows, so
+// ! `cs` + `cf` re-lexes as `cscf`. `4dF` and `!p` are their own tokens.
+const BARE_MODIFIER_END = /(?:cs|cf|sd|s)$/;
+
+const STARTS_WITH_LETTER = /^[A-Za-z]/;
+
+/**
+ * Appends a modifier code to the expression built so far, separating the two
+ * with a space when concatenating them would re-lex as a single identifier.
+ * The space is the same separator the input used to make them parse.
+ */
+export function joinModifierCode(expression: string, code: string): string {
+  return BARE_MODIFIER_END.test(expression) && STARTS_WITH_LETTER.test(code)
+    ? `${expression} ${code}`
+    : `${expression}${code}`;
+}

package/src/parser/ast.ts

@@ -61,8 +61,11 @@ export type DiceNode = NodeSpan & {
  * Fate/Fudge dice node (`dF`).
  * Each die produces a result in {-1, 0, +1}. No configurable sides.
  *
- * Fate dice carry `sides: 0` as a sentinel in their `DieResult`, and are
- * never `critical` or `fumble` — there is no maximum face to hit.
+ * Fate dice carry `sides: 0` as a sentinel in their `DieResult`, so the
+ * default `critical`/`fumble` rule never fires — it is guarded on `sides > 1`,
+ * which also stops a `+1` face from reading as a fumbled 1. An explicit
+ * threshold still applies: `4dFcs>0` and `4dFcf=-1` set the flags, while the
+ * bare `cs`/`cf` forms are rejected at parse time.
  *
  * @category AST
  */
@@ -314,9 +317,10 @@ export type SortNode = NodeSpan & {
 };
 
 /**
- * Sentinel for bare `cs` / `cf` without a ComparePoint. Resolved to
- * `result === sides` (for critical) or `result === 1` (for fumble) at
- * evaluation time, using each die's own `sides`.
+ * Sentinel for bare `cs` / `cf` without a ComparePoint. Resolved at
+ * evaluation time against each die's own `sides` and its natural face
+ * (`initialResult ?? result`): critical when that face equals `sides`,
+ * fumble when it equals 1.
  *
  * @category AST
  */
@@ -325,8 +329,9 @@ export type CritThreshold = ComparePoint | 'default';
 /**
  * Critical threshold modifier node (`cs`, `cf`).
  *
- * Overrides the default `critical`/`fumble` flag logic for the dice
- * produced by `target`. Bare `cs`/`cf` uses the `'default'` sentinel
+ * Overrides the default `critical`/`fumble` flag logic for `target`'s dice
+ * pool — including dice an enclosing `!` or `r` adds to it afterwards, which
+ * `target` never produced. Bare `cs`/`cf` uses the `'default'` sentinel
  * (max face / 1). Custom thresholds accept any ComparePoint. Chaining
  * collapses into a single node — `1d20cs=20cs=1cf>18` has two success
  * and one fail threshold. Display-only: does not change `total`,