@yipe/dice 0.8.1 → 0.10.0

package/dist/builder/index.cjs

@@ -117,6 +117,10 @@ var _DiceQuery = class _DiceQuery {
     if (this._combinedWithAttr) {
       return this._combinedWithAttr;
     }
+    if (this._combinedProvided) {
+      this._combinedWithAttr = this.combined.withAttribution();
+      return this._combinedWithAttr;
+    }
     if (this.singles.every((pmf) => pmf.hasAttribution())) {
       this._combinedWithAttr = this.combined;
       return this._combinedWithAttr;
@@ -887,6 +891,55 @@ var _DiceQuery = class _DiceQuery {
     }
     return out;
   }
+  /**
+   * Per-outcome probabilities and damage ranges, aggregated over the individual
+   * singles rather than read off the combined distribution.
+   *
+   * `damageRange` is the sum, over every single that can produce the outcome, of
+   * that single's own conditional damage range: "what this outcome contributes
+   * across the whole turn when every attack that can produce it does". Linear in
+   * the number of attacks by construction.
+   *
+   * Prefer this over {@link DiceQuery.snapshot} for a multi-attack query.
+   * `snapshot` reads `damageRange` off the combined PMF's `count`, which the
+   * convolution accumulates as an expected count, so its `avg` is size-biased
+   * for N≥2 (its own doc comment says so). The two agree for a single attack.
+   *
+   * Only outcomes that actually occur appear in the result.
+   *
+   * Like every `singles`-based helper on this class, it describes the singles
+   * and not an explicitly provided `combined`. `Turn.toQuery()` supplies one whose
+   * distribution also contains rider attacks that are absent from `singles`
+   * (an `otherwise([unarmed, unarmed])` flurry, say), so those attacks do not
+   * appear here. For rider-inclusive figures read the combined distribution
+   * directly: {@link DiceQuery.outcomeTotals}, {@link DiceQuery.outcomeDamageRanges}.
+   *
+   * @param outcomes Which outcomes to consider; defaults to every canonical one.
+   */
+  outcomeStats(outcomes = ALL_OUTCOME_TYPES) {
+    const stats = /* @__PURE__ */ new Map();
+    const perSingle = this.singles.map((pmf) => new _DiceQuery([pmf], void 0, this._eps));
+    for (const outcome of outcomes) {
+      const atLeastOneProbability = this.probAtLeastOne(outcome);
+      if (atLeastOneProbability <= 0) continue;
+      const damageRange = { min: 0, avg: 0, max: 0 };
+      let contributors = 0;
+      for (const single of perSingle) {
+        if (single.probAtLeastOne(outcome) <= 0) continue;
+        contributors++;
+        const stat = single.damageStatsFrom(outcome);
+        damageRange.min += stat.min;
+        damageRange.avg += stat.avg;
+        damageRange.max += stat.max;
+      }
+      stats.set(outcome, {
+        atLeastOneProbability,
+        allProbability: contributors > 0 ? this.probExactlyK(outcome, contributors) : 0,
+        damageRange
+      });
+    }
+    return stats;
+  }
   /**
    * 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)
@@ -1423,7 +1476,7 @@ var _PMF = class _PMF {
     const id = this.identifier;
     let key = `${id}`;
     for (let i = 1; i < n; i++) key += `+${id}`;
-    return `${key}@${eps}`;
+    return `${key}@${eps}|${this.fingerprint()}`;
   }
   /**
    * Efficiently computes this PMF convolved with itself `n` times.
@@ -1774,16 +1827,27 @@ var _PMF = class _PMF {
     return `v4:${raw ? "RAW" : "N"}:${id1}+${id2}@${eps}|${p1.fingerprint()}|${p2.fingerprint()}`;
   }
   /**
-   * A small content fingerprint (mass + bin count + face sum) so convolution
-   * cache keys change if the underlying numbers do. Memoized because a PMF is
-   * immutable once constructed — this avoids re-summing every key on each
-   * convolve() call (including cache hits).
+   * A content fingerprint of every bin (probability, per-label `count`, per-label `attr`) plus
+   * the `normalized` flag, so convolution/power cache keys change whenever the underlying
+   * numbers do. Mass/bin-count/face-sum alone are not content-unique: `mapDamage` variants can
+   * keep the same identifier, support, mass, and face sum while differing in per-bin
+   * probabilities or in the `count`/`attr` channels `convolve()`/`power()` actually propagate --
+   * that previously let `power()` return one PMF's cached result for a different PMF. Memoized
+   * because a PMF is immutable once constructed -- this avoids re-deriving the key on every
+   * convolve()/power() call (including cache hits). Bin order is sorted by damage value (and
+   * label keys sorted within each bin) so two equal-content PMFs built via different code paths
+   * fingerprint identically regardless of Map insertion order.
    */
   fingerprint() {
     if (this._fingerprint === void 0) {
-      let faceSum = 0;
-      for (const k of this.map.keys()) faceSum += k;
-      this._fingerprint = `${this.mass().toFixed(12)}|${this.map.size}|${faceSum}`;
+      const bins = [...this.map.entries()].sort((a, b) => a[0] - b[0]);
+      const parts = [];
+      for (const [damageValue, bin] of bins) {
+        const countStr = Object.keys(bin.count).sort().map((k) => `${k}:${bin.count[k]}`).join(",");
+        const attrStr = bin.attr ? Object.keys(bin.attr).sort().map((k) => `${k}:${bin.attr[k]}`).join(",") : "";
+        parts.push(`${damageValue}:${bin.p}[${countStr}]{${attrStr}}`);
+      }
+      this._fingerprint = `${this.normalized ? 1 : 0}|${parts.join(";")}`;
     }
     return this._fingerprint;
   }
@@ -2015,11 +2079,13 @@ var _PMF = class _PMF {
   /** Quantile / inverse CDF for p in [0,1]. Returns smallest x with CDF ≥ p. */
   quantile(p) {
     if (this.map.size === 0) return 0;
+    const totalMass = this.mass();
+    if (totalMass <= 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;
+      if (acc / totalMass >= p) return x;
     }
     return s[s.length - 1];
   }
@@ -2998,6 +3064,12 @@ function combineDiceWithNormalization(dice, normValue, outcomeType, currentNorm,
   finalResult = finalResult.combine(dice);
   return { newNorm: currentNorm * normValue, updatedResult: finalResult };
 }
+function subtractCounts(a, b) {
+  const result = new Dice();
+  for (const [key, value] of a.getFaceEntries()) result.increment(key, value);
+  for (const [key, value] of b.getFaceEntries()) result.increment(key, -value);
+  return result;
+}
 function parseExpression(arr, n) {
   const result = (() => {
     const res = parseArgument(arr, n);
@@ -3005,8 +3077,29 @@ function parseExpression(arr, n) {
   })();
   let op = parseOperation(arr);
   let finalResult = result;
+  let baseDieMeta = result.privateData?.checkDie && !result.privateData.checkDie.rerollOne ? result.privateData.checkDie : void 0;
+  let bonusOnly = Dice.scalar(0);
   while (op != null) {
     const arg = !op.unary ? parseArgument(arr, n) : finalResult;
+    let acAlreadyApplied = false;
+    if (baseDieMeta) {
+      if (op === Dice.prototype.addNonZero) {
+        bonusOnly = bonusOnly.add(arg);
+      } else if (op === Dice.prototype.subtract) {
+        bonusOnly = bonusOnly.subtract(arg);
+      } else if (op === Dice.prototype.ac && typeof arg === "number") {
+        const natMaxSlice = bonusOnly.add(baseDieMeta.sides);
+        const restSlice = subtractCounts(finalResult, natMaxSlice);
+        const gatedNatMaxSlice = natMaxSlice.ac(arg);
+        finalResult = restSlice.ac(arg).combine(gatedNatMaxSlice);
+        finalResult.privateData.checkDie = baseDieMeta;
+        finalResult.privateData.natMaxCritSlice = gatedNatMaxSlice;
+        acAlreadyApplied = true;
+        baseDieMeta = void 0;
+      } else {
+        baseDieMeta = void 0;
+      }
+    }
     let crit;
     let critNorm = 1;
     if (arr[0] === "x" || arr[0] === "c") {
@@ -3017,11 +3110,17 @@ function parseExpression(arr, n) {
       assertToken(arr, "i");
       assertToken(arr, "t");
       const count = isXcrit ? parseNumber(arr, n) : 1;
-      crit = new Dice();
-      for (let i = 0; i < count; i++) {
-        const max = finalResult.maxFace();
-        crit.setFace(max, finalResult.get(max));
-        finalResult = finalResult.deleteFace(max);
+      const trackedCritSlice = finalResult.privateData?.natMaxCritSlice;
+      if (count === 1 && trackedCritSlice) {
+        crit = trackedCritSlice;
+        finalResult = subtractCounts(finalResult, trackedCritSlice);
+      } else {
+        crit = new Dice();
+        for (let i = 0; i < count; i++) {
+          const max = finalResult.maxFace();
+          crit.setFace(max, finalResult.get(max));
+          finalResult = finalResult.deleteFace(max);
+        }
       }
       critNorm = crit.total();
       crit = op.call(crit, parseBinaryArgument(arg, arr, n));
@@ -3072,7 +3171,9 @@ function parseExpression(arr, n) {
       missNorm = miss && missNorm ? miss.total() / missNorm : 1;
     }
     let norm = finalResult.total();
-    finalResult = op.call(finalResult, arg);
+    if (!acAlreadyApplied) {
+      finalResult = op.call(finalResult, arg);
+    }
     norm = norm ? finalResult.total() / norm : 1;
     if (crit) {
       const result2 = combineDiceWithNormalization(
@@ -3263,6 +3364,7 @@ function parseDice(s, n) {
   if (rerollOne) {
     result = result.reroll(1);
   }
+  result.privateData.checkDie = { sides, rerollOne };
   return result;
 }
 function peek(arr, expected) {
@@ -3454,6 +3556,12 @@ function d20PMF(rerollOne) {
 }
 
 // src/builder/roll.ts
+function validateScaleInt(scale) {
+  const scaleInt = Math.floor(scale);
+  if (scaleInt !== scale) throw new Error("Scale must be an integer");
+  if (scaleInt <= 0) throw new Error("Scale must be > 0");
+  return scaleInt;
+}
 var rollPMFCache = new LRUCache(4e3);
 function clearRollCache() {
   rollPMFCache.clear();
@@ -3659,7 +3767,8 @@ var RollBuilder = class _RollBuilder {
     newConfigs[newConfigs.length - 1].explode = count;
     return this.create(newConfigs);
   }
-  /** Apply per-die minimum value (min > 0). */
+  /** Apply per-die minimum value (floors each die roll at `val`, e.g. `minimum(3)` treats a 1 or
+   * 2 as a 3 -- the 2024 Great Weapon Fighting style). */
   minimum(val) {
     if (val !== void 0 && isNaN(val))
       throw new Error("Invalid NaN value for minimum");
@@ -3667,7 +3776,7 @@ var RollBuilder = class _RollBuilder {
     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;
+    newConfigs[newConfigs.length - 1].minimum = val;
     return this.create(newConfigs);
   }
   bestOf(count) {
@@ -3768,9 +3877,7 @@ var RollBuilder = class _RollBuilder {
     return this.create(configs);
   }
   scaleDice(scale) {
-    const scaleInt = Math.floor(scale);
-    if (scaleInt !== scale) throw new Error("Scale must be an integer");
-    if (scaleInt <= 0) throw new Error("Scale must be > 0");
+    const scaleInt = validateScaleInt(scale);
     const newConfigs = this.getSubRollConfigs().map((config) => {
       if (!config.sides || config.sides <= 0) return config;
       return { ...config, count: config.count * scaleInt };
@@ -3893,12 +4000,16 @@ var RollBuilder = class _RollBuilder {
   }
   configToSingleExpressionWithoutModifier(config, isRootDie) {
     if (!config.sides || config.sides <= 0) return "";
+    if (config.explode && Number.isFinite(config.explode) && config.explode > 0) {
+      throw new Error(
+        `toExpression() cannot represent an exploding die (d${config.sides} explode(${config.explode})): the string grammar has no explode syntax. Use the builder's own PMF (.toPMF()/.pmf) instead of round-tripping through toExpression()/parse().`
+      );
+    }
     let baseDie = `d${config.sides}`;
+    const rerollClause = config.reroll > 0 ? config.reroll === 1 ? " reroll 1" : ` reroll d${config.reroll}` : "";
     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 && config.explode > 0) ; else {
+        baseDie += rerollClause;
       }
     }
     if (config.minimum > 0) {
@@ -3908,9 +4019,7 @@ var RollBuilder = class _RollBuilder {
         baseDie = `${config.minimum}>${baseDie}`;
       }
       if (config.reroll > 0 && config.explode > 0) {
-        for (let i = 1; i <= config.reroll; i++) {
-          baseDie += ` reroll ${i}`;
-        }
+        baseDie += rerollClause;
       }
     }
     if (baseDie === "d20 reroll 1" && config.minimum <= 1) baseDie = "hd20";
@@ -3928,10 +4037,14 @@ var RollBuilder = class _RollBuilder {
       case "flat":
         if (config.keep) {
           const mode = config.keep.mode === "highest" ? "kh" : "kl";
+          const baseCount = Math.max(1, Math.floor(Math.abs(config.count || 1)));
+          const trials = Math.max(1, Math.floor(config.keep.total));
+          const isMaxOfShape = config.keep.count === 1 && config.keep.mode === "highest";
+          const innerCount = trials === baseCount && !isMaxOfShape ? 1 : baseCount;
           const baseDieExpression = this.configToSingleExpressionWithoutModifier(
             {
               ...config,
-              count: config.count,
+              count: innerCount,
               modifier: 0,
               rollType: "flat",
               keep: void 0
@@ -3963,7 +4076,19 @@ var RollBuilder = class _RollBuilder {
           }
         }
         if (config.bestOf && config.count && config.bestOf < config.count) {
-          mainExpression += `kh${config.bestOf}`;
+          const pool = Math.max(1, Math.floor(Math.abs(config.count)));
+          const baseDieExpression = this.configToSingleExpressionWithoutModifier(
+            {
+              ...config,
+              count: 1,
+              modifier: 0,
+              bestOf: 0,
+              keep: void 0,
+              rollType: "flat"
+            },
+            false
+          );
+          mainExpression = `${pool}kh${Math.floor(config.bestOf)}(${baseDieExpression})`;
         }
         break;
     }
@@ -4066,6 +4191,12 @@ var HalfRollBuilder = class _HalfRollBuilder extends RollBuilder {
   toPMF(eps = 0) {
     return pmfFromRollBuilder(this, eps);
   }
+  // Scale the dice, keep the same // 2 (half) transform applied on top -- delegating to the
+  // base class's `create()`-based scaleDice would drop the halving entirely, e.g. a doubled-dice
+  // crit on a resisted hit payload silently losing the resistance.
+  scaleDice(scale) {
+    return new _HalfRollBuilder(this.innerRoll.scaleDice(scale));
+  }
   copy() {
     return new _HalfRollBuilder(this.innerRoll.copy());
   }
@@ -4092,9 +4223,16 @@ var ScaleRollBuilder = class _ScaleRollBuilder extends RollBuilder {
   }
   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}`;
+    const denominator = this.denominator === 0 ? 1 : this.denominator;
+    if (denominator === 1) return `${this.numerator} ** (${inner})`;
+    if (this.rounding === "round") {
+      throw new Error(
+        `toExpression() cannot represent scaleResult(${this.numerator}, ${this.denominator}, "round"): the string grammar has only floor (//) and ceil (/) division. Use the builder's own PMF (.toPMF()/.pmf) instead.`
+      );
+    }
+    const div = this.rounding === "ceil" ? "/" : "//";
+    if (this.numerator === 1) return `(${inner}) ${div} ${denominator}`;
+    return `(${inner}) ** ${this.numerator} ${div} ${denominator}`;
   }
   toAST() {
     return {
@@ -4108,6 +4246,17 @@ var ScaleRollBuilder = class _ScaleRollBuilder extends RollBuilder {
   toPMF(eps = 0) {
     return pmfFromRollBuilder(this, eps);
   }
+  // Scale the dice, keep the same numerator/denominator/rounding transform applied on top --
+  // delegating to the base class's `create()`-based scaleDice would drop the scale entirely,
+  // e.g. a doubled-dice crit on a vulnerable hit payload silently losing the vulnerability.
+  scaleDice(scale) {
+    return new _ScaleRollBuilder(
+      this.innerRoll.scaleDice(scale),
+      this.numerator,
+      this.denominator,
+      this.rounding
+    );
+  }
   copy() {
     return new _ScaleRollBuilder(
       this.innerRoll.copy(),
@@ -4180,6 +4329,18 @@ var MaxOfRollBuilder = class _MaxOfRollBuilder extends RollBuilder {
   toPMF(eps = 0) {
     return pmfFromRollBuilder(this, eps);
   }
+  // Scale the dice INSIDE each trial (e.g. maxOf(2, 1d12) -> maxOf(2, 2d12)), keeping the same
+  // trial count -- delegating to the base class's `create()`-based scaleDice would collapse
+  // straight to plain dice, losing the "take the highest of N trials" semantics entirely.
+  scaleDice(scale) {
+    const scaleInt = validateScaleInt(scale);
+    return new _MaxOfRollBuilder(
+      this.innerRoll.scaleDice(scaleInt),
+      this.count,
+      this.diceCount ? this.diceCount * scaleInt : void 0,
+      this.diceSides
+    );
+  }
   copy() {
     return new _MaxOfRollBuilder(this.innerRoll.copy(), this.count);
   }
@@ -4226,9 +4387,7 @@ var AlwaysHitBuilder = class _AlwaysHitBuilder extends RollBuilder {
     return new RollBuilder(configs).toExpression();
   }
   toPMF() {
-    const rollType = this.rollType;
-    const rerollOne = this.baseReroll > 0;
-    return d20RollPMF(rollType, rerollOne);
+    return resolveRootD20(this);
   }
   copy() {
     const baseCopy = new RollBuilder(this.getSubRollConfigs());
@@ -4276,9 +4435,7 @@ var AlwaysCritBuilder = class _AlwaysCritBuilder extends RollBuilder {
     return new RollBuilder(configs).toExpression();
   }
   toPMF() {
-    const rollType = this.rollType;
-    const rerollOne = this.baseReroll > 0;
-    return d20RollPMF(rollType, rerollOne);
+    return resolveRootD20(this);
   }
   copy() {
     const baseCopy = new RollBuilder(this.getSubRollConfigs());
@@ -4468,6 +4625,17 @@ var CompositeSumRollBuilder = class _CompositeSumRollBuilder extends RollBuilder
   toPMF(eps = 0) {
     return pmfFromRollBuilder(this, eps);
   }
+  // Scaling a composite (mixed damage types, e.g. base + resisted) must scale each PART's own
+  // dice while preserving its own half/scale wrapper -- delegating to the base class's
+  // `create()`-based scaleDice would lose every part's transform, collapsing straight to plain
+  // dice. This is what auto-crit doubling (attack.ts's `hitEffect.copy().doubleDice()`) relies
+  // on for a mixed-resistance hit payload.
+  scaleDice(scale) {
+    validateScaleInt(scale);
+    return new _CompositeSumRollBuilder(
+      this.parts.map((p) => p.scaleDice(scale))
+    );
+  }
   copy() {
     return new _CompositeSumRollBuilder(this.parts.map((p) => p.copy()));
   }
@@ -4545,6 +4713,15 @@ var builderPMFCache = new LRUCache(1e3);
 // src/builder/ast.ts
 var defaultEps = 0;
 var singleDiePMFCache = new LRUCache(1e3);
+function dieNodeFromConfig(cfg) {
+  return {
+    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
+  };
+}
 function astFromRollConfigs(configs) {
   if (!configs || configs.length === 0) return void 0;
   const children = [];
@@ -4554,13 +4731,9 @@ function astFromRollConfigs(configs) {
     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
-    };
+    const isSynthesizedBestOf = !cfg.keep && cfg.bestOf > 0 && cfg.bestOf < count;
+    const effectiveKeep = isSynthesizedBestOf ? { total: count, count: Math.floor(cfg.bestOf), mode: "highest" } : cfg.keep;
+    const die = dieNodeFromConfig(cfg);
     let node = die;
     let appliedRollType = false;
     if (cfg.rollType && cfg.rollType !== "flat") {
@@ -4578,11 +4751,11 @@ function astFromRollConfigs(configs) {
       }
       appliedRollType = true;
     }
-    if (cfg.rollType === "flat" && cfg.keep && cfg.keep.total > 0) {
+    if (cfg.rollType === "flat" && effectiveKeep && effectiveKeep.total > 0) {
       const baseCount = Math.max(1, Math.floor(Math.abs(count || 1)));
-      const trials = Math.max(1, Math.floor(cfg.keep.total));
-      const k = Math.max(0, Math.floor(cfg.keep.count));
-      if (k === 1 && cfg.keep.mode === "highest") {
+      const trials = Math.max(1, Math.floor(effectiveKeep.total));
+      const k = Math.max(0, Math.floor(effectiveKeep.count));
+      if (k === 1 && effectiveKeep.mode === "highest" && !isSynthesizedBestOf) {
         const perTrial = {
           type: "sum",
           count: baseCount,
@@ -4601,7 +4774,7 @@ function astFromRollConfigs(configs) {
         const base = { type: "sum", count: trials, child: node };
         node = {
           type: "keep",
-          mode: cfg.keep.mode,
+          mode: effectiveKeep.mode,
           count: k,
           child: base
         };
@@ -4621,7 +4794,7 @@ function astFromRollConfigs(configs) {
           };
           node = {
             type: "keep",
-            mode: cfg.keep.mode,
+            mode: effectiveKeep.mode,
             count: k,
             child: trialPool
           };
@@ -4695,8 +4868,8 @@ function resolve(node, eps = defaultEps) {
       }
       case "d20Roll": {
         const childDie = findDie(node.child);
-        const rerollOne = !!childDie && (childDie.reroll || 0) >= 1;
-        return d20RollPMF(node.rollType, rerollOne);
+        if (!childDie) return d20RollPMF(node.rollType, false);
+        return resolveD20Roll(childDie, node.rollType);
       }
       case "half": {
         const childPMF = resolve(node.child, eps);
@@ -4722,6 +4895,37 @@ function pmfFromRollBuilder(rb, eps = defaultEps) {
   const ast = rb.toAST();
   return resolve(ast, eps);
 }
+var d20RollLiftCache = new LRUCache(500);
+function resolveD20Roll(die, rollType) {
+  const base = resolveSingleDie(die, defaultEps);
+  const type = rollType || "flat";
+  if (type === "flat") return base;
+  const cacheKey = `${getASTSignature(die)}|${type}`;
+  const cached = d20RollLiftCache.get(cacheKey);
+  if (cached) return cached;
+  const support = [...base.support()].sort((a, b) => a - b);
+  const out = /* @__PURE__ */ new Map();
+  let cum = 0;
+  let prevLifted = 0;
+  for (const k of support) {
+    cum += base.pAt(k);
+    const curLifted = type === "advantage" ? cum * cum : type === "elven accuracy" ? cum * cum * cum : 1 - (1 - cum) * (1 - cum);
+    const pk = curLifted - prevLifted;
+    if (pk > 0) out.set(k, pk);
+    prevLifted = curLifted;
+  }
+  const result = PMF.fromMap(out, defaultEps);
+  d20RollLiftCache.set(cacheKey, result);
+  return result;
+}
+function resolveRootD20(check) {
+  const rootConfig = check.getRootDieConfig();
+  const rollType = check.rollType;
+  if (!rootConfig || !(rootConfig.sides > 0)) {
+    return d20RollPMF(rollType, check.baseReroll > 0);
+  }
+  return resolveD20Roll(dieNodeFromConfig(rootConfig), rollType);
+}
 function resolveSingleDie(die, eps = defaultEps) {
   const signature = getASTSignature(die);
   const cacheKey = `${signature}_${eps}`;
@@ -4755,20 +4959,12 @@ function resolveSingleDie(die, eps = defaultEps) {
     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 nonMaxPMF = PMF.fromMap(nonMax, eps);
+    let chain = pmf;
+    for (let remaining = 1; remaining <= times - 1; remaining++) {
+      chain = PMF.branch(chain.mapDamage((v) => v + maxFace), nonMaxPMF, pMax);
     }
-    const exploded = PMF.branch(
-      tail.mapDamage((v) => v + maxFace),
-      nonMaxPMF,
-      pMax
-    );
+    const exploded = PMF.branch(chain.mapDamage((v) => v + maxFace), nonMaxPMF, pMax);
     pmf = exploded;
   }
   singleDiePMFCache.set(cacheKey, pmf);
@@ -5067,10 +5263,8 @@ var AttackBuilder = class _AttackBuilder {
     return `${checkPart} * ${effectPart}`;
   }
   resolveProbabilities(check, eps = 0) {
-    const rollType = check.rollType;
-    const rerollOne = check.baseReroll > 0;
     const critThreshold = check.critThreshold;
-    const d202 = d20RollPMF(rollType, rerollOne);
+    const d202 = resolveRootD20(check);
     if (check instanceof AlwaysCritBuilder) {
       if (check.fromAlwaysHit) {
         return { pSuccess: 1, pHit: 0, pCrit: 1, pMiss: 0 };
@@ -5120,13 +5314,17 @@ var AttackBuilder = class _AttackBuilder {
         pmiss += pr;
         continue;
       }
-      if (r >= critThreshold) {
+      if (r === 20) {
         pcrit += pr;
         continue;
       }
       const need = ac - staticMod - r;
       const pBonusHit = bonusPMF.tailProbGE(need);
-      phit += pr * pBonusHit;
+      if (r >= critThreshold) {
+        pcrit += pr * pBonusHit;
+      } else {
+        phit += pr * pBonusHit;
+      }
       pmiss += pr * (1 - pBonusHit);
     }
     const psuccess = phit + pcrit;
@@ -5139,11 +5337,11 @@ var AttackBuilder = class _AttackBuilder {
       pMiss: pmiss
     } = this.resolveProbabilities(this.check, eps);
     const hitPMF = this.hitEffect ? this.hitEffect instanceof ParsedRollBuilder ? this.hitEffect.toPMF(eps) : pmfFromRollBuilder(this.hitEffect, eps) : PMF.delta(0, eps);
-    let critPMF = null;
+    let critPMF2 = null;
     let phit = pHit;
     let pcrit = pCrit;
     if (this.critEffect === null) {
-      critPMF = null;
+      critPMF2 = null;
       phit += pcrit;
       pcrit = 0;
     } else {
@@ -5151,7 +5349,7 @@ var AttackBuilder = class _AttackBuilder {
       if (this.critEffect) {
         critBuilder = this.critEffect;
       } else if (this.hitEffect instanceof ParsedRollBuilder) {
-        critPMF = null;
+        critPMF2 = null;
         phit += pcrit;
         pcrit = 0;
         critBuilder = void 0;
@@ -5159,20 +5357,20 @@ var AttackBuilder = class _AttackBuilder {
         critBuilder = this.hitEffect?.copy().doubleDice();
       }
       if (critBuilder) {
-        critPMF = critBuilder instanceof ParsedRollBuilder ? critBuilder.toPMF(eps) : pmfFromRollBuilder(critBuilder, eps);
+        critPMF2 = critBuilder instanceof ParsedRollBuilder ? critBuilder.toPMF(eps) : pmfFromRollBuilder(critBuilder, eps);
       }
     }
     const missPMF = this.missEffect ? this.missEffect instanceof ParsedRollBuilder ? this.missEffect.toPMF(eps) : 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 (critPMF2 && pcrit > 0) mix.add("crit", critPMF2, 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),
+      crit: critPMF2 ?? PMF.delta(0, eps),
       miss: missPMF ?? PMF.delta(0, eps),
       weights: { hit: phit, crit: pcrit, miss: pmiss }
     };
@@ -5274,9 +5472,7 @@ var ACBuilder = class _ACBuilder extends RollBuilder {
   }
   toPMF(eps = 0) {
     const ac = this.attackConfig.ac;
-    const rollType = this.rollType;
-    const rerollOne = this.baseReroll > 0;
-    const d202 = d20RollPMF(rollType, rerollOne);
+    const d202 = resolveRootD20(this);
     const staticMod = this.modifier;
     const bonusPMFs = this.getBonusDicePMFs(this, eps);
     const parts = [d202, ...bonusPMFs];
@@ -5386,21 +5582,17 @@ var SaveBuilder = class _SaveBuilder {
 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 eps = 0;
+  const die = resolveRootD20(check);
   const faceP = /* @__PURE__ */ new Map();
   for (const [r, bin] of die) {
     const pr = bin.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;
+  for (const [r, pr] of faceP) {
     const need = dc - saveBonus - r;
     pSuccess += pr * bonusPMF.tailProbGE(need);
   }
@@ -5470,9 +5662,7 @@ var DCBuilder = class _DCBuilder extends RollBuilder {
       if (cached) return cached;
     }
     const saveDC = this.saveDC;
-    const rollType = this.rollType;
-    const rerollOne = this.baseReroll > 0;
-    const d202 = d20RollPMF(rollType, rerollOne);
+    const d202 = resolveRootD20(this);
     const staticMod = this.modifier;
     const bonusDicePMFs = this.getBonusDiceConfigs().map(
       (cfg) => pmfFromRollBuilder(RollBuilder.fromConfigs([cfg]), eps)
@@ -5500,18 +5690,626 @@ RollBuilder.prototype.dc = function(saveDC) {
   return new DCBuilder(this).dc(saveDC);
 };
 
+// src/turn/types.ts
+var TurnSpecError = class extends Error {
+  constructor(code, id, message) {
+    super(message);
+    this.code = code;
+    this.id = id;
+    this.name = "TurnSpecError";
+  }
+};
+var MAX_TRIGGER_GROUPS = 4;
+
+// src/turn/plan.ts
+var IS_HIT_TRIGGER = {
+  "first-hit": true,
+  "any-crit": true,
+  "any-miss": true,
+  "every-hit": true
+};
+function toPMF(damage, eps, id = "") {
+  const parts = Array.isArray(damage) ? damage : [damage];
+  if (parts.length === 0) return PMF.delta(0, eps);
+  const pmfs = parts.map((part) => {
+    if (part instanceof PMF) return part;
+    if (typeof part.toPMF !== "function") {
+      throw new TurnSpecError(
+        "not-an-attack",
+        id,
+        `"${id}" is neither a PMF nor a builder with toPMF().`
+      );
+    }
+    const resolved = part.toPMF(eps);
+    if (!(resolved instanceof PMF)) {
+      throw new TurnSpecError(
+        "not-an-attack",
+        id,
+        `"${id}" has a toPMF() that did not return a PMF.`
+      );
+    }
+    return resolved;
+  });
+  return PMF.convolveMany(pmfs, eps);
+}
+function critPMF(rider, base, eps) {
+  if (rider.critDamage !== void 0) return toPMF(rider.critDamage, eps);
+  const parts = Array.isArray(rider.damage) ? rider.damage : [rider.damage];
+  const doubled = [];
+  for (const part of parts) {
+    const doublable = part;
+    if (part instanceof PMF || typeof doublable.doubleDice !== "function") {
+      return base;
+    }
+    try {
+      doubled.push(toPMF(doublable.doubleDice(), eps));
+    } catch {
+      return base;
+    }
+  }
+  if (doubled.length === 0) return base;
+  return PMF.convolveMany(doubled, eps);
+}
+function sliceSource(pmf) {
+  const labels = pmf.outcomes();
+  if (!labels.includes("hit") && !labels.includes("crit")) return null;
+  const missParts = ["missNone", "missDamage"].filter((label) => labels.includes(label)).map((label) => pmf.filterOutcome(label));
+  return {
+    hit: labels.includes("hit") ? pmf.filterOutcome("hit") : PMF.emptyMass(),
+    crit: labels.includes("crit") ? pmf.filterOutcome("crit") : PMF.emptyMass(),
+    miss: missParts.length ? missParts.reduce((all, part) => all.add(part)) : PMF.emptyMass()
+  };
+}
+function buildPlan(spec, eps = EPS) {
+  const fail = (code, id, message) => {
+    throw new TurnSpecError(code, id, message);
+  };
+  const attackIds = [];
+  const attackPMFs = [];
+  const attackSlices = [];
+  spec.attacks.forEach((entry, index) => {
+    const named = entry;
+    const hasWrapper = typeof named.id === "string" && named.source !== void 0;
+    const id = hasWrapper ? named.id : `attack ${index + 1}`;
+    const source = hasWrapper ? named.source : entry;
+    const pmf = toPMF(source, eps, id);
+    attackIds.push(id);
+    attackPMFs.push(pmf);
+    attackSlices.push(sliceSource(pmf));
+  });
+  const riders = spec.riders ?? [];
+  const riderIds = riders.map((rider, index) => rider.id ?? `rider ${index + 1}`);
+  const seen = /* @__PURE__ */ new Set();
+  for (const id of [...attackIds, ...riderIds]) {
+    if (seen.has(id)) fail("duplicate-id", id, `Duplicate id "${id}".`);
+    seen.add(id);
+  }
+  const attackIndexById = new Map(attackIds.map((id, index) => [id, index]));
+  const riderIndexById = new Map(riderIds.map((id, index) => [id, index]));
+  const sourceIdsByRider = riders.map((rider, index) => {
+    const id = riderIds[index];
+    if (rider.on === "not-fired") {
+      const target = rider.of;
+      if (target === id) {
+        fail("self-reference", id, `Rider "${id}" cannot depend on itself.`);
+      }
+      const targetIndex = riderIndexById.get(target);
+      if (targetIndex === void 0) {
+        fail(
+          "unknown-id",
+          target,
+          `Rider "${id}" negates "${target}", which is not a rider in this turn.`
+        );
+      }
+      if (riders[targetIndex].on === "every-hit") {
+        fail(
+          "not-an-attack",
+          target,
+          `Rider "${id}" negates "${target}", an every-hit rider, which can fire more than once and so has no single "did not fire" branch.`
+        );
+      }
+      return [target];
+    }
+    const of = [...new Set(rider.of ?? attackIds)];
+    if (of.length === 0) {
+      fail("unknown-id", id, `Rider "${id}" has no sources.`);
+    }
+    for (const sourceId of of) {
+      if (sourceId === id) {
+        fail("self-reference", id, `Rider "${id}" cannot depend on itself.`);
+      }
+      const riderIndex = riderIndexById.get(sourceId);
+      const isAttack = attackIndexById.has(sourceId);
+      if (!isAttack && riderIndex === void 0) {
+        fail(
+          "unknown-id",
+          sourceId,
+          `Rider "${id}" depends on "${sourceId}", which is not in this turn.`
+        );
+      }
+      if (riderIndex !== void 0 && riders[riderIndex].on === "every-hit") {
+        fail(
+          "not-an-attack",
+          sourceId,
+          `Rider "${id}" triggers on "${sourceId}", an every-hit rider. Those are folded into their own sources rather than resolved separately, so they cannot be triggered on \u2014 point at the attacks instead.`
+        );
+      }
+      const slices = isAttack ? attackSlices[attackIndexById.get(sourceId)] : sliceSource(
+        toPMF(riders[riderIndex].damage, eps, sourceId)
+      );
+      if (!slices) {
+        fail(
+          "not-an-attack",
+          sourceId,
+          `Rider "${id}" triggers on "${sourceId}", which has no hit/crit outcomes.`
+        );
+      }
+    }
+    return [...of];
+  });
+  const order = [];
+  const visiting = /* @__PURE__ */ new Set();
+  const done = /* @__PURE__ */ new Set();
+  const visit = (index) => {
+    if (done.has(index)) return;
+    const id = riderIds[index];
+    if (visiting.has(index)) {
+      fail("cycle", id, `Rider "${id}" is part of a dependency cycle.`);
+    }
+    visiting.add(index);
+    for (const sourceId of sourceIdsByRider[index]) {
+      const dependency = riderIndexById.get(sourceId);
+      if (dependency !== void 0) visit(dependency);
+    }
+    visiting.delete(index);
+    done.add(index);
+    order.push(index);
+  };
+  riders.forEach((_, index) => visit(index));
+  const groupIndexByKey = /* @__PURE__ */ new Map();
+  const groupSources = [];
+  const groupOf = (sourceIds) => {
+    const key = JSON.stringify([...sourceIds].sort());
+    const existing = groupIndexByKey.get(key);
+    if (existing !== void 0) return existing;
+    if (groupSources.length >= MAX_TRIGGER_GROUPS) {
+      fail(
+        "too-many-groups",
+        key,
+        `A turn may track at most ${MAX_TRIGGER_GROUPS} distinct trigger source sets.`
+      );
+    }
+    const index = groupSources.length;
+    groupIndexByKey.set(key, index);
+    groupSources.push([...sourceIds]);
+    return index;
+  };
+  const readsByRider = /* @__PURE__ */ new Map();
+  const perHitGroups = /* @__PURE__ */ new Map();
+  for (const index of order) {
+    const rider = riders[index];
+    if (!IS_HIT_TRIGGER[rider.on]) continue;
+    const group = groupOf(sourceIdsByRider[index]);
+    readsByRider.set(index, group);
+    if (rider.on === "every-hit") perHitGroups.set(riderIds[index], group);
+  }
+  const perHitBySource = /* @__PURE__ */ new Map();
+  for (const index of order) {
+    const rider = riders[index];
+    if (rider.on !== "every-hit") continue;
+    const hit = toPMF(rider.damage, eps, riderIds[index]);
+    const payload = { hit, crit: critPMF(rider, hit, eps) };
+    for (const sourceId of sourceIdsByRider[index]) {
+      const existing = perHitBySource.get(sourceId);
+      if (existing) existing.push(payload);
+      else perHitBySource.set(sourceId, [payload]);
+    }
+  }
+  const updatesById = /* @__PURE__ */ new Map();
+  groupSources.forEach((sourceIds, groupIndex) => {
+    for (const sourceId of sourceIds) {
+      const existing = updatesById.get(sourceId);
+      if (existing) existing.push(groupIndex);
+      else updatesById.set(sourceId, [groupIndex]);
+    }
+  });
+  const withPerHit = (slices, id) => {
+    const payloads = perHitBySource.get(id);
+    if (!payloads) return slices;
+    let hit = slices.hit;
+    let crit = slices.crit;
+    for (const payload of payloads) {
+      hit = hit.convolve(payload.hit, eps, true);
+      crit = crit.convolve(payload.crit, eps, true);
+    }
+    return { hit, crit, miss: slices.miss };
+  };
+  const steps = attackIds.map((id, index) => ({
+    id,
+    trigger: null,
+    slices: withPerHit(
+      attackSlices[index] ?? {
+        hit: attackPMFs[index],
+        crit: PMF.emptyMass(),
+        miss: PMF.emptyMass()
+      },
+      id
+    ),
+    damage: null,
+    updates: updatesById.get(id) ?? [],
+    reads: -1,
+    negates: -1
+  }));
+  const stepIndexByRider = /* @__PURE__ */ new Map();
+  const riderSteps = /* @__PURE__ */ new Map();
+  for (const index of order) {
+    const rider = riders[index];
+    if (rider.on === "every-hit") continue;
+    const id = riderIds[index];
+    const hit = toPMF(rider.damage, eps, id);
+    const slices = sliceSource(hit);
+    if (slices && rider.critDamage !== void 0) {
+      fail(
+        "unused-crit-damage",
+        id,
+        `Rider "${id}" rolls its own attack, so its critDamage would never be used. Remove it, or pass plain damage dice instead.`
+      );
+    }
+    const negatedRider = rider.on === "not-fired" ? riderIndexById.get(rider.of) : void 0;
+    const step = {
+      id,
+      trigger: rider,
+      slices: slices ? withPerHit(slices, id) : null,
+      damage: slices ? null : { hit, crit: critPMF(rider, hit, eps) },
+      updates: updatesById.get(id) ?? [],
+      reads: readsByRider.get(index) ?? -1,
+      negates: negatedRider === void 0 ? -1 : stepIndexByRider.get(negatedRider)
+    };
+    steps.push(step);
+    stepIndexByRider.set(index, steps.length - 1);
+    riderSteps.set(id, steps.length - 1);
+  }
+  return {
+    steps,
+    groupCount: groupSources.length,
+    attackPMFs,
+    attackIds,
+    riderIds,
+    riderSteps,
+    perHitGroups
+  };
+}
+
+// src/turn/state.ts
+var FIRST_NONE = 0;
+var FIRST_HIT = 1;
+var FIRST_CRIT = 2;
+var CRIT_BIT = 2;
+var MISS_BIT = 1;
+var START_CODE = FIRST_NONE << 2;
+function advance(code, outcome) {
+  if (outcome === "miss") return code | MISS_BIT;
+  const first = code >> 2;
+  const withCrit = outcome === "crit" ? code | CRIT_BIT : code;
+  if (first !== FIRST_NONE) return withCrit;
+  const nextFirst = outcome === "crit" ? FIRST_CRIT : FIRST_HIT;
+  return nextFirst << 2 | withCrit & (CRIT_BIT | MISS_BIT);
+}
+
+// src/turn/turn.ts
+var OUTCOMES = ["hit", "crit", "miss"];
+function fireMode(step, codes, firedByStep) {
+  const trigger = step.trigger;
+  if (!trigger) return "hit";
+  if (trigger.on === "not-fired") {
+    return firedByStep[step.negates] === null ? "hit" : null;
+  }
+  const code = codes[step.reads];
+  const first = code >> 2;
+  switch (trigger.on) {
+    case "first-hit":
+      if (first === FIRST_NONE) return null;
+      return first === FIRST_CRIT ? "crit" : "hit";
+    case "any-crit":
+      return (code & CRIT_BIT) !== 0 ? "crit" : null;
+    case "any-miss":
+      return (code & MISS_BIT) !== 0 ? "hit" : null;
+    default:
+      return null;
+  }
+}
+var Turn = class _Turn {
+  constructor(attacks, riders, eps) {
+    this.declaredAttacks = [...attacks];
+    this.riders = [...riders];
+    this.eps = eps;
+    this.plan = buildPlan({ attacks: this.declaredAttacks, riders: this.riders }, eps);
+  }
+  /**
+   * Builds a turn from plain data, throwing {@link TurnSpecError} if it is
+   * malformed. Use this from a UI, where `error.code` maps to the field state to
+   * show.
+   */
+  static from(spec, eps = EPS) {
+    return new _Turn(spec.attacks, spec.riders ?? [], eps);
+  }
+  /**
+   * Appends an attack, throwing {@link TurnSpecError} if that makes the turn
+   * invalid.
+   *
+   * A rider with no explicit `of` watches every declared attack *including ones
+   * appended after it*, because `of` is resolved when the plan is built rather
+   * than when the rider is added. Pass an explicit `of` to pin a rider to the
+   * attacks it already saw. One attack must exist before a rider with a default
+   * `of` is added, or the build fails `unknown-id`.
+   */
+  attack(source, id) {
+    const entry = id === void 0 ? source : { id, source };
+    return new _Turn([...this.declaredAttacks, entry], this.riders, this.eps);
+  }
+  /**
+   * Appends `count` copies of the same attack — the Extra Attack case, which is
+   * most of 5e. Argument order mirrors `roll(count, die)`.
+   *
+   * ```ts
+   * turn().attacks(4, greatsword).onEveryHit(d6); // fighter 20 + hunter's mark
+   * ```
+   *
+   * @throws {RangeError} if `count` is not a positive integer.
+   */
+  attacks(count, source) {
+    if (!Number.isInteger(count) || count < 1) {
+      throw new RangeError(
+        `attacks(count) needs a positive integer, got ${count}.`
+      );
+    }
+    const added = new Array(count).fill(source);
+    return new _Turn([...this.declaredAttacks, ...added], this.riders, this.eps);
+  }
+  /**
+   * Appends a rider, throwing {@link TurnSpecError} if that makes the turn
+   * invalid. The `onX` methods below are the readable way to call this.
+   */
+  rider(rider) {
+    return new _Turn(this.declaredAttacks, [...this.riders, rider], this.eps);
+  }
+  /**
+   * Fires once, on the first source that lands, in that source's mode — so a
+   * crit on the first landing attack doubles the rider's dice. Sneak Attack.
+   */
+  onFirstHit(damage, options = {}) {
+    return this.rider({ ...options, damage, on: "first-hit" });
+  }
+  /**
+   * Fires once if any source crit, always in crit mode. Divine Smite: nothing is
+   * lost by holding it for a crit, so this is "any", not "first".
+   */
+  onAnyCrit(damage, options = {}) {
+    return this.rider({ ...options, damage, on: "any-crit" });
+  }
+  /**
+   * Fires once if any source missed. The reroll gate: a reroll is a fresh attack,
+   * so pass one as the damage. Kensei's Unerring Accuracy, Lucky.
+   */
+  onAnyMiss(damage, options = {}) {
+    return this.rider({ ...options, damage, on: "any-miss" });
+  }
+  /**
+   * Fires once per source that lands, in that hit's mode — so it can fire several
+   * times in a turn. Hunter's Mark, Hex, Rage.
+   */
+  onEveryHit(damage, options = {}) {
+    return this.rider({ ...options, damage, on: "every-hit" });
+  }
+  /**
+   * Damage for the turns where the rider added just before this one did *not*
+   * fire: "flurry of blows if I didn't smite".
+   *
+   * ```ts
+   * turn([dagger, dagger])
+   *   .onAnyCrit(roll(2, d8))      // smite
+   *   .otherwise([flurry, flurry]) // ... or two more attacks
+   * ```
+   *
+   * Always binds to the *immediately* preceding rider, so the two are branches of
+   * one decision and can never both land. Note that chaining it therefore
+   * alternates rather than laddering: `a.otherwise(b).otherwise(c)` makes `c`
+   * fire whenever `b` did not, which is exactly when `a` did. For a genuine
+   * three-way priority chain, name the riders and use explicit `not-fired`
+   * triggers against the right one.
+   */
+  otherwise(damage, options = {}) {
+    const index = this.riders.length - 1;
+    if (index < 0) {
+      throw new TurnSpecError(
+        "unknown-id",
+        "",
+        "otherwise() needs a preceding rider to negate."
+      );
+    }
+    const previous = this.riders[index];
+    if (previous.on === "every-hit") {
+      throw new TurnSpecError(
+        "not-an-attack",
+        previous.id ?? `rider ${index + 1}`,
+        "otherwise() cannot negate an every-hit rider: it can fire more than once."
+      );
+    }
+    const target = previous.id ?? `rider ${index + 1}`;
+    const riders = [...this.riders];
+    riders[index] = { ...previous, id: target };
+    riders.push({ ...options, damage, on: "not-fired", of: target });
+    return new _Turn(this.declaredAttacks, riders, this.eps);
+  }
+  /**
+   * The exact joint distribution: mass 1, outcome-labelled. Resolved once and
+   * cached.
+   *
+   * There is no `toPMF(eps)` to match the builders: a turn's epsilon is fixed
+   * when it is constructed, because the plan is validated and its sources are
+   * resolved at that point.
+   */
+  get pmf() {
+    return this.resolve().pmf;
+  }
+  /** Mean damage for the turn. */
+  mean() {
+    return this.pmf.mean();
+  }
+  /**
+   * A query whose `singles` are the **declared attacks** and whose combined
+   * distribution is the exact turn PMF.
+   *
+   * Riders are inside the combined PMF, not in `singles`, so singles-based
+   * helpers (`probAtLeastOne`, `countSinglesWith`, `outcomeStats`) describe the
+   * attacks only. Read rider-inclusive statistics off the combined PMF —
+   * `outcomeTotals`, `outcomeDamageRanges`, `damageAttributionChartModel`.
+   */
+  toQuery() {
+    return new DiceQuery([...this.plan.attackPMFs], this.pmf, this.eps);
+  }
+  /**
+   * Attack ids in declaration order, including the `attack 1`, `attack 2`, …
+   * defaults given to bare sources. These are the names `of` accepts.
+   */
+  get attackIds() {
+    return this.plan.attackIds;
+  }
+  /**
+   * Rider ids in declaration order, including the `rider 1`, `rider 2`, …
+   * defaults. These are the names {@link Turn.fireProbability} accepts.
+   */
+  get riderIds() {
+    return this.plan.riderIds;
+  }
+  /**
+   * P(this rider fired). For an `every-hit` rider it is P(at least one source
+   * hit), since that rider can fire more than once in a turn.
+   *
+   * @throws {TurnSpecError} `unknown-id` if `id` is not a rider — attack ids
+   * included, since attacks always happen and have no firing probability.
+   */
+  fireProbability(id) {
+    const mass = this.resolve().fireMass.get(id);
+    if (mass === void 0) {
+      throw new TurnSpecError(
+        "unknown-id",
+        id,
+        `"${id}" is not a rider in this turn. Riders: ${this.plan.riderIds.map((each) => `"${each}"`).join(", ")}.`
+      );
+    }
+    return mass;
+  }
+  resolve() {
+    if (this.resolved) return this.resolved;
+    const plan = this.plan;
+    const eps = this.eps;
+    const width = plan.groupCount;
+    const start = {
+      codes: new Array(width).fill(START_CODE),
+      pmf: PMF.delta(0, eps),
+      fired: new Array(plan.steps.length).fill(null)
+    };
+    let states = /* @__PURE__ */ new Map([[String.fromCharCode(), start]]);
+    plan.steps.forEach((step, stepIndex) => {
+      const next = /* @__PURE__ */ new Map();
+      const merge = (state) => {
+        const key = String.fromCharCode(...state.codes) + "
" + state.fired.map((mode) => mode === null ? "-" : "+").join("");
+        const existing = next.get(key);
+        if (existing) existing.pmf = existing.pmf.add(state.pmf);
+        else next.set(key, state);
+      };
+      for (const state of states.values()) {
+        const mode = fireMode(step, state.codes, state.fired);
+        const fired = [...state.fired];
+        fired[stepIndex] = mode;
+        if (mode === null) {
+          merge({ codes: state.codes, pmf: state.pmf, fired });
+          continue;
+        }
+        if (!step.slices) {
+          const payload = step.damage;
+          merge({
+            codes: state.codes,
+            pmf: state.pmf.convolve(
+              mode === "crit" ? payload.crit : payload.hit,
+              eps,
+              true
+            ),
+            fired
+          });
+          continue;
+        }
+        for (const outcome of OUTCOMES) {
+          const slice = step.slices[outcome];
+          const sliceMass = slice.mass();
+          if (sliceMass <= eps) continue;
+          const codes = [...state.codes];
+          for (const group of step.updates) {
+            codes[group] = advance(codes[group], outcome);
+          }
+          merge({
+            codes,
+            pmf: state.pmf.convolve(slice, eps, true),
+            fired
+          });
+        }
+      }
+      states = next;
+    });
+    const fireMass = /* @__PURE__ */ new Map();
+    for (const id of plan.riderSteps.keys()) fireMass.set(id, 0);
+    for (const id of plan.perHitGroups.keys()) fireMass.set(id, 0);
+    let total;
+    for (const state of states.values()) {
+      total = total ? total.add(state.pmf) : state.pmf;
+      const mass = state.pmf.mass();
+      for (const [id, stepIndex] of plan.riderSteps) {
+        if (state.fired[stepIndex] !== null) {
+          fireMass.set(id, fireMass.get(id) + mass);
+        }
+      }
+      for (const [id, group] of plan.perHitGroups) {
+        if (state.codes[group] >> 2 !== FIRST_NONE) {
+          fireMass.set(id, fireMass.get(id) + mass);
+        }
+      }
+    }
+    const pmf = total ?? PMF.delta(0, eps);
+    const totalMass = pmf.mass();
+    const needsNormalizing = Math.abs(totalMass - 1) > eps && totalMass > 0;
+    if (needsNormalizing) {
+      for (const [id, mass] of fireMass) fireMass.set(id, mass / totalMass);
+    }
+    this.resolved = {
+      pmf: needsNormalizing ? pmf.normalize() : pmf,
+      fireMass
+    };
+    return this.resolved;
+  }
+};
+function turn(attacks = [], eps = EPS) {
+  return Turn.from(
+    { attacks: Array.isArray(attacks) ? attacks : [attacks] },
+    eps
+  );
+}
+
 exports.ACBuilder = ACBuilder;
 exports.AlwaysCritBuilder = AlwaysCritBuilder;
 exports.AlwaysHitBuilder = AlwaysHitBuilder;
 exports.AttackBuilder = AttackBuilder;
 exports.DCBuilder = DCBuilder;
 exports.HalfRollBuilder = HalfRollBuilder;
+exports.MAX_TRIGGER_GROUPS = MAX_TRIGGER_GROUPS;
 exports.MaxOfRollBuilder = MaxOfRollBuilder;
 exports.ParsedRollBuilder = ParsedRollBuilder;
 exports.PooledRollBuilder = PooledRollBuilder;
 exports.RollBuilder = RollBuilder;
 exports.SaveBuilder = SaveBuilder;
 exports.ScaleRollBuilder = ScaleRollBuilder;
+exports.Turn = Turn;
+exports.TurnSpecError = TurnSpecError;
 exports.builderPMFCache = builderPMFCache;
 exports.clearAttackCache = clearAttackCache;
 exports.clearDCCache = clearDCCache;
@@ -5530,5 +6328,6 @@ exports.flat = flat;
 exports.hd20 = hd20;
 exports.roll = roll;
 exports.sumRolls = sumRolls;
+exports.turn = turn;
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map