@yipe/dice 0.9.0 → 0.10.0

package/dist/builder/index.js

@@ -1474,7 +1474,7 @@ var _PMF = class _PMF {
     const id = this.identifier;
     let key = `${id}`;
     for (let i = 1; i < n; i++) key += `+${id}`;
-    return `${key}@${eps}`;
+    return `${key}@${eps}|${this.fingerprint()}`;
   }
   /**
    * Efficiently computes this PMF convolved with itself `n` times.
@@ -1825,16 +1825,27 @@ var _PMF = class _PMF {
     return `v4:${raw ? "RAW" : "N"}:${id1}+${id2}@${eps}|${p1.fingerprint()}|${p2.fingerprint()}`;
   }
   /**
-   * A small content fingerprint (mass + bin count + face sum) so convolution
-   * cache keys change if the underlying numbers do. Memoized because a PMF is
-   * immutable once constructed — this avoids re-summing every key on each
-   * convolve() call (including cache hits).
+   * A content fingerprint of every bin (probability, per-label `count`, per-label `attr`) plus
+   * the `normalized` flag, so convolution/power cache keys change whenever the underlying
+   * numbers do. Mass/bin-count/face-sum alone are not content-unique: `mapDamage` variants can
+   * keep the same identifier, support, mass, and face sum while differing in per-bin
+   * probabilities or in the `count`/`attr` channels `convolve()`/`power()` actually propagate --
+   * that previously let `power()` return one PMF's cached result for a different PMF. Memoized
+   * because a PMF is immutable once constructed -- this avoids re-deriving the key on every
+   * convolve()/power() call (including cache hits). Bin order is sorted by damage value (and
+   * label keys sorted within each bin) so two equal-content PMFs built via different code paths
+   * fingerprint identically regardless of Map insertion order.
    */
   fingerprint() {
     if (this._fingerprint === void 0) {
-      let faceSum = 0;
-      for (const k of this.map.keys()) faceSum += k;
-      this._fingerprint = `${this.mass().toFixed(12)}|${this.map.size}|${faceSum}`;
+      const bins = [...this.map.entries()].sort((a, b) => a[0] - b[0]);
+      const parts = [];
+      for (const [damageValue, bin] of bins) {
+        const countStr = Object.keys(bin.count).sort().map((k) => `${k}:${bin.count[k]}`).join(",");
+        const attrStr = bin.attr ? Object.keys(bin.attr).sort().map((k) => `${k}:${bin.attr[k]}`).join(",") : "";
+        parts.push(`${damageValue}:${bin.p}[${countStr}]{${attrStr}}`);
+      }
+      this._fingerprint = `${this.normalized ? 1 : 0}|${parts.join(";")}`;
     }
     return this._fingerprint;
   }
@@ -2066,11 +2077,13 @@ var _PMF = class _PMF {
   /** Quantile / inverse CDF for p in [0,1]. Returns smallest x with CDF ≥ p. */
   quantile(p) {
     if (this.map.size === 0) return 0;
+    const totalMass = this.mass();
+    if (totalMass <= 0) return 0;
     const s = this.support().sort((a, b) => a - b);
     let acc = 0;
     for (const x of s) {
       acc += this.pAt(x);
-      if (acc >= p) return x;
+      if (acc / totalMass >= p) return x;
     }
     return s[s.length - 1];
   }
@@ -3049,6 +3062,12 @@ function combineDiceWithNormalization(dice, normValue, outcomeType, currentNorm,
   finalResult = finalResult.combine(dice);
   return { newNorm: currentNorm * normValue, updatedResult: finalResult };
 }
+function subtractCounts(a, b) {
+  const result = new Dice();
+  for (const [key, value] of a.getFaceEntries()) result.increment(key, value);
+  for (const [key, value] of b.getFaceEntries()) result.increment(key, -value);
+  return result;
+}
 function parseExpression(arr, n) {
   const result = (() => {
     const res = parseArgument(arr, n);
@@ -3056,8 +3075,29 @@ function parseExpression(arr, n) {
   })();
   let op = parseOperation(arr);
   let finalResult = result;
+  let baseDieMeta = result.privateData?.checkDie && !result.privateData.checkDie.rerollOne ? result.privateData.checkDie : void 0;
+  let bonusOnly = Dice.scalar(0);
   while (op != null) {
     const arg = !op.unary ? parseArgument(arr, n) : finalResult;
+    let acAlreadyApplied = false;
+    if (baseDieMeta) {
+      if (op === Dice.prototype.addNonZero) {
+        bonusOnly = bonusOnly.add(arg);
+      } else if (op === Dice.prototype.subtract) {
+        bonusOnly = bonusOnly.subtract(arg);
+      } else if (op === Dice.prototype.ac && typeof arg === "number") {
+        const natMaxSlice = bonusOnly.add(baseDieMeta.sides);
+        const restSlice = subtractCounts(finalResult, natMaxSlice);
+        const gatedNatMaxSlice = natMaxSlice.ac(arg);
+        finalResult = restSlice.ac(arg).combine(gatedNatMaxSlice);
+        finalResult.privateData.checkDie = baseDieMeta;
+        finalResult.privateData.natMaxCritSlice = gatedNatMaxSlice;
+        acAlreadyApplied = true;
+        baseDieMeta = void 0;
+      } else {
+        baseDieMeta = void 0;
+      }
+    }
     let crit;
     let critNorm = 1;
     if (arr[0] === "x" || arr[0] === "c") {
@@ -3068,11 +3108,17 @@ function parseExpression(arr, n) {
       assertToken(arr, "i");
       assertToken(arr, "t");
       const count = isXcrit ? parseNumber(arr, n) : 1;
-      crit = new Dice();
-      for (let i = 0; i < count; i++) {
-        const max = finalResult.maxFace();
-        crit.setFace(max, finalResult.get(max));
-        finalResult = finalResult.deleteFace(max);
+      const trackedCritSlice = finalResult.privateData?.natMaxCritSlice;
+      if (count === 1 && trackedCritSlice) {
+        crit = trackedCritSlice;
+        finalResult = subtractCounts(finalResult, trackedCritSlice);
+      } else {
+        crit = new Dice();
+        for (let i = 0; i < count; i++) {
+          const max = finalResult.maxFace();
+          crit.setFace(max, finalResult.get(max));
+          finalResult = finalResult.deleteFace(max);
+        }
       }
       critNorm = crit.total();
       crit = op.call(crit, parseBinaryArgument(arg, arr, n));
@@ -3123,7 +3169,9 @@ function parseExpression(arr, n) {
       missNorm = miss && missNorm ? miss.total() / missNorm : 1;
     }
     let norm = finalResult.total();
-    finalResult = op.call(finalResult, arg);
+    if (!acAlreadyApplied) {
+      finalResult = op.call(finalResult, arg);
+    }
     norm = norm ? finalResult.total() / norm : 1;
     if (crit) {
       const result2 = combineDiceWithNormalization(
@@ -3314,6 +3362,7 @@ function parseDice(s, n) {
   if (rerollOne) {
     result = result.reroll(1);
   }
+  result.privateData.checkDie = { sides, rerollOne };
   return result;
 }
 function peek(arr, expected) {
@@ -3505,6 +3554,12 @@ function d20PMF(rerollOne) {
 }
 
 // src/builder/roll.ts
+function validateScaleInt(scale) {
+  const scaleInt = Math.floor(scale);
+  if (scaleInt !== scale) throw new Error("Scale must be an integer");
+  if (scaleInt <= 0) throw new Error("Scale must be > 0");
+  return scaleInt;
+}
 var rollPMFCache = new LRUCache(4e3);
 function clearRollCache() {
   rollPMFCache.clear();
@@ -3710,7 +3765,8 @@ var RollBuilder = class _RollBuilder {
     newConfigs[newConfigs.length - 1].explode = count;
     return this.create(newConfigs);
   }
-  /** Apply per-die minimum value (min > 0). */
+  /** Apply per-die minimum value (floors each die roll at `val`, e.g. `minimum(3)` treats a 1 or
+   * 2 as a 3 -- the 2024 Great Weapon Fighting style). */
   minimum(val) {
     if (val !== void 0 && isNaN(val))
       throw new Error("Invalid NaN value for minimum");
@@ -3718,7 +3774,7 @@ var RollBuilder = class _RollBuilder {
     if (val === 0) return this;
     if (val < 0) throw new Error("Minimum value must be >= 0");
     const newConfigs = this.getSubRollConfigs();
-    newConfigs[newConfigs.length - 1].minimum = val + 1;
+    newConfigs[newConfigs.length - 1].minimum = val;
     return this.create(newConfigs);
   }
   bestOf(count) {
@@ -3819,9 +3875,7 @@ var RollBuilder = class _RollBuilder {
     return this.create(configs);
   }
   scaleDice(scale) {
-    const scaleInt = Math.floor(scale);
-    if (scaleInt !== scale) throw new Error("Scale must be an integer");
-    if (scaleInt <= 0) throw new Error("Scale must be > 0");
+    const scaleInt = validateScaleInt(scale);
     const newConfigs = this.getSubRollConfigs().map((config) => {
       if (!config.sides || config.sides <= 0) return config;
       return { ...config, count: config.count * scaleInt };
@@ -3944,12 +3998,16 @@ var RollBuilder = class _RollBuilder {
   }
   configToSingleExpressionWithoutModifier(config, isRootDie) {
     if (!config.sides || config.sides <= 0) return "";
+    if (config.explode && Number.isFinite(config.explode) && config.explode > 0) {
+      throw new Error(
+        `toExpression() cannot represent an exploding die (d${config.sides} explode(${config.explode})): the string grammar has no explode syntax. Use the builder's own PMF (.toPMF()/.pmf) instead of round-tripping through toExpression()/parse().`
+      );
+    }
     let baseDie = `d${config.sides}`;
+    const rerollClause = config.reroll > 0 ? config.reroll === 1 ? " reroll 1" : ` reroll d${config.reroll}` : "";
     if (config.reroll > 0) {
-      if (config.minimum > 0 && config.explode > 0) ; else if (config.minimum > 0) {
-        for (let i = config.reroll; i >= 1; i--) baseDie += ` reroll ${i}`;
-      } else {
-        for (let i = 1; i <= config.reroll; i++) baseDie += ` reroll ${i}`;
+      if (config.minimum > 0 && config.explode > 0) ; else {
+        baseDie += rerollClause;
       }
     }
     if (config.minimum > 0) {
@@ -3959,9 +4017,7 @@ var RollBuilder = class _RollBuilder {
         baseDie = `${config.minimum}>${baseDie}`;
       }
       if (config.reroll > 0 && config.explode > 0) {
-        for (let i = 1; i <= config.reroll; i++) {
-          baseDie += ` reroll ${i}`;
-        }
+        baseDie += rerollClause;
       }
     }
     if (baseDie === "d20 reroll 1" && config.minimum <= 1) baseDie = "hd20";
@@ -3979,10 +4035,14 @@ var RollBuilder = class _RollBuilder {
       case "flat":
         if (config.keep) {
           const mode = config.keep.mode === "highest" ? "kh" : "kl";
+          const baseCount = Math.max(1, Math.floor(Math.abs(config.count || 1)));
+          const trials = Math.max(1, Math.floor(config.keep.total));
+          const isMaxOfShape = config.keep.count === 1 && config.keep.mode === "highest";
+          const innerCount = trials === baseCount && !isMaxOfShape ? 1 : baseCount;
           const baseDieExpression = this.configToSingleExpressionWithoutModifier(
             {
               ...config,
-              count: config.count,
+              count: innerCount,
               modifier: 0,
               rollType: "flat",
               keep: void 0
@@ -4014,7 +4074,19 @@ var RollBuilder = class _RollBuilder {
           }
         }
         if (config.bestOf && config.count && config.bestOf < config.count) {
-          mainExpression += `kh${config.bestOf}`;
+          const pool = Math.max(1, Math.floor(Math.abs(config.count)));
+          const baseDieExpression = this.configToSingleExpressionWithoutModifier(
+            {
+              ...config,
+              count: 1,
+              modifier: 0,
+              bestOf: 0,
+              keep: void 0,
+              rollType: "flat"
+            },
+            false
+          );
+          mainExpression = `${pool}kh${Math.floor(config.bestOf)}(${baseDieExpression})`;
         }
         break;
     }
@@ -4117,6 +4189,12 @@ var HalfRollBuilder = class _HalfRollBuilder extends RollBuilder {
   toPMF(eps = 0) {
     return pmfFromRollBuilder(this, eps);
   }
+  // Scale the dice, keep the same // 2 (half) transform applied on top -- delegating to the
+  // base class's `create()`-based scaleDice would drop the halving entirely, e.g. a doubled-dice
+  // crit on a resisted hit payload silently losing the resistance.
+  scaleDice(scale) {
+    return new _HalfRollBuilder(this.innerRoll.scaleDice(scale));
+  }
   copy() {
     return new _HalfRollBuilder(this.innerRoll.copy());
   }
@@ -4143,9 +4221,16 @@ var ScaleRollBuilder = class _ScaleRollBuilder extends RollBuilder {
   }
   toExpression() {
     const inner = this.innerRoll.toExpression();
-    if (this.denominator === 1) return `${this.numerator} * (${inner})`;
-    if (this.numerator === 1) return `(${inner}) // ${this.denominator}`;
-    return `(${inner}) * ${this.numerator} // ${this.denominator}`;
+    const denominator = this.denominator === 0 ? 1 : this.denominator;
+    if (denominator === 1) return `${this.numerator} ** (${inner})`;
+    if (this.rounding === "round") {
+      throw new Error(
+        `toExpression() cannot represent scaleResult(${this.numerator}, ${this.denominator}, "round"): the string grammar has only floor (//) and ceil (/) division. Use the builder's own PMF (.toPMF()/.pmf) instead.`
+      );
+    }
+    const div = this.rounding === "ceil" ? "/" : "//";
+    if (this.numerator === 1) return `(${inner}) ${div} ${denominator}`;
+    return `(${inner}) ** ${this.numerator} ${div} ${denominator}`;
   }
   toAST() {
     return {
@@ -4159,6 +4244,17 @@ var ScaleRollBuilder = class _ScaleRollBuilder extends RollBuilder {
   toPMF(eps = 0) {
     return pmfFromRollBuilder(this, eps);
   }
+  // Scale the dice, keep the same numerator/denominator/rounding transform applied on top --
+  // delegating to the base class's `create()`-based scaleDice would drop the scale entirely,
+  // e.g. a doubled-dice crit on a vulnerable hit payload silently losing the vulnerability.
+  scaleDice(scale) {
+    return new _ScaleRollBuilder(
+      this.innerRoll.scaleDice(scale),
+      this.numerator,
+      this.denominator,
+      this.rounding
+    );
+  }
   copy() {
     return new _ScaleRollBuilder(
       this.innerRoll.copy(),
@@ -4231,6 +4327,18 @@ var MaxOfRollBuilder = class _MaxOfRollBuilder extends RollBuilder {
   toPMF(eps = 0) {
     return pmfFromRollBuilder(this, eps);
   }
+  // Scale the dice INSIDE each trial (e.g. maxOf(2, 1d12) -> maxOf(2, 2d12)), keeping the same
+  // trial count -- delegating to the base class's `create()`-based scaleDice would collapse
+  // straight to plain dice, losing the "take the highest of N trials" semantics entirely.
+  scaleDice(scale) {
+    const scaleInt = validateScaleInt(scale);
+    return new _MaxOfRollBuilder(
+      this.innerRoll.scaleDice(scaleInt),
+      this.count,
+      this.diceCount ? this.diceCount * scaleInt : void 0,
+      this.diceSides
+    );
+  }
   copy() {
     return new _MaxOfRollBuilder(this.innerRoll.copy(), this.count);
   }
@@ -4277,9 +4385,7 @@ var AlwaysHitBuilder = class _AlwaysHitBuilder extends RollBuilder {
     return new RollBuilder(configs).toExpression();
   }
   toPMF() {
-    const rollType = this.rollType;
-    const rerollOne = this.baseReroll > 0;
-    return d20RollPMF(rollType, rerollOne);
+    return resolveRootD20(this);
   }
   copy() {
     const baseCopy = new RollBuilder(this.getSubRollConfigs());
@@ -4327,9 +4433,7 @@ var AlwaysCritBuilder = class _AlwaysCritBuilder extends RollBuilder {
     return new RollBuilder(configs).toExpression();
   }
   toPMF() {
-    const rollType = this.rollType;
-    const rerollOne = this.baseReroll > 0;
-    return d20RollPMF(rollType, rerollOne);
+    return resolveRootD20(this);
   }
   copy() {
     const baseCopy = new RollBuilder(this.getSubRollConfigs());
@@ -4519,6 +4623,17 @@ var CompositeSumRollBuilder = class _CompositeSumRollBuilder extends RollBuilder
   toPMF(eps = 0) {
     return pmfFromRollBuilder(this, eps);
   }
+  // Scaling a composite (mixed damage types, e.g. base + resisted) must scale each PART's own
+  // dice while preserving its own half/scale wrapper -- delegating to the base class's
+  // `create()`-based scaleDice would lose every part's transform, collapsing straight to plain
+  // dice. This is what auto-crit doubling (attack.ts's `hitEffect.copy().doubleDice()`) relies
+  // on for a mixed-resistance hit payload.
+  scaleDice(scale) {
+    validateScaleInt(scale);
+    return new _CompositeSumRollBuilder(
+      this.parts.map((p) => p.scaleDice(scale))
+    );
+  }
   copy() {
     return new _CompositeSumRollBuilder(this.parts.map((p) => p.copy()));
   }
@@ -4596,6 +4711,15 @@ var builderPMFCache = new LRUCache(1e3);
 // src/builder/ast.ts
 var defaultEps = 0;
 var singleDiePMFCache = new LRUCache(1e3);
+function dieNodeFromConfig(cfg) {
+  return {
+    type: "die",
+    sides: cfg.sides,
+    reroll: cfg.reroll > 0 ? cfg.reroll : void 0,
+    minimum: cfg.minimum > 0 ? cfg.minimum : void 0,
+    explode: cfg.explode && Number.isFinite(cfg.explode) && cfg.explode > 0 ? cfg.explode : void 0
+  };
+}
 function astFromRollConfigs(configs) {
   if (!configs || configs.length === 0) return void 0;
   const children = [];
@@ -4605,13 +4729,9 @@ function astFromRollConfigs(configs) {
     const count = Math.abs(cfg.count || 0);
     constantSum += cfg.modifier || 0;
     if ((cfg.sides || 0) <= 0) continue;
-    const die = {
-      type: "die",
-      sides: cfg.sides,
-      reroll: cfg.reroll > 0 ? cfg.reroll : void 0,
-      minimum: cfg.minimum > 0 ? cfg.minimum : void 0,
-      explode: cfg.explode && Number.isFinite(cfg.explode) && cfg.explode > 0 ? cfg.explode : void 0
-    };
+    const isSynthesizedBestOf = !cfg.keep && cfg.bestOf > 0 && cfg.bestOf < count;
+    const effectiveKeep = isSynthesizedBestOf ? { total: count, count: Math.floor(cfg.bestOf), mode: "highest" } : cfg.keep;
+    const die = dieNodeFromConfig(cfg);
     let node = die;
     let appliedRollType = false;
     if (cfg.rollType && cfg.rollType !== "flat") {
@@ -4629,11 +4749,11 @@ function astFromRollConfigs(configs) {
       }
       appliedRollType = true;
     }
-    if (cfg.rollType === "flat" && cfg.keep && cfg.keep.total > 0) {
+    if (cfg.rollType === "flat" && effectiveKeep && effectiveKeep.total > 0) {
       const baseCount = Math.max(1, Math.floor(Math.abs(count || 1)));
-      const trials = Math.max(1, Math.floor(cfg.keep.total));
-      const k = Math.max(0, Math.floor(cfg.keep.count));
-      if (k === 1 && cfg.keep.mode === "highest") {
+      const trials = Math.max(1, Math.floor(effectiveKeep.total));
+      const k = Math.max(0, Math.floor(effectiveKeep.count));
+      if (k === 1 && effectiveKeep.mode === "highest" && !isSynthesizedBestOf) {
         const perTrial = {
           type: "sum",
           count: baseCount,
@@ -4652,7 +4772,7 @@ function astFromRollConfigs(configs) {
         const base = { type: "sum", count: trials, child: node };
         node = {
           type: "keep",
-          mode: cfg.keep.mode,
+          mode: effectiveKeep.mode,
           count: k,
           child: base
         };
@@ -4672,7 +4792,7 @@ function astFromRollConfigs(configs) {
           };
           node = {
             type: "keep",
-            mode: cfg.keep.mode,
+            mode: effectiveKeep.mode,
             count: k,
             child: trialPool
           };
@@ -4746,8 +4866,8 @@ function resolve(node, eps = defaultEps) {
       }
       case "d20Roll": {
         const childDie = findDie(node.child);
-        const rerollOne = !!childDie && (childDie.reroll || 0) >= 1;
-        return d20RollPMF(node.rollType, rerollOne);
+        if (!childDie) return d20RollPMF(node.rollType, false);
+        return resolveD20Roll(childDie, node.rollType);
       }
       case "half": {
         const childPMF = resolve(node.child, eps);
@@ -4773,6 +4893,37 @@ function pmfFromRollBuilder(rb, eps = defaultEps) {
   const ast = rb.toAST();
   return resolve(ast, eps);
 }
+var d20RollLiftCache = new LRUCache(500);
+function resolveD20Roll(die, rollType) {
+  const base = resolveSingleDie(die, defaultEps);
+  const type = rollType || "flat";
+  if (type === "flat") return base;
+  const cacheKey = `${getASTSignature(die)}|${type}`;
+  const cached = d20RollLiftCache.get(cacheKey);
+  if (cached) return cached;
+  const support = [...base.support()].sort((a, b) => a - b);
+  const out = /* @__PURE__ */ new Map();
+  let cum = 0;
+  let prevLifted = 0;
+  for (const k of support) {
+    cum += base.pAt(k);
+    const curLifted = type === "advantage" ? cum * cum : type === "elven accuracy" ? cum * cum * cum : 1 - (1 - cum) * (1 - cum);
+    const pk = curLifted - prevLifted;
+    if (pk > 0) out.set(k, pk);
+    prevLifted = curLifted;
+  }
+  const result = PMF.fromMap(out, defaultEps);
+  d20RollLiftCache.set(cacheKey, result);
+  return result;
+}
+function resolveRootD20(check) {
+  const rootConfig = check.getRootDieConfig();
+  const rollType = check.rollType;
+  if (!rootConfig || !(rootConfig.sides > 0)) {
+    return d20RollPMF(rollType, check.baseReroll > 0);
+  }
+  return resolveD20Roll(dieNodeFromConfig(rootConfig), rollType);
+}
 function resolveSingleDie(die, eps = defaultEps) {
   const signature = getASTSignature(die);
   const cacheKey = `${signature}_${eps}`;
@@ -4806,20 +4957,12 @@ function resolveSingleDie(die, eps = defaultEps) {
     for (const v of pmf.support()) {
       if (v !== maxFace) nonMax.set(v, pmf.pAt(v));
     }
-    let nonMaxPMF = PMF.fromMap(nonMax, eps);
-    if (Math.abs(nonMaxPMF.mass() - (1 - pMax)) > eps) {
-      nonMaxPMF = nonMaxPMF.scaleMass(1 - pMax);
-    }
-    let tail = PMF.delta(0, eps);
-    const addOnce = pmf;
-    for (let t = 1; t <= times; t++) {
-      tail = tail.convolve(addOnce, eps);
+    const nonMaxPMF = PMF.fromMap(nonMax, eps);
+    let chain = pmf;
+    for (let remaining = 1; remaining <= times - 1; remaining++) {
+      chain = PMF.branch(chain.mapDamage((v) => v + maxFace), nonMaxPMF, pMax);
     }
-    const exploded = PMF.branch(
-      tail.mapDamage((v) => v + maxFace),
-      nonMaxPMF,
-      pMax
-    );
+    const exploded = PMF.branch(chain.mapDamage((v) => v + maxFace), nonMaxPMF, pMax);
     pmf = exploded;
   }
   singleDiePMFCache.set(cacheKey, pmf);
@@ -5118,10 +5261,8 @@ var AttackBuilder = class _AttackBuilder {
     return `${checkPart} * ${effectPart}`;
   }
   resolveProbabilities(check, eps = 0) {
-    const rollType = check.rollType;
-    const rerollOne = check.baseReroll > 0;
     const critThreshold = check.critThreshold;
-    const d202 = d20RollPMF(rollType, rerollOne);
+    const d202 = resolveRootD20(check);
     if (check instanceof AlwaysCritBuilder) {
       if (check.fromAlwaysHit) {
         return { pSuccess: 1, pHit: 0, pCrit: 1, pMiss: 0 };
@@ -5171,13 +5312,17 @@ var AttackBuilder = class _AttackBuilder {
         pmiss += pr;
         continue;
       }
-      if (r >= critThreshold) {
+      if (r === 20) {
         pcrit += pr;
         continue;
       }
       const need = ac - staticMod - r;
       const pBonusHit = bonusPMF.tailProbGE(need);
-      phit += pr * pBonusHit;
+      if (r >= critThreshold) {
+        pcrit += pr * pBonusHit;
+      } else {
+        phit += pr * pBonusHit;
+      }
       pmiss += pr * (1 - pBonusHit);
     }
     const psuccess = phit + pcrit;
@@ -5325,9 +5470,7 @@ var ACBuilder = class _ACBuilder extends RollBuilder {
   }
   toPMF(eps = 0) {
     const ac = this.attackConfig.ac;
-    const rollType = this.rollType;
-    const rerollOne = this.baseReroll > 0;
-    const d202 = d20RollPMF(rollType, rerollOne);
+    const d202 = resolveRootD20(this);
     const staticMod = this.modifier;
     const bonusPMFs = this.getBonusDicePMFs(this, eps);
     const parts = [d202, ...bonusPMFs];
@@ -5437,21 +5580,17 @@ var SaveBuilder = class _SaveBuilder {
 function resolveProbabilities(check) {
   const saveBonus = check.modifier;
   const dc = check.saveDC;
-  const d20Type = check.rollType;
-  const baseReroll = check.baseReroll;
-  const die = d20RollPMF(d20Type, baseReroll > 0);
+  const eps = 0;
+  const die = resolveRootD20(check);
   const faceP = /* @__PURE__ */ new Map();
   for (const [r, bin] of die) {
     const pr = bin.p;
     if (pr > 0) faceP.set(r, pr);
   }
-  const eps = 0;
   const bonusDicePMFs = check.getBonusDicePMFs(check, eps);
   const bonusPMF = bonusDicePMFs.length > 0 ? PMF.convolveMany(bonusDicePMFs, eps) : PMF.zero(eps);
   let pSuccess = 0;
-  for (let r = 1; r <= 20; r++) {
-    const pr = faceP.get(r);
-    if (!pr) continue;
+  for (const [r, pr] of faceP) {
     const need = dc - saveBonus - r;
     pSuccess += pr * bonusPMF.tailProbGE(need);
   }
@@ -5521,9 +5660,7 @@ var DCBuilder = class _DCBuilder extends RollBuilder {
       if (cached) return cached;
     }
     const saveDC = this.saveDC;
-    const rollType = this.rollType;
-    const rerollOne = this.baseReroll > 0;
-    const d202 = d20RollPMF(rollType, rerollOne);
+    const d202 = resolveRootD20(this);
     const staticMod = this.modifier;
     const bonusDicePMFs = this.getBonusDiceConfigs().map(
       (cfg) => pmfFromRollBuilder(RollBuilder.fromConfigs([cfg]), eps)