@yipe/dice 0.6.0 → 0.8.0

package/dist/builder/index.js

@@ -43,6 +43,26 @@ var LRUCache = class {
 // src/common/types.ts
 var EPS = 1e-12;
 var MISS_NONE_OUTCOME = "missNone";
+var ALL_OUTCOME_TYPES = [
+  "missNone",
+  "missDamage",
+  "saveFail",
+  "saveHalf",
+  "pc",
+  "hit",
+  "crit"
+];
+function sortOutcomes(outcomes, order = ALL_OUTCOME_TYPES) {
+  const rank = new Map(order.map((o, i) => [o, i]));
+  return [...outcomes].sort((a, b) => {
+    const ra = rank.get(a);
+    const rb = rank.get(b);
+    if (ra !== void 0 && rb !== void 0) return ra - rb;
+    if (ra !== void 0) return -1;
+    if (rb !== void 0) return 1;
+    return a.localeCompare(b);
+  });
+}
 
 // src/pmf/query.ts
 var _DiceQuery = class _DiceQuery {
@@ -89,7 +109,7 @@ var _DiceQuery = class _DiceQuery {
    * const attack = d20.plus(5).ac(15).onHit(d(2,6).plus(3)).onCrit(d(2,6))
    * const query = attack.toQuery()
    * const pmf = query.combinedWithAttribution()
-   * // Now pmf can be used with toDamageAttributionChartSeries()
+   * // Now pmf can be used with attributionByValue() / damageAttributionChartModel()
    */
   combinedWithAttribution() {
     if (this._combinedWithAttr) {
@@ -115,6 +135,14 @@ var _DiceQuery = class _DiceQuery {
   attributionByValue() {
     return this.combinedWithAttribution().attributionByValue();
   }
+  /**
+   * Full numeric model for the stacked damage-attribution chart. Convenience for
+   * `combinedWithAttribution().damageAttributionChartModel(options)`; see
+   * {@link PMF.damageAttributionChartModel}.
+   */
+  damageAttributionChartModel(options) {
+    return this.combinedWithAttribution().damageAttributionChartModel(options);
+  }
   /**
    * How many of the independent single PMFs can produce the given outcome
    * label. Useful for "all of them succeeded" style probabilities where the
@@ -719,290 +747,6 @@ var _DiceQuery = class _DiceQuery {
     }));
     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.
@@ -2374,6 +2118,149 @@ var _PMF = class _PMF {
     }
     return result;
   }
+  /**
+   * Reversed-convention CCDF percentile markers used by the attribution chart:
+   * for each target probability t, the largest damage x still reached with
+   * P(X ≥ x) > t%, falling back to the smallest/largest support value at the
+   * edges. Ported verbatim from the app so `p80/p50/p20` keep their intentional
+   * reversed meaning (p80 is the low-damage end). Computed on the full, un-binned
+   * support. Assumes a non-empty map.
+   */
+  attributionPercentiles() {
+    const sortedKeys = [...this.map.keys()].sort((a, b) => a - b);
+    const sparseCCDF = [];
+    let cumulativeP = 0;
+    for (let i = sortedKeys.length - 1; i >= 0; i--) {
+      const key = sortedKeys[i];
+      const bin = this.map.get(key);
+      if (!bin) continue;
+      cumulativeP += bin.p;
+      sparseCCDF.unshift({ x: key, y: cumulativeP * 100 });
+    }
+    const findDamageAtProbability = (targetProb) => {
+      for (let i = 0; i < sparseCCDF.length; i++) {
+        if (sparseCCDF[i].y <= targetProb) {
+          return i > 0 ? sparseCCDF[i - 1].x : sparseCCDF[i].x;
+        }
+      }
+      return sparseCCDF[sparseCCDF.length - 1].x;
+    };
+    return {
+      p80: findDamageAtProbability(80),
+      p50: findDamageAtProbability(50),
+      p20: findDamageAtProbability(20)
+    };
+  }
+  /**
+   * Full numeric model for the stacked damage-attribution chart — bar-height
+   * masses, tooltip shares, bucket labels/ranges, percentile markers, and the
+   * mean. The caller only maps these into a rendering format (colors, labels,
+   * axis units); all of the dice-and-probability logic lives here.
+   *
+   * Built split-first-then-bin: the attribution split ({@link attributionByValue})
+   * runs on the un-binned distribution, then the resulting series are coarsened.
+   * {@link rebin} is deliberately *not* used — rebinning first would fold any
+   * sub-`binSize` damage into the damage-0 bucket, which the split then mistakes
+   * for a clean miss and drops.
+   *
+   * @param options.maxBuckets Coarsen to at most this many equal-width buckets
+   *   when the integer support is wider (`range > maxBuckets`); omit for a dense,
+   *   per-integer model.
+   * @param options.stackOrder Preferred outcome order (defaults to
+   *   {@link ALL_OUTCOME_TYPES}); labels outside it sort alphabetically after.
+   * @param options.epsilon Bucket-total floor below which a `shares` entry is 0
+   *   (divide-by-~0 guard). Defaults to 1e-9.
+   */
+  damageAttributionChartModel(options = {}) {
+    const { maxBuckets, stackOrder = ALL_OUTCOME_TYPES, epsilon = 1e-9 } = options;
+    const empty = {
+      labels: [],
+      outcomes: [],
+      series: /* @__PURE__ */ new Map(),
+      shares: /* @__PURE__ */ new Map(),
+      totals: [],
+      percentiles: { p80: 0, p50: 0, p20: 0 },
+      mean: 0
+    };
+    if (this.map.size === 0) return empty;
+    const split = this.attributionByValue();
+    const discovered = /* @__PURE__ */ new Set();
+    for (const [, bin] of this.map) {
+      for (const k in bin.count) discovered.add(k);
+      if (bin.attr) for (const k in bin.attr) discovered.add(k);
+    }
+    const outcomes = sortOutcomes([...discovered], stackOrder);
+    const hasAttribution = outcomes.length > 0;
+    let min = Infinity;
+    let max = -Infinity;
+    const widen = (d2) => {
+      if (d2 < min) min = d2;
+      if (d2 > max) max = d2;
+    };
+    if (hasAttribution) {
+      for (const s of split.values())
+        for (const [d2, m] of s) if (m > 0) widen(d2);
+    } else {
+      for (const [d2, bin] of this.map) if ((bin.p || 0) > 0) widen(d2);
+    }
+    if (max < min) return empty;
+    const range = max - min;
+    const binned = maxBuckets !== void 0 && maxBuckets > 0 && range > maxBuckets;
+    const binSize = binned ? Math.ceil((range + 1) / maxBuckets) : 1;
+    const numBins = binned ? Math.ceil((range + 1) / binSize) : range + 1;
+    const bucketOf = (d2) => Math.floor((d2 - min) / binSize);
+    const labels = [];
+    const binRanges = binned ? [] : void 0;
+    for (let i = 0; i < numBins; i++) {
+      const start = min + i * binSize;
+      labels.push(start);
+      if (binRanges)
+        binRanges.push({ start, end: Math.min(start + binSize - 1, max) });
+    }
+    const series = /* @__PURE__ */ new Map();
+    for (const outcome of outcomes) {
+      const arr = new Array(numBins).fill(0);
+      const s = split.get(outcome);
+      if (s) {
+        for (const [d2, m] of s) {
+          const b = bucketOf(d2);
+          if (b >= 0 && b < numBins) arr[b] += m;
+        }
+      }
+      series.set(outcome, arr);
+    }
+    const totals = new Array(numBins).fill(0);
+    if (hasAttribution) {
+      for (const arr of series.values())
+        for (let i = 0; i < numBins; i++) totals[i] += arr[i];
+    } else {
+      for (const [d2, bin] of this.map) {
+        const p = bin.p || 0;
+        if (p <= 0) continue;
+        const b = bucketOf(d2);
+        if (b >= 0 && b < numBins) totals[b] += p;
+      }
+    }
+    const shares = /* @__PURE__ */ new Map();
+    for (const outcome of outcomes) {
+      const arr = series.get(outcome);
+      const sh = new Array(numBins).fill(0);
+      for (let i = 0; i < numBins; i++) {
+        sh[i] = totals[i] > epsilon ? arr[i] / totals[i] : 0;
+      }
+      shares.set(outcome, sh);
+    }
+    return {
+      labels,
+      binRanges,
+      outcomes,
+      series,
+      shares,
+      totals,
+      percentiles: this.attributionPercentiles(),
+      mean: this.mean()
+    };
+  }
   tailProbGE(t) {
     let s = 0;
     for (const [x, bin] of this) {
@@ -3614,6 +3501,17 @@ var RollBuilder = class _RollBuilder {
   getSubRollConfigs() {
     return this.subRollConfigs.map((c) => ({ ...c }));
   }
+  /**
+   * A cheap, stable string that FULLY identifies this builder's PMF — used by {@link AttackBuilder.toPMF}
+   * to cache resolved attack PMFs across rebuilds without walking the AST via {@link toExpression}. A plain
+   * roll is fully determined by its {@link RollConfig} array (count/sides/modifier/reroll/explode/minimum/
+   * bestOf/keep/rollType/isSubtraction), so serializing that is sound. Subclasses whose PMF depends on
+   * hidden state NOT captured by `subRollConfigs` (half/scale/max/parsed/pooled/composite transforms) return
+   * `null` to opt OUT of caching — a conservative miss is always safe; a wrong key would corrupt DPR.
+   */
+  cacheKey() {
+    return JSON.stringify(this.subRollConfigs);
+  }
   // for testing
   static fromConfig(config) {
     return new _RollBuilder([{ ...defaultConfig, ...config }]);
@@ -4122,6 +4020,9 @@ var HalfRollBuilder = class _HalfRollBuilder extends RollBuilder {
   hasHiddenState() {
     return this.innerRoll.hasHiddenState();
   }
+  cacheKey() {
+    return null;
+  }
   // No need to override create if we don't expose RollBuilder methods that use it,
   // but HalfRollBuilder extends RollBuilder so it does.
   // However, HalfRollBuilder seems to just wrap another roll.
@@ -4166,6 +4067,9 @@ var ScaleRollBuilder = class _ScaleRollBuilder extends RollBuilder {
   hasHiddenState() {
     return this.innerRoll.hasHiddenState();
   }
+  cacheKey() {
+    return null;
+  }
   get lastConfig() {
     return this.innerRoll.lastConfig;
   }
@@ -4210,6 +4114,9 @@ var MaxOfRollBuilder = class _MaxOfRollBuilder extends RollBuilder {
   hasHiddenState() {
     return this.innerRoll.hasHiddenState();
   }
+  cacheKey() {
+    return null;
+  }
   get lastConfig() {
     return this.innerRoll.lastConfig;
   }
@@ -4287,6 +4194,10 @@ var AlwaysHitBuilder = class _AlwaysHitBuilder extends RollBuilder {
   get critThreshold() {
     return this.attackConfig.critThreshold;
   }
+  cacheKey() {
+    const base = super.cacheKey();
+    return base === null ? null : `H|${this.attackConfig.critThreshold}|${base}`;
+  }
   // TODO - move this to AC Builder… or if we create a DC builder that has critOn, throw an error?
   critOn(critThreshold) {
     const newConfig = { critThreshold };
@@ -4337,6 +4248,10 @@ var AlwaysCritBuilder = class _AlwaysCritBuilder extends RollBuilder {
   get critThreshold() {
     return this.attackConfig.critThreshold;
   }
+  cacheKey() {
+    const base = super.cacheKey();
+    return base === null ? null : `C|${this.fromAlwaysHit ? 1 : 0}|${this.attackConfig.critThreshold}|${this.attackConfig.ac ?? ""}|${base}`;
+  }
   critOn(critThreshold) {
     const newConfig = { critThreshold, ac: this.attackConfig.ac };
     return new _AlwaysCritBuilder(this, newConfig, this.fromAlwaysHit);
@@ -4367,6 +4282,9 @@ var ParsedRollBuilder = class _ParsedRollBuilder extends RollBuilder {
   hasHiddenState() {
     return true;
   }
+  cacheKey() {
+    return null;
+  }
   create(configs) {
     return new RollBuilder(configs);
   }
@@ -4402,6 +4320,9 @@ var PooledRollBuilder = class _PooledRollBuilder extends RollBuilder {
   hasHiddenState() {
     return true;
   }
+  cacheKey() {
+    return null;
+  }
   d(_sides) {
     throw new Error("Cannot add dice to a pooled roll. The pool is finalized.");
   }
@@ -4505,6 +4426,9 @@ var CompositeSumRollBuilder = class _CompositeSumRollBuilder extends RollBuilder
   hasHiddenState() {
     return true;
   }
+  cacheKey() {
+    return null;
+  }
   getSubRollConfigs() {
     return [];
   }
@@ -5057,6 +4981,10 @@ function getASTSignature(node) {
 }
 
 // src/builder/attack.ts
+var attackPMFCache = new LRUCache(4e3);
+function clearAttackCache() {
+  attackPMFCache.clear();
+}
 var AttackBuilder = class _AttackBuilder {
   constructor(check, hitEffect, critEffect, missEffect) {
     this.check = check;
@@ -5235,9 +5163,46 @@ var AttackBuilder = class _AttackBuilder {
       weights: { hit: phit, crit: pcrit, miss: pmiss }
     };
   }
-  // By default, create PMF with no pruning
+  /**
+   * A cheap, complete key for this attack's resolved PMF, or `null` when it can't be cached soundly (an
+   * effect whose PMF isn't captured by its {@link RollConfig}s — see {@link RollBuilder.cacheKey}). Composed
+   * from the check + hit/crit/miss effect keys + `eps`. `critEffect === null` (noCrit) and `undefined`
+   * (auto-double the hit dice) are distinct crit states, encoded separately.
+   */
+  cacheKey(eps) {
+    const checkKey = this.check.cacheKey();
+    if (checkKey === null) return null;
+    let hitKey = "";
+    if (this.hitEffect) {
+      const k = this.hitEffect.cacheKey();
+      if (k === null) return null;
+      hitKey = k;
+    }
+    let critKey;
+    if (this.critEffect === null) critKey = "n";
+    else if (this.critEffect === void 0) critKey = "a";
+    else {
+      const k = this.critEffect.cacheKey();
+      if (k === null) return null;
+      critKey = k;
+    }
+    let missKey = "";
+    if (this.missEffect) {
+      const k = this.missEffect.cacheKey();
+      if (k === null) return null;
+      missKey = k;
+    }
+    return `${checkKey}*H${hitKey}*C${critKey}*M${missKey}*e${eps}`;
+  }
+  // By default, create PMF with no pruning. Cached by the cheap config key across identical rebuilds.
   toPMF(eps = 0) {
-    return this.resolve(eps).pmf;
+    const key = this.cacheKey(eps);
+    if (key === null) return this.resolve(eps).pmf;
+    const cached = attackPMFCache.get(key);
+    if (cached) return cached;
+    const pmf = this.resolve(eps).pmf;
+    attackPMFCache.set(key, pmf);
+    return pmf;
   }
   get pmf() {
     return this.toPMF();
@@ -5265,6 +5230,10 @@ var ACBuilder = class _ACBuilder extends RollBuilder {
   get critThreshold() {
     return this.attackConfig.critThreshold;
   }
+  cacheKey() {
+    const base = super.cacheKey();
+    return base === null ? null : `A|${this.attackConfig.ac}|${this.attackConfig.critThreshold}|${base}`;
+  }
   // TODO - move this to AC Builder… or if we create a DC builder that has critOn, throw an error?
   critOn(threshold) {
     const newConfig = {
@@ -5469,6 +5438,6 @@ RollBuilder.prototype.dc = function(saveDC) {
   return new DCBuilder(this).dc(saveDC);
 };
 
-export { ACBuilder, AlwaysCritBuilder, AlwaysHitBuilder, AttackBuilder, DCBuilder, HalfRollBuilder, MaxOfRollBuilder, ParsedRollBuilder, PooledRollBuilder, RollBuilder, SaveBuilder, ScaleRollBuilder, builderPMFCache, d, d10, d100, d12, d20, d4, d6, d8, defaultConfig, flat, hd20, roll, sumRolls };
+export { ACBuilder, AlwaysCritBuilder, AlwaysHitBuilder, AttackBuilder, DCBuilder, HalfRollBuilder, MaxOfRollBuilder, ParsedRollBuilder, PooledRollBuilder, RollBuilder, SaveBuilder, ScaleRollBuilder, builderPMFCache, clearAttackCache, d, d10, d100, d12, d20, d4, d6, d8, defaultConfig, flat, hd20, roll, sumRolls };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map