@yipe/dice 0.2.0 → 0.2.1

package/dist/builder/index.js

@@ -0,0 +1,3447 @@
+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());
+  }
+  get(key) {
+    const value = this.cache.get(key);
+    if (value === void 0) return void 0;
+    this.cache.delete(key);
+    this.cache.set(key, value);
+    return value;
+  }
+  delete(key) {
+    this.cache.delete(key);
+  }
+  set(key, value) {
+    if (this.cache.size >= this.maxSize && !this.cache.has(key)) {
+      const oldestKey = this.cache.keys().next().value;
+      this.cache.delete(oldestKey);
+    }
+    this.cache.delete(key);
+    this.cache.set(key, value);
+    return this;
+  }
+  clear() {
+    this.cache.clear();
+  }
+  get size() {
+    return this.cache.size;
+  }
+  has(key) {
+    return this.cache.has(key);
+  }
+  keys() {
+    return this.cache.keys();
+  }
+  values() {
+    return this.cache.values();
+  }
+};
+
+// src/common/types.ts
+var EPS = 1e-12;
+
+// src/pmf/query.ts
+var _DiceQuery = class _DiceQuery {
+  constructor(singles, combined, eps = EPS) {
+    __publicField(this, "singles");
+    __publicField(this, "combined");
+    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();
+  }
+  /**
+   * Returns the expected damage across all possible outcomes.
+   *
+   * Example: `query.mean()` → 12.5
+   * Use case: "What's my average damage per round?"
+   */
+  mean() {
+    let totalSum = 0;
+    for (const [damageValue, probabilityBin] of this.combined) {
+      totalSum += damageValue * probabilityBin.p;
+    }
+    return totalSum;
+  }
+  /**
+   * Returns the variance of the damage distribution.
+   *
+   * Example: `query.variance()` → 45.2
+   * Use case: "How much does my damage vary from the average?"
+   * 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;
+    }
+    return varianceSum;
+  }
+  /**
+   * Returns the standard deviation of the damage distribution.
+   *
+   * Example: `query.stdev()` → 6.7
+   * Use case: "What's the typical spread around my average damage?"
+   * Used to determine how consistent the damage is.
+   */
+  stddev() {
+    return Math.sqrt(this.variance());
+  }
+  /**
+   * Returns the Cumulative Distribution Function.
+   */
+  cdf(x) {
+    return this.probTotalAtMost(x);
+  }
+  /**
+   * Returns the probability of dealing X damage or less.
+   * In statistics, this is called the cumulative distribution function (CDF).
+   * Example: `query.cdf(20)` → 0.75
+   * Use case: "What's the chance I deal 20 damage or less?"
+   */
+  probTotalAtMost(x) {
+    let cumulativeProbability = 0;
+    for (const [damageValue, probabilityBin] of this.combined) {
+      if (damageValue <= x) {
+        cumulativeProbability += probabilityBin.p;
+      }
+    }
+    return cumulativeProbability;
+  }
+  /**
+   * Returns the Complementary Cumulative Distribution Function.
+   */
+  ccdf(x) {
+    return this.probTotalAtLeast(x);
+  }
+  /**
+   * Returns the probability of dealing at least X damage.
+   *
+   * Example: `query.probTotalAtLeast(25)` → 0.35
+   * Use case: "What's the chance I deal at least 25 damage to finish the enemy?"
+   */
+  probTotalAtLeast(threshold) {
+    let probabilitySum = 0;
+    for (const [damageValue, probabilityBin] of this.combined) {
+      if (damageValue >= threshold) {
+        probabilitySum += probabilityBin.p;
+      }
+    }
+    return probabilitySum;
+  }
+  /**
+   * Returns damage values at specific percentiles.
+   *
+   * 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];
+    });
+  }
+  /**
+   * Returns the minimum possible damage.
+   *
+   * Example: `query.min()` → 0
+   * Use case: "What's the worst-case damage if everything misses?"
+   */
+  min() {
+    return this.combined.min();
+  }
+  /**
+   * Returns the maximum possible damage.
+   *
+   * Example: `query.max()` → 56
+   * Use case: "What's the best-case damage if everything crits and rolls max?"
+   */
+  max() {
+    return this.combined.max();
+  }
+  singleProb(diceIndex, label) {
+    let probabilitySum = 0;
+    for (const [, probabilityBin] of this.singles[diceIndex]) {
+      probabilitySum += probabilityBin.count[label] || 0;
+    }
+    return probabilitySum;
+  }
+  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;
+    let tail = 0;
+    for (let i = k; i <= n; i++) {
+      tail += this.probExactlyK(L, i);
+    }
+    if (tail < 0) return 0;
+    if (tail > 1) return 1;
+    return tail;
+  }
+  /**
+   * Returns the probability that at least one attack has the specified outcome(s).
+   * - This is the complement of probAtMostK(labels, 0)
+   *
+   * Examples:
+   * - `query.probAtLeastOne('hit')` → 0.88 (88% chance at least one attack hits)
+   * - `query.probAtLeastOne(['hit', 'crit'])` → 0.96 (96% chance at least one succeeds)
+   *
+   * Use cases:
+   * - "What's the chance at least one of my attacks connects?"
+   *
+   * 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.
+   */
+  probAtLeastOne(labels) {
+    if (typeof labels === "string") {
+      labels = [labels];
+    }
+    let productOfNonOccurrence = 1;
+    for (let diceIndex = 0; diceIndex < this.singles.length; diceIndex++) {
+      let combinedProbability = 0;
+      for (const label of labels) {
+        combinedProbability += this.singleProb(diceIndex, label);
+      }
+      productOfNonOccurrence *= 1 - combinedProbability;
+    }
+    return 1 - productOfNonOccurrence;
+  }
+  /**
+   * Computes binomial probabilities for exactly 0, 1, 2, ..., maxK occurrences of a label.
+   *
+   * Uses dynamic programming to efficiently calculate the probability distribution
+   * of how many attacks will have the specified outcome, accounting for different
+   * success probabilities across individual attacks.
+   *
+   * Example: For 3 attacks with 50% hit chance each, returns:
+   * [0.125, 0.375, 0.375, 0.125] = [P(0 hits), P(1 hit), P(2 hits), P(3 hits)]
+   *
+   * @param label - The outcome type to count
+   * @param maxK - Maximum number of occurrences to calculate (usually number of attacks)
+   * @returns Array where index K contains P(exactly K attacks have the label)
+   */
+  computeBinomialProbabilities(label, maxK) {
+    const individualProbabilities = this.singles.map(
+      (_, diceIndex) => this.singleProb(diceIndex, label)
+    );
+    const binomialProbs = new Array(maxK + 1).fill(0);
+    binomialProbs[0] = 1;
+    for (const singleProbability of individualProbabilities) {
+      for (let outcomeCount = maxK; outcomeCount >= 1; outcomeCount--) {
+        binomialProbs[outcomeCount] = binomialProbs[outcomeCount] * (1 - singleProbability) + binomialProbs[outcomeCount - 1] * singleProbability;
+      }
+      binomialProbs[0] *= 1 - singleProbability;
+    }
+    return binomialProbs;
+  }
+  /**
+   * Returns the probability that exactly K attacks result in the specified outcome(s).
+   *
+   * Single label examples:
+   * - probExactlyK('hit', 2) = probability exactly 2 attacks hit
+   * - probExactlyK('crit', 1) = probability exactly 1 attack crits
+   * - probExactlyK('crit', 0) = probability no attacks crit
+   *
+   * 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
+   *
+   * Use cases:
+   * - "What's the chance exactly one of my attacks hits?"
+   * - "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.
+   */
+  probExactlyK(labels, k) {
+    if (typeof labels === "string") {
+      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];
+  }
+  /**
+   * Returns the probability that AT MOST K attacks result in the specified outcome(s).
+   *
+   * 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
+   *
+   * Array examples:
+   * - probAtMostK(['hit', 'crit'], 1) = probability at most 1 attack succeeds
+   * - probAtMostK(['hit', 'crit'], 0) = probability no attacks succeed (all miss)
+   *
+   * Use cases:
+   * - "What's the chance that at most one attack hits?" (rest miss)
+   * - "How likely am I to have mostly failures?" (at most 1 success)
+   * - "What's the probability of a really bad turn?" (at most 0 successes)
+   *
+   */
+  probAtMostK(labels, k) {
+    if (typeof labels === "string") {
+      const probabilityArray = this.computeBinomialProbabilities(labels, k);
+      let cumulativeSum2 = 0;
+      for (let outcomeCount = 0; outcomeCount <= k; outcomeCount++) {
+        cumulativeSum2 += probabilityArray[outcomeCount];
+      }
+      return cumulativeSum2;
+    }
+    let cumulativeSum = 0;
+    for (let outcomeCount = 0; outcomeCount <= k; outcomeCount++) {
+      cumulativeSum += this.probExactlyK(labels, outcomeCount);
+    }
+    return cumulativeSum;
+  }
+  /**
+   * Returns the expected damage attributed to specific outcome types.
+   *
+   * Single label examples:
+   * - expectedDamageFrom('hit') = expected damage from hit components
+   * - expectedDamageFrom('crit') = expected damage from crit components
+   *
+   * Array examples:
+   * - expectedDamageFrom(['hit', 'crit']) = expected damage from any success
+   * - expectedDamageFrom(['missDamage', 'missNone']) = expected damage from misses
+   *
+   * Use cases:
+   * - "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)?"
+   */
+  expectedDamageFrom(labels) {
+    const wanted = Array.isArray(labels) ? labels : [labels];
+    let total = 0;
+    for (const single of this.singles) {
+      for (const [dmg, bin] of single) {
+        let p = 0;
+        for (const label of wanted) p += bin.count[label] ?? 0;
+        total += dmg * p;
+      }
+    }
+    return total;
+  }
+  /**
+   * Returns damage statistics for scenarios where AT LEAST ONE attack results in
+   * the specified outcome(s).
+   *
+   * This method answers "What happens when things go reasonably well?" rather than
+   * "What's the theoretical maximum?" It includes mixed scenarios which are more
+   * common and tactically relevant than pure scenarios.
+   *
+   * Single label examples:
+   * - damageStatsFrom('hit') = damage range when at least one attack hits
+   * - damageStatsFrom('crit') = damage range when at least one attack crits
+   *
+   * Array examples:
+   * - damageStatsFrom(['hit', 'crit']) = damage range when at least one attack succeeds
+   * - damageStatsFrom(['miss', '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?"
+   * - "When planning to kill a 60 HP enemy, what's my damage range on successful turns?"
+   * - "Should I use this risky spell if it has good damage when it works?"
+   * - "What's my damage potential when something goes right?" (vs pure failure)
+   *
+   * Combat Planning Examples:
+   * - 4 attacks with 90% hit chance: "96% of the time you'll do 25-150 damage, avg 52"
+   *   (Much more useful than "You average 50 damage including complete misses")
+   * - Risk assessment: "80% of successful turns do 40-80 damage, but 20% do 80-150"
+   * - Resource management: "If I hit anything, I'll likely finish this enemy"
+   *
+   * Statistical Note:
+   * 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.
+   *
+   * @example
+   * // High-level tactical planning
+   * const successStats = query.damageStatsFrom('hit')
+   * const successChance = query.probAtLeastOne('hit')
+   * console.log(`${(successChance*100).toFixed(1)}% chance to do ${successStats.min}-${successStats.max} damage`)
+   */
+  damageStatsFrom(labels) {
+    const labelArray = typeof labels === "string" ? [labels] : labels;
+    let minDamage = Infinity;
+    let maxDamage = -Infinity;
+    let totalDamage = 0;
+    let totalCount = 0;
+    for (const [damage, probabilityBin] of this.combined) {
+      let binHasAnyLabel = false;
+      let binContribution = 0;
+      for (const label of labelArray) {
+        const count = probabilityBin.count[label];
+        if (count && count > 0) {
+          binHasAnyLabel = true;
+          binContribution += count;
+        }
+      }
+      if (damage > 0 && binHasAnyLabel) {
+        minDamage = Math.min(minDamage, damage);
+        maxDamage = Math.max(maxDamage, damage);
+        const weightToUse = labelArray.length === 1 ? binContribution : probabilityBin.p;
+        totalDamage += damage * weightToUse;
+        totalCount += weightToUse;
+      }
+    }
+    return {
+      min: minDamage === Infinity ? 0 : minDamage,
+      max: maxDamage === -Infinity ? 0 : maxDamage,
+      avg: totalCount > 0 ? totalDamage / totalCount : 0,
+      count: totalCount
+    };
+  }
+  /**
+   * Returns damage statistics for scenarios where ALL attacks result in the specified
+   * outcome, calculated by leveraging the pure partition of singles.
+   *
+   * This method answers "What's the theoretical best/worst case?" and "What are the
+   * clean mathematical boundaries?" It provides pure scenarios without mixing outcomes.
+   *
+   * Examples:
+   * - combinedDamageStats('hit') = damage range when all attacks hit (none crit, none miss)
+   * - combinedDamageStats('crit') = damage range when all attacks crit (none just hit)
+   *
+   * UI and Display Use Cases:
+   * - Statistics panels showing "MAX Hit Damage" (users expect pure hits, not mixed)
+   * - "Best case scenario" vs "worst case scenario" analysis
+   * - Mathematical verification: "Does our hit damage calculation match manual math?"
+   * - Clean damage type attribution: "How much comes from base hits vs crits?"
+   *
+   * Design and Balance Use Cases:
+   * - Game designers: "What's the damage ceiling if someone gets lucky?"
+   * - Character optimization: "What's my absolute maximum potential?"
+   * - Ability comparison: "Which build has higher crit ceiling?"
+   * - Minimum guaranteed damage: "What's the worst I can do if everything hits?"
+   *
+   * Mathematical Use Cases:
+   * - Validating complex calculations against simple manual math
+   * - Understanding damage component contributions in isolation
+   * - Separating luck (crit variance) from consistency (hit variance)
+   * - Building intuition about damage sources
+   *
+   * When to Use This vs damageStatsFrom():
+   * - Use THIS for: UI max/min displays, theoretical limits, clean comparisons
+   * - Use damageStatsFrom() for: tactical planning, realistic expectations, mixed scenarios
+   *
+   * Statistical Note:
+   * Pure scenarios (all hits, all crits) are rare but represent clear mathematical
+   * boundaries. These stats help understand the "shape" of your damage potential.
+   *
+   * @example
+   * // UI display logic
+   * const pureHitMax = query.combinedDamageStats('hit').max    // Clean "MAX Hit Damage: 90"
+   * const pureCritMax = query.combinedDamageStats('crit').max  // Clean "MAX Crit Damage: 168"
+   *
+   * // vs tactical planning (use damageStatsFrom instead)
+   * const realisticRange = query.damageStatsFrom('hit')  // Includes mixed scenarios
+   */
+  combinedDamageStats(targetLabel) {
+    const singleStats = this.singles.map(
+      (single) => new _DiceQuery([single]).damageStatsFrom(targetLabel)
+    );
+    if (singleStats.some((stats) => stats.count === 0)) {
+      return { min: 0, max: 0, avg: 0, count: 0 };
+    }
+    const combinedMin = singleStats.reduce((sum, stats) => sum + stats.min, 0);
+    const combinedMax = singleStats.reduce((sum, stats) => sum + stats.max, 0);
+    const combinedAvg = singleStats.reduce((sum, stats) => sum + stats.avg, 0);
+    const combinedProb = singleStats.reduce(
+      (product, stats) => product * stats.count,
+      1
+    );
+    return {
+      min: combinedMin,
+      max: combinedMax,
+      avg: combinedAvg,
+      count: combinedProb
+    };
+  }
+  /**
+   * Returns the probability that a result includes ANY of the specified labels.
+   *
+   * Examples:
+   * - `query.probabilityOf('hit')` → 0.88 (probability at least one hit occurs)
+   * - `query.probabilityOf(['hit', 'crit'])` → 0.96 (probability of any success)
+   *
+   * 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?"
+   */
+  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;
+  }
+  /**
+   * Returns the probability of missing (any type of miss).
+   *
+   * Example: `query.missChance()` → 0.04
+   * Use case: "What's the chance I miss completely this turn?"
+   */
+  missChance() {
+    return this.probabilityOf(["missDamage", "missNone"]);
+  }
+  /**
+   * Returns data formatted for plotting damage probability distribution.
+   *
+   * Example: `query.toChartSeries()` → [{x: 0, y: 0.04}, {x: 6, y: 0.1}, ...]
+   * Use case: "I want to visualize my damage distribution in a chart."
+   */
+  toChartSeries() {
+    return this.combined.support().map((damageValue) => ({
+      x: damageValue,
+      y: this.combined.map.get(damageValue).p
+    }));
+  }
+  /**
+   * Returns tabular data showing damage values and their probability breakdowns.
+   *
+   * Example: `query.toLabeledTable(['hit', 'crit'])` →
+   *   [{damage: 6, total: 0.01, hit: 0.008, crit: 0}, ...]
+   *
+   * Use case: "I want to see exactly how hit/crit probabilities contribute to each damage value."
+   */
+  toLabeledTable(labels = []) {
+    return this.combined.support().map((damageValue) => {
+      const probabilityBin = this.combined.map.get(damageValue);
+      const tableRow = {
+        damage: damageValue,
+        total: probabilityBin.p
+      };
+      for (const outcomeLabel of labels) {
+        tableRow[outcomeLabel] = probabilityBin.count[outcomeLabel] || 0;
+      }
+      return tableRow;
+    });
+  }
+  /**
+   * Returns data for stacked charts with unconditional per-label probability mass per damage.
+   *
+   * - Each dataset value equals the unconditional probability mass for that label at that damage
+   *   (i.e., `bin.count[label]`).
+   * - Column sums may be less than the total probability `bin.p` when you omit labels or when
+   *   there is unlabeled mass. Include all relevant outcome labels if you need the sum to match.
+   * - This behavior matches tests that expect raw per-label mass (not proportional scaling).
+   * - NOTE: This implementation may break dprcalc.com chart binning at large n, need to test it more.
+   *
+   * @example
+   * query.toStackedChartData(['hit', 'crit'])
+   * // → {labels: [0, 6, 12, ...], datasets: [{label: 'hit', data: [0, 0.03, ...]}, ...]}
+   */
+  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) => {
+        const bin = this.combined.map.get(dmg);
+        const v = bin ? bin.count[outcomeLabel] || 0 : 0;
+        return v <= epsilon ? 0 : v;
+      })
+    }));
+    return { labels: damageValues, datasets };
+  }
+  /**
+   * Returns pure mathematical data for attribution charts showing outcome contributions.
+   *
+   * Automatically discovers all outcome types present in the PMF, applies filtering rules,
+   * and returns proportional data suitable for stacked visualization.
+   *
+   * @param options Configuration options
+   * @param options.stackOrder Preferred order for outcome types (unknowns placed at end)
+   * @param options.filterRules Function to determine if outcome should be included for a given damage value
+   * @param options.asPercentages Whether to return percentages (0-100) or probabilities (0-1)
+   * @returns Pure data structure with support, outcomes, and proportional data
+   *
+   * @example
+   * query.toAttributionChartSeries()
+   * // → {support: [0, 6, 12], outcomes: ['hit', 'crit'], data: {hit: [5.2, 8.1, ...], crit: [0, 2.3, ...]}}
+   */
+  toAttributionChartSeries(options = {}) {
+    const {
+      stackOrder = [
+        "missNone",
+        "missDamage",
+        "saveFail",
+        "saveHalf",
+        "pc",
+        "hit",
+        "crit"
+      ],
+      filterRules = (outcome, damage) => !(outcome === "missNone" && damage !== 0),
+      asPercentages = true
+    } = options;
+    const originalSupport = this.combined.support();
+    if (originalSupport.length === 0) {
+      return { support: [], outcomes: [], data: {} };
+    }
+    const minDamage = Math.min(...originalSupport);
+    const maxDamage = Math.max(...originalSupport);
+    const support = Array.from(
+      { length: maxDamage - minDamage + 1 },
+      (_, i) => minDamage + i
+    );
+    const allOutcomeTypes = /* @__PURE__ */ new Set();
+    for (const [, bin] of this.combined.map) {
+      for (const outcomeType in bin.count) {
+        if (bin.count[outcomeType] && bin.count[outcomeType] > 0) {
+          allOutcomeTypes.add(outcomeType);
+        }
+      }
+    }
+    const existingOutcomes = Array.from(allOutcomeTypes).sort((a, b) => {
+      const indexA = stackOrder.indexOf(a);
+      const indexB = stackOrder.indexOf(b);
+      if (indexA >= 0 && indexB >= 0) return indexA - indexB;
+      if (indexA >= 0) return -1;
+      if (indexB >= 0) return 1;
+      return a.localeCompare(b);
+    });
+    if (existingOutcomes.length === 0) {
+      return { support, outcomes: [], data: {} };
+    }
+    const data = {};
+    for (const outcome of existingOutcomes) {
+      data[outcome] = support.map((damage) => {
+        const bin = this.combined.map.get(damage);
+        if (!bin) return 0;
+        if (!filterRules(outcome, damage)) {
+          return 0;
+        }
+        const outcomeCount = bin.count[outcome] || 0;
+        let totalChartableCount = 0;
+        for (const [outcomeName, count] of Object.entries(bin.count)) {
+          if (filterRules(outcomeName, damage)) {
+            totalChartableCount += count || 0;
+          }
+        }
+        if (totalChartableCount === 0) return 0;
+        const outcomeFraction = outcomeCount / totalChartableCount;
+        const outcomeProbability = bin.p * outcomeFraction;
+        return asPercentages ? outcomeProbability * 100 : outcomeProbability;
+      });
+    }
+    return {
+      support,
+      outcomes: existingOutcomes,
+      data
+    };
+  }
+  /**
+   * Returns pure mathematical data for damage attribution charts showing damage contribution
+   * from each outcome type at each damage value.
+   *
+   * Similar to toAttributionChartSeries() but uses bin.attr (damage attribution) instead of
+   * bin.count (probability attribution).
+   *
+   * @param options Configuration options
+   * @param options.stackOrder Preferred order for outcome types (unknowns placed at end)
+   * @param options.filterRules Function to determine if outcome should be included for a given damage value
+   * @param options.asPercentages Whether to return percentages (0-100) or raw damage values (0+)
+   * @returns Pure data structure with support, outcomes, and damage attribution data
+   *
+   * @example
+   * query.toDamageAttributionChartSeries()
+   * // → {support: [0, 6, 12], outcomes: ['hit', 'crit'], data: {hit: [3.2, 5.1, ...], crit: [0, 1.8, ...]}}
+   */
+  toDamageAttributionChartSeries(options = {}) {
+    const {
+      stackOrder = [
+        "missNone",
+        "missDamage",
+        "saveFail",
+        "saveHalf",
+        "pc",
+        "hit",
+        "crit"
+      ],
+      filterRules = (outcome, damage) => !(outcome === "missNone" && damage !== 0),
+      asPercentages = true
+    } = options;
+    const originalSupport = this.combined.support();
+    if (originalSupport.length === 0) {
+      return { support: [], outcomes: [], data: {} };
+    }
+    const minDamage = Math.min(...originalSupport);
+    const maxDamage = Math.max(...originalSupport);
+    const support = Array.from(
+      { length: maxDamage - minDamage + 1 },
+      (_, i) => minDamage + i
+    );
+    const allOutcomeTypes = /* @__PURE__ */ new Set();
+    for (const [, bin] of this.combined.map) {
+      if (bin.attr) {
+        for (const outcomeType in bin.attr) {
+          if (bin.attr[outcomeType] && bin.attr[outcomeType] > 0) {
+            allOutcomeTypes.add(outcomeType);
+          }
+        }
+      }
+    }
+    const existingOutcomes = Array.from(allOutcomeTypes).sort((a, b) => {
+      const indexA = stackOrder.indexOf(a);
+      const indexB = stackOrder.indexOf(b);
+      if (indexA >= 0 && indexB >= 0) return indexA - indexB;
+      if (indexA >= 0) return -1;
+      if (indexB >= 0) return 1;
+      return a.localeCompare(b);
+    });
+    if (existingOutcomes.length === 0) {
+      return { support, outcomes: [], data: {} };
+    }
+    const data = {};
+    for (const outcome of existingOutcomes) {
+      data[outcome] = support.map((damage) => {
+        const bin = this.combined.map.get(damage);
+        if (!bin || !bin.attr) return 0;
+        if (!filterRules(outcome, damage)) {
+          return 0;
+        }
+        const outcomeDamageAttribution = bin.attr[outcome] || 0;
+        if (asPercentages) {
+          let totalDamageAttribution = 0;
+          for (const [outcomeName, damageAttr] of Object.entries(bin.attr)) {
+            if (filterRules(outcomeName, damage)) {
+              totalDamageAttribution += damageAttr || 0;
+            }
+          }
+          if (totalDamageAttribution === 0) return 0;
+          const damagePercentage = outcomeDamageAttribution / totalDamageAttribution * 100;
+          return damagePercentage * bin.p * 100;
+        } else {
+          return outcomeDamageAttribution;
+        }
+      });
+    }
+    return {
+      support,
+      outcomes: existingOutcomes,
+      data
+    };
+  }
+  /**
+   * Returns pure mathematical data for outcome attribution charts showing which
+   * attack outcome combinations can produce each damage value.
+   *
+   * Unlike toDamageAttributionChartSeries() which tracks damage sources, this tracks
+   * outcome combinations - answering "what attack outcomes produced this damage?"
+   *
+   * @param options Configuration options
+   * @param options.stackOrder Preferred order for outcome types (unknowns placed at end)
+   * @param options.filterRules Function to determine if outcome should be included for a given damage value
+   * @param options.asPercentages Whether to return percentages (0-100) or probabilities (0-1)
+   * @returns Pure data structure with support, outcomes, and outcome combination probabilities
+   *
+   * @example
+   * query.toOutcomeAttributionChartSeries()
+   * // → {support: [0, 6, 12], outcomes: ['all_miss', 'mixed', 'all_hit'], data: {all_miss: [15, 0, 0], mixed: [60, 80, 20], all_hit: [25, 20, 80]}}
+   */
+  toOutcomeAttributionChartSeries(options = {}) {
+    const {
+      stackOrder = [
+        "missNone",
+        "missDamage",
+        "saveFail",
+        "saveHalf",
+        "pc",
+        "hit",
+        "crit"
+      ],
+      filterRules = (outcome, damage) => !(outcome === "missNone" && damage !== 0),
+      asPercentages = true
+    } = options;
+    const originalSupport = this.combined.support();
+    if (originalSupport.length === 0) {
+      return { support: [], outcomes: [], data: {} };
+    }
+    const minDamage = Math.min(...originalSupport);
+    const maxDamage = Math.max(...originalSupport);
+    const support = Array.from(
+      { length: maxDamage - minDamage + 1 },
+      (_, i) => minDamage + i
+    );
+    const allOutcomeTypes = /* @__PURE__ */ new Set();
+    for (const [, bin] of this.combined.map) {
+      for (const outcomeType in bin.count) {
+        if (bin.count[outcomeType] && bin.count[outcomeType] > 0) {
+          allOutcomeTypes.add(outcomeType);
+        }
+      }
+    }
+    const existingOutcomes = Array.from(allOutcomeTypes).sort((a, b) => {
+      const indexA = stackOrder.indexOf(a);
+      const indexB = stackOrder.indexOf(b);
+      if (indexA >= 0 && indexB >= 0) return indexA - indexB;
+      if (indexA >= 0) return -1;
+      if (indexB >= 0) return 1;
+      return a.localeCompare(b);
+    });
+    if (existingOutcomes.length === 0) {
+      return { support, outcomes: [], data: {} };
+    }
+    const data = {};
+    for (const outcome of existingOutcomes) {
+      data[outcome] = support.map((damage) => {
+        const bin = this.combined.map.get(damage);
+        if (!bin) return 0;
+        if (!filterRules(outcome, damage)) {
+          return 0;
+        }
+        if (outcome === "missNone") {
+          const outcomeCount = bin.count[outcome] || 0;
+          if (outcomeCount === 0) return 0;
+          if (asPercentages) {
+            let totalChartableCount = 0;
+            for (const [outcomeName, count] of Object.entries(bin.count)) {
+              if (filterRules(outcomeName, damage)) {
+                totalChartableCount += count || 0;
+              }
+            }
+            if (totalChartableCount === 0) return 0;
+            const outcomeFraction = outcomeCount / totalChartableCount;
+            return outcomeFraction * bin.p * 100;
+          } else {
+            return outcomeCount;
+          }
+        }
+        if (!bin.attr) return 0;
+        const outcomeDamageContribution = bin.attr[outcome] || 0;
+        if (asPercentages) {
+          let totalDamageAttribution = 0;
+          for (const [, damageAttr] of Object.entries(bin.attr)) {
+            totalDamageAttribution += damageAttr || 0;
+          }
+          if (totalDamageAttribution === 0) return 0;
+          const outcomeFraction = outcomeDamageContribution / totalDamageAttribution;
+          return outcomeFraction * bin.p * 100;
+        } else {
+          return outcomeDamageContribution;
+        }
+      });
+    }
+    return {
+      support,
+      outcomes: existingOutcomes,
+      data
+    };
+  }
+  /**
+   * Returns pure mathematical data for cumulative distribution function (CDF).
+   * Shows P(X ≤ x) - the probability of getting at most x damage.
+   *
+   * @param asPercentages Whether to return percentages (0-100) or probabilities (0-1)
+   * @returns Pure data structure with support and cumulative probabilities
+   *
+   * @example
+   * query.toCDFSeries()
+   * // → {support: [0, 6, 12], data: [5.2, 18.3, 45.1]}
+   */
+  toCDFSeries(asPercentages = true) {
+    const originalSupport = this.combined.support();
+    if (originalSupport.length === 0) {
+      return { support: [], data: [] };
+    }
+    const minDamage = Math.min(...originalSupport);
+    const maxDamage = Math.max(...originalSupport);
+    const support = Array.from(
+      { length: maxDamage - minDamage + 1 },
+      (_, i) => minDamage + i
+    );
+    let cumulativeProbability = 0;
+    const cdfData = [];
+    for (const damage of support) {
+      const bin = this.combined.map.get(damage);
+      if (bin) {
+        cumulativeProbability += bin.p;
+      }
+      cdfData.push(
+        asPercentages ? cumulativeProbability * 100 : cumulativeProbability
+      );
+    }
+    return {
+      support,
+      data: cdfData
+    };
+  }
+  /**
+   * Returns pure mathematical data for complementary cumulative distribution function (CCDF).
+   * Shows P(X ≥ x) - the probability of getting at least x damage.
+   *
+   * @param asPercentages Whether to return percentages (0-100) or probabilities (0-1)
+   * @returns Pure data structure with support and complementary cumulative probabilities
+   *
+   * @example
+   * query.toCCDFSeries()
+   * // → {support: [0, 6, 12], data: [100, 94.8, 81.7]}
+   */
+  toCCDFSeries(asPercentages = true) {
+    const originalSupport = this.combined.support();
+    if (originalSupport.length === 0) {
+      return { support: [], data: [] };
+    }
+    const minDamage = Math.min(...originalSupport);
+    const maxDamage = Math.max(...originalSupport);
+    const support = Array.from(
+      { length: maxDamage - minDamage + 1 },
+      (_, i) => minDamage + i
+    );
+    let cumulativeProbability = 0;
+    const ccdfData = [];
+    for (const damage of support) {
+      const ccdf = 1 - cumulativeProbability;
+      ccdfData.push(asPercentages ? ccdf * 100 : ccdf);
+      const bin = this.combined.map.get(damage);
+      if (bin) {
+        cumulativeProbability += bin.p;
+      }
+    }
+    return {
+      support,
+      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). */
+  outcomeKeys(order) {
+    const found = /* @__PURE__ */ new Set();
+    for (const [, bin] of this.combined.map) {
+      for (const k in bin.count)
+        if (bin.count[k] && bin.count[k] > 0) found.add(k);
+    }
+    if (found.size === 0)
+      ["hit", "crit", "missNone"].forEach((k) => found.add(k));
+    const keys = Array.from(found).filter(
+      (k) => order?.includes(k) ?? true
+    );
+    if (order && order.length)
+      keys.sort((a, b) => order.indexOf(a) + 999 - (order.indexOf(b) + 999));
+    return keys;
+  }
+  /** Total probability per outcome across the PMF. */
+  outcomeTotals(outcomes = this.outcomeKeys()) {
+    const totals = /* @__PURE__ */ new Map();
+    outcomes.forEach((o) => totals.set(o, 0));
+    for (const [, row] of this.combined.map) {
+      for (const o of outcomes) {
+        const p = row.count[o] || 0;
+        totals.set(o, (totals.get(o) || 0) + p);
+      }
+    }
+    return totals;
+  }
+  /** Conditional damage range per outcome (min/avg/max of X | outcome). */
+  outcomeDamageRanges(outcomes = this.outcomeKeys()) {
+    const table = this.toLabeledTable(outcomes);
+    const ranges = /* @__PURE__ */ new Map();
+    outcomes.forEach((o) => ranges.set(o, { sum: 0, mass: 0 }));
+    for (const row of table) {
+      const dmg = row.damage;
+      for (const o of outcomes) {
+        const p = row[o] || 0;
+        if (p > 0) {
+          const r = ranges.get(o);
+          r.sum += dmg * p;
+          r.mass += p;
+          if (r.min === void 0 || dmg < r.min) r.min = dmg;
+          if (r.max === void 0 || dmg > r.max) r.max = dmg;
+        }
+      }
+    }
+    const out = /* @__PURE__ */ new Map();
+    for (const o of outcomes) {
+      const r = ranges.get(o);
+      const avg = r.mass > 0 ? r.sum / r.mass : 0;
+      out.set(o, { min: r.min ?? 0, avg, max: r.max ?? 0 });
+    }
+    return out;
+  }
+  /**
+   * 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
+   */
+  snapshot(order) {
+    const discovered = /* @__PURE__ */ new Set();
+    for (const [, bin] of this.combined.map) {
+      for (const k in bin.count) {
+        if (bin.count[k] && bin.count[k] > 0) discovered.add(k);
+      }
+    }
+    if (discovered.size === 0) {
+      for (const k of _DiceQuery.DEFAULT_OUTCOMES) discovered.add(k);
+    }
+    let outcomes = Array.from(discovered);
+    if (order && order.length) {
+      const inOrder = new Set(order);
+      outcomes = outcomes.filter((k) => inOrder.has(k));
+      const rank = new Map(order.map((k, i) => [k, i]));
+      outcomes.sort(
+        (a, b) => (rank.get(a) ?? 999) - (rank.get(b) ?? 999)
+      );
+    }
+    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) {
+      const dmg = row.damage;
+      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;
+        if (r.min === void 0 || dmg < r.min) r.min = dmg;
+        if (r.max === void 0 || dmg > r.max) r.max = dmg;
+      }
+    }
+    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
+        damageRange: { min: r.min ?? 0, avg, max: r.max ?? 0 }
+      });
+    }
+    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)
+    };
+    return { averageDPR, damageChance, percentiles, outcomes: outcomeMap };
+  }
+  /**
+   * PMF Transformation Methods
+   *
+   * These methods provide a fluent API for transforming dice queries by wrapping
+   * the underlying PMF transformation methods. All operations work on the combined
+   * PMF and return new DiceQuery instances.
+   */
+  /**
+   * Returns a new DiceQuery with normalized probabilities (ensuring they sum to 1.0).
+   *
+   * @returns New DiceQuery with normalized combined PMF
+   */
+  normalize() {
+    return new _DiceQuery([this.combined.normalize()]);
+  }
+  /**
+   * Returns a new DiceQuery with low-probability outcomes removed.
+   *
+   * @param eps Minimum probability threshold (defaults to PMF epsilon)
+   * @param keepFinalBin Whether to keep the highest damage bin regardless of probability
+   * @returns New DiceQuery with compacted combined PMF
+   */
+  compact(eps, keepFinalBin) {
+    return new _DiceQuery([this.combined.compact(eps, keepFinalBin)]);
+  }
+  /**
+   * Returns a new DiceQuery with an additional scaled branch added.
+   * Useful for conditional outcomes like "30% chance of opportunity attack".
+   *
+   * @param branch DiceQuery to add as a scaled branch
+   * @param probability Probability of the branch occurring (0-1)
+   * @returns New DiceQuery combining this query with the scaled branch
+   *
+   * @example
+   * const baseAttack = parse("(d20 + 5 AC 15) * (2d6 + 3)");
+   * const opportunityAttack = parse("(d20 + 5 AC 15) * (1d8 + 3)");
+   * const withOpportunity = baseAttack.addScaled(opportunityAttack, 0.3);
+   */
+  addScaled(branch, probability) {
+    return new _DiceQuery([
+      this.combined.addScaled(branch.combined, probability)
+    ]);
+  }
+  /**
+   * Returns a new DiceQuery with all probabilities scaled by a factor.
+   * Used for conditional scenarios where the entire outcome has reduced probability.
+   *
+   * @param factor Scaling factor for probabilities
+   * @returns New DiceQuery with scaled probabilities
+   *
+   * @example
+   * const fullAttack = parse("(d20 + 5 AC 15) * (2d6 + 3)");
+   * const conditionalAttack = fullAttack.scaleMass(0.3); // 30% chance scenario
+   */
+  scaleMass(factor) {
+    return new _DiceQuery([this.combined.scaleMass(factor)]);
+  }
+  totalMass() {
+    return this.combined.mass();
+  }
+  /**
+   * Returns a new DiceQuery with damage values transformed by a function.
+   * Useful for applying modifiers, resistances, or other damage transformations.
+   *
+   * @param damageTransformFunction Function to transform each damage value
+   * @returns New DiceQuery with transformed damage values
+   *
+   * @example
+   * const baseAttack = parse("2d6 + 3");
+   * const withResistance = baseAttack.mapDamage(dmg => Math.floor(dmg / 2)); // Half damage
+   * const withBonus = baseAttack.mapDamage(dmg => dmg + 5); // +5 damage
+   */
+  mapDamage(damageTransformFunction) {
+    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.
+   *
+   * @param factor Scaling factor for damage values
+   * @param rounding Rounding method: "floor" (default), "round", or "ceil"
+   * @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
+   */
+  scaleDamage(factor, rounding = "floor") {
+    return new _DiceQuery([this.combined.scaleDamage(factor, rounding)]);
+  }
+  /**
+   * Returns a new DiceQuery combining this query with another via convolution.
+   * Equivalent to rolling both queries independently and adding results.
+   * It is important to use this rather than combing()ing the PMFs directly!
+   * This method maintains the provenance of the PMFs which is needed for damage attribution.
+   * Combining the .combined PMFs directly is still valid for DPR calculations but
+   * is not statistically sound for queries.
+   *
+   * @param other DiceQuery to combine with
+   * @param eps Optional epsilon for precision control
+   * @returns New DiceQuery representing the combined outcome
+   *
+   * @example
+   * const mainAttack = parse("(d20 + 5 AC 15) * (2d6 + 3)");
+   * const bonusAttack = parse("(d20 + 3 AC 15) * (1d6 + 1)");
+   * const bothAttacks = mainAttack.convolve(bonusAttack);
+   */
+  convolve(other) {
+    const singles = [...this.singles, ...other.singles];
+    return new _DiceQuery(singles);
+  }
+  /**
+   * First-success split over an ordered list of DISTINCT single-swing PMFs.
+   * Each PMF may have different success/subset probabilities (from labels).
+   *
+   * successOutcome: e.g., ["success"] or ["hit", "crit"]
+   * subsetOutcome:  e.g., ["subset"] or ["crit"] where subset ⊆ success
+   *
+   * Returns tuple: [pFirstNonSubset, pFirstSubset, pAnySuccess, pNone]
+   */
+  firstSuccessSplit(successOutcome, subsetOutcome, eps = EPS) {
+    const pmfs = this.singles;
+    if (!pmfs.length) {
+      throw new Error("firstSuccessSplitFromPMFs: pmfs must be non-empty");
+    }
+    const toArr = (x) => Array.isArray(x) ? x : [x];
+    const clamp01 = (x) => Math.max(0, Math.min(1, x));
+    const tol = Math.max(eps, 8 * Number.EPSILON);
+    const per = pmfs.map((pmf) => {
+      const dq = new _DiceQuery([pmf]);
+      const pS = dq.probAtLeastOne(toArr(successOutcome));
+      const pB = dq.probAtLeastOne(toArr(subsetOutcome));
+      if (pB - pS > eps) {
+        throw new Error(
+          "firstSuccessSplitFromPMFs: P(subset) > P(success) for an event. Ensure subset \u2286 success."
+        );
+      }
+      return { pS, pB };
+    });
+    let missSoFar = 1;
+    let pFirstSubset = 0;
+    let pFirstNonSubset = 0;
+    let pNone = 1;
+    for (const { pS, pB } of per) {
+      pFirstSubset += missSoFar * pB;
+      pFirstNonSubset += missSoFar * (pS - pB);
+      const miss = 1 - pS;
+      missSoFar *= miss;
+      pNone *= miss;
+    }
+    const pAny = 1 - pNone;
+    const a = clamp01(pFirstNonSubset);
+    const b = clamp01(pFirstSubset);
+    const any = clamp01(pAny);
+    const none = clamp01(pNone);
+    if (Math.abs(a + b - any) > tol * Math.max(1, any)) {
+      throw new Error(
+        `firstSuccessSplitFromPMFs: parts do not sum to pAny. got a+b=${a + b}, pAny=${any}`
+      );
+    }
+    return [a, b, any, none];
+  }
+};
+__publicField(_DiceQuery, "DEFAULT_OUTCOMES", [
+  "hit",
+  "crit",
+  "missNone"
+]);
+var DiceQuery = _DiceQuery;
+var pmfCache = new LRUCache(1e3);
+var _PMF = class _PMF {
+  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;
+    // 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);
+  }
+  // This has a single bin at value 0, mass of 1
+  static zero(epsilon = EPS) {
+    const m = /* @__PURE__ */ new Map();
+    m.set(0, { p: 1, count: { miss: 1 }, attr: {} });
+    return new _PMF(m, epsilon, false, "zero");
+  }
+  static delta(value, epsilon = EPS) {
+    return _PMF.fromMap(/* @__PURE__ */ new Map([[value, 1]]), epsilon);
+  }
+  // This creates a single bin at value 0, but with weight 0.
+  static emptyMass() {
+    return _PMF.zero().scaleMass(0);
+  }
+  //  Makes PMF iterable over [damage, bin] pairs.
+  [Symbol.iterator]() {
+    return this.map[Symbol.iterator]();
+  }
+  static clearCache() {
+    pmfCache.clear();
+  }
+  /**
+   * Creates a conditional PMF from two branches (success and failure) and a probability.
+   * This is the core logic for modeling any probabilistic event where there are two
+   * distinct outcomes.
+   */
+  static branch(successPMF, failurePMF, successProbability) {
+    let p = successProbability;
+    if (!Number.isFinite(p)) p = 0;
+    if (p < 0) p = 0;
+    if (p > 1) p = 1;
+    const q = 1 - p;
+    if (p === 0) return failurePMF.scaleMass(1);
+    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;
+  }
+  /**
+   * withProbability()
+   *
+   * A convenience wrapper around branch() for the common case where the "failure" branch is always zero().
+   *
+   *  Think of this as a shortcut for:
+   *    pmf.gate(p, PMF.zero())
+   *
+   * Use this to model a *single* Bernoulli event — an outcome that either happens or doesn't,
+   * like an opportunity attack that occurs with probability p, or a single attack that either hits or misses.
+   *
+   * This is **not** for combining multiple independent attacks or mutually exclusive multi-outcome scenarios.
+   * - For multiple independent swings, use DiceQuery with separate PMFs for each attack.
+   * - For modeling "first success" logic across multiple attacks (like Sneak Attack or Smite)
+   *   use query.firstSuccessSplit() to get the exact probabilities.
+   * - For scenarios with several mutually exclusive outcomes (like crit vs hit vs none), use PMF.exclusive().
+   *
+   */
+  static withProbability(successPMF, probability) {
+    return _PMF.branch(successPMF, _PMF.zero(), probability);
+  }
+  /**
+   * gate()
+   *
+   * A conditional wrapper around branch() that applies this PMF with probability `p`,
+   * and applies a provided fallback PMF otherwise.
+   *
+   * This is useful for modeling a binary choice between two outcomes:
+   * - The "success" outcome (this PMF) happens with probability `p`.
+   * - The "failure" outcome (fallback PMF) happens with probability `1 - p`.
+   *
+   * Examples:
+   * - 25% chance to include an opportunity attack, otherwise nothing:
+   *     attackPMF.gate(0.25, PMF.zero())
+   *
+   * - 50% chance to deal fireball damage, otherwise cone of cold damage:
+   *     fireballPMF.gate(0.5, coneOfColdPMF)
+   *
+   * Relationship to other helpers:
+   * - **withProbability()** is a shortcut for the common case where the fallback is `PMF.zero()`.
+   * - **exclusive()** is for three or more mutually exclusive outcomes (e.g., crit vs hit vs none).
+   *
+   * @param p Probability of applying this PMF (between 0 and 1).
+   * @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);
+  }
+  /**
+   * PMF.exclusive()
+   *
+   * Builds a single PMF from a set of mutually exclusive weighted outcomes.
+   * Exactly one of the provided options will occur.
+   *
+   * Each option has:
+   *  - A PMF representing its outcome (e.g., damage dice).
+   *  - A weight representing its probability of being selected.
+   *
+   * This is useful for modeling situations like:
+   *  - Sneak Attack: 6d6 if first hit is a crit, 3d6 if first hit is non-crit, 0 otherwise.
+   *  - Multiple exclusive spells: Fireball vs Cone of Cold vs nothing.
+   *
+   * Notes:
+   *  - If the total weight is less than 1, a zero PMF will automatically be added to
+   *    make up the remaining probability.
+   *  - Throws an error if the total weight is greater than 1 (invalid probability sum).
+   *
+   * @param options Array of `{ pmf, weight }` objects, each representing an outcome and its probability.
+   * @param label Optional name for debugging or charting.
+   * @param eps Optional tolerance for floating point rounding
+   * @returns A single PMF representing the exclusive mixture of all options.
+   */
+  static exclusive(options, eps = EPS) {
+    const items = options.map(
+      (o) => Array.isArray(o) ? { pmf: o[0], weight: o[1] } : o
+    );
+    const totalWeight = items.reduce((s, { weight }) => s + weight, 0);
+    if (totalWeight - 1 > eps) {
+      throw new Error(
+        `PMF.exclusive: total weight ${totalWeight.toFixed(6)} exceeds 1.`
+      );
+    }
+    let out = items.reduce(
+      (acc, { pmf, weight }) => weight > 0 ? acc.addScaled(pmf, weight) : acc,
+      _PMF.empty(eps)
+    );
+    const leftover = 1 - totalWeight;
+    if (leftover > eps) {
+      out = out.addScaled(_PMF.zero(), leftover);
+    }
+    return out;
+  }
+  /**
+   * General-purpose N-way mixture.
+   * weights: Array of [weight, PMF].
+   *
+   * Example: PMF.mixN([
+   *   [pMiss, zero],
+   *   [pHit, hitPMF],
+   *   [pCrit, critPMF],
+   * ]);
+   */
+  static mixN(weights, eps = EPS) {
+    const filtered = weights.filter(([w]) => w > eps);
+    if (filtered.length === 0) {
+      return _PMF.emptyMass();
+    }
+    let acc = null;
+    let sum = 0;
+    for (const [w, pmf] of filtered) {
+      if (acc === null) {
+        acc = pmf;
+        sum = w;
+      } else {
+        const q = w / (sum + w);
+        acc = _PMF.branch(pmf, acc, q);
+        sum += w;
+      }
+    }
+    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;
+  }
+  preservedProvenance() {
+    return this._preservedProvenance;
+  }
+  getPowerCacheKey(n, eps) {
+    const id = this.identifier;
+    let key = `${id}`;
+    for (let i = 1; i < n; i++) key += `+${id}`;
+    return `${key}@${eps}`;
+  }
+  /**
+   * 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().
+   */
+  power(n, eps = this.epsilon) {
+    if (!Number.isInteger(n) || n <= 0) {
+      throw new Error("power(n): n must be a positive integer");
+    }
+    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;
+    }
+    let base = this.normalized ? this : this.normalize();
+    let result = base;
+    let exp = n - 1;
+    while (exp > 0) {
+      if (exp & 1) {
+        result = result.convolve(base, epsilon);
+      }
+      exp >>= 1;
+      if (exp > 0) {
+        base = base.convolve(base, epsilon);
+      }
+    }
+    result.setPreservedProvenance(false);
+    {
+      pmfCache?.set(key, result);
+    }
+    return result;
+  }
+  /*
+   * Helper for chaining multiple identical attacks
+   */
+  replicate(n) {
+    if (!Number.isInteger(n) || n <= 0) {
+      throw new Error("combineN(n): n must be a positive integer");
+    }
+    if (n === 1) return [this];
+    return Array.from({ length: n }, () => this);
+  }
+  mass() {
+    if (this._totalMass === void 0) {
+      let totalProbabilityMass = 0;
+      for (const { p } of this.map.values()) {
+        totalProbabilityMass += p;
+      }
+      this._totalMass = totalProbabilityMass;
+    }
+    return this._totalMass;
+  }
+  outcomeMass(outcome) {
+    let totalProbabilityMass = 0;
+    for (const { p, count } of this.map.values()) {
+      totalProbabilityMass += p * (count[outcome] ?? 0);
+    }
+    return totalProbabilityMass;
+  }
+  // Helper for testing
+  faceTotal() {
+    return [...this.map.keys()].reduce((sum, key) => sum + key, 0);
+  }
+  normalize() {
+    if (this.normalized) return this;
+    const normalizationFactor = this.mass();
+    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;
+      }
+      let normalizedAttributes;
+      if (probabilityBin.attr) {
+        normalizedAttributes = {};
+        for (const labelKey in probabilityBin.attr) {
+          normalizedAttributes[labelKey] = probabilityBin.attr[labelKey] / normalizationFactor;
+        }
+      }
+      normalizedMap.set(damageValue, {
+        p: normalizedProbability,
+        count: normalizedCount,
+        attr: normalizedAttributes
+      });
+    }
+    return new _PMF(normalizedMap, this.epsilon, true, this.identifier);
+  }
+  /**
+   * Returns a copy with negligible probabilities removed (p < eps).
+   * If keepFinalBin is true, the bin with the largest key is always kept,
+   * even if its probability is below eps. count/attr submaps are still cleaned.
+   */
+  compact(eps = this.epsilon, keepFinalBin = false) {
+    let maxKey = -Infinity;
+    if (keepFinalBin) {
+      for (const key of this.map.keys()) {
+        if (key > maxKey) maxKey = key;
+      }
+    }
+    const compactedMap = /* @__PURE__ */ new Map();
+    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];
+        }
+      }
+      if (probabilityBin.attr) {
+        for (const labelKey in probabilityBin.attr) {
+          if (Math.abs(probabilityBin.attr[labelKey] || 0) < eps) {
+            delete probabilityBin.attr[labelKey];
+          }
+        }
+        if (Object.keys(probabilityBin.attr).length === 0) {
+          probabilityBin.attr = void 0;
+        }
+      }
+      compactedMap.set(damageValue, probabilityBin);
+    }
+    return new _PMF(compactedMap, eps, this.normalized, this.identifier);
+  }
+  // Note: The "support" of a PMF is the set of all non-zero probability outcomes.
+  // This returns all damage values with non-zero probability, sorted ascending.
+  support() {
+    if (this._support === void 0) {
+      this._support = [...this.map.keys()].sort((a, b) => a - b);
+    }
+    return this._support;
+  }
+  // Minimum possible damage value.
+  min() {
+    if (this._min === void 0) {
+      const support = this.support();
+      this._min = support.length > 0 ? support[0] : 0;
+    }
+    return this._min;
+  }
+  // Maximum possible damage value.
+  max() {
+    if (this._max === void 0) {
+      const support = this.support();
+      this._max = support.length > 0 ? support[support.length - 1] : 0;
+    }
+    return this._max;
+  }
+  /**
+   * Returns the expected (mean) damage value.
+   * Cached for performance since this requires iterating through all bins.
+   */
+  mean() {
+    if (this._mean === void 0) {
+      let totalSum = 0;
+      for (const [damageValue, probabilityBin] of this.map) {
+        totalSum += damageValue * probabilityBin.p;
+      }
+      this._mean = totalSum;
+    }
+    return this._mean;
+  }
+  /**
+   * Returns the variance of the damage distribution.
+   * Cached for performance since this requires mean calculation plus iteration.
+   */
+  variance() {
+    if (this._variance === void 0) {
+      const meanValue = this.mean();
+      let varianceSum = 0;
+      for (const [damageValue, probabilityBin] of this.map) {
+        const deviationFromMean = damageValue - meanValue;
+        varianceSum += deviationFromMean * deviationFromMean * probabilityBin.p;
+      }
+      this._variance = varianceSum;
+    }
+    return this._variance;
+  }
+  /**
+   * Returns the standard deviation of the damage distribution.
+   */
+  stdev() {
+    if (this._stdev === void 0) {
+      this._stdev = Math.sqrt(this.variance());
+    }
+    return this._stdev;
+  }
+  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
+      });
+      return;
+    }
+    existingBin.p += binToAdd.p;
+    for (const labelKey in binToAdd.count) {
+      existingBin.count[labelKey] = (existingBin.count[labelKey] || 0) + binToAdd.count[labelKey];
+    }
+    if (binToAdd.attr) {
+      if (!existingBin.attr) {
+        existingBin.attr = {};
+      }
+      for (const labelKey in binToAdd.attr) {
+        existingBin.attr[labelKey] = (existingBin.attr[labelKey] || 0) + binToAdd.attr[labelKey];
+      }
+    }
+  }
+  // Convenience method
+  add(other) {
+    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
+   */
+  addScaled(branch, probability) {
+    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
+      });
+    }
+    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
+      });
+    }
+    return new _PMF(
+      resultMap,
+      this.epsilon,
+      false,
+      `${this.identifier}+scaled(${branch.identifier},${probability})`
+    );
+  }
+  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
+      });
+    }
+    return new _PMF(
+      scaledMap,
+      this.epsilon,
+      false,
+      `scale(${this.identifier},${factor})`
+    );
+  }
+  mapDamage(damageTransformFunction) {
+    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
+      });
+    }
+    return new _PMF(
+      transformedMap,
+      this.epsilon,
+      this.normalized,
+      `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));
+  }
+  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;
+      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)}`;
+  }
+  convolve(other, eps, raw = false) {
+    const epsilon = eps ?? this.epsilon;
+    const norm = (x) => raw ? x : Math.abs(x.mass() - 1) <= epsilon ? x : x.normalize();
+    const A0 = norm(this);
+    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);
+    if (cached) return cached;
+    const combinedMap = /* @__PURE__ */ new Map();
+    for (const [aVal, aBin] of A.map) {
+      for (const [bVal, bBin] of B.map) {
+        const p = aBin.p * bBin.p;
+        const dmg = aVal + bVal;
+        const count = {};
+        for (const k in aBin.count)
+          count[k] = (count[k] || 0) + aBin.count[k] * bBin.p;
+        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;
+          if (bBin.attr)
+            for (const k in bBin.attr)
+              attr[k] = (attr[k] || 0) + bBin.attr[k] * aBin.p;
+        }
+        _PMF.mergeInto(combinedMap, dmg, { p, count, attr });
+      }
+    }
+    let result = new _PMF(
+      combinedMap,
+      epsilon,
+      !raw,
+      `${A.identifier}${raw ? "*" : "+"}${B.identifier}`
+    );
+    const mExp = (raw ? A.mass() : 1) * (raw ? B.mass() : 1);
+    const mGot = result.mass();
+    if (mExp !== 0 && Math.abs(mGot - mExp) > epsilon) {
+      result = result.scaleMass(mExp / mGot);
+    }
+    if (!raw && Math.abs(result.mass() - 1) > epsilon)
+      result = result.normalize();
+    pmfCache?.set(cacheKey, result);
+    return result;
+  }
+  // 3) Nice wrapper so you can call pmf.combineRaw(other)
+  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];
+    for (let i = 1; i < pmfList.length; i++) {
+      result = result.convolve(pmfList[i], eps);
+    }
+    return result;
+  }
+  /**
+   * Convolves multiple PMFs using linear convolution with automatic caching.
+   * Uses a left-to-right accumulation approach for maximum cache reuse.
+   * Each convolve() call automatically uses the convolution cache for performance.
+   *
+   * This linear approach provides better cache hits than pairwise because:
+   * - Intermediate results are more predictable and stable
+   * - Similar PMF lists share common prefixes (A+B, (A+B)+C, etc.)
+   * - Order-independent cache keys work better with consistent build patterns
+   */
+  static convolveMany(pmfList, eps = EPS) {
+    if (pmfList.length === 0) return _PMF.empty(eps);
+    if (pmfList.length === 1) return pmfList[0];
+    return _PMF.reduceConvolveLeft(pmfList, eps);
+  }
+  toJSON() {
+    return JSON.stringify({
+      bins: [...this.map.entries()],
+      normalized: this.normalized,
+      identifier: this.identifier
+    });
+  }
+  static fromJSON(jsonData) {
+    return new _PMF(
+      new Map(jsonData.bins),
+      EPS,
+      !!jsonData.normalized,
+      jsonData.identifier || "fromJSON"
+    );
+  }
+  /**
+   * Relative pruning with optional top-K floor.
+   * Keeps bins with p >= epsRel * peak, always keeps min and max damage,
+   * optionally guarantees at least `minBins` survivors by adding top-K.
+   * Returns a new, non-normalized PMF.
+   */
+  prune(epsRel, minBins = 0) {
+    const size = this.map.size;
+    if (size === 0) return this;
+    let peak = 0;
+    let minDamage = Number.POSITIVE_INFINITY;
+    let maxDamage = Number.NEGATIVE_INFINITY;
+    for (const [dmg, bin] of this.map) {
+      if (bin.p > peak) peak = bin.p;
+      if (dmg < minDamage) minDamage = dmg;
+      if (dmg > maxDamage) maxDamage = dmg;
+    }
+    if (peak === 0)
+      return new _PMF(new Map(this.map), epsRel, false, this.identifier);
+    const thresh = epsRel * peak;
+    const entries = [...this.map.entries()];
+    const survivorsByDmg = /* @__PURE__ */ new Map();
+    const protect = (d2) => {
+      const b = this.map.get(d2);
+      if (b) survivorsByDmg.set(d2, b);
+    };
+    protect(minDamage);
+    if (maxDamage !== minDamage) protect(maxDamage);
+    for (const [dmg, bin] of entries) {
+      if (bin.p >= thresh) survivorsByDmg.set(dmg, bin);
+    }
+    if (minBins > 0 && survivorsByDmg.size < minBins) {
+      entries.sort((a, b) => b[1].p - a[1].p);
+      for (const [dmg, bin] of entries) {
+        if (!survivorsByDmg.has(dmg)) {
+          survivorsByDmg.set(dmg, bin);
+          if (survivorsByDmg.size >= minBins) break;
+        }
+      }
+    }
+    const prunedMap = /* @__PURE__ */ new Map();
+    for (const [dmg, bin] of survivorsByDmg) {
+      const newCount = {};
+      for (const k in bin.count) {
+        const v = bin.count[k];
+        if (Math.abs(v) >= thresh) newCount[k] = v;
+      }
+      let newAttr;
+      if (bin.attr) {
+        for (const k in bin.attr) {
+          const v = bin.attr[k];
+          if (Math.abs(v) >= thresh) {
+            if (!newAttr) newAttr = {};
+            newAttr[k] = v;
+          }
+        }
+      }
+      prunedMap.set(dmg, { p: bin.p, count: newCount, attr: newAttr });
+    }
+    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;
+  }
+  /** Dense integer support from min..max (inclusive).
+   * Useful for showing empty bars in charts.
+   */
+  denseSupport() {
+    const s = this.support();
+    if (s.length === 0) return [];
+    const lo = Math.min(...s), hi = Math.max(...s);
+    return Array.from({ length: hi - lo + 1 }, (_, i) => lo + i).sort(
+      (a, b) => a - b
+    );
+  }
+  /** CDF at x: P(X ≤ x). */
+  cdfAt(x) {
+    let acc = 0;
+    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(p) {
+    if (this.map.size === 0) return 0;
+    const s = this.support().sort((a, b) => a - b);
+    let acc = 0;
+    for (const x of s) {
+      acc += this.pAt(x);
+      if (acc >= p) return x;
+    }
+    return s[s.length - 1];
+  }
+  /** Get outcome probability at specific damage value. */
+  outcomeAt(damage, outcome) {
+    return this.map.get(damage)?.count[outcome] ?? 0;
+  }
+  /** Get all outcome types present in this PMF. */
+  outcomes() {
+    const outcomeSet = /* @__PURE__ */ new Set();
+    for (const [, bin] of this.map) {
+      for (const outcome in bin.count) {
+        if (bin.count[outcome] > 0) {
+          outcomeSet.add(outcome);
+        }
+      }
+    }
+    return Array.from(outcomeSet).sort();
+  }
+  /** Get total probability of an outcome across all damage values. */
+  outcomeProbability(outcome) {
+    let total = 0;
+    for (const [, bin] of this.map) {
+      total += bin.count[outcome] ?? 0;
+    }
+    return total;
+  }
+  /** Get damage attribution for an outcome at specific damage value. */
+  outcomeAttributionAt(damage, outcome) {
+    return this.map.get(damage)?.attr?.[outcome] ?? 0;
+  }
+  /** Get all outcome data at specific damage value. */
+  binAt(damage) {
+    const bin = this.map.get(damage);
+    if (!bin) return null;
+    return {
+      p: bin.p,
+      count: { ...bin.count },
+      attr: bin.attr ? { ...bin.attr } : void 0
+    };
+  }
+  /** Check if outcome exists in this PMF. */
+  hasOutcome(outcome) {
+    for (const [, bin] of this.map) {
+      if ((bin.count[outcome] ?? 0) > 0) {
+        return true;
+      }
+    }
+    return false;
+  }
+  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;
+    }
+    return s;
+  }
+  tailProbGT(t) {
+    let s = 0;
+    for (const [x, rec] of this) {
+      if (x > t) s += rec.p;
+    }
+    return s;
+  }
+  /**
+   * Returns a new PMF containing only bins where the specified outcome has non-zero probability.
+   * This creates a marginal distribution for the given outcome type, with probabilities
+   * scaled to represent the unconditional mass attributable to that outcome.
+   */
+  filterOutcome(outcome) {
+    const filteredMap = /* @__PURE__ */ new Map();
+    for (const [damageValue, bin] of this.map) {
+      const outcomeCount = bin.count[outcome] ?? 0;
+      const totalCount = Object.values(bin.count ?? {}).reduce(
+        (a, b) => (a ?? 0) + (b ?? 0),
+        0
+      );
+      if (outcomeCount > 0 && totalCount !== void 0 && totalCount > 0) {
+        const proportion = outcomeCount / totalCount;
+        const newP = bin.p * proportion;
+        const newCount = { [outcome]: outcomeCount };
+        let newAttr;
+        if (bin.attr && bin.attr[outcome] !== void 0) {
+          newAttr = { [outcome]: bin.attr[outcome] * proportion };
+        }
+        filteredMap.set(damageValue, {
+          p: newP,
+          count: newCount,
+          attr: newAttr
+        });
+      }
+    }
+    return new _PMF(
+      filteredMap,
+      this.epsilon,
+      false,
+      // don't normalize by default
+      `filter(${this.identifier},${outcome})`
+    );
+  }
+  /**
+   * Calculates probabilities for first-success outcomes across n independent attempts.
+   *
+   * @param pSuccess - Total probability of any success on a single attempt.
+   * @param pSpecial - Probability of a specific subset of successes (e.g., critical success).
+   * @param n - Number of independent attempts.
+   *
+   * Returns:
+   *  - pSpecificSuccess: Probability that the first success was of the "special" type
+   *  - pGeneralSuccess: Probability that the first success was of the non-special type
+   *  - pNone: Probability that no successes occurred
+   *  - pAny: Probability that at least one success occurred
+   */
+  static firstSuccessWeights(pSuccess, pSpecial, n) {
+    const pFail = 1 - pSuccess;
+    const pFailAll = Math.pow(pFail, n);
+    const pAny = 1 - pFailAll;
+    const denom = pSuccess === 0 ? 1 : pSuccess;
+    const pSpecificSuccess = pSpecial * pAny / denom;
+    const pGeneralSuccess = (pSuccess - pSpecial) * pAny / denom;
+    const pNone = 1 - pSpecificSuccess - pGeneralSuccess;
+    return { pSpecificSuccess, pGeneralSuccess, pNone, pAny };
+  }
+  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();
+    for (const [v, rec] of this) {
+      if (Math.abs(rec.p) < eps) continue;
+      const u = round(f(v));
+      probs.set(u, (probs.get(u) ?? 0) + rec.p);
+      if (preserveCounts) {
+        const rec2 = this.map.get(v);
+        const src = typeof rec2 === "number" ? void 0 : rec2?.count;
+        if (src) {
+          const dest = counts.get(u) ?? {};
+          for (const k in src) {
+            dest[k] = (dest[k] ?? 0) + src[k];
+          }
+          counts.set(u, dest);
+        }
+      }
+    }
+    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
+    );
+  }
+  static fromMap(m, eps = EPS, { requireIntegerValues = true } = {}) {
+    const filtered = [];
+    for (const [v, p] of m) {
+      if (!Number.isFinite(v) || !Number.isFinite(p)) continue;
+      if (p <= 0 || Math.abs(p) < eps) continue;
+      if (requireIntegerValues && !Number.isInteger(v)) {
+        throw new Error(`fromMap: non-integer outcome ${v}`);
+      }
+      filtered.push([v, p]);
+    }
+    if (filtered.length === 0) {
+      throw new Error("fromMap: empty or invalid input map");
+    }
+    let sum = 0;
+    let c = 0;
+    for (const [, p] of filtered) {
+      const y = p - c;
+      const t = sum + y;
+      c = t - sum - y;
+      sum = t;
+    }
+    if (sum <= 0) throw new Error("pmfFromMap: probabilities sum to 0");
+    filtered.sort((a, b) => a[0] - b[0]);
+    const internal = /* @__PURE__ */ new Map();
+    for (const [v, p] of filtered) {
+      internal.set(v, { p: p / sum, count: {} });
+    }
+    return new _PMF(internal, eps);
+  }
+  query() {
+    return new DiceQuery(this);
+  }
+};
+// Unique ID generator for anonymous PMFs to avoid cache key collisions
+__publicField(_PMF, "__anonIdCounter", 1);
+var PMF = _PMF;
+
+// src/pmf/mixture.ts
+var Mixture = class _Mixture {
+  constructor(eps = EPS) {
+    __publicField(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.eps = Number.isFinite(eps) ? eps : EPS;
+  }
+  /** Remove all accumulated state. */
+  clear() {
+    this.totals.clear();
+    this.labelMass.clear();
+    return this;
+  }
+  /** Number of distinct outcome values currently accumulated. */
+  size() {
+    return this.totals.size;
+  }
+  /** Whether a label was ever added. */
+  hasLabel(label) {
+    for (const bag of this.labelMass.values()) if (bag[label]) return true;
+    return false;
+  }
+  /**
+   * Add a labeled component with a mixture weight.
+   * Weight can be any positive finite number. Very small contributions are pruned by eps.
+   */
+  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;
+      if (p <= 0) continue;
+      const add = weight * p;
+      if (!Number.isFinite(add) || Math.abs(add) < this.eps) continue;
+      this.totals.set(v, (this.totals.get(v) ?? 0) + add);
+      const bag = this.labelMass.get(v) ?? {};
+      bag[label] = (bag[label] ?? 0) + add;
+      this.labelMass.set(v, bag);
+    }
+    return this;
+  }
+  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;
+    }
+    if (!(grand > 0)) throw new Error("Mixture: zero total mass");
+    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 });
+    }
+    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.
+   */
+  byOutcome() {
+    const labels = /* @__PURE__ */ new Set();
+    for (const bag of this.labelMass.values()) {
+      for (const k of Object.keys(bag)) labels.add(k);
+    }
+    const out = {};
+    for (const label of labels) {
+      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 (m.size > 0) out[label] = PMF.fromMap(m, this.eps);
+    }
+    return out;
+  }
+  /**
+   * Mixture weights per label, normalized to sum to 1 over labels that appeared.
+   * Uses raw mass before per-outcome normalization.
+   */
+  weights() {
+    const res = {};
+    for (const [, bag] of this.labelMass) {
+      for (const [lab, w] of Object.entries(bag)) {
+        if (!Number.isFinite(w) || w <= 0) continue;
+        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;
+    }
+    if (total > 0) {
+      for (const k in res) res[k] = res[k] / total;
+    }
+    return res;
+  }
+  toJSON() {
+    return {
+      totals: Array.from(this.totals.entries()).sort((a, b) => a[0] - b[0]),
+      labels: Array.from(this.labelMass.entries()).sort((a, b) => a[0] - b[0]),
+      eps: this.eps
+    };
+  }
+  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();
+  }
+};
+
+// src/builder/prob.ts
+function d20PmfFromCdf(cdfPow, eps = EPS) {
+  const out = /* @__PURE__ */ new Map();
+  let prev = 0;
+  for (let k = 1; k <= 20; k++) {
+    const cur = cdfPow(k);
+    const pk = cur - prev;
+    if (pk > 0) {
+      out.set(k, pk);
+    }
+    prev = cur;
+  }
+  return PMF.fromMap(out, eps);
+}
+
+// src/builder/d20.ts
+var cacheKeyMap = {
+  "flat-flat": "d20",
+  "flat-reroll": "hd20",
+  "advantage-flat": "d20 > d20",
+  "advantage-reroll": "hd20 > hd20",
+  "disadvantage-flat": "d20 < d20",
+  "disadvantage-reroll": "hd20 < hd20",
+  "elven accuracy-flat": "d20 > d20 > d20",
+  "elven accuracy-reroll": "hd20 > hd20 > hd20"
+};
+function d20RollPMF(rollType, rerollOne = false) {
+  rollType = rollType || "flat";
+  const cacheKeyLookup = `${rollType}-${rerollOne ? "reroll" : "flat"}`;
+  const cacheKey = cacheKeyMap[cacheKeyLookup];
+  if (!cacheKey) {
+    throw new Error(`Invalid roll type: ${rollType}`);
+  }
+  const cached = pmfCache.get(cacheKey);
+  if (cached) return cached;
+  const base = d20PMF(rerollOne);
+  if (!rollType || rollType === "flat") {
+    pmfCache.set(cacheKey, base);
+    return base;
+  }
+  const p = new Array(21).fill(0);
+  for (const [r, rec] of base) {
+    const pr = typeof rec === "number" ? rec : rec.p;
+    if (r >= 1 && r <= 20) p[r] = pr;
+  }
+  const F = new Array(21).fill(0);
+  for (let k = 1; k <= 20; k++) F[k] = F[k - 1] + p[k];
+  const eps = 0;
+  let result = base;
+  if (rollType === "advantage") {
+    result = d20PmfFromCdf((k) => Math.pow(F[k], 2), eps);
+  } else if (rollType === "elven accuracy") {
+    result = d20PmfFromCdf((k) => Math.pow(F[k], 3), eps);
+  } else if (rollType === "disadvantage") {
+    result = d20PmfFromCdf((k) => 1 - Math.pow(1 - F[k], 2), eps);
+  }
+  pmfCache.set(cacheKey, result);
+  return result;
+}
+function d20PMF(rerollOne) {
+  const cacheKey = `flat-${rerollOne ? "reroll" : "flat"}`;
+  const cached = pmfCache.get(cacheKey);
+  if (cached) return cached;
+  const m = /* @__PURE__ */ new Map();
+  const base = 1 / 20;
+  const rerollShare = base * base;
+  if (!rerollOne) {
+    for (let r = 1; r <= 20; r++) {
+      m.set(r, base);
+    }
+  } else {
+    for (let r = 1; r <= 20; r++) {
+      m.set(r, (r === 1 ? 0 : base) + rerollShare);
+    }
+  }
+  const result = PMF.fromMap(m, EPS);
+  pmfCache.set(cacheKey, result);
+  return result;
+}
+
+// src/builder/ast.ts
+var defaultEps = 0;
+var singleDiePMFCache = new LRUCache(1e3);
+function astFromRollConfigs(configs) {
+  if (!configs || configs.length === 0) return void 0;
+  const children = [];
+  let constantSum = 0;
+  for (const cfg of configs) {
+    const sign = cfg.isSubtraction || cfg.count < 0 ? -1 : 1;
+    const count = Math.abs(cfg.count || 0);
+    constantSum += cfg.modifier || 0;
+    if ((cfg.sides || 0) <= 0) continue;
+    const die = {
+      type: "die",
+      sides: cfg.sides,
+      reroll: cfg.reroll > 0 ? cfg.reroll : void 0,
+      minimum: cfg.minimum > 0 ? cfg.minimum : void 0,
+      explode: cfg.explode && Number.isFinite(cfg.explode) && cfg.explode > 0 ? cfg.explode : void 0
+    };
+    let node = die;
+    let appliedRollType = false;
+    if (cfg.rollType && cfg.rollType !== "flat") {
+      if (cfg.sides === 20) {
+        node = {
+          type: "d20Roll",
+          rollType: cfg.rollType,
+          child: node
+        };
+      } else {
+        const n = cfg.rollType === "elven accuracy" ? 3 : 2;
+        const mode = cfg.rollType === "disadvantage" ? "lowest" : "highest";
+        const base = { type: "sum", count: n, child: node };
+        node = { type: "keep", mode, count: 1, child: base };
+      }
+      appliedRollType = true;
+    }
+    if (cfg.rollType === "flat" && cfg.keep && cfg.keep.total > 0) {
+      const base = { type: "sum", count: cfg.keep.total, child: node };
+      node = {
+        type: "keep",
+        mode: cfg.keep.mode,
+        count: cfg.keep.count,
+        child: base
+      };
+    } else {
+      const c = appliedRollType ? 1 : Math.max(1, count || 1);
+      node = { type: "sum", count: c, child: node };
+    }
+    children.push({ node, sign });
+  }
+  if (children.length === 0) {
+    return { type: "constant", value: constantSum };
+  }
+  const add = { type: "add", children };
+  if (constantSum !== 0)
+    add.children.push({
+      node: { type: "constant", value: constantSum },
+      sign: 1
+    });
+  return add;
+}
+function resolve(node, eps = defaultEps) {
+  const signature = getASTSignature(node);
+  const cacheKey = `${signature}_${eps}`;
+  const cached = builderPMFCache.get(cacheKey);
+  if (cached) return cached;
+  const result = (() => {
+    switch (node.type) {
+      case "constant":
+        return PMF.delta(node.value, eps);
+      case "die": {
+        return resolveSingleDie(node, eps);
+      }
+      case "sum": {
+        const base = resolve(node.child, eps);
+        const n = Math.max(0, Math.floor(node.count));
+        if (n === 0) return PMF.delta(0, eps);
+        if (n === 1) return base;
+        return base.power(n, eps);
+      }
+      case "add": {
+        let shift = 0;
+        const parts = [];
+        for (const c of node.children) {
+          if (c.node.type === "constant") {
+            shift += c.sign * c.node.value;
+          } else {
+            const p = resolve(c.node, eps);
+            parts.push(c.sign === 1 ? p : p.mapDamage((v) => -v));
+          }
+        }
+        if (parts.length === 0) return PMF.delta(shift, eps);
+        let res = parts.length === 1 ? parts[0] : PMF.convolveMany(parts, eps);
+        if (shift !== 0) res = res.mapDamage((v) => v + shift);
+        return res;
+      }
+      case "keep": {
+        const total = getTotalCount(node);
+        const die = findDie(node.child.child);
+        const perDie = die ? resolveSingleDie(die, eps) : PMF.delta(0, eps);
+        const keepCount = Math.max(0, Math.min(node.count, total));
+        if (keepCount === 0 || total === 0) return PMF.delta(0, eps);
+        return keepSumPMF(
+          perDie,
+          total,
+          keepCount,
+          node.mode === "highest",
+          eps
+        );
+      }
+      case "d20Roll": {
+        const childDie = findDie(node.child);
+        const rerollOne = !!childDie && (childDie.reroll || 0) >= 1;
+        return d20RollPMF(node.rollType, rerollOne);
+      }
+    }
+  })();
+  builderPMFCache.set(cacheKey, result);
+  return result;
+}
+function pmfFromRollBuilder(rb, eps = defaultEps) {
+  const configs = rb.getSubRollConfigs?.() ?? [];
+  const ast = astFromRollConfigs(configs) || { type: "constant", value: 0 };
+  return resolve(ast, eps);
+}
+function resolveSingleDie(die, eps = defaultEps) {
+  const signature = getASTSignature(die);
+  const cacheKey = `${signature}_${eps}`;
+  const cached = singleDiePMFCache.get(cacheKey);
+  if (cached) return cached;
+  const s = Math.max(0, Math.floor(die.sides));
+  if (s <= 0) return PMF.delta(0, eps);
+  let probs = /* @__PURE__ */ new Map();
+  for (let v = 1; v <= s; v++) probs.set(v, 1 / s);
+  const r = Math.max(0, Math.floor(die.reroll || 0));
+  if (r > 0) {
+    const k = Math.min(r, s);
+    const rerollMass = k / s;
+    const uniformReroll = rerollMass / s;
+    const next = /* @__PURE__ */ new Map();
+    for (let v = 1; v <= s; v++) {
+      const keep = v <= k ? 0 : 1 / s;
+      next.set(v, keep + uniformReroll);
+    }
+    probs = next;
+  }
+  let pmf = PMF.fromMap(new Map(probs), eps);
+  const minV = Math.max(0, Math.floor(die.minimum || 0));
+  if (minV > 0) pmf = pmf.mapDamage((v) => Math.max(v, minV));
+  const explode = die.explode;
+  if (explode && Number.isFinite(explode) && explode > 0) {
+    const times = Math.floor(explode);
+    const maxFace = s;
+    const nonMax = /* @__PURE__ */ new Map();
+    const pMax = pmf.pAt(maxFace);
+    for (const v of pmf.support()) {
+      if (v !== maxFace) nonMax.set(v, pmf.pAt(v));
+    }
+    let nonMaxPMF = PMF.fromMap(nonMax, eps);
+    if (Math.abs(nonMaxPMF.mass() - (1 - pMax)) > eps) {
+      nonMaxPMF = nonMaxPMF.scaleMass(1 - pMax);
+    }
+    let tail = PMF.delta(0, eps);
+    const addOnce = pmf;
+    for (let t = 1; t <= times; t++) {
+      tail = tail.convolve(addOnce, eps);
+    }
+    const exploded = PMF.branch(
+      tail.mapDamage((v) => v + maxFace),
+      nonMaxPMF,
+      pMax
+    );
+    pmf = exploded;
+  }
+  singleDiePMFCache.set(cacheKey, pmf);
+  return pmf;
+}
+function findDie(node) {
+  switch (node.type) {
+    case "die":
+      return node;
+    case "constant":
+      return void 0;
+    case "sum":
+    case "d20Roll":
+      return findDie(node.child);
+    case "keep":
+      return findDie(node.child.child);
+    case "add":
+      for (const c of node.children) {
+        const d2 = findDie(c.node);
+        if (d2) return d2;
+      }
+      return void 0;
+  }
+}
+function getTotalCount(node) {
+  let cur = node.child;
+  while (cur.type === "keep") cur = cur.child;
+  return cur.type === "sum" ? Math.max(0, Math.floor(cur.count)) : 0;
+}
+function keepSumPMF(single, total, keep, highest, eps = defaultEps) {
+  if (keep >= total) return single.power(total, eps);
+  if (keep <= 0) return PMF.delta(0, eps);
+  const sortedSupport = [...single.support()].sort((a, b) => a - b);
+  const pmfSig = sortedSupport.map((val) => `${val}:${single.pAt(val).toPrecision(6)}`).join(",");
+  const cacheKey = `keep|${pmfSig}|t:${total}|k:${keep}|h:${highest ? 1 : 0}|e:${eps}`;
+  const cached = builderPMFCache.get(cacheKey);
+  if (cached) return cached;
+  const support = single.support();
+  const probs = support.map((v) => ({ v, p: single.pAt(v) }));
+  const out = /* @__PURE__ */ new Map();
+  function dfs(i, accValues, weight) {
+    if (i === total) {
+      const sorted = [...accValues].sort((a, b) => highest ? b - a : a - b);
+      let sum = 0;
+      for (let j = 0; j < keep; j++) sum += sorted[j];
+      out.set(sum, (out.get(sum) || 0) + weight);
+      return;
+    }
+    for (const { v, p } of probs) {
+      if (p <= 0) continue;
+      dfs(i + 1, [...accValues, v], weight * p);
+    }
+  }
+  dfs(0, [], 1);
+  const result = PMF.fromMap(out, eps);
+  builderPMFCache.set(cacheKey, result);
+  return result;
+}
+function getASTSignature(node) {
+  switch (node.type) {
+    case "constant":
+      return `c:${node.value}`;
+    case "die": {
+      const parts = [];
+      parts.push(`s:${node.sides}`);
+      if (node.reroll) parts.push(`r:${node.reroll}`);
+      if (node.minimum) parts.push(`m:${node.minimum}`);
+      if (node.explode) parts.push(`e:${node.explode}`);
+      return `d{${parts.join(",")}}`;
+    }
+    case "sum":
+      return `sum{c:${node.count},ch:${getASTSignature(node.child)}}`;
+    case "d20Roll":
+      return `d20{t:${node.rollType},ch:${getASTSignature(node.child)}}`;
+    case "keep":
+      return `keep{c:${node.count},m:${node.mode},ch:${getASTSignature(
+        node.child
+      )}}`;
+    case "add": {
+      let constantValue = 0;
+      const otherChildrenSigs = [];
+      for (const c of node.children) {
+        if (c.node.type === "constant") {
+          constantValue += c.sign * c.node.value;
+        } else {
+          otherChildrenSigs.push(
+            `${c.sign === -1 ? "-" : "+"}${getASTSignature(c.node)}`
+          );
+        }
+      }
+      if (constantValue !== 0) {
+        otherChildrenSigs.push(
+          constantValue > 0 ? `+c:${constantValue}` : `-c:${-constantValue}`
+        );
+      }
+      otherChildrenSigs.sort();
+      return `add[${otherChildrenSigs.join("")}]`;
+    }
+  }
+}
+
+// src/builder/roll.ts
+var defaultConfig = {
+  count: 1,
+  sides: 0,
+  modifier: 0,
+  reroll: 0,
+  explode: 0,
+  minimum: 0,
+  bestOf: 0,
+  keep: void 0,
+  rollType: "flat"
+};
+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));
+    if (typeof countOrConfigs === "number") {
+      const count = countOrConfigs;
+      if (isNaN(count)) throw new Error("Invalid NaN value for count");
+      this.subRollConfigs = [
+        { ...defaultConfig, count, isSubtraction: count < 0 }
+      ];
+    } else {
+      this.subRollConfigs = countOrConfigs.map((c) => ({ ...c }));
+    }
+  }
+  get lastConfig() {
+    return this.subRollConfigs[this.subRollConfigs.length - 1];
+  }
+  getSubRollConfigs() {
+    return this.subRollConfigs.map((c) => ({ ...c }));
+  }
+  // for testing
+  static fromConfig(config) {
+    return new _RollBuilder([{ ...defaultConfig, ...config }]);
+  }
+  static fromConfigs(configs) {
+    return new _RollBuilder(
+      configs.map((config) => ({ ...defaultConfig, ...config }))
+    );
+  }
+  static fromArgs(...args) {
+    if (args.length === 1) {
+      const arg = args[0];
+      if (typeof arg === "number") {
+        if (isNaN(arg)) throw new Error("Invalid NaN value for argument");
+        return new _RollBuilder(0).plus(arg);
+      }
+      if (arg instanceof _RollBuilder) {
+        return arg;
+      }
+    }
+    if (args.length === 2 || args.length === 3) {
+      const [count, sidesOrDie, modifier] = args;
+      if (typeof count !== "number") {
+        throw new Error("First argument must be a number for multi-arg call");
+      }
+      if (isNaN(count)) throw new Error("Invalid NaN value for count argument");
+      if (sidesOrDie instanceof _RollBuilder) {
+        const subRollConfigs = sidesOrDie.getSubRollConfigs();
+        if (subRollConfigs.length === 0) {
+          const result = new _RollBuilder(0);
+          return modifier !== void 0 ? result.plus(modifier) : result;
+        }
+        const absCount = Math.abs(count);
+        const newConfigs = subRollConfigs.map((config) => ({
+          ...config,
+          count: config.count * absCount,
+          modifier: config.modifier * absCount
+        }));
+        let resultBuilder = new _RollBuilder(newConfigs);
+        if (count < 0) {
+          const negatedConfigs = resultBuilder.getSubRollConfigs().map((c) => ({ ...c, isSubtraction: !c.isSubtraction }));
+          resultBuilder = new _RollBuilder(negatedConfigs);
+        }
+        return modifier !== void 0 ? resultBuilder.plus(modifier) : resultBuilder;
+      } else if (typeof sidesOrDie === "number" || sidesOrDie === void 0) {
+        if (typeof sidesOrDie === "number" && isNaN(sidesOrDie))
+          throw new Error("Invalid NaN value for sides argument");
+        let builder = new _RollBuilder(count);
+        if (sidesOrDie && sidesOrDie > 0) {
+          builder = builder.d(sidesOrDie);
+        }
+        return modifier !== void 0 ? builder.plus(modifier) : builder;
+      }
+    }
+    throw new Error(`Invalid arguments passed: ${args.join(", ")}`);
+  }
+  // --- Core Dice Methods ---
+  d(sides) {
+    if (sides !== void 0 && isNaN(sides))
+      throw new Error("Invalid NaN value for sides");
+    if (sides === void 0) return this;
+    if (this.lastConfig.sides && this.lastConfig.sides > 0) {
+      throw new Error("Cannot add a die after adding a die");
+    }
+    if (sides === 0) return this;
+    const newConfigs = this.getSubRollConfigs();
+    newConfigs[newConfigs.length - 1].sides = sides;
+    return new this.constructor(newConfigs);
+  }
+  plus(modOrRoll, die) {
+    if (typeof modOrRoll === "number" && isNaN(modOrRoll))
+      throw new Error("Invalid NaN value for modOrRoll");
+    if (die instanceof _RollBuilder && typeof modOrRoll === "number") {
+      const count = modOrRoll;
+      const subRollConfigs = die.getSubRollConfigs();
+      if (subRollConfigs.length === 0) return this;
+      const absCount = Math.abs(count);
+      const newConfigs = subRollConfigs.map((config) => ({
+        ...config,
+        count: config.count * absCount,
+        modifier: config.modifier * absCount
+      }));
+      let rollToAdd = new _RollBuilder(newConfigs);
+      if (count < 0) {
+        const negatedConfigs = rollToAdd.getSubRollConfigs().map((c) => ({ ...c, isSubtraction: !c.isSubtraction }));
+        rollToAdd = new _RollBuilder(negatedConfigs);
+      }
+      return this.add(rollToAdd);
+    }
+    if (die !== void 0) {
+      throw new Error("Invalid arguments to plus()");
+    }
+    if (modOrRoll === void 0) return this;
+    if (typeof modOrRoll === "number") {
+      if (modOrRoll === 0) return this;
+      const newConfigs = this.getSubRollConfigs();
+      newConfigs[newConfigs.length - 1].modifier += modOrRoll;
+      return new this.constructor(newConfigs);
+    }
+    return this.add(modOrRoll);
+  }
+  minus(modOrRoll, die) {
+    const isNumber = typeof modOrRoll === "number";
+    const dieIsRoll = die instanceof _RollBuilder;
+    if (dieIsRoll && isNumber) return this.plus(-modOrRoll, die);
+    if (die !== void 0) throw new Error("Invalid arguments to minus()");
+    if (modOrRoll === void 0) return this;
+    return isNumber ? this.plus(-modOrRoll) : this.plus(-1, modOrRoll);
+  }
+  /** Apply one-pass reroll threshold (k): reroll faces 1..k once, must keep. */
+  reroll(value) {
+    if (isNaN(value)) throw new Error("Invalid NaN value for reroll");
+    const newConfigs = this.getSubRollConfigs();
+    newConfigs[newConfigs.length - 1].reroll = value;
+    return new this.constructor(newConfigs);
+  }
+  /** Set finite explode count for max-face explosions (Infinity allowed). */
+  explode(count = Infinity) {
+    if (count !== void 0 && isNaN(count))
+      throw new Error("Invalid NaN value for explode count");
+    if (count === void 0) return this;
+    if (count === 0) return this;
+    if (count < 0) throw new Error("Explode count must be >= 0");
+    const newConfigs = this.getSubRollConfigs();
+    newConfigs[newConfigs.length - 1].explode = count;
+    return new this.constructor(newConfigs);
+  }
+  /** Apply per-die minimum value (min > 0). */
+  minimum(val) {
+    if (val !== void 0 && isNaN(val))
+      throw new Error("Invalid NaN value for minimum");
+    if (val === void 0) return this;
+    if (val === 0) return this;
+    if (val < 0) throw new Error("Minimum value must be >= 0");
+    const newConfigs = this.getSubRollConfigs();
+    newConfigs[newConfigs.length - 1].minimum = val + 1;
+    return new this.constructor(newConfigs);
+  }
+  bestOf(count) {
+    if (count !== void 0 && isNaN(count))
+      throw new Error("Invalid NaN value for bestOf count");
+    if (count === void 0) return this;
+    if (count <= 0) throw new Error("Best of count must be > 0");
+    const newConfigs = this.getSubRollConfigs();
+    newConfigs[newConfigs.length - 1].bestOf = count;
+    return new this.constructor(newConfigs);
+  }
+  keepHighest(total, count) {
+    if (isNaN(total) || isNaN(count))
+      throw new Error("Invalid NaN value for keepHighest");
+    const newConfigs = this.getSubRollConfigs();
+    newConfigs[newConfigs.length - 1].keep = { total, count, mode: "highest" };
+    return new this.constructor(newConfigs);
+  }
+  keepLowest(total, count) {
+    if (isNaN(total) || isNaN(count))
+      throw new Error("Invalid NaN value for keepLowest");
+    const newConfigs = this.getSubRollConfigs();
+    newConfigs[newConfigs.length - 1].keep = { total, count, mode: "lowest" };
+    return new this.constructor(newConfigs);
+  }
+  withAdvantage() {
+    const newConfigs = this.getSubRollConfigs();
+    newConfigs[newConfigs.length - 1].rollType = "advantage";
+    return new this.constructor(newConfigs);
+  }
+  withDisadvantage() {
+    const configs = this.getSubRollConfigs();
+    configs[configs.length - 1].rollType = "disadvantage";
+    return new this.constructor(configs);
+  }
+  add(anotherRoll) {
+    if (anotherRoll === void 0) return this;
+    const configs = [...this.subRollConfigs, ...anotherRoll.subRollConfigs];
+    return new this.constructor(configs);
+  }
+  withBonus(anotherRoll) {
+    const configs = [...this.subRollConfigs, ...anotherRoll.subRollConfigs];
+    return new this.constructor(configs);
+  }
+  addRoll(count = 1) {
+    if (isNaN(count)) throw new Error("Invalid NaN value for count");
+    const configs = [
+      ...this.subRollConfigs,
+      {
+        ...defaultConfig,
+        count,
+        isSubtraction: count < 0
+      }
+    ];
+    return new this.constructor(configs);
+  }
+  doubleDice() {
+    const newConfigs = this.getSubRollConfigs().map((config) => {
+      if (!config.sides || config.sides <= 0) return config;
+      return { ...config, count: config.count * 2 };
+    });
+    return new this.constructor(newConfigs);
+  }
+  copy() {
+    return new this.constructor(this.getSubRollConfigs());
+  }
+  ac(targetAC) {
+    if (isNaN(targetAC)) throw new Error("Invalid NaN value for targetAC");
+    return new ACBuilder(this, targetAC);
+  }
+  withElvenAccuracy() {
+    const newConfigs = this.getSubRollConfigs();
+    newConfigs[newConfigs.length - 1].rollType = "elven accuracy";
+    return new this.constructor(newConfigs);
+  }
+  dc(saveDC) {
+    if (isNaN(saveDC)) throw new Error("Invalid NaN value for saveDC");
+    return new DCBuilder(this).dc(saveDC);
+  }
+  toExpression() {
+    const diceConfigs = this.subRollConfigs.filter(
+      (config) => config.sides && config.sides > 0
+    );
+    const totalModifier = this.subRollConfigs.reduce(
+      (sum, config) => sum + config.modifier,
+      0
+    );
+    if (diceConfigs.length === 0) return totalModifier.toString();
+    const rootConfig = this.getRootDieConfig();
+    const diceExpressions = diceConfigs.map(
+      (config) => this.configToSingleExpressionWithoutModifier(
+        config,
+        config === rootConfig
+      )
+    );
+    let result = "";
+    for (let i = 0; i < diceExpressions.length; i++) {
+      const config = diceConfigs[i];
+      const expression = diceExpressions[i];
+      if (i === 0) {
+        result = (config.isSubtraction ? "-" : "") + expression;
+      } else {
+        const operator = config.isSubtraction ? " - " : " + ";
+        result += operator + expression;
+      }
+    }
+    if (totalModifier > 0) result += ` + ${totalModifier}`;
+    else if (totalModifier < 0) result += ` - ${Math.abs(totalModifier)}`;
+    return result.replace(/\+ -/g, "-");
+  }
+  toPMF(eps = 0) {
+    return pmfFromRollBuilder(this, eps);
+  }
+  toQuery(eps = 0) {
+    return this.toPMF(eps).query();
+  }
+  toAST() {
+    const configs = this.getSubRollConfigs();
+    return astFromRollConfigs(configs) || { type: "constant", value: 0 };
+  }
+  configToSingleExpressionWithoutModifier(config, isRootDie) {
+    if (!config.sides || config.sides <= 0) return "";
+    let baseDie = `d${config.sides}`;
+    if (config.reroll > 0) {
+      if (config.minimum > 0 && config.explode > 0) ; else if (config.minimum > 0) {
+        for (let i = config.reroll; i >= 1; i--) baseDie += ` reroll ${i}`;
+      } else {
+        for (let i = 1; i <= config.reroll; i++) baseDie += ` reroll ${i}`;
+      }
+    }
+    if (config.minimum > 0) {
+      baseDie = `${config.minimum}>${baseDie}`;
+      if (config.reroll > 0 && config.explode > 0) {
+        for (let i = 1; i <= config.reroll; i++) {
+          baseDie += ` reroll ${i}`;
+        }
+      }
+    }
+    if (baseDie === "d20 reroll 1" && config.minimum <= 1) baseDie = "hd20";
+    let mainExpression = "";
+    switch (config.rollType) {
+      case "advantage":
+        mainExpression = `${baseDie} > ${baseDie}`;
+        break;
+      case "disadvantage":
+        mainExpression = `${baseDie} < ${baseDie}`;
+        break;
+      case "elven accuracy":
+        mainExpression = `${baseDie} > ${baseDie} > ${baseDie}`;
+        break;
+      case "flat":
+        if (config.keep) {
+          const mode = config.keep.mode === "highest" ? "kh" : "kl";
+          mainExpression = `${config.keep.total}${mode}${config.keep.count}(${baseDie})`;
+        } else {
+          const isComplex = baseDie.length > `d${config.sides}`.length;
+          const isHalflingShorthand = baseDie === "hd20";
+          const isD20Shorthand = baseDie === "d20" && isRootDie;
+          const hasMinimum = baseDie.startsWith("(") && baseDie.includes(">");
+          const hasReroll = baseDie.includes("reroll");
+          const effectiveCount = config.isSubtraction ? Math.abs(config.count) : config.count < 0 ? 1 : Math.abs(config.count);
+          if (effectiveCount > 1) {
+            const shouldAddParentheses = isComplex && (// Complex single roll: explode + reroll
+            !hasMinimum && !hasReroll || // Simple complex case
+            hasReroll && !hasMinimum);
+            mainExpression = shouldAddParentheses ? `${effectiveCount}(${baseDie})` : `${effectiveCount}${baseDie}`;
+          } else if (effectiveCount === 1) {
+            if (config.isSubtraction) {
+              mainExpression = `1${baseDie}`;
+            } else if (isComplex || isHalflingShorthand || isD20Shorthand || config.count < 0) {
+              mainExpression = baseDie;
+            } else {
+              mainExpression = `1${baseDie}`;
+            }
+          } else {
+            mainExpression = baseDie;
+          }
+        }
+        if (config.bestOf && config.count && config.bestOf < config.count) {
+          mainExpression += `kh${config.bestOf}`;
+        }
+        break;
+    }
+    return mainExpression;
+  }
+  getRootDieConfig() {
+    const configs = this.subRollConfigs;
+    return configs.find((config) => config.sides > 0) || configs[0];
+  }
+  getAllDieConfigs() {
+    return this.getSubRollConfigs();
+  }
+  getBonusDiceConfigs() {
+    const allConfigs = this.subRollConfigs;
+    const rootConfig = allConfigs.find((config) => config.sides > 0) || allConfigs[0];
+    if (!rootConfig) return [];
+    return allConfigs.filter((config) => config.sides > 0).filter((config) => config !== rootConfig);
+  }
+  getBonusDicePMFs(check, eps = 0) {
+    return check.getBonusDiceConfigs().map(
+      (config) => pmfFromRollBuilder(_RollBuilder.fromConfigs([config]), eps)
+    );
+  }
+  get modifier() {
+    return this.subRollConfigs.reduce(
+      (sum, config) => sum + config.modifier,
+      0
+    );
+  }
+  get rollType() {
+    const rootConfig = this.getRootDieConfig();
+    return rootConfig?.rollType || "flat";
+  }
+  get baseReroll() {
+    const rootConfig = this.getRootDieConfig();
+    return rootConfig?.reroll || 0;
+  }
+};
+
+// src/builder/attack.ts
+var AttackBuilder = class _AttackBuilder {
+  constructor(check, hitEffect, critEffect, missEffect) {
+    this.check = check;
+    this.hitEffect = hitEffect;
+    this.critEffect = critEffect;
+    this.missEffect = missEffect;
+  }
+  onCrit(...args) {
+    const damageRoll = RollBuilder.fromArgs(...args);
+    return new _AttackBuilder(
+      this.check,
+      this.hitEffect,
+      damageRoll,
+      this.missEffect
+    );
+  }
+  onMiss(...args) {
+    const damageRoll = RollBuilder.fromArgs(...args);
+    return new _AttackBuilder(
+      this.check,
+      this.hitEffect,
+      this.critEffect,
+      damageRoll
+    );
+  }
+  noCrit() {
+    return new _AttackBuilder(this.check, this.hitEffect, null, this.missEffect);
+  }
+  // Legacy expressions
+  toExpression() {
+    const checkPart = this.check.toExpression();
+    let effectPart = "";
+    if (this.hitEffect) {
+      effectPart = `(${this.hitEffect.toExpression()})`;
+      let crit = void 0;
+      if (this.critEffect !== null) {
+        crit = this.critEffect ?? this.hitEffect.copy().doubleDice();
+        const critThreshold = this.check.critThreshold;
+        if (critThreshold < 15 || critThreshold > 20) {
+          throw new Error(
+            `Invalid crit threshold: ${critThreshold}. Must be between 15 and 20.`
+          );
+        }
+        if (critThreshold === 20) {
+          effectPart += ` crit (${crit.toExpression()})`;
+        } else {
+          const xcritNumber = 21 - critThreshold;
+          effectPart += ` xcrit${xcritNumber} (${crit.toExpression()})`;
+        }
+      }
+      if (this.missEffect) {
+        effectPart += ` miss (${this.missEffect.toExpression()})`;
+      }
+    }
+    return `${checkPart} * ${effectPart}`;
+  }
+  resolveProbabilities(check, eps = 0) {
+    const ac = check.attackConfig.ac;
+    const rollType = check.rollType;
+    const rerollOne = check.baseReroll > 0;
+    const critThreshold = check.critThreshold;
+    const d202 = d20RollPMF(rollType, rerollOne);
+    const staticMod = this.check.modifier;
+    const bonusDicePMFs = this.check.getBonusDicePMFs(this.check, eps);
+    const bonusPMF = bonusDicePMFs.length ? PMF.convolveMany(bonusDicePMFs, eps) : PMF.delta(0, eps);
+    let pcrit = 0;
+    let phit = 0;
+    let pmiss = 0;
+    for (const [r, rec] of d202) {
+      const pr = typeof rec === "number" ? rec : rec.p;
+      if (pr <= 0) continue;
+      if (r >= critThreshold) {
+        pcrit += pr;
+        continue;
+      }
+      if (r === 1) {
+        pmiss += pr;
+        continue;
+      }
+      const need = ac - staticMod - r;
+      const pBonusHit = bonusPMF.tailProbGE(need);
+      phit += pr * pBonusHit;
+      pmiss += pr * (1 - pBonusHit);
+    }
+    const psuccess = phit + pcrit;
+    return { pSuccess: psuccess, pHit: phit, pCrit: pcrit, pMiss: pmiss };
+  }
+  resolve(eps = EPS) {
+    const {
+      pHit,
+      pCrit,
+      pMiss: pmiss
+    } = this.resolveProbabilities(this.check, eps);
+    const hitPMF = this.hitEffect ? pmfFromRollBuilder(this.hitEffect, eps) : PMF.delta(0, eps);
+    let critPMF = null;
+    let phit = pHit;
+    let pcrit = pCrit;
+    if (this.critEffect === null) {
+      critPMF = null;
+      phit += pcrit;
+      pcrit = 0;
+    } else {
+      const critBuilder = this.critEffect ?? this.hitEffect?.copy().doubleDice();
+      critPMF = critBuilder ? pmfFromRollBuilder(critBuilder, eps) : PMF.delta(0, eps);
+    }
+    const missPMF = this.missEffect ? pmfFromRollBuilder(this.missEffect, eps) : PMF.delta(0, eps);
+    const mix = new Mixture(eps);
+    if (phit > 0) mix.add("hit", hitPMF, phit);
+    if (critPMF && pcrit > 0) mix.add("crit", critPMF, pcrit);
+    if (pmiss > 0)
+      mix.add(this.missEffect ? "missDamage" : "missNone", missPMF, pmiss);
+    return {
+      pmf: mix.buildPMF(eps) ?? PMF.delta(0, eps),
+      check: this.check.toPMF(eps) ?? PMF.delta(0, eps),
+      hit: hitPMF ?? PMF.delta(0, eps),
+      crit: critPMF ?? PMF.delta(0, eps),
+      miss: missPMF ?? PMF.delta(0, eps),
+      weights: { hit: phit, crit: pcrit, miss: pmiss }
+    };
+  }
+  // By default, create PMF with no pruning
+  toPMF(eps = 0) {
+    return this.resolve(eps).pmf;
+  }
+  // By default, create query on PMF with no pruning
+  toQuery(eps = 0) {
+    return this.toPMF(eps).query();
+  }
+};
+
+// src/builder/ac.ts
+var ACBuilder = class _ACBuilder extends RollBuilder {
+  constructor(baseRoll, ac, attackConfig) {
+    super(baseRoll.getSubRollConfigs());
+    __publicField(this, "attackConfig");
+    if (attackConfig) {
+      this.attackConfig = { ...attackConfig, ac };
+    } else {
+      this.attackConfig = { ac, critThreshold: 20 };
+    }
+  }
+  onHit(...args) {
+    const damageRoll = RollBuilder.fromArgs(...args);
+    return new AttackBuilder(this, damageRoll);
+  }
+  dc(_) {
+    throw new Error(
+      "Cannot use dc() on an AttackRollBuilder. Use ac() for attack rolls instead."
+    );
+  }
+  get critThreshold() {
+    return this.attackConfig.critThreshold;
+  }
+  // TODO - move this to AC Builder… or if we create a DC builder that has critOn, throw an error?
+  critOn(threshold) {
+    const newConfig = {
+      ...this.attackConfig,
+      critThreshold: threshold
+    };
+    return new _ACBuilder(this, this.attackConfig.ac, newConfig);
+  }
+  // Legacy expressions
+  toExpression() {
+    const configs = this.getSubRollConfigs();
+    const expression = new RollBuilder(configs).toExpression();
+    return this.attackConfig.ac ? `(${expression} AC ${this.attackConfig.ac})` : expression;
+  }
+  toPMF(eps = 0) {
+    const ac = this.attackConfig.ac;
+    const rollType = this.rollType;
+    const rerollOne = this.baseReroll > 0;
+    const d202 = d20RollPMF(rollType, rerollOne);
+    const staticMod = this.modifier;
+    const bonusPMFs = this.getBonusDicePMFs(this, eps);
+    const parts = [d202, ...bonusPMFs];
+    let attackRollPMF = parts.length === 1 ? d202 : PMF.convolveMany(parts, eps);
+    if (staticMod !== 0)
+      attackRollPMF = attackRollPMF.mapDamage(
+        (rollValue) => rollValue + staticMod
+      );
+    const out = /* @__PURE__ */ new Map();
+    for (const rollValue of attackRollPMF.support()) {
+      const p = attackRollPMF.pAt(rollValue);
+      const key = rollValue >= ac ? rollValue : 0;
+      out.set(key, (out.get(key) || 0) + p);
+    }
+    return PMF.fromMap(out, eps);
+  }
+  copy() {
+    const baseCopy = new RollBuilder(this.getSubRollConfigs());
+    const newConfig = {
+      ac: this.attackConfig.ac,
+      critThreshold: this.attackConfig.critThreshold
+    };
+    return new _ACBuilder(baseCopy, newConfig.ac, newConfig);
+  }
+};
+
+// src/builder/save.ts
+var SaveBuilder = class _SaveBuilder {
+  constructor(check, failureEffect, saveOutcome = "normal") {
+    this.check = check;
+    this.failureEffect = failureEffect;
+    this.saveOutcome = saveOutcome;
+  }
+  saveHalf() {
+    return new _SaveBuilder(this.check, this.failureEffect, "half");
+  }
+  toExpression() {
+    const checkPart = this.check.toExpression();
+    if (!this.failureEffect) return checkPart;
+    const failureEffectPart = this.failureEffect.toExpression();
+    const result = `${checkPart} * (${failureEffectPart})`;
+    return this.saveOutcome === "half" ? `${result} save half` : result;
+  }
+  resolve(eps = EPS) {
+    const { pSuccess: psuccess = 0, pFail: pfail = 1 } = resolveProbabilities(
+      this.check
+    );
+    const failPMF = this.failureEffect ? pmfFromRollBuilder(this.failureEffect) : PMF.delta(0);
+    const onSuccess = this.saveOutcome ?? "half";
+    let successPMF = PMF.delta(0, eps);
+    if (onSuccess === "half") successPMF = failPMF.scaleDamage(0.5, "floor");
+    const successLabel = onSuccess === "normal" ? "missNone" : "saveHalf";
+    const failLabel = "saveFail";
+    const baseMix = new Mixture(eps);
+    const mixture = baseMix.add(successLabel, successPMF, psuccess).add(failLabel, failPMF, pfail);
+    return {
+      pmf: mixture.buildPMF(eps) ?? PMF.delta(0, eps),
+      check: PMF.exclusive([[PMF.delta(1), psuccess]], eps) ?? PMF.delta(0, eps),
+      saveFail: failPMF ?? PMF.delta(0, eps),
+      saveSuccess: successPMF ?? PMF.delta(0, eps),
+      weights: { success: psuccess, fail: pfail }
+    };
+  }
+  // By default, create PMF with no pruning
+  toPMF(eps = 0) {
+    return this.resolve(eps).pmf;
+  }
+  // By default, create query on PMF with no pruning
+  toQuery(eps = 0) {
+    return this.toPMF(eps).query();
+  }
+};
+function resolveProbabilities(check) {
+  const saveBonus = check.modifier;
+  const dc = check.saveDC;
+  const d20Type = check.rollType;
+  const baseReroll = check.baseReroll;
+  const die = d20RollPMF(d20Type, baseReroll > 0);
+  const faceP = /* @__PURE__ */ new Map();
+  for (const [r, rec] of die) {
+    const pr = typeof rec === "number" ? rec : rec.p;
+    if (pr > 0) faceP.set(r, pr);
+  }
+  const eps = 0;
+  const bonusDicePMFs = check.getBonusDicePMFs(check, eps);
+  const bonusPMF = bonusDicePMFs.length > 0 ? PMF.convolveMany(bonusDicePMFs, eps) : PMF.zero(eps);
+  let pSuccess = 0;
+  for (let r = 1; r <= 20; r++) {
+    const pr = faceP.get(r);
+    if (!pr) continue;
+    const need = dc - saveBonus - r;
+    pSuccess += pr * bonusPMF.tailProbGE(need);
+  }
+  const pFail = Math.max(0, 1 - pSuccess);
+  return { pSuccess, pFail };
+}
+
+// src/builder/dc.ts
+var DCBuilder = class _DCBuilder extends RollBuilder {
+  constructor(baseRoll, saveConfig) {
+    super(baseRoll.getSubRollConfigs());
+    __publicField(this, "saveConfig");
+    this.saveConfig = saveConfig ? { ...saveConfig } : { dc: 10 };
+  }
+  dc(saveDC) {
+    if (this.rollType && this.rollType === "elven accuracy") {
+      throw new Error(
+        "Cannot use dc() on an AttackRollBuilder. Use ac() for attack rolls instead."
+      );
+    }
+    return new _DCBuilder(this, { dc: saveDC });
+  }
+  get saveDC() {
+    return this.saveConfig.dc;
+  }
+  add(anotherRoll) {
+    const newBuilder = super.add(anotherRoll);
+    return new _DCBuilder(newBuilder, this.saveConfig);
+  }
+  addRoll(count) {
+    const newBuilder = super.addRoll(count);
+    return new _DCBuilder(newBuilder, this.saveConfig);
+  }
+  onSaveFailure(...args) {
+    const damageRoll = RollBuilder.fromArgs(...args);
+    return new SaveBuilder(this, damageRoll);
+  }
+  withElvenAccuracy() {
+    throw new Error(
+      "Elven Accuracy cannot be used with saving throws (DC checks). It is only valid for attack rolls (AC checks)."
+    );
+  }
+  // Legacy expressions
+  toExpression() {
+    const subConfigs = this.getSubRollConfigs();
+    const allConfigs = [...subConfigs];
+    const expression = new RollBuilder(allConfigs).toExpression();
+    return `(${expression} DC ${this.saveConfig.dc})`;
+  }
+  toPMF(eps = 0) {
+    const saveDC = this.saveDC;
+    const rollType = this.rollType;
+    const rerollOne = this.baseReroll > 0;
+    const d202 = d20RollPMF(rollType, rerollOne);
+    const staticMod = this.modifier;
+    const bonusDicePMFs = this.getBonusDiceConfigs().map(
+      (cfg) => pmfFromRollBuilder(RollBuilder.fromConfigs([cfg]), eps)
+    );
+    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;
+      if (pr <= 0) continue;
+      const need = saveDC - staticMod - r;
+      psuccess += pr * bonusPMF.tailProbGE(need);
+    }
+    const pfail = Math.max(0, 1 - psuccess);
+    const m = /* @__PURE__ */ new Map([
+      [0, psuccess > 0 ? psuccess : 0],
+      [1, pfail > 0 ? pfail : 0]
+    ]);
+    return PMF.fromMap(m, eps);
+  }
+};
+
+// src/builder/factory.ts
+var rollFn = (count, sidesOrDie, modifier) => {
+  if (sidesOrDie instanceof RollBuilder) {
+    const subRollConfigs = sidesOrDie.getSubRollConfigs();
+    if (subRollConfigs.length === 0) return new RollBuilder(0).plus(modifier);
+    const absCount = Math.abs(count);
+    const newConfigs = subRollConfigs.map((config) => ({
+      ...config,
+      count: config.count * absCount,
+      modifier: config.modifier * absCount
+    }));
+    let resultBuilder = new RollBuilder(newConfigs);
+    if (count < 0) {
+      const negatedConfigs = resultBuilder.getSubRollConfigs().map((c) => ({ ...c, isSubtraction: !c.isSubtraction }));
+      resultBuilder = new RollBuilder(negatedConfigs);
+    }
+    return resultBuilder.plus(modifier);
+  } else {
+    let builder = new RollBuilder(count);
+    if (sidesOrDie && sidesOrDie > 0) {
+      builder = builder.d(sidesOrDie);
+    }
+    return builder.plus(modifier);
+  }
+};
+rollFn.d = (sides) => new RollBuilder(1).d(sides);
+rollFn.hd20 = () => new RollBuilder(1).d20().reroll(1);
+rollFn.d4 = () => new RollBuilder(1).d4();
+rollFn.d6 = () => new RollBuilder(1).d6();
+rollFn.d8 = () => new RollBuilder(1).d8();
+rollFn.d10 = () => new RollBuilder(1).d10();
+rollFn.d12 = () => new RollBuilder(1).d12();
+rollFn.d20 = () => new RollBuilder(1).d20();
+rollFn.d100 = () => new RollBuilder(1).d100();
+rollFn.flat = (n) => new RollBuilder(0).plus(n);
+function d(sides) {
+  return new RollBuilder(1).d(sides);
+}
+var d4 = new RollBuilder(1).d4();
+var d6 = new RollBuilder(1).d6();
+var d8 = new RollBuilder(1).d8();
+var d10 = new RollBuilder(1).d10();
+var d12 = new RollBuilder(1).d12();
+var d20 = new RollBuilder(1).d20();
+var hd20 = new RollBuilder(1).d20().reroll(1);
+var d100 = new RollBuilder(1).d100();
+var flat = (n) => new RollBuilder(0).plus(n);
+var roll = rollFn;
+var builderPMFCache = new LRUCache(1e3);
+
+export { ACBuilder, DCBuilder, RollBuilder, SaveBuilder, builderPMFCache, d, d10, d100, d12, d20, d4, d6, d8, defaultConfig, flat, hd20, roll };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map