@yipe/dice 0.2.16 → 0.2.17

package/dist/builder/index.cjs

@@ -54,6 +54,7 @@ var _DiceQuery = class _DiceQuery {
   constructor(singles, combined, eps = EPS) {
     __publicField(this, "singles");
     __publicField(this, "combined");
+    __publicField(this, "_combinedWithAttr");
     this.singles = Array.isArray(singles) ? singles : [singles];
     if (this.singles.some((s) => s === void 0)) {
       throw new Error("DiceQuery contains undefined singles");
@@ -61,6 +62,35 @@ var _DiceQuery = class _DiceQuery {
     const c = combined ?? PMF.convolveMany(this.singles);
     this.combined = Math.abs(c.mass() - 1) <= eps ? c : c.normalize();
   }
+  /**
+   * Returns a new PMF with damage attribution metadata populated.
+   *
+   * This method computes attribution on-demand for builder-generated PMFs,
+   * enabling them to work with damage attribution charts. The `attr` field
+   * tracks how much damage each outcome type contributes at each damage value.
+   *
+   * For each bin at damage D: sum(attr.values()) ≈ D × P(damage = D)
+   *
+   * Performance: Cached after first call. Adds minimal overhead vs `combined`.
+   *
+   * @returns PMF with attr field populated for damage attribution charts
+   *
+   * @example
+   * 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()
+   */
+  combinedWithAttribution() {
+    if (this._combinedWithAttr) {
+      return this._combinedWithAttr;
+    }
+    const singlesWithAttr = this.singles.map((pmf) => pmf.withAttribution());
+    const combined = PMF.convolveMany(singlesWithAttr, this.combined.epsilon);
+    const normalized = Math.abs(combined.mass() - 1) <= this.combined.epsilon ? combined : combined.normalize();
+    this._combinedWithAttr = normalized;
+    return normalized;
+  }
   /**
    * Returns the expected damage across all possible outcomes.
    *
@@ -1405,9 +1435,9 @@ var _PMF = class _PMF {
     let totalWeight = items.reduce((s, { weight }) => s + weight, 0);
     if (Math.abs(totalWeight) <= eps) totalWeight = 0;
     if (Math.abs(1 - totalWeight) <= eps) totalWeight = 1;
-    if (totalWeight > 1 + eps) {
+    if (totalWeight > 1 + EPS) {
       throw new Error(
-        `PMF.exclusive: total weight ${totalWeight.toFixed(6)} exceeds 1.`
+        `PMF.exclusive: total weight ${totalWeight} exceeds 1. (epsilon: ${eps})`
       );
     }
     let out = _PMF.empty(eps);
@@ -1449,6 +1479,44 @@ var _PMF = class _PMF {
     }
     return out;
   }
+  /**
+   * Adds damage attribution metadata to this PMF based on existing count metadata.
+   * For each bin, sets attr[outcome] = damage × count[outcome].
+   *
+   * This enables damage attribution charts to work with builder-generated PMFs.
+   * The parser generates attr automatically, but builder PMFs only have count.
+   *
+   * @returns New PMF with attr field populated in each bin
+   */
+  withAttribution() {
+    for (const [damage, bin] of this.map) {
+      if (damage !== 0 && bin.attr && Object.keys(bin.attr).length > 0) {
+        return this;
+      }
+      if (damage > 0) break;
+    }
+    const newMap = /* @__PURE__ */ new Map();
+    for (const [damage, bin] of this.map) {
+      const attr = {};
+      for (const outcome in bin.count) {
+        const probability = bin.count[outcome];
+        if (probability > 0) {
+          attr[outcome] = damage * probability;
+        }
+      }
+      newMap.set(damage, {
+        p: bin.p,
+        count: { ...bin.count },
+        attr: Object.keys(attr).length > 0 ? attr : void 0
+      });
+    }
+    return new _PMF(
+      newMap,
+      this.epsilon,
+      this.normalized,
+      `${this.identifier}~attr`
+    );
+  }
   /**
    * General-purpose N-way mixture.
    * weights: Array of [weight, PMF].