@yipe/dice 0.7.0 → 0.8.1

package/dist/builder/index.js

@@ -3452,6 +3452,10 @@ function d20PMF(rerollOne) {
 }
 
 // src/builder/roll.ts
+var rollPMFCache = new LRUCache(4e3);
+function clearRollCache() {
+  rollPMFCache.clear();
+}
 var defaultConfig = {
   count: 1,
   sides: 0,
@@ -3501,6 +3505,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 }]);
@@ -3853,8 +3868,16 @@ var RollBuilder = class _RollBuilder {
     }
     return result.replace(/\+ -/g, "-");
   }
+  // Main AST entry point. Cached by the cheap config key across identical rebuilds; see `rollPMFCache`.
   toPMF(eps = 0) {
-    return pmfFromRollBuilder(this, eps);
+    const key = this.cacheKey();
+    if (key === null) return pmfFromRollBuilder(this, eps);
+    const fullKey = `${key}*e${eps}`;
+    const cached = rollPMFCache.get(fullKey);
+    if (cached) return cached;
+    const pmf = pmfFromRollBuilder(this, eps);
+    rollPMFCache.set(fullKey, pmf);
+    return pmf;
   }
   get pmf() {
     return this.toPMF();
@@ -4009,6 +4032,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.
@@ -4053,6 +4079,9 @@ var ScaleRollBuilder = class _ScaleRollBuilder extends RollBuilder {
   hasHiddenState() {
     return this.innerRoll.hasHiddenState();
   }
+  cacheKey() {
+    return null;
+  }
   get lastConfig() {
     return this.innerRoll.lastConfig;
   }
@@ -4097,6 +4126,9 @@ var MaxOfRollBuilder = class _MaxOfRollBuilder extends RollBuilder {
   hasHiddenState() {
     return this.innerRoll.hasHiddenState();
   }
+  cacheKey() {
+    return null;
+  }
   get lastConfig() {
     return this.innerRoll.lastConfig;
   }
@@ -4174,6 +4206,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 };
@@ -4224,6 +4260,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);
@@ -4254,6 +4294,9 @@ var ParsedRollBuilder = class _ParsedRollBuilder extends RollBuilder {
   hasHiddenState() {
     return true;
   }
+  cacheKey() {
+    return null;
+  }
   create(configs) {
     return new RollBuilder(configs);
   }
@@ -4289,6 +4332,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.");
   }
@@ -4392,6 +4438,9 @@ var CompositeSumRollBuilder = class _CompositeSumRollBuilder extends RollBuilder
   hasHiddenState() {
     return true;
   }
+  cacheKey() {
+    return null;
+  }
   getSubRollConfigs() {
     return [];
   }
@@ -4944,6 +4993,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;
@@ -5122,9 +5175,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();
@@ -5152,6 +5242,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 = {
@@ -5212,6 +5306,10 @@ RollBuilder.prototype.ac = function(targetAC) {
 };
 
 // src/builder/save.ts
+var savePMFCache = new LRUCache(4e3);
+function clearSaveCache() {
+  savePMFCache.clear();
+}
 var SaveBuilder = class _SaveBuilder {
   constructor(check, failureEffect, saveOutcome = "normal") {
     this.check = check;
@@ -5248,9 +5346,32 @@ var SaveBuilder = class _SaveBuilder {
       weights: { success: psuccess, fail: pfail }
     };
   }
-  // By default, create PMF with no pruning
+  /**
+   * A cheap, complete key for this save's resolved PMF, or `null` when it can't be cached soundly.
+   * {@link resolve} reads exactly three things: the DC check (via `resolveProbabilities`), the failure
+   * effect's PMF, and the save outcome — so composing their keys pins it. A `ParsedRollBuilder` failure
+   * effect returns `null`, which correctly forces this uncached.
+   */
+  cacheKey(eps) {
+    const checkKey = this.check.cacheKey();
+    if (checkKey === null) return null;
+    let failKey = "";
+    if (this.failureEffect) {
+      const k = this.failureEffect.cacheKey();
+      if (k === null) return null;
+      failKey = k;
+    }
+    return `${checkKey}*F${failKey}*O${this.saveOutcome}*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 = savePMFCache.get(key);
+    if (cached) return cached;
+    const pmf = this.resolve(eps).pmf;
+    savePMFCache.set(key, pmf);
+    return pmf;
   }
   get pmf() {
     return this.toPMF();
@@ -5286,6 +5407,10 @@ function resolveProbabilities(check) {
 }
 
 // src/builder/dc.ts
+var dcPMFCache = new LRUCache(4e3);
+function clearDCCache() {
+  dcPMFCache.clear();
+}
 var DCBuilder = class _DCBuilder extends RollBuilder {
   constructor(baseRoll, saveConfig) {
     super(baseRoll.getSubRollConfigs());
@@ -5326,7 +5451,22 @@ var DCBuilder = class _DCBuilder extends RollBuilder {
     const expression = new RollBuilder(allConfigs).toExpression();
     return `(${expression} DC ${this.saveConfig.dc})`;
   }
+  /**
+   * The DC check's PMF is fully determined by the save DC plus everything `toPMF` below reads off the roll
+   * configs (`rollType`, `baseReroll`, `modifier`, bonus dice) — all of which `super.cacheKey()` already
+   * serializes. So extend the base key with the DC, mirroring {@link AlwaysHitBuilder.cacheKey}.
+   */
+  cacheKey() {
+    const base = super.cacheKey();
+    return base === null ? null : `DC|${this.saveConfig.dc}|${base}`;
+  }
   toPMF(eps = 0) {
+    const key = this.cacheKey();
+    const fullKey = key === null ? null : `${key}*e${eps}`;
+    if (fullKey !== null) {
+      const cached = dcPMFCache.get(fullKey);
+      if (cached) return cached;
+    }
     const saveDC = this.saveDC;
     const rollType = this.rollType;
     const rerollOne = this.baseReroll > 0;
@@ -5348,7 +5488,9 @@ var DCBuilder = class _DCBuilder extends RollBuilder {
       [0, psuccess > 0 ? psuccess : 0],
       [1, pfail > 0 ? pfail : 0]
     ]);
-    return PMF.fromMap(m, eps);
+    const pmf = PMF.fromMap(m, eps);
+    if (fullKey !== null) dcPMFCache.set(fullKey, pmf);
+    return pmf;
   }
 };
 RollBuilder.prototype.dc = function(saveDC) {
@@ -5356,6 +5498,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, clearDCCache, clearRollCache, clearSaveCache, d, d10, d100, d12, d20, d4, d6, d8, defaultConfig, flat, hd20, roll, sumRolls };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map