@yipe/dice 0.10.0 → 0.12.0

package/dist/index.cjs

@@ -1,6 +1,27 @@
 'use strict';
 
 // src/common/bounce.ts
+function faceWeights(faces, minimum = 0, reroll = 0) {
+  const f = Math.max(0, Math.floor(faces));
+  if (f <= 0) return [];
+  let weights = new Array(f).fill(1 / f);
+  const r = Math.max(0, Math.min(Math.floor(reroll), f));
+  if (r > 0) {
+    const rerollMass = r / f;
+    const uniformReroll = rerollMass / f;
+    weights = weights.map((_, i) => (i < r ? 0 : 1 / f) + uniformReroll);
+  }
+  const minV = Math.max(0, Math.floor(minimum));
+  if (minV > 1) {
+    const collapsed = new Array(f).fill(0);
+    for (let v = 1; v <= f; v++) {
+      const target = Math.min(f, Math.max(v, minV));
+      collapsed[target - 1] += weights[v - 1];
+    }
+    weights = collapsed;
+  }
+  return weights;
+}
 function binom(n, k) {
   if (k < 0 || k > n) return 0;
   let result = 1;
@@ -35,19 +56,161 @@ function calculateBounceOdds(diceCount, dieFaces, options) {
   const minimumDieRoll = options?.minimumDieRoll ?? 0;
   const rerollDamageDice = options?.rerollDamageDice ?? 0;
   const pMatchFirst = pMatch(diceCount, dieFaces, minimumDieRoll);
-  const rerollCount = Math.min(rerollDamageDice, diceCount);
-  if (rerollCount <= 0) return pMatchFirst;
-  const pNoMatchFirst = 1 - pMatchFirst;
-  const keptDice = diceCount - rerollCount;
-  const effectiveFaces = minimumDieRoll >= 2 ? dieFaces - (minimumDieRoll - 1) : dieFaces;
-  const pRerollDieMissesAll = keptDice > 0 ? Math.pow((effectiveFaces - keptDice) / effectiveFaces, rerollCount) : 1;
-  const pAtLeastOneRerollMatches = 1 - pRerollDieMissesAll;
-  const pRerolledMatch = rerollCount >= 2 ? pMatch(rerollCount, dieFaces, minimumDieRoll) : 0;
-  const pMatchAfterReroll = Math.min(
+  const rerollLimit = Math.min(Math.floor(rerollDamageDice), diceCount);
+  if (rerollLimit <= 0 || pMatchFirst >= 1) return pMatchFirst;
+  const collapsed = minimumDieRoll >= 2;
+  const lightCount = collapsed ? dieFaces - minimumDieRoll : dieFaces;
+  const heavyWeight = collapsed ? minimumDieRoll / dieFaces : 0;
+  const pMissAfter = (rerolled, keptLight, heavyKept) => pAllDistinct(rerolled, dieFaces, lightCount - keptLight, heavyKept ? 0 : heavyWeight);
+  let missLightOnly = 1;
+  let missWithHeavy = 1;
+  for (let rerolled = 1; rerolled <= rerollLimit; rerolled++) {
+    const allLightKept = pMissAfter(rerolled, diceCount - rerolled, false);
+    missLightOnly = Math.min(missLightOnly, allLightKept);
+    missWithHeavy = Math.min(missWithHeavy, allLightKept);
+    if (rerolled < diceCount) {
+      missWithHeavy = Math.min(missWithHeavy, pMissAfter(rerolled, diceCount - 1 - rerolled, true));
+    }
+  }
+  const pLightOnly = pAllDistinct(diceCount, dieFaces, lightCount, 0);
+  const pWithHeavy = diceCount * heavyWeight * pAllDistinct(diceCount - 1, dieFaces, lightCount, 0);
+  return Math.min(
     1,
-    pAtLeastOneRerollMatches + pRerolledMatch * (1 - pAtLeastOneRerollMatches)
+    pMatchFirst + pLightOnly * (1 - missLightOnly) + pWithHeavy * (1 - missWithHeavy)
   );
-  return Math.min(1, pMatchFirst + pNoMatchFirst * pMatchAfterReroll);
+}
+function diceSumDistribution(dice, weights) {
+  let dist = /* @__PURE__ */ new Map([[0, 1]]);
+  for (let die = 0; die < dice; die++) {
+    const next = /* @__PURE__ */ new Map();
+    for (const [sum, mass] of dist) {
+      for (let face = 1; face <= weights.length; face++) {
+        const w = weights[face - 1] ?? 0;
+        if (w <= 0) continue;
+        const s = sum + face;
+        next.set(s, (next.get(s) ?? 0) + mass * w);
+      }
+    }
+    dist = next;
+  }
+  return dist;
+}
+function sumAllDistinctDistribution(dice, weights) {
+  const faceCount = weights.length;
+  let dp = /* @__PURE__ */ new Map([[0, /* @__PURE__ */ new Map([[0, 1]])]]);
+  for (let face = 1; face <= faceCount; face++) {
+    const w = weights[face - 1] ?? 0;
+    const next = /* @__PURE__ */ new Map();
+    for (const [count, sumMap] of dp) next.set(count, new Map(sumMap));
+    if (w > 0) {
+      for (const [count, sumMap] of dp) {
+        const nextCount = count + 1;
+        if (nextCount > dice) continue;
+        const target = next.get(nextCount) ?? /* @__PURE__ */ new Map();
+        for (const [sum, mass] of sumMap) {
+          const s = sum + face;
+          target.set(s, (target.get(s) ?? 0) + mass * w);
+        }
+        next.set(nextCount, target);
+      }
+    }
+    dp = next;
+  }
+  let factorial = 1;
+  for (let i = 2; i <= dice; i++) factorial *= i;
+  const chosen = dp.get(dice) ?? /* @__PURE__ */ new Map();
+  const result = /* @__PURE__ */ new Map();
+  for (const [sum, mass] of chosen) result.set(sum, mass * factorial);
+  return result;
+}
+function jointSumAndMatch(dice, weights) {
+  if (dice <= 1) return /* @__PURE__ */ new Map();
+  const total = diceSumDistribution(dice, weights);
+  const distinct = sumAllDistinctDistribution(dice, weights);
+  const rest = diceSumDistribution(dice - 2, weights);
+  const matchable = /* @__PURE__ */ new Set();
+  weights.forEach((weight, index) => {
+    if (weight <= 0) return;
+    for (const sum of rest.keys()) matchable.add(2 * (index + 1) + sum);
+  });
+  const result = /* @__PURE__ */ new Map();
+  for (const [sum, mass] of total) {
+    if (!matchable.has(sum)) continue;
+    const matchMass = Math.max(0, mass - (distinct.get(sum) ?? 0));
+    if (matchMass > 0) result.set(sum, matchMass);
+  }
+  return result;
+}
+function explodingPoolMkDistribution(pMax, count, budget) {
+  const binomial = (n, p) => {
+    const result = new Array(n + 1).fill(0);
+    result[0] = 1;
+    for (let trial = 0; trial < n; trial++) {
+      const next = new Array(n + 1).fill(0);
+      for (let successes = 0; successes <= trial; successes++) {
+        const mass = result[successes];
+        if (mass <= 0) continue;
+        next[successes] += mass * (1 - p);
+        next[successes + 1] += mass * p;
+      }
+      for (let i = 0; i <= n; i++) result[i] = next[i];
+    }
+    return result;
+  };
+  const memo = /* @__PURE__ */ new Map();
+  const f = (pending, remainingBudget) => {
+    if (pending === 0) return /* @__PURE__ */ new Map([["0,0", 1]]);
+    if (remainingBudget === 0) {
+      const binom2 = binomial(pending, pMax);
+      const result2 = /* @__PURE__ */ new Map();
+      for (let m = 0; m <= pending; m++) {
+        const mass = binom2[m];
+        if (mass > 0) result2.set(`${m},${pending - m}`, mass);
+      }
+      return result2;
+    }
+    const key = `${pending},${remainingBudget}`;
+    const cached = memo.get(key);
+    if (cached) return cached;
+    const result = /* @__PURE__ */ new Map();
+    const accumulate = (mk, mass) => {
+      result.set(mk, (result.get(mk) ?? 0) + mass);
+    };
+    for (const [mk, mass] of f(pending, remainingBudget - 1)) {
+      const [m, k] = mk.split(",").map(Number);
+      accumulate(`${m + 1},${k}`, mass * pMax);
+    }
+    for (const [mk, mass] of f(pending - 1, remainingBudget)) {
+      const [m, k] = mk.split(",").map(Number);
+      accumulate(`${m},${k + 1}`, mass * (1 - pMax));
+    }
+    memo.set(key, result);
+    return result;
+  };
+  return f(count, budget);
+}
+function allDistinctProbability(count, weights) {
+  const symmetric = new Array(count + 1).fill(0);
+  symmetric[0] = 1;
+  for (const weight of weights) {
+    if (weight <= 0) continue;
+    for (let chosen = count; chosen >= 1; chosen--) symmetric[chosen] += symmetric[chosen - 1] * weight;
+  }
+  let factorial = 1;
+  for (let i = 2; i <= count; i++) factorial *= i;
+  return factorial * symmetric[count];
+}
+function explodingPoolMatchProbability(weights, count, budget) {
+  if (count <= 0 || weights.length === 0) return 0;
+  const pMax = weights[weights.length - 1];
+  const nonMax = pMax < 1 ? weights.slice(0, -1).map((weight) => weight / (1 - pMax)) : [];
+  let pMatchTotal = 0;
+  for (const [mk, weight] of explodingPoolMkDistribution(pMax, count, budget)) {
+    const [m, k] = mk.split(",").map(Number);
+    if (m >= 2) pMatchTotal += weight;
+    else if (k >= 2) pMatchTotal += weight * (1 - allDistinctProbability(k, nonMax));
+  }
+  return Math.min(1, Math.max(0, pMatchTotal));
 }
 
 // src/common/errors.ts
@@ -62,12 +225,40 @@ var DiceParseError = class _DiceParseError extends Error {
 };
 
 // src/common/lru-cache.ts
+var cachingEnabled = true;
+var cacheGeneration = 0;
+function setCachingEnabled(enabled) {
+  cachingEnabled = enabled;
+  if (!enabled) cacheGeneration++;
+}
+function getCachingEnabled() {
+  return cachingEnabled;
+}
 var LRUCache = class {
-  constructor(maxSize = 1e3) {
+  /**
+   * @param maxSize Entries kept before the least recently used is evicted. A capacity of 0 or
+   *   less (or NaN) makes the cache store nothing.
+   */
+  constructor(maxSize = 1e3, options = {}) {
     this.maxSize = maxSize;
     this.cache = /* @__PURE__ */ new Map();
+    this.generation = cacheGeneration;
+    this.onInsert = options.onInsert;
+    this.followsCachingToggle = options.followsCachingToggle ?? false;
+  }
+  /** Drops the entries of a toggle-following cache when caching was turned off since last use. */
+  sync() {
+    if (this.followsCachingToggle && this.generation !== cacheGeneration) {
+      this.cache.clear();
+      this.generation = cacheGeneration;
+    }
+  }
+  get storing() {
+    this.sync();
+    return this.maxSize > 0 && (cachingEnabled || !this.followsCachingToggle);
   }
   get(key) {
+    if (!this.storing) return void 0;
     const value = this.cache.get(key);
     if (value === void 0) return void 0;
     this.cache.delete(key);
@@ -78,11 +269,13 @@ var LRUCache = class {
     this.cache.delete(key);
   }
   set(key, value) {
-    if (this.cache.size >= this.maxSize && !this.cache.has(key)) {
+    if (!this.storing) return this;
+    this.onInsert?.(value);
+    this.cache.delete(key);
+    if (this.cache.size >= this.maxSize) {
       const oldestKey = this.cache.keys().next().value;
       this.cache.delete(oldestKey);
     }
-    this.cache.delete(key);
     this.cache.set(key, value);
     return this;
   }
@@ -90,15 +283,18 @@ var LRUCache = class {
     this.cache.clear();
   }
   get size() {
+    this.sync();
     return this.cache.size;
   }
   has(key) {
-    return this.cache.has(key);
+    return this.storing && this.cache.has(key);
   }
   keys() {
+    this.sync();
     return this.cache.keys();
   }
   values() {
+    this.sync();
     return this.cache.values();
   }
 };
@@ -367,33 +563,14 @@ var _DiceQuery = class _DiceQuery {
     return probabilitySum;
   }
   /**
-   * Returns damage values at specific percentiles.
+   * Returns damage values at specific percentiles: for each p, the smallest damage x with
+   * P(total ≤ x) ≥ p, exact at CDF boundaries (see {@link PMF.quantile}).
    *
    * Example: `query.percentiles([0.25, 0.5, 0.75])` → [8, 12, 18]
    * Use case: "What are my 25th, 50th, and 75th percentile damage values?"
    */
   percentiles(percentileValues) {
-    const sortedDamageValues = this.combined.support();
-    if (sortedDamageValues.length === 0) return percentileValues.map(() => 0);
-    const cumulativeProbabilities = [];
-    let runningProbabilitySum = 0;
-    for (const damageValue of sortedDamageValues) {
-      runningProbabilitySum += this.combined.map.get(damageValue).p;
-      cumulativeProbabilities.push(runningProbabilitySum);
-    }
-    return percentileValues.map((targetPercentile) => {
-      let leftBound = 0;
-      let rightBound = cumulativeProbabilities.length - 1;
-      while (leftBound <= rightBound) {
-        const middleIndex = Math.floor((leftBound + rightBound) / 2);
-        if (cumulativeProbabilities[middleIndex] >= targetPercentile) {
-          rightBound = middleIndex - 1;
-        } else {
-          leftBound = middleIndex + 1;
-        }
-      }
-      return leftBound < sortedDamageValues.length ? sortedDamageValues[leftBound] : sortedDamageValues[sortedDamageValues.length - 1];
-    });
+    return percentileValues.map((p) => this.combined.quantile(p));
   }
   /**
    * Returns the minimum possible damage.
@@ -476,16 +653,14 @@ var _DiceQuery = class _DiceQuery {
    * Note:
    *
    * - You have to pass in an array of labels to avoid double-counting if you are
-   *   using multiple labels. You cannot just add them.
+   *   using multiple labels. You cannot just add them. A label listed twice counts once.
    */
   probAtLeastOne(labels) {
-    if (typeof labels === "string") {
-      labels = [labels];
-    }
+    const distinctLabels = typeof labels === "string" ? [labels] : [...new Set(labels)];
     let productOfNonOccurrence = 1;
     for (let diceIndex = 0; diceIndex < this.singles.length; diceIndex++) {
       let combinedProbability = 0;
-      for (const label of labels) {
+      for (const label of distinctLabels) {
         combinedProbability += this.singleProb(diceIndex, label);
       }
       if (combinedProbability < 0) combinedProbability = 0;
@@ -541,10 +716,11 @@ var _DiceQuery = class _DiceQuery {
    * - "How likely am I to get exactly 2 successes out of 3 attacks?"
    * - "What's the probability that exactly half my attacks succeed?"
    *
-   * Note: For arrays, an attack counts as a "success" if it has any of the specified labels.
-   * This is different from probAtMostK, which counts an attack as a "success" if it has ALL of the specified labels.
+   * Note: For arrays, an attack counts as a "success" if it has any of the specified labels,
+   * as in probAtLeastK and probAtMostK. A negative k has probability 0.
    */
   probExactlyK(labels, k) {
+    if (k < 0) return 0;
     if (typeof labels === "string") {
       const probabilityArray = this.computeBinomialProbabilities(labels, k);
       return probabilityArray[k];
@@ -602,16 +778,24 @@ var _DiceQuery = class _DiceQuery {
    * - "How much damage do I expect from successful attacks?"
    * - "What's the damage contribution from critical hits specifically?"
    * - "How much damage comes from miss effects (like save-for-half spells)?"
+   *
+   * A single whose mass is not 1 is normalized exactly as {@link mean} normalizes it, so the
+   * contributions of labels that cover every outcome add up to `mean()`. A label listed twice
+   * counts once.
    */
   expectedDamageFrom(labels) {
-    const wanted = Array.isArray(labels) ? labels : [labels];
+    const wanted = Array.isArray(labels) ? [...new Set(labels)] : [labels];
     let total = 0;
     for (const single of this.singles) {
+      const mass = single.mass();
+      if (mass <= 0) continue;
+      let contribution = 0;
       for (const [dmg, bin] of single) {
         let p = 0;
         for (const label of wanted) p += bin.count[label] ?? 0;
-        total += dmg * p;
+        contribution += dmg * p;
       }
+      total += Math.abs(mass - 1) <= this._eps ? contribution : contribution / mass;
     }
     return total;
   }
@@ -778,10 +962,15 @@ var _DiceQuery = class _DiceQuery {
     return this.probAtLeastOne(labels);
   }
   /**
-   * Returns the probability of missing (any type of miss).
+   * Returns the probability that at least one attack misses (either kind of miss:
+   * `missNone` or `missDamage`). For a single attack this is its miss chance.
+   *
+   * Example: `query.missChance()` → 0.45
+   * Use case: "What's the chance I miss at least once this turn?"
    *
-   * Example: `query.missChance()` → 0.04
-   * Use case: "What's the chance I miss completely this turn?"
+   * For the chance that every attack misses, use
+   * `probExactlyK(["missNone", "missDamage"], n)` with n attacks, or
+   * `probAtMostK(["hit", "crit"], 0)`.
    */
   missChance() {
     return this.probabilityOf(["missDamage", "missNone"]);
@@ -920,16 +1109,13 @@ var _DiceQuery = class _DiceQuery {
       data: ccdfData
     };
   }
-  /*
-        Statistics snapshot of the query.
-            */
   /** Probability of doing strictly more than threshold damage (default >0). */
   probDamageGreaterThan(threshold = 0) {
     let acc = 0;
     for (const [x, bin] of this.combined.map) if (x > threshold) acc += bin.p;
     return acc;
   }
-  /** All outcome keys actually present (typed & ordered if you pass an order). */
+  /** All outcome keys present in the PMF, ordered by `order` when given. */
   outcomeKeys(order) {
     const found = /* @__PURE__ */ new Set();
     for (const [, bin] of this.combined.map) {
@@ -1097,17 +1283,10 @@ var _DiceQuery = class _DiceQuery {
     const averageDPR = this.mean();
     let damageChance = 0;
     for (const [x, bin] of this.combined.map) if (x > 0) damageChance += bin.p;
-    const { support, data } = this.toCDFSeries(false);
-    const quantile = (p) => {
-      if (support.length === 0) return 0;
-      for (let i = 0; i < support.length; i++)
-        if (data[i] >= p) return support[i];
-      return support[support.length - 1];
-    };
     const percentiles = {
-      p25: quantile(0.25),
-      p50: quantile(0.5),
-      p75: quantile(0.75)
+      p25: this.combined.quantile(0.25),
+      p50: this.combined.quantile(0.5),
+      p75: this.combined.quantile(0.75)
     };
     return { averageDPR, damageChance, percentiles, outcomes: outcomeMap };
   }
@@ -1187,20 +1366,23 @@ var _DiceQuery = class _DiceQuery {
     return new _DiceQuery([this.combined.mapDamage(damageTransformFunction)]);
   }
   /**
-   * Returns a new DiceQuery with damage values scaled by a factor.
-   * Convenient wrapper around mapDamage for multiplicative scaling.
+   * Returns a new DiceQuery with damage values scaled by `factor / denominator`.
+   * Convenient wrapper around mapDamage for multiplicative scaling; see
+   * {@link PMF.scaleDamage} for the rounding rules.
    *
-   * @param factor Scaling factor for damage values
+   * @param factor Scaling factor for damage values (the numerator of a ratio)
    * @param rounding Rounding method: "floor" (default), "round", or "ceil"
+   * @param denominator Divisor; integer `factor` and `denominator` round exactly
    * @returns New DiceQuery with scaled damage values
    *
    * @example
    * const baseAttack = parse("2d6 + 3");
    * const doubled = baseAttack.scaleDamage(2); // Double damage
    * const halfDamage = baseAttack.scaleDamage(0.5, "round"); // Half damage, rounded
+   * const sevenTenths = baseAttack.scaleDamage(7, "floor", 10); // floor(7v/10), exactly
    */
-  scaleDamage(factor, rounding = "floor") {
-    return new _DiceQuery([this.combined.scaleDamage(factor, rounding)]);
+  scaleDamage(factor, rounding = "floor", denominator = 1) {
+    return new _DiceQuery([this.combined.scaleDamage(factor, rounding, denominator)]);
   }
   /**
    * Returns a new DiceQuery combining this query with another via convolution.
@@ -1281,14 +1463,69 @@ _DiceQuery.DEFAULT_OUTCOMES = [
   "missNone"
 ];
 var DiceQuery = _DiceQuery;
-var pmfCache = new LRUCache(1e3);
+
+// src/pmf/pmf.ts
+var sharedPMFCacheOptions = {
+  onInsert: (pmf) => pmf.freeze(),
+  followsCachingToggle: true
+};
+var pmfCache = new LRUCache(1e3, sharedPMFCacheOptions);
+var QUANTILE_RELATIVE_SLACK = 1e-12;
+var FrozenBinMap = class extends Map {
+  constructor(source) {
+    super();
+    for (const [value, bin] of source) super.set(value, bin);
+  }
+  set(value) {
+    throw new TypeError(`Cannot set damage value ${value}: this PMF is frozen (shared through a cache)`);
+  }
+  delete(value) {
+    throw new TypeError(`Cannot delete damage value ${value}: this PMF is frozen (shared through a cache)`);
+  }
+  clear() {
+    throw new TypeError("Cannot clear the map: this PMF is frozen (shared through a cache)");
+  }
+};
 var _PMF = class _PMF {
+  /**
+   * @param map Damage value → bin. Typed read-only: a PMF is immutable once built. A PMF returned
+   *   from the library's caches is frozen: its bins, its map and the `map` property itself reject
+   *   writes (see {@link freeze}).
+   */
   constructor(map = /* @__PURE__ */ new Map(), epsilon = EPS, normalized = false, identifier = `anon#${_PMF.__anonIdCounter++}`, _preservedProvenance = true) {
     this.map = map;
     this.epsilon = epsilon;
     this.normalized = normalized;
     this.identifier = identifier;
     this._preservedProvenance = _preservedProvenance;
+    this._frozen = false;
+  }
+  /**
+   * A PMF cache that freezes every stored PMF and follows `setCachingEnabled`. The library's
+   * own caches are built with this.
+   */
+  static createCache(maxSize) {
+    return new LRUCache(maxSize, sharedPMFCacheOptions);
+  }
+  /**
+   * Freezes this PMF so it can be shared through a cache. Every bin is deep-frozen, including its
+   * `count` and `attr` maps, so writing to one throws a `TypeError`. The map is replaced by a copy
+   * whose `set`/`delete`/`clear` throw a `TypeError` (the map this PMF was built with stays the
+   * caller's), and the `map` property becomes read-only, so assigning it throws too.
+   * Returns this PMF.
+   */
+  freeze() {
+    if (this._frozen) return this;
+    const map = new FrozenBinMap(this.map);
+    for (const bin of map.values()) {
+      Object.freeze(bin.count);
+      if (bin.attr) Object.freeze(bin.attr);
+      Object.freeze(bin);
+    }
+    Object.freeze(map);
+    Object.defineProperty(this, "map", { value: map, writable: false, enumerable: true, configurable: false });
+    this._frozen = true;
+    return this;
   }
   static empty(epsilon = EPS, identifier = "empty") {
     return new _PMF(/* @__PURE__ */ new Map(), epsilon, false, identifier);
@@ -1549,18 +1786,10 @@ var _PMF = class _PMF {
     }
     return acc ?? _PMF.emptyMass();
   }
-  // This is a convenience method for when we use power
-  // TODO: It can be smarter in the future, and we can also add it to query
-  // That way statistics operations on invalid PMFs can throw an error
-  // TODO… how can we detect if manually merging two queries' combined PMFs, as that loses provenance?
-  setPreservedProvenance(preserved) {
-    if (!this._preservedProvenance && preserved) {
-      throw new Error(
-        "Preserved provenance is already set to false, cannot fix that"
-      );
-    }
-    this._preservedProvenance = preserved;
-  }
+  /**
+   * False for a PMF produced by {@link power}, which folds independent attacks into one
+   * distribution and cannot say which attack produced which label.
+   */
   preservedProvenance() {
     return this._preservedProvenance;
   }
@@ -1571,14 +1800,12 @@ var _PMF = class _PMF {
     return `${key}@${eps}|${this.fingerprint()}`;
   }
   /**
-   * Efficiently computes this PMF convolved with itself `n` times.
-   * Uses exponentiation by squaring to reduce total convolutions.
-   * n must be a positive integer.
-   * *
-   * * NOTE: This folds multiple independent attacks into a single PMF.
-   * As a result, The power() method causes a loss of data provenance.
-   * This is ONLY SAFE if you are trying to calculate masses.
-   * If you want to query any atLeast probabilities, you should use the DiceQuery class instead without power().
+   * Convolves this PMF with itself `n` times, by exponentiation by squaring. `n` must be a
+   * positive integer.
+   *
+   * NOTE: this folds `n` independent, identical attacks into one PMF, so it loses data
+   * provenance. It is only safe when computing masses; for `atLeast`-style queries use a
+   * `DiceQuery` instead of `power()`.
    */
   power(n, eps = this.epsilon) {
     if (!Number.isInteger(n) || n <= 0) {
@@ -1587,10 +1814,8 @@ var _PMF = class _PMF {
     if (n === 1) return this;
     const epsilon = eps ?? this.epsilon;
     const key = this.getPowerCacheKey(n, epsilon);
-    {
-      const cached = pmfCache?.get(key);
-      if (cached) return cached;
-    }
+    const cached = pmfCache.get(key);
+    if (cached) return cached;
     let base = this.normalized ? this : this.normalize();
     let result = base;
     let exp = n - 1;
@@ -1603,11 +1828,15 @@ var _PMF = class _PMF {
         base = base.convolve(base, epsilon);
       }
     }
-    result.setPreservedProvenance(false);
-    {
-      pmfCache?.set(key, result);
-    }
-    return result;
+    const folded = new _PMF(
+      result.map,
+      result.epsilon,
+      result.normalized,
+      result.identifier,
+      false
+    );
+    pmfCache.set(key, folded);
+    return folded;
   }
   /*
    * Helper for chaining multiple identical attacks
@@ -1726,8 +1955,11 @@ var _PMF = class _PMF {
     return this._max;
   }
   /**
-   * Returns the expected (mean) damage value.
-   * Cached for performance since this requires iterating through all bins.
+   * Returns the expected (mean) damage value, Σ v·p. Cached.
+   *
+   * On a PMF whose mass is not 1 this is the partial expectation (the slice's contribution to
+   * the whole distribution's mean), not the conditional mean; `DiceQuery.mean()` divides by the
+   * mass instead.
    */
   mean() {
     if (this._mean === void 0) {
@@ -1740,18 +1972,25 @@ var _PMF = class _PMF {
     return this._mean;
   }
   /**
-   * Returns the variance of the damage distribution.
-   * Cached for performance since this requires mean calculation plus iteration.
+   * Returns the variance of the damage distribution. Cached.
+   *
+   * On a PMF whose mass is not 1 (a slice such as {@link filterOutcome}'s output) this is the
+   * variance of the distribution conditioned on the slice, Σ (v − μ)²·p / m with μ = Σ v·p / m
+   * and m = {@link mass}, the same quantity `DiceQuery.variance()` reports for that PMF. Note
+   * that {@link mean} is not conditioned: it stays the partial expectation Σ v·p, so slices add
+   * up. Within 1e-12 of unit mass (or at zero or negative mass) no conditioning is applied.
    */
   variance() {
     if (this._variance === void 0) {
-      const meanValue = this.mean();
+      const mass = this.mass();
+      const conditional = mass > 0 && Math.abs(mass - 1) > EPS;
+      const meanValue = conditional ? this.mean() / mass : this.mean();
       let varianceSum = 0;
       for (const [damageValue, probabilityBin] of this.map) {
         const deviationFromMean = damageValue - meanValue;
         varianceSum += deviationFromMean * deviationFromMean * probabilityBin.p;
       }
-      this._variance = varianceSum;
+      this._variance = conditional ? varianceSum / mass : varianceSum;
     }
     return this._variance;
   }
@@ -1811,11 +2050,9 @@ var _PMF = class _PMF {
     return this.addScaled(other, 1);
   }
   /**
-   * Returns a new PMF with a scaled branch added to this one.
-   * The branch PMF is scaled by the given probability before merging
-   * This will be very useful for conditional effects and for being
-   * able to model "I can probably have this opportunity attack 40% of rounds"
-   * Example: `pmf.addScaled(critBranch, 0.05)` → PMF including 5% crit outcomes
+   * Returns a new PMF with `branch` added to this one, scaled by `probability` before merging —
+   * the primitive for conditional effects. Example: `pmf.addScaled(critBranch, 0.05)` → a PMF
+   * including a 5% crit slice.
    */
   addScaled(branch, probability) {
     if (probability === 0) return this;
@@ -1838,40 +2075,42 @@ var _PMF = class _PMF {
     );
   }
   /**
-   * Redistributes probability mass to model an effect that only occurs with
-   * probability `frequency` — a conditional attack, an on-hit rider, or a
-   * sub-one AoE target fraction.
+   * Bernoulli thinning: the effect this PMF describes happens with probability
+   * `frequency` and otherwise deals nothing — a conditional attack, an on-hit
+   * rider, or a sub-one AoE target fraction. The result is
+   * `frequency · X + (1 − frequency) · δ0`.
    *
-   * Every hit outcome (damage > 0) is scaled by `frequency` — probability mass,
-   * per-label `count`, AND per-label `attr` — and the freed mass is moved into
-   * the miss bin at damage 0, tagged with the canonical `missNone` outcome.
-   * Total probability mass is preserved.
+   * Every bin (negative damage included) keeps `frequency` of its probability
+   * mass, per-label `count` and per-label `attr`; the zero bin keeps its labels
+   * at that share too. The freed mass, `(1 − frequency) · mass()`, is added to
+   * the damage-0 bin under the canonical `missNone` outcome, so the total mass
+   * is unchanged, also for a slice whose mass is not 1.
    *
    * Unlike a bare {@link scaleMass} or {@link mapDamage}, this keeps damage
    * attribution (`attr`) intact, so a frequency-scaled PMF still renders
    * correctly in the damage-attribution charts.
    *
    * `frequency >= 1` (or non-finite) returns this PMF unchanged; `frequency <= 0`
-   * collapses all mass into the miss bin. The miss outcome is assumed to be
-   * encoded at damage value 0.
+   * leaves only the damage-0 bin, holding all of the mass as `missNone`.
    *
    * @param frequency Probability in [0, 1] that the effect occurs.
    */
   applyHitFrequency(frequency) {
     if (!Number.isFinite(frequency) || frequency >= 1) return this;
     const freq = Math.max(0, frequency);
-    const pMiss = this.pAt(0);
-    const pHit = 1 - pMiss;
-    const newMissMass = pMiss + (1 - freq) * pHit;
+    const freedMass = (1 - freq) * this.mass();
     const newMap = /* @__PURE__ */ new Map();
-    newMap.set(0, {
-      p: newMissMass,
-      count: { [MISS_NONE_OUTCOME]: newMissMass },
-      attr: {}
-    });
-    for (const [damage, bin] of this.map) {
-      if (damage <= 0) continue;
-      newMap.set(damage, _PMF.scaleBin(bin, freq));
+    if (freq > 0) {
+      for (const [damage, bin] of this.map) {
+        newMap.set(damage, _PMF.scaleBin(bin, freq));
+      }
+    }
+    if (freedMass > 0) {
+      _PMF.mergeInto(newMap, 0, {
+        p: freedMass,
+        count: { [MISS_NONE_OUTCOME]: freedMass },
+        attr: {}
+      });
     }
     return new _PMF(
       newMap,
@@ -1880,6 +2119,71 @@ var _PMF = class _PMF {
       `freq(${this.identifier},${freq})`
     );
   }
+  /**
+   * Splits this PMF into two complementary PMFs by an arbitrary per-damage-value factor in
+   * `[0, 1]` — bin `d`'s mass, `count`, and `attr` split `factor(d)` / `1 - factor(d)` between the
+   * two results (via the same proportional scaling {@link applyHitFrequency} uses, `scaleBin`), so
+   * `a.add(b)` recovers this PMF exactly and both halves stay chart-attributable. Unlike
+   * {@link applyHitFrequency}, mass is NOT redistributed to a miss bin at 0 — each bin stays at its
+   * own damage value in whichever half it lands in. `factor` outside `[0, 1]` is clamped.
+   *
+   * Built for `dice-match` trigger slicing: splitting a hit/crit sub-PMF into "matched" and
+   * "did not match" halves by the exact per-damage-value match probability.
+   */
+  splitByFactor(factor) {
+    const a = /* @__PURE__ */ new Map();
+    const b = /* @__PURE__ */ new Map();
+    for (const [damage, bin] of this.map) {
+      const f = Math.min(1, Math.max(0, factor(damage)));
+      if (f > 0) a.set(damage, _PMF.scaleBin(bin, f));
+      if (f < 1) b.set(damage, _PMF.scaleBin(bin, 1 - f));
+    }
+    return [
+      new _PMF(a, this.epsilon, false, `split+(${this.identifier})`),
+      new _PMF(b, this.epsilon, false, `split-(${this.identifier})`)
+    ];
+  }
+  /**
+   * Max of two i.i.d. copies of this PMF's distribution: normalize, square
+   * the CDF, then restore the original mass. The engine's damage-reroll
+   * substitution (`onFirstHit(keepBestDamage())`) applies this to a landing
+   * attack's base payload slice — "roll it again, keep the better total".
+   *
+   * PRESERVES outcome labels and attribution. A max, unlike a sum, is
+   * literally one of the two draws: the value that wins was drawn from this
+   * same distribution, so its `count`/`attr` composition is unchanged in
+   * *proportion* — only that bin's total mass is recomputed (via the
+   * squared-CDF step) and every label is rescaled by the same factor. This
+   * is why {@link power}'s documented provenance loss does not apply here:
+   * for a sum, one output value arises from many `(x1, x2)` pairs with
+   * different attribution mixes, so provenance is genuinely ambiguous; for a
+   * max, there is exactly one realized draw per bin. A naive rebuild through
+   * {@link fromMap} would silently discard both `count` and `attr`.
+   *
+   * Works on a non-unit-mass slice (e.g. {@link filterOutcome}'s output):
+   * the CDF is squared on the NORMALIZED distribution, then the result is
+   * rescaled back to this PMF's original total mass, not to 1.
+   */
+  maxOfTwo() {
+    const totalMass = this.mass();
+    if (totalMass <= 0) return this;
+    const resultMap = /* @__PURE__ */ new Map();
+    let cdf = 0;
+    for (const damage of this.support()) {
+      const bin = this.map.get(damage);
+      const normalizedP = bin.p / totalMass;
+      if (normalizedP <= 0) continue;
+      const prevCdf = cdf;
+      cdf += normalizedP;
+      resultMap.set(damage, _PMF.scaleBin(bin, cdf + prevCdf));
+    }
+    return new _PMF(
+      resultMap,
+      this.epsilon,
+      this.normalized,
+      `maxOfTwo(${this.identifier})`
+    );
+  }
   scaleMass(factor) {
     if (factor === 1) return this;
     const scaledMap = /* @__PURE__ */ new Map();
@@ -1910,9 +2214,37 @@ var _PMF = class _PMF {
       `map(${this.identifier})`
     );
   }
-  scaleDamage(factor, rounding = "floor") {
-    const roundFunction = rounding === "round" ? Math.round : rounding === "ceil" ? Math.ceil : Math.floor;
-    return this.mapDamage((damageValue) => roundFunction(damageValue * factor));
+  /**
+   * Multiplies every damage value by `factor / denominator` and rounds: `floor`
+   * (toward −∞, the default), `ceil` (toward +∞) or `round` (to nearest, halves
+   * toward +∞). Values that land on the same result merge, labels included.
+   *
+   * With an integer `factor` and `denominator` the rounding is exact: `v·factor`
+   * is an exact integer, and one division of two integers below 2^53 lands on
+   * the correct side of every integer. Pass a ratio that way, e.g.
+   * `scaleDamage(9, "ceil", 7)`; `scaleDamage(9 / 7, "ceil")` rounds the factor
+   * to a double first, so 21·(9/7) = 27.000000000000004 would round up to 28.
+   */
+  scaleDamage(factor, rounding = "floor", denominator = 1) {
+    if (!Number.isFinite(factor)) {
+      throw new RangeError(`scaleDamage() factor must be finite, got ${factor}`);
+    }
+    if (!Number.isFinite(denominator) || denominator === 0) {
+      throw new RangeError(`scaleDamage() denominator must be finite and non-zero, got ${denominator}`);
+    }
+    const exact = Number.isInteger(factor) && Number.isInteger(denominator);
+    return this.mapDamage((damageValue) => {
+      if (exact && Number.isInteger(damageValue)) {
+        const numerator = damageValue * factor;
+        if (rounding === "round") {
+          return Math.floor((2 * numerator + denominator) / (2 * denominator));
+        }
+        const quotient = numerator / denominator;
+        return rounding === "ceil" ? Math.ceil(quotient) : Math.floor(quotient);
+      }
+      const scaled = damageValue * factor / denominator;
+      return rounding === "round" ? Math.round(scaled) : rounding === "ceil" ? Math.ceil(scaled) : Math.floor(scaled);
+    });
   }
   getPMFCombineCacheKey(p1, p2, eps, raw) {
     const [id1, id2] = [p1.identifier, p2.identifier].sort();
@@ -1928,16 +2260,16 @@ var _PMF = class _PMF {
    * 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 identically regardless of Map insertion order. Label keys are JSON-encoded, so a
+   * label containing the separators cannot make two different bins read the same.
    */
   fingerprint() {
     if (this._fingerprint === void 0) {
+      const labels = (m) => m === void 0 ? "" : Object.keys(m).sort().map((k) => `${JSON.stringify(k)}:${m[k]}`).join(",");
       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}}`);
+        parts.push(`${damageValue}:${bin.p}[${labels(bin.count)}]{${labels(bin.attr)}}`);
       }
       this._fingerprint = `${this.normalized ? 1 : 0}|${parts.join(";")}`;
     }
@@ -1950,15 +2282,21 @@ var _PMF = class _PMF {
     const B0 = norm(other);
     const [A, B] = A0.identifier <= B0.identifier ? [A0, B0] : [B0, A0];
     const cacheKey = this.getPMFCombineCacheKey(A, B, epsilon, raw);
-    const cached = pmfCache?.get(cacheKey);
+    const cached = pmfCache.get(cacheKey);
     if (cached) return cached;
+    const labelEntries = (m) => m === void 0 ? void 0 : Object.entries(m);
+    const bEntries = [...B.map].map(([bVal, bBin]) => ({
+      bVal,
+      bp: bBin.p,
+      count: labelEntries(bBin.count),
+      attr: labelEntries(bBin.attr)
+    }));
     const combinedMap = /* @__PURE__ */ new Map();
     for (const [aVal, aBin] of A.map) {
       const ap = aBin.p;
-      const aCount = aBin.count;
-      const aAttr = aBin.attr;
-      for (const [bVal, bBin] of B.map) {
-        const bp = bBin.p;
+      const aCount = labelEntries(aBin.count);
+      const aAttr = labelEntries(aBin.attr);
+      for (const { bVal, bp, count: bCount, attr: bAttr } of bEntries) {
         const dmg = aVal + bVal;
         let dest = combinedMap.get(dmg);
         if (dest === void 0) {
@@ -1967,20 +2305,16 @@ var _PMF = class _PMF {
         }
         dest.p += ap * bp;
         const dc = dest.count;
-        for (const k in aCount) dc[k] = (dc[k] || 0) + aCount[k] * bp;
-        for (const k in bBin.count)
-          dc[k] = (dc[k] || 0) + bBin.count[k] * ap;
-        if (aAttr || bBin.attr) {
+        for (const [k, v] of aCount) dc[k] = (dc[k] || 0) + v * bp;
+        for (const [k, v] of bCount) dc[k] = (dc[k] || 0) + v * ap;
+        if (aAttr || bAttr) {
           let da = dest.attr;
           if (da === void 0) {
             da = {};
             dest.attr = da;
           }
-          if (aAttr)
-            for (const k in aAttr) da[k] = (da[k] || 0) + aAttr[k] * bp;
-          if (bBin.attr)
-            for (const k in bBin.attr)
-              da[k] = (da[k] || 0) + bBin.attr[k] * ap;
+          if (aAttr) for (const [k, v] of aAttr) da[k] = (da[k] || 0) + v * bp;
+          if (bAttr) for (const [k, v] of bAttr) da[k] = (da[k] || 0) + v * ap;
         }
       }
     }
@@ -1997,10 +2331,10 @@ var _PMF = class _PMF {
     }
     if (!raw && mGot !== 0 && Math.abs(result.mass() - 1) > epsilon)
       result = result.normalize();
-    pmfCache?.set(cacheKey, result);
+    pmfCache.set(cacheKey, result);
     return result;
   }
-  // 3) Nice wrapper so you can call pmf.combineRaw(other)
+  // Convolve without renormalizing (raw = true), for callers that combine raw counts.
   combineRaw(other, eps) {
     return this.convolve(other, eps, true);
   }
@@ -2168,18 +2502,61 @@ var _PMF = class _PMF {
     for (const [val, bin] of this.map) if (val <= x) acc += bin.p;
     return acc;
   }
-  /** Quantile / inverse CDF for p in [0,1]. Returns smallest x with CDF ≥ p. */
+  /**
+   * Quantile / inverse CDF: the smallest support value x with P(X ≤ x) ≥ p·mass().
+   * `p <= 0` gives the smallest support value; `p >= 1` or NaN gives the largest.
+   *
+   * A float running sum can land an ulp short of a CDF that is exactly p (a d20's CDF(10) sums
+   * to 0.49999999999999994), so the comparison allows a relative slack of a few ulps per bin.
+   * Below the median it compares the CDF summed from the low end; above it, the mass strictly
+   * above x summed from the high end. A sum of non-negative terms is accurate relative to its
+   * own size, so the tail that decides the answer is never swamped by the rest of the mass.
+   */
   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 / totalMass >= p) return x;
+    const { values, below, above } = this.cumulative();
+    const n = values.length;
+    if (n === 0) return 0;
+    const total = below[n - 1];
+    if (!(total > 0)) return 0;
+    if (p <= 0) return values[0];
+    if (p >= 1) return values[n - 1];
+    const slack = Math.max(QUANTILE_RELATIVE_SLACK, 4 * n * Number.EPSILON);
+    const lowTarget = p * total * (1 - slack);
+    const highTarget = (1 - p) * total * (1 + slack);
+    const lowSide = p <= 0.5;
+    let lo = 0;
+    let hi = n;
+    while (lo < hi) {
+      const mid = lo + hi >>> 1;
+      const reached = lowSide ? below[mid] >= lowTarget : above[mid] <= highTarget;
+      if (reached) hi = mid;
+      else lo = mid + 1;
+    }
+    return values[Math.min(lo, n - 1)];
+  }
+  /**
+   * Sorted support with `below[i]` = Σ p over values ≤ values[i], summed from the low end,
+   * and `above[i]` = Σ p over values > values[i], summed from the high end. Cached.
+   */
+  cumulative() {
+    if (this._cumulative === void 0) {
+      const values = this.support();
+      const n = values.length;
+      const below = new Array(n);
+      const above = new Array(n);
+      let sum = 0;
+      for (let i = 0; i < n; i++) {
+        sum += this.map.get(values[i]).p;
+        below[i] = sum;
+      }
+      sum = 0;
+      for (let i = n - 1; i >= 0; i--) {
+        above[i] = sum;
+        sum += this.map.get(values[i]).p;
+      }
+      this._cumulative = { values, below, above };
     }
-    return s[s.length - 1];
+    return this._cumulative;
   }
   /** Get outcome probability at specific damage value. */
   outcomeAt(damage, outcome) {
@@ -2499,35 +2876,33 @@ var _PMF = class _PMF {
     const pNone = 1 - pSpecificSuccess - pGeneralSuccess;
     return { pSpecificSuccess, pGeneralSuccess, pNone, pAny };
   }
+  /**
+   * Maps every damage value through `f`, then optionally rounds it (`rounding`, default
+   * `"none"`). Values that land on the same result merge their probability and, unless
+   * `preserveCounts` is false, their per-label `count`. Damage attribution (`attr`) is dropped,
+   * because it is tied to the old values. Nothing is pruned and the mass is unchanged.
+   *
+   * @param eps Epsilon carried by the result.
+   * @throws Error when a mapped value is not a finite integer.
+   */
   mapValues(f, eps = EPS, opts) {
     const rounding = opts?.rounding ?? "none";
     const preserveCounts = opts?.preserveCounts ?? true;
     const round = (x) => rounding === "floor" ? Math.floor(x) : rounding === "ceil" ? Math.ceil(x) : rounding === "round" ? Math.round(x) : x;
-    const probs = /* @__PURE__ */ new Map();
-    const counts = /* @__PURE__ */ new Map();
+    const merged = /* @__PURE__ */ new Map();
     for (const [v, bin] of this) {
-      if (Math.abs(bin.p) < eps) continue;
+      if (bin.p === 0) continue;
       const u = round(f(v));
-      probs.set(u, (probs.get(u) ?? 0) + bin.p);
-      if (preserveCounts) {
-        const src = bin.count;
-        if (src) {
-          const dest = counts.get(u) ?? {};
-          for (const k in src) {
-            dest[k] = (dest[k] ?? 0) + src[k];
-          }
-          counts.set(u, dest);
-        }
+      if (!Number.isInteger(u)) {
+        throw new Error(`mapValues: ${v} maps to ${u}, not a finite integer`);
       }
+      _PMF.mergeInto(merged, u, {
+        p: bin.p,
+        count: preserveCounts ? bin.count : {}
+      });
     }
-    const internal = /* @__PURE__ */ new Map();
-    for (const [u, p] of probs) {
-      internal.set(u, { p, count: counts.get(u) ?? {} });
-    }
-    return _PMF.fromMap(
-      new Map(Array.from(internal, ([u, b]) => [u, b.p])),
-      eps
-    );
+    const sorted = new Map([...merged.entries()].sort((a, b) => a[0] - b[0]));
+    return new _PMF(sorted, eps, this.normalized, `mapValues(${this.identifier})`);
   }
   static fromMap(m, eps = EPS, { requireIntegerValues = true } = {}) {
     const filtered = [];
@@ -2624,7 +2999,7 @@ var Dice = class _Dice {
     if (totalCount === 0) return 0;
     return expectedDamage / totalCount;
   }
-  // TODO this can be private later if we change how testing works
+  // Public (no modifier) for direct test access.
   calculateHitDistribution() {
     const hitValues = {};
     const subtractedOutcomes = [
@@ -2645,7 +3020,7 @@ var Dice = class _Dice {
         }
       }
       if (numFace === 0) {
-        hitCount = 0;
+        hitCount = this.outcomeData.hit?.[0] ?? 0;
       }
       if (hitCount < 0) {
         hitCount = 0;
@@ -2687,18 +3062,6 @@ var Dice = class _Dice {
     }
     return result;
   }
-  removeFaces(facesToRemove) {
-    const result = new _Dice();
-    for (const [key, value] of Object.entries(this.faces)) {
-      const numKey = Number(key);
-      if (!facesToRemove.includes(numKey)) {
-        result.faces[numKey] = value;
-      }
-    }
-    result.privateData = { ...this.privateData };
-    result.outcomeData = { ...this.outcomeData };
-    return result;
-  }
   // PUBLIC FUNCTIONS
   getFaceEntries() {
     return Object.entries(this.faces).map(([k, v]) => [Number(k), v]);
@@ -2744,13 +3107,20 @@ var Dice = class _Dice {
     const current = this.faces[face] || 0;
     this.faces[face] = current + count;
   }
+  /** Scales every face count, and every outcome's counts with it, so each outcome keeps its share. */
   normalize(scalar) {
     const result = new _Dice();
     for (const [face, count] of Object.entries(this.faces)) {
       result.faces[Number(face)] = count * scalar;
     }
     result.privateData = { ...this.privateData };
-    result.outcomeData = { ...this.outcomeData };
+    for (const [key, distribution] of Object.entries(this.outcomeData)) {
+      const scaled = {};
+      for (const [face, count] of Object.entries(distribution)) {
+        scaled[Number(face)] = count * scalar;
+      }
+      result.outcomeData[key] = scaled;
+    }
     return result;
   }
   // OPERATIONS
@@ -2788,10 +3158,18 @@ var Dice = class _Dice {
     return this.binaryOp(other, (a, b) => a / b);
   }
   divideRoundUp(other) {
-    return this.binaryOp(other, (a, b) => Math.ceil(a / b));
+    this.assertNonZeroDivisor(other);
+    return this.binaryOp(other, (a, b) => b === 0 ? 0 : Math.ceil(a / b));
   }
   divideRoundDown(other) {
-    return this.binaryOp(other, (a, b) => Math.floor(a / b));
+    this.assertNonZeroDivisor(other);
+    return this.binaryOp(other, (a, b) => b === 0 ? 0 : Math.floor(a / b));
+  }
+  /** A divisor that can be 0 has no quotient there. A 0 face with no weight is never rolled, so it passes. */
+  assertNonZeroDivisor(other) {
+    if (typeof other === "number" ? other === 0 : other.get(0) > 0) {
+      throw new DiceParseError("Division by zero: the divisor can be 0");
+    }
   }
   and(other) {
     return this.binaryOp(other, (a, b) => a && b ? 1 : 0);
@@ -2827,18 +3205,19 @@ var Dice = class _Dice {
     result.outcomeData = { ...this.outcomeData };
     return result;
   }
+  /**
+   * Roll once and, on a result in `toReroll`'s faces, roll again and keep the second roll. Each
+   * result keeps its own weight: with T the total count and c_R the count on the rerolled faces,
+   * face v's new count is c_v·(T·[v∉R] + c_R), i.e. p′(v) = p(v)·[v∉R] + P(R)·p(v).
+   */
   reroll(toReroll) {
-    const rerollDice = typeof toReroll === "number" ? _Dice.scalar(toReroll) : toReroll;
-    const rerollKeys = rerollDice.keys();
-    const rerollSet = new Set(rerollKeys);
-    const removed = this.removeFaces(rerollKeys);
-    let result = new _Dice();
-    for (const face of this.keys()) {
-      const wasRerolled = rerollSet.has(face);
-      result = result.combine(removed);
-      if (wasRerolled) {
-        result = result.combine(this);
-      }
+    const rerolled = new Set(typeof toReroll === "number" ? [toReroll] : toReroll.keys());
+    const total = this.total();
+    let rerolledCount = 0;
+    for (const [face, count] of this.getFaceEntries()) if (rerolled.has(face)) rerolledCount += count;
+    const result = new _Dice();
+    for (const [face, count] of this.getFaceEntries()) {
+      result.increment(face, count * ((rerolled.has(face) ? 0 : total) + rerolledCount));
     }
     return result;
   }
@@ -2901,6 +3280,7 @@ var Dice = class _Dice {
     const critDistro = this.getOutcomeDistribution("crit") || {};
     const missDistro = this.getOutcomeDistribution("missDamage") || {};
     const saveDistro = this.getOutcomeDistribution("saveHalf") || {};
+    const saveFailDistro = this.getOutcomeDistribution("saveFail") || {};
     const pcDistro = this.getOutcomeDistribution("pc") || {};
     const isSaveHalf = Object.keys(saveDistro).length > 0;
     const isDCCheck = this.privateData.isDCCheck === true;
@@ -2944,15 +3324,15 @@ var Dice = class _Dice {
       if (saveDistro[face]) {
         const c = clampNonNeg(saveDistro[face] / total);
         if (c > 0) {
-          if (isSaveHalf) {
-            count.saveHalf = c;
-            attr.saveHalf = clampNonNeg(face * saveDistro[face] / total);
-          } else {
-            count.saveFail = (count.saveFail ?? 0) + c;
-            attr.saveFail = clampNonNeg(
-              (attr.saveFail ?? 0) + face * saveDistro[face] / total
-            );
-          }
+          count.saveHalf = c;
+          attr.saveHalf = clampNonNeg(face * saveDistro[face] / total);
+        }
+      }
+      if (saveFailDistro[face]) {
+        const c = clampNonNeg(saveFailDistro[face] / total);
+        if (c > 0) {
+          count.saveFail = (count.saveFail ?? 0) + c;
+          attr.saveFail = clampNonNeg((attr.saveFail ?? 0) + face * saveFailDistro[face] / total);
         }
       }
       if (pcDistro[face]) {
@@ -2962,8 +3342,8 @@ var Dice = class _Dice {
           attr.pc = clampNonNeg(face * pcDistro[face] / total);
         }
       }
-      if (!isSaveHalf && !isDCCheck) {
-        const distroCountRaw = (hitDistro[face] || 0) + (critDistro[face] || 0) + (missDistro[face] || 0) + (saveDistro[face] || 0) + (pcDistro[face] || 0);
+      if (!isDCCheck) {
+        const distroCountRaw = (hitDistro[face] || 0) + (critDistro[face] || 0) + (missDistro[face] || 0) + (saveDistro[face] || 0) + (saveFailDistro[face] || 0) + (pcDistro[face] || 0);
         const unaccountedCount = clampNonNeg(faceCount - distroCountRaw);
         if (unaccountedCount > 0) {
           const frac = clampNonNeg(unaccountedCount / total);
@@ -2983,25 +3363,238 @@ var Dice = class _Dice {
   }
 };
 
+// src/parser/scaleDice.ts
+var isDigitOrN = (c) => c !== void 0 && (c >= "0" && c <= "9" || c === "n");
+var isPerDieOp = (op) => op === "reroll" || op === ">" || op === "<" || op === "!";
+var UndoubleableExpressionError = class extends Error {
+};
+var AmbiguousCritDoublingError = class extends Error {
+};
+var DiceTermReader = class {
+  constructor(s, expression) {
+    this.s = s;
+    this.expression = expression;
+    this.pos = 0;
+  }
+  read() {
+    const expr = this.expr();
+    if (this.pos !== this.s.length) this.fail(`unexpected '${this.s[this.pos]}'`);
+    return expr;
+  }
+  fail(reason) {
+    throw new UndoubleableExpressionError(`Cannot double the dice of "${this.expression}": ${reason}.`);
+  }
+  expr() {
+    const first = this.chain();
+    const rest = [];
+    for (let op = this.operation(); op !== void 0; op = this.operation()) {
+      if (op === "ac") {
+        this.fail("it contains an attack check (a d20 roll against an AC), so it is not a damage expression");
+      }
+      if (op === "dc") {
+        this.fail("it contains a saving throw check (a d20 roll against a DC), so it is not a damage expression");
+      }
+      const arg = op === "!" ? void 0 : this.chain();
+      const c = this.s[this.pos];
+      if (c === "x" || c === "c" || c === "s" || c === "m" || this.s.startsWith("pc", this.pos)) {
+        this.fail("it contains a check-outcome clause (crit/save/pc/miss), so it is not a damage expression");
+      }
+      rest.push({ op, arg, end: this.pos });
+    }
+    return { first, rest };
+  }
+  chain() {
+    const start = this.pos;
+    const atoms = [];
+    for (let atom = this.atom(); atom !== void 0; atom = this.atom()) atoms.push(atom);
+    return { start, atoms };
+  }
+  atom() {
+    const start = this.pos;
+    const c = this.s[start];
+    if (c === "(") {
+      this.pos++;
+      const expr = this.expr();
+      if (this.s[this.pos] !== ")") this.fail("unbalanced parentheses");
+      this.pos++;
+      return { kind: "group", start, end: this.pos, expr };
+    }
+    if (c === "h" && this.s[start + 1] === "d" && isDigitOrN(this.s[start + 2])) {
+      this.pos += 2;
+      this.number();
+      return { kind: "die", start, end: this.pos };
+    }
+    if (c === "d" && isDigitOrN(this.s[start + 1])) {
+      this.pos += 1;
+      this.number();
+      return { kind: "die", start, end: this.pos };
+    }
+    if (c === "k") {
+      const mode = this.s[start + 1];
+      if (mode !== "h" && mode !== "l") this.fail("'k' must be followed by 'h' or 'l'");
+      this.pos += 2;
+      const kept = this.number();
+      const inner = this.atom();
+      if (inner === void 0) this.fail("a keep needs dice after it");
+      return { kind: "keep", start, end: this.pos, inner, mode, kept };
+    }
+    if (isDigitOrN(c)) {
+      const value = this.number();
+      return { kind: "number", start, end: this.pos, value };
+    }
+    return void 0;
+  }
+  number() {
+    let digits = "";
+    while (isDigitOrN(this.s[this.pos])) {
+      const ch = this.s[this.pos++];
+      digits += ch === "n" ? "0" : ch;
+    }
+    if (digits.length === 0) this.fail(`expected a number at '${this.s[this.pos]}'`);
+    return parseInt(digits, 10);
+  }
+  operation() {
+    const rest = this.s.slice(this.pos);
+    const op = ["reroll", "**", "//", "~+", "ac", "dc", "!", ">", "<", "+", "-", "&", "*", "/", "="].find(
+      (token) => rest.startsWith(token)
+    );
+    if (op !== void 0) this.pos += op.length;
+    return op;
+  }
+};
+function atomHasDice(atom) {
+  switch (atom.kind) {
+    case "die":
+      return true;
+    case "number":
+      return false;
+    case "keep":
+      return atomHasDice(atom.inner);
+    case "group":
+      return chainHasDice(atom.expr.first) || atom.expr.rest.some(({ op, arg }) => op !== "reroll" && arg !== void 0 && chainHasDice(arg));
+  }
+}
+var chainHasDice = (chain) => chain.atoms.some(atomHasDice);
+var isSingleDieAtom = (atom) => atom.kind === "die" || atom.kind === "group" && isSingleDieExpr(atom.expr, atom.expr.rest.length);
+function isSingleDieExpr(expr, opCount) {
+  const operands = [expr.first];
+  for (const { op, arg } of expr.rest.slice(0, opCount)) {
+    if (!isPerDieOp(op)) return false;
+    if (op !== "reroll" && arg !== void 0) operands.push(arg);
+  }
+  let dice = 0;
+  for (const chain of operands) {
+    if (chain.atoms.length === 1 && isSingleDieAtom(chain.atoms[0])) dice++;
+    else if (chainHasDice(chain)) return false;
+  }
+  return dice === 1;
+}
+function scaleParsedDice(expression, scale) {
+  let cleaned = "";
+  const original = [];
+  for (let i = 0; i < expression.length; i++) {
+    if (expression[i] === " ") continue;
+    cleaned += expression[i].toLowerCase();
+    original.push(i);
+  }
+  const root = new DiceTermReader(cleaned, expression).read();
+  const edits = [];
+  const span = (start, end) => ({ from: original[start], to: original[end - 1] + 1 });
+  const wrap = (start, end, open) => {
+    const { from, to } = span(start, end);
+    edits.push({ from, to: from, text: open }, { from: to, to, text: ")" });
+  };
+  const source = (start, end) => {
+    const { from, to } = span(start, end);
+    return expression.slice(from, to);
+  };
+  const ambiguous = [];
+  const keepReading = 'has no single doubled meaning (only keep-highest-of-1, "roll it N times, keep the best", doubles its dice inside each trial)';
+  const noteKeep = (keep, trials) => {
+    if (keep.mode === "h" && keep.kept === 1 || !atomHasDice(keep.inner)) return;
+    ambiguous.push(`the keep \`${source(trials?.kind === "number" ? trials.start : keep.start, keep.inner.start)}\` ${keepReading}`);
+  };
+  const scaleKept = (inner) => {
+    if (isSingleDieAtom(inner)) wrap(inner.start, inner.end, `(${scale}`);
+    else if (inner.kind === "group") scaleExpr(inner.expr);
+    else if (inner.kind === "keep") {
+      noteKeep(inner);
+      scaleKept(inner.inner);
+    }
+  };
+  const scaleChain = (chain) => {
+    const { atoms } = chain;
+    if (atoms.length === 0) return;
+    const last = atoms[atoms.length - 1];
+    const counts = atoms.slice(0, -1);
+    if (counts.some(atomHasDice)) {
+      throw new UndoubleableExpressionError(
+        `Cannot double the dice of "${expression}": a dice-valued repeat count (like d4d6) has no single dice term to double.`
+      );
+    }
+    if (last.kind === "keep") {
+      noteKeep(last, counts[counts.length - 1]);
+      scaleKept(last.inner);
+    } else if (isSingleDieAtom(last)) {
+      const count = counts[counts.length - 1];
+      if (count?.kind === "number") {
+        edits.push({ ...span(count.start, count.end), text: String(count.value * scale) });
+      } else {
+        const at = original[last.start];
+        edits.push({ from: at, to: at, text: String(scale) });
+      }
+    } else if (last.kind === "group") {
+      scaleExpr(last.expr);
+    }
+  };
+  function scaleExpr(expr) {
+    let unitOps = 0;
+    for (let i = 1; i <= expr.rest.length && isPerDieOp(expr.rest[i - 1].op); i++) {
+      if (isSingleDieExpr(expr, i)) unitOps = i;
+    }
+    if (unitOps > 0) wrap(expr.first.start, expr.rest[unitOps - 1].end, `${scale}(`);
+    else scaleChain(expr.first);
+    let leftHasDice = unitOps > 0 || chainHasDice(expr.first);
+    for (const { op, arg, end } of expr.rest.slice(unitOps)) {
+      if (op === "reroll" || arg === void 0) continue;
+      const argHasDice = chainHasDice(arg);
+      if (op === "<" && leftHasDice && argHasDice) {
+        ambiguous.push(`the lower of two dice terms \`${source(expr.first.start, end)}\` ${keepReading}`);
+      }
+      if (op === "&" && (leftHasDice || argHasDice)) {
+        ambiguous.push(
+          `the mix \`${source(expr.first.start, end)}\` has no single doubled meaning (an \`&\` weights each side by its count of outcomes, so doubling a side's dice also changes its share of the mix)`
+        );
+      }
+      leftHasDice || (leftHasDice = argHasDice);
+      scaleChain(arg);
+    }
+  }
+  scaleExpr(root);
+  if (ambiguous.length > 0) {
+    throw new AmbiguousCritDoublingError(
+      `Cannot double the dice of "${expression}" on a crit: ${ambiguous[0]}. Give the crit explicitly: onCrit(...) on an attack, critDamage on a rider, or a crit (...) clause.`
+    );
+  }
+  let result = expression;
+  for (const { from, to, text } of edits.sort((a, b) => b.from - a.from)) {
+    result = result.slice(0, from) + text + result.slice(to);
+  }
+  return result;
+}
+
 // src/parser/parser.ts
 var MAX_DIE_SIDES = 1e6;
 var MAX_DICE_COUNT = 1e4;
-var MAX_KEEP_OUTCOMES = 1e6;
-var parseCache = new LRUCache(1e3);
-var cachingEnabled = true;
-function setCachingEnabled(enabled) {
-  cachingEnabled = enabled;
-  if (!enabled) clearParserCache();
-}
-function getCachingEnabled() {
-  return cachingEnabled;
-}
+var MAX_KEEP_WORK = 1e8;
+var MAX_EXACT_COUNT = Number.MAX_SAFE_INTEGER;
+var parseCache = PMF.createCache(1e3);
 function clearParserCache() {
   parseCache.clear();
 }
 function parse(expression, n = 0) {
   const cleaned = expression.replace(/ /g, "").toLowerCase();
-  if (cachingEnabled) {
+  if (getCachingEnabled()) {
     const cacheKey = `${cleaned}:${n}`;
     const cached = parseCache.get(cacheKey);
     if (cached) return cached;
@@ -3024,8 +3617,21 @@ function parse(expression, n = 0) {
       { expression }
     );
   }
+  const total = result.total();
+  if (total === 0) {
+    throw new DiceParseError(
+      `Cannot parse dice expression [${expression}]: it has no outcomes (a d0 has no faces; it is only a reroll set, as in \`reroll d0\`)`,
+      { expression }
+    );
+  }
+  if (!Number.isFinite(total)) {
+    throw new DiceParseError(
+      `Cannot parse dice expression [${expression}]: its outcome counts overflow (too many dice combined to count exactly)`,
+      { expression }
+    );
+  }
   const resultPMF = result.toPMF(-1);
-  if (cachingEnabled) {
+  if (getCachingEnabled()) {
     const cacheKey = `${cleaned}:${n}`;
     parseCache.set(cacheKey, resultPMF);
   }
@@ -3044,61 +3650,72 @@ function subtractCounts(a, b) {
   for (const [key, value] of b.getFaceEntries()) result.increment(key, -value);
   return result;
 }
-function parseExpression(arr, n) {
-  const result = (() => {
-    const res = parseArgument(arr, n);
-    return typeof res === "number" ? Dice.scalar(res) : res;
-  })();
-  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);
+var HIT_ONLY_OPS = /* @__PURE__ */ new Set([
+  Dice.prototype.addNonZero,
+  Dice.prototype.conditionalApply,
+  Dice.prototype.multiply,
+  Dice.prototype.divideRoundUp,
+  Dice.prototype.divideRoundDown
+]);
+var GATE_OPS = /* @__PURE__ */ new Set([Dice.prototype.ac, Dice.prototype.dc]);
+function lastGateAt(arr) {
+  let depth = 0;
+  let at;
+  for (let i = 0; i < arr.length - 1; i++) {
+    const c = arr[i];
+    if (c === "(") depth++;
+    else if (c === ")") {
+      if (depth === 0) break;
+      depth--;
+    } else if (depth === 0 && (c === "a" || c === "d") && arr[i + 1] === "c") {
+      at = arr.length - i;
+    }
+  }
+  return at;
+}
+function parseExpression(arr, n, inCheck = false) {
+  const gate = lastGateAt(arr);
+  const buildsCheck = () => inCheck || gate !== void 0 && arr.length > gate;
+  const readOperation = () => {
+    const checkTerm = buildsCheck();
+    const parsed = parseOperation(arr);
+    return parsed === Dice.prototype.addNonZero && checkTerm ? Dice.prototype.add : parsed;
+  };
+  const first = parseArgument(arr, n, buildsCheck());
+  let finalResult = typeof first === "number" ? Dice.scalar(first) : first;
+  if (typeof first === "number") finalResult.privateData.noDie = true;
+  let opText = finalResult.privateData.implicitCrit ? arr.join("") : void 0;
+  let op = readOperation();
   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;
-      }
-    }
+    const pending = op === Dice.prototype.conditionalApply && finalResult.privateData.isACCheck ? arr.join("") : void 0;
+    const arg = !op.unary ? parseArgument(arr, n, buildsCheck()) : finalResult;
+    const hitText = pending?.slice(0, pending.length - arr.length);
+    const termText = opText?.slice(0, opText.length - arr.length);
+    const before = finalResult;
+    if (op === Dice.prototype.combine) assertMixable(before, arg, arr);
     let crit;
     let critNorm = 1;
-    if (arr[0] === "x" || arr[0] === "c") {
-      const isXcrit = arr[0] === "x";
-      if (isXcrit) assertToken(arr, "x");
-      assertToken(arr, "c");
-      assertToken(arr, "r");
-      assertToken(arr, "i");
-      assertToken(arr, "t");
-      const count = isXcrit ? parseNumber(arr, n) : 1;
-      const trackedCritSlice = finalResult.privateData?.natMaxCritSlice;
-      if (count === 1 && trackedCritSlice) {
-        crit = trackedCritSlice;
-        finalResult = subtractCounts(finalResult, trackedCritSlice);
+    const critClause = arr[0] === "x" || arr[0] === "c";
+    const implicitCrit = !critClause && hitText !== void 0 && !finalResult.privateData.noDie;
+    if (critClause || implicitCrit) {
+      let count = 1;
+      if (critClause) {
+        const isXcrit = arr[0] === "x";
+        if (isXcrit) assertToken(arr, "x");
+        assertToken(arr, "c");
+        assertToken(arr, "r");
+        assertToken(arr, "i");
+        assertToken(arr, "t");
+        if (isXcrit) count = parseNumber(arr, n);
+      }
+      if (finalResult.privateData.noDie) {
+        parseBinaryArgument(arg, arr, n);
       } 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);
-        }
+        ({ crit, rest: finalResult } = splitCrit(finalResult, count));
+        critNorm = crit.total();
+        crit = op.call(crit, critClause ? parseBinaryArgument(arg, arr, n) : critPayload(hitText, n));
+        critNorm = crit && critNorm ? crit.total() / critNorm : 1;
       }
-      critNorm = crit.total();
-      crit = op.call(crit, parseBinaryArgument(arg, arr, n));
-      critNorm = crit && critNorm ? crit.total() / critNorm : 1;
     }
     let save;
     let saveNorm = 1;
@@ -3145,109 +3762,351 @@ function parseExpression(arr, n) {
       missNorm = miss && missNorm ? miss.total() / missNorm : 1;
     }
     let norm = finalResult.total();
-    if (!acAlreadyApplied) {
+    const clause = crit !== void 0 || save !== void 0 || pc !== void 0 || miss !== void 0;
+    const labelled = hasOutcomeLabels(finalResult);
+    const operand = finalResult;
+    if (!clause && labelled && HIT_ONLY_OPS.has(op)) {
+      finalResult = applyByOutcome(finalResult, op, arg, termText, n);
+    } else {
       finalResult = op.call(finalResult, arg);
     }
+    if (operand.privateData.isDCCheck && HIT_ONLY_OPS.has(op)) {
+      finalResult.setOutcomeDistribution("saveFail", op.call(operand.deleteFace(0), arg).getFaceMap());
+    }
+    if (!operand.privateData.isDCCheck && HIT_ONLY_OPS.has(op) && (hitText !== void 0 || operand.privateData.attackPayload)) {
+      finalResult.privateData.attackPayload = true;
+      const landed = landedHitsAtZero(operand, op, arg);
+      if (landed > 0) finalResult.setOutcomeDistribution("hit", { 0: landed });
+    } else if (op === Dice.prototype.combine && typeof arg !== "number" && arg.privateData.attackPayload) {
+      finalResult.privateData.attackPayload = true;
+      const landed = operand.getOutcomeCount("hit", 0) + arg.getOutcomeCount("hit", 0);
+      if (landed > 0) finalResult.setOutcomeDistribution("hit", { 0: landed });
+    }
+    const gated = op === Dice.prototype.combine && typeof arg !== "number" && arg.privateData.isACCheck;
+    if (op === Dice.prototype.ac || gated) finalResult.privateData.isACCheck = true;
+    followNaturalRoll(before, op, arg, finalResult, clause);
     norm = norm ? finalResult.total() / norm : 1;
     if (crit) {
-      const result2 = combineDiceWithNormalization(
+      const result = combineDiceWithNormalization(
         crit,
         critNorm,
         "crit",
         norm,
         finalResult
       );
-      norm = result2.newNorm;
-      finalResult = result2.updatedResult;
+      norm = result.newNorm;
+      finalResult = result.updatedResult;
     }
     if (save) {
-      const result2 = combineDiceWithNormalization(
+      const result = combineDiceWithNormalization(
         save,
         saveNorm,
         "saveHalf",
         norm,
         finalResult
       );
-      norm = result2.newNorm;
-      finalResult = result2.updatedResult;
+      norm = result.newNorm;
+      finalResult = result.updatedResult;
     }
     if (miss) {
-      const result2 = combineDiceWithNormalization(
+      const result = combineDiceWithNormalization(
         miss,
         missNorm,
         "missDamage",
         norm,
         finalResult
       );
-      norm = result2.newNorm;
-      finalResult = result2.updatedResult;
+      norm = result.newNorm;
+      finalResult = result.updatedResult;
     }
     if (pc) {
-      const result2 = combineDiceWithNormalization(
+      const result = combineDiceWithNormalization(
         pc,
         pcNorm,
         "pc",
         norm,
         finalResult
       );
-      norm = result2.newNorm;
-      finalResult = result2.updatedResult;
+      norm = result.newNorm;
+      finalResult = result.updatedResult;
     }
-    op = parseOperation(arr);
+    if (implicitCrit) finalResult.privateData.implicitCrit = { payload: hitText };
+    opText = finalResult.privateData.implicitCrit ? arr.join("") : void 0;
+    op = readOperation();
   }
   return finalResult;
 }
-function parseArgument(s, n) {
-  let result = parseArgumentInternal(s, n);
-  while (true) {
-    const next = parseArgumentInternal(s, n);
-    if (next === void 0) break;
+function naturalSides(value) {
+  if (typeof value === "number") return 0;
+  const { critTrack, untrackedSides } = value.privateData;
+  return critTrack ? critTrack.sides : untrackedSides ?? 0;
+}
+function outranks(sides, other) {
+  if (sides === other) return false;
+  if (sides === 20 || other === 20) return sides === 20;
+  return sides > other;
+}
+function bareTrack(die) {
+  return {
+    sides: die.maxFace(),
+    bare: true,
+    slice: (face) => {
+      const slice = new Dice();
+      const weight = die.get(face);
+      if (weight) slice.setFace(face, weight);
+      return slice;
+    }
+  };
+}
+function asValue(value) {
+  if (typeof value !== "number") return value;
+  const scalar = Dice.scalar(value);
+  scalar.privateData.noDie = true;
+  return scalar;
+}
+function branchesOf(value) {
+  return typeof value === "number" ? [asValue(value)] : value.privateData.branches ?? [value];
+}
+var hasOutcomeLabels = (value) => typeof value !== "number" && Object.keys(value.getFullOutcomeDistribution()).some((label) => label !== "hit");
+var isSave = (value) => typeof value !== "number" && value.privateData.isDCCheck === true;
+function assertMixable(left, right, rest) {
+  if (hasOutcomeLabels(left) || hasOutcomeLabels(right)) {
+    throw new Error(
+      "an `&` mix of an attack already split into crit, miss or save outcomes has no single reading: mix the checks before the payload, like `((d20 AC 10) & (d20 AC 15)) * (1d6)`"
+    );
+  }
+  if (isSave(left) !== isSave(right)) {
+    throw new Error("an `&` mix of a saving throw (DC) with anything but another saving throw has no single set of outcomes");
+  }
+  const [next, after] = rest;
+  if (next === "x" || next === "c" || next === "s" || next === "m" || next === "p" && after === "c") {
+    throw new Error("a crit, save, pc or miss clause on an `&` mix has no single reading: put it after the payload's `*`");
+  }
+}
+function followNaturalRoll(before, op, arg, after, clause) {
+  const data = after.privateData;
+  delete data.critTrack;
+  delete data.untrackedSides;
+  delete data.noDie;
+  delete data.branches;
+  const gate = GATE_OPS.has(op);
+  if (!clause && before.privateData.noDie && (gate || typeof arg === "number" || arg.privateData.noDie)) {
+    data.noDie = true;
+  }
+  const mixed = before.privateData.branches !== void 0 || !gate && typeof arg !== "number" && arg.privateData.branches !== void 0;
+  if (!clause && op === Dice.prototype.combine) {
+    data.branches = [...branchesOf(before), ...branchesOf(arg)];
+  } else if (!clause && mixed && op !== Dice.prototype.reroll) {
+    const advantage = op === Dice.prototype.advantage;
+    const pairOp = advantage ? Dice.prototype.max : op;
+    const lefts = branchesOf(before);
+    const rights = advantage ? lefts : gate ? [asValue(arg)] : branchesOf(arg);
+    data.branches = lefts.flatMap(
+      (left) => rights.map((right) => {
+        const part = pairOp.call(left, right);
+        followNaturalRoll(left, pairOp, right, part, false);
+        return part;
+      })
+    );
+  }
+  if (data.branches) {
+    mixNaturalRolls(after, data.branches);
+    return;
+  }
+  const track = before.privateData.critTrack;
+  const argTrack = typeof arg === "number" || gate ? void 0 : arg.privateData.critTrack;
+  const sides = naturalSides(before);
+  const argSides = gate ? 0 : naturalSides(arg);
+  const extremum = op === Dice.prototype.max || op === Dice.prototype.min;
+  const own = track !== void 0 && outranks(sides, argSides);
+  const followed = own ? track : argTrack && outranks(argSides, sides) ? argTrack : void 0;
+  if (clause) ; else if (op === Dice.prototype.advantage || op === Dice.prototype.reroll) {
+    if (track?.bare) data.critTrack = bareTrack(after);
+  } else if (extremum && track?.bare && argTrack?.bare && sides === argSides) {
+    data.critTrack = bareTrack(after);
+  } else if (followed) {
+    const apply = own ? (value) => op.call(value, arg) : (value) => op.call(before, value);
+    const step = extremum ? (slice) => keptPart(slice, apply) : apply;
+    data.critTrack = { sides: followed.sides, bare: false, slice: (face) => step(followed.slice(face)) };
+  }
+  if (!data.critTrack) {
+    const top = outranks(argSides, sides) ? argSides : sides;
+    if (top > 0) data.untrackedSides = top;
+  }
+}
+function mixNaturalRolls(after, branches) {
+  const sides = branches.reduce((top, branch) => outranks(naturalSides(branch), top) ? naturalSides(branch) : top, 0);
+  if (sides === 0) return;
+  const tracks = [];
+  for (const branch of branches) {
+    if (naturalSides(branch) !== sides) continue;
+    const track = branch.privateData.critTrack;
+    if (!track) {
+      after.privateData.untrackedSides = sides;
+      return;
+    }
+    tracks.push(track);
+  }
+  after.privateData.critTrack = {
+    sides,
+    bare: tracks.length === branches.length && tracks.every((track) => track.bare),
+    slice: (face) => {
+      const slice = new Dice();
+      for (const track of tracks) slice.combineInPlace(track.slice(face));
+      return slice;
+    }
+  };
+}
+function keptPart(slice, apply) {
+  const result = new Dice();
+  for (const [value, count] of slice.getFaceEntries()) {
+    const face = new Dice();
+    face.setFace(value, count);
+    const kept = apply(face).get(value);
+    if (kept) result.increment(value, kept);
+  }
+  return result;
+}
+function splitCrit(check, count) {
+  if (count === 0) {
+    const none = new Dice();
+    return { crit: none, rest: subtractCounts(check, none) };
+  }
+  const track = check.privateData.critTrack;
+  if (!track) {
+    throw new Error(
+      "crit rate cannot be computed exactly for this attack check: its natural roll is not one die (a dice-valued check like 2d20 or 2kh2d20, two d20s like d20 + d20, or advantage over a total). Build the attack with the builder API instead."
+    );
+  }
+  const { sides } = track;
+  if (count > sides) {
+    throw new Error(`xcrit${count} is wider than the d${sides} it reads its natural roll from`);
+  }
+  let crit = new Dice();
+  for (let face = sides; face > sides - count; face--) crit.combineInPlace(track.slice(face));
+  const rest = subtractCounts(check, crit);
+  const missed = crit.get(0);
+  if (missed) {
+    crit = crit.deleteFace(0);
+    rest.increment(0, missed);
+  }
+  return { crit, rest };
+}
+function critPayload(text, n) {
+  let doubled = text;
+  try {
+    doubled = scaleParsedDice(text.replace(/n/g, String(n)), 2);
+  } catch (error) {
+    if (!(error instanceof UndoubleableExpressionError)) throw error;
+  }
+  const chars = [...doubled];
+  const payload = parseExpression(chars, n);
+  if (chars.length > 0) {
+    throw new Error(`Unexpected token '${chars[0]}' in the crit payload '${doubled}'`);
+  }
+  return payload;
+}
+function applyByOutcome(labelled, op, arg, termText, n) {
+  const implicit = labelled.privateData.implicitCrit;
+  const argTotal = typeof arg === "number" ? 1 : arg.total();
+  const result = new Dice();
+  let rest = labelled;
+  let payload;
+  for (const [label, distribution] of Object.entries(labelled.getFullOutcomeDistribution())) {
+    if (label === "hit" || distribution === void 0) continue;
+    const part = new Dice();
+    for (const [face, count] of Object.entries(distribution)) part.increment(Number(face), count);
+    rest = subtractCounts(rest, part);
+    let applied;
+    if (label === "crit" && implicit && termText !== void 0) {
+      payload = implicit.payload + termText;
+      const doubled = critPayload(payload, n);
+      applied = doubled.normalize(part.total() * argTotal / doubled.total());
+    } else {
+      applied = op.call(part, arg);
+    }
+    result.combineInPlace(applied);
+    result.setOutcomeDistribution(label, applied.getFaceMap());
+  }
+  result.combineInPlace(op.call(rest, arg));
+  if (labelled.privateData.isDCCheck) result.privateData.isDCCheck = true;
+  if (payload !== void 0) result.privateData.implicitCrit = { payload };
+  return result;
+}
+function landedHitsAtZero(operand, op, arg) {
+  let landed = 0;
+  for (const [face, count] of Object.entries(operand.calculateHitDistribution())) {
+    if (!(count > 0)) continue;
+    const hit = new Dice();
+    hit.setFace(Number(face), count);
+    landed += op.call(hit, arg).get(0);
+  }
+  return landed;
+}
+function parseArgument(s, n, inCheck = false) {
+  if (s[0] === "-") {
+    s.shift();
+    const operand = parseArgument(s, n, inCheck);
+    if (typeof operand === "number") return 0 - operand;
+    const zero = asValue(0);
+    const negated = zero.subtract(operand);
+    followNaturalRoll(zero, Dice.prototype.subtract, operand, negated, false);
+    return negated;
+  }
+  let result = parseArgumentInternal(s, n, inCheck);
+  if (result === void 0) {
+    const at = s.length === 0 ? "the end of the expression" : `'${s.slice(0, 20).join("")}'`;
+    throw new Error(`Expected a number, a die, a keep or '(' at ${at}`);
+  }
+  for (let next = parseArgumentInternal(s, n, inCheck); next !== void 0; next = parseArgumentInternal(s, n, inCheck)) {
     result = multiplyDiceByDice(result, next);
   }
   return result;
 }
 function multiplyDiceByDice(d1, d2) {
+  const noDie = (typeof d1 === "number" || d1.privateData.noDie) && (typeof d2 === "number" || d2.privateData.noDie);
   if (typeof d1 === "number") d1 = Dice.scalar(d1);
   if (typeof d2 === "number") d2 = Dice.scalar(d2);
   const result = new Dice();
   const faces = /* @__PURE__ */ new Map();
-  let normalizationFactor = 1;
+  let common = 1;
+  const { keep } = d2.privateData;
   for (const key of d1.keys()) {
-    let face;
-    if (typeof key !== "number") {
-      continue;
-    }
-    if (d2.privateData.keep) {
-      const faceCount = d2.keys().length;
-      if (Math.pow(faceCount, key) > MAX_KEEP_OUTCOMES) {
-        throw new DiceParseError(
-          `Keep enumeration of ${faceCount}^${key} outcomes exceeds the maximum of ${MAX_KEEP_OUTCOMES}`
-        );
-      }
-      const repeat = Array(key).fill(d2);
-      face = opDice(repeat, d2.privateData.keep);
-    } else {
-      face = multiplyDice(key, d2);
-    }
-    normalizationFactor *= face.total();
+    const face = keep ? keepDice(d2, key, keep) : multiplyDice(key, d2);
+    common *= face.total();
     faces.set(key, face);
   }
+  const exact = common <= MAX_EXACT_COUNT;
   for (const [k, face] of faces) {
     const count = d1.get(k);
-    result.combineInPlace(
-      face.normalize(count * normalizationFactor / face.total())
-    );
+    result.combineInPlace(face.normalize((exact ? common : 1) * count / face.total()));
   }
   result.privateData.except = {};
+  const [only, ...more] = d1.keys();
+  const { critTrack } = d2.privateData;
+  const rolls = keep === void 0 ? only : Math.min(only, keep.kept);
+  const sides = outranks(naturalSides(d2), naturalSides(d1)) ? naturalSides(d2) : naturalSides(d1);
+  if (rolls === 1 && more.length === 0 && critTrack?.bare) {
+    result.privateData.critTrack = bareTrack(result);
+  } else if (sides > 0) {
+    result.privateData.untrackedSides = sides;
+  }
+  if (noDie) result.privateData.noDie = true;
   return result;
 }
-function multiplyDice(n, d) {
+function assertRepeatCount(n) {
+  if (!Number.isInteger(n) || n < 0) {
+    throw new DiceParseError(`A repeat count must be a whole number of 0 or more; this one can be ${n}`);
+  }
   if (n > MAX_DICE_COUNT) {
     throw new DiceParseError(
       `Dice count ${n} exceeds the maximum of ${MAX_DICE_COUNT}`
     );
   }
-  if (n === 0) return new Dice(0);
+}
+function multiplyDice(n, d) {
+  assertRepeatCount(n);
+  if (n === 0) return Dice.scalar(0);
   if (n === 1) return d;
   const half = Math.floor(n / 2);
   let result = multiplyDice(half, d);
@@ -3255,43 +4114,70 @@ function multiplyDice(n, d) {
   if (n % 2 === 1) {
     result = result.add(d);
   }
-  return result;
-}
-function opDice(diceList, keepFn) {
-  return opDiceInternal(diceList, new Dice(), 0, [], 1, keepFn);
+  const total = result.total();
+  return total > MAX_EXACT_COUNT ? result.normalize(1 / total) : result;
 }
-function opDiceInternal(diceList, result, index, values, weight, combineFn) {
-  if (index === diceList.length) {
-    return result.combine(Dice.scalar(combineFn(values)).normalize(weight));
-  }
-  const currentDice = diceList[index];
-  for (const face of currentDice.keys()) {
-    values.push(face);
-    result = opDiceInternal(
-      diceList,
-      result,
-      index + 1,
-      values,
-      weight * currentDice.get(face),
-      combineFn
+function keepDice(die, count, { kept, lowest }) {
+  assertRepeatCount(count);
+  if (kept >= count) return multiplyDice(count, die);
+  if (kept <= 0) return Dice.scalar(0);
+  const faces = die.getFaceEntries().filter(([, weight]) => weight > 0).sort(([a], [b]) => lowest ? a - b : b - a);
+  if (faces.length === 0) return new Dice();
+  const span = Math.abs(faces[faces.length - 1][0] - faces[0][0]);
+  const work = faces.length * kept * kept * (kept * span + 1);
+  if (work > MAX_KEEP_WORK) {
+    throw new DiceParseError(
+      `Keep of ${kept} of ${count} copies of a ${faces.length}-face roll exceeds the maximum work of ${MAX_KEEP_WORK}`
     );
-    values.pop();
   }
+  const tails = new Array(faces.length);
+  for (let i = faces.length - 1, tail = 0; i >= 0; i--) tails[i] = tail += faces[i][1];
+  const addTo = (map, key, p) => {
+    map.set(key, (map.get(key) ?? 0) + p);
+  };
+  let states = Array.from({ length: kept }, () => /* @__PURE__ */ new Map());
+  states[0].set(0, 1);
+  const done = /* @__PURE__ */ new Map();
+  faces.forEach(([value, weight], i) => {
+    const q = weight / tails[i];
+    const next = Array.from({ length: kept }, () => /* @__PURE__ */ new Map());
+    states.forEach((sums, placed) => {
+      if (sums.size === 0) return;
+      const left = count - placed;
+      const need = kept - placed;
+      const few = [];
+      let logChoose = 0;
+      for (let c = 0; c < need; c++) {
+        if (c > 0) logChoose += Math.log((left - c + 1) / c);
+        few.push(q >= 1 ? 0 : Math.exp(logChoose + c * Math.log(q) + (left - c) * Math.log1p(-q)));
+      }
+      const enough = Math.max(0, 1 - few.reduce((total, p) => total + p, 0));
+      for (const [sum, p] of sums) {
+        few.forEach((pc, c) => {
+          if (pc > 0) addTo(next[placed + c], sum + c * value, p * pc);
+        });
+        if (enough > 0) addTo(done, sum + need * value, p * enough);
+      }
+    });
+    states = next;
+  });
+  const result = new Dice();
+  for (const [sum, p] of done) result.increment(sum, p);
   return result;
 }
-function parseArgumentInternal(s, n) {
+function parseArgumentInternal(s, n, inCheck = false) {
   if (s.length === 0) return;
   const c = s[0];
   switch (c) {
     case "(":
       s.shift();
-      return assertToken(s, ")", parseExpression(s, n));
+      return assertToken(s, ")", parseExpression(s, n, inCheck));
     case "h":
     case "d":
       return parseDice(s, n);
     case "k":
       assertToken(s, "k");
-      return parseKeep(s, n);
+      return parseKeep(s, n, inCheck);
     case "n":
       return parseNumber(s, n);
     default:
@@ -3335,10 +4221,11 @@ function parseDice(s, n) {
     );
   }
   let result = new Dice(sides);
+  if (sides === 0) return result;
   if (rerollOne) {
     result = result.reroll(1);
   }
-  result.privateData.checkDie = { sides, rerollOne };
+  result.privateData.critTrack = bareTrack(result);
   return result;
 }
 function peek(arr, expected) {
@@ -3366,31 +4253,24 @@ function parseNumber(s, n) {
 function isDigit(c) {
   return c >= "0" && c <= "9";
 }
-function parseKeep(s, n) {
-  let keepLowest = false;
+function parseKeep(s, n, inCheck) {
+  let lowest = false;
   if (peek(s, "l")) {
     assertToken(s, "l");
-    keepLowest = true;
+    lowest = true;
   } else if (peek(s, "h")) {
     assertToken(s, "h");
-    keepLowest = false;
   } else {
     return;
   }
-  const keepCount = parseNumber(s, n);
-  const result = parseArgumentInternal(s, n);
+  const kept = parseNumber(s, n);
+  const result = parseArgumentInternal(s, n, inCheck);
   if (result instanceof Dice) {
-    result.privateData.keep = keepN(keepCount, keepLowest);
+    result.privateData.keep = { kept, lowest };
     return result;
   }
   throw new Error("Expected Dice after keep modifier");
 }
-function keepN(n, low) {
-  return (values) => {
-    const sorted = [...values].sort((a, b) => low ? a - b : b - a);
-    return sorted.slice(0, n).reduce((sum, val) => sum + val, 0);
-  };
-}
 function parseOperation(s) {
   switch (s[0]) {
     case ")":
@@ -3533,7 +4413,7 @@ var Mixture = class _Mixture {
   }
   /**
    * Add a labeled component with a mixture weight.
-   * Weight can be any positive finite number. Very small contributions are pruned by eps.
+   * Weight can be any positive finite number; only the ratios between weights matter.
    */
   add(label, pmf, weight = 1) {
     if (!Number.isFinite(weight) || weight <= 0) return this;
@@ -3541,7 +4421,7 @@ var Mixture = class _Mixture {
       const p = bin.p;
       if (p <= 0) continue;
       const add = weight * p;
-      if (!Number.isFinite(add) || Math.abs(add) < this.eps) continue;
+      if (!Number.isFinite(add) || add <= 0) continue;
       this.totals.set(v, (this.totals.get(v) ?? 0) + add);
       const bag = this.labelMass.get(v) ?? {};
       bag[label] = (bag[label] ?? 0) + add;
@@ -3549,27 +4429,35 @@ var Mixture = class _Mixture {
     }
     return this;
   }
+  /**
+   * The normalized mixture. Each bin's `p` and per-label `count` are its raw mass divided by
+   * the grand total, so labels sum to `p` whatever the weights summed to. Outcomes below
+   * `eps` of the total (the pruning `eps` given to the constructor) are dropped first.
+   *
+   * @param eps Epsilon carried by the built PMF.
+   */
   buildPMF(eps = EPS) {
-    let grand = 0;
-    let c = 0;
-    for (const m of this.totals.values()) {
-      const y = m - c;
-      const t = grand + y;
-      c = t - grand - y;
-      grand = t;
-    }
+    const grand = kahanSum(this.totals.values());
     if (!(grand > 0)) throw new Error("Mixture: zero total mass");
+    const threshold = this.eps * grand;
+    const kept = [...this.totals].filter(([, m]) => m > 0 && m >= threshold);
+    if (kept.length === 0) {
+      throw new Error(`Mixture: pruning at eps ${this.eps} removed every outcome`);
+    }
+    const keptTotal = kept.length === this.totals.size ? grand : kahanSum(kept.map(([, m]) => m));
     const internal = /* @__PURE__ */ new Map();
-    for (const [v, m] of this.totals) {
-      if (m <= 0 || Math.abs(m) < this.eps) continue;
-      const count = this.labelMass.get(v) ?? {};
-      internal.set(v, { p: m / grand, count });
+    for (const [v, m] of kept) {
+      const count = {};
+      const bag = this.labelMass.get(v) ?? {};
+      for (const label in bag) count[label] = bag[label] / keptTotal;
+      internal.set(v, { p: m / keptTotal, count });
     }
     return new PMF(internal, eps);
   }
   /**
    * Produce normalized *per-label* PMFs (labels independent).
-   * These are unlabeled PMFs built from the raw mass of that label alone.
+   * These are unlabeled PMFs built from the raw mass of that label alone; values below `eps`
+   * of the label's own mass are pruned.
    */
   byOutcome() {
     const labels = /* @__PURE__ */ new Set();
@@ -3578,12 +4466,16 @@ var Mixture = class _Mixture {
     }
     const out = {};
     for (const label of labels) {
+      const labelTotal = kahanSum(
+        [...this.labelMass.values()].map((bag) => bag[label] ?? 0)
+      );
+      if (!(labelTotal > 0)) continue;
       const m = /* @__PURE__ */ new Map();
       for (const [v, bag] of this.labelMass) {
         const w = bag[label];
-        if (w && Math.abs(w) >= this.eps) m.set(v, w);
+        if (w) m.set(v, w / labelTotal);
       }
-      if (m.size > 0) out[label] = PMF.fromMap(m, this.eps);
+      out[label] = PMF.fromMap(m, this.eps);
     }
     return out;
   }
@@ -3599,14 +4491,7 @@ var Mixture = class _Mixture {
         res[lab] = (res[lab] ?? 0) + w;
       }
     }
-    let total = 0;
-    let c = 0;
-    for (const v of Object.values(res)) {
-      const y = v - c;
-      const t = total + y;
-      c = t - total - y;
-      total = t;
-    }
+    const total = kahanSum(Object.values(res));
     if (total > 0) {
       for (const k in res) res[k] = res[k] / total;
     }
@@ -3622,9 +4507,20 @@ var Mixture = class _Mixture {
   static mix(items, eps = EPS) {
     const mix = new _Mixture(eps);
     for (const [lab, pmf, w] of items) mix.add(lab, pmf, w);
-    return mix.buildPMF();
+    return mix.buildPMF(eps);
   }
 };
+function kahanSum(values) {
+  let sum = 0;
+  let c = 0;
+  for (const v of values) {
+    const y = v - c;
+    const t = sum + y;
+    c = t - sum - y;
+    sum = t;
+  }
+  return sum;
+}
 
 exports.ALL_OUTCOME_TYPES = ALL_OUTCOME_TYPES;
 exports.DiceParseError = DiceParseError;
@@ -3638,7 +4534,11 @@ exports.PMF = PMF;
 exports.calculateBounceOdds = calculateBounceOdds;
 exports.clearParserCache = clearParserCache;
 exports.critProbability = critProbability;
+exports.diceSumDistribution = diceSumDistribution;
+exports.explodingPoolMatchProbability = explodingPoolMatchProbability;
+exports.faceWeights = faceWeights;
 exports.getCachingEnabled = getCachingEnabled;
+exports.jointSumAndMatch = jointSumAndMatch;
 exports.onAnyHit = onAnyHit;
 exports.onCritOnly = onCritOnly;
 exports.onHitOnly = onHitOnly;