@yipe/dice 0.3.0 → 0.5.0

package/dist/builder/index.d.cts

@@ -1,4 +1,4 @@
-import { P as PMF, D as DiceQuery, C as CritConfig, L as LRUCache } from '../pmf-DqUCnYN9.cjs';
+import { b as RollType, P as PMF, l as DiceQuery, C as CritConfig, L as LRUCache } from '../pmf-D5VRghZI.cjs';
 
 type RollFactory = {
     (count: number, sides?: number, modifier?: number): RollBuilder;
@@ -14,7 +14,6 @@ type RollFactory = {
     d100(): RollBuilder;
     flat(n: number): RollBuilder;
 };
-type RollType = "flat" | "advantage" | "disadvantage" | "elven accuracy";
 type KeepMode = "highest" | "lowest";
 type RollConfig = {
     count: number;
@@ -99,7 +98,7 @@ declare class DCBuilder extends RollBuilder {
     toPMF(eps?: number): PMF;
 }
 
-type ExpressionNode = DieNode | ConstantNode | SumNode | AddNode | KeepNode | D20RollNode | HalfNode | MaxOfNode;
+type ExpressionNode = DieNode | ConstantNode | SumNode | AddNode | KeepNode | D20RollNode | HalfNode | MaxOfNode | ScaleNode;
 type DieNode = {
     type: "die";
     sides: number;
@@ -143,6 +142,22 @@ type MaxOfNode = {
     count: number;
     child: ExpressionNode;
 };
+/**
+ * Scale the child's result by `numerator / denominator`, then round.
+ *
+ * Unlike {@link HalfNode} (a fixed `// 2` with floor), this is a general, composable
+ * multiplier/divider — the building block for damage-type resistance (`1/2`, floor),
+ * vulnerability (`2/1`), and similar per-source transforms. It renders as
+ * `N * (child)` when the denominator is 1, `(child) // D` when the numerator is 1,
+ * and `(child) * N // D` otherwise.
+ */
+type ScaleNode = {
+    type: "scale";
+    numerator: number;
+    denominator: number;
+    rounding: "floor" | "round" | "ceil";
+    child: ExpressionNode;
+};
 
 declare const defaultConfig: RollConfig;
 declare class RollBuilder {
@@ -203,6 +218,13 @@ declare class RollBuilder {
     get rollType(): RollType;
     get baseReroll(): number;
     half(): HalfRollBuilder;
+    /**
+     * Scale this roll's result by `numerator / denominator`, rounding each outcome.
+     * A general, composable form of {@link half} — used to model damage-type resistance
+     * (`scaleResult(1, 2)` → `(expr) // 2`) and vulnerability (`scaleResult(2)` → `2 * (expr)`).
+     * Compose several of these (and plain rolls) into one payload with {@link sumRolls}.
+     */
+    scaleResult(numerator: number, denominator?: number, rounding?: "floor" | "round" | "ceil"): ScaleRollBuilder;
     maxOf(count: number): MaxOfRollBuilder;
     ac(_targetAC: number): ACBuilder;
     dc(_saveDC: number): DCBuilder;
@@ -218,6 +240,25 @@ declare class HalfRollBuilder extends RollBuilder {
     toPMF(eps?: number): PMF;
     copy(): HalfRollBuilder;
 }
+/**
+ * A roll whose result is scaled by `numerator / denominator` and rounded — the composable
+ * generalization of {@link HalfRollBuilder}. Renders as `N * (inner)`, `(inner) // D`, or
+ * `(inner) * N // D`. Terminal (like `half`): use {@link sumRolls} to combine with other rolls.
+ */
+declare class ScaleRollBuilder extends RollBuilder {
+    private readonly innerRoll;
+    private readonly numerator;
+    private readonly denominator;
+    private readonly rounding;
+    constructor(innerRoll: RollBuilder, numerator: number, denominator?: number, rounding?: "floor" | "round" | "ceil");
+    hasHiddenState(): boolean;
+    get lastConfig(): RollConfig;
+    getSubRollConfigs(): readonly RollConfig[];
+    toExpression(): string;
+    toAST(): ExpressionNode;
+    toPMF(eps?: number): PMF;
+    copy(): ScaleRollBuilder;
+}
 declare class MaxOfRollBuilder extends RollBuilder {
     private readonly innerRoll;
     private readonly count;
@@ -306,6 +347,14 @@ declare class PooledRollBuilder extends RollBuilder {
     scaleDice(scale: number): RollBuilder;
     times(count: number): PooledRollBuilder;
 }
+/**
+ * Combine several rolls into one additive payload whose PMF is their convolution and whose
+ * expression is them joined with ` + `. Unlike `a.plus(b)`, this preserves parts that carry
+ * hidden state (e.g. `roll.scaleResult(1, 2)` / `roll.half()`), so per-damage-type resistance
+ * and vulnerability survive into both the distribution and the rendered expression.
+ * Empty parts collapse to `0`; a single part is returned unwrapped.
+ */
+declare function sumRolls(parts: readonly RollBuilder[]): RollBuilder;
 
 type ActionEffect = RollBuilder;
 declare class AttackBuilder implements CheckBuilder {
@@ -377,4 +426,4 @@ declare const flat: (n: number) => RollBuilder;
 declare const roll: RollFactory;
 declare const builderPMFCache: LRUCache<string, PMF>;
 
-export { ACBuilder, AlwaysCritBuilder, AlwaysHitBuilder, AttackBuilder, type AttackConfig, type AttackResolution, type CheckBuilder, DCBuilder, HalfRollBuilder, type KeepMode, MaxOfRollBuilder, ParsedRollBuilder, PooledRollBuilder, type Resolution, RollBuilder, type RollConfig, type RollFactory, type RollType, SaveBuilder, type SaveOutcome, type SaveResolution, builderPMFCache, d, d10, d100, d12, d20, d4, d6, d8, defaultConfig, flat, hd20, roll };
+export { ACBuilder, AlwaysCritBuilder, AlwaysHitBuilder, AttackBuilder, type AttackConfig, type AttackResolution, type CheckBuilder, DCBuilder, HalfRollBuilder, type KeepMode, MaxOfRollBuilder, ParsedRollBuilder, PooledRollBuilder, type Resolution, RollBuilder, type RollConfig, type RollFactory, RollType, SaveBuilder, type SaveOutcome, type SaveResolution, ScaleRollBuilder, builderPMFCache, d, d10, d100, d12, d20, d4, d6, d8, defaultConfig, flat, hd20, roll, sumRolls };

package/dist/builder/index.d.ts

@@ -1,4 +1,4 @@
-import { P as PMF, D as DiceQuery, C as CritConfig, L as LRUCache } from '../pmf-DqUCnYN9.js';
+import { b as RollType, P as PMF, l as DiceQuery, C as CritConfig, L as LRUCache } from '../pmf-D5VRghZI.js';
 
 type RollFactory = {
     (count: number, sides?: number, modifier?: number): RollBuilder;
@@ -14,7 +14,6 @@ type RollFactory = {
     d100(): RollBuilder;
     flat(n: number): RollBuilder;
 };
-type RollType = "flat" | "advantage" | "disadvantage" | "elven accuracy";
 type KeepMode = "highest" | "lowest";
 type RollConfig = {
     count: number;
@@ -99,7 +98,7 @@ declare class DCBuilder extends RollBuilder {
     toPMF(eps?: number): PMF;
 }
 
-type ExpressionNode = DieNode | ConstantNode | SumNode | AddNode | KeepNode | D20RollNode | HalfNode | MaxOfNode;
+type ExpressionNode = DieNode | ConstantNode | SumNode | AddNode | KeepNode | D20RollNode | HalfNode | MaxOfNode | ScaleNode;
 type DieNode = {
     type: "die";
     sides: number;
@@ -143,6 +142,22 @@ type MaxOfNode = {
     count: number;
     child: ExpressionNode;
 };
+/**
+ * Scale the child's result by `numerator / denominator`, then round.
+ *
+ * Unlike {@link HalfNode} (a fixed `// 2` with floor), this is a general, composable
+ * multiplier/divider — the building block for damage-type resistance (`1/2`, floor),
+ * vulnerability (`2/1`), and similar per-source transforms. It renders as
+ * `N * (child)` when the denominator is 1, `(child) // D` when the numerator is 1,
+ * and `(child) * N // D` otherwise.
+ */
+type ScaleNode = {
+    type: "scale";
+    numerator: number;
+    denominator: number;
+    rounding: "floor" | "round" | "ceil";
+    child: ExpressionNode;
+};
 
 declare const defaultConfig: RollConfig;
 declare class RollBuilder {
@@ -203,6 +218,13 @@ declare class RollBuilder {
     get rollType(): RollType;
     get baseReroll(): number;
     half(): HalfRollBuilder;
+    /**
+     * Scale this roll's result by `numerator / denominator`, rounding each outcome.
+     * A general, composable form of {@link half} — used to model damage-type resistance
+     * (`scaleResult(1, 2)` → `(expr) // 2`) and vulnerability (`scaleResult(2)` → `2 * (expr)`).
+     * Compose several of these (and plain rolls) into one payload with {@link sumRolls}.
+     */
+    scaleResult(numerator: number, denominator?: number, rounding?: "floor" | "round" | "ceil"): ScaleRollBuilder;
     maxOf(count: number): MaxOfRollBuilder;
     ac(_targetAC: number): ACBuilder;
     dc(_saveDC: number): DCBuilder;
@@ -218,6 +240,25 @@ declare class HalfRollBuilder extends RollBuilder {
     toPMF(eps?: number): PMF;
     copy(): HalfRollBuilder;
 }
+/**
+ * A roll whose result is scaled by `numerator / denominator` and rounded — the composable
+ * generalization of {@link HalfRollBuilder}. Renders as `N * (inner)`, `(inner) // D`, or
+ * `(inner) * N // D`. Terminal (like `half`): use {@link sumRolls} to combine with other rolls.
+ */
+declare class ScaleRollBuilder extends RollBuilder {
+    private readonly innerRoll;
+    private readonly numerator;
+    private readonly denominator;
+    private readonly rounding;
+    constructor(innerRoll: RollBuilder, numerator: number, denominator?: number, rounding?: "floor" | "round" | "ceil");
+    hasHiddenState(): boolean;
+    get lastConfig(): RollConfig;
+    getSubRollConfigs(): readonly RollConfig[];
+    toExpression(): string;
+    toAST(): ExpressionNode;
+    toPMF(eps?: number): PMF;
+    copy(): ScaleRollBuilder;
+}
 declare class MaxOfRollBuilder extends RollBuilder {
     private readonly innerRoll;
     private readonly count;
@@ -306,6 +347,14 @@ declare class PooledRollBuilder extends RollBuilder {
     scaleDice(scale: number): RollBuilder;
     times(count: number): PooledRollBuilder;
 }
+/**
+ * Combine several rolls into one additive payload whose PMF is their convolution and whose
+ * expression is them joined with ` + `. Unlike `a.plus(b)`, this preserves parts that carry
+ * hidden state (e.g. `roll.scaleResult(1, 2)` / `roll.half()`), so per-damage-type resistance
+ * and vulnerability survive into both the distribution and the rendered expression.
+ * Empty parts collapse to `0`; a single part is returned unwrapped.
+ */
+declare function sumRolls(parts: readonly RollBuilder[]): RollBuilder;
 
 type ActionEffect = RollBuilder;
 declare class AttackBuilder implements CheckBuilder {
@@ -377,4 +426,4 @@ declare const flat: (n: number) => RollBuilder;
 declare const roll: RollFactory;
 declare const builderPMFCache: LRUCache<string, PMF>;
 
-export { ACBuilder, AlwaysCritBuilder, AlwaysHitBuilder, AttackBuilder, type AttackConfig, type AttackResolution, type CheckBuilder, DCBuilder, HalfRollBuilder, type KeepMode, MaxOfRollBuilder, ParsedRollBuilder, PooledRollBuilder, type Resolution, RollBuilder, type RollConfig, type RollFactory, type RollType, SaveBuilder, type SaveOutcome, type SaveResolution, builderPMFCache, d, d10, d100, d12, d20, d4, d6, d8, defaultConfig, flat, hd20, roll };
+export { ACBuilder, AlwaysCritBuilder, AlwaysHitBuilder, AttackBuilder, type AttackConfig, type AttackResolution, type CheckBuilder, DCBuilder, HalfRollBuilder, type KeepMode, MaxOfRollBuilder, ParsedRollBuilder, PooledRollBuilder, type Resolution, RollBuilder, type RollConfig, type RollFactory, RollType, SaveBuilder, type SaveOutcome, type SaveResolution, ScaleRollBuilder, builderPMFCache, d, d10, d100, d12, d20, d4, d6, d8, defaultConfig, flat, hd20, roll, sumRolls };

package/dist/builder/index.js

@@ -42,6 +42,7 @@ var LRUCache = class {
 
 // src/common/types.ts
 var EPS = 1e-12;
+var MISS_NONE_OUTCOME = "missNone";
 
 // src/pmf/query.ts
 var _DiceQuery = class _DiceQuery {
@@ -104,6 +105,29 @@ var _DiceQuery = class _DiceQuery {
     this._combinedWithAttr = normalized;
     return normalized;
   }
+  /**
+   * Per-label `damage value → probability mass` series for the combined,
+   * attribution-carrying distribution — the provenance core of the stacked
+   * damage-attribution chart. Convenience for
+   * `combinedWithAttribution().attributionByValue()`; see
+   * {@link PMF.attributionByValue}.
+   */
+  attributionByValue() {
+    return this.combinedWithAttribution().attributionByValue();
+  }
+  /**
+   * How many of the independent single PMFs can produce the given outcome
+   * label. Useful for "all of them succeeded" style probabilities where the
+   * exponent is the number of contributing attacks (see
+   * {@link DiceQuery.probExactlyK}).
+   */
+  countSinglesWith(label) {
+    let count = 0;
+    for (const single of this.singles) {
+      if (single.hasOutcome(label)) count++;
+    }
+    return count;
+  }
   /**
    * Returns the expected damage across all possible outcomes.
    *
@@ -1387,6 +1411,20 @@ var _PMF = class _PMF {
   static delta(value, epsilon = EPS) {
     return _PMF.fromMap(/* @__PURE__ */ new Map([[value, 1]]), epsilon);
   }
+  /**
+   * Point mass at damage 0 tagged with the canonical `missNone` outcome.
+   *
+   * Differs from {@link PMF.zero}, which labels its zero bin `miss` — the
+   * builder's attack-resolution vocabulary. This uses the `missNone`
+   * {@link OutcomeType} that the attribution charts and outcome stats key on,
+   * so it is the correct "clean miss / no damage" delta for provenance-aware
+   * mixtures feeding those consumers.
+   */
+  static missNone(epsilon = EPS) {
+    const m = /* @__PURE__ */ new Map();
+    m.set(0, { p: 1, count: { [MISS_NONE_OUTCOME]: 1 }, attr: {} });
+    return new _PMF(m, epsilon, false, "missNone");
+  }
   // This creates a single bin at value 0, but with weight 0.
   static emptyMass() {
     return _PMF.zero().scaleMass(0);
@@ -1908,6 +1946,49 @@ var _PMF = class _PMF {
       `${this.identifier}+scaled(${branch.identifier},${probability})`
     );
   }
+  /**
+   * Redistributes probability mass to model an effect that only occurs with
+   * probability `frequency` — a conditional attack, an on-hit rider, or a
+   * sub-one AoE target fraction.
+   *
+   * Every hit outcome (damage > 0) is scaled by `frequency` — probability mass,
+   * per-label `count`, AND per-label `attr` — and the freed mass is moved into
+   * the miss bin at damage 0, tagged with the canonical `missNone` outcome.
+   * Total probability mass is preserved.
+   *
+   * Unlike a bare {@link scaleMass} or {@link mapDamage}, this keeps damage
+   * attribution (`attr`) intact, so a frequency-scaled PMF still renders
+   * correctly in the damage-attribution charts.
+   *
+   * `frequency >= 1` (or non-finite) returns this PMF unchanged; `frequency <= 0`
+   * collapses all mass into the miss bin. The miss outcome is assumed to be
+   * encoded at damage value 0.
+   *
+   * @param frequency Probability in [0, 1] that the effect occurs.
+   */
+  applyHitFrequency(frequency) {
+    if (!Number.isFinite(frequency) || frequency >= 1) return this;
+    const freq = Math.max(0, frequency);
+    const pMiss = this.pAt(0);
+    const pHit = 1 - pMiss;
+    const newMissMass = pMiss + (1 - freq) * pHit;
+    const newMap = /* @__PURE__ */ new Map();
+    newMap.set(0, {
+      p: newMissMass,
+      count: { [MISS_NONE_OUTCOME]: newMissMass },
+      attr: {}
+    });
+    for (const [damage, bin] of this.map) {
+      if (damage <= 0) continue;
+      newMap.set(damage, _PMF.scaleBin(bin, freq));
+    }
+    return new _PMF(
+      newMap,
+      this.epsilon,
+      false,
+      `freq(${this.identifier},${freq})`
+    );
+  }
   scaleMass(factor) {
     if (factor === 1) return this;
     const scaledMap = /* @__PURE__ */ new Map();
@@ -2135,6 +2216,39 @@ var _PMF = class _PMF {
   pAt(x) {
     return this.map.get(x)?.p ?? 0;
   }
+  /**
+   * P(any damage) — the mass on all non-zero outcomes, i.e. `1 - P(0)`.
+   * Assumes a miss is encoded as the damage-0 bin (the convention used across
+   * attack/save PMFs). The dual of {@link missProbability}.
+   */
+  hitProbability() {
+    return 1 - this.pAt(0);
+  }
+  /** P(no damage) — the mass at damage 0. The dual of {@link hitProbability}. */
+  missProbability() {
+    return this.pAt(0);
+  }
+  /**
+   * Coarsen the distribution into at most `maxBuckets` contiguous, equal-width
+   * damage buckets, aggregating probability mass (and `count`/`attr`
+   * provenance) into each bucket's start value. Returns this PMF unchanged when
+   * its integer support already fits within `maxBuckets`.
+   *
+   * This is a lossy display/downsampling transform (bucket start replaces the
+   * exact damage value) — use it for charting wide distributions, not for DPR
+   * math.
+   */
+  rebin(maxBuckets) {
+    if (!(maxBuckets > 0)) return this;
+    const support = this.support();
+    if (support.length === 0) return this;
+    const min = support[0];
+    const max = support[support.length - 1];
+    const range = max - min;
+    if (range + 1 <= maxBuckets) return this;
+    const binSize = Math.ceil((range + 1) / maxBuckets);
+    return this.mapDamage((d2) => min + Math.floor((d2 - min) / binSize) * binSize);
+  }
   /** Dense integer support from min..max (inclusive).
    * Useful for showing empty bars in charts.
    */
@@ -2210,6 +2324,56 @@ var _PMF = class _PMF {
     }
     return false;
   }
+  /**
+   * Split each damage value's probability mass across outcome labels, returning
+   * per-label maps of `damage value → probability mass attributable to that
+   * label`. Summing over labels at a given value recovers that value's `p`.
+   *
+   * Damage-bearing bins are split by `attr` weight (the share of damage each
+   * outcome contributed); the clean-miss bin at 0 is split by `count` weight
+   * (there is no damage to attribute). Attribution is computed on demand via
+   * {@link withAttribution} when absent, so builder-generated PMFs work too.
+   *
+   * This is the provenance core of the stacked damage-attribution chart — the
+   * caller only maps these series into its rendering format (colors, binning,
+   * axis labels).
+   */
+  attributionByValue() {
+    const src = this.hasAttribution() ? this : this.withAttribution();
+    const result = /* @__PURE__ */ new Map();
+    const add = (label, damage, mass) => {
+      if (!(mass > 0)) return;
+      let series = result.get(label);
+      if (!series) {
+        series = /* @__PURE__ */ new Map();
+        result.set(label, series);
+      }
+      series.set(damage, (series.get(damage) ?? 0) + mass);
+    };
+    for (const [damage, bin] of src.map) {
+      const p = bin.p || 0;
+      if (p <= 0) continue;
+      const isMissBin = damage === 0;
+      if (isMissBin) {
+        let totalCount = 0;
+        for (const k in bin.count) totalCount += bin.count[k] || 0;
+        if (totalCount > 0) {
+          const c = bin.count[MISS_NONE_OUTCOME] || 0;
+          add(MISS_NONE_OUTCOME, damage, c / totalCount * p);
+        }
+        continue;
+      }
+      let totalAttr = 0;
+      if (bin.attr) for (const k in bin.attr) totalAttr += bin.attr[k] || 0;
+      if (bin.attr && totalAttr > 0) {
+        for (const k in bin.attr) {
+          if (k === MISS_NONE_OUTCOME) continue;
+          add(k, damage, (bin.attr[k] || 0) / totalAttr * p);
+        }
+      }
+    }
+    return result;
+  }
   tailProbGE(t) {
     let s = 0;
     for (const [x, bin] of this) {
@@ -3928,6 +4092,15 @@ var RollBuilder = class _RollBuilder {
   half() {
     return new HalfRollBuilder(this);
   }
+  /**
+   * Scale this roll's result by `numerator / denominator`, rounding each outcome.
+   * A general, composable form of {@link half} — used to model damage-type resistance
+   * (`scaleResult(1, 2)` → `(expr) // 2`) and vulnerability (`scaleResult(2)` → `2 * (expr)`).
+   * Compose several of these (and plain rolls) into one payload with {@link sumRolls}.
+   */
+  scaleResult(numerator, denominator = 1, rounding = "floor") {
+    return new ScaleRollBuilder(this, numerator, denominator, rounding);
+  }
   // Create a "max of N rolls" version of this roll for crit damage with keep operations
   maxOf(count) {
     return new MaxOfRollBuilder(this, count);
@@ -3982,6 +4155,50 @@ var HalfRollBuilder = class _HalfRollBuilder extends RollBuilder {
     return new _HalfRollBuilder(this.innerRoll.copy());
   }
 };
+var ScaleRollBuilder = class _ScaleRollBuilder extends RollBuilder {
+  constructor(innerRoll, numerator, denominator = 1, rounding = "floor") {
+    super(0);
+    this.innerRoll = innerRoll;
+    this.numerator = numerator;
+    this.denominator = denominator;
+    this.rounding = rounding;
+  }
+  hasHiddenState() {
+    return this.innerRoll.hasHiddenState();
+  }
+  get lastConfig() {
+    return this.innerRoll.lastConfig;
+  }
+  getSubRollConfigs() {
+    return this.innerRoll.getSubRollConfigs();
+  }
+  toExpression() {
+    const inner = this.innerRoll.toExpression();
+    if (this.denominator === 1) return `${this.numerator} * (${inner})`;
+    if (this.numerator === 1) return `(${inner}) // ${this.denominator}`;
+    return `(${inner}) * ${this.numerator} // ${this.denominator}`;
+  }
+  toAST() {
+    return {
+      type: "scale",
+      numerator: this.numerator,
+      denominator: this.denominator,
+      rounding: this.rounding,
+      child: this.innerRoll.toAST()
+    };
+  }
+  toPMF(eps = 0) {
+    return pmfFromRollBuilder(this, eps);
+  }
+  copy() {
+    return new _ScaleRollBuilder(
+      this.innerRoll.copy(),
+      this.numerator,
+      this.denominator,
+      this.rounding
+    );
+  }
+};
 var MaxOfRollBuilder = class _MaxOfRollBuilder extends RollBuilder {
   constructor(innerRoll, count, diceCount, diceSides) {
     super(0);
@@ -4280,6 +4497,49 @@ var PooledRollBuilder = class _PooledRollBuilder extends RollBuilder {
     return new _PooledRollBuilder(sumNode, newExpr);
   }
 };
+var CompositeSumRollBuilder = class _CompositeSumRollBuilder extends RollBuilder {
+  constructor(parts) {
+    super(0);
+    this.parts = parts;
+  }
+  hasHiddenState() {
+    return true;
+  }
+  getSubRollConfigs() {
+    return [];
+  }
+  toAST() {
+    return {
+      type: "add",
+      children: this.parts.map((p) => ({
+        node: p.toAST(),
+        sign: 1
+      }))
+    };
+  }
+  toExpression() {
+    const exprs = this.parts.map((p) => p.toExpression()).filter((e) => e && e !== "0");
+    if (exprs.length === 0) return "0";
+    let result = exprs[0];
+    for (let i = 1; i < exprs.length; i++) {
+      const e = exprs[i];
+      result += e.startsWith("-") ? ` - ${e.substring(1)}` : ` + ${e}`;
+    }
+    return result.replace(/\+ -/g, "-");
+  }
+  toPMF(eps = 0) {
+    return pmfFromRollBuilder(this, eps);
+  }
+  copy() {
+    return new _CompositeSumRollBuilder(this.parts.map((p) => p.copy()));
+  }
+};
+function sumRolls(parts) {
+  const meaningful = parts.filter((p) => p !== void 0);
+  if (meaningful.length === 0) return new RollBuilder(0);
+  if (meaningful.length === 1) return meaningful[0];
+  return new CompositeSumRollBuilder(meaningful);
+}
 
 // src/builder/factory.ts
 var rollFn = (count, sidesOrDie, modifier) => {
@@ -4510,6 +4770,11 @@ function resolve(node, eps = defaultEps) {
         if (count === 1) return childPMF;
         return computeMaxOfPMF(childPMF, count, eps);
       }
+      case "scale": {
+        const childPMF = resolve(node.child, eps);
+        const denom = node.denominator === 0 ? 1 : node.denominator;
+        return childPMF.scaleDamage(node.numerator / denom, node.rounding);
+      }
     }
   })();
   builderPMFCache.set(cacheKey, result);
@@ -4581,6 +4846,7 @@ function findDie(node) {
     case "d20Roll":
     case "half":
     case "maxOf":
+    case "scale":
       return findDie(node.child);
     case "keep":
       return findDie(node.child.child);
@@ -4765,6 +5031,8 @@ function getASTSignature(node) {
       return `half{ch:${getASTSignature(node.child)}}`;
     case "maxOf":
       return `maxOf{c:${node.count},ch:${getASTSignature(node.child)}}`;
+    case "scale":
+      return `scale{n:${node.numerator},d:${node.denominator},r:${node.rounding},ch:${getASTSignature(node.child)}}`;
     case "add": {
       let constantValue = 0;
       const otherChildrenSigs = [];
@@ -5201,6 +5469,6 @@ RollBuilder.prototype.dc = function(saveDC) {
   return new DCBuilder(this).dc(saveDC);
 };
 
-export { ACBuilder, AlwaysCritBuilder, AlwaysHitBuilder, AttackBuilder, DCBuilder, HalfRollBuilder, MaxOfRollBuilder, ParsedRollBuilder, PooledRollBuilder, RollBuilder, SaveBuilder, builderPMFCache, d, d10, d100, d12, d20, d4, d6, d8, defaultConfig, flat, hd20, roll };
+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 };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map