@yipe/dice 0.2.23 → 0.4.0

package/dist/builder/index.js

@@ -1,12 +1,8 @@
-var __defProp = Object.defineProperty;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
-
 // src/common/lru-cache.ts
 var LRUCache = class {
   constructor(maxSize = 1e3) {
     this.maxSize = maxSize;
-    __publicField(this, "cache", /* @__PURE__ */ new Map());
+    this.cache = /* @__PURE__ */ new Map();
   }
   get(key) {
     const value = this.cache.get(key);
@@ -46,19 +42,35 @@ var LRUCache = class {
 
 // src/common/types.ts
 var EPS = 1e-12;
+var MISS_NONE_OUTCOME = "missNone";
 
 // src/pmf/query.ts
 var _DiceQuery = class _DiceQuery {
   constructor(singles, combined, eps = EPS) {
-    __publicField(this, "singles");
-    __publicField(this, "combined");
-    __publicField(this, "_combinedWithAttr");
     this.singles = Array.isArray(singles) ? singles : [singles];
     if (this.singles.some((s) => s === void 0)) {
       throw new Error("DiceQuery contains undefined singles");
     }
-    const c = combined ?? PMF.convolveMany(this.singles);
-    this.combined = Math.abs(c.mass() - 1) <= eps ? c : c.normalize();
+    this._eps = eps;
+    this._combinedProvided = combined !== void 0;
+    if (combined !== void 0) {
+      this._combined = Math.abs(combined.mass() - 1) <= eps ? combined : combined.normalize();
+    }
+  }
+  /**
+   * The combined damage distribution of all single PMFs (their convolution),
+   * normalized to total probability 1.
+   *
+   * Computed lazily on first access and cached. Queries that only need
+   * additive statistics — {@link DiceQuery.mean}, {@link DiceQuery.variance},
+   * {@link DiceQuery.stddev} — never trigger this convolution.
+   */
+  get combined() {
+    if (this._combined === void 0) {
+      const c = PMF.convolveMany(this.singles);
+      this._combined = Math.abs(c.mass() - 1) <= this._eps ? c : c.normalize();
+    }
+    return this._combined;
   }
   /**
    * Returns a new PMF with damage attribution metadata populated.
@@ -83,12 +95,39 @@ var _DiceQuery = class _DiceQuery {
     if (this._combinedWithAttr) {
       return this._combinedWithAttr;
     }
+    if (this.singles.every((pmf) => pmf.hasAttribution())) {
+      this._combinedWithAttr = this.combined;
+      return this._combinedWithAttr;
+    }
     const singlesWithAttr = this.singles.map((pmf) => pmf.withAttribution());
     const combined = PMF.convolveMany(singlesWithAttr, this.combined.epsilon);
     const normalized = Math.abs(combined.mass() - 1) <= this.combined.epsilon ? combined : combined.normalize();
     this._combinedWithAttr = normalized;
     return normalized;
   }
+  /**
+   * Per-label `damage value → probability mass` series for the combined,
+   * attribution-carrying distribution — the provenance core of the stacked
+   * damage-attribution chart. Convenience for
+   * `combinedWithAttribution().attributionByValue()`; see
+   * {@link PMF.attributionByValue}.
+   */
+  attributionByValue() {
+    return this.combinedWithAttribution().attributionByValue();
+  }
+  /**
+   * How many of the independent single PMFs can produce the given outcome
+   * label. Useful for "all of them succeeded" style probabilities where the
+   * exponent is the number of contributing attacks (see
+   * {@link DiceQuery.probExactlyK}).
+   */
+  countSinglesWith(label) {
+    let count = 0;
+    for (const single of this.singles) {
+      if (single.hasOutcome(label)) count++;
+    }
+    return count;
+  }
   /**
    * Returns the expected damage across all possible outcomes.
    *
@@ -96,11 +135,18 @@ var _DiceQuery = class _DiceQuery {
    * Use case: "What's my average damage per round?"
    */
   mean() {
-    let totalSum = 0;
-    for (const [damageValue, probabilityBin] of this.combined) {
-      totalSum += damageValue * probabilityBin.p;
+    if (this._combinedProvided) {
+      let m = 0;
+      for (const [damageValue, bin] of this.combined) m += damageValue * bin.p;
+      return m;
+    }
+    let totalMean = 0;
+    for (const single of this.singles) {
+      const mass = single.mass();
+      if (mass <= 0) continue;
+      totalMean += Math.abs(mass - 1) <= this._eps ? single.mean() : single.mean() / mass;
     }
-    return totalSum;
+    return totalMean;
   }
   /**
    * Returns the variance of the damage distribution.
@@ -110,13 +156,33 @@ var _DiceQuery = class _DiceQuery {
    * High variance means higher risk/reward. Lower variance means more consistent damage.
    */
   variance() {
-    const meanValue = this.mean();
-    let varianceSum = 0;
-    for (const [damageValue, probabilityBin] of this.combined) {
-      const deviationFromMean = damageValue - meanValue;
-      varianceSum += deviationFromMean * deviationFromMean * probabilityBin.p;
+    if (this._combinedProvided) {
+      const mu = this.mean();
+      let v = 0;
+      for (const [damageValue, bin] of this.combined) {
+        const dev = damageValue - mu;
+        v += dev * dev * bin.p;
+      }
+      return v;
+    }
+    let totalVariance = 0;
+    for (const single of this.singles) {
+      const mass = single.mass();
+      if (mass <= 0) continue;
+      if (Math.abs(mass - 1) <= this._eps) {
+        totalVariance += single.variance();
+      } else {
+        let mu = 0;
+        for (const [d2, b] of single) mu += d2 * (b.p / mass);
+        let v = 0;
+        for (const [d2, b] of single) {
+          const dev = d2 - mu;
+          v += dev * dev * (b.p / mass);
+        }
+        totalVariance += v;
+      }
     }
-    return varianceSum;
+    return totalVariance;
   }
   /**
    * Returns the standard deviation of the damage distribution.
@@ -128,6 +194,10 @@ var _DiceQuery = class _DiceQuery {
   stddev() {
     return Math.sqrt(this.variance());
   }
+  /** Alias of {@link DiceQuery.stddev}, matching {@link PMF.stdev}. */
+  stdev() {
+    return this.stddev();
+  }
   /**
    * Returns the Cumulative Distribution Function.
    */
@@ -218,20 +288,49 @@ var _DiceQuery = class _DiceQuery {
     return this.combined.max();
   }
   singleProb(diceIndex, label) {
+    const single = this.singles[diceIndex];
     let probabilitySum = 0;
-    for (const [, probabilityBin] of this.singles[diceIndex]) {
+    for (const [, probabilityBin] of single) {
       probabilitySum += probabilityBin.count[label] || 0;
     }
-    return probabilitySum;
+    const mass = single.mass();
+    return mass > 0 ? probabilitySum / mass : 0;
+  }
+  /**
+   * Full count distribution [P(0), P(1), …, P(n)] for "an attack succeeds if it
+   * carries ANY of `labels`", over the n independent singles.
+   *
+   * Each single's per-event success probability is the Poisson-binomial
+   * marginal P(≥1 of labels) from {@link probabilityOf} (i.e. probAtLeastOne),
+   * computed exactly once. The binomial DP then runs once to produce the whole
+   * distribution, so the array-label paths of probExactlyK / probAtLeastK /
+   * probAtMostK can slice or sum from it instead of rebuilding a DiceQuery and
+   * re-running the DP per requested k.
+   */
+  countDistribution(labels) {
+    const n = this.singles.length;
+    const successProbabilities = this.singles.map(
+      (single) => new _DiceQuery([single]).probabilityOf(labels)
+    );
+    const dist = new Array(n + 1).fill(0);
+    dist[0] = 1;
+    for (const successProb of successProbabilities) {
+      for (let outcomeCount = n; outcomeCount >= 1; outcomeCount--) {
+        dist[outcomeCount] = dist[outcomeCount] * (1 - successProb) + dist[outcomeCount - 1] * successProb;
+      }
+      dist[0] *= 1 - successProb;
+    }
+    return dist;
   }
   probAtLeastK(labels, k) {
     const L = Array.isArray(labels) ? [...new Set(labels)] : [labels];
     const n = this.singles.length;
     if (k <= 0) return 1;
     if (k > n) return 0;
+    const dist = this.countDistribution(L);
     let tail = 0;
     for (let i = k; i <= n; i++) {
-      tail += this.probExactlyK(L, i);
+      tail += dist[i];
     }
     if (tail < 0) return 0;
     if (tail > 1) return 1;
@@ -263,9 +362,12 @@ var _DiceQuery = class _DiceQuery {
       for (const label of labels) {
         combinedProbability += this.singleProb(diceIndex, label);
       }
+      if (combinedProbability < 0) combinedProbability = 0;
+      else if (combinedProbability > 1) combinedProbability = 1;
       productOfNonOccurrence *= 1 - combinedProbability;
     }
-    return 1 - productOfNonOccurrence;
+    const result = 1 - productOfNonOccurrence;
+    return result < 0 ? 0 : result > 1 ? 1 : result;
   }
   /**
    * Computes binomial probabilities for exactly 0, 1, 2, ..., maxK occurrences of a label.
@@ -306,7 +408,7 @@ var _DiceQuery = class _DiceQuery {
    * Array examples:
    * - probExactlyK(['hit', 'crit'], 2) = probability exactly 2 attacks succeed
    * - probExactlyK(['hit', 'crit'], 1) = probability exactly 1 attack succeeds
-   * - probExactlyK(['miss', 'missNone'], 0) = probability no attacks miss
+   * - probExactlyK(['missDamage', 'missNone'], 0) = probability no attacks miss
    *
    * Use cases:
    * - "What's the chance exactly one of my attacks hits?"
@@ -321,19 +423,8 @@ var _DiceQuery = class _DiceQuery {
       const probabilityArray = this.computeBinomialProbabilities(labels, k);
       return probabilityArray[k];
     }
-    const successProbabilities = this.singles.map((single) => {
-      const singleQuery = new _DiceQuery([single]);
-      return singleQuery.probabilityOf(labels);
-    });
-    const binomialProbs = new Array(k + 1).fill(0);
-    binomialProbs[0] = 1;
-    for (const successProb of successProbabilities) {
-      for (let outcomeCount = k; outcomeCount >= 1; outcomeCount--) {
-        binomialProbs[outcomeCount] = binomialProbs[outcomeCount] * (1 - successProb) + binomialProbs[outcomeCount - 1] * successProb;
-      }
-      binomialProbs[0] *= 1 - successProb;
-    }
-    return binomialProbs[k];
+    const dist = this.countDistribution(labels);
+    return k >= 0 && k < dist.length ? dist[k] : 0;
   }
   /**
    * Returns the probability that AT MOST K attacks result in the specified outcome(s).
@@ -341,7 +432,7 @@ var _DiceQuery = class _DiceQuery {
    * Single label examples:
    * - probAtMostK('hit', 1) = probability 0 or 1 attacks hit (at most 1)
    * - probAtMostK('crit', 0) = probability no attacks crit
-   * - probAtMostK('miss', 2) = probability at most 2 attacks miss
+   * - probAtMostK('missDamage', 2) = probability at most 2 attacks miss
    *
    * Array examples:
    * - probAtMostK(['hit', 'crit'], 1) = probability at most 1 attack succeeds
@@ -362,9 +453,11 @@ var _DiceQuery = class _DiceQuery {
       }
       return cumulativeSum2;
     }
+    const dist = this.countDistribution(labels);
+    const upper = Math.min(k, dist.length - 1);
     let cumulativeSum = 0;
-    for (let outcomeCount = 0; outcomeCount <= k; outcomeCount++) {
-      cumulativeSum += this.probExactlyK(labels, outcomeCount);
+    for (let outcomeCount = 0; outcomeCount <= upper; outcomeCount++) {
+      cumulativeSum += dist[outcomeCount];
     }
     return cumulativeSum;
   }
@@ -410,7 +503,7 @@ var _DiceQuery = class _DiceQuery {
    *
    * Array examples:
    * - damageStatsFrom(['hit', 'crit']) = damage range when at least one attack succeeds
-   * - damageStatsFrom(['miss', 'missNone']) = damage range when at least one attack misses
+   * - damageStatsFrom(['missDamage', 'missNone']) = damage range when at least one attack misses
    *
    * Tactical Use Cases:
    * - "Given that I don't completely whiff (99% of turns), what damage should I expect?"
@@ -428,6 +521,12 @@ var _DiceQuery = class _DiceQuery {
    * This includes mixed scenarios (2 hits + 1 crit, 3 hits + 1 miss, etc.) which
    * occur far more frequently than pure scenarios. For pure scenarios, use combinedDamageStats.
    *
+   * KNOWN LIMITATION (multi-attack, single label): the returned `count` is an
+   * EXPECTED COUNT (E[#label], so > 1 for N≥2 attacks, not a probability), and
+   * `avg` is the size-biased conditional mean E[dmg·#label]/E[#label] rather than
+   * E[dmg | the label occurs]. For a single attack both are the plain
+   * conditional figures. Use {@link probAtLeastOne} for the scenario probability.
+   *
    * @example
    * // High-level tactical planning
    * const successStats = query.damageStatsFrom('hit')
@@ -532,7 +631,8 @@ var _DiceQuery = class _DiceQuery {
     };
   }
   /**
-   * Returns the probability that a result includes ANY of the specified labels.
+   * Returns the probability that at least one attack carries ANY of the
+   * specified labels (the marginal P(≥1) across the independent attacks).
    *
    * Examples:
    * - `query.probabilityOf('hit')` → 0.88 (probability at least one hit occurs)
@@ -541,25 +641,15 @@ var _DiceQuery = class _DiceQuery {
    * Use cases:
    * - "What's the chance my resolution includes a success label?"
    * - "How likely am I to get any hits or crits across all attacks?"
+   *
+   * Note: this must NOT be computed by summing `combined` bin probabilities. A
+   * single combined damage total is reachable by many outcome combinations and
+   * a bin can hold several labels at once, so summing `bin.p` over bins that
+   * contain a label over-counts. The correct marginal is the Poisson-binomial
+   * complement over the per-attack probabilities, i.e. {@link probAtLeastOne}.
    */
   probabilityOf(labels) {
-    if (typeof labels === "string") {
-      labels = [labels];
-    }
-    let totalProbability = 0;
-    for (const [, probabilityBin] of this.combined) {
-      let binHasAnyLabel = false;
-      for (const label of labels) {
-        if (probabilityBin.count[label] && probabilityBin.count[label] > 0) {
-          binHasAnyLabel = true;
-          break;
-        }
-      }
-      if (binHasAnyLabel) {
-        totalProbability += probabilityBin.p;
-      }
-    }
-    return totalProbability;
+    return this.probAtLeastOne(labels);
   }
   /**
    * Returns the probability of missing (any type of miss).
@@ -619,10 +709,6 @@ var _DiceQuery = class _DiceQuery {
    */
   toStackedChartData(labels = [], epsilon = EPS) {
     const damageValues = this.combined.support();
-    damageValues.map((dmg) => {
-      const bin = this.combined.map.get(dmg);
-      return labels.reduce((sum, lab) => sum + (bin.count[lab] || 0), 0);
-    });
     const datasets = labels.map((outcomeLabel) => ({
       label: outcomeLabel,
       data: damageValues.map((dmg) => {
@@ -1059,6 +1145,16 @@ var _DiceQuery = class _DiceQuery {
    * Snapshot of the distribution in the exact shape the UI consumes.
    * - outcome probabilities are "at least one" (and equal to "all" for a single PMF)
    * - damageRange is conditional on the outcome occurring
+   *
+   * The outcome probabilities use the correct Poisson-binomial marginals
+   * (`atLeastOneProbability` = P(≥1 attack has it), `allProbability` = P(all do)),
+   * so they are always valid probabilities in [0,1].
+   *
+   * KNOWN LIMITATION (multi-attack): `damageRange.avg` is still aggregated from
+   * the combined PMF's `count`, which the convolution accumulates as an EXPECTED
+   * COUNT, so for N≥2 attacks it is the size-biased mean E[dmg·#label]/E[#label]
+   * rather than a clean conditional expectation. It is correct for a single
+   * attack.
    */
   snapshot(order) {
     const discovered = /* @__PURE__ */ new Set();
@@ -1080,10 +1176,8 @@ var _DiceQuery = class _DiceQuery {
       );
     }
     const rows = this.toLabeledTable(outcomes);
-    const totals = /* @__PURE__ */ new Map();
     const rangeAcc = /* @__PURE__ */ new Map();
     for (const ot of outcomes) {
-      totals.set(ot, 0);
       rangeAcc.set(ot, { sum: 0, mass: 0 });
     }
     for (const row of rows) {
@@ -1091,7 +1185,6 @@ var _DiceQuery = class _DiceQuery {
       for (const ot of outcomes) {
         const p = row[ot] || 0;
         if (p <= 0) continue;
-        totals.set(ot, (totals.get(ot) || 0) + p);
         const r = rangeAcc.get(ot);
         r.sum += dmg * p;
         r.mass += p;
@@ -1099,15 +1192,14 @@ var _DiceQuery = class _DiceQuery {
         if (r.max === void 0 || dmg > r.max) r.max = dmg;
       }
     }
+    const n = this.singles.length;
     const outcomeMap = /* @__PURE__ */ new Map();
     for (const ot of outcomes) {
-      const total = totals.get(ot) || 0;
       const r = rangeAcc.get(ot);
       const avg = r.mass > 0 ? r.sum / r.mass : 0;
       outcomeMap.set(ot, {
-        atLeastOneProbability: total,
-        allProbability: total,
-        // single aggregate PMF: same value
+        atLeastOneProbability: this.probAtLeastOne(ot),
+        allProbability: this.probAtLeastK(ot, n),
         damageRange: { min: r.min ?? 0, avg, max: r.max ?? 0 }
       });
     }
@@ -1292,11 +1384,11 @@ var _DiceQuery = class _DiceQuery {
     return [a, b, any, none];
   }
 };
-__publicField(_DiceQuery, "DEFAULT_OUTCOMES", [
+_DiceQuery.DEFAULT_OUTCOMES = [
   "hit",
   "crit",
   "missNone"
-]);
+];
 var DiceQuery = _DiceQuery;
 var pmfCache = new LRUCache(1e3);
 var _PMF = class _PMF {
@@ -1306,14 +1398,6 @@ var _PMF = class _PMF {
     this.normalized = normalized;
     this.identifier = identifier;
     this._preservedProvenance = _preservedProvenance;
-    // Cached computed values
-    __publicField(this, "_support");
-    __publicField(this, "_min");
-    __publicField(this, "_max");
-    __publicField(this, "_totalMass");
-    __publicField(this, "_mean");
-    __publicField(this, "_variance");
-    __publicField(this, "_stdev");
   }
   static empty(epsilon = EPS, identifier = "empty") {
     return new _PMF(/* @__PURE__ */ new Map(), epsilon, false, identifier);
@@ -1327,6 +1411,20 @@ var _PMF = class _PMF {
   static delta(value, epsilon = EPS) {
     return _PMF.fromMap(/* @__PURE__ */ new Map([[value, 1]]), epsilon);
   }
+  /**
+   * Point mass at damage 0 tagged with the canonical `missNone` outcome.
+   *
+   * Differs from {@link PMF.zero}, which labels its zero bin `miss` — the
+   * builder's attack-resolution vocabulary. This uses the `missNone`
+   * {@link OutcomeType} that the attribution charts and outcome stats key on,
+   * so it is the correct "clean miss / no damage" delta for provenance-aware
+   * mixtures feeding those consumers.
+   */
+  static missNone(epsilon = EPS) {
+    const m = /* @__PURE__ */ new Map();
+    m.set(0, { p: 1, count: { [MISS_NONE_OUTCOME]: 1 }, attr: {} });
+    return new _PMF(m, epsilon, false, "missNone");
+  }
   // This creates a single bin at value 0, but with weight 0.
   static emptyMass() {
     return _PMF.zero().scaleMass(0);
@@ -1353,8 +1451,14 @@ var _PMF = class _PMF {
     if (p === 1) return successPMF.scaleMass(1);
     const eps = successPMF.epsilon ?? failurePMF.epsilon;
     const id = `branch(${failurePMF.identifier}*${q.toFixed(6)} + ${successPMF.identifier}*${p.toFixed(6)})`;
-    const out = _PMF.empty(eps, id).addScaled(failurePMF, q).addScaled(successPMF, p);
-    return out;
+    const resultMap = /* @__PURE__ */ new Map();
+    for (const [damageValue, bin] of failurePMF.map) {
+      _PMF.mergeInto(resultMap, damageValue, _PMF.scaleBin(bin, q));
+    }
+    for (const [damageValue, bin] of successPMF.map) {
+      _PMF.mergeInto(resultMap, damageValue, _PMF.scaleBin(bin, p));
+    }
+    return new _PMF(resultMap, eps, false, id);
   }
   /**
    * withProbability()
@@ -1402,8 +1506,8 @@ var _PMF = class _PMF {
    * @param fallback PMF to apply when this PMF is *not* selected.
    * @returns A new PMF representing the weighted mixture of this PMF and the fallback.
    */
-  gate(p, zero) {
-    return _PMF.branch(this, zero, p);
+  gate(p, fallback) {
+    return _PMF.branch(this, fallback, p);
   }
   /**
    * PMF.exclusive()
@@ -1486,13 +1590,23 @@ var _PMF = class _PMF {
    *
    * @returns New PMF with attr field populated in each bin
    */
-  withAttribution() {
+  /**
+   * Returns true if this PMF already carries damage attribution metadata.
+   *
+   * Only the first positive-damage bin is inspected (parser-generated PMFs
+   * populate `attr` uniformly), so this is O(1) in practice.
+   */
+  hasAttribution() {
     for (const [damage, bin] of this.map) {
       if (damage !== 0 && bin.attr && Object.keys(bin.attr).length > 0) {
-        return this;
+        return true;
       }
       if (damage > 0) break;
     }
+    return false;
+  }
+  withAttribution() {
+    if (this.hasAttribution()) return this;
     const newMap = /* @__PURE__ */ new Map();
     for (const [damage, bin] of this.map) {
       const attr = {};
@@ -1609,7 +1723,7 @@ var _PMF = class _PMF {
    */
   replicate(n) {
     if (!Number.isInteger(n) || n <= 0) {
-      throw new Error("combineN(n): n must be a positive integer");
+      throw new Error("replicate(n): n must be a positive integer");
     }
     if (n === 1) return [this];
     return Array.from({ length: n }, () => this);
@@ -1641,7 +1755,6 @@ var _PMF = class _PMF {
     if (normalizationFactor === 0) return this;
     const normalizedMap = /* @__PURE__ */ new Map();
     for (const [damageValue, probabilityBin] of this.map) {
-      const normalizedProbability = probabilityBin.p / normalizationFactor;
       const normalizedCount = {};
       for (const labelKey in probabilityBin.count) {
         normalizedCount[labelKey] = probabilityBin.count[labelKey] / normalizationFactor;
@@ -1654,7 +1767,7 @@ var _PMF = class _PMF {
         }
       }
       normalizedMap.set(damageValue, {
-        p: normalizedProbability,
+        p: probabilityBin.p / normalizationFactor,
         count: normalizedCount,
         attr: normalizedAttributes
       });
@@ -1677,22 +1790,23 @@ var _PMF = class _PMF {
     for (const [damageValue, probabilityBin] of this.map) {
       const shouldKeep = probabilityBin.p >= eps || keepFinalBin && damageValue === maxKey;
       if (!shouldKeep) continue;
-      for (const labelKey in probabilityBin.count) {
-        if (Math.abs(probabilityBin.count[labelKey] || 0) < eps) {
-          delete probabilityBin.count[labelKey];
+      const cleanedBin = _PMF.cloneBin(probabilityBin);
+      for (const labelKey in cleanedBin.count) {
+        if (Math.abs(cleanedBin.count[labelKey] || 0) < eps) {
+          delete cleanedBin.count[labelKey];
         }
       }
-      if (probabilityBin.attr) {
-        for (const labelKey in probabilityBin.attr) {
-          if (Math.abs(probabilityBin.attr[labelKey] || 0) < eps) {
-            delete probabilityBin.attr[labelKey];
+      if (cleanedBin.attr) {
+        for (const labelKey in cleanedBin.attr) {
+          if (Math.abs(cleanedBin.attr[labelKey] || 0) < eps) {
+            delete cleanedBin.attr[labelKey];
           }
         }
-        if (Object.keys(probabilityBin.attr).length === 0) {
-          probabilityBin.attr = void 0;
+        if (Object.keys(cleanedBin.attr).length === 0) {
+          cleanedBin.attr = void 0;
         }
       }
-      compactedMap.set(damageValue, probabilityBin);
+      compactedMap.set(damageValue, cleanedBin);
     }
     return new _PMF(compactedMap, eps, this.normalized, this.identifier);
   }
@@ -1759,14 +1873,33 @@ var _PMF = class _PMF {
     }
     return this._stdev;
   }
+  /** Deep-copies a Bin, cloning its count and (optional) attr maps. */
+  static cloneBin(bin) {
+    return {
+      p: bin.p,
+      count: { ...bin.count },
+      attr: bin.attr ? { ...bin.attr } : void 0
+    };
+  }
+  /** Returns a new Bin with p, count, and attr all multiplied by `factor`. */
+  static scaleBin(bin, factor) {
+    const count = {};
+    for (const k in bin.count) {
+      count[k] = bin.count[k] * factor;
+    }
+    let attr;
+    if (bin.attr) {
+      attr = {};
+      for (const k in bin.attr) {
+        attr[k] = bin.attr[k] * factor;
+      }
+    }
+    return { p: bin.p * factor, count, attr };
+  }
   static mergeInto(destinationMap, damageValue, binToAdd) {
     const existingBin = destinationMap.get(damageValue);
     if (!existingBin) {
-      destinationMap.set(damageValue, {
-        p: binToAdd.p,
-        count: { ...binToAdd.count },
-        attr: binToAdd.attr ? { ...binToAdd.attr } : void 0
-      });
+      destinationMap.set(damageValue, _PMF.cloneBin(binToAdd));
       return;
     }
     existingBin.p += binToAdd.p;
@@ -1797,29 +1930,14 @@ var _PMF = class _PMF {
     if (probability === 0) return this;
     const resultMap = /* @__PURE__ */ new Map();
     for (const [dmg, bin] of this.map) {
-      resultMap.set(dmg, {
-        p: bin.p,
-        count: { ...bin.count },
-        attr: bin.attr ? { ...bin.attr } : void 0
-      });
+      resultMap.set(dmg, _PMF.cloneBin(bin));
     }
     for (const [damageValue, probabilityBin] of branch.map) {
-      const scaledCount = {};
-      for (const k in probabilityBin.count) {
-        scaledCount[k] = probability * probabilityBin.count[k];
-      }
-      let scaledAttributes;
-      if (probabilityBin.attr) {
-        scaledAttributes = {};
-        for (const k in probabilityBin.attr) {
-          scaledAttributes[k] = probability * probabilityBin.attr[k];
-        }
-      }
-      _PMF.mergeInto(resultMap, damageValue, {
-        p: probability * probabilityBin.p,
-        count: scaledCount,
-        attr: scaledAttributes
-      });
+      _PMF.mergeInto(
+        resultMap,
+        damageValue,
+        _PMF.scaleBin(probabilityBin, probability)
+      );
     }
     return new _PMF(
       resultMap,
@@ -1828,26 +1946,54 @@ var _PMF = class _PMF {
       `${this.identifier}+scaled(${branch.identifier},${probability})`
     );
   }
+  /**
+   * 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.
+   *
+   * 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.
+   *
+   * 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.
+   *
+   * @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 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));
+    }
+    return new _PMF(
+      newMap,
+      this.epsilon,
+      false,
+      `freq(${this.identifier},${freq})`
+    );
+  }
   scaleMass(factor) {
     if (factor === 1) return this;
     const scaledMap = /* @__PURE__ */ new Map();
     for (const [damageValue, probabilityBin] of this.map) {
-      const scaledCount = {};
-      for (const labelKey in probabilityBin.count) {
-        scaledCount[labelKey] = probabilityBin.count[labelKey] * factor;
-      }
-      let scaledAttributes;
-      if (probabilityBin.attr) {
-        scaledAttributes = {};
-        for (const labelKey in probabilityBin.attr) {
-          scaledAttributes[labelKey] = probabilityBin.attr[labelKey] * factor;
-        }
-      }
-      scaledMap.set(damageValue, {
-        p: probabilityBin.p * factor,
-        count: scaledCount,
-        attr: scaledAttributes
-      });
+      scaledMap.set(damageValue, _PMF.scaleBin(probabilityBin, factor));
     }
     return new _PMF(
       scaledMap,
@@ -1860,11 +2006,11 @@ var _PMF = class _PMF {
     const transformedMap = /* @__PURE__ */ new Map();
     for (const [originalDamage, probabilityBin] of this.map) {
       const transformedDamage = damageTransformFunction(originalDamage);
-      _PMF.mergeInto(transformedMap, transformedDamage, {
-        p: probabilityBin.p,
-        count: { ...probabilityBin.count },
-        attr: probabilityBin.attr ? { ...probabilityBin.attr } : void 0
-      });
+      _PMF.mergeInto(
+        transformedMap,
+        transformedDamage,
+        _PMF.cloneBin(probabilityBin)
+      );
     }
     return new _PMF(
       transformedMap,
@@ -1879,14 +2025,21 @@ var _PMF = class _PMF {
   }
   getPMFCombineCacheKey(p1, p2, eps, raw) {
     const [id1, id2] = [p1.identifier, p2.identifier].sort();
-    const fp = (x) => {
-      const m = x.mass().toFixed(12);
-      const n = x.map.size;
+    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).
+   */
+  fingerprint() {
+    if (this._fingerprint === void 0) {
       let faceSum = 0;
-      for (const k of x.map.keys()) faceSum += k;
-      return `${m}|${n}|${faceSum}`;
-    };
-    return `v4:${raw ? "RAW" : "N"}:${id1}+${id2}@${eps}|${fp(p1)}|${fp(p2)}`;
+      for (const k of this.map.keys()) faceSum += k;
+      this._fingerprint = `${this.mass().toFixed(12)}|${this.map.size}|${faceSum}`;
+    }
+    return this._fingerprint;
   }
   convolve(other, eps, raw = false) {
     const epsilon = eps ?? this.epsilon;
@@ -1899,25 +2052,34 @@ var _PMF = class _PMF {
     if (cached) return cached;
     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 p = aBin.p * bBin.p;
+        const bp = bBin.p;
         const dmg = aVal + bVal;
-        const count = {};
-        for (const k in aBin.count)
-          count[k] = (count[k] || 0) + aBin.count[k] * bBin.p;
+        let dest = combinedMap.get(dmg);
+        if (dest === void 0) {
+          dest = { p: 0, count: {} };
+          combinedMap.set(dmg, dest);
+        }
+        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)
-          count[k] = (count[k] || 0) + bBin.count[k] * aBin.p;
-        let attr;
-        if (aBin.attr || bBin.attr) {
-          attr = {};
-          if (aBin.attr)
-            for (const k in aBin.attr)
-              attr[k] = (attr[k] || 0) + aBin.attr[k] * bBin.p;
+          dc[k] = (dc[k] || 0) + bBin.count[k] * ap;
+        if (aAttr || bBin.attr) {
+          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)
-              attr[k] = (attr[k] || 0) + bBin.attr[k] * aBin.p;
+              da[k] = (da[k] || 0) + bBin.attr[k] * ap;
         }
-        _PMF.mergeInto(combinedMap, dmg, { p, count, attr });
       }
     }
     let result = new _PMF(
@@ -1928,10 +2090,10 @@ var _PMF = class _PMF {
     );
     const mExp = (raw ? A.mass() : 1) * (raw ? B.mass() : 1);
     const mGot = result.mass();
-    if (mExp !== 0 && Math.abs(mGot - mExp) > epsilon) {
+    if (mExp !== 0 && mGot !== 0 && Math.abs(mGot - mExp) > epsilon) {
       result = result.scaleMass(mExp / mGot);
     }
-    if (!raw && Math.abs(result.mass() - 1) > epsilon)
+    if (!raw && mGot !== 0 && Math.abs(result.mass() - 1) > epsilon)
       result = result.normalize();
     pmfCache?.set(cacheKey, result);
     return result;
@@ -1940,27 +2102,6 @@ var _PMF = class _PMF {
   combineRaw(other, eps) {
     return this.convolve(other, eps, true);
   }
-  // Collapse repeated identical PMFs using power() and return a sorted list
-  // Temporarily disabled for now. This was used for a performance optimization, but can lose data provenance.
-  //   private static collapseIdentical(pmfList: PMF[], eps: number): PMF[] {
-  //     const grouped = new Map<string, { pmf: PMF; count: number }>();
-  //     for (const pmf of pmfList) {
-  //       const id = pmf.identifier;
-  //       const g = grouped.get(id);
-  //       if (g) g.count++;
-  //       else grouped.set(id, { pmf, count: 1 });
-  //     }
-  //     if (grouped.size >= pmfList.length) return pmfList;
-  //     const collapsed: PMF[] = [];
-  //     for (const { pmf, count } of grouped.values()) {
-  //       collapsed.push(count > 1 ? pmf.power(count, eps) : pmf);
-  //     }
-  //     // Stable order for better cache locality
-  //     collapsed.sort((a, b) =>
-  //       a.identifier < b.identifier ? -1 : a.identifier > b.identifier ? 1 : 0
-  //     );
-  //     return collapsed;
-  //   }
   // Reduce a list of PMFs by left-folding convolve() with the given eps
   static reduceConvolveLeft(pmfList, eps) {
     let result = pmfList[0];
@@ -1984,12 +2125,23 @@ var _PMF = class _PMF {
     if (pmfList.length === 1) return pmfList[0];
     return _PMF.reduceConvolveLeft(pmfList, eps);
   }
+  /**
+   * Returns a plain, JSON-serializable representation of this PMF.
+   *
+   * Follows the standard `toJSON` contract, so `JSON.stringify(pmf)` produces
+   * the expected output (no double-encoding). Use {@link PMF.fromJSON} to
+   * reconstruct, or {@link PMF.toJSONString} if you need the string directly.
+   */
   toJSON() {
-    return JSON.stringify({
+    return {
       bins: [...this.map.entries()],
       normalized: this.normalized,
       identifier: this.identifier
-    });
+    };
+  }
+  /** Serializes this PMF to a JSON string (equivalent to `JSON.stringify(pmf)`). */
+  toJSONString() {
+    return JSON.stringify(this);
   }
   static fromJSON(jsonData) {
     return new _PMF(
@@ -2060,11 +2212,43 @@ var _PMF = class _PMF {
     }
     return new _PMF(prunedMap, epsRel, false, `prune(${this.identifier})`);
   }
-  /** NEW - REVIEW IF THESE ARE USEFUL OR DUPLCIATIVE?  */
   /** Probability mass at exactly x. */
   pAt(x) {
     return this.map.get(x)?.p ?? 0;
   }
+  /**
+   * P(any damage) — the mass on all non-zero outcomes, i.e. `1 - P(0)`.
+   * Assumes a miss is encoded as the damage-0 bin (the convention used across
+   * attack/save PMFs). The dual of {@link missProbability}.
+   */
+  hitProbability() {
+    return 1 - this.pAt(0);
+  }
+  /** P(no damage) — the mass at damage 0. The dual of {@link hitProbability}. */
+  missProbability() {
+    return this.pAt(0);
+  }
+  /**
+   * Coarsen the distribution into at most `maxBuckets` contiguous, equal-width
+   * damage buckets, aggregating probability mass (and `count`/`attr`
+   * provenance) into each bucket's start value. Returns this PMF unchanged when
+   * its integer support already fits within `maxBuckets`.
+   *
+   * This is a lossy display/downsampling transform (bucket start replaces the
+   * exact damage value) — use it for charting wide distributions, not for DPR
+   * math.
+   */
+  rebin(maxBuckets) {
+    if (!(maxBuckets > 0)) return this;
+    const support = this.support();
+    if (support.length === 0) return this;
+    const min = support[0];
+    const max = support[support.length - 1];
+    const range = max - min;
+    if (range + 1 <= maxBuckets) return this;
+    const binSize = Math.ceil((range + 1) / maxBuckets);
+    return this.mapDamage((d2) => min + Math.floor((d2 - min) / binSize) * binSize);
+  }
   /** Dense integer support from min..max (inclusive).
    * Useful for showing empty bars in charts.
    */
@@ -2140,11 +2324,60 @@ var _PMF = class _PMF {
     }
     return false;
   }
+  /**
+   * Split each damage value's probability mass across outcome labels, returning
+   * per-label maps of `damage value → probability mass attributable to that
+   * label`. Summing over labels at a given value recovers that value's `p`.
+   *
+   * Damage-bearing bins are split by `attr` weight (the share of damage each
+   * outcome contributed); the clean-miss bin at 0 is split by `count` weight
+   * (there is no damage to attribute). Attribution is computed on demand via
+   * {@link withAttribution} when absent, so builder-generated PMFs work too.
+   *
+   * This is the provenance core of the stacked damage-attribution chart — the
+   * caller only maps these series into its rendering format (colors, binning,
+   * axis labels).
+   */
+  attributionByValue() {
+    const src = this.hasAttribution() ? this : this.withAttribution();
+    const result = /* @__PURE__ */ new Map();
+    const add = (label, damage, mass) => {
+      if (!(mass > 0)) return;
+      let series = result.get(label);
+      if (!series) {
+        series = /* @__PURE__ */ new Map();
+        result.set(label, series);
+      }
+      series.set(damage, (series.get(damage) ?? 0) + mass);
+    };
+    for (const [damage, bin] of src.map) {
+      const p = bin.p || 0;
+      if (p <= 0) continue;
+      const isMissBin = damage === 0;
+      if (isMissBin) {
+        let totalCount = 0;
+        for (const k in bin.count) totalCount += bin.count[k] || 0;
+        if (totalCount > 0) {
+          const c = bin.count[MISS_NONE_OUTCOME] || 0;
+          add(MISS_NONE_OUTCOME, damage, c / totalCount * p);
+        }
+        continue;
+      }
+      let totalAttr = 0;
+      if (bin.attr) for (const k in bin.attr) totalAttr += bin.attr[k] || 0;
+      if (bin.attr && totalAttr > 0) {
+        for (const k in bin.attr) {
+          if (k === MISS_NONE_OUTCOME) continue;
+          add(k, damage, (bin.attr[k] || 0) / totalAttr * p);
+        }
+      }
+    }
+    return result;
+  }
   tailProbGE(t) {
     let s = 0;
-    for (const [x, rec] of this) {
-      const p = typeof rec === "number" ? rec : rec.p;
-      if (p > 0 && x >= t) s += p;
+    for (const [x, bin] of this) {
+      if (bin.p > 0 && x >= t) s += bin.p;
     }
     return s;
   }
@@ -2205,6 +2438,11 @@ var _PMF = class _PMF {
    *  - pAny: Probability that at least one success occurred
    */
   static firstSuccessWeights(pSuccess, pSpecial, n) {
+    if (!Number.isFinite(pSuccess) || !Number.isFinite(pSpecial) || pSuccess < 0 || pSuccess > 1 || pSpecial < 0 || pSpecial - pSuccess > EPS) {
+      throw new Error(
+        `firstSuccessWeights: require 0 <= pSpecial <= pSuccess <= 1 (got pSuccess=${pSuccess}, pSpecial=${pSpecial})`
+      );
+    }
     const pFail = 1 - pSuccess;
     const pFailAll = Math.pow(pFail, n);
     const pAny = 1 - pFailAll;
@@ -2220,13 +2458,12 @@ var _PMF = class _PMF {
     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();
-    for (const [v, rec] of this) {
-      if (Math.abs(rec.p) < eps) continue;
+    for (const [v, bin] of this) {
+      if (Math.abs(bin.p) < eps) continue;
       const u = round(f(v));
-      probs.set(u, (probs.get(u) ?? 0) + rec.p);
+      probs.set(u, (probs.get(u) ?? 0) + bin.p);
       if (preserveCounts) {
-        const rec2 = this.map.get(v);
-        const src = typeof rec2 === "number" ? void 0 : rec2?.count;
+        const src = bin.count;
         if (src) {
           const dest = counts.get(u) ?? {};
           for (const k in src) {
@@ -2279,17 +2516,15 @@ var _PMF = class _PMF {
   }
 };
 // Unique ID generator for anonymous PMFs to avoid cache key collisions
-__publicField(_PMF, "__anonIdCounter", 1);
+_PMF.__anonIdCounter = 1;
 var PMF = _PMF;
 
 // src/pmf/mixture.ts
 var Mixture = class _Mixture {
   constructor(eps = EPS) {
-    __publicField(this, "totals", /* @__PURE__ */ new Map());
+    this.totals = /* @__PURE__ */ new Map();
     // raw mass per outcome (pre-normalization)
-    __publicField(this, "labelMass", /* @__PURE__ */ new Map());
-    // raw mass per outcome per label
-    __publicField(this, "eps");
+    this.labelMass = /* @__PURE__ */ new Map();
     this.eps = Number.isFinite(eps) ? eps : EPS;
   }
   /** Remove all accumulated state. */
@@ -2313,9 +2548,8 @@ var Mixture = class _Mixture {
    */
   add(label, pmf, weight = 1) {
     if (!Number.isFinite(weight) || weight <= 0) return this;
-    for (const [v, binOrNumber] of pmf) {
-      const isNumber = typeof binOrNumber === "number";
-      const p = isNumber ? binOrNumber : binOrNumber?.p ?? 0;
+    for (const [v, bin] of pmf) {
+      const p = bin.p;
       if (p <= 0) continue;
       const add = weight * p;
       if (!Number.isFinite(add) || Math.abs(add) < this.eps) continue;
@@ -2403,14 +2637,28 @@ var Mixture = class _Mixture {
   }
 };
 
+// src/common/errors.ts
+var DiceParseError = class _DiceParseError extends Error {
+  constructor(message, options) {
+    super(message);
+    this.name = "DiceParseError";
+    this.expression = options?.expression;
+    this.cause = options?.cause;
+    Object.setPrototypeOf(this, _DiceParseError.prototype);
+  }
+};
+
 // src/parser/dice.ts
+var MAX_BINARY_OUTCOMES = 1e8;
 var Dice = class _Dice {
   constructor(x = 0) {
-    __publicField(this, "faces", {});
-    __publicField(this, "privateData", {});
-    __publicField(this, "outcomeData", {});
-    __publicField(this, "hasHitDistributionCalculated", false);
-    __publicField(this, "identifier");
+    this.faces = {};
+    this.privateData = {};
+    // Partial: the object starts empty and gains keys as outcomes are recorded,
+    // so the type must not claim every OutcomeType is present. (Previously typed
+    // as a full Record via an `as` cast, which lied about missing keys.)
+    this.outcomeData = {};
+    this.hasHitDistributionCalculated = false;
     if (x <= 0) return;
     for (let i = 1; i <= x; i++) {
       this.faces[i] = 1;
@@ -2461,27 +2709,27 @@ var Dice = class _Dice {
   // TODO this can be private later if we change how testing works
   calculateHitDistribution() {
     const hitValues = {};
+    const subtractedOutcomes = [
+      this.outcomeData.crit,
+      this.outcomeData.missNone,
+      this.outcomeData.missDamage,
+      this.outcomeData.saveHalf,
+      this.outcomeData.saveFail,
+      this.outcomeData.pc
+    ];
     for (const [face, totalCount] of Object.entries(this.faces)) {
       const numFace = Number(face);
       let hitCount = totalCount;
-      for (const outcomeType of [
-        "crit",
-        "missNone",
-        "missDamage",
-        "saveHalf",
-        "saveFail",
-        "pc"
-      ]) {
-        const distribution = this.getOutcomeDistribution(outcomeType);
-        if (distribution && distribution[numFace]) {
-          hitCount -= distribution[numFace];
+      for (const distribution of subtractedOutcomes) {
+        const outcomeCount = distribution?.[numFace];
+        if (outcomeCount) {
+          hitCount -= outcomeCount;
         }
       }
       if (numFace === 0) {
         hitCount = 0;
       }
       if (hitCount < 0) {
-        console.error("hitCount is <=0?", face, totalCount, hitCount);
         hitCount = 0;
       }
       hitValues[numFace] = hitCount;
@@ -2500,13 +2748,18 @@ var Dice = class _Dice {
     const result = diceConstructor ? diceConstructor() : new _Dice();
     const isScalar = typeof other === "number";
     const keys1 = this.keys();
+    const keys2 = isScalar ? [] : other.keys();
+    if (!isScalar && keys1.length * keys2.length > MAX_BINARY_OUTCOMES) {
+      throw new DiceParseError(
+        `Dice operation over ${keys1.length}\xD7${keys2.length} face pairs exceeds the maximum of ${MAX_BINARY_OUTCOMES}`
+      );
+    }
     for (const key1 of keys1) {
       const value1 = this.faces[key1];
       if (isScalar) {
         const resultKey = op(key1, other);
         result.increment(resultKey, value1);
       } else {
-        const keys2 = other.keys();
         for (const key2 of keys2) {
           const value2 = other.faces[key2];
           const resultKey = op(key1, key2);
@@ -2528,7 +2781,7 @@ var Dice = class _Dice {
     result.outcomeData = { ...this.outcomeData };
     return result;
   }
-  // PUBLIC FUNTIONS
+  // PUBLIC FUNCTIONS
   getFaceEntries() {
     return Object.entries(this.faces).map(([k, v]) => [Number(k), v]);
   }
@@ -2658,10 +2911,12 @@ var Dice = class _Dice {
   }
   reroll(toReroll) {
     const rerollDice = typeof toReroll === "number" ? _Dice.scalar(toReroll) : toReroll;
-    const removed = this.removeFaces(rerollDice.keys());
+    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 = rerollDice.keys().includes(face);
+      const wasRerolled = rerollSet.has(face);
       result = result.combine(removed);
       if (wasRerolled) {
         result = result.combine(this);
@@ -2729,17 +2984,10 @@ var Dice = class _Dice {
     const missDistro = this.getOutcomeDistribution("missDamage") || {};
     const saveDistro = this.getOutcomeDistribution("saveHalf") || {};
     const pcDistro = this.getOutcomeDistribution("pc") || {};
-    let isSaveHalf = false;
-    for (const halfDamage of Object.keys(saveDistro).map(Number)) {
-      const fullDamage = halfDamage * 2;
-      if (fullDamage > 0 && hitDistro[fullDamage]) {
-        isSaveHalf = true;
-        break;
-      }
-    }
+    const isSaveHalf = Object.keys(saveDistro).length > 0;
     const isDCCheck = this.privateData.isDCCheck === true;
     const clampNonNeg = (x) => x < 0 && x > -1e-15 ? 0 : x;
-    for (const [faceStr, faceCountRaw] of Object.entries(this.getFaceMap())) {
+    for (const [faceStr, faceCountRaw] of Object.entries(this.faces)) {
       const face = Number(faceStr);
       const faceCount = Number(faceCountRaw);
       if (faceCount <= 0) continue;
@@ -2813,14 +3061,14 @@ var Dice = class _Dice {
       map.set(face, bin);
     }
     const identifier = this.identifier || "ERROR";
-    if (identifier === "ERROR") {
-      console.error("Dice identifier is undefined", this);
-    }
     return new PMF(map, numEpsilon, true, identifier).compact(numEpsilon, true);
   }
 };
 
 // src/parser/parser.ts
+var MAX_DIE_SIDES = 1e6;
+var MAX_DICE_COUNT = 1e4;
+var MAX_KEEP_OUTCOMES = 1e6;
 var parseCache = new LRUCache(1e3);
 function parse(expression, n = 0) {
   const cleaned = expression.replace(/ /g, "").toLowerCase();
@@ -2830,20 +3078,21 @@ function parse(expression, n = 0) {
     if (cached) return cached;
   }
   const chars = [...cleaned];
-  let result = void 0;
+  let result;
   try {
     result = parseExpression(chars, n);
   } catch (error) {
-    throw new Error(`Cannot parse dice expression [${expression}]: ${error}`);
-  }
-  try {
-    result.privateData = result.privateData || {};
-    result.identifier = cleaned;
-  } catch {
+    throw new DiceParseError(
+      `Cannot parse dice expression [${expression}]: ${error}`,
+      { expression, cause: error }
+    );
   }
+  result.privateData = result.privateData || {};
+  result.identifier = cleaned;
   if (chars.length > 0) {
-    throw new Error(
-      `Unexpected token: '${chars[0]}' from expression: '${expression}'`
+    throw new DiceParseError(
+      `Unexpected token: '${chars[0]}' from expression: '${expression}'`,
+      { expression }
     );
   }
   const resultPMF = result.toPMF(-1);
@@ -2997,7 +3246,7 @@ function multiplyDiceByDice(d1, d2) {
   if (typeof d1 === "number") d1 = Dice.scalar(d1);
   if (typeof d2 === "number") d2 = Dice.scalar(d2);
   const result = new Dice();
-  const faces = {};
+  const faces = /* @__PURE__ */ new Map();
   let normalizationFactor = 1;
   for (const key of d1.keys()) {
     let face;
@@ -3005,17 +3254,21 @@ function multiplyDiceByDice(d1, d2) {
       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();
-    faces[key] = face;
+    faces.set(key, face);
   }
-  for (const key of Object.keys(faces)) {
-    const k = parseFloat(key);
-    const face = faces[k];
+  for (const [k, face] of faces) {
     const count = d1.get(k);
     result.combineInPlace(
       face.normalize(count * normalizationFactor / face.total())
@@ -3025,6 +3278,11 @@ function multiplyDiceByDice(d1, d2) {
   return result;
 }
 function multiplyDice(n, d2) {
+  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);
   if (n === 1) return d2;
   const half = Math.floor(n / 2);
@@ -3107,9 +3365,14 @@ function parseDice(s, n) {
     return;
   }
   const sides = parseNumber(s, n);
+  if (sides > MAX_DIE_SIDES) {
+    throw new DiceParseError(
+      `Die size ${sides} exceeds the maximum of ${MAX_DIE_SIDES}`
+    );
+  }
   let result = new Dice(sides);
   if (rerollOne) {
-    result = result.deleteFace(1).combine(result);
+    result = result.reroll(1);
   }
   return result;
 }
@@ -3321,15 +3584,14 @@ var configComplexityScore = (config) => {
 };
 var RollBuilder = class _RollBuilder {
   constructor(countOrConfigs = 1) {
-    __publicField(this, "subRollConfigs");
     // --- Dice Shortcut Methods ---
-    __publicField(this, "d4", () => this.d(4));
-    __publicField(this, "d6", () => this.d(6));
-    __publicField(this, "d8", () => this.d(8));
-    __publicField(this, "d10", () => this.d(10));
-    __publicField(this, "d12", () => this.d(12));
-    __publicField(this, "d20", () => this.d(20));
-    __publicField(this, "d100", () => this.d(100));
+    this.d4 = () => this.d(4);
+    this.d6 = () => this.d(6);
+    this.d8 = () => this.d(8);
+    this.d10 = () => this.d(10);
+    this.d12 = () => this.d(12);
+    this.d20 = () => this.d(20);
+    this.d100 = () => this.d(100);
     if (typeof countOrConfigs === "number") {
       const count = countOrConfigs;
       if (isNaN(count)) throw new Error("Invalid NaN value for count");
@@ -3836,10 +4098,10 @@ var RollBuilder = class _RollBuilder {
   }
   // These methods are implemented via prototype augmentation in ac.ts and dc.ts
   // They are declared here to provide proper TypeScript types
-  ac(targetAC) {
+  ac(_targetAC) {
     throw new Error("ac() should be implemented via prototype augmentation");
   }
-  dc(saveDC) {
+  dc(_saveDC) {
     throw new Error("dc() should be implemented via prototype augmentation");
   }
 };
@@ -3956,7 +4218,6 @@ var AlwaysHitBuilder = class _AlwaysHitBuilder extends RollBuilder {
       );
     }
     super(baseRoll.getSubRollConfigs());
-    __publicField(this, "attackConfig");
     if (attackConfig) {
       this.attackConfig = { ...attackConfig };
     } else {
@@ -4006,8 +4267,6 @@ var AlwaysCritBuilder = class _AlwaysCritBuilder extends RollBuilder {
       );
     }
     super(baseRoll.getSubRollConfigs());
-    __publicField(this, "attackConfig");
-    __publicField(this, "fromAlwaysHit");
     if (attackConfig) {
       this.attackConfig = { ...attackConfig };
     } else {
@@ -4049,8 +4308,6 @@ var AlwaysCritBuilder = class _AlwaysCritBuilder extends RollBuilder {
 var ParsedRollBuilder = class _ParsedRollBuilder extends RollBuilder {
   constructor(expression) {
     super([]);
-    __publicField(this, "cachedPMF");
-    __publicField(this, "originalExpression");
     this.originalExpression = expression;
     this.cachedPMF = parse(expression, 0);
   }
@@ -4300,7 +4557,11 @@ function astFromRollConfigs(configs) {
         if (trials === 1) {
           node = perTrial;
         } else {
-          node = { type: "maxOf", count: trials, child: perTrial };
+          node = {
+            type: "maxOf",
+            count: trials,
+            child: perTrial
+          };
         }
       } else if (trials === baseCount) {
         const base = { type: "sum", count: trials, child: node };
@@ -4505,7 +4766,7 @@ function computeMaxOfPMF(pmf, count, eps = defaultEps) {
   const support = pmf.support();
   const out = /* @__PURE__ */ new Map();
   if (count <= 6 && support.length <= 20) {
-    let dfs = function(rollsLeft, currentMax, probability) {
+    let dfs2 = function(rollsLeft, currentMax, probability) {
       if (rollsLeft === 0) {
         out.set(currentMax, (out.get(currentMax) || 0) + probability);
         return;
@@ -4514,17 +4775,18 @@ function computeMaxOfPMF(pmf, count, eps = defaultEps) {
         const p = pmf.pAt(value);
         if (p > 0) {
           const newMax = Math.max(currentMax, value);
-          dfs(rollsLeft - 1, newMax, probability * p);
+          dfs2(rollsLeft - 1, newMax, probability * p);
         }
       }
     };
-    dfs(count, -Infinity, 1);
+    dfs2(count, -Infinity, 1);
   } else {
     const sortedSupport = [...support].sort((a, b) => a - b);
+    let runningCdf = 0;
     for (const value of sortedSupport) {
-      const cdfAtValue = pmf.cdfAt(value);
-      const cdfAtValueMinus1 = value > sortedSupport[0] ? pmf.cdfAt(value - 1) : 0;
-      const probMax = Math.pow(cdfAtValue, count) - Math.pow(cdfAtValueMinus1, count);
+      const prevCdf = runningCdf;
+      runningCdf += pmf.pAt(value);
+      const probMax = Math.pow(runningCdf, count) - Math.pow(prevCdf, count);
       if (probMax > eps) {
         out.set(value, probMax);
       }
@@ -4551,7 +4813,8 @@ function keepSumPMF(single, total, keep, highest, eps = defaultEps) {
     }
   }
   let state = /* @__PURE__ */ new Map();
-  const keyOf = (used, r) => `${used}|${r}`;
+  const stride = total + 1;
+  const keyOf = (used, r) => used * stride + r;
   state.set(keyOf(0, total), /* @__PURE__ */ new Map([[0, 1]]));
   const valuesDesc = highest ? [...sortedSupport].sort((a, b) => b - a) : [...sortedSupport].sort((a, b) => a - b);
   const binomPMF = (r, p) => {
@@ -4600,9 +4863,8 @@ function keepSumPMF(single, total, keep, highest, eps = defaultEps) {
     const pCond = Math.min(1, p / q);
     const next = /* @__PURE__ */ new Map();
     for (const [k, m] of state) {
-      const [usedStr, rStr] = k.split("|");
-      const used = parseInt(usedStr, 10);
-      const r = parseInt(rStr, 10);
+      const used = Math.floor(k / stride);
+      const r = k - used * stride;
       if (r === 0) {
         const destKey = keyOf(used, 0);
         const dest = next.get(destKey) ?? /* @__PURE__ */ new Map();
@@ -4773,8 +5035,8 @@ var AttackBuilder = class _AttackBuilder {
       const bonusPMF2 = bonusDicePMFs2.length ? PMF.convolveMany(bonusDicePMFs2, eps) : PMF.delta(0, eps);
       let pcrit2 = 0;
       let pmiss2 = 0;
-      for (const [r, rec] of d202) {
-        const pr = typeof rec === "number" ? rec : rec.p;
+      for (const [r, bin] of d202) {
+        const pr = bin.p;
         if (pr <= 0) continue;
         if (r === 1) {
           pmiss2 += pr;
@@ -4789,8 +5051,8 @@ var AttackBuilder = class _AttackBuilder {
     }
     if (check instanceof AlwaysHitBuilder) {
       let pCrit = 0;
-      for (const [r, rec] of d202) {
-        const pr = typeof rec === "number" ? rec : rec.p;
+      for (const [r, bin] of d202) {
+        const pr = bin.p;
         if (pr <= 0) continue;
         if (r >= critThreshold) pCrit += pr;
       }
@@ -4805,8 +5067,8 @@ var AttackBuilder = class _AttackBuilder {
     let pcrit = 0;
     let phit = 0;
     let pmiss = 0;
-    for (const [r, rec] of d202) {
-      const pr = typeof rec === "number" ? rec : rec.p;
+    for (const [r, bin] of d202) {
+      const pr = bin.p;
       if (pr <= 0) continue;
       if (r === 1) {
         pmiss += pr;
@@ -4886,7 +5148,6 @@ var AttackBuilder = class _AttackBuilder {
 var ACBuilder = class _ACBuilder extends RollBuilder {
   constructor(baseRoll, ac, attackConfig) {
     super(baseRoll.getSubRollConfigs());
-    __publicField(this, "attackConfig");
     if (attackConfig) {
       this.attackConfig = { ...attackConfig, ac };
     } else {
@@ -5015,8 +5276,8 @@ function resolveProbabilities(check) {
   const baseReroll = check.baseReroll;
   const die = d20RollPMF(d20Type, baseReroll > 0);
   const faceP = /* @__PURE__ */ new Map();
-  for (const [r, rec] of die) {
-    const pr = typeof rec === "number" ? rec : rec.p;
+  for (const [r, bin] of die) {
+    const pr = bin.p;
     if (pr > 0) faceP.set(r, pr);
   }
   const eps = 0;
@@ -5037,7 +5298,6 @@ function resolveProbabilities(check) {
 var DCBuilder = class _DCBuilder extends RollBuilder {
   constructor(baseRoll, saveConfig) {
     super(baseRoll.getSubRollConfigs());
-    __publicField(this, "saveConfig");
     this.saveConfig = saveConfig ? { ...saveConfig } : { dc: 10 };
   }
   dc(saveDC) {
@@ -5086,8 +5346,8 @@ var DCBuilder = class _DCBuilder extends RollBuilder {
     );
     const bonusPMF = bonusDicePMFs.length ? PMF.convolveMany(bonusDicePMFs, eps) : PMF.delta(0, eps);
     let psuccess = 0;
-    for (const [r, rec] of d202) {
-      const pr = typeof rec === "number" ? rec : rec.p;
+    for (const [r, bin] of d202) {
+      const pr = bin.p;
       if (pr <= 0) continue;
       const need = saveDC - staticMod - r;
       psuccess += pr * bonusPMF.tailProbGE(need);