roll-parser 3.0.0-beta.0 → 3.1.0

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

@@ -4,148 +4,150 @@
  * @module evaluator/modifiers/keep-drop
  */
 
-import type { DieResult } from '../../types.js';
+import type { DieResult, KeepDropSpec } from '../../types.js';
+import { isVersusDc } from './flags.js';
 
-/**
- * Marks all eligible dice as `'kept'`. Dice that already carry `'dropped'`
- * (e.g., intermediate rerolls, or the loser of a prior modifier) are left
- * untouched so those drops cannot be silently revived.
- */
-export function markAllKept(dice: DieResult[]): DieResult[] {
-  return dice.map((die) => {
-    if (die.modifiers.includes('dropped')) return die;
-    return {
-      ...die,
-      modifiers: die.modifiers.includes('kept') ? die.modifiers : [...die.modifiers, 'kept'],
-    };
-  });
-}
+/** One selectable die: its rolled value and its slot in the original pool. */
+type EligibleDie = { result: number; index: number };
 
 /**
- * Returns indexed dice that are eligible for keep/drop selection — dice that
- * have not already been dropped by a preceding modifier (e.g. reroll's
- * intermediate dice carry `'dropped'` and must be ignored here).
- */
-function eligibleIndexed(dice: DieResult[]): { die: DieResult; index: number }[] {
-  return dice
-    .map((die, index) => ({ die, index }))
-    .filter(({ die }) => !die.modifiers.includes('dropped'));
-}
-
-/**
- * Rebuilds a die's slot flags (`kept` / `dropped`) from the selection set.
- * Pre-dropped dice are returned unchanged so their state is preserved.
- */
-function applySelection(
-  dice: DieResult[],
-  selectionIndices: Set<number>,
-  selectionMarker: 'kept' | 'dropped',
-): DieResult[] {
-  const otherMarker = selectionMarker === 'kept' ? 'dropped' : 'kept';
-
-  return dice.map((die, index) => {
-    if (die.modifiers.includes('dropped')) return die;
-
-    const isSelected = selectionIndices.has(index);
-    const marker = isSelected ? selectionMarker : otherMarker;
-
-    return {
-      ...die,
-      modifiers: [...die.modifiers.filter((m) => m !== 'kept' && m !== 'dropped'), marker],
-    };
-  });
-}
-
-/**
- * Drops every non-already-dropped die. Used by keep-N when N <= 0 and by
- * drop-N when N >= eligible.length.
- */
-function markAllDropped(dice: DieResult[]): DieResult[] {
-  return dice.map((die) => {
-    if (die.modifiers.includes('dropped')) return die;
-    return {
-      ...die,
-      modifiers: [...die.modifiers.filter((m) => m !== 'kept'), 'dropped'],
-    };
-  });
-}
-
-/**
- * Applies keep highest modifier - keeps the N highest eligible dice, marks
- * others as dropped. Dice already marked `'dropped'` are left unchanged.
+ * Records into `droppedMask` every pool slot that `kind` / `selector` /
+ * `count` drops.
  *
- * @param dice - Array of die results
- * @param count - Number of dice to keep
- * @returns New array with appropriate modifiers applied
- */
-export function applyKeepHighest(dice: DieResult[], count: number): DieResult[] {
-  const eligible = eligibleIndexed(dice);
-
-  if (count >= eligible.length) return markAllKept(dice);
-  if (count <= 0) return markAllDropped(dice);
-
-  const sorted = [...eligible].sort((a, b) => b.die.result - a.die.result);
-  const keptIndices = new Set(sorted.slice(0, count).map((item) => item.index));
-
-  return applySelection(dice, keptIndices, 'kept');
-}
-
-/**
- * Applies keep lowest modifier - keeps the N lowest eligible dice, marks
- * others as dropped. Dice already marked `'dropped'` are left unchanged.
- */
-export function applyKeepLowest(dice: DieResult[], count: number): DieResult[] {
-  const eligible = eligibleIndexed(dice);
-
-  if (count >= eligible.length) return markAllKept(dice);
-  if (count <= 0) return markAllDropped(dice);
-
-  const sorted = [...eligible].sort((a, b) => a.die.result - b.die.result);
-  const keptIndices = new Set(sorted.slice(0, count).map((item) => item.index));
-
-  return applySelection(dice, keptIndices, 'kept');
-}
-
-/**
- * Applies drop highest modifier - drops the N highest eligible dice, keeps
- * the rest. Dice already marked `'dropped'` are left unchanged.
+ * Nothing is cloned and no flag is written. The caller owns the merge, so a
+ * chain like `4d6kh3dl1` runs one pass per spec over the same mask and then
+ * rewrites each die's slot flags exactly once — where the previous
+ * clone-per-spec appliers rebuilt the whole pool for every spec only to have
+ * their flags read back and discarded.
+ *
+ * Dice already carrying `'dropped'` (reroll intermediates, meta dice, a
+ * preceding chain's losers) are ineligible for selection and stay dropped.
  */
-export function applyDropHighest(dice: DieResult[], count: number): DieResult[] {
-  const eligible = eligibleIndexed(dice);
-
-  if (count <= 0) return markAllKept(dice);
-  if (count >= eligible.length) return markAllDropped(dice);
-
-  const sorted = [...eligible].sort((a, b) => b.die.result - a.die.result);
-  const droppedIndices = new Set(sorted.slice(0, count).map((item) => item.index));
-
-  return applySelection(dice, droppedIndices, 'dropped');
+export function markDroppedIndices(
+  dice: DieResult[],
+  count: number,
+  kind: KeepDropSpec['kind'],
+  selector: KeepDropSpec['selector'],
+  droppedMask: Uint8Array,
+  hasVersusDc: boolean,
+): void {
+  if (count === 1) {
+    markSingleExtreme(dice, kind, selector, droppedMask, hasVersusDc);
+    return;
+  }
+
+  const eligible: EligibleDie[] = [];
+
+  for (let index = 0; index < dice.length; index++) {
+    const die = dice[index];
+    if (die == null) continue;
+    if (hasVersusDc && isVersusDc(die)) continue;
+
+    if (die.modifiers.includes('dropped')) {
+      droppedMask[index] = 1;
+      continue;
+    }
+
+    eligible.push({ result: die.result, index });
+  }
+
+  const isKeep = kind === 'keep';
+
+  // Keep-everything: a keep covering the whole eligible pool, or a zero drop.
+  if (isKeep ? count >= eligible.length : count <= 0) return;
+
+  // Drop-everything: a zero keep, or a drop covering the whole eligible pool.
+  if (isKeep ? count <= 0 : count >= eligible.length) {
+    for (const item of eligible) {
+      droppedMask[item.index] = 1;
+    }
+    return;
+  }
+
+  // Stable sort — ties resolve by original pool order.
+  eligible.sort(
+    selector === 'highest' ? (a, b) => b.result - a.result : (a, b) => a.result - b.result,
+  );
+
+  // The sort puts the acted-on dice first: `keep` drops everything past
+  // `count`, `drop` drops the selection itself.
+  const start = isKeep ? count : 0;
+  const end = isKeep ? eligible.length : count;
+
+  for (let i = start; i < end; i++) {
+    const item = eligible[i];
+    if (item != null) droppedMask[item.index] = 1;
+  }
 }
 
 /**
- * Applies drop lowest modifier - drops the N lowest eligible dice, keeps
- * the rest. Dice already marked `'dropped'` are left unchanged.
+ * `count === 1` fast path: a single linear scan replaces the wrapper array
+ * and comparator sort — `2d20kh1` (advantage) and `4d6dl1` are the most
+ * common notations. Strict comparison preserves the stable sort's
+ * first-occurrence tie-break, and bits are only ever set, never cleared, so
+ * a shared mask keeps every previous spec's drops.
  */
-export function applyDropLowest(dice: DieResult[], count: number): DieResult[] {
-  const eligible = eligibleIndexed(dice);
-
-  if (count <= 0) return markAllKept(dice);
-  if (count >= eligible.length) return markAllDropped(dice);
-
-  const sorted = [...eligible].sort((a, b) => a.die.result - b.die.result);
-  const droppedIndices = new Set(sorted.slice(0, count).map((item) => item.index));
-
-  return applySelection(dice, droppedIndices, 'dropped');
+function markSingleExtreme(
+  dice: DieResult[],
+  kind: KeepDropSpec['kind'],
+  selector: KeepDropSpec['selector'],
+  droppedMask: Uint8Array,
+  hasVersusDc: boolean,
+): void {
+  const isKeep = kind === 'keep';
+  const wantHighest = selector === 'highest';
+
+  let extremeIndex = -1;
+  let extremeResult = 0;
+
+  for (let index = 0; index < dice.length; index++) {
+    const die = dice[index];
+    if (die == null) continue;
+    if (hasVersusDc && isVersusDc(die)) continue;
+
+    if (die.modifiers.includes('dropped')) {
+      droppedMask[index] = 1;
+      continue;
+    }
+
+    const { result } = die;
+
+    if (extremeIndex === -1) {
+      extremeIndex = index;
+      extremeResult = result;
+      continue;
+    }
+
+    if (wantHighest ? result > extremeResult : result < extremeResult) {
+      // A keep drops the dethroned extreme; a drop keeps everything else.
+      if (isKeep) droppedMask[extremeIndex] = 1;
+      extremeIndex = index;
+      extremeResult = result;
+    } else if (isKeep) {
+      droppedMask[index] = 1;
+    }
+  }
+
+  // Keeping 1 of ≤1 eligible dice drops nothing; dropping 1 of ≥1 drops the
+  // extreme — both match the general path's whole-pool guards.
+  if (!isKeep && extremeIndex !== -1) droppedMask[extremeIndex] = 1;
 }
 
 /**
  * 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 {
-  return dice
-    .filter((die) => !die.modifiers.includes('dropped'))
-    .reduce((sum, die) => sum + die.result, 0);
+export function sumKeptDice(dice: DieResult[], hasVersusDc: boolean): number {
+  let total = 0;
+
+  for (const die of dice) {
+    if (hasVersusDc && isVersusDc(die)) continue;
+    if (!die.modifiers.includes('dropped')) total += die.result;
+  }
+
+  return total;
 }

package/src/evaluator/modifiers/reroll.ts

@@ -9,49 +9,45 @@
  * @module evaluator/modifiers/reroll
  */
 
+import { EvaluatorError } from '../../errors.js';
 import type { RNG } from '../../rng/types.js';
 import type { CompareOp, DieResult } from '../../types.js';
-import { EvaluatorError, type EvalEnv } from '../evaluator.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';
 
-/** Default maximum reroll iterations per die. */
+/**
+ * Default value of `EvaluationOptions.maxRerollIterations`: how many times a
+ * single die may be re-rolled by `r` before `REROLL_LIMIT_EXCEEDED` is
+ * thrown.
+ *
+ * Per die, not per pool — it bounds notations like `1d1r<2`, whose reroll
+ * condition can never stop matching. `ro` re-rolls exactly once and is
+ * unaffected.
+ *
+ * @category Limits
+ */
 export const DEFAULT_MAX_REROLL_ITERATIONS = 1_000;
 
-export { matchesCondition };
-
 /**
- * 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 {
-  if (env.totalDiceRolled + 1 > env.maxDice) {
-    throw new EvaluatorError(
-      `Total dice count ${env.totalDiceRolled + 1} exceeds limit of ${env.maxDice}`,
-      'DICE_LIMIT_EXCEEDED',
-      'Reroll',
-    );
-  }
-  env.totalDiceRolled += 1;
-
-  if (sides === 0) {
-    const result = rng.nextInt(-1, 1);
-    return {
-      sides: 0,
-      result,
-      modifiers: [],
-      critical: false,
-      fumble: false,
-    };
-  }
+function rollReplacement(parent: DieResult, rng: RNG, env: EvalEnv): DieResult {
+  chargeDie(env, 'Reroll');
+
+  const sides = parent.sides;
+  const die =
+    sides === 0
+      ? createFateDieResult(rng.nextInt(-1, 1), [])
+      : createDieResult(sides, rng.nextInt(1, sides), []);
 
-  const result = rng.nextInt(1, sides);
-  return {
-    sides,
-    result,
-    modifiers: [],
-    critical: result === sides && sides > 1,
-    fumble: result === 1 && sides > 1,
-  };
+  inheritCritRule(env, parent, die);
+  return die;
 }
 
 function rerollLimitError(maxIterations: number): EvaluatorError {
@@ -66,19 +62,11 @@ 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 {
+function canReroll(die: DieResult, hasVersusDc: boolean): boolean {
+  if (hasVersusDc && isVersusDc(die)) return false;
   return !die.modifiers.includes('dropped');
 }
 
-/**
- * Returns the die's modifiers with any "slot" flags removed. Slot flags
- * (`kept`, `dropped`, `rerolled`) are controlled by the surrounding logic
- * and should be reassigned each pass.
- */
-function stripSlotFlags(modifiers: DieResult['modifiers']): DieResult['modifiers'] {
-  return modifiers.filter((m) => m !== 'kept' && m !== 'dropped' && m !== 'rerolled');
-}
-
 /**
  * Applies recursive reroll: re-roll each matching die until it no longer
  * matches or the per-die iteration limit is reached. Intermediate dice are
@@ -97,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;
     }
@@ -105,21 +93,21 @@ export function applyRecursiveReroll(
     let current = original;
     let iterations = 0;
 
-    // ? Mutate flags in place — the same DieResult objects are shared with
-    //   the RollPart tree, and both views must reflect reroll state.
+    // Mutate flags in place — the same DieResult objects are shared with
+    // the RollPart tree, and both views must reflect reroll state.
     while (matchesCondition(current.result, operator, value)) {
       if (iterations >= env.maxRerollIterations) {
         throw rerollLimitError(env.maxRerollIterations);
       }
 
-      current.modifiers = [...stripSlotFlags(current.modifiers), 'rerolled', 'dropped'];
+      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;
     }
 
-    current.modifiers = [...stripSlotFlags(current.modifiers), 'kept'];
+    current.modifiers = rewriteFlags(current.modifiers, REROLL_SLOT_FLAGS, 'kept');
     result.push(current);
   }
 
@@ -141,23 +129,23 @@ export function applyRerollOnce(
   const result: DieResult[] = [];
 
   for (const original of pool) {
-    if (!canReroll(original)) {
+    if (!canReroll(original, env.hasVersusDc)) {
       result.push(original);
       continue;
     }
 
-    // ? Mutate flags in place — see `applyRecursiveReroll`.
+    // Mutate flags in place — see `applyRecursiveReroll`.
     if (!matchesCondition(original.result, operator, value)) {
-      original.modifiers = [...stripSlotFlags(original.modifiers), 'kept'];
+      original.modifiers = rewriteFlags(original.modifiers, REROLL_SLOT_FLAGS, 'kept');
       result.push(original);
       continue;
     }
 
-    original.modifiers = [...stripSlotFlags(original.modifiers), 'rerolled', 'dropped'];
+    original.modifiers = rewriteFlags(original.modifiers, REROLL_SLOT_FLAGS, 'rerolled', 'dropped');
     result.push(original);
 
-    const replacement = rollReplacement(original.sides, rng, env);
-    replacement.modifiers = [...stripSlotFlags(replacement.modifiers), 'kept'];
+    const replacement = rollReplacement(original, rng, env);
+    replacement.modifiers = rewriteFlags(replacement.modifiers, REROLL_SLOT_FLAGS, 'kept');
     result.push(replacement);
   }
 

package/src/evaluator/modifiers/sort.ts

@@ -7,10 +7,15 @@
  * Dropped dice stay in the pool and sort alongside kept dice so readers can
  * see where the dropped value landed in the ordered sequence.
  *
+ * DC dice are the exception: they hold their positions rather than sorting,
+ * so a `vs` comparison's DC faces never appear shuffled into the roll-side
+ * pool they are not a member of.
+ *
  * @module evaluator/modifiers/sort
  */
 
 import type { DieResult } from '../../types.js';
+import { isVersusDc } from './flags.js';
 
 /**
  * Returns a sorted copy of `dice` in the given order, preserving every die's
@@ -21,10 +26,24 @@ import type { DieResult } from '../../types.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;
-  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 (#281).
+  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,18 +10,17 @@
  * 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. Each
+ * tag is written at most once per die: a group counted after its members
+ * (`{4d6>=5}>=1`) runs this pass twice over the same dice, and the parse-time
+ * reject that blocks a direct `4d6>=5>=4` does not reach through a group.
  *
  * @module evaluator/modifiers/success-count
  */
 
-import type { CompareOp, DieResult } from '../../types.js';
+import type { DieResult, ResolvedComparePoint } from '../../types.js';
 import { matchesCondition } from './compare.js';
-
-export type ResolvedThreshold = {
-  operator: CompareOp;
-  value: number;
-};
+import { isVersusDc } from './flags.js';
 
 export type SuccessCountResult = {
   total: number;
@@ -31,17 +30,30 @@ export type SuccessCountResult = {
 
 export function countSuccesses(
   dice: DieResult[],
-  threshold: ResolvedThreshold,
-  failThreshold?: ResolvedThreshold,
+  threshold: ResolvedComparePoint,
+  failThreshold: ResolvedComparePoint | undefined,
+  hasVersusDc: boolean,
 ): SuccessCountResult {
   let successes = 0;
   let failures = 0;
 
-  for (const die of dice) {
+  // ! 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 (#281). 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;
+
+  // ! The guards below only stop the *same* tag being written twice. A nested
+  // ! count with a different threshold still appends to the first pass's tags,
+  // ! so a die can end up both `'success'` and `'failure'`, and the returned
+  // ! counts then disagree with the tags in `rolls`.
+  for (const die of pool) {
     if (die.modifiers.includes('dropped')) continue;
 
     if (matchesCondition(die.result, threshold.operator, threshold.value)) {
-      die.modifiers.push('success');
+      if (!die.modifiers.includes('success')) die.modifiers.push('success');
       successes += 1;
       continue;
     }
@@ -50,7 +62,7 @@ export function countSuccesses(
       failThreshold != null &&
       matchesCondition(die.result, failThreshold.operator, failThreshold.value)
     ) {
-      die.modifiers.push('failure');
+      if (!die.modifiers.includes('failure')) die.modifiers.push('failure');
       failures += 1;
     }
   }