{"version":3,"sources":["../../src/common/lru-cache.ts","../../src/common/types.ts","../../src/pmf/query.ts","../../src/pmf/pmf.ts","../../src/pmf/mixture.ts","../../src/common/errors.ts","../../src/parser/dice.ts","../../src/parser/parser.ts","../../src/builder/prob.ts","../../src/builder/d20.ts","../../src/builder/roll.ts","../../src/builder/factory.ts","../../src/builder/ast.ts","../../src/builder/attack.ts","../../src/builder/ac.ts","../../src/builder/save.ts","../../src/builder/dc.ts","../../src/turn/types.ts","../../src/turn/plan.ts","../../src/turn/state.ts","../../src/turn/turn.ts"],"names":["d","cumulativeSum","result","dfs","arr","d20","ac","staticMod","bonusDicePMFs","bonusPMF","pcrit","pmiss","critPMF"],"mappings":"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","file":"index.cjs","sourcesContent":["/**\n * Simple LRU cache implementation\n */\n\nexport class LRUCache<K, V> {\n  private cache = new Map<K, V>();\n\n  constructor(private readonly maxSize = 1000) {}\n\n  get(key: K): V | undefined {\n    const value = this.cache.get(key);\n    if (value === undefined) return undefined;\n\n    this.cache.delete(key);\n    this.cache.set(key, value);\n    return value;\n  }\n\n  delete(key: K): void {\n    this.cache.delete(key);\n  }\n\n  set(key: K, value: V): this {\n    if (this.cache.size >= this.maxSize && !this.cache.has(key)) {\n      const oldestKey = this.cache.keys().next().value;\n      this.cache.delete(oldestKey as K);\n    }\n    this.cache.delete(key);\n    this.cache.set(key, value);\n    return this;\n  }\n\n  clear(): void {\n    this.cache.clear();\n  }\n\n  get size(): number {\n    return this.cache.size;\n  }\n\n  has(key: K): boolean {\n    return this.cache.has(key);\n  }\n\n  keys(): IterableIterator<K> {\n    return this.cache.keys();\n  }\n\n  values(): IterableIterator<V> {\n    return this.cache.values();\n  }\n}\n","/** Mapping from outcome label to probability mass or damage attribution. */\nexport type OutcomeLabelMap = Partial<Record<string, number>>;\n\n/** Computational epsilon for pruning negligible probabilities. */\nexport const EPS = 1e-12;\n\n/** A probability bin for a specific damage value. */\nexport interface Bin {\n  /** Total probability mass at this damage value. */\n  p: number;\n  /** Per-outcome probability mass contributions at this damage. */\n  count: OutcomeLabelMap;\n  /** Optional per-outcome damage attribution at this damage. */\n  attr?: OutcomeLabelMap;\n}\n\nexport interface CritConfig {\n    critThreshold: number;\n}\n\n/** Simple mapping from damage value to probability. */\nexport type DamageDistribution = Record<number, number>;\n/** Canonical outcome labels supported by the query helpers. */\nexport type OutcomeType =\n  | \"crit\"\n  | \"hit\"\n  | \"missNone\"\n  | \"missDamage\"\n  | \"saveHalf\"\n  | \"saveFail\"\n  | \"pc\";\n\nexport type Rounding = \"none\" | \"floor\" | \"round\" | \"ceil\";\n\n/** How a d20 attack roll resolves: single die, keep-highest of 2/3, or keep-lowest of 2. */\nexport type RollType = \"flat\" | \"advantage\" | \"disadvantage\" | \"elven accuracy\";\n\n/**\n * P(critical hit) for the given crit window and d20 {@link RollType}.\n *\n * `critRange` is the number of top faces that crit (1 for a natural 20, 2 for\n * 19–20, …), so a single die crits with probability `critRange / 20`. Advantage\n * rolls two d20s / elven accuracy three, keeping the best; disadvantage keeps\n * the worst of two.\n */\nexport function critProbability(critRange: number, rollType: RollType = \"flat\"): number {\n  const base = critRange / 20;\n  switch (rollType) {\n    case \"advantage\":\n      return 1 - (1 - base) ** 2;\n    case \"elven accuracy\":\n      return 1 - (1 - base) ** 3;\n    case \"disadvantage\":\n      return base ** 2;\n    case \"flat\":\n    default:\n      return base;\n  }\n}\n\n/**\n * The canonical \"clean miss\" outcome — a point of zero damage with no rider.\n * This is the {@link OutcomeType} that attribution charts and outcome stats key\n * on, and is distinct from the builder's attack-resolution `miss` weight label.\n */\nexport const MISS_NONE_OUTCOME: OutcomeType = \"missNone\";\n\n/**\n * All outcome types in canonical severity order — clean miss → crit. This is\n * also the natural stacking order for attribution charts (least- to\n * most-impactful, bottom → top). Enumerates every {@link OutcomeType} exactly\n * once; use it instead of hand-maintained per-consumer outcome tables.\n */\nexport const ALL_OUTCOME_TYPES: OutcomeType[] = [\n  \"missNone\",\n  \"missDamage\",\n  \"saveFail\",\n  \"saveHalf\",\n  \"pc\",\n  \"hit\",\n  \"crit\",\n];\n\n/**\n * Outcome types in display order for stats / breakdown rows — most prominent\n * first (crit, hit, …) down to the clean miss.\n */\nexport const OUTCOME_DISPLAY_ORDER: OutcomeType[] = [\n  \"crit\",\n  \"hit\",\n  \"missDamage\",\n  \"saveHalf\",\n  \"saveFail\",\n  \"pc\",\n  \"missNone\",\n];\n\n/**\n * Sort outcome labels by a canonical order (defaults to {@link ALL_OUTCOME_TYPES}).\n * Labels not present in `order` sort after known ones, alphabetically — so\n * ad-hoc/test labels outside the {@link OutcomeType} union stay stable.\n */\nexport function sortOutcomes<T extends string>(\n  outcomes: Iterable<T>,\n  order: readonly string[] = ALL_OUTCOME_TYPES\n): T[] {\n  const rank = new Map(order.map((o, i) => [o, i]));\n  return [...outcomes].sort((a, b) => {\n    const ra = rank.get(a);\n    const rb = rank.get(b);\n    if (ra !== undefined && rb !== undefined) return ra - rb;\n    if (ra !== undefined) return -1;\n    if (rb !== undefined) return 1;\n    return a.localeCompare(b);\n  });\n}\n\nexport const onAnyHit: OutcomeType[] = [\"hit\", \"crit\"];\nexport const onCritOnly: OutcomeType[] = [\"crit\"];\nexport const onHitOnly: OutcomeType[] = [\"hit\"];\nexport const onMissOnly: OutcomeType[] = [\"missNone\", \"missDamage\"];\nexport const onMissDamageOnly: OutcomeType[] = [\"missDamage\"];\nexport const onSaveHalfOnly: OutcomeType[] = [\"saveHalf\"];\nexport const onSaveFailOnly: OutcomeType[] = [\"saveFail\"];\nexport const onPotentCantripOnly: OutcomeType[] = [\"pc\"];\n","import type { OutcomeType } from \"../common/types\";\nimport { ALL_OUTCOME_TYPES, EPS } from \"../common/types\";\nimport { PMF } from \"./pmf\";\nimport type { DamageAttributionChartModel } from \"./pmf\";\n\n/**\n * Query interface for analyzing dice roll probability distributions.\n *\n * Combines multiple attack PMFs and provides statistical analysis methods for:\n * - Basic statistics (mean, variance, min/max, percentiles)\n * - Probability queries (hit chances, success rates, exact counts)\n * - Damage analysis (ranges by outcome type, expected values)\n * - Data export (charts, tables, visualizations)\n *\n */\n\nexport class DiceQuery {\n  public readonly singles: PMF[];\n  private readonly _eps: number;\n  private readonly _combinedProvided: boolean;\n  private _combined?: PMF;\n  private _combinedWithAttr?: PMF;\n\n  constructor(singles: PMF | PMF[], combined?: PMF, eps = EPS) {\n    this.singles = Array.isArray(singles) ? singles : [singles];\n    if (this.singles.some((s) => s === undefined)) {\n      throw new Error(\"DiceQuery contains undefined singles\");\n    }\n    this._eps = eps;\n    // When the caller supplies an explicit combined distribution that may not\n    // equal convolve(singles), the additive closed-form moments would describe\n    // a different distribution than cdf/percentiles. Track this so mean()/\n    // variance() can fall back to the provided combined and stay consistent.\n    this._combinedProvided = combined !== undefined;\n    if (combined !== undefined) {\n      this._combined =\n        Math.abs(combined.mass() - 1) <= eps ? combined : combined.normalize();\n    }\n  }\n\n  /**\n   * The combined damage distribution of all single PMFs (their convolution),\n   * normalized to total probability 1.\n   *\n   * Computed lazily on first access and cached. Queries that only need\n   * additive statistics — {@link DiceQuery.mean}, {@link DiceQuery.variance},\n   * {@link DiceQuery.stddev} — never trigger this convolution.\n   */\n  get combined(): PMF {\n    if (this._combined === undefined) {\n      const c = PMF.convolveMany(this.singles);\n      this._combined =\n        Math.abs(c.mass() - 1) <= this._eps ? c : c.normalize();\n    }\n    return this._combined;\n  }\n\n  private static readonly DEFAULT_OUTCOMES: readonly OutcomeType[] = [\n    \"hit\",\n    \"crit\",\n    \"missNone\",\n  ] as const;\n\n  /**\n   * Returns a new PMF with damage attribution metadata populated.\n   *\n   * This method computes attribution on-demand for builder-generated PMFs,\n   * enabling them to work with damage attribution charts. The `attr` field\n   * tracks how much damage each outcome type contributes at each damage value.\n   *\n   * For each bin at damage D: sum(attr.values()) ≈ D × P(damage = D)\n   *\n   * Performance: Cached after first call. Adds minimal overhead vs `combined`.\n   *\n   * @returns PMF with attr field populated for damage attribution charts\n   *\n   * @example\n   * const attack = d20.plus(5).ac(15).onHit(d(2,6).plus(3)).onCrit(d(2,6))\n   * const query = attack.toQuery()\n   * const pmf = query.combinedWithAttribution()\n   * // Now pmf can be used with attributionByValue() / damageAttributionChartModel()\n   */\n  combinedWithAttribution(): PMF {\n    if (this._combinedWithAttr) {\n      return this._combinedWithAttr;\n    }\n\n    // An explicitly provided `combined` is NOT the convolution of `singles` —\n    // a Turn's exact joint distribution, for instance, is narrower than the\n    // independent product because riders correlate with their sources.\n    // Re-convolving would silently discard it (and drop the riders' damage\n    // entirely), so attribute the provided distribution itself.\n    if (this._combinedProvided) {\n      this._combinedWithAttr = this.combined.withAttribution();\n      return this._combinedWithAttr;\n    }\n\n    // Fast path: if every single already carries attribution (as parser-\n    // generated PMFs do), the attributed convolution is bit-for-bit identical\n    // to `combined` — reuse it instead of convolving a second time.\n    if (this.singles.every((pmf) => pmf.hasAttribution())) {\n      this._combinedWithAttr = this.combined;\n      return this._combinedWithAttr;\n    }\n\n    // Otherwise (e.g. builder-generated PMFs that only carry `count`), add\n    // attribution to each single PMF, then convolve.\n    const singlesWithAttr = this.singles.map((pmf) => pmf.withAttribution());\n    const combined = PMF.convolveMany(singlesWithAttr, this.combined.epsilon);\n\n    // Normalize if needed\n    const normalized =\n      Math.abs(combined.mass() - 1) <= this.combined.epsilon\n        ? combined\n        : combined.normalize();\n\n    this._combinedWithAttr = normalized;\n    return normalized;\n  }\n\n  /**\n   * Per-label `damage value → probability mass` series for the combined,\n   * attribution-carrying distribution — the provenance core of the stacked\n   * damage-attribution chart. Convenience for\n   * `combinedWithAttribution().attributionByValue()`; see\n   * {@link PMF.attributionByValue}.\n   */\n  attributionByValue(): Map<string, Map<number, number>> {\n    return this.combinedWithAttribution().attributionByValue();\n  }\n\n  /**\n   * Full numeric model for the stacked damage-attribution chart. Convenience for\n   * `combinedWithAttribution().damageAttributionChartModel(options)`; see\n   * {@link PMF.damageAttributionChartModel}.\n   */\n  damageAttributionChartModel(options?: {\n    maxBuckets?: number;\n    stackOrder?: readonly string[];\n    epsilon?: number;\n  }): DamageAttributionChartModel {\n    return this.combinedWithAttribution().damageAttributionChartModel(options);\n  }\n\n  /**\n   * How many of the independent single PMFs can produce the given outcome\n   * label. Useful for \"all of them succeeded\" style probabilities where the\n   * exponent is the number of contributing attacks (see\n   * {@link DiceQuery.probExactlyK}).\n   */\n  countSinglesWith(label: string): number {\n    let count = 0;\n    for (const single of this.singles) {\n      if (single.hasOutcome(label)) count++;\n    }\n    return count;\n  }\n\n  /**\n   * Returns the expected damage across all possible outcomes.\n   *\n   * Example: `query.mean()` → 12.5\n   * Use case: \"What's my average damage per round?\"\n   */\n  mean(): number {\n    // If the caller supplied a combined distribution that may diverge from\n    // convolve(singles), report its mean so mean() stays consistent with\n    // cdf/percentiles/min/max (which all read `combined`).\n    if (this._combinedProvided) {\n      let m = 0;\n      for (const [damageValue, bin] of this.combined) m += damageValue * bin.p;\n      return m;\n    }\n    // Expectation is additive over independent attacks: E[Σ Xᵢ] = Σ E[Xᵢ].\n    // Computing it directly from the singles avoids building `combined`.\n    let totalMean = 0;\n    for (const single of this.singles) {\n      const mass = single.mass();\n      if (mass <= 0) continue;\n      // Match `combined`'s semantics: only divide by mass when it is not\n      // already 1 (within eps), so an already-normalized single is bit-exact.\n      totalMean +=\n        Math.abs(mass - 1) <= this._eps ? single.mean() : single.mean() / mass;\n    }\n    return totalMean;\n  }\n\n  /**\n   * Returns the variance of the damage distribution.\n   *\n   * Example: `query.variance()` → 45.2\n   * Use case: \"How much does my damage vary from the average?\"\n   * High variance means higher risk/reward. Lower variance means more consistent damage.\n   */\n  variance(): number {\n    // Consistent with mean(): if a (possibly divergent) combined was provided,\n    // compute the variance of that distribution directly.\n    if (this._combinedProvided) {\n      const mu = this.mean();\n      let v = 0;\n      for (const [damageValue, bin] of this.combined) {\n        const dev = damageValue - mu;\n        v += dev * dev * bin.p;\n      }\n      return v;\n    }\n    // Variance is additive over independent attacks: Var[Σ Xᵢ] = Σ Var[Xᵢ].\n    // Use the centered form per single (E[(X−μ)²]) rather than E[X²]−μ², which\n    // suffers catastrophic cancellation when damage has a large constant offset.\n    let totalVariance = 0;\n    for (const single of this.singles) {\n      const mass = single.mass();\n      if (mass <= 0) continue;\n      if (Math.abs(mass - 1) <= this._eps) {\n        // PMF.variance() is the centered, cached, mass-1 variance.\n        totalVariance += single.variance();\n      } else {\n        // Normalized centered variance of a non-unit-mass single.\n        let mu = 0;\n        for (const [d, b] of single) mu += d * (b.p / mass);\n        let v = 0;\n        for (const [d, b] of single) {\n          const dev = d - mu;\n          v += dev * dev * (b.p / mass);\n        }\n        totalVariance += v;\n      }\n    }\n    return totalVariance;\n  }\n\n  /**\n   * Returns the standard deviation of the damage distribution.\n   *\n   * Example: `query.stdev()` → 6.7\n   * Use case: \"What's the typical spread around my average damage?\"\n   * Used to determine how consistent the damage is.\n   */\n  stddev(): number {\n    return Math.sqrt(this.variance());\n  }\n\n  /** Alias of {@link DiceQuery.stddev}, matching {@link PMF.stdev}. */\n  stdev(): number {\n    return this.stddev();\n  }\n\n  /**\n   * Returns the Cumulative Distribution Function.\n   */\n  cdf(x: number): number {\n    return this.probTotalAtMost(x);\n  }\n\n  /**\n   * Returns the probability of dealing X damage or less.\n   * In statistics, this is called the cumulative distribution function (CDF).\n   * Example: `query.cdf(20)` → 0.75\n   * Use case: \"What's the chance I deal 20 damage or less?\"\n   */\n  probTotalAtMost(x: number): number {\n    let cumulativeProbability = 0;\n    for (const [damageValue, probabilityBin] of this.combined) {\n      if (damageValue <= x) {\n        cumulativeProbability += probabilityBin.p;\n      }\n    }\n    return cumulativeProbability;\n  }\n\n  /**\n   * Returns the Complementary Cumulative Distribution Function.\n   */\n  ccdf(x: number): number {\n    return this.probTotalAtLeast(x);\n  }\n\n  /**\n   * Returns the probability of dealing at least X damage.\n   *\n   * Example: `query.probTotalAtLeast(25)` → 0.35\n   * Use case: \"What's the chance I deal at least 25 damage to finish the enemy?\"\n   */\n  probTotalAtLeast(threshold: number): number {\n    let probabilitySum = 0;\n    for (const [damageValue, probabilityBin] of this.combined) {\n      if (damageValue >= threshold) {\n        probabilitySum += probabilityBin.p;\n      }\n    }\n    return probabilitySum;\n  }\n\n  /**\n   * Returns damage values at specific percentiles.\n   *\n   * Example: `query.percentiles([0.25, 0.5, 0.75])` → [8, 12, 18]\n   * Use case: \"What are my 25th, 50th, and 75th percentile damage values?\"\n   */\n  percentiles(percentileValues: number[]): number[] {\n    const sortedDamageValues = this.combined.support();\n    if (sortedDamageValues.length === 0) return percentileValues.map(() => 0);\n\n    const cumulativeProbabilities: number[] = [];\n    let runningProbabilitySum = 0;\n    for (const damageValue of sortedDamageValues) {\n      runningProbabilitySum += this.combined.map.get(damageValue)!.p;\n      cumulativeProbabilities.push(runningProbabilitySum);\n    }\n\n    return percentileValues.map((targetPercentile) => {\n      // Binary search for efficiency\n      let leftBound = 0;\n      let rightBound = cumulativeProbabilities.length - 1;\n\n      while (leftBound <= rightBound) {\n        const middleIndex = Math.floor((leftBound + rightBound) / 2);\n        if (cumulativeProbabilities[middleIndex] >= targetPercentile) {\n          rightBound = middleIndex - 1;\n        } else {\n          leftBound = middleIndex + 1;\n        }\n      }\n\n      return leftBound < sortedDamageValues.length\n        ? sortedDamageValues[leftBound]\n        : sortedDamageValues[sortedDamageValues.length - 1];\n    });\n  }\n\n  /**\n   * Returns the minimum possible damage.\n   *\n   * Example: `query.min()` → 0\n   * Use case: \"What's the worst-case damage if everything misses?\"\n   */\n  min(): number {\n    return this.combined.min();\n  }\n\n  /**\n   * Returns the maximum possible damage.\n   *\n   * Example: `query.max()` → 56\n   * Use case: \"What's the best-case damage if everything crits and rolls max?\"\n   */\n  max(): number {\n    return this.combined.max();\n  }\n\n  private singleProb(diceIndex: number, label: OutcomeType): number {\n    const single = this.singles[diceIndex];\n    let probabilitySum = 0;\n    for (const [, probabilityBin] of single) {\n      probabilitySum += probabilityBin.count[label] || 0;\n    }\n    // Return the conditional per-event probability. Dividing by the single's\n    // mass keeps the result in [0,1] for a non-normalized single (e.g. one that\n    // has been scaled), so probAtLeastOne / the binomial DP stay mass-invariant.\n    const mass = single.mass();\n    return mass > 0 ? probabilitySum / mass : 0;\n  }\n\n  /**\n   * Full count distribution [P(0), P(1), …, P(n)] for \"an attack succeeds if it\n   * carries ANY of `labels`\", over the n independent singles.\n   *\n   * Each single's per-event success probability is the Poisson-binomial\n   * marginal P(≥1 of labels) from {@link probabilityOf} (i.e. probAtLeastOne),\n   * computed exactly once. The binomial DP then runs once to produce the whole\n   * distribution, so the array-label paths of probExactlyK / probAtLeastK /\n   * probAtMostK can slice or sum from it instead of rebuilding a DiceQuery and\n   * re-running the DP per requested k.\n   */\n  private countDistribution(labels: OutcomeType[]): number[] {\n    const n = this.singles.length;\n    const successProbabilities = this.singles.map((single) =>\n      new DiceQuery([single]).probabilityOf(labels)\n    );\n\n    const dist = new Array(n + 1).fill(0);\n    dist[0] = 1;\n    for (const successProb of successProbabilities) {\n      for (let outcomeCount = n; outcomeCount >= 1; outcomeCount--) {\n        dist[outcomeCount] =\n          dist[outcomeCount] * (1 - successProb) +\n          dist[outcomeCount - 1] * successProb;\n      }\n      dist[0] *= 1 - successProb;\n    }\n    return dist;\n  }\n\n  probAtLeastK(labels: OutcomeType | OutcomeType[], k: number): number {\n    const L = Array.isArray(labels) ? [...new Set(labels)] : [labels];\n    const n = this.singles.length;\n\n    if (k <= 0) return 1;\n    if (k > n) return 0;\n\n    // Sum the upper tail of the single, shared count distribution rather than\n    // calling probExactlyK (which rebuilt the distribution) once per i.\n    const dist = this.countDistribution(L);\n    let tail = 0;\n    for (let i = k; i <= n; i++) {\n      tail += dist[i];\n    }\n\n    if (tail < 0) return 0;\n    if (tail > 1) return 1;\n    return tail;\n  }\n\n  /**\n   * Returns the probability that at least one attack has the specified outcome(s).\n   * - This is the complement of probAtMostK(labels, 0)\n   *\n   * Examples:\n   * - `query.probAtLeastOne('hit')` → 0.88 (88% chance at least one attack hits)\n   * - `query.probAtLeastOne(['hit', 'crit'])` → 0.96 (96% chance at least one succeeds)\n   *\n   * Use cases:\n   * - \"What's the chance at least one of my attacks connects?\"\n   *\n   * Note:\n   *\n   * - You have to pass in an array of labels to avoid double-counting if you are\n   *   using multiple labels. You cannot just add them.\n   */\n  probAtLeastOne(labels: OutcomeType | OutcomeType[]): number {\n    // Handle single label case (backward compatibility)\n    if (typeof labels === \"string\") {\n      labels = [labels];\n    }\n\n    let productOfNonOccurrence = 1;\n    for (let diceIndex = 0; diceIndex < this.singles.length; diceIndex++) {\n      // Calculate total probability of any of the specified labels occurring.\n      // Clamp to [0,1] so floating-point drift in the per-attack sum cannot push\n      // the complement out of range.\n      let combinedProbability = 0;\n      for (const label of labels) {\n        combinedProbability += this.singleProb(diceIndex, label);\n      }\n      if (combinedProbability < 0) combinedProbability = 0;\n      else if (combinedProbability > 1) combinedProbability = 1;\n      productOfNonOccurrence *= 1 - combinedProbability;\n    }\n    const result = 1 - productOfNonOccurrence;\n    return result < 0 ? 0 : result > 1 ? 1 : result;\n  }\n\n  /**\n   * Computes binomial probabilities for exactly 0, 1, 2, ..., maxK occurrences of a label.\n   *\n   * Uses dynamic programming to efficiently calculate the probability distribution\n   * of how many attacks will have the specified outcome, accounting for different\n   * success probabilities across individual attacks.\n   *\n   * Example: For 3 attacks with 50% hit chance each, returns:\n   * [0.125, 0.375, 0.375, 0.125] = [P(0 hits), P(1 hit), P(2 hits), P(3 hits)]\n   *\n   * @param label - The outcome type to count\n   * @param maxK - Maximum number of occurrences to calculate (usually number of attacks)\n   * @returns Array where index K contains P(exactly K attacks have the label)\n   */\n  private computeBinomialProbabilities(\n    label: OutcomeType,\n    maxK: number\n  ): number[] {\n    const individualProbabilities = this.singles.map((_, diceIndex) =>\n      this.singleProb(diceIndex, label)\n    );\n    const binomialProbs = new Array(maxK + 1).fill(0);\n    binomialProbs[0] = 1;\n\n    for (const singleProbability of individualProbabilities) {\n      for (let outcomeCount = maxK; outcomeCount >= 1; outcomeCount--) {\n        binomialProbs[outcomeCount] =\n          binomialProbs[outcomeCount] * (1 - singleProbability) +\n          binomialProbs[outcomeCount - 1] * singleProbability;\n      }\n      binomialProbs[0] *= 1 - singleProbability;\n    }\n\n    return binomialProbs;\n  }\n\n  /**\n   * Returns the probability that exactly K attacks result in the specified outcome(s).\n   *\n   * Single label examples:\n   * - probExactlyK('hit', 2) = probability exactly 2 attacks hit\n   * - probExactlyK('crit', 1) = probability exactly 1 attack crits\n   * - probExactlyK('crit', 0) = probability no attacks crit\n   *\n   * Array examples:\n   * - probExactlyK(['hit', 'crit'], 2) = probability exactly 2 attacks succeed\n   * - probExactlyK(['hit', 'crit'], 1) = probability exactly 1 attack succeeds\n   * - probExactlyK(['missDamage', 'missNone'], 0) = probability no attacks miss\n   *\n   * Use cases:\n   * - \"What's the chance exactly one of my attacks hits?\"\n   * - \"How likely am I to get exactly 2 successes out of 3 attacks?\"\n   * - \"What's the probability that exactly half my attacks succeed?\"\n   *\n   * Note: For arrays, an attack counts as a \"success\" if it has any of the specified labels.\n   * This is different from probAtMostK, which counts an attack as a \"success\" if it has ALL of the specified labels.\n   */\n  probExactlyK(labels: OutcomeType | OutcomeType[], k: number): number {\n    // Handle single label case (backward compatibility)\n    if (typeof labels === \"string\") {\n      const probabilityArray = this.computeBinomialProbabilities(labels, k);\n      return probabilityArray[k];\n    }\n\n    // For multiple labels, derive P(exactly k) from the single shared count\n    // distribution. (k > n is impossible, so index out of range reads as 0.)\n    const dist = this.countDistribution(labels);\n    return k >= 0 && k < dist.length ? dist[k] : 0;\n  }\n\n  /**\n   * Returns the probability that AT MOST K attacks result in the specified outcome(s).\n   *\n   * Single label examples:\n   * - probAtMostK('hit', 1) = probability 0 or 1 attacks hit (at most 1)\n   * - probAtMostK('crit', 0) = probability no attacks crit\n   * - probAtMostK('missDamage', 2) = probability at most 2 attacks miss\n   *\n   * Array examples:\n   * - probAtMostK(['hit', 'crit'], 1) = probability at most 1 attack succeeds\n   * - probAtMostK(['hit', 'crit'], 0) = probability no attacks succeed (all miss)\n   *\n   * Use cases:\n   * - \"What's the chance that at most one attack hits?\" (rest miss)\n   * - \"How likely am I to have mostly failures?\" (at most 1 success)\n   * - \"What's the probability of a really bad turn?\" (at most 0 successes)\n   *\n   */\n  probAtMostK(labels: OutcomeType | OutcomeType[], k: number): number {\n    // Handle single label case (backward compatibility)\n    if (typeof labels === \"string\") {\n      const probabilityArray = this.computeBinomialProbabilities(labels, k);\n      let cumulativeSum = 0;\n      for (let outcomeCount = 0; outcomeCount <= k; outcomeCount++) {\n        cumulativeSum += probabilityArray[outcomeCount];\n      }\n      return cumulativeSum;\n    }\n\n    // For multiple labels, sum the lower tail of the single shared count\n    // distribution rather than recomputing it per outcomeCount.\n    const dist = this.countDistribution(labels);\n    const upper = Math.min(k, dist.length - 1);\n    let cumulativeSum = 0;\n    for (let outcomeCount = 0; outcomeCount <= upper; outcomeCount++) {\n      cumulativeSum += dist[outcomeCount];\n    }\n    return cumulativeSum;\n  }\n\n  /**\n   * Returns the expected damage attributed to specific outcome types.\n   *\n   * Single label examples:\n   * - expectedDamageFrom('hit') = expected damage from hit components\n   * - expectedDamageFrom('crit') = expected damage from crit components\n   *\n   * Array examples:\n   * - expectedDamageFrom(['hit', 'crit']) = expected damage from any success\n   * - expectedDamageFrom(['missDamage', 'missNone']) = expected damage from misses\n   *\n   * Use cases:\n   * - \"How much damage do I expect from successful attacks?\"\n   * - \"What's the damage contribution from critical hits specifically?\"\n   * - \"How much damage comes from miss effects (like save-for-half spells)?\"\n   */\n  expectedDamageFrom(labels: OutcomeType | OutcomeType[]): number {\n    const wanted = Array.isArray(labels) ? labels : [labels];\n\n    let total = 0;\n    // By linearity of expectation, we can sum the expected damages from each individual PMF. This avoids issues with the `count` aggregation during\n    for (const single of this.singles) {\n      for (const [dmg, bin] of single) {\n        let p = 0;\n        for (const label of wanted) p += bin.count[label] ?? 0;\n        total += dmg * p;\n      }\n    }\n    return total;\n  }\n\n  /**\n   * Returns damage statistics for scenarios where AT LEAST ONE attack results in\n   * the specified outcome(s).\n   *\n   * This method answers \"What happens when things go reasonably well?\" rather than\n   * \"What's the theoretical maximum?\" It includes mixed scenarios which are more\n   * common and tactically relevant than pure scenarios.\n   *\n   * Single label examples:\n   * - damageStatsFrom('hit') = damage range when at least one attack hits\n   * - damageStatsFrom('crit') = damage range when at least one attack crits\n   *\n   * Array examples:\n   * - damageStatsFrom(['hit', 'crit']) = damage range when at least one attack succeeds\n   * - damageStatsFrom(['missDamage', 'missNone']) = damage range when at least one attack misses\n   *\n   * Tactical Use Cases:\n   * - \"Given that I don't completely whiff (99% of turns), what damage should I expect?\"\n   * - \"When planning to kill a 60 HP enemy, what's my damage range on successful turns?\"\n   * - \"Should I use this risky spell if it has good damage when it works?\"\n   * - \"What's my damage potential when something goes right?\" (vs pure failure)\n   *\n   * Combat Planning Examples:\n   * - 4 attacks with 90% hit chance: \"96% of the time you'll do 25-150 damage, avg 52\"\n   *   (Much more useful than \"You average 50 damage including complete misses\")\n   * - Risk assessment: \"80% of successful turns do 40-80 damage, but 20% do 80-150\"\n   * - Resource management: \"If I hit anything, I'll likely finish this enemy\"\n   *\n   * Statistical Note:\n   * This includes mixed scenarios (2 hits + 1 crit, 3 hits + 1 miss, etc.) which\n   * occur far more frequently than pure scenarios. For pure scenarios, use combinedDamageStats.\n   *\n   * KNOWN LIMITATION (multi-attack, single label): the returned `count` is an\n   * EXPECTED COUNT (E[#label], so > 1 for N≥2 attacks, not a probability), and\n   * `avg` is the size-biased conditional mean E[dmg·#label]/E[#label] rather than\n   * E[dmg | the label occurs]. For a single attack both are the plain\n   * conditional figures. Use {@link probAtLeastOne} for the scenario probability.\n   *\n   * @example\n   * // High-level tactical planning\n   * const successStats = query.damageStatsFrom('hit')\n   * const successChance = query.probAtLeastOne('hit')\n   * console.log(`${(successChance*100).toFixed(1)}% chance to do ${successStats.min}-${successStats.max} damage`)\n   */\n  damageStatsFrom(labels: OutcomeType | OutcomeType[]): {\n    min: number;\n    max: number;\n    avg: number;\n    count: number;\n  } {\n    // Normalize input to array for uniform handling\n    const labelArray = typeof labels === \"string\" ? [labels] : labels;\n\n    let minDamage = Infinity;\n    let maxDamage = -Infinity;\n    let totalDamage = 0;\n    let totalCount = 0;\n\n    for (const [damage, probabilityBin] of this.combined) {\n      // Check if this bin has any of the specified labels\n      let binHasAnyLabel = false;\n      let binContribution = 0;\n\n      for (const label of labelArray) {\n        const count = probabilityBin.count[label] as number;\n        if (count && count > 0) {\n          binHasAnyLabel = true;\n          binContribution += count;\n        }\n      }\n\n      if (damage > 0 && binHasAnyLabel) {\n        minDamage = Math.min(minDamage, damage);\n        maxDamage = Math.max(maxDamage, damage);\n\n        // For single labels, use the specific count; for multiple labels, use total probability\n        const weightToUse =\n          labelArray.length === 1 ? binContribution : probabilityBin.p;\n        totalDamage += damage * weightToUse;\n        totalCount += weightToUse;\n      }\n    }\n\n    return {\n      min: minDamage === Infinity ? 0 : minDamage,\n      max: maxDamage === -Infinity ? 0 : maxDamage,\n      avg: totalCount > 0 ? totalDamage / totalCount : 0,\n      count: totalCount,\n    };\n  }\n\n  /**\n   * Returns damage statistics for scenarios where ALL attacks result in the specified\n   * outcome, calculated by leveraging the pure partition of singles.\n   *\n   * This method answers \"What's the theoretical best/worst case?\" and \"What are the\n   * clean mathematical boundaries?\" It provides pure scenarios without mixing outcomes.\n   *\n   * Examples:\n   * - combinedDamageStats('hit') = damage range when all attacks hit (none crit, none miss)\n   * - combinedDamageStats('crit') = damage range when all attacks crit (none just hit)\n   *\n   * UI and Display Use Cases:\n   * - Statistics panels showing \"MAX Hit Damage\" (users expect pure hits, not mixed)\n   * - \"Best case scenario\" vs \"worst case scenario\" analysis\n   * - Mathematical verification: \"Does our hit damage calculation match manual math?\"\n   * - Clean damage type attribution: \"How much comes from base hits vs crits?\"\n   *\n   * Design and Balance Use Cases:\n   * - Game designers: \"What's the damage ceiling if someone gets lucky?\"\n   * - Character optimization: \"What's my absolute maximum potential?\"\n   * - Ability comparison: \"Which build has higher crit ceiling?\"\n   * - Minimum guaranteed damage: \"What's the worst I can do if everything hits?\"\n   *\n   * Mathematical Use Cases:\n   * - Validating complex calculations against simple manual math\n   * - Understanding damage component contributions in isolation\n   * - Separating luck (crit variance) from consistency (hit variance)\n   * - Building intuition about damage sources\n   *\n   * When to Use This vs damageStatsFrom():\n   * - Use THIS for: UI max/min displays, theoretical limits, clean comparisons\n   * - Use damageStatsFrom() for: tactical planning, realistic expectations, mixed scenarios\n   *\n   * Statistical Note:\n   * Pure scenarios (all hits, all crits) are rare but represent clear mathematical\n   * boundaries. These stats help understand the \"shape\" of your damage potential.\n   *\n   * @example\n   * // UI display logic\n   * const pureHitMax = query.combinedDamageStats('hit').max    // Clean \"MAX Hit Damage: 90\"\n   * const pureCritMax = query.combinedDamageStats('crit').max  // Clean \"MAX Crit Damage: 168\"\n   *\n   * // vs tactical planning (use damageStatsFrom instead)\n   * const realisticRange = query.damageStatsFrom('hit')  // Includes mixed scenarios\n   */\n  combinedDamageStats(targetLabel: OutcomeType): {\n    min: number;\n    max: number;\n    avg: number;\n    count: number;\n  } {\n    // Get pure statistics from each single attack (singles are already pure partitions)\n    const singleStats = this.singles.map((single) =>\n      new DiceQuery([single]).damageStatsFrom(targetLabel)\n    );\n\n    // If any single attack has no outcomes of this type, return zeros\n    if (singleStats.some((stats) => stats.count === 0)) {\n      return { min: 0, max: 0, avg: 0, count: 0 };\n    }\n\n    // Calculate combined statistics for N attacks all of target type\n    const combinedMin = singleStats.reduce((sum, stats) => sum + stats.min, 0);\n    const combinedMax = singleStats.reduce((sum, stats) => sum + stats.max, 0);\n    const combinedAvg = singleStats.reduce((sum, stats) => sum + stats.avg, 0);\n    const combinedProb = singleStats.reduce(\n      (product, stats) => product * stats.count,\n      1\n    );\n\n    return {\n      min: combinedMin,\n      max: combinedMax,\n      avg: combinedAvg,\n      count: combinedProb,\n    };\n  }\n\n  /**\n   * Returns the probability that at least one attack carries ANY of the\n   * specified labels (the marginal P(≥1) across the independent attacks).\n   *\n   * Examples:\n   * - `query.probabilityOf('hit')` → 0.88 (probability at least one hit occurs)\n   * - `query.probabilityOf(['hit', 'crit'])` → 0.96 (probability of any success)\n   *\n   * Use cases:\n   * - \"What's the chance my resolution includes a success label?\"\n   * - \"How likely am I to get any hits or crits across all attacks?\"\n   *\n   * Note: this must NOT be computed by summing `combined` bin probabilities. A\n   * single combined damage total is reachable by many outcome combinations and\n   * a bin can hold several labels at once, so summing `bin.p` over bins that\n   * contain a label over-counts. The correct marginal is the Poisson-binomial\n   * complement over the per-attack probabilities, i.e. {@link probAtLeastOne}.\n   */\n  probabilityOf(labels: OutcomeType | OutcomeType[]): number {\n    return this.probAtLeastOne(labels);\n  }\n\n  /**\n   * Returns the probability of missing (any type of miss).\n   *\n   * Example: `query.missChance()` → 0.04\n   * Use case: \"What's the chance I miss completely this turn?\"\n   */\n  missChance(): number {\n    // Miss can be either explicit misses with damage or zero-damage misses\n    return this.probabilityOf([\"missDamage\", \"missNone\"]);\n  }\n\n  /**\n   * Returns data formatted for plotting damage probability distribution.\n   *\n   * Example: `query.toChartSeries()` → [{x: 0, y: 0.04}, {x: 6, y: 0.1}, ...]\n   * Use case: \"I want to visualize my damage distribution in a chart.\"\n   */\n  toChartSeries(): Array<{ x: number; y: number }> {\n    return this.combined.support().map((damageValue) => ({\n      x: damageValue,\n      y: this.combined.map.get(damageValue)!.p,\n    }));\n  }\n\n  /**\n   * Returns tabular data showing damage values and their probability breakdowns.\n   *\n   * Example: `query.toLabeledTable(['hit', 'crit'])` →\n   *   [{damage: 6, total: 0.01, hit: 0.008, crit: 0}, ...]\n   *\n   * Use case: \"I want to see exactly how hit/crit probabilities contribute to each damage value.\"\n   */\n  toLabeledTable(\n    labels: OutcomeType[] = []\n  ): Array<{ damage: number; total: number } & Record<string, number>> {\n    return this.combined.support().map((damageValue) => {\n      const probabilityBin = this.combined.map.get(damageValue)!;\n      const tableRow: { damage: number; total: number } & Record<\n        string,\n        number\n      > = {\n        damage: damageValue,\n        total: probabilityBin.p,\n      };\n      for (const outcomeLabel of labels) {\n        tableRow[outcomeLabel] = probabilityBin.count[outcomeLabel] || 0;\n      }\n      return tableRow;\n    });\n  }\n\n  /**\n   * Returns data for stacked charts with unconditional per-label probability mass per damage.\n   *\n   * - Each dataset value equals the unconditional probability mass for that label at that damage\n   *   (i.e., `bin.count[label]`).\n   * - Column sums may be less than the total probability `bin.p` when you omit labels or when\n   *   there is unlabeled mass. Include all relevant outcome labels if you need the sum to match.\n   * - This behavior matches tests that expect raw per-label mass (not proportional scaling).\n   * - NOTE: This implementation may break dprcalc.com chart binning at large n, need to test it more.\n   *\n   * @example\n   * query.toStackedChartData(['hit', 'crit'])\n   * // → {labels: [0, 6, 12, ...], datasets: [{label: 'hit', data: [0, 0.03, ...]}, ...]}\n   */\n  toStackedChartData(\n    labels: OutcomeType[] = [],\n    epsilon = EPS\n  ): { labels: number[]; datasets: Array<{ label: string; data: number[] }> } {\n    const damageValues = this.combined.support();\n\n    const datasets = labels.map((outcomeLabel) => ({\n      label: outcomeLabel,\n      data: damageValues.map((dmg) => {\n        const bin = this.combined.map.get(dmg);\n        const v = bin ? (bin.count[outcomeLabel] as number) || 0 : 0;\n        return v <= epsilon ? 0 : v;\n      }),\n    }));\n\n    return { labels: damageValues, datasets };\n  }\n\n  /**\n   * Returns pure mathematical data for cumulative distribution function (CDF).\n   * Shows P(X ≤ x) - the probability of getting at most x damage.\n   *\n   * @param asPercentages Whether to return percentages (0-100) or probabilities (0-1)\n   * @returns Pure data structure with support and cumulative probabilities\n   *\n   * @example\n   * query.toCDFSeries()\n   * // → {support: [0, 6, 12], data: [5.2, 18.3, 45.1]}\n   */\n  toCDFSeries(asPercentages: boolean = true): {\n    support: number[];\n    data: number[];\n  } {\n    const originalSupport = this.combined.support();\n    if (originalSupport.length === 0) {\n      return { support: [], data: [] };\n    }\n\n    // Create complete integer range from min to max\n    const minDamage = Math.min(...originalSupport);\n    const maxDamage = Math.max(...originalSupport);\n    const support = Array.from(\n      { length: maxDamage - minDamage + 1 },\n      (_, i) => minDamage + i\n    );\n\n    let cumulativeProbability = 0;\n    const cdfData: number[] = [];\n\n    for (const damage of support) {\n      const bin = this.combined.map.get(damage);\n      if (bin) {\n        cumulativeProbability += bin.p;\n      }\n      cdfData.push(\n        asPercentages ? cumulativeProbability * 100 : cumulativeProbability\n      );\n    }\n\n    return {\n      support,\n      data: cdfData,\n    };\n  }\n\n  /**\n   * Returns pure mathematical data for complementary cumulative distribution function (CCDF).\n   * Shows P(X ≥ x) - the probability of getting at least x damage.\n   *\n   * @param asPercentages Whether to return percentages (0-100) or probabilities (0-1)\n   * @returns Pure data structure with support and complementary cumulative probabilities\n   *\n   * @example\n   * query.toCCDFSeries()\n   * // → {support: [0, 6, 12], data: [100, 94.8, 81.7]}\n   */\n  toCCDFSeries(asPercentages: boolean = true): {\n    support: number[];\n    data: number[];\n  } {\n    const originalSupport = this.combined.support();\n    if (originalSupport.length === 0) {\n      return { support: [], data: [] };\n    }\n\n    // Create complete integer range from min to max\n    const minDamage = Math.min(...originalSupport);\n    const maxDamage = Math.max(...originalSupport);\n    const support = Array.from(\n      { length: maxDamage - minDamage + 1 },\n      (_, i) => minDamage + i\n    );\n\n    // Calculate CCDF: P(X ≥ x) = 1 - P(X < x)\n    let cumulativeProbability = 0;\n    const ccdfData: number[] = [];\n\n    for (const damage of support) {\n      // For CCDF at point x, we want P(X ≥ x) = 1 - P(X < x)\n      // which is the total probability minus cumulative up to (but not including) x\n      const ccdf = 1 - cumulativeProbability;\n      ccdfData.push(asPercentages ? ccdf * 100 : ccdf);\n\n      // Now add current probability for next iteration\n      const bin = this.combined.map.get(damage);\n      if (bin) {\n        cumulativeProbability += bin.p;\n      }\n    }\n\n    return {\n      support,\n      data: ccdfData,\n    };\n  }\n\n  /*\n        Statistics snapshot of the query.\n            */\n\n  /** Probability of doing strictly more than threshold damage (default >0). */\n  probDamageGreaterThan(threshold = 0): number {\n    let acc = 0;\n    for (const [x, bin] of this.combined.map) if (x > threshold) acc += bin.p;\n    return acc;\n  }\n\n  /** All outcome keys actually present (typed & ordered if you pass an order). */\n  outcomeKeys(order?: OutcomeType[]): OutcomeType[] {\n    const found = new Set<string>();\n    for (const [, bin] of this.combined.map) {\n      for (const k in bin.count)\n        if (bin.count[k] && (bin.count[k] as number) > 0) found.add(k);\n    }\n    if (found.size === 0)\n      [\"hit\", \"crit\", \"missNone\"].forEach((k) => found.add(k));\n    const keys = Array.from(found).filter(\n      (k) => order?.includes(k as OutcomeType) ?? true\n    ) as OutcomeType[];\n    if (order && order.length)\n      keys.sort((a, b) => order.indexOf(a) + 999 - (order.indexOf(b) + 999));\n    return keys;\n  }\n\n  /** Total probability per outcome across the PMF. */\n  outcomeTotals(\n    outcomes: OutcomeType[] = this.outcomeKeys()\n  ): Map<OutcomeType, number> {\n    const totals = new Map<OutcomeType, number>();\n    outcomes.forEach((o) => totals.set(o, 0));\n    for (const [, row] of this.combined.map) {\n      for (const o of outcomes) {\n        const p = (row.count[o] as number) || 0; // if your bins store per-outcome p; else derive via toLabeledTable\n        totals.set(o, (totals.get(o) || 0) + p);\n      }\n    }\n    return totals;\n  }\n\n  /** Conditional damage range per outcome (min/avg/max of X | outcome). */\n  outcomeDamageRanges(\n    outcomes: OutcomeType[] = this.outcomeKeys()\n  ): Map<OutcomeType, { min: number; avg: number; max: number }> {\n    // Use toLabeledTable to stay consistent with your existing attribution\n    const table = this.toLabeledTable(outcomes);\n    const ranges = new Map<\n      OutcomeType,\n      { min?: number; max?: number; sum: number; mass: number }\n    >();\n    outcomes.forEach((o) => ranges.set(o, { sum: 0, mass: 0 }));\n\n    for (const row of table) {\n      const dmg = row.damage as number;\n      for (const o of outcomes) {\n        const p = (row[o] as number) || 0; // joint mass at (damage, outcome)\n        if (p > 0) {\n          const r = ranges.get(o)!;\n          r.sum += dmg * p;\n          r.mass += p;\n          if (r.min === undefined || dmg < r.min) r.min = dmg;\n          if (r.max === undefined || dmg > r.max) r.max = dmg;\n        }\n      }\n    }\n\n    const out = new Map<\n      OutcomeType,\n      { min: number; avg: number; max: number }\n    >();\n    for (const o of outcomes) {\n      const r = ranges.get(o)!;\n      const avg = r.mass > 0 ? r.sum / r.mass : 0;\n      out.set(o, { min: r.min ?? 0, avg, max: r.max ?? 0 });\n    }\n    return out;\n  }\n\n  /**\n   * Per-outcome probabilities and damage ranges, aggregated over the individual\n   * singles rather than read off the combined distribution.\n   *\n   * `damageRange` is the sum, over every single that can produce the outcome, of\n   * that single's own conditional damage range: \"what this outcome contributes\n   * across the whole turn when every attack that can produce it does\". Linear in\n   * the number of attacks by construction.\n   *\n   * Prefer this over {@link DiceQuery.snapshot} for a multi-attack query.\n   * `snapshot` reads `damageRange` off the combined PMF's `count`, which the\n   * convolution accumulates as an expected count, so its `avg` is size-biased\n   * for N≥2 (its own doc comment says so). The two agree for a single attack.\n   *\n   * Only outcomes that actually occur appear in the result.\n   *\n   * Like every `singles`-based helper on this class, it describes the singles\n   * and not an explicitly provided `combined`. `Turn.toQuery()` supplies one whose\n   * distribution also contains rider attacks that are absent from `singles`\n   * (an `otherwise([unarmed, unarmed])` flurry, say), so those attacks do not\n   * appear here. For rider-inclusive figures read the combined distribution\n   * directly: {@link DiceQuery.outcomeTotals}, {@link DiceQuery.outcomeDamageRanges}.\n   *\n   * @param outcomes Which outcomes to consider; defaults to every canonical one.\n   */\n  outcomeStats(\n    outcomes: readonly OutcomeType[] = ALL_OUTCOME_TYPES\n  ): Map<OutcomeType, OutcomeSnapshot> {\n    const stats = new Map<OutcomeType, OutcomeSnapshot>();\n    const perSingle = this.singles.map((pmf) => new DiceQuery([pmf], undefined, this._eps));\n\n    for (const outcome of outcomes) {\n      const atLeastOneProbability = this.probAtLeastOne(outcome);\n      if (atLeastOneProbability <= 0) continue;\n\n      const damageRange = { min: 0, avg: 0, max: 0 };\n      let contributors = 0;\n      for (const single of perSingle) {\n        if (single.probAtLeastOne(outcome) <= 0) continue;\n        contributors++;\n        const stat = single.damageStatsFrom(outcome);\n        damageRange.min += stat.min;\n        damageRange.avg += stat.avg;\n        damageRange.max += stat.max;\n      }\n\n      stats.set(outcome, {\n        atLeastOneProbability,\n        allProbability:\n          contributors > 0 ? this.probExactlyK(outcome, contributors) : 0,\n        damageRange,\n      });\n    }\n\n    return stats;\n  }\n\n  /**\n   * Snapshot of the distribution in the exact shape the UI consumes.\n   * - outcome probabilities are \"at least one\" (and equal to \"all\" for a single PMF)\n   * - damageRange is conditional on the outcome occurring\n   *\n   * The outcome probabilities use the correct Poisson-binomial marginals\n   * (`atLeastOneProbability` = P(≥1 attack has it), `allProbability` = P(all do)),\n   * so they are always valid probabilities in [0,1].\n   *\n   * KNOWN LIMITATION (multi-attack): `damageRange.avg` is still aggregated from\n   * the combined PMF's `count`, which the convolution accumulates as an EXPECTED\n   * COUNT, so for N≥2 attacks it is the size-biased mean E[dmg·#label]/E[#label]\n   * rather than a clean conditional expectation. It is correct for a single\n   * attack.\n   */\n  snapshot(order?: readonly OutcomeType[]): Snapshot {\n    // 1) Discover which outcomes actually appear in this PMF\n    const discovered = new Set<string>();\n    for (const [, bin] of this.combined.map) {\n      for (const k in bin.count) {\n        if (bin.count[k] && (bin.count[k] as number) > 0) discovered.add(k);\n      }\n    }\n    if (discovered.size === 0) {\n      for (const k of DiceQuery.DEFAULT_OUTCOMES) discovered.add(k);\n    }\n\n    let outcomes = Array.from(discovered);\n\n    // Optional filtering + ordering if a preferred order was provided\n    if (order && order.length) {\n      const inOrder = new Set(order);\n      outcomes = outcomes.filter((k) => inOrder.has(k as OutcomeType));\n      const rank = new Map(order.map((k, i) => [k, i]));\n      outcomes.sort(\n        (a, b) =>\n          (rank.get(a as OutcomeType) ?? 999) -\n          (rank.get(b as OutcomeType) ?? 999)\n      );\n    }\n\n    // 2) Aggregate per-outcome mass and conditional damage ranges via labeled table\n    const rows = this.toLabeledTable(outcomes as OutcomeType[]);\n\n    const rangeAcc = new Map<\n      OutcomeType,\n      { min?: number; max?: number; sum: number; mass: number }\n    >();\n    for (const ot of outcomes) {\n      rangeAcc.set(ot as OutcomeType, { sum: 0, mass: 0 });\n    }\n\n    for (const row of rows) {\n      const dmg = row.damage as number;\n      for (const ot of outcomes) {\n        const p = (row[ot] as number) || 0;\n        if (p <= 0) continue;\n\n        const r = rangeAcc.get(ot as OutcomeType)!;\n        r.sum += dmg * p;\n        r.mass += p;\n        if (r.min === undefined || dmg < r.min) r.min = dmg;\n        if (r.max === undefined || dmg > r.max) r.max = dmg;\n      }\n    }\n\n    const n = this.singles.length;\n    const outcomeMap = new Map<OutcomeType, OutcomeSnapshot>();\n    for (const ot of outcomes) {\n      const r = rangeAcc.get(ot as OutcomeType)!;\n      const avg = r.mass > 0 ? r.sum / r.mass : 0;\n      // Use the correct per-attack marginals (Poisson-binomial) so these are\n      // always valid probabilities in [0,1]. For a single attack both reduce to\n      // P(outcome); the previous `total` was an expected count and could exceed 1.\n      outcomeMap.set(ot as OutcomeType, {\n        atLeastOneProbability: this.probAtLeastOne(ot as OutcomeType),\n        allProbability: this.probAtLeastK(ot as OutcomeType, n),\n        damageRange: { min: r.min ?? 0, avg, max: r.max ?? 0 },\n      });\n    }\n\n    // 3) Scalars: mean, damageChance, and percentiles from the dense CDF\n    const averageDPR = this.mean();\n\n    let damageChance = 0; // P(total damage > 0)\n    for (const [x, bin] of this.combined.map) if (x > 0) damageChance += bin.p;\n\n    const { support, data } = this.toCDFSeries(false); // P(X ≤ x) in 0..1\n    const quantile = (p: number) => {\n      if (support.length === 0) return 0;\n      for (let i = 0; i < support.length; i++)\n        if (data[i] >= p) return support[i];\n      return support[support.length - 1];\n    };\n    const percentiles = {\n      p25: quantile(0.25),\n      p50: quantile(0.5),\n      p75: quantile(0.75),\n    };\n\n    return { averageDPR, damageChance, percentiles, outcomes: outcomeMap };\n  }\n\n  /**\n   * PMF Transformation Methods\n   *\n   * These methods provide a fluent API for transforming dice queries by wrapping\n   * the underlying PMF transformation methods. All operations work on the combined\n   * PMF and return new DiceQuery instances.\n   */\n\n  /**\n   * Returns a new DiceQuery with normalized probabilities (ensuring they sum to 1.0).\n   *\n   * @returns New DiceQuery with normalized combined PMF\n   */\n  normalize(): DiceQuery {\n    return new DiceQuery([this.combined.normalize()]);\n  }\n\n  /**\n   * Returns a new DiceQuery with low-probability outcomes removed.\n   *\n   * @param eps Minimum probability threshold (defaults to PMF epsilon)\n   * @param keepFinalBin Whether to keep the highest damage bin regardless of probability\n   * @returns New DiceQuery with compacted combined PMF\n   */\n  compact(eps?: number, keepFinalBin?: boolean): DiceQuery {\n    return new DiceQuery([this.combined.compact(eps, keepFinalBin)]);\n  }\n\n  /**\n   * Returns a new DiceQuery with an additional scaled branch added.\n   * Useful for conditional outcomes like \"30% chance of opportunity attack\".\n   *\n   * @param branch DiceQuery to add as a scaled branch\n   * @param probability Probability of the branch occurring (0-1)\n   * @returns New DiceQuery combining this query with the scaled branch\n   *\n   * @example\n   * const baseAttack = parse(\"(d20 + 5 AC 15) * (2d6 + 3)\");\n   * const opportunityAttack = parse(\"(d20 + 5 AC 15) * (1d8 + 3)\");\n   * const withOpportunity = baseAttack.addScaled(opportunityAttack, 0.3);\n   */\n  addScaled(branch: DiceQuery, probability: number): DiceQuery {\n    return new DiceQuery([\n      this.combined.addScaled(branch.combined, probability),\n    ]);\n  }\n\n  /**\n   * Returns a new DiceQuery with all probabilities scaled by a factor.\n   * Used for conditional scenarios where the entire outcome has reduced probability.\n   *\n   * @param factor Scaling factor for probabilities\n   * @returns New DiceQuery with scaled probabilities\n   *\n   * @example\n   * const fullAttack = parse(\"(d20 + 5 AC 15) * (2d6 + 3)\");\n   * const conditionalAttack = fullAttack.scaleMass(0.3); // 30% chance scenario\n   */\n  scaleMass(factor: number): DiceQuery {\n    return new DiceQuery([this.combined.scaleMass(factor)]);\n  }\n\n  totalMass(): number {\n    return this.combined.mass();\n  }\n\n  /**\n   * Returns a new DiceQuery with damage values transformed by a function.\n   * Useful for applying modifiers, resistances, or other damage transformations.\n   *\n   * @param damageTransformFunction Function to transform each damage value\n   * @returns New DiceQuery with transformed damage values\n   *\n   * @example\n   * const baseAttack = parse(\"2d6 + 3\");\n   * const withResistance = baseAttack.mapDamage(dmg => Math.floor(dmg / 2)); // Half damage\n   * const withBonus = baseAttack.mapDamage(dmg => dmg + 5); // +5 damage\n   */\n  mapDamage(\n    damageTransformFunction: (damageValue: number) => number\n  ): DiceQuery {\n    return new DiceQuery([this.combined.mapDamage(damageTransformFunction)]);\n  }\n\n  /**\n   * Returns a new DiceQuery with damage values scaled by a factor.\n   * Convenient wrapper around mapDamage for multiplicative scaling.\n   *\n   * @param factor Scaling factor for damage values\n   * @param rounding Rounding method: \"floor\" (default), \"round\", or \"ceil\"\n   * @returns New DiceQuery with scaled damage values\n   *\n   * @example\n   * const baseAttack = parse(\"2d6 + 3\");\n   * const doubled = baseAttack.scaleDamage(2); // Double damage\n   * const halfDamage = baseAttack.scaleDamage(0.5, \"round\"); // Half damage, rounded\n   */\n  scaleDamage(\n    factor: number,\n    rounding: \"floor\" | \"round\" | \"ceil\" = \"floor\"\n  ): DiceQuery {\n    return new DiceQuery([this.combined.scaleDamage(factor, rounding)]);\n  }\n\n  /**\n   * Returns a new DiceQuery combining this query with another via convolution.\n   * Equivalent to rolling both queries independently and adding results.\n   * It is important to use this rather than combing()ing the PMFs directly!\n   * This method maintains the provenance of the PMFs which is needed for damage attribution.\n   * Combining the .combined PMFs directly is still valid for DPR calculations but\n   * is not statistically sound for queries.\n   *\n   * @param other DiceQuery to combine with\n   * @param eps Optional epsilon for precision control\n   * @returns New DiceQuery representing the combined outcome\n   *\n   * @example\n   * const mainAttack = parse(\"(d20 + 5 AC 15) * (2d6 + 3)\");\n   * const bonusAttack = parse(\"(d20 + 3 AC 15) * (1d6 + 1)\");\n   * const bothAttacks = mainAttack.convolve(bonusAttack);\n   */\n  convolve(other: DiceQuery): DiceQuery {\n    const singles = [...this.singles, ...other.singles];\n    return new DiceQuery(singles);\n  }\n\n  /**\n   * First-success split over an ordered list of DISTINCT single-swing PMFs.\n   * Each PMF may have different success/subset probabilities (from labels).\n   *\n   * successOutcome: e.g., [\"success\"] or [\"hit\", \"crit\"]\n   * subsetOutcome:  e.g., [\"subset\"] or [\"crit\"] where subset ⊆ success\n   *\n   * Returns tuple: [pFirstNonSubset, pFirstSubset, pAnySuccess, pNone]\n   */\n  public firstSuccessSplit(\n    successOutcome: OutcomeType | OutcomeType[],\n    subsetOutcome: OutcomeType | OutcomeType[],\n    eps = EPS\n  ): readonly [pSuccess: number, pSubset: number, pAny: number, pNone: number] {\n    const pmfs = this.singles;\n    if (!pmfs.length) {\n      throw new Error(\"firstSuccessSplitFromPMFs: pmfs must be non-empty\");\n    }\n\n    const toArr = (x: OutcomeType | OutcomeType[]): OutcomeType[] =>\n      Array.isArray(x) ? x : [x];\n    const clamp01 = (x: number) => Math.max(0, Math.min(1, x));\n    const tol = Math.max(eps, 8 * Number.EPSILON);\n\n    // Per-event probabilities from each PMF via DiceQuery([pmf])\n    const per = pmfs.map((pmf) => {\n      const dq = new DiceQuery([pmf]);\n      const pS = dq.probAtLeastOne(toArr(successOutcome));\n      const pB = dq.probAtLeastOne(toArr(subsetOutcome));\n      if (pB - pS > eps) {\n        throw new Error(\n          \"firstSuccessSplitFromPMFs: P(subset) > P(success) for an event. Ensure subset ⊆ success.\"\n        );\n      }\n      return { pS, pB };\n    });\n\n    // Aggregate with running miss prefix\n    let missSoFar = 1;\n    let pFirstSubset = 0;\n    let pFirstNonSubset = 0;\n    let pNone = 1;\n\n    for (const { pS, pB } of per) {\n      pFirstSubset += missSoFar * pB;\n      pFirstNonSubset += missSoFar * (pS - pB);\n      const miss = 1 - pS;\n      missSoFar *= miss;\n      pNone *= miss;\n    }\n\n    const pAny = 1 - pNone;\n\n    // Clamp and sanity check\n    const a = clamp01(pFirstNonSubset);\n    const b = clamp01(pFirstSubset);\n    const any = clamp01(pAny);\n    const none = clamp01(pNone);\n\n    if (Math.abs(a + b - any) > tol * Math.max(1, any)) {\n      throw new Error(\n        `firstSuccessSplitFromPMFs: parts do not sum to pAny. got a+b=${\n          a + b\n        }, pAny=${any}`\n      );\n    }\n\n    return [a, b, any, none] as const;\n  }\n}\n// Make sure these types are exported in your public index, or inline them here.\nexport type OutcomeSnapshot = {\n  atLeastOneProbability: number; // P(outcome occurs at least once)\n  allProbability: number; // equal to atLeastOneProbability for a single aggregated PMF\n  damageRange: { min: number; avg: number; max: number }; // conditional on the outcome occurring\n};\n\nexport type Snapshot = {\n  averageDPR: number;\n  damageChance: number; // P(total damage > 0)\n  percentiles: { p25: number; p50: number; p75: number };\n  outcomes: Map<OutcomeType, OutcomeSnapshot>;\n};\n","import { LRUCache } from \"../common/lru-cache\";\nimport type { Bin, OutcomeLabelMap, Rounding } from \"../common/types\";\nimport {\n  ALL_OUTCOME_TYPES,\n  EPS,\n  MISS_NONE_OUTCOME,\n  sortOutcomes,\n} from \"../common/types\";\nimport { DiceQuery } from \"./query\";\n\nconst cacheEnabled = true;\n\nexport const pmfCache = new LRUCache<string, PMF>(1000);\n\n/**\n * Complete numeric model for the stacked damage-attribution chart, produced by\n * {@link PMF.damageAttributionChartModel}. Carries every dice-and-probability\n * value the chart needs; a renderer only maps these numbers into its own format\n * (colors, human labels, axis units, dataset objects).\n */\nexport interface DamageAttributionChartModel {\n  /** Bucket-start value for each column. Numeric; the caller stringifies for labels. */\n  labels: number[];\n  /** Present only when the distribution was coarsened; [start,end] inclusive, per bucket. */\n  binRanges?: { start: number; end: number }[];\n  /** Discovered outcome labels in stack order. Empty for pure (unattributed) distributions. */\n  outcomes: string[];\n  /** outcome → per-bucket probability mass (fraction 0..1). Bar heights. Σ over outcomes ≈ totals[i]. */\n  series: Map<string, number[]>;\n  /**\n   * outcome → per-bucket conditional share (fraction 0..1) of that bucket's total.\n   * Tooltip signal. 0 where the bucket total is below `epsilon`; otherwise Σ over\n   * outcomes ≈ 1.\n   */\n  shares: Map<string, number[]>;\n  /** Per-bucket total probability mass (fraction 0..1). The only signal for pure distributions. */\n  totals: number[];\n  /** Reversed-convention CCDF markers: damage at which P(X ≥ x) crosses 80/50/20%. */\n  percentiles: { p80: number; p50: number; p20: number };\n  /** Distribution mean, `this.mean()`. */\n  mean: number;\n}\n\n/**\n * Probability Mass Function for discrete damage distributions.\n */\nexport class PMF {\n  // Unique ID generator for anonymous PMFs to avoid cache key collisions\n  private static __anonIdCounter = 1;\n\n  // Cached computed values\n  private _support?: number[];\n  private _min?: number;\n  private _max?: number;\n  private _totalMass?: number;\n  private _mean?: number;\n  private _variance?: number;\n  private _stdev?: number;\n  private _fingerprint?: string;\n\n  constructor(\n    public readonly map: Map<number, Bin> = new Map(),\n    public readonly epsilon = EPS,\n    public readonly normalized = false,\n    public readonly identifier: string = `anon#${PMF.__anonIdCounter++}`,\n    private _preservedProvenance = true\n  ) {}\n\n  static empty(epsilon = EPS, identifier = \"empty\") {\n    return new PMF(new Map(), epsilon, false, identifier);\n  }\n\n  // This has a single bin at value 0, mass of 1\n  static zero(epsilon = EPS): PMF {\n    const m = new Map();\n    m.set(0, { p: 1, count: { miss: 1 }, attr: {} });\n    return new PMF(m, epsilon, false, \"zero\");\n  }\n\n  static delta(value: number, epsilon = EPS): PMF {\n    return PMF.fromMap(new Map([[value, 1]]), epsilon);\n  }\n\n  /**\n   * Point mass at damage 0 tagged with the canonical `missNone` outcome.\n   *\n   * Differs from {@link PMF.zero}, which labels its zero bin `miss` — the\n   * builder's attack-resolution vocabulary. This uses the `missNone`\n   * {@link OutcomeType} that the attribution charts and outcome stats key on,\n   * so it is the correct \"clean miss / no damage\" delta for provenance-aware\n   * mixtures feeding those consumers.\n   */\n  static missNone(epsilon = EPS): PMF {\n    const m = new Map<number, Bin>();\n    m.set(0, { p: 1, count: { [MISS_NONE_OUTCOME]: 1 }, attr: {} });\n    return new PMF(m, epsilon, false, \"missNone\");\n  }\n\n  // This creates a single bin at value 0, but with weight 0.\n  static emptyMass(): PMF {\n    return PMF.zero().scaleMass(0);\n  }\n\n  //  Makes PMF iterable over [damage, bin] pairs.\n  [Symbol.iterator](): IterableIterator<[number, Bin]> {\n    return this.map[Symbol.iterator]();\n  }\n\n  static clearCache() {\n    pmfCache.clear();\n  }\n\n  /**\n   * Creates a conditional PMF from two branches (success and failure) and a probability.\n   * This is the core logic for modeling any probabilistic event where there are two\n   * distinct outcomes.\n   */\n  static branch(\n    successPMF: PMF,\n    failurePMF: PMF,\n    successProbability: number\n  ): PMF {\n    let p = successProbability;\n    if (!Number.isFinite(p)) p = 0;\n    if (p < 0) p = 0;\n    if (p > 1) p = 1;\n\n    const q = 1 - p;\n\n    // Fast paths. scaleMass(1) returns the same instance, so these hand back the\n    // branch PMF unchanged. That is safe because PMFs are treated as immutable\n    // (compact() and the other transforms now clone bins rather than mutate).\n    if (p === 0) return failurePMF.scaleMass(1);\n    if (p === 1) return successPMF.scaleMass(1);\n\n    // Choose epsilon. You can also pick Math.min for a tighter threshold.\n    const eps = successPMF.epsilon ?? failurePMF.epsilon;\n    const id = `branch(${failurePMF.identifier}*${q.toFixed(6)} + ${\n      successPMF.identifier\n    }*${p.toFixed(6)})`;\n\n    // Proper Bernoulli mixture: q·failure ⊕ p·success, assembled in a single\n    // pass. The previous `empty().addScaled(failure,q).addScaled(success,p)`\n    // chain copied failurePMF's bins twice (into the intermediate, then again\n    // when the intermediate was copied by the second addScaled). Merging both\n    // scaled branches directly into one fresh map keeps the same accumulation\n    // order — q·failure first, then p·success — so the result is bit-identical.\n    const resultMap = new Map<number, Bin>();\n    for (const [damageValue, bin] of failurePMF.map) {\n      PMF.mergeInto(resultMap, damageValue, PMF.scaleBin(bin, q));\n    }\n    for (const [damageValue, bin] of successPMF.map) {\n      PMF.mergeInto(resultMap, damageValue, PMF.scaleBin(bin, p));\n    }\n\n    return new PMF(resultMap, eps, false, id);\n  }\n\n  /**\n   * withProbability()\n   *\n   * A convenience wrapper around branch() for the common case where the \"failure\" branch is always zero().\n   *\n   *  Think of this as a shortcut for:\n   *    pmf.gate(p, PMF.zero())\n   *\n   * Use this to model a *single* Bernoulli event — an outcome that either happens or doesn't,\n   * like an opportunity attack that occurs with probability p, or a single attack that either hits or misses.\n   *\n   * This is **not** for combining multiple independent attacks or mutually exclusive multi-outcome scenarios.\n   * - For multiple independent swings, use DiceQuery with separate PMFs for each attack.\n   * - For modeling \"first success\" logic across multiple attacks (like Sneak Attack or Smite)\n   *   use query.firstSuccessSplit() to get the exact probabilities.\n   * - For scenarios with several mutually exclusive outcomes (like crit vs hit vs none), use PMF.exclusive().\n   *\n   */\n  static withProbability(successPMF: PMF, probability: number): PMF {\n    return PMF.branch(successPMF, PMF.zero(), probability);\n  }\n\n  /**\n   * gate()\n   *\n   * A conditional wrapper around branch() that applies this PMF with probability `p`,\n   * and applies a provided fallback PMF otherwise.\n   *\n   * This is useful for modeling a binary choice between two outcomes:\n   * - The \"success\" outcome (this PMF) happens with probability `p`.\n   * - The \"failure\" outcome (fallback PMF) happens with probability `1 - p`.\n   *\n   * Examples:\n   * - 25% chance to include an opportunity attack, otherwise nothing:\n   *     attackPMF.gate(0.25, PMF.zero())\n   *\n   * - 50% chance to deal fireball damage, otherwise cone of cold damage:\n   *     fireballPMF.gate(0.5, coneOfColdPMF)\n   *\n   * Relationship to other helpers:\n   * - **withProbability()** is a shortcut for the common case where the fallback is `PMF.zero()`.\n   * - **exclusive()** is for three or more mutually exclusive outcomes (e.g., crit vs hit vs none).\n   *\n   * @param p Probability of applying this PMF (between 0 and 1).\n   * @param fallback PMF to apply when this PMF is *not* selected.\n   * @returns A new PMF representing the weighted mixture of this PMF and the fallback.\n   */\n  gate(p: number, fallback: PMF) {\n    return PMF.branch(this, fallback, p);\n  }\n\n  /**\n   * PMF.exclusive()\n   *\n   * Builds a single PMF from a set of mutually exclusive weighted outcomes.\n   * Exactly one of the provided options will occur.\n   *\n   * Each option has:\n   *  - A PMF representing its outcome (e.g., damage dice).\n   *  - A weight representing its probability of being selected.\n   *\n   * Notes:\n   *  - If total weight < 1 (within eps), leftover mass is assumed to be PMF.zero()\n   *\n   * @param options Array of `{ pmf, weight }` or `[PMF, number]`.\n   * @param eps Optional tolerance for floating point rounding.\n   */\n  static exclusive(\n    options: Array<{ pmf: PMF; weight: number } | [PMF, number]>,\n    eps = EPS\n  ): PMF {\n    const items = options.map((o) =>\n      Array.isArray(o) ? { pmf: o[0], weight: o[1] } : o\n    );\n\n    // Validate weights\n    for (const { weight } of items) {\n      if (!Number.isFinite(weight) || weight < -eps) {\n        throw new Error(`PMF.exclusive: invalid weight ${weight}.`);\n      }\n    }\n\n    // Sum and check\n    let totalWeight = items.reduce((s, { weight }) => s + weight, 0);\n\n    // Normalize tiny negatives to 0 and tiny overshoot to 1 when within eps\n    if (Math.abs(totalWeight) <= eps) totalWeight = 0;\n    if (Math.abs(1 - totalWeight) <= eps) totalWeight = 1;\n\n    if (totalWeight > 1 + EPS) {\n      throw new Error(\n        `PMF.exclusive: total weight ${totalWeight} exceeds 1. (epsilon: ${eps})`\n      );\n    }\n\n    // Accumulate scaled components, skipping near-zero weights\n    let out = PMF.empty(eps);\n    for (const { pmf, weight } of items) {\n      if (weight > eps) out = out.addScaled(pmf, weight);\n    }\n\n    // Add leftover mass at zero outcome\n    const leftover = Math.max(0, 1 - totalWeight);\n    if (leftover > eps) {\n      out = out.addScaled(PMF.zero(), leftover);\n    }\n\n    return out;\n  }\n\n  /**\n   * PMF.mix()\n   *\n   * Builds a PMF as a linear combination of input PMFs with the given weights.\n   * Unlike `exclusive`, this does NOT:\n   *  - enforce that weights sum to 1\n   *  - add leftover probability to δ0 (PMF.zero())\n   *\n   * Use when outcomes are not mutually exclusive, or for interpolation/blending.\n   *\n   * @param options Array of `{ pmf, weight }` or `[PMF, number]`.\n   * @param eps Optional tolerance for skipping tiny weights.\n   */\n  static mix(\n    options: Array<{ pmf: PMF; weight: number } | [PMF, number]>,\n    eps = EPS\n  ): PMF {\n    const items = options.map((o) =>\n      Array.isArray(o) ? { pmf: o[0], weight: o[1] } : o\n    );\n\n    // Validate weights, but do not constrain their sum.\n    for (const { weight } of items) {\n      if (!Number.isFinite(weight)) {\n        throw new Error(`PMF.mix: invalid weight ${weight}.`);\n      }\n    }\n\n    let out = PMF.empty(eps);\n    for (const { pmf, weight } of items) {\n      if (Math.abs(weight) <= eps) continue; // ignore crumbs\n      out = out.addScaled(pmf, weight);\n    }\n    return out;\n  }\n  /**\n   * Adds damage attribution metadata to this PMF based on existing count metadata.\n   * For each bin, sets attr[outcome] = damage × count[outcome].\n   *\n   * This enables damage attribution charts to work with builder-generated PMFs.\n   * The parser generates attr automatically, but builder PMFs only have count.\n   *\n   * @returns New PMF with attr field populated in each bin\n   */\n  /**\n   * Returns true if this PMF already carries damage attribution metadata.\n   *\n   * Only the first positive-damage bin is inspected (parser-generated PMFs\n   * populate `attr` uniformly), so this is O(1) in practice.\n   */\n  hasAttribution(): boolean {\n    for (const [damage, bin] of this.map) {\n      if (damage !== 0 && bin.attr && Object.keys(bin.attr).length > 0) {\n        return true;\n      }\n      // Only check the first non-zero bin for performance\n      if (damage > 0) break;\n    }\n    return false;\n  }\n\n  withAttribution(): PMF {\n    // Fast path: if attr already exists, return this PMF unchanged\n    if (this.hasAttribution()) return this;\n\n    const newMap = new Map<number, Bin>();\n\n    for (const [damage, bin] of this.map) {\n      const attr: OutcomeLabelMap = {};\n\n      // For each outcome type in count, compute its damage contribution\n      for (const outcome in bin.count) {\n        const probability = bin.count[outcome] as number;\n        if (probability > 0) {\n          attr[outcome] = damage * probability;\n        }\n      }\n\n      // Create new bin with attribution\n      newMap.set(damage, {\n        p: bin.p,\n        count: { ...bin.count },\n        attr: Object.keys(attr).length > 0 ? attr : undefined,\n      });\n    }\n\n    // Use a different identifier to avoid cache collisions with non-attributed version\n    return new PMF(\n      newMap,\n      this.epsilon,\n      this.normalized,\n      `${this.identifier}~attr`\n    );\n  }\n\n  /**\n   * General-purpose N-way mixture.\n   * weights: Array of [weight, PMF].\n   *\n   * Example: PMF.mixN([\n   *   [pMiss, zero],\n   *   [pHit, hitPMF],\n   *   [pCrit, critPMF],\n   * ]);\n   */\n  static mixN(weights: [number, PMF][], eps = EPS): PMF {\n    // Treat tiny/negative as zero; keep performance clean\n    const filtered = weights.filter(([w]) => w > eps);\n\n    if (filtered.length === 0) {\n      return PMF.emptyMass(); // not PMF.zero(): we want \"no mass\" mixture\n    }\n\n    // No need to normalize up front; we accumulate and blend by relative weight\n    let acc: PMF | null = null;\n    let sum = 0;\n\n    for (const [w, pmf] of filtered) {\n      if (acc === null) {\n        acc = pmf;\n        sum = w;\n      } else {\n        const q = w / (sum + w); // relative weight of the new component\n        acc = PMF.branch(pmf, acc, q); // success=new pmf, failure=acc\n        sum += w;\n      }\n    }\n\n    // If everything got filtered out (all ~0), return empty mass\n    return acc ?? PMF.emptyMass();\n  }\n\n  // This is a convenience method for when we use power\n  // TODO: It can be smarter in the future, and we can also add it to query\n  // That way statistics operations on invalid PMFs can throw an error\n  // TODO… how can we detect if manually merging two queries' combined PMFs, as that loses provenance?\n  private setPreservedProvenance(preserved: boolean) {\n    if (!this._preservedProvenance && preserved) {\n      throw new Error(\n        \"Preserved provenance is already set to false, cannot fix that\"\n      );\n    }\n    this._preservedProvenance = preserved;\n  }\n\n  public preservedProvenance(): boolean {\n    return this._preservedProvenance;\n  }\n\n  private getPowerCacheKey(n: number, eps: number): string {\n    // Includes fingerprint() (per-bin probability/count/attr content), matching convolve()'s\n    // cache key: the identifier alone is not content-unique. `mapDamage`/`scaleDamage`,\n    // `normalize()`, and `compact()` all keep the PARENT's identifier while producing a\n    // numerically different PMF\n    // (e.g. `X.mapDamage(f).power(2)` and `X.mapDamage(g).power(2)` would otherwise collide on\n    // the same key `map(X)+map(X)@eps` and silently return each other's cached result).\n    const id = this.identifier;\n    let key = `${id}`;\n    for (let i = 1; i < n; i++) key += `+${id}`;\n    return `${key}@${eps}|${this.fingerprint()}`;\n  }\n\n  /**\n   * Efficiently computes this PMF convolved with itself `n` times.\n   * Uses exponentiation by squaring to reduce total convolutions.\n   * n must be a positive integer.\n   * *\n   * * NOTE: This folds multiple independent attacks into a single PMF.\n   * As a result, The power() method causes a loss of data provenance.\n   * This is ONLY SAFE if you are trying to calculate masses.\n   * If you want to query any atLeast probabilities, you should use the DiceQuery class instead without power().\n   */\n  power(n: number, eps = this.epsilon): PMF {\n    if (!Number.isInteger(n) || n <= 0) {\n      throw new Error(\"power(n): n must be a positive integer\");\n    }\n    if (n === 1) return this;\n\n    const epsilon = eps ?? this.epsilon;\n\n    const key = this.getPowerCacheKey(n, epsilon);\n    if (cacheEnabled) {\n      const cached = pmfCache?.get(key);\n      if (cached) return cached;\n    }\n\n    // Start from the base PMF and accumulate n-1 additional powers\n    let base: PMF = this.normalized ? this : this.normalize();\n    let result: PMF = base;\n    let exp = n - 1;\n\n    while (exp > 0) {\n      if (exp & 1) {\n        result = result.convolve(base, epsilon);\n      }\n      exp >>= 1;\n      if (exp > 0) {\n        base = base.convolve(base, epsilon);\n      }\n    }\n\n    result.setPreservedProvenance(false);\n    if (cacheEnabled) {\n      pmfCache?.set(key, result);\n    }\n    return result;\n  }\n\n  /*\n   * Helper for chaining multiple identical attacks\n   */\n  replicate(n: number): PMF[] {\n    if (!Number.isInteger(n) || n <= 0) {\n      throw new Error(\"replicate(n): n must be a positive integer\");\n    }\n    if (n === 1) return [this];\n    return Array.from({ length: n }, () => this);\n  }\n\n  mass(): number {\n    if (this._totalMass === undefined) {\n      let totalProbabilityMass = 0;\n      for (const { p } of this.map.values()) {\n        totalProbabilityMass += p;\n      }\n      this._totalMass = totalProbabilityMass;\n    }\n    return this._totalMass;\n  }\n\n  outcomeMass(outcome: string): number {\n    let totalProbabilityMass = 0;\n    for (const { p, count } of this.map.values()) {\n      totalProbabilityMass += p * ((count[outcome] as number) ?? 0);\n    }\n    return totalProbabilityMass;\n  }\n\n  // Helper for testing\n  faceTotal(): number {\n    return [...this.map.keys()].reduce((sum, key) => sum + key, 0);\n  }\n\n  normalize(): PMF {\n    if (this.normalized) return this;\n    const normalizationFactor = this.mass();\n    if (normalizationFactor === 0) return this;\n\n    // Note: this divides by normalizationFactor rather than multiplying by its\n    // reciprocal, to keep results bit-identical to direct division.\n    const normalizedMap = new Map<number, Bin>();\n    for (const [damageValue, probabilityBin] of this.map) {\n      const normalizedCount: OutcomeLabelMap = {};\n      for (const labelKey in probabilityBin.count) {\n        normalizedCount[labelKey] =\n          (probabilityBin.count[labelKey] as number) / normalizationFactor;\n      }\n\n      let normalizedAttributes: OutcomeLabelMap | undefined;\n      if (probabilityBin.attr) {\n        normalizedAttributes = {};\n        for (const labelKey in probabilityBin.attr) {\n          normalizedAttributes[labelKey] =\n            (probabilityBin.attr[labelKey] as number) / normalizationFactor;\n        }\n      }\n\n      normalizedMap.set(damageValue, {\n        p: probabilityBin.p / normalizationFactor,\n        count: normalizedCount,\n        attr: normalizedAttributes,\n      });\n    }\n    return new PMF(normalizedMap, this.epsilon, true, this.identifier);\n  }\n\n  /**\n   * Returns a copy with negligible probabilities removed (p < eps).\n   * If keepFinalBin is true, the bin with the largest key is always kept,\n   * even if its probability is below eps. count/attr submaps are still cleaned.\n   */\n  compact(eps = this.epsilon, keepFinalBin = false): PMF {\n    let maxKey = -Infinity;\n    if (keepFinalBin) {\n      for (const key of this.map.keys()) {\n        if (key > maxKey) maxKey = key;\n      }\n    }\n\n    const compactedMap = new Map<number, Bin>();\n\n    for (const [damageValue, probabilityBin] of this.map) {\n      const shouldKeep =\n        probabilityBin.p >= eps || (keepFinalBin && damageValue === maxKey);\n\n      if (!shouldKeep) continue;\n\n      // Build a fresh Bin rather than mutating the source. Bins are shared by\n      // reference across PMFs (e.g. branch()/addScaled()/scaleMass() fast paths\n      // can carry another PMF's bin objects), so deleting sub-eps entries in\n      // place would silently corrupt the source PMF's count/attr.\n      const cleanedBin = PMF.cloneBin(probabilityBin);\n\n      for (const labelKey in cleanedBin.count) {\n        if (Math.abs(cleanedBin.count[labelKey] || 0) < eps) {\n          delete cleanedBin.count[labelKey];\n        }\n      }\n\n      if (cleanedBin.attr) {\n        for (const labelKey in cleanedBin.attr) {\n          if (Math.abs(cleanedBin.attr[labelKey] || 0) < eps) {\n            delete cleanedBin.attr[labelKey];\n          }\n        }\n        if (Object.keys(cleanedBin.attr).length === 0) {\n          cleanedBin.attr = undefined;\n        }\n      }\n\n      compactedMap.set(damageValue, cleanedBin);\n    }\n\n    return new PMF(compactedMap, eps, this.normalized, this.identifier);\n  }\n\n  // Note: The \"support\" of a PMF is the set of all non-zero probability outcomes.\n  // This returns all damage values with non-zero probability, sorted ascending.\n  support(): number[] {\n    if (this._support === undefined) {\n      this._support = [...this.map.keys()].sort((a, b) => a - b);\n    }\n    return this._support!;\n  }\n\n  // Minimum possible damage value.\n  min(): number {\n    if (this._min === undefined) {\n      const support = this.support();\n      this._min = support.length > 0 ? support[0] : 0;\n    }\n    return this._min;\n  }\n\n  // Maximum possible damage value.\n  max(): number {\n    if (this._max === undefined) {\n      const support = this.support();\n      this._max = support.length > 0 ? support[support.length - 1] : 0;\n    }\n    return this._max;\n  }\n\n  /**\n   * Returns the expected (mean) damage value.\n   * Cached for performance since this requires iterating through all bins.\n   */\n  mean(): number {\n    if (this._mean === undefined) {\n      let totalSum = 0;\n      for (const [damageValue, probabilityBin] of this.map) {\n        totalSum += damageValue * probabilityBin.p;\n      }\n      this._mean = totalSum;\n    }\n    return this._mean;\n  }\n\n  /**\n   * Returns the variance of the damage distribution.\n   * Cached for performance since this requires mean calculation plus iteration.\n   */\n  variance(): number {\n    if (this._variance === undefined) {\n      const meanValue = this.mean();\n      let varianceSum = 0;\n      for (const [damageValue, probabilityBin] of this.map) {\n        const deviationFromMean = damageValue - meanValue;\n        varianceSum += deviationFromMean * deviationFromMean * probabilityBin.p;\n      }\n      this._variance = varianceSum;\n    }\n    return this._variance;\n  }\n\n  /**\n   * Returns the standard deviation of the damage distribution.\n   */\n  stdev(): number {\n    if (this._stdev === undefined) {\n      this._stdev = Math.sqrt(this.variance());\n    }\n    return this._stdev;\n  }\n\n  /** Deep-copies a Bin, cloning its count and (optional) attr maps. */\n  private static cloneBin(bin: Bin): Bin {\n    return {\n      p: bin.p,\n      count: { ...bin.count },\n      attr: bin.attr ? { ...bin.attr } : undefined,\n    };\n  }\n\n  /** Returns a new Bin with p, count, and attr all multiplied by `factor`. */\n  private static scaleBin(bin: Bin, factor: number): Bin {\n    const count: OutcomeLabelMap = {};\n    for (const k in bin.count) {\n      count[k] = (bin.count[k] as number) * factor;\n    }\n\n    let attr: OutcomeLabelMap | undefined;\n    if (bin.attr) {\n      attr = {};\n      for (const k in bin.attr) {\n        attr[k] = (bin.attr[k] as number) * factor;\n      }\n    }\n\n    return { p: bin.p * factor, count, attr };\n  }\n\n  private static mergeInto(\n    destinationMap: Map<number, Bin>,\n    damageValue: number,\n    binToAdd: Bin\n  ) {\n    const existingBin = destinationMap.get(damageValue);\n    if (!existingBin) {\n      destinationMap.set(damageValue, PMF.cloneBin(binToAdd));\n      return;\n    }\n\n    existingBin.p += binToAdd.p;\n\n    for (const labelKey in binToAdd.count) {\n      existingBin.count[labelKey] =\n        (existingBin.count[labelKey] || 0) +\n        (binToAdd.count[labelKey] as number);\n    }\n\n    if (binToAdd.attr) {\n      if (!existingBin.attr) {\n        existingBin.attr = {};\n      }\n      for (const labelKey in binToAdd.attr) {\n        existingBin.attr[labelKey] =\n          (existingBin.attr[labelKey] || 0) +\n          (binToAdd.attr[labelKey] as number);\n      }\n    }\n  }\n\n  // Convenience method\n  add(other: PMF): PMF {\n    return this.addScaled(other, 1);\n  }\n\n  /**\n   * Returns a new PMF with a scaled branch added to this one.\n   * The branch PMF is scaled by the given probability before merging\n   * This will be very useful for conditional effects and for being\n   * able to model \"I can probably have this opportunity attack 40% of rounds\"\n   * Example: `pmf.addScaled(critBranch, 0.05)` → PMF including 5% crit outcomes\n   */\n  addScaled(branch: PMF, probability: number): PMF {\n    if (probability === 0) return this;\n\n    const resultMap = new Map<number, Bin>();\n    for (const [dmg, bin] of this.map) {\n      resultMap.set(dmg, PMF.cloneBin(bin));\n    }\n\n    for (const [damageValue, probabilityBin] of branch.map) {\n      PMF.mergeInto(\n        resultMap,\n        damageValue,\n        PMF.scaleBin(probabilityBin, probability)\n      );\n    }\n\n    return new PMF(\n      resultMap,\n      this.epsilon,\n      false,\n      `${this.identifier}+scaled(${branch.identifier},${probability})`\n    );\n  }\n\n  /**\n   * Redistributes probability mass to model an effect that only occurs with\n   * probability `frequency` — a conditional attack, an on-hit rider, or a\n   * sub-one AoE target fraction.\n   *\n   * Every hit outcome (damage > 0) is scaled by `frequency` — probability mass,\n   * per-label `count`, AND per-label `attr` — and the freed mass is moved into\n   * the miss bin at damage 0, tagged with the canonical `missNone` outcome.\n   * Total probability mass is preserved.\n   *\n   * Unlike a bare {@link scaleMass} or {@link mapDamage}, this keeps damage\n   * attribution (`attr`) intact, so a frequency-scaled PMF still renders\n   * correctly in the damage-attribution charts.\n   *\n   * `frequency >= 1` (or non-finite) returns this PMF unchanged; `frequency <= 0`\n   * collapses all mass into the miss bin. The miss outcome is assumed to be\n   * encoded at damage value 0.\n   *\n   * @param frequency Probability in [0, 1] that the effect occurs.\n   */\n  applyHitFrequency(frequency: number): PMF {\n    if (!Number.isFinite(frequency) || frequency >= 1) return this;\n    const freq = Math.max(0, frequency);\n\n    const pMiss = this.pAt(0);\n    const pHit = 1 - pMiss;\n    const newMissMass = pMiss + (1 - freq) * pHit;\n\n    const newMap = new Map<number, Bin>();\n    newMap.set(0, {\n      p: newMissMass,\n      count: { [MISS_NONE_OUTCOME]: newMissMass },\n      attr: {},\n    });\n\n    for (const [damage, bin] of this.map) {\n      if (damage <= 0) continue;\n      newMap.set(damage, PMF.scaleBin(bin, freq));\n    }\n\n    return new PMF(\n      newMap,\n      this.epsilon,\n      false,\n      `freq(${this.identifier},${freq})`\n    );\n  }\n\n  scaleMass(factor: number): PMF {\n    if (factor === 1) return this;\n\n    const scaledMap = new Map<number, Bin>();\n    for (const [damageValue, probabilityBin] of this.map) {\n      scaledMap.set(damageValue, PMF.scaleBin(probabilityBin, factor));\n    }\n    return new PMF(\n      scaledMap,\n      this.epsilon,\n      false,\n      `scale(${this.identifier},${factor})`\n    );\n  }\n\n  mapDamage(damageTransformFunction: (damageValue: number) => number): PMF {\n    const transformedMap = new Map<number, Bin>();\n    for (const [originalDamage, probabilityBin] of this.map) {\n      const transformedDamage = damageTransformFunction(originalDamage);\n      PMF.mergeInto(\n        transformedMap,\n        transformedDamage,\n        PMF.cloneBin(probabilityBin)\n      );\n    }\n    return new PMF(\n      transformedMap,\n      this.epsilon,\n      this.normalized,\n      `map(${this.identifier})`\n    );\n  }\n\n  scaleDamage(\n    factor: number,\n    rounding: \"floor\" | \"round\" | \"ceil\" = \"floor\"\n  ): PMF {\n    const roundFunction =\n      rounding === \"round\"\n        ? Math.round\n        : rounding === \"ceil\"\n        ? Math.ceil\n        : Math.floor;\n    return this.mapDamage((damageValue) => roundFunction(damageValue * factor));\n  }\n\n  private getPMFCombineCacheKey(\n    p1: PMF,\n    p2: PMF,\n    eps: number,\n    raw: boolean\n  ): string {\n    const [id1, id2] = [p1.identifier, p2.identifier].sort();\n\n    return `v4:${raw ? \"RAW\" : \"N\"}:${id1}+${id2}@${eps}|${p1.fingerprint()}|${p2.fingerprint()}`;\n  }\n\n  /**\n   * A content fingerprint of every bin (probability, per-label `count`, per-label `attr`) plus\n   * the `normalized` flag, so convolution/power cache keys change whenever the underlying\n   * numbers do. Mass/bin-count/face-sum alone are not content-unique: `mapDamage` variants can\n   * keep the same identifier, support, mass, and face sum while differing in per-bin\n   * probabilities or in the `count`/`attr` channels `convolve()`/`power()` actually propagate --\n   * that previously let `power()` return one PMF's cached result for a different PMF. Memoized\n   * because a PMF is immutable once constructed -- this avoids re-deriving the key on every\n   * convolve()/power() call (including cache hits). Bin order is sorted by damage value (and\n   * label keys sorted within each bin) so two equal-content PMFs built via different code paths\n   * fingerprint identically regardless of Map insertion order.\n   */\n  fingerprint(): string {\n    if (this._fingerprint === undefined) {\n      const bins = [...this.map.entries()].sort((a, b) => a[0] - b[0]);\n      const parts: string[] = [];\n      for (const [damageValue, bin] of bins) {\n        const countStr = Object.keys(bin.count)\n          .sort()\n          .map((k) => `${k}:${bin.count[k]}`)\n          .join(\",\");\n        const attrStr = bin.attr\n          ? Object.keys(bin.attr)\n              .sort()\n              .map((k) => `${k}:${(bin.attr as OutcomeLabelMap)[k]}`)\n              .join(\",\")\n          : \"\";\n        parts.push(`${damageValue}:${bin.p}[${countStr}]{${attrStr}}`);\n      }\n      this._fingerprint = `${this.normalized ? 1 : 0}|${parts.join(\";\")}`;\n    }\n    return this._fingerprint;\n  }\n\n  convolve(other: PMF, eps?: number, raw = false): PMF {\n    const epsilon = eps ?? this.epsilon;\n\n    // Normalize-by-value on non-raw path\n    const norm = (x: PMF) =>\n      raw ? x : Math.abs(x.mass() - 1) <= epsilon ? x : x.normalize();\n    const A0 = norm(this);\n    const B0 = norm(other);\n\n    const [A, B] = A0.identifier <= B0.identifier ? [A0, B0] : [B0, A0];\n    const cacheKey = this.getPMFCombineCacheKey(A, B, epsilon, raw);\n    const cached = pmfCache?.get(cacheKey);\n    if (cached) return cached;\n\n    // Accumulate directly into each destination bin instead of building a\n    // temporary Bin per (a,b) pair and merging it. The probability channel\n    // (`dest.p += ap*bp`) accumulates in the same order as before, so it is\n    // bit-identical; only the per-label `count`/`attr` sums re-associate, which\n    // shifts them by at most a few ULP (far below the eps pruning threshold).\n    const combinedMap = new Map<number, Bin>();\n    for (const [aVal, aBin] of A.map) {\n      const ap = aBin.p;\n      const aCount = aBin.count;\n      const aAttr = aBin.attr;\n      for (const [bVal, bBin] of B.map) {\n        const bp = bBin.p;\n        const dmg = aVal + bVal;\n\n        let dest = combinedMap.get(dmg);\n        if (dest === undefined) {\n          dest = { p: 0, count: {} };\n          combinedMap.set(dmg, dest);\n        }\n\n        dest.p += ap * bp;\n\n        const dc = dest.count;\n        for (const k in aCount) dc[k] = (dc[k] || 0) + (aCount[k] as number) * bp;\n        for (const k in bBin.count)\n          dc[k] = (dc[k] || 0) + (bBin.count[k] as number) * ap;\n\n        if (aAttr || bBin.attr) {\n          let da = dest.attr;\n          if (da === undefined) {\n            da = {};\n            dest.attr = da;\n          }\n          if (aAttr)\n            for (const k in aAttr) da[k] = (da[k] || 0) + (aAttr[k] as number) * bp;\n          if (bBin.attr)\n            for (const k in bBin.attr)\n              da[k] = (da[k] || 0) + (bBin.attr[k] as number) * ap;\n        }\n      }\n    }\n\n    let result = new PMF(\n      combinedMap,\n      epsilon,\n      !raw,\n      `${A.identifier}${raw ? \"*\" : \"+\"}${B.identifier}`\n    );\n\n    // Enforce mass invariant: mass(out) = (raw? A.mass():1) * (raw? B.mass():1)\n    const mExp = (raw ? A.mass() : 1) * (raw ? B.mass() : 1);\n    const mGot = result.mass();\n    // Guard mGot !== 0: a zero-mass operand convolves to the zero measure\n    // (mass 0). Without this guard the non-raw path would scaleMass(mExp/0) =\n    // scaleMass(Infinity), poisoning every bin to 0*Infinity = NaN.\n    if (mExp !== 0 && mGot !== 0 && Math.abs(mGot - mExp) > epsilon) {\n      result = result.scaleMass(mExp / mGot);\n    }\n    if (!raw && mGot !== 0 && Math.abs(result.mass() - 1) > epsilon)\n      result = result.normalize();\n\n    pmfCache?.set(cacheKey, result);\n    return result;\n  }\n\n  // 3) Nice wrapper so you can call pmf.combineRaw(other)\n  combineRaw(other: PMF, eps?: number): PMF {\n    return this.convolve(other, eps, true);\n  }\n\n  // Reduce a list of PMFs by left-folding convolve() with the given eps\n  private static reduceConvolveLeft(pmfList: PMF[], eps: number): PMF {\n    let result = pmfList[0];\n    for (let i = 1; i < pmfList.length; i++) {\n      result = result.convolve(pmfList[i], eps);\n    }\n    return result;\n  }\n\n  /**\n   * Convolves multiple PMFs using linear convolution with automatic caching.\n   * Uses a left-to-right accumulation approach for maximum cache reuse.\n   * Each convolve() call automatically uses the convolution cache for performance.\n   *\n   * This linear approach provides better cache hits than pairwise because:\n   * - Intermediate results are more predictable and stable\n   * - Similar PMF lists share common prefixes (A+B, (A+B)+C, etc.)\n   * - Order-independent cache keys work better with consistent build patterns\n   */\n  static convolveMany(pmfList: PMF[], eps = EPS): PMF {\n    if (pmfList.length === 0) return PMF.empty(eps);\n    if (pmfList.length === 1) return pmfList[0];\n\n    // Linear combination with automatic intermediate caching: each prefix\n    // (A+B, (A+B)+C, ...) is a stable cache key, maximizing reuse.\n    return PMF.reduceConvolveLeft(pmfList, eps);\n  }\n\n  /**\n   * Returns a plain, JSON-serializable representation of this PMF.\n   *\n   * Follows the standard `toJSON` contract, so `JSON.stringify(pmf)` produces\n   * the expected output (no double-encoding). Use {@link PMF.fromJSON} to\n   * reconstruct, or {@link PMF.toJSONString} if you need the string directly.\n   */\n  toJSON(): {\n    bins: Array<[number, Bin]>;\n    normalized: boolean;\n    identifier: string;\n  } {\n    return {\n      bins: [...this.map.entries()],\n      normalized: this.normalized,\n      identifier: this.identifier,\n    };\n  }\n\n  /** Serializes this PMF to a JSON string (equivalent to `JSON.stringify(pmf)`). */\n  toJSONString(): string {\n    return JSON.stringify(this);\n  }\n\n  static fromJSON(jsonData: {\n    bins: Array<[number, Bin]>;\n    normalized?: boolean;\n    identifier?: string;\n  }) {\n    return new PMF(\n      new Map(jsonData.bins),\n      EPS,\n      !!jsonData.normalized,\n      jsonData.identifier || \"fromJSON\"\n    );\n  }\n\n  /**\n   * Relative pruning with optional top-K floor.\n   * Keeps bins with p >= epsRel * peak, always keeps min and max damage,\n   * optionally guarantees at least `minBins` survivors by adding top-K.\n   * Returns a new, non-normalized PMF.\n   */\n  prune(epsRel: number, minBins = 0): PMF {\n    const size = this.map.size;\n    if (size === 0) return this;\n\n    // One pass: peak, min, max\n    let peak = 0;\n    let minDamage = Number.POSITIVE_INFINITY;\n    let maxDamage = Number.NEGATIVE_INFINITY;\n    for (const [dmg, bin] of this.map) {\n      if (bin.p > peak) peak = bin.p;\n      if (dmg < minDamage) minDamage = dmg;\n      if (dmg > maxDamage) maxDamage = dmg;\n    }\n    if (peak === 0)\n      return new PMF(new Map(this.map), epsRel, false, this.identifier);\n\n    const thresh = epsRel * peak;\n    const entries = [...this.map.entries()];\n\n    // Protect endpoints\n    const survivorsByDmg = new Map<number, Bin>();\n    const protect = (d: number) => {\n      const b = this.map.get(d);\n      if (b) survivorsByDmg.set(d, b);\n    };\n    protect(minDamage);\n    if (maxDamage !== minDamage) protect(maxDamage);\n\n    // Relative survivors\n    for (const [dmg, bin] of entries) {\n      if (bin.p >= thresh) survivorsByDmg.set(dmg, bin);\n    }\n\n    // Enforce minBins via top-K if requested\n    if (minBins > 0 && survivorsByDmg.size < minBins) {\n      // Sort all entries by probability desc (or replace with Quickselect for O(n))\n      entries.sort((a, b) => b[1].p - a[1].p);\n      for (const [dmg, bin] of entries) {\n        if (!survivorsByDmg.has(dmg)) {\n          survivorsByDmg.set(dmg, bin);\n          if (survivorsByDmg.size >= minBins) break;\n        }\n      }\n    }\n\n    // Rebuild map, pruning tiny count/attr entries with the same threshold\n    const prunedMap = new Map<number, Bin>();\n    for (const [dmg, bin] of survivorsByDmg) {\n      const newCount: OutcomeLabelMap = {};\n      for (const k in bin.count) {\n        const v = bin.count[k] as number;\n        if (Math.abs(v) >= thresh) newCount[k] = v;\n      }\n      let newAttr: OutcomeLabelMap | undefined;\n      if (bin.attr) {\n        for (const k in bin.attr) {\n          const v = bin.attr[k] as number;\n          if (Math.abs(v) >= thresh) {\n            if (!newAttr) newAttr = {};\n            newAttr[k] = v;\n          }\n        }\n      }\n      prunedMap.set(dmg, { p: bin.p, count: newCount, attr: newAttr });\n    }\n\n    // Return non-normalized PMF\n    return new PMF(prunedMap, epsRel, false, `prune(${this.identifier})`);\n  }\n\n  /** Probability mass at exactly x. */\n  pAt(x: number): number {\n    return this.map.get(x)?.p ?? 0;\n  }\n\n  /**\n   * P(any damage) — the mass on all non-zero outcomes, i.e. `1 - P(0)`.\n   * Assumes a miss is encoded as the damage-0 bin (the convention used across\n   * attack/save PMFs). The dual of {@link missProbability}.\n   */\n  hitProbability(): number {\n    return 1 - this.pAt(0);\n  }\n\n  /** P(no damage) — the mass at damage 0. The dual of {@link hitProbability}. */\n  missProbability(): number {\n    return this.pAt(0);\n  }\n\n  /**\n   * Coarsen the distribution into at most `maxBuckets` contiguous, equal-width\n   * damage buckets, aggregating probability mass (and `count`/`attr`\n   * provenance) into each bucket's start value. Returns this PMF unchanged when\n   * its integer support already fits within `maxBuckets`.\n   *\n   * This is a lossy display/downsampling transform (bucket start replaces the\n   * exact damage value) — use it for charting wide distributions, not for DPR\n   * math.\n   */\n  rebin(maxBuckets: number): PMF {\n    if (!(maxBuckets > 0)) return this;\n    const support = this.support();\n    if (support.length === 0) return this;\n    const min = support[0];\n    const max = support[support.length - 1];\n    const range = max - min;\n    if (range + 1 <= maxBuckets) return this;\n    const binSize = Math.ceil((range + 1) / maxBuckets);\n    return this.mapDamage((d) => min + Math.floor((d - min) / binSize) * binSize);\n  }\n\n  /** Dense integer support from min..max (inclusive).\n   * Useful for showing empty bars in charts.\n   */\n  denseSupport(): number[] {\n    const s = this.support();\n    if (s.length === 0) return [];\n    const lo = Math.min(...s),\n      hi = Math.max(...s);\n    return Array.from({ length: hi - lo + 1 }, (_, i) => lo + i).sort(\n      (a, b) => a - b\n    );\n  }\n\n  /** CDF at x: P(X ≤ x). */\n  cdfAt(x: number): number {\n    let acc = 0;\n    for (const [val, bin] of this.map) if (val <= x) acc += bin.p;\n    return acc;\n  }\n\n  /** Quantile / inverse CDF for p in [0,1]. Returns smallest x with CDF ≥ p. */\n  quantile(p: number): number {\n    if (this.map.size === 0) return 0;\n    const totalMass = this.mass();\n    if (totalMass <= 0) return 0;\n    const s = this.support().sort((a, b) => a - b);\n    let acc = 0;\n    for (const x of s) {\n      acc += this.pAt(x);\n      if (acc / totalMass >= p) return x;\n    }\n    return s[s.length - 1];\n  }\n\n  /** Get outcome probability at specific damage value. */\n  outcomeAt(damage: number, outcome: string): number {\n    return (this.map.get(damage)?.count[outcome] as number) ?? 0;\n  }\n\n  /** Get all outcome types present in this PMF. */\n  outcomes(): string[] {\n    const outcomeSet = new Set<string>();\n    for (const [, bin] of this.map) {\n      for (const outcome in bin.count) {\n        if ((bin.count[outcome] as number) > 0) {\n          outcomeSet.add(outcome);\n        }\n      }\n    }\n    return Array.from(outcomeSet).sort();\n  }\n\n  /** Get total probability of an outcome across all damage values. */\n  outcomeProbability(outcome: string): number {\n    let total = 0;\n    for (const [, bin] of this.map) {\n      total += (bin.count[outcome] as number) ?? 0;\n    }\n    return total;\n  }\n\n  /** Get damage attribution for an outcome at specific damage value. */\n  outcomeAttributionAt(damage: number, outcome: string): number {\n    return (this.map.get(damage)?.attr?.[outcome] as number) ?? 0;\n  }\n\n  /** Get all outcome data at specific damage value. */\n  binAt(damage: number): {\n    p: number;\n    count: Record<string, number>;\n    attr?: Record<string, number>;\n  } | null {\n    const bin = this.map.get(damage);\n    if (!bin) return null;\n\n    return {\n      p: bin.p,\n      count: { ...bin.count } as Record<string, number>,\n      attr: bin.attr ? ({ ...bin.attr } as Record<string, number>) : undefined,\n    };\n  }\n\n  /** Check if outcome exists in this PMF. */\n  hasOutcome(outcome: string): boolean {\n    for (const [, bin] of this.map) {\n      if (((bin.count[outcome] as number) ?? 0) > 0) {\n        return true;\n      }\n    }\n    return false;\n  }\n\n  /**\n   * Split each damage value's probability mass across outcome labels, returning\n   * per-label maps of `damage value → probability mass attributable to that\n   * label`. Summing over labels at a given value recovers that value's `p`.\n   *\n   * Damage-bearing bins are split by `attr` weight (the share of damage each\n   * outcome contributed); the clean-miss bin at 0 is split by `count` weight\n   * (there is no damage to attribute). Attribution is computed on demand via\n   * {@link withAttribution} when absent, so builder-generated PMFs work too.\n   *\n   * This is the provenance core of the stacked damage-attribution chart — the\n   * caller only maps these series into its rendering format (colors, binning,\n   * axis labels).\n   */\n  attributionByValue(): Map<string, Map<number, number>> {\n    const src = this.hasAttribution() ? this : this.withAttribution();\n    const result = new Map<string, Map<number, number>>();\n\n    const add = (label: string, damage: number, mass: number): void => {\n      if (!(mass > 0)) return;\n      let series = result.get(label);\n      if (!series) {\n        series = new Map<number, number>();\n        result.set(label, series);\n      }\n      series.set(damage, (series.get(damage) ?? 0) + mass);\n    };\n\n    for (const [damage, bin] of src.map) {\n      const p = bin.p || 0;\n      if (p <= 0) continue;\n      const isMissBin = damage === 0;\n\n      // Damage-0 (clean miss): split by count, crediting the missNone label.\n      if (isMissBin) {\n        let totalCount = 0;\n        for (const k in bin.count) totalCount += (bin.count[k] as number) || 0;\n        if (totalCount > 0) {\n          const c = (bin.count[MISS_NONE_OUTCOME] as number) || 0;\n          add(MISS_NONE_OUTCOME, damage, (c / totalCount) * p);\n        }\n        continue;\n      }\n\n      // Damage-bearing bin: split by attribution weight.\n      let totalAttr = 0;\n      if (bin.attr) for (const k in bin.attr) totalAttr += (bin.attr[k] as number) || 0;\n      if (bin.attr && totalAttr > 0) {\n        for (const k in bin.attr) {\n          if (k === MISS_NONE_OUTCOME) continue;\n          add(k, damage, (((bin.attr[k] as number) || 0) / totalAttr) * p);\n        }\n      }\n    }\n\n    return result;\n  }\n\n  /**\n   * Reversed-convention CCDF percentile markers used by the attribution chart:\n   * for each target probability t, the largest damage x still reached with\n   * P(X ≥ x) > t%, falling back to the smallest/largest support value at the\n   * edges. Ported verbatim from the app so `p80/p50/p20` keep their intentional\n   * reversed meaning (p80 is the low-damage end). Computed on the full, un-binned\n   * support. Assumes a non-empty map.\n   */\n  private attributionPercentiles(): { p80: number; p50: number; p20: number } {\n    const sortedKeys = [...this.map.keys()].sort((a, b) => a - b);\n    const sparseCCDF: { x: number; y: number }[] = [];\n    let cumulativeP = 0;\n    for (let i = sortedKeys.length - 1; i >= 0; i--) {\n      const key = sortedKeys[i];\n      const bin = this.map.get(key);\n      if (!bin) continue;\n      cumulativeP += bin.p;\n      sparseCCDF.unshift({ x: key, y: cumulativeP * 100 });\n    }\n    const findDamageAtProbability = (targetProb: number): number => {\n      for (let i = 0; i < sparseCCDF.length; i++) {\n        if (sparseCCDF[i].y <= targetProb) {\n          return i > 0 ? sparseCCDF[i - 1].x : sparseCCDF[i].x;\n        }\n      }\n      return sparseCCDF[sparseCCDF.length - 1].x;\n    };\n    return {\n      p80: findDamageAtProbability(80),\n      p50: findDamageAtProbability(50),\n      p20: findDamageAtProbability(20),\n    };\n  }\n\n  /**\n   * Full numeric model for the stacked damage-attribution chart — bar-height\n   * masses, tooltip shares, bucket labels/ranges, percentile markers, and the\n   * mean. The caller only maps these into a rendering format (colors, labels,\n   * axis units); all of the dice-and-probability logic lives here.\n   *\n   * Built split-first-then-bin: the attribution split ({@link attributionByValue})\n   * runs on the un-binned distribution, then the resulting series are coarsened.\n   * {@link rebin} is deliberately *not* used — rebinning first would fold any\n   * sub-`binSize` damage into the damage-0 bucket, which the split then mistakes\n   * for a clean miss and drops.\n   *\n   * @param options.maxBuckets Coarsen to at most this many equal-width buckets\n   *   when the integer support is wider (`range > maxBuckets`); omit for a dense,\n   *   per-integer model.\n   * @param options.stackOrder Preferred outcome order (defaults to\n   *   {@link ALL_OUTCOME_TYPES}); labels outside it sort alphabetically after.\n   * @param options.epsilon Bucket-total floor below which a `shares` entry is 0\n   *   (divide-by-~0 guard). Defaults to 1e-9.\n   */\n  damageAttributionChartModel(\n    options: {\n      maxBuckets?: number;\n      stackOrder?: readonly string[];\n      epsilon?: number;\n    } = {}\n  ): DamageAttributionChartModel {\n    const { maxBuckets, stackOrder = ALL_OUTCOME_TYPES, epsilon = 1e-9 } = options;\n\n    const empty: DamageAttributionChartModel = {\n      labels: [],\n      outcomes: [],\n      series: new Map(),\n      shares: new Map(),\n      totals: [],\n      percentiles: { p80: 0, p50: 0, p20: 0 },\n      mean: 0,\n    };\n    if (this.map.size === 0) return empty;\n\n    // Split on the un-binned distribution: outcome → (damage → probability mass).\n    const split = this.attributionByValue();\n\n    // Discover outcomes across BOTH count and attr keys so any all-zero legend\n    // entries survive (matches the app's discovery), then order for stacking.\n    const discovered = new Set<string>();\n    for (const [, bin] of this.map) {\n      for (const k in bin.count) discovered.add(k);\n      if (bin.attr) for (const k in bin.attr) discovered.add(k);\n    }\n    const outcomes = sortOutcomes([...discovered], stackOrder);\n    const hasAttribution = outcomes.length > 0;\n\n    // Support window over values carrying positive mass (the app's allDamageValues):\n    // from the split for attributed PMFs, from positive-p bins for pure ones.\n    let min = Infinity;\n    let max = -Infinity;\n    const widen = (d: number): void => {\n      if (d < min) min = d;\n      if (d > max) max = d;\n    };\n    if (hasAttribution) {\n      for (const s of split.values())\n        for (const [d, m] of s) if (m > 0) widen(d);\n    } else {\n      for (const [d, bin] of this.map) if ((bin.p || 0) > 0) widen(d);\n    }\n    if (max < min) return empty; // nothing carried positive mass\n    const range = max - min;\n\n    // Binning geometry — dense (per-integer) unless range > maxBuckets.\n    const binned =\n      maxBuckets !== undefined && maxBuckets > 0 && range > maxBuckets;\n    const binSize = binned ? Math.ceil((range + 1) / maxBuckets!) : 1;\n    const numBins = binned ? Math.ceil((range + 1) / binSize) : range + 1;\n    const bucketOf = (d: number): number => Math.floor((d - min) / binSize);\n\n    const labels: number[] = [];\n    const binRanges: { start: number; end: number }[] | undefined = binned\n      ? []\n      : undefined;\n    for (let i = 0; i < numBins; i++) {\n      const start = min + i * binSize;\n      labels.push(start);\n      if (binRanges)\n        binRanges.push({ start, end: Math.min(start + binSize - 1, max) });\n    }\n\n    // Aggregate per-outcome masses into buckets.\n    const series = new Map<string, number[]>();\n    for (const outcome of outcomes) {\n      const arr = new Array<number>(numBins).fill(0);\n      const s = split.get(outcome);\n      if (s) {\n        for (const [d, m] of s) {\n          const b = bucketOf(d);\n          if (b >= 0 && b < numBins) arr[b] += m;\n        }\n      }\n      series.set(outcome, arr);\n    }\n\n    // Per-bucket totals: sum of the attributed series, or (pure) of raw p.\n    const totals = new Array<number>(numBins).fill(0);\n    if (hasAttribution) {\n      for (const arr of series.values())\n        for (let i = 0; i < numBins; i++) totals[i] += arr[i];\n    } else {\n      for (const [d, bin] of this.map) {\n        const p = bin.p || 0;\n        if (p <= 0) continue;\n        const b = bucketOf(d);\n        if (b >= 0 && b < numBins) totals[b] += p;\n      }\n    }\n\n    // Conditional shares for tooltips (guarded against a ~zero bucket total).\n    const shares = new Map<string, number[]>();\n    for (const outcome of outcomes) {\n      const arr = series.get(outcome)!;\n      const sh = new Array<number>(numBins).fill(0);\n      for (let i = 0; i < numBins; i++) {\n        sh[i] = totals[i] > epsilon ? arr[i] / totals[i] : 0;\n      }\n      shares.set(outcome, sh);\n    }\n\n    return {\n      labels,\n      binRanges,\n      outcomes,\n      series,\n      shares,\n      totals,\n      percentiles: this.attributionPercentiles(),\n      mean: this.mean(),\n    };\n  }\n\n  tailProbGE(t: number): number {\n    let s = 0;\n    for (const [x, bin] of this) {\n      if (bin.p > 0 && x >= t) s += bin.p;\n    }\n    return s;\n  }\n\n  tailProbGT(t: number): number {\n    let s = 0;\n    for (const [x, rec] of this) {\n      if (x > t) s += rec.p;\n    }\n    return s;\n  }\n\n  /**\n   * Returns a new PMF containing only bins where the specified outcome has non-zero probability.\n   * This creates a marginal distribution for the given outcome type, with probabilities\n   * scaled to represent the unconditional mass attributable to that outcome.\n   */\n  filterOutcome(outcome: string): PMF {\n    const filteredMap = new Map<number, Bin>();\n\n    for (const [damageValue, bin] of this.map) {\n      const outcomeCount = (bin.count[outcome] as number) ?? 0;\n\n      // total paths that reached this bin (sum across labels)\n      const totalCount = Object.values(bin.count ?? {}).reduce(\n        (a, b) => (a ?? 0) + ((b as number) ?? 0),\n        0\n      );\n\n      if (outcomeCount > 0 && totalCount !== undefined && totalCount > 0) {\n        // proportion of this bin's mass attributable to the outcome\n        const proportion = outcomeCount / totalCount;\n\n        // downweight p to the unconditional mass from the outcome only\n        const newP = bin.p * proportion;\n\n        const newCount: OutcomeLabelMap = { [outcome]: outcomeCount };\n\n        let newAttr: OutcomeLabelMap | undefined;\n        if (bin.attr && bin.attr[outcome] !== undefined) {\n          // If attr is a count-like accumulator, scale it too.\n          // If attr is already per-outcome only, you can just carry it over.\n          newAttr = { [outcome]: (bin.attr[outcome] as number) * proportion };\n        }\n\n        filteredMap.set(damageValue, {\n          p: newP,\n          count: newCount,\n          attr: newAttr,\n        });\n      }\n    }\n\n    return new PMF(\n      filteredMap,\n      this.epsilon,\n      false, // don't normalize by default\n      `filter(${this.identifier},${outcome})`\n    );\n  }\n  /**\n   * Calculates probabilities for first-success outcomes across n independent attempts.\n   *\n   * @param pSuccess - Total probability of any success on a single attempt.\n   * @param pSpecial - Probability of a specific subset of successes (e.g., critical success).\n   * @param n - Number of independent attempts.\n   *\n   * Returns:\n   *  - pSpecificSuccess: Probability that the first success was of the \"special\" type\n   *  - pGeneralSuccess: Probability that the first success was of the non-special type\n   *  - pNone: Probability that no successes occurred\n   *  - pAny: Probability that at least one success occurred\n   */\n  public static firstSuccessWeights(\n    pSuccess: number,\n    pSpecial: number,\n    n: number\n  ) {\n    // Preconditions: the \"special\" successes are a subset of all successes, so\n    // 0 <= pSpecial <= pSuccess <= 1. Without this guard, violating inputs\n    // silently produce probabilities outside [0,1].\n    if (\n      !Number.isFinite(pSuccess) ||\n      !Number.isFinite(pSpecial) ||\n      pSuccess < 0 ||\n      pSuccess > 1 ||\n      pSpecial < 0 ||\n      pSpecial - pSuccess > EPS\n    ) {\n      throw new Error(\n        `firstSuccessWeights: require 0 <= pSpecial <= pSuccess <= 1 (got pSuccess=${pSuccess}, pSpecial=${pSpecial})`\n      );\n    }\n\n    const pFail = 1 - pSuccess;\n    const pFailAll = Math.pow(pFail, n);\n\n    // Probability of at least one success\n    const pAny = 1 - pFailAll;\n\n    // Avoid divide-by-zero if pSuccess is 0\n    const denom = pSuccess === 0 ? 1 : pSuccess;\n\n    // Breakdown of first success type\n    const pSpecificSuccess = (pSpecial * pAny) / denom;\n    const pGeneralSuccess = ((pSuccess - pSpecial) * pAny) / denom;\n\n    const pNone = 1 - pSpecificSuccess - pGeneralSuccess; // Should equal pFailAll\n\n    return { pSpecificSuccess, pGeneralSuccess, pNone, pAny };\n  }\n\n  mapValues(\n    f: (v: number) => number,\n    eps: number = EPS,\n    opts?: { rounding?: Rounding; preserveCounts?: boolean }\n  ): PMF {\n    const rounding = opts?.rounding ?? \"none\";\n    const preserveCounts = opts?.preserveCounts ?? true;\n\n    const round = (x: number) =>\n      rounding === \"floor\"\n        ? Math.floor(x)\n        : rounding === \"ceil\"\n        ? Math.ceil(x)\n        : rounding === \"round\"\n        ? Math.round(x)\n        : x;\n\n    // Accumulate probs and merged counts\n    const probs = new Map<number, number>();\n    const counts = new Map<number, Record<string, number>>();\n\n    for (const [v, bin] of this) {\n      if (Math.abs(bin.p) < eps) continue;\n      const u = round(f(v));\n      probs.set(u, (probs.get(u) ?? 0) + bin.p);\n\n      if (preserveCounts) {\n        // Merge counts if present\n        const src = bin.count;\n        if (src) {\n          const dest = counts.get(u) ?? {};\n          for (const k in src) {\n            dest[k] = (dest[k] ?? 0) + (src[k] as number);\n          }\n          counts.set(u, dest);\n        }\n      }\n    }\n\n    // Build PMF with merged counts, then normalize\n    const internal = new Map<number, Bin>();\n    for (const [u, p] of probs) {\n      internal.set(u, { p, count: counts.get(u) ?? {} });\n    }\n    // Normalize via pmfFromMap to keep one source of truth\n    return PMF.fromMap(\n      new Map(Array.from(internal, ([u, b]) => [u, b.p] as [number, number])),\n      eps\n    );\n  }\n\n  static fromMap(\n    m: Map<number, number>,\n    eps: number = EPS,\n    { requireIntegerValues = true }: { requireIntegerValues?: boolean } = {}\n  ): PMF {\n    const filtered: Array<[number, number]> = [];\n    for (const [v, p] of m) {\n      if (!Number.isFinite(v) || !Number.isFinite(p)) continue;\n      if (p <= 0 || Math.abs(p) < eps) continue;\n      if (requireIntegerValues && !Number.isInteger(v)) {\n        throw new Error(`fromMap: non-integer outcome ${v}`);\n      }\n      filtered.push([v, p]);\n    }\n\n    if (filtered.length === 0) {\n      throw new Error(\"fromMap: empty or invalid input map\");\n    }\n\n    // Kahan sum for stability\n    let sum = 0;\n    let c = 0;\n    for (const [, p] of filtered) {\n      const y = p - c;\n      const t = sum + y;\n      c = t - sum - y;\n      sum = t;\n    }\n    if (sum <= 0) throw new Error(\"pmfFromMap: probabilities sum to 0\");\n\n    filtered.sort((a, b) => a[0] - b[0]);\n\n    const internal = new Map<number, Bin>();\n    for (const [v, p] of filtered) {\n      internal.set(v, { p: p / sum, count: {} }); // keep count object present for consistency\n    }\n    return new PMF(internal, eps);\n  }\n\n  query(): DiceQuery {\n    return new DiceQuery(this);\n  }\n}\n","import type { Bin } from \"../common/types\";\nimport { EPS } from \"../common/types\";\nimport { PMF } from \"./pmf\";\n\n/** A labeled mixture builder that preserves provenance in Bin.count. */\nexport class Mixture<L extends string = string> {\n  private readonly totals = new Map<number, number>(); // raw mass per outcome (pre-normalization)\n  private readonly labelMass = new Map<number, Record<L, number>>(); // raw mass per outcome per label\n  private readonly eps: number;\n\n  constructor(eps: number = EPS) {\n    this.eps = Number.isFinite(eps) ? eps : EPS;\n  }\n\n  /** Remove all accumulated state. */\n  clear(): this {\n    this.totals.clear();\n    this.labelMass.clear();\n    return this;\n  }\n\n  /** Number of distinct outcome values currently accumulated. */\n  size(): number {\n    return this.totals.size;\n  }\n\n  /** Whether a label was ever added. */\n  hasLabel(label: L): boolean {\n    for (const bag of this.labelMass.values()) if (bag[label]) return true;\n    return false;\n  }\n\n  /**\n   * Add a labeled component with a mixture weight.\n   * Weight can be any positive finite number. Very small contributions are pruned by eps.\n   */\n  add(label: L, pmf: PMF, weight = 1): this {\n    if (!Number.isFinite(weight) || weight <= 0) return this;\n\n    // Stream probabilities from each [value, Bin] pair.\n    for (const [v, bin] of pmf) {\n      const p = bin.p;\n      if (p <= 0) continue;\n\n      const add = weight * p;\n      if (!Number.isFinite(add) || Math.abs(add) < this.eps) continue;\n\n      this.totals.set(v, (this.totals.get(v) ?? 0) + add);\n      const bag = this.labelMass.get(v) ?? ({} as Record<L, number>);\n      bag[label] = (bag[label] ?? 0) + add;\n      this.labelMass.set(v, bag);\n    }\n\n    return this;\n  }\n\n  buildPMF(eps: number = EPS): PMF {\n    // Kahan sum for robustness.\n    let grand = 0;\n    let c = 0;\n    for (const m of this.totals.values()) {\n      const y = m - c;\n      const t = grand + y;\n      c = t - grand - y;\n      grand = t;\n    }\n    if (!(grand > 0)) throw new Error(\"Mixture: zero total mass\");\n\n    const internal = new Map<number, Bin>();\n    for (const [v, m] of this.totals) {\n      if (m <= 0 || Math.abs(m) < this.eps) continue;\n      const count = this.labelMass.get(v) ?? {};\n      internal.set(v, { p: m / grand, count });\n    }\n    return new PMF(internal, eps);\n  }\n\n  /**\n   * Produce normalized *per-label* PMFs (labels independent).\n   * These are unlabeled PMFs built from the raw mass of that label alone.\n   */\n  byOutcome(): Record<L, PMF> {\n    // Collect the set of labels present.\n    const labels = new Set<L>();\n    for (const bag of this.labelMass.values()) {\n      for (const k of Object.keys(bag) as L[]) labels.add(k);\n    }\n\n    const out = {} as Record<L, PMF>;\n    for (const label of labels) {\n      const m = new Map<number, number>();\n      for (const [v, bag] of this.labelMass) {\n        const w = bag[label];\n        if (w && Math.abs(w) >= this.eps) m.set(v, w);\n      }\n      if (m.size > 0) out[label] = PMF.fromMap(m, this.eps);\n    }\n    return out;\n  }\n\n  /**\n   * Mixture weights per label, normalized to sum to 1 over labels that appeared.\n   * Uses raw mass before per-outcome normalization.\n   */\n  weights(): Record<L, number> {\n    const res = {} as Record<L, number>;\n    for (const [, bag] of this.labelMass) {\n      for (const [lab, w] of Object.entries(bag) as [L, number][]) {\n        if (!Number.isFinite(w) || w <= 0) continue;\n        res[lab] = (res[lab] ?? 0) + w;\n      }\n    }\n    // Normalize\n    let total = 0;\n    let c = 0;\n    for (const v of Object.values(res)) {\n      const y = (v as number) - c;\n      const t = total + y;\n      c = t - total - y;\n      total = t;\n    }\n    if (total > 0) {\n      for (const k in res) res[k as L] = res[k as L] / total;\n    }\n    return res;\n  }\n\n  toJSON(): {\n    totals: Array<[number, number]>;\n    labels: Array<[number, Record<L, number>]>;\n    eps: number;\n  } {\n    return {\n      totals: Array.from(this.totals.entries()).sort((a, b) => a[0] - b[0]),\n      labels: Array.from(this.labelMass.entries()).sort((a, b) => a[0] - b[0]),\n      eps: this.eps,\n    };\n  }\n\n  static mix<L extends string = string>(\n    items: Array<[label: L, pmf: PMF, weight: number]>,\n    eps: number = EPS\n  ): PMF {\n    const mix = new Mixture<L>(eps);\n    for (const [lab, pmf, w] of items) mix.add(lab, pmf, w);\n    return mix.buildPMF();\n  }\n}\n","/**\n * Error thrown when a dice expression cannot be parsed.\n *\n * Extends the built-in {@link Error}, so existing `catch (e)` / message checks\n * continue to work, while callers can now narrow with `instanceof DiceParseError`.\n *\n * @example\n * try {\n *   parse(\"d6@3\");\n * } catch (e) {\n *   if (e instanceof DiceParseError) {\n *     // e.expression === \"d6@3\"\n *   }\n * }\n */\nexport class DiceParseError extends Error {\n  /** The original expression that failed to parse, when available. */\n  readonly expression?: string;\n\n  /** The underlying error that triggered this one, when available. */\n  readonly cause?: unknown;\n\n  constructor(\n    message: string,\n    options?: { expression?: string; cause?: unknown }\n  ) {\n    super(message);\n    this.name = \"DiceParseError\";\n    this.expression = options?.expression;\n    this.cause = options?.cause;\n    // Restore the prototype chain for reliable `instanceof` across targets.\n    Object.setPrototypeOf(this, DiceParseError.prototype);\n  }\n}\n","// dice.ts (internal)\n\nimport { DiceParseError } from \"../common/errors\";\nimport type {\n  Bin,\n  DamageDistribution,\n  OutcomeLabelMap,\n  OutcomeType,\n} from \"../common/types\";\nimport { EPS } from \"../common/types\";\nimport { PMF } from \"../pmf/pmf\";\n\n/**\n * Work budget for a single dice×dice operation. binaryOp is O(faces₁ × faces₂),\n * so two individually-legal large dice (e.g. `d100000 + d100000`) would otherwise\n * enumerate ~10^10 face pairs and hang. The parser's per-die / per-count caps\n * bound each operand but not their product, so this bounds the operation itself.\n * Generous enough for any realistic expression; only pathological blow-ups trip\n * it. (Chosen so expressions well beyond normal use still parse; tune if needed.)\n */\nconst MAX_BINARY_OUTCOMES = 100_000_000;\n\n/** Internal bookkeeping attached to a {@link Dice} during parsing. */\nexport interface DicePrivateData {\n  /** Marks a DC (saving-throw) check so outcomes are attributed correctly. */\n  isDCCheck?: boolean;\n  /** The \"other\" distribution recorded by {@link Dice.combine}. */\n  except?: Dice | Record<string, never>;\n  /** Keep-highest/lowest selector applied when a die is multiplied out. */\n  keep?: (values: number[]) => number;\n  /** Set on a freshly parsed flat `dN`/`hdN` atom: its own face count and whether it rerolls a\n   * natural 1 once (Halfling Luck). Read by {@link parseExpression} in parser.ts to recover a\n   * base check die's natural-max identity after it has been convolved with bonus to-hit dice\n   * and modifiers, for a correct plain-`crit` probability. See parser.ts's \"Track a flat ...\n   * base check die\" comment. */\n  checkDie?: { sides: number; rerollOne: boolean };\n  /** Set on the result of a tracked AC gate (see parser.ts): the exact \"natural max, any bonus\n   * roll\" sub-distribution, already isolated from the rest of the to-hit total. A plain `crit`\n   * clause reads this directly instead of peeling the combined expression's single highest\n   * face, which is wrong whenever bonus dice are present. */\n  natMaxCritSlice?: Dice;\n}\n\n/**\n * @internal\n */\nexport class Dice {\n  private readonly faces: DamageDistribution = {};\n  public privateData: DicePrivateData = {};\n  // Partial: the object starts empty and gains keys as outcomes are recorded,\n  // so the type must not claim every OutcomeType is present. (Previously typed\n  // as a full Record via an `as` cast, which lied about missing keys.)\n  private outcomeData: Partial<Record<OutcomeType, DamageDistribution>> = {};\n  private hasHitDistributionCalculated = false;\n  public identifier?: string;\n\n  constructor(x: number = 0) {\n    if (x <= 0) return;\n    for (let i = 1; i <= x; i++) {\n      this.faces[i] = 1;\n    }\n  }\n\n  getOutcomeDistribution(key: OutcomeType): DamageDistribution | undefined {\n    if (key === \"hit\") {\n      this.ensureHitDistribution();\n    }\n\n    const distribution = this.outcomeData[key];\n    if (distribution === undefined) return undefined;\n\n    return { ...distribution };\n  }\n\n  getFullOutcomeDistribution(): Partial<\n    Record<OutcomeType, DamageDistribution>\n  > {\n    return { ...this.outcomeData };\n  }\n\n  setOutcomeDistribution(\n    key: OutcomeType,\n    data: DamageDistribution | undefined\n  ): void {\n    if (data) {\n      this.outcomeData[key] = data;\n    } else {\n      delete this.outcomeData[key];\n    }\n  }\n\n  hasOutcomeData(key: OutcomeType): boolean {\n    if (key === \"hit\") {\n      this.ensureHitDistribution();\n    }\n    const data = this.outcomeData[key];\n    return data !== undefined && Object.keys(data).length > 0;\n  }\n\n  getOutcomeCount(key: OutcomeType, face: number): number {\n    return this.outcomeData[key]?.[face] ?? 0;\n  }\n\n  getAverage(key: OutcomeType): number {\n    const distribution = this.getOutcomeDistribution(key);\n    if (!distribution) return 0;\n    // TODO caching opportunity\n\n    const totalCount = Object.values(distribution).reduce(\n      (sum, count) => sum + count,\n      0\n    );\n    const expectedDamage = Object.entries(distribution).reduce(\n      (sum, [damage, count]) => sum + Number(damage) * count,\n      0\n    );\n    if (totalCount === 0) return 0;\n    return expectedDamage / totalCount;\n  }\n\n  // TODO this can be private later if we change how testing works\n  calculateHitDistribution(): DamageDistribution {\n    const hitValues: DamageDistribution = {};\n\n    // Hoist the per-outcome distributions out of the face loop: they are\n    // constant across faces, so fetching (and previously cloning) them once is\n    // O(faces + outcomes) instead of O(faces × outcomes). The stored maps are\n    // only read here, never mutated, so reading them directly is safe and\n    // produces identical counts.\n    const subtractedOutcomes: (DamageDistribution | undefined)[] = [\n      this.outcomeData.crit,\n      this.outcomeData.missNone,\n      this.outcomeData.missDamage,\n      this.outcomeData.saveHalf,\n      this.outcomeData.saveFail,\n      this.outcomeData.pc,\n    ];\n\n    for (const [face, totalCount] of Object.entries(this.faces)) {\n      const numFace = Number(face);\n      let hitCount = totalCount;\n\n      for (const distribution of subtractedOutcomes) {\n        const outcomeCount = distribution?.[numFace];\n        if (outcomeCount) {\n          hitCount -= outcomeCount;\n        }\n      }\n\n      // Zero damage should not be counted as hits - they represent misses\n      if (numFace === 0) {\n        hitCount = 0;\n      }\n\n      // Defensive clamp: guards against negative hit counts from older\n      // inclusion-exclusion logic. Should never trigger in practice.\n      if (hitCount < 0) {\n        hitCount = 0;\n      }\n      hitValues[numFace] = hitCount;\n    }\n\n    return hitValues;\n  }\n\n  private ensureHitDistribution(): void {\n    if (!this.hasHitDistributionCalculated) {\n      const hitValues = this.calculateHitDistribution();\n      this.setOutcomeDistribution(\"hit\", hitValues);\n      this.hasHitDistributionCalculated = true;\n    }\n  }\n\n  // PRIVATE FUNCTIONS\n\n  private binaryOp(\n    other: Dice | number,\n    op: (a: number, b: number) => number,\n    diceConstructor?: () => Dice\n  ): Dice {\n    const result = diceConstructor ? diceConstructor() : new Dice();\n\n    const isScalar = typeof other === \"number\";\n    const keys1 = this.keys();\n    // Hoist the inner die's faces out of the outer loop: they are constant\n    // across key1, so computing them once avoids re-allocating the array on\n    // every outer iteration.\n    const keys2 = isScalar ? [] : (other as Dice).keys();\n\n    // Guard the O(faces₁ × faces₂) work before running it: a binary op between\n    // two large (but individually legal) dice would otherwise blow up.\n    if (!isScalar && keys1.length * keys2.length > MAX_BINARY_OUTCOMES) {\n      throw new DiceParseError(\n        `Dice operation over ${keys1.length}×${keys2.length} face pairs exceeds the maximum of ${MAX_BINARY_OUTCOMES}`\n      );\n    }\n\n    for (const key1 of keys1) {\n      const value1 = this.faces[key1]!;\n\n      if (isScalar) {\n        const resultKey = op(key1, other as number);\n        result.increment(resultKey, value1);\n      } else {\n        for (const key2 of keys2) {\n          const value2 = other.faces[key2]!;\n          const resultKey = op(key1, key2);\n          result.increment(resultKey, value1 * value2);\n        }\n      }\n    }\n\n    return result;\n  }\n\n  private removeFaces(facesToRemove: number[]): Dice {\n    const result = new Dice();\n\n    for (const [key, value] of Object.entries(this.faces)) {\n      const numKey = Number(key);\n      if (!facesToRemove.includes(numKey)) {\n        result.faces[numKey] = value;\n      }\n    }\n\n    result.privateData = { ...this.privateData };\n    result.outcomeData = { ...this.outcomeData };\n    return result;\n  }\n\n  // PUBLIC FUNCTIONS\n\n  getFaceEntries(): [number, number][] {\n    return Object.entries(this.faces).map(([k, v]) => [Number(k), v]);\n  }\n\n  getFaceMap(): DamageDistribution {\n    return { ...this.faces };\n  }\n\n  get(face: number): number {\n    return this.faces[face] ?? 0;\n  }\n\n  keys(): number[] {\n    return Object.keys(this.faces).map(Number);\n  }\n\n  values(): number[] {\n    return Object.values(this.faces);\n  }\n\n  total(): number {\n    return Object.values(this.faces).reduce((sum, value) => sum + value, 0);\n  }\n\n  public setFace(key: number, value: number): void {\n    this.faces[key] = value;\n  }\n\n  public static scalar(value: number): Dice {\n    const result = new Dice();\n    result.increment(value, 1);\n    return result;\n  }\n\n  public maxFace(): number {\n    const numericKeys = this.keys();\n\n    if (numericKeys.length === 0) {\n      throw new Error(\"No numeric faces found\");\n    }\n\n    return Math.max(...numericKeys);\n  }\n\n  public minFace(): number {\n    const numericKeys = this.keys();\n\n    if (numericKeys.length === 0) {\n      throw new Error(\"No numeric faces found\");\n    }\n\n    return Math.min(...numericKeys);\n  }\n\n  public increment(face: number, count: number): void {\n    const current = this.faces[face] || 0;\n    this.faces[face] = current + count;\n  }\n\n  public normalize(scalar: number): Dice {\n    const result = new Dice();\n\n    for (const [face, count] of Object.entries(this.faces)) {\n      result.faces[Number(face)] = count * scalar;\n    }\n\n    result.privateData = { ...this.privateData };\n    result.outcomeData = { ...this.outcomeData };\n    return result;\n  }\n\n  // OPERATIONS\n\n  public add(other: Dice | number): Dice {\n    return this.binaryOp(other, (a, b) => a + b);\n  }\n\n  public subtract(other: Dice | number): Dice {\n    return this.binaryOp(other, (a, b) => a - b);\n  }\n\n  public conditionalApply(other: Dice | number): Dice {\n    return this.binaryOp(other, (a, b) => (a === 0 ? 0 : 1) * b);\n  }\n\n  public multiply(other: Dice | number): Dice {\n    return this.binaryOp(other, (a, b) => a * b);\n  }\n\n  public addNonZero(other: Dice | number): Dice {\n    return this.binaryOp(other, (a, b) => (a !== 0 ? a + b : a));\n  }\n\n  public eq(other: Dice | number): Dice {\n    return this.binaryOp(other, (a, b) => (a === b ? 1 : 0));\n  }\n\n  public max(other: Dice | number): Dice {\n    return this.binaryOp(other, (a, b) => Math.max(a, b));\n  }\n\n  public min(other: Dice | number): Dice {\n    return this.binaryOp(other, (a, b) => Math.min(a, b));\n  }\n\n  public advantage(): Dice {\n    return this.max(this);\n  }\n\n  public ge(other: Dice | number): Dice {\n    return this.binaryOp(other, (a, b) => (a >= b ? 0 : 1));\n  }\n\n  public divide(other: Dice | number): Dice {\n    return this.binaryOp(other, (a, b) => a / b);\n  }\n\n  public divideRoundUp(other: Dice | number): Dice {\n    return this.binaryOp(other, (a, b) => Math.ceil(a / b));\n  }\n\n  public divideRoundDown(other: Dice | number): Dice {\n    return this.binaryOp(other, (a, b) => Math.floor(a / b));\n  }\n\n  public and(other: Dice | number): Dice {\n    return this.binaryOp(other, (a, b) => (a && b ? 1 : 0));\n  }\n\n  private checkTarget(\n    other: Dice | number,\n    comparisonLogic: (roll: number, target: number) => number\n  ): Dice {\n    const createResult = () => {\n      const result = new Dice();\n      result.increment(0, 0); // Success\n      result.increment(1, 0); // Failure\n      return result;\n    };\n\n    return this.binaryOp(other, comparisonLogic, createResult);\n  }\n\n  public dc(other: Dice | number): Dice {\n    const dcCheck = (a: number, b: number) => (a >= b ? 0 : 1);\n    const result = this.checkTarget(other, dcCheck);\n    // Mark this as a DC check (save mechanic) for proper attribute assignment\n    result.privateData.isDCCheck = true;\n    return result;\n  }\n\n  public ac(other: Dice | number): Dice {\n    const acCheck = (a: number, b: number) => (a >= b ? a : 0);\n    return this.checkTarget(other, acCheck);\n  }\n\n  public deleteFace(face: number): Dice {\n    const result = new Dice();\n\n    for (const [key, value] of Object.entries(this.faces)) {\n      const numKey = Number(key);\n      if (numKey !== face) {\n        result.increment(numKey, value);\n      }\n    }\n\n    result.privateData = { ...this.privateData };\n    result.outcomeData = { ...this.outcomeData };\n    return result;\n  }\n\n  public reroll(toReroll: Dice | number): Dice {\n    const rerollDice =\n      typeof toReroll === \"number\" ? Dice.scalar(toReroll) : toReroll;\n\n    const rerollKeys = rerollDice.keys();\n    const rerollSet = new Set(rerollKeys);\n    const removed = this.removeFaces(rerollKeys);\n    let result = new Dice();\n\n    for (const face of this.keys()) {\n      const wasRerolled = rerollSet.has(face);\n      result = result.combine(removed);\n      if (wasRerolled) {\n        result = result.combine(this);\n      }\n    }\n\n    return result;\n  }\n\n  // This is not addition and not rolling two dice at once.\n  // Instead, it’s mixing two distributions into a single weighted die.\n  public combine(other: Dice | number): Dice {\n    if (typeof other === \"number\") {\n      other = Dice.scalar(other);\n    }\n\n    // Start by copying \"other\" into a new Dice object\n    const result = new Dice();\n    for (const [key, value] of Object.entries(other.faces)) {\n      result.faces[Number(key)] = value;\n    }\n\n    // Build the \"except\" dice and add faces from `this` to result\n    const except = new Dice();\n    for (const [key, value] of Object.entries(this.faces)) {\n      const numKey = Number(key);\n      result.increment(numKey, value);\n\n      // If the key did not already exist in `other`, we remove it from `except`\n      if (!(numKey in other.faces)) {\n        except.increment(numKey, value); // still tracked in except\n      }\n    }\n\n    result.privateData = { ...this.privateData, except: other };\n    result.outcomeData = { ...this.outcomeData };\n    return result;\n  }\n\n  public combineInPlace(other: Dice): void {\n    for (const [key, value] of Object.entries(other.faces)) {\n      const numKey = Number(key);\n      const current = this.faces[numKey] || 0;\n      this.faces[numKey] = current + value;\n    }\n  }\n\n  public percent(): DamageDistribution {\n    const total = this.total();\n    const result: DamageDistribution = {};\n\n    for (const [face, count] of Object.entries(this.faces)) {\n      result[Number(face)] = count / total;\n    }\n\n    return result;\n  }\n\n  public average(): number {\n    const total = this.total();\n    if (total === 0) return 0;\n\n    let sum = 0;\n    for (const [key, value] of Object.entries(this.faces)) {\n      sum += Number(key) * value;\n    }\n\n    return sum / total;\n  }\n\n  /*\n   * Convert dice to PMF using OutcomeType labels directly from damage distribution.\n   * This is much cleaner than the original complex distribution conversion.\n   */\n  public toPMF(numEpsilon: number = EPS): PMF {\n    const total = this.total();\n    if (total === 0) return PMF.empty(numEpsilon);\n\n    // Ensure hit distribution is calculated before using it\n    this.ensureHitDistribution();\n\n    const map = new Map<number, Bin>();\n\n    // Outcome distributions (counts, not probabilities)\n    const hitDistro = this.getOutcomeDistribution(\"hit\") || {};\n    const critDistro = this.getOutcomeDistribution(\"crit\") || {};\n    const missDistro = this.getOutcomeDistribution(\"missDamage\") || {};\n    const saveDistro = this.getOutcomeDistribution(\"saveHalf\") || {};\n    const pcDistro = this.getOutcomeDistribution(\"pc\") || {};\n\n    // A non-empty save distribution means the \"save\" mechanic was used (e.g.\n    // \"save half\"): its success mass is a saveHalf outcome and the remaining\n    // (full-damage) mass is a saveFail. The previous heuristic — \"isSaveHalf iff\n    // 2×(a half value) appears in the hit distribution\" — false-negatived on odd\n    // or constant damage, mislabeling saveHalf as saveFail and saveFail as hit.\n    const isSaveHalf = Object.keys(saveDistro).length > 0;\n\n    const isDCCheck = this.privateData.isDCCheck === true;\n\n    const clampNonNeg = (x: number) => (x < 0 && x > -1e-15 ? 0 : x);\n\n    // Process each face value (iterate the internal map directly; this loop\n    // only reads it, so the defensive clone from getFaceMap() is unnecessary)\n    for (const [faceStr, faceCountRaw] of Object.entries(this.faces)) {\n      const face = Number(faceStr);\n      const faceCount = Number(faceCountRaw);\n\n      // Skip structurally present but empty bins early\n      if (faceCount <= 0) continue;\n\n      let p = faceCount / total;\n      p = clampNonNeg(p);\n\n      // Always drop exact zeros to keep PMF semantics clean\n      if (!(p > 0)) continue;\n\n      // Optional pruning only when epsilon is enabled\n      if (numEpsilon >= 0 && p < numEpsilon) continue;\n\n      const count: OutcomeLabelMap = {};\n      const attr: OutcomeLabelMap = {};\n\n      // Add distribution counts and attributions\n      if (hitDistro[face]) {\n        const c = clampNonNeg(hitDistro[face] / total);\n        if (c > 0) {\n          if (isSaveHalf || isDCCheck) {\n            count.saveFail = c; // full damage on failed save\n            attr.saveFail = clampNonNeg((face * hitDistro[face]) / total);\n          } else {\n            count.hit = c;\n            attr.hit = clampNonNeg((face * hitDistro[face]) / total);\n          }\n        }\n      }\n\n      if (critDistro[face]) {\n        const c = clampNonNeg(critDistro[face] / total);\n        if (c > 0) {\n          count.crit = c;\n          attr.crit = clampNonNeg((face * critDistro[face]) / total);\n        }\n      }\n\n      if (missDistro[face]) {\n        const c = clampNonNeg(missDistro[face] / total);\n        if (c > 0) {\n          count.missDamage = c;\n          attr.missDamage = clampNonNeg((face * missDistro[face]) / total);\n        }\n      }\n\n      if (saveDistro[face]) {\n        const c = clampNonNeg(saveDistro[face] / total);\n        if (c > 0) {\n          if (isSaveHalf) {\n            count.saveHalf = c; // half damage on successful save\n            attr.saveHalf = clampNonNeg((face * saveDistro[face]) / total);\n          } else {\n            count.saveFail = (count.saveFail ?? 0) + c; // regular fail\n            attr.saveFail = clampNonNeg(\n              (attr.saveFail ?? 0) + (face * saveDistro[face]) / total\n            );\n          }\n        }\n      }\n\n      if (pcDistro[face]) {\n        const c = clampNonNeg(pcDistro[face] / total);\n        if (c > 0) {\n          count.pc = c;\n          attr.pc = clampNonNeg((face * pcDistro[face]) / total);\n        }\n      }\n\n      // Handle faces with no specific distribution (missNone) for non-save and non-DC checks\n      if (!isSaveHalf && !isDCCheck) {\n        const distroCountRaw =\n          (hitDistro[face] || 0) +\n          (critDistro[face] || 0) +\n          (missDistro[face] || 0) +\n          (saveDistro[face] || 0) +\n          (pcDistro[face] || 0);\n\n        const unaccountedCount = clampNonNeg(faceCount - distroCountRaw);\n        if (unaccountedCount > 0) {\n          const frac = clampNonNeg(unaccountedCount / total);\n          if (frac > 0) {\n            count.missNone = (count.missNone ?? 0) + frac;\n            // missNone does 0 damage, so no attr contribution\n          }\n        }\n      }\n\n      const bin: Bin = { p, count };\n      if (Object.keys(attr).length > 0) {\n        bin.attr = attr;\n      }\n\n      map.set(face, bin);\n    }\n\n    // Fall back to a sentinel identifier if none was assigned. This indicates\n    // a Dice constructed outside the normal parse/build flow.\n    const identifier = this.identifier || \"ERROR\";\n\n    // Normalize, drop zeros again if any snuck in, then compaction and pruning\n    return new PMF(map, numEpsilon, true, identifier).compact(numEpsilon, true);\n  }\n}\n\nexport type _DiceInternal = never;\n","import { DiceParseError } from \"../common/errors\";\nimport { LRUCache } from \"../common/lru-cache\";\nimport type { OutcomeType } from \"../common/types\";\nimport type { PMF } from \"../pmf/pmf\";\nimport { Dice } from \"./dice\";\n\ntype DiceOperation = ((this: Dice, other: Dice | number) => Dice) & {\n  unary?: boolean;\n};\n\n/**\n * Resource-exhaustion guards. Adversarial expressions (a huge die, a huge dice\n * count, or a keep over a large enumerated pool) can otherwise blow up memory\n * and CPU. These caps are deliberately generous so every legitimate expression\n * the suite exercises (e.g. d100000) still parses.\n */\n// Must stay >= 100000: the suite asserts d100000 (100k faces) parses.\nconst MAX_DIE_SIDES = 1_000_000;\nconst MAX_DICE_COUNT = 10_000;\n// multiplyDiceByDice enumerates faces^count outcomes when a keep is applied.\nconst MAX_KEEP_OUTCOMES = 1_000_000;\n\n/**\n * Internal parse cache for PMFs produced from string expressions.\n * Keyed by cleaned expression (spaces stripped, lowercased) and optional `n` value.\n */\nconst parseCache = new LRUCache<string, PMF>(1000);\n\nlet cachingEnabled = true;\n\n/** Enable or disable the internal parse cache. */\nexport function setCachingEnabled(enabled: boolean): void {\n  cachingEnabled = enabled;\n  if (!enabled) clearParserCache();\n}\n\n/** Returns whether the internal parse cache is currently enabled. */\nexport function getCachingEnabled(): boolean {\n  return cachingEnabled;\n}\n\n/** Clears the internal parse cache. */\nexport function clearParserCache(): void {\n  parseCache.clear();\n}\n\n/**\n * Parse a dice expression into a PMF.\n *\n * - Expression is case-insensitive and ignores spaces.\n */\nexport function parse(expression: string, n: number = 0): PMF {\n  // Check cache first if enabled\n  const cleaned = expression.replace(/ /g, \"\").toLowerCase();\n\n  if (cachingEnabled) {\n    const cacheKey = `${cleaned}:${n}`;\n    const cached = parseCache.get(cacheKey);\n    if (cached) return cached;\n  }\n\n  const chars = [...cleaned];\n\n  let result: Dice;\n  try {\n    result = parseExpression(chars, n);\n  } catch (error) {\n    throw new DiceParseError(\n      `Cannot parse dice expression [${expression}]: ${error}`,\n      { expression, cause: error }\n    );\n  }\n\n  result.privateData = result.privateData || {};\n  result.identifier = cleaned;\n\n  if (chars.length > 0) {\n    throw new DiceParseError(\n      `Unexpected token: '${chars[0]}' from expression: '${expression}'`,\n      { expression }\n    );\n  }\n\n  // When creating the PMF, do not epsilon prune\n  const resultPMF = result.toPMF(-1);\n  if (cachingEnabled) {\n    // store using the same cleaned key we used for lookup\n    const cacheKey = `${cleaned}:${n}`;\n    parseCache.set(cacheKey, resultPMF);\n  }\n\n  return resultPMF;\n}\n\nfunction combineDiceWithNormalization(\n  dice: Dice,\n  normValue: number,\n  outcomeType: OutcomeType,\n  currentNorm: number,\n  finalResult: Dice\n): { newNorm: number; updatedResult: Dice } {\n  dice = dice.normalize(currentNorm);\n  finalResult = finalResult.normalize(normValue);\n  finalResult.setOutcomeDistribution(outcomeType, dice.getFaceMap());\n  finalResult = finalResult.combine(dice);\n  return { newNorm: currentNorm * normValue, updatedResult: finalResult };\n}\n\n/**\n * Face-wise histogram difference. NOT the same as {@link Dice.subtract}, which convolves VALUES\n * (`a - b` as numbers); this subtracts raw face COUNTS, used to isolate \"everything except this\n * natural-die-value's contribution\" out of an already-convolved to-hit total.\n */\nfunction subtractCounts(a: Dice, b: Dice): Dice {\n  const result = new Dice();\n  for (const [key, value] of a.getFaceEntries()) result.increment(key, value);\n  for (const [key, value] of b.getFaceEntries()) result.increment(key, -value);\n  return result;\n}\n\nfunction parseExpression(arr: string[], n: number): Dice {\n  const result = (() => {\n    const res = parseArgument(arr, n);\n    return typeof res === \"number\" ? Dice.scalar(res) : res;\n  })();\n\n  let op = parseOperation(arr);\n  let finalResult = result;\n\n  // Track a flat (no advantage/disadvantage/reroll) base check die's natural-max face\n  // separately from whatever bonus-to-hit dice and modifiers get added to it, so a later plain\n  // `crit` clause -- possibly in an OUTER parseExpression call, once this AC-checked\n  // sub-expression has already collapsed to one Dice -- can recover the exact \"natural max, any\n  // bonus roll\" slice instead of peeling the combined expression's single highest TOTAL, which\n  // undercounts crit mass whenever bonus dice are present (e.g. Bless: \"d20 + 5 + 1d4\" reported\n  // a crit probability of 1/(20*4) instead of 1/20).\n  //\n  // Scoped narrowly and deliberately: only a bare flat `dN` base die with no reroll, combined\n  // solely via `+`/`-`, terminated by a numeric `AC`/`DC` target. Anything else --\n  // advantage/disadvantage/elven accuracy on the base die, halfling reroll, a dynamic\n  // (dice-valued) AC target, or `xcrit` (an expanded crit RANGE, which needs its own AC check\n  // per natural face) -- invalidates tracking and falls back to the legacy peel-based behavior,\n  // which remains correct with no bonus dice and is the same known-imperfect approximation\n  // otherwise. See CHANGELOG.\n  let baseDieMeta =\n    result.privateData?.checkDie && !result.privateData.checkDie.rerollOne\n      ? result.privateData.checkDie\n      : undefined;\n  let bonusOnly = Dice.scalar(0);\n\n  while (op != null) {\n    const arg = !op.unary ? parseArgument(arr, n) : finalResult;\n\n    let acAlreadyApplied = false;\n    if (baseDieMeta) {\n      if (op === Dice.prototype.addNonZero) {\n        bonusOnly = bonusOnly.add(arg);\n      } else if (op === Dice.prototype.subtract) {\n        bonusOnly = bonusOnly.subtract(arg);\n      } else if (op === Dice.prototype.ac && typeof arg === \"number\") {\n        // Isolate the natural-max face's contribution BEFORE gating, so the crit clause can use\n        // it directly (see below) -- but AC-gate it exactly like every other natural value (no\n        // RAW \"natural 20 always hits\" exception here: that would change this checked total's\n        // hit/miss math, not just crit attribution, and several tests pin the parser's existing\n        // \"AC is a pure numeric threshold, no natural-face exceptions\" behavior, e.g. an\n        // unreachably high AC yields zero mass even on a natural max). Splitting into two pieces\n        // and re-gating each is mathematically identical to gating the whole, since `.ac()` acts\n        // per-face independently.\n        const natMaxSlice = bonusOnly.add(baseDieMeta.sides);\n        const restSlice = subtractCounts(finalResult, natMaxSlice);\n        const gatedNatMaxSlice = natMaxSlice.ac(arg);\n        finalResult = restSlice.ac(arg).combine(gatedNatMaxSlice);\n        finalResult.privateData.checkDie = baseDieMeta;\n        finalResult.privateData.natMaxCritSlice = gatedNatMaxSlice;\n        acAlreadyApplied = true;\n        baseDieMeta = undefined;\n      } else {\n        baseDieMeta = undefined;\n      }\n    }\n\n    // Handle crit (e.g. xcrit, crit)\n    let crit: Dice | undefined;\n    let critNorm = 1;\n    if (arr[0] === \"x\" || arr[0] === \"c\") {\n      const isXcrit = arr[0] === \"x\";\n      if (isXcrit) assertToken(arr, \"x\");\n      assertToken(arr, \"c\");\n      assertToken(arr, \"r\");\n      assertToken(arr, \"i\");\n      assertToken(arr, \"t\");\n\n      const count = isXcrit ? parseNumber(arr, n) : 1;\n      const trackedCritSlice = finalResult.privateData?.natMaxCritSlice;\n\n      if (count === 1 && trackedCritSlice) {\n        // Exact path: trackedCritSlice already isolates \"natural max, any bonus roll\" (see the\n        // AC-tracking block above), independent of how many bonus-to-hit dice sides would\n        // otherwise smear that mass across several total values.\n        crit = trackedCritSlice;\n        finalResult = subtractCounts(finalResult, trackedCritSlice);\n      } else {\n        // KNOWN LIMITATION (xcrit, or no tracked base die -- advantage/disadvantage/elven\n        // accuracy, halfling reroll, or bonus dice mixed into a non-flat check): peels the\n        // maximum FACE of the already-convolved to-hit distribution. Correct only when the\n        // to-hit has no bonus dice, since bonus dice otherwise smear a natural-max roll's mass\n        // across several total values that also contain non-crit mass. Use the builder API\n        // (d20.plus(...).plus(bonusDie).ac(...).onCrit(...)) for a correct crit probability with\n        // bonus to-hit dice in these cases. See CHANGELOG.\n        crit = new Dice();\n        for (let i = 0; i < count; i++) {\n          const max = finalResult.maxFace();\n          crit.setFace(max, finalResult.get(max));\n          finalResult = finalResult.deleteFace(max);\n        }\n      }\n\n      critNorm = crit.total();\n      crit = op.call(crit, parseBinaryArgument(arg, arr, n));\n\n      critNorm = crit && critNorm ? crit.total() / critNorm : 1;\n    }\n\n    // Handle save\n    let save: Dice | undefined;\n    let saveNorm = 1;\n    if (arr[0] === \"s\") {\n      assertToken(arr, \"s\");\n      assertToken(arr, \"a\");\n      assertToken(arr, \"v\");\n      assertToken(arr, \"e\");\n\n      save = new Dice();\n      const min = finalResult.minFace();\n      save.increment(min > 0 ? min : 1, finalResult.get(min));\n\n      saveNorm = save.total();\n      finalResult = finalResult.deleteFace(min);\n      save = op.call(save, parseBinaryArgument(arg, arr, n));\n      saveNorm = save && saveNorm ? save.total() / saveNorm : 1;\n    }\n\n    // Handle half damage on hit (potent cantrip)\n    let pc: Dice | undefined;\n    let pcNorm = 1;\n\n    if (arr.length >= 2 && arr[0] === \"p\" && arr[1] === \"c\") {\n      assertToken(arr, \"p\");\n      assertToken(arr, \"c\");\n\n      pc = new Dice();\n      const min = finalResult.minFace();\n      pc.increment(min > 0 ? min : 1, finalResult.get(min));\n\n      const missBefore = pc.total();\n      finalResult = finalResult.deleteFace(min);\n\n      pc = op.call(pc, parseBinaryArgument(arg, arr, n)).divideRoundDown(2); // parse the damage\n\n      const missAfter = pc ? pc.total() : 0;\n      pcNorm = missBefore ? missAfter / missBefore : 1;\n    }\n\n    // Handle miss\n    let miss: Dice | undefined;\n    let missNorm = 1;\n\n    if (arr[0] === \"m\") {\n      assertToken(arr, \"m\");\n      assertToken(arr, \"i\");\n      assertToken(arr, \"s\");\n      assertToken(arr, \"s\");\n\n      miss = new Dice();\n      const min = finalResult.minFace();\n      miss.increment(min > 0 ? min : 1, finalResult.get(min));\n\n      missNorm = miss.total();\n      finalResult = finalResult.deleteFace(min);\n\n      miss = op.call(miss, parseBinaryArgument(arg, arr, n));\n      missNorm = miss && missNorm ? miss.total() / missNorm : 1;\n    }\n\n    let norm = finalResult.total();\n\n    if (!acAlreadyApplied) {\n      finalResult = op.call(finalResult, arg);\n    }\n    norm = norm ? finalResult.total() / norm : 1;\n\n    // Combine dice with normalization\n    if (crit) {\n      const result = combineDiceWithNormalization(\n        crit,\n        critNorm,\n        \"crit\",\n        norm,\n        finalResult\n      );\n      norm = result.newNorm;\n      finalResult = result.updatedResult;\n    }\n\n    if (save) {\n      const result = combineDiceWithNormalization(\n        save,\n        saveNorm,\n        \"saveHalf\",\n        norm,\n        finalResult\n      );\n      norm = result.newNorm;\n      finalResult = result.updatedResult;\n    }\n\n    if (miss) {\n      const result = combineDiceWithNormalization(\n        miss,\n        missNorm,\n        \"missDamage\",\n        norm,\n        finalResult\n      );\n      norm = result.newNorm;\n      finalResult = result.updatedResult;\n    }\n\n    if (pc) {\n      const result = combineDiceWithNormalization(\n        pc,\n        pcNorm,\n        \"pc\",\n        norm,\n        finalResult\n      );\n      norm = result.newNorm;\n      finalResult = result.updatedResult;\n    }\n\n    op = parseOperation(arr);\n  }\n\n  return finalResult;\n}\n\nfunction parseArgument(s: string[], n: number): Dice | number {\n  let result = parseArgumentInternal(s, n);\n\n  while (true) {\n    const next = parseArgumentInternal(s, n);\n    if (next === undefined) break;\n\n    result = multiplyDiceByDice(result as Dice | number, next);\n  }\n\n  return result as Dice | number;\n}\n\nfunction multiplyDiceByDice(d1: Dice | number, d2: Dice | number): Dice {\n  if (typeof d1 === \"number\") d1 = Dice.scalar(d1);\n  if (typeof d2 === \"number\") d2 = Dice.scalar(d2);\n\n  const result = new Dice();\n  // Keyed by face value. A Map avoids the number→string→parseFloat round-trip of\n  // an object and preserves insertion order, which matches d1.keys() ascending\n  // order — so the combine order below is identical to the previous version.\n  const faces = new Map<number, Dice>();\n  let normalizationFactor = 1;\n\n  for (const key of d1.keys()) {\n    let face: Dice;\n\n    if (typeof key !== \"number\") {\n      continue; // Skip invalid scalar\n    }\n\n    if (d2.privateData.keep) {\n      // Repeat dice2 \"key\" times and apply keep. opDice enumerates the full\n      // faces^count outcome space, so guard against a combinatorial blow-up.\n      const faceCount = d2.keys().length;\n      if (Math.pow(faceCount, key) > MAX_KEEP_OUTCOMES) {\n        throw new DiceParseError(\n          `Keep enumeration of ${faceCount}^${key} outcomes exceeds the maximum of ${MAX_KEEP_OUTCOMES}`\n        );\n      }\n      const repeat: Dice[] = Array(key).fill(d2);\n      face = opDice(repeat, d2.privateData.keep);\n    } else {\n      face = multiplyDice(key, d2);\n    }\n\n    normalizationFactor *= face.total();\n    faces.set(key, face);\n  }\n\n  for (const [k, face] of faces) {\n    const count = d1.get(k);\n    result.combineInPlace(\n      face.normalize((count * normalizationFactor) / face.total())\n    );\n  }\n\n  result.privateData.except = {};\n  return result;\n}\n\nfunction multiplyDice(n: number, d: Dice): Dice {\n  if (n > MAX_DICE_COUNT) {\n    throw new DiceParseError(\n      `Dice count ${n} exceeds the maximum of ${MAX_DICE_COUNT}`\n    );\n  }\n  if (n === 0) return new Dice(0);\n  if (n === 1) return d;\n\n  const half = Math.floor(n / 2);\n  let result = multiplyDice(half, d);\n  result = result.add(result);\n\n  if (n % 2 === 1) {\n    result = result.add(d);\n  }\n\n  return result;\n}\n\nfunction opDice(diceList: Dice[], keepFn: (values: number[]) => number): Dice {\n  return opDiceInternal(diceList, new Dice(), 0, [], 1, keepFn);\n}\n\nfunction opDiceInternal(\n  diceList: Dice[],\n  result: Dice,\n  index: number,\n  values: number[],\n  weight: number,\n  combineFn: (values: number[]) => number\n): Dice {\n  if (index === diceList.length) {\n    return result.combine(Dice.scalar(combineFn(values)).normalize(weight));\n  }\n\n  const currentDice = diceList[index];\n  for (const face of currentDice.keys()) {\n    values.push(face as number);\n    result = opDiceInternal(\n      diceList,\n      result,\n      index + 1,\n      values,\n      weight * currentDice.get(face),\n      combineFn\n    );\n    values.pop();\n  }\n\n  return result;\n}\n\nfunction parseArgumentInternal(\n  s: string[],\n  n: number\n): Dice | number | undefined {\n  if (s.length === 0) return;\n\n  const c = s[0];\n\n  switch (c) {\n    case \"(\":\n      s.shift();\n      return assertToken(s, \")\", parseExpression(s, n));\n\n    case \"h\":\n    case \"d\":\n      return parseDice(s, n);\n\n    case \"k\":\n      assertToken(s, \"k\");\n      return parseKeep(s, n);\n\n    case \"n\":\n      return parseNumber(s, n);\n\n    default:\n      if (isDigit(c)) return parseNumber(s, n);\n      return;\n  }\n}\n\nfunction parseBinaryArgument(\n  arg: Dice | number,\n  arr: string[],\n  n: number\n): Dice {\n  if (arr.length >= 4 && arr[0] === \"h\" && peek(arr, \"half\")) {\n    assertToken(arr, \"half\");\n\n    const diceArg = typeof arg === \"number\" ? Dice.scalar(arg) : arg;\n    return diceArg.divideRoundDown(2);\n  }\n\n  const parsed = parseArgument(arr, n);\n  return typeof parsed === \"number\" ? Dice.scalar(parsed) : parsed;\n}\n\nfunction assertToken<T>(s: string[], expected: string, ret?: T): T | undefined {\n  for (const ch of expected) {\n    const found = s.shift();\n    if (found !== ch) {\n      throw new Error(`Expected character '${ch}', found '${found}'`);\n    }\n  }\n  return ret;\n}\n\nfunction parseDice(s: string[], n: number): Dice | undefined {\n  let rerollOne = false;\n\n  if (peek(s, \"hd\") && peekIsNumber(s, 2)) {\n    assertToken(s, \"h\");\n    assertToken(s, \"d\");\n    rerollOne = true;\n  } else if (peek(s, \"d\") && peekIsNumber(s, 1)) {\n    assertToken(s, \"d\");\n  } else {\n    return;\n  }\n\n  const sides = parseNumber(s, n);\n  if (sides > MAX_DIE_SIDES) {\n    throw new DiceParseError(\n      `Die size ${sides} exceeds the maximum of ${MAX_DIE_SIDES}`\n    );\n  }\n  let result = new Dice(sides);\n\n  if (rerollOne) {\n    // Reroll a rolled 1 exactly once, keeping the second roll (e.g. halfling\n    // luck). This is the same semantics as the `reroll 1` operator; the previous\n    // deleteFace(1).combine(result) computed a weighted union (P(1)=1/(2s−1)),\n    // not a reroll (correct P(1)=1/s²).\n    result = result.reroll(1);\n  }\n\n  result.privateData.checkDie = { sides, rerollOne };\n  return result;\n}\n\nfunction peek(arr: string[], expected: string): boolean {\n  if (expected.length > arr.length) return false;\n\n  for (let i = 0; i < expected.length; i++) {\n    if (arr[i] !== expected.charAt(i)) return false;\n  }\n\n  return true;\n}\n\nfunction peekIsNumber(arr: string[], index: number): boolean {\n  if (index >= arr.length) return false;\n  return isDigit(arr[index]) || arr[index] === \"n\";\n}\n\nfunction parseNumber(s: string[], n: number): number {\n  let ret = \"\";\n\n  while (s.length > 0 && (isDigit(s[0]) || s[0] === \"n\")) {\n    const ch = s.shift()!;\n    ret += ch === \"n\" ? n.toString() : ch;\n  }\n\n  if (ret.length === 0) {\n    throw new Error(`Expected number, found: '${s[0]}'`);\n  }\n\n  return parseInt(ret, 10);\n}\n\nfunction isDigit(c: string): boolean {\n  return c >= \"0\" && c <= \"9\";\n}\n\nfunction parseKeep(s: string[], n: number): Dice | undefined {\n  let keepLowest = false;\n\n  if (peek(s, \"l\")) {\n    assertToken(s, \"l\");\n    keepLowest = true;\n  } else if (peek(s, \"h\")) {\n    assertToken(s, \"h\");\n    keepLowest = false;\n  } else {\n    return;\n  }\n\n  const keepCount = parseNumber(s, n);\n  const result = parseArgumentInternal(s, n);\n\n  if (result instanceof Dice) {\n    result.privateData.keep = keepN(keepCount, keepLowest);\n    return result;\n  }\n\n  throw new Error(\"Expected Dice after keep modifier\");\n}\n\nfunction keepN(n: number, low: boolean): (values: number[]) => number {\n  return (values: number[]): number => {\n    const sorted = [...values].sort((a, b) => (low ? a - b : b - a));\n    return sorted.slice(0, n).reduce((sum, val) => sum + val, 0);\n  };\n}\n\nfunction parseOperation(s: string[]): DiceOperation | undefined {\n  switch (s[0]) {\n    case \")\":\n      return;\n\n    case \"a\":\n      assertToken(s, \"ac\");\n      return Dice.prototype.ac;\n\n    case \"d\":\n      assertToken(s, \"dc\");\n      return Dice.prototype.dc;\n\n    case \"!\":\n      assertToken(s, \"!\");\n      const adv = Dice.prototype.advantage as DiceOperation;\n      adv.unary = true;\n      return adv;\n\n    case \">\":\n      assertToken(s, \">\");\n      return Dice.prototype.max;\n\n    case \"<\":\n      assertToken(s, \"<\");\n      return Dice.prototype.min;\n\n    case \"+\":\n      assertToken(s, \"+\");\n      return Dice.prototype.addNonZero;\n\n    case \"~\":\n      assertToken(s, \"~\");\n      assertToken(s, \"+\");\n      return Dice.prototype.add;\n\n    case \"-\":\n      assertToken(s, \"-\");\n      return Dice.prototype.subtract;\n\n    case \"&\":\n      assertToken(s, \"&\");\n      return Dice.prototype.combine;\n\n    case \"r\":\n      assertToken(s, \"reroll\");\n      return Dice.prototype.reroll;\n\n    case \"*\":\n      assertToken(s, \"*\");\n\n      if (peek(s, \"*\")) {\n        assertToken(s, \"*\");\n        return Dice.prototype.multiply;\n      }\n\n      return Dice.prototype.conditionalApply;\n\n    case \"/\":\n      assertToken(s, \"/\");\n      if (s[0] === \"/\") {\n        assertToken(s, \"/\");\n        return Dice.prototype.divideRoundDown;\n      }\n      return Dice.prototype.divideRoundUp;\n\n    case \"=\":\n      assertToken(s, \"=\");\n      return Dice.prototype.eq;\n  }\n\n  return;\n}\n","import { EPS, PMF } from \"../\";\n\nexport function d20PmfFromCdf(\n  cdfPow: (k: number) => number,\n  eps: number = EPS\n): PMF {\n  const out = new Map<number, number>();\n  let prev = 0;\n  for (let k = 1; k <= 20; k++) {\n    const cur = cdfPow(k);\n    const pk = cur - prev;\n    if (pk > 0) {\n      out.set(k, pk);\n    }\n    prev = cur;\n  }\n\n  return PMF.fromMap(out, eps);\n}\n","import { EPS, PMF, pmfCache } from \"../\";\nimport { d20PmfFromCdf } from \"./prob\";\nimport type { RollType } from \"./types\";\n\nconst cacheKeyMap: Record<string, string> = {\n  \"flat-flat\": \"d20\",\n  \"flat-reroll\": \"hd20\",\n  \"advantage-flat\": \"d20 > d20\",\n  \"advantage-reroll\": \"hd20 > hd20\",\n  \"disadvantage-flat\": \"d20 < d20\",\n  \"disadvantage-reroll\": \"hd20 < hd20\",\n  \"elven accuracy-flat\": \"d20 > d20 > d20\",\n  \"elven accuracy-reroll\": \"hd20 > hd20 > hd20\",\n};\n\n/** Lift a single d20 PMF into advantage, disadvantage, or elven (triple-advantage). */\nexport function d20RollPMF(\n  rollType: RollType | undefined,\n  rerollOne: boolean = false\n): PMF {\n  rollType = rollType || \"flat\";\n  const cacheKeyLookup = `${rollType}-${rerollOne ? \"reroll\" : \"flat\"}`;\n  const cacheKey = cacheKeyMap[cacheKeyLookup];\n  if (!cacheKey) {\n    throw new Error(`Invalid roll type: ${rollType}`);\n  }\n\n  const cached = pmfCache.get(cacheKey);\n  if (cached) return cached;\n\n  const base = d20PMF(rerollOne);\n  if (!rollType || rollType === \"flat\") {\n    pmfCache.set(cacheKey, base);\n    return base;\n  }\n\n  const p: number[] = new Array(21).fill(0); // indices 1..20\n  for (const [r, rec] of base) {\n    const pr = typeof rec === \"number\" ? rec : rec.p;\n    if (r >= 1 && r <= 20) p[r] = pr;\n  }\n  const F: number[] = new Array(21).fill(0);\n  for (let k = 1; k <= 20; k++) F[k] = F[k - 1] + p[k];\n\n  const eps = 0;\n  let result = base;\n  if (rollType === \"advantage\") {\n    result = d20PmfFromCdf((k) => Math.pow(F[k], 2), eps);\n  } else if (rollType === \"elven accuracy\") {\n    result = d20PmfFromCdf((k) => Math.pow(F[k], 3), eps);\n  } else if (rollType === \"disadvantage\") {\n    result = d20PmfFromCdf((k) => 1 - Math.pow(1 - F[k], 2), eps);\n  }\n\n  pmfCache.set(cacheKey, result);\n  return result;\n}\n\nexport function d20PMF(rerollOne: boolean): PMF {\n  const cacheKey = `flat-${rerollOne ? \"reroll\" : \"flat\"}`;\n  const cached = pmfCache.get(cacheKey);\n  if (cached) return cached;\n\n  const m = new Map<number, number>();\n  const base = 1 / 20;\n  const rerollShare = base * base;\n  if (!rerollOne) {\n    for (let r = 1; r <= 20; r++) {\n      m.set(r, base);\n    }\n  } else {\n    for (let r = 1; r <= 20; r++) {\n      m.set(r, (r === 1 ? 0 : base) + rerollShare);\n    }\n  }\n  const result = PMF.fromMap(m, EPS);\n  pmfCache.set(cacheKey, result);\n  return result;\n}\n","import type { ACBuilder } from \"./ac\";\nimport type { CritConfig } from \"../common/types\";\nimport type { DCBuilder } from \"./dc\";\nimport { LRUCache } from \"../common/lru-cache\";\nimport { parse } from \"../parser/parser\";\nimport type { PMF } from \"../pmf/pmf\";\nimport type { DiceQuery } from \"../pmf/query\";\nimport { astFromRollConfigs, pmfFromRollBuilder, resolveRootD20 } from \"./ast\";\nimport { AttackBuilder } from \"./attack\";\nimport type { ExpressionNode, KeepNode, SumNode } from \"./nodes\";\nimport type { RollConfig, RollType } from \"./types\";\n\n/** Validates a `scaleDice`/`doubleDice` multiplier: must be a positive integer. Shared by\n * `RollBuilder.scaleDice` and every wrapper subclass's override (Half/Scale/MaxOf/Composite). */\nfunction validateScaleInt(scale: number): number {\n  const scaleInt = Math.floor(scale);\n  if (scaleInt !== scale) throw new Error(\"Scale must be an integer\");\n  if (scaleInt <= 0) throw new Error(\"Scale must be > 0\");\n  return scaleInt;\n}\n\n/**\n * Plain-roll PMF cache, the sibling of {@link attackPMFCache}. `toPMF()` re-runs the whole AST convolution\n * every call, and a DPR sweep rebuilds the SAME damage roll thousands of times — a Paladin's smite damage,\n * a Wizard's Fireball. Keyed by {@link RollBuilder.cacheKey} plus `eps`; a `null` key (half/scale/max/parsed/\n * pooled/composite, whose PMF is not captured by `subRollConfigs`) resolves uncached, because a conservative\n * miss is always safe and a wrong key would corrupt DPR.\n *\n * Subclasses that override `toPMF` (Half/Scale/MaxOf/Composite) never reach this — and all of them return a\n * `null` key anyway, so they are uncacheable by the same rule either way.\n */\nconst rollPMFCache = new LRUCache<string, PMF>(4000);\n\n/** Clears the plain-roll PMF cache (test/bench seam; mirrors {@link clearAttackCache}). */\nexport function clearRollCache(): void {\n  rollPMFCache.clear();\n}\n\nexport const defaultConfig: RollConfig = {\n  count: 1,\n  sides: 0,\n  modifier: 0,\n  reroll: 0,\n  explode: 0,\n  minimum: 0,\n  bestOf: 0,\n  keep: undefined,\n  rollType: \"flat\",\n};\n\nconst rollConfigsEqual = (a: RollConfig, b: RollConfig) => {\n  return (\n    a.count === b.count &&\n    a.sides === b.sides &&\n    a.modifier === b.modifier &&\n    a.reroll === b.reroll &&\n    a.explode === b.explode &&\n    a.minimum === b.minimum &&\n    a.bestOf === b.bestOf &&\n    a.keep === b.keep &&\n    a.rollType === b.rollType\n  );\n};\n\nconst configComplexityScore = (config: RollConfig) => {\n  return (\n    (config.reroll > 0 ? 1 : 0) +\n    (config.explode > 0 ? 1 : 0) +\n    (config.minimum > 0 ? 1 : 0) +\n    (config.bestOf > 0 ? 1 : 0) +\n    (config.keep !== undefined ? 1 : 0) +\n    (config.rollType !== \"flat\" ? 1 : 0)\n  );\n};\n\n// Fluent builder for dice to create PMFs with an AST\nexport class RollBuilder {\n  protected readonly subRollConfigs: readonly RollConfig[];\n\n  constructor(countOrConfigs: number | readonly RollConfig[] = 1) {\n    if (typeof countOrConfigs === \"number\") {\n      const count = countOrConfigs;\n      if (isNaN(count)) throw new Error(\"Invalid NaN value for count\");\n      this.subRollConfigs = [\n        { ...defaultConfig, count, isSubtraction: count < 0 },\n      ];\n    } else {\n      this.subRollConfigs = countOrConfigs.map((c) => ({ ...c }));\n    }\n  }\n\n  protected create(configs: readonly RollConfig[]): RollBuilder {\n    return new RollBuilder(configs);\n  }\n\n  protected get lastConfig() {\n    return this.subRollConfigs[this.subRollConfigs.length - 1];\n  }\n\n  hasHiddenState(): boolean {\n    return false;\n  }\n\n  getSubRollConfigs(): readonly RollConfig[] {\n    return this.subRollConfigs.map((c: RollConfig) => ({ ...c }));\n  }\n\n  /**\n   * A cheap, stable string that FULLY identifies this builder's PMF — used by {@link AttackBuilder.toPMF}\n   * to cache resolved attack PMFs across rebuilds without walking the AST via {@link toExpression}. A plain\n   * roll is fully determined by its {@link RollConfig} array (count/sides/modifier/reroll/explode/minimum/\n   * bestOf/keep/rollType/isSubtraction), so serializing that is sound. Subclasses whose PMF depends on\n   * hidden state NOT captured by `subRollConfigs` (half/scale/max/parsed/pooled/composite transforms) return\n   * `null` to opt OUT of caching — a conservative miss is always safe; a wrong key would corrupt DPR.\n   */\n  cacheKey(): string | null {\n    return JSON.stringify(this.subRollConfigs);\n  }\n\n  // for testing\n  static fromConfig(config: Partial<RollConfig>): RollBuilder {\n    return new RollBuilder([{ ...defaultConfig, ...config }]);\n  }\n\n  static fromConfigs(configs: Partial<RollConfig>[]): RollBuilder {\n    return new RollBuilder(\n      configs.map((config) => ({ ...defaultConfig, ...config }))\n    );\n  }\n\n  static fromArgs(...args: any[]): RollBuilder {\n    if (args.length === 1) {\n      const arg = args[0];\n      if (typeof arg === \"number\") {\n        if (isNaN(arg)) throw new Error(\"Invalid NaN value for argument\");\n        return new RollBuilder(0).plus(arg);\n      }\n      if (typeof arg === \"string\") {\n        return new ParsedRollBuilder(arg);\n      }\n      if (arg instanceof RollBuilder) {\n        return arg;\n      }\n    }\n\n    if (args.length === 2 || args.length === 3) {\n      const [count, sidesOrDie, modifier] = args;\n\n      if (typeof count !== \"number\") {\n        throw new Error(\"First argument must be a number for multi-arg call\");\n      }\n      if (isNaN(count)) throw new Error(\"Invalid NaN value for count argument\");\n\n      if (sidesOrDie instanceof RollBuilder) {\n        if (sidesOrDie.hasHiddenState()) {\n          throw new Error(\n            \"Cannot use a roll with hidden state (like a pooled roll) as a die type.\"\n          );\n        }\n        const subRollConfigs = sidesOrDie.getSubRollConfigs();\n        if (subRollConfigs.length === 0) {\n          const result = new RollBuilder(0);\n          return modifier !== undefined ? result.plus(modifier) : result;\n        }\n\n        const absCount = Math.abs(count);\n\n        const newConfigs = subRollConfigs.map((config) => ({\n          ...config,\n          count: config.count * absCount,\n          modifier: config.modifier * absCount,\n        }));\n\n        let resultBuilder = new RollBuilder(newConfigs);\n\n        if (count < 0) {\n          const negatedConfigs = resultBuilder\n            .getSubRollConfigs()\n            .map((c) => ({ ...c, isSubtraction: !c.isSubtraction }));\n          resultBuilder = new RollBuilder(negatedConfigs);\n        }\n\n        return modifier !== undefined\n          ? resultBuilder.plus(modifier)\n          : resultBuilder;\n      } else if (typeof sidesOrDie === \"number\" || sidesOrDie === undefined) {\n        if (typeof sidesOrDie === \"number\" && isNaN(sidesOrDie))\n          throw new Error(\"Invalid NaN value for sides argument\");\n        let builder = new RollBuilder(count);\n        if (sidesOrDie && sidesOrDie > 0) {\n          builder = builder.d(sidesOrDie);\n        }\n        return modifier !== undefined ? builder.plus(modifier) : builder;\n      }\n    }\n\n    throw new Error(`Invalid arguments passed: ${args.join(\", \")}`);\n  }\n\n  // --- Core Dice Methods ---\n  d(sides: number | undefined): RollBuilder {\n    if (sides !== undefined && isNaN(sides))\n      throw new Error(\"Invalid NaN value for sides\");\n    if (sides === undefined) return this;\n    if (this.lastConfig.sides && this.lastConfig.sides > 0) {\n      throw new Error(\"Cannot add a die after adding a die\");\n    }\n    if (sides === 0) return this;\n    const newConfigs = this.getSubRollConfigs();\n    newConfigs[newConfigs.length - 1].sides = sides;\n    return this.create(newConfigs);\n  }\n\n  plus(modOrRoll: number | RollBuilder | undefined): RollBuilder;\n  plus(count: number, die: RollBuilder): RollBuilder;\n  plus(\n    modOrRoll: number | RollBuilder | undefined,\n    die?: RollBuilder\n  ): RollBuilder {\n    if (typeof modOrRoll === \"number\" && isNaN(modOrRoll))\n      throw new Error(\"Invalid NaN value for modOrRoll\");\n    if (die instanceof RollBuilder && typeof modOrRoll === \"number\") {\n      if (die.hasHiddenState()) {\n        throw new Error(\n          \"Cannot use a roll with hidden state (like a pooled roll) as a die type.\"\n        );\n      }\n      const count = modOrRoll;\n      const subRollConfigs = die.getSubRollConfigs();\n      if (subRollConfigs.length === 0) return this;\n\n      const absCount = Math.abs(count);\n\n      const newConfigs = subRollConfigs.map((config) => ({\n        ...config,\n        count: config.count * absCount,\n        modifier: config.modifier * absCount,\n      }));\n\n      let rollToAdd = new RollBuilder(newConfigs);\n\n      if (count < 0) {\n        const negatedConfigs = rollToAdd\n          .getSubRollConfigs()\n          .map((c) => ({ ...c, isSubtraction: !c.isSubtraction }));\n        rollToAdd = new RollBuilder(negatedConfigs);\n      }\n      return this.add(rollToAdd);\n    }\n\n    if (die !== undefined) {\n      throw new Error(\"Invalid arguments to plus()\");\n    }\n\n    if (modOrRoll === undefined) return this;\n    if (typeof modOrRoll === \"number\") {\n      if (modOrRoll === 0) return this;\n      const newConfigs = this.getSubRollConfigs();\n      newConfigs[newConfigs.length - 1].modifier += modOrRoll;\n      return this.create(newConfigs);\n    }\n    return this.add(modOrRoll as RollBuilder);\n  }\n\n  minus(modOrRoll: number | RollBuilder | undefined): RollBuilder;\n  minus(count: number, die: RollBuilder): RollBuilder;\n  minus(\n    modOrRoll: number | RollBuilder | undefined,\n    die?: RollBuilder\n  ): RollBuilder {\n    const isNumber = typeof modOrRoll === \"number\";\n    const dieIsRoll = die instanceof RollBuilder;\n    if (dieIsRoll && isNumber) return this.plus(-modOrRoll, die);\n\n    if (die !== undefined) throw new Error(\"Invalid arguments to minus()\");\n    if (modOrRoll === undefined) return this;\n\n    return isNumber\n      ? this.plus(-modOrRoll)\n      : this.plus(-1, modOrRoll as RollBuilder);\n  }\n\n  /** Apply one-pass reroll threshold (k): reroll faces 1..k once, must keep. */\n  reroll(value: number): RollBuilder {\n    if (isNaN(value)) throw new Error(\"Invalid NaN value for reroll\");\n    if (value === this.lastConfig.reroll) return this;\n\n    const newConfigs = this.getSubRollConfigs();\n\n    newConfigs[newConfigs.length - 1].reroll = value;\n    return this.create(newConfigs);\n  }\n\n  /** Set finite explode count for max-face explosions (Infinity allowed). */\n  explode(count: number | undefined = Infinity): RollBuilder {\n    if (count !== undefined && isNaN(count))\n      throw new Error(\"Invalid NaN value for explode count\");\n    if (count === undefined) return this;\n    if (count === 0) return this;\n    if (count < 0) throw new Error(\"Explode count must be >= 0\");\n\n    const newConfigs = this.getSubRollConfigs();\n    newConfigs[newConfigs.length - 1].explode = count;\n    return this.create(newConfigs);\n  }\n\n  /** Apply per-die minimum value (floors each die roll at `val`, e.g. `minimum(3)` treats a 1 or\n   * 2 as a 3 -- the 2024 Great Weapon Fighting style). */\n  minimum(val: number | undefined): RollBuilder {\n    if (val !== undefined && isNaN(val))\n      throw new Error(\"Invalid NaN value for minimum\");\n    if (val === undefined) return this;\n    if (val === 0) return this;\n    if (val < 0) throw new Error(\"Minimum value must be >= 0\");\n\n    const newConfigs = this.getSubRollConfigs();\n    newConfigs[newConfigs.length - 1].minimum = val;\n    return this.create(newConfigs);\n  }\n\n  bestOf(count: number | undefined): RollBuilder {\n    if (count !== undefined && isNaN(count))\n      throw new Error(\"Invalid NaN value for bestOf count\");\n    if (count === undefined) return this;\n    if (count <= 0) throw new Error(\"Best of count must be > 0\");\n\n    const newConfigs = this.getSubRollConfigs();\n    newConfigs[newConfigs.length - 1].bestOf = count;\n    return this.create(newConfigs);\n  }\n\n  keepHighest(total: number, count: number): RollBuilder {\n    if (isNaN(total) || isNaN(count))\n      throw new Error(\"Invalid NaN value for keepHighest\");\n    const newConfigs = this.getSubRollConfigs();\n    newConfigs[newConfigs.length - 1].keep = { total, count, mode: \"highest\" };\n    return this.create(newConfigs);\n  }\n\n  keepLowest(total: number, count: number): RollBuilder {\n    if (isNaN(total) || isNaN(count))\n      throw new Error(\"Invalid NaN value for keepLowest\");\n    const newConfigs = this.getSubRollConfigs();\n    newConfigs[newConfigs.length - 1].keep = { total, count, mode: \"lowest\" };\n    return this.create(newConfigs);\n  }\n\n  keepHighestAll(total: number, count: number): PooledRollBuilder {\n    if (isNaN(total) || isNaN(count))\n      throw new Error(\"Invalid NaN value for keepHighestAll\");\n    const currentAST = this.toAST();\n    // Wrap in SumNode to represent trials, then KeepNode\n    const trialPool: SumNode = {\n      type: \"sum\",\n      count: total,\n      child: currentAST,\n    };\n    const keepNode: KeepNode = {\n      type: \"keep\",\n      mode: \"highest\",\n      count,\n      child: trialPool,\n    };\n    const currentExpr = this.toExpression();\n    const expression = `${total}kh${count}(${currentExpr})`;\n    return new PooledRollBuilder(keepNode, expression);\n  }\n\n  keepLowestAll(total: number, count: number): PooledRollBuilder {\n    if (isNaN(total) || isNaN(count))\n      throw new Error(\"Invalid NaN value for keepLowestAll\");\n    const currentAST = this.toAST();\n    const trialPool: SumNode = {\n      type: \"sum\",\n      count: total,\n      child: currentAST,\n    };\n    const keepNode: KeepNode = {\n      type: \"keep\",\n      mode: \"lowest\",\n      count,\n      child: trialPool,\n    };\n    const currentExpr = this.toExpression();\n    const expression = `${total}kl${count}(${currentExpr})`;\n    return new PooledRollBuilder(keepNode, expression);\n  }\n\n  withAdvantage(): RollBuilder {\n    const newConfigs = this.getSubRollConfigs();\n    newConfigs[newConfigs.length - 1].rollType = \"advantage\";\n    return this.create(newConfigs);\n  }\n\n  withDisadvantage(): RollBuilder {\n    const configs = this.getSubRollConfigs();\n    configs[configs.length - 1].rollType = \"disadvantage\";\n    return this.create(configs);\n  }\n\n  add(anotherRoll: RollBuilder | undefined): RollBuilder {\n    if (anotherRoll === undefined) return this;\n    if (anotherRoll.hasHiddenState()) {\n      throw new Error(\n        \"Cannot add a roll with hidden state (like a pooled roll) to a standard roll. Try adding the standard roll to the pooled roll instead: pool.plus(roll).\"\n      );\n    }\n    const configs = [...this.subRollConfigs, ...anotherRoll.subRollConfigs];\n    return this.create(configs);\n  }\n\n  withBonus(anotherRoll: RollBuilder): RollBuilder {\n    const configs = [...this.subRollConfigs, ...anotherRoll.subRollConfigs];\n    return this.create(configs);\n  }\n\n  addRoll(count: number = 1): RollBuilder {\n    if (isNaN(count)) throw new Error(\"Invalid NaN value for count\");\n    const configs = [\n      ...this.subRollConfigs,\n      {\n        ...defaultConfig,\n        count,\n        isSubtraction: count < 0,\n      },\n    ];\n    return this.create(configs);\n  }\n\n  scaleDice(scale: number): RollBuilder {\n    const scaleInt = validateScaleInt(scale);\n\n    const newConfigs = this.getSubRollConfigs().map((config) => {\n      if (!config.sides || config.sides <= 0) return config;\n      return { ...config, count: config.count * scaleInt };\n    });\n    return this.create(newConfigs);\n  }\n\n  doubleDice(): RollBuilder {\n    return this.scaleDice(2);\n  }\n\n  alwaysHits() {\n    return new AlwaysHitBuilder(this);\n  }\n\n  alwaysCrits() {\n    return new AlwaysCritBuilder(this);\n  }\n\n  copy(): RollBuilder {\n    return this.create(this.getSubRollConfigs());\n  }\n\n  // --- Dice Shortcut Methods ---\n  d4 = () => this.d(4);\n  d6 = () => this.d(6);\n  d8 = () => this.d(8);\n  d10 = () => this.d(10);\n  d12 = () => this.d(12);\n  d20 = () => this.d(20);\n  d100 = () => this.d(100);\n\n  withElvenAccuracy() {\n    const newConfigs = this.getSubRollConfigs();\n    newConfigs[newConfigs.length - 1].rollType = \"elven accuracy\";\n    return this.create(newConfigs);\n  }\n\n  toExpression(): string {\n    const originalDiceConfigs = this.subRollConfigs.filter(\n      (config) => config.sides && config.sides > 0\n    );\n\n    type Group = { config: RollConfig; totalCount: number };\n    const configGroups = new Map<string, Group>();\n\n    for (const config of originalDiceConfigs) {\n      const keyConfig: Partial<RollConfig> = { ...config };\n      delete keyConfig.count;\n      delete keyConfig.modifier;\n      const key = JSON.stringify(keyConfig);\n\n      const existingGroup = configGroups.get(key);\n      if (existingGroup) {\n        existingGroup.totalCount += config.count;\n      } else {\n        configGroups.set(key, { config, totalCount: config.count });\n      }\n    }\n\n    const rootConfig = this.getRootDieConfig();\n    const groupedConfigs = Array.from(configGroups.values());\n    let rootD20Group: Group | undefined;\n\n    if (rootConfig && rootConfig.sides === 20) {\n      const rootIndex = groupedConfigs.findIndex(\n        ({ config }) =>\n          rollConfigsEqual(config, rootConfig) &&\n          JSON.stringify(config.keep) === JSON.stringify(rootConfig.keep)\n      );\n\n      if (rootIndex !== -1) {\n        rootD20Group = groupedConfigs.splice(rootIndex, 1)[0];\n      }\n    }\n\n    const sortedDiceConfigs = groupedConfigs\n      .map(({ config, totalCount }) => ({\n        ...config,\n        count: totalCount,\n      }))\n      .sort((a, b) => {\n        const aHasPriority = a.reroll > 0 || a.minimum > 0;\n        const bHasPriority = b.reroll > 0 || b.minimum > 0;\n        if (aHasPriority !== bHasPriority) return aHasPriority ? -1 : 1;\n        if (b.sides !== a.sides) return b.sides - a.sides;\n        return configComplexityScore(b) - configComplexityScore(a);\n      });\n\n    const diceConfigs = rootD20Group\n      ? [\n          { ...rootD20Group.config, count: rootD20Group.totalCount },\n          ...sortedDiceConfigs,\n        ]\n      : sortedDiceConfigs;\n\n    const totalModifier = this.subRollConfigs.reduce(\n      (sum, config) => sum + config.modifier,\n      0\n    );\n    if (diceConfigs.length === 0) return totalModifier.toString();\n\n    const rootDieConfig = this.getRootDieConfig();\n    const newRootConfig = rootDieConfig\n      ? diceConfigs.find((c) => rollConfigsEqual(c, rootDieConfig))\n      : undefined;\n\n    // Generate dice expressions without individual modifiers\n    const diceExpressions = diceConfigs.map((config) =>\n      this.configToSingleExpressionWithoutModifier(\n        config,\n        config === newRootConfig\n      )\n    );\n\n    // Join dice expressions with appropriate operators based on their count\n    let result = \"\";\n    for (let i = 0; i < diceExpressions.length; i++) {\n      const config = diceConfigs[i];\n      const expression = diceExpressions[i];\n\n      if (i === 0) {\n        result = (config.isSubtraction ? \"-\" : \"\") + expression;\n\n        // Add constants right after the root d20 die (if it's a d20)\n        if (config.sides === 20 && totalModifier !== 0) {\n          if (totalModifier > 0) result += ` + ${totalModifier}`;\n          else result += ` - ${Math.abs(totalModifier)}`;\n        }\n      } else {\n        // Use minus sign for negative subtraction, plus sign otherwise\n        const operator = config.isSubtraction ? \" - \" : \" + \";\n        result += operator + expression;\n      }\n    }\n\n    // If constants weren't added after d20, add them at the end\n    if (diceConfigs.length === 0 || diceConfigs[0].sides !== 20) {\n      if (totalModifier > 0) result += ` + ${totalModifier}`;\n      else if (totalModifier < 0) result += ` - ${Math.abs(totalModifier)}`;\n    }\n\n    return result.replace(/\\+ -/g, \"-\");\n  }\n\n  // Main AST entry point. Cached by the cheap config key across identical rebuilds; see `rollPMFCache`.\n  toPMF(eps: number = 0): PMF {\n    const key = this.cacheKey();\n    if (key === null) return pmfFromRollBuilder(this, eps);\n    const fullKey = `${key}*e${eps}`;\n    const cached = rollPMFCache.get(fullKey);\n    if (cached) return cached;\n    const pmf = pmfFromRollBuilder(this, eps);\n    rollPMFCache.set(fullKey, pmf);\n    return pmf;\n  }\n\n  get pmf() {\n    return this.toPMF();\n  }\n\n  toQuery(eps: number = 0): DiceQuery {\n    return this.toPMF(eps).query();\n  }\n\n  toAST(): ExpressionNode {\n    const configs = this.getSubRollConfigs();\n    return (\n      astFromRollConfigs(configs) ||\n      ({ type: \"constant\", value: 0 } as ExpressionNode)\n    );\n  }\n\n  private configToSingleExpressionWithoutModifier(\n    config: RollConfig,\n    isRootDie: boolean\n  ): string {\n    if (!config.sides || config.sides <= 0) return \"\";\n\n    // The string grammar has no explode token at all (see parser.ts/dice.ts) -- there is no\n    // representable syntax that round-trips an exploding die's distribution. Silently rendering\n    // a plain (non-exploding) die here would re-parse to a materially different, WRONG\n    // distribution with no indication anything was lost. Fail loudly instead.\n    if (config.explode && Number.isFinite(config.explode) && config.explode > 0) {\n      throw new Error(\n        `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().`\n      );\n    }\n\n    let baseDie = `d${config.sides}`;\n\n    // A reroll(k) config means \"reroll faces 1..k once, must keep\" (see resolveSingleDie) — a\n    // THRESHOLD, not a literal face value. The parser's `reroll <n>` for a bare number n rerolls\n    // ONLY face value n (matches k=1, where the threshold and the literal face coincide); for\n    // k>=2 the threshold must be expressed as `reroll d{k}`, using a k-sided die's face SET\n    // {1..k} as the reroll operator's argument — chaining `reroll 1 reroll 2 ... reroll k` as\n    // separate clauses re-parses as k SEQUENTIAL reroll passes, a different (and wrong)\n    // distribution. `rerollClause` is shared by every placement below (with/without minimum,\n    // with/without explode) since the clause's own content never depends on where it sits.\n    const rerollClause = config.reroll > 0 ? (config.reroll === 1 ? \" reroll 1\" : ` reroll d${config.reroll}`) : \"\";\n\n    if (config.reroll > 0) {\n      if (config.minimum > 0 && config.explode > 0) {\n        // Complex single roll case: minimum + explode + reroll\n        // Apply reroll after minimum is applied\n      } else {\n        baseDie += rerollClause;\n      }\n    }\n\n    if (config.minimum > 0) {\n      if (config.reroll > 0 && !config.explode) {\n        baseDie = `${config.minimum}>(${baseDie})`;\n      } else {\n        baseDie = `${config.minimum}>${baseDie}`;\n      }\n      if (config.reroll > 0 && config.explode > 0) {\n        baseDie += rerollClause;\n      }\n    }\n\n    // Check for hd20 shorthand AFTER adding explode\n    if (baseDie === \"d20 reroll 1\" && config.minimum <= 1) baseDie = \"hd20\";\n\n    let mainExpression = \"\";\n    switch (config.rollType) {\n      case \"advantage\":\n        mainExpression = `${baseDie} > ${baseDie}`;\n        break;\n      case \"disadvantage\":\n        mainExpression = `${baseDie} < ${baseDie}`;\n        break;\n      case \"elven accuracy\":\n        mainExpression = `${baseDie} > ${baseDie} > ${baseDie}`;\n        break;\n      case \"flat\":\n        if (config.keep) {\n          const mode = config.keep.mode === \"highest\" ? \"kh\" : \"kl\";\n\n          // The inner expression must match astFromRollConfigs' own per-trial shape (see\n          // resolve()'s \"keep\" case, which reads it back out as `node.child.child`), not just\n          // echo `config.count`. astFromRollConfigs collapses to \"N individual dice, keep top K\"\n          // (a bare per-trial die) exactly when the die count equals the trial count (`baseCount\n          // === trials`) -- UNLESS it's the kh1 case (count 1, highest), which always keeps its\n          // per-trial die multiplied by baseCount even when baseCount happens to equal trials\n          // (`3kh1` on 3d6-per-trial means \"max of three 3d6 sums\", not \"max of 3 individual\n          // d6\"). Getting this wrong previously serialized `roll(4,d6).keepHighest(4,3)` as\n          // `4kh3(4d6)` (\"keep 3 of four 4d6 sums\") instead of the correct `4kh3(1d6)` (\"keep 3\n          // of four individual d6 rolls\") -- a ~3.7x overstatement on re-parse.\n          const baseCount = Math.max(1, Math.floor(Math.abs(config.count || 1)));\n          const trials = Math.max(1, Math.floor(config.keep.total));\n          const isMaxOfShape = config.keep.count === 1 && config.keep.mode === \"highest\";\n          const innerCount = trials === baseCount && !isMaxOfShape ? 1 : baseCount;\n\n          const baseDieExpression =\n            this.configToSingleExpressionWithoutModifier(\n              {\n                ...config,\n                count: innerCount,\n                modifier: 0,\n                rollType: \"flat\",\n                keep: undefined,\n              },\n              false\n            );\n          mainExpression = `${config.keep.total}${mode}${config.keep.count}(${baseDieExpression})`;\n        } else {\n          const isComplex = baseDie.length > `d${config.sides}`.length;\n          const isHalflingShorthand = baseDie === \"hd20\";\n          const isD20Shorthand = baseDie === \"d20\" && isRootDie;\n          const hasMinimum = config.minimum > 0;\n          const hasReroll = config.reroll > 0;\n          // For negative subtraction, use absolute value for display\n          // For negative counts from factory function, treat as 1 (legacy behavior)\n          const effectiveCount = config.isSubtraction\n            ? Math.abs(config.count)\n            : config.count < 0\n            ? 1\n            : Math.abs(config.count);\n\n          if (effectiveCount > 1) {\n            const shouldAddParentheses = isComplex;\n            mainExpression = shouldAddParentheses\n              ? `${effectiveCount}(${baseDie})`\n              : `${effectiveCount}${baseDie}`;\n          } else if (effectiveCount === 1) {\n            const needsParens = hasReroll && hasMinimum;\n            if (config.isSubtraction) {\n              mainExpression = needsParens ? `1(${baseDie})` : `1${baseDie}`;\n            } else if (\n              isComplex ||\n              isHalflingShorthand ||\n              isD20Shorthand ||\n              config.count < 0\n            ) {\n              mainExpression = needsParens ? `1(${baseDie})` : baseDie;\n            } else {\n              mainExpression = needsParens ? `1(${baseDie})` : `1${baseDie}`;\n            }\n          } else {\n            mainExpression = baseDie;\n          }\n        }\n        if (config.bestOf && config.count && config.bestOf < config.count) {\n          const pool = Math.max(1, Math.floor(Math.abs(config.count)));\n          const baseDieExpression = this.configToSingleExpressionWithoutModifier(\n            {\n              ...config,\n              count: 1,\n              modifier: 0,\n              bestOf: 0,\n              keep: undefined,\n              rollType: \"flat\",\n            },\n            false\n          );\n          mainExpression = `${pool}kh${Math.floor(config.bestOf)}(${baseDieExpression})`;\n        }\n        break;\n    }\n\n    return mainExpression;\n  }\n\n  getRootDieConfig(): RollConfig | undefined {\n    const configs = this.subRollConfigs;\n    return configs.find((config) => config.sides > 0) || configs[0];\n  }\n\n  getAllDieConfigs(): readonly RollConfig[] {\n    return this.getSubRollConfigs();\n  }\n\n  getBonusDiceConfigs(): RollConfig[] {\n    const allConfigs = this.subRollConfigs;\n    const rootConfig =\n      allConfigs.find((config) => config.sides > 0) || allConfigs[0];\n    if (!rootConfig) return [];\n    return allConfigs\n      .filter((config) => config.sides > 0)\n      .filter((config) => config !== rootConfig);\n  }\n\n  getBonusDicePMFs(check: RollBuilder, eps: number = 0): PMF[] {\n    return check\n      .getBonusDiceConfigs()\n      .map((config) =>\n        pmfFromRollBuilder(RollBuilder.fromConfigs([config]), eps)\n      );\n  }\n\n  get modifier(): number {\n    return this.subRollConfigs.reduce(\n      (sum, config) => sum + config.modifier,\n      0\n    );\n  }\n\n  get rollType(): RollType {\n    const rootConfig = this.getRootDieConfig();\n    return rootConfig?.rollType || \"flat\";\n  }\n\n  get baseReroll(): number {\n    const rootConfig = this.getRootDieConfig();\n    return rootConfig?.reroll || 0;\n  }\n\n  half(): HalfRollBuilder {\n    return new HalfRollBuilder(this);\n  }\n\n  /**\n   * Scale this roll's result by `numerator / denominator`, rounding each outcome.\n   * A general, composable form of {@link half} — used to model damage-type resistance\n   * (`scaleResult(1, 2)` → `(expr) // 2`) and vulnerability (`scaleResult(2)` → `2 * (expr)`).\n   * Compose several of these (and plain rolls) into one payload with {@link sumRolls}.\n   */\n  scaleResult(\n    numerator: number,\n    denominator: number = 1,\n    rounding: \"floor\" | \"round\" | \"ceil\" = \"floor\"\n  ): ScaleRollBuilder {\n    return new ScaleRollBuilder(this, numerator, denominator, rounding);\n  }\n\n  // Create a \"max of N rolls\" version of this roll for crit damage with keep operations\n  maxOf(count: number): MaxOfRollBuilder {\n    return new MaxOfRollBuilder(this, count);\n  }\n\n  // These methods are implemented via prototype augmentation in ac.ts and dc.ts\n  // They are declared here to provide proper TypeScript types\n  ac(_targetAC: number): ACBuilder {\n    throw new Error(\"ac() should be implemented via prototype augmentation\");\n  }\n\n  dc(_saveDC: number): DCBuilder {\n    throw new Error(\"dc() should be implemented via prototype augmentation\");\n  }\n}\n\nexport class HalfRollBuilder extends RollBuilder {\n  constructor(private readonly innerRoll: RollBuilder) {\n    super(0); // dummy, we override methods\n  }\n\n  override hasHiddenState(): boolean {\n    return this.innerRoll.hasHiddenState();\n  }\n\n  override cacheKey(): string | null {\n    return null; // half-of transform not captured by subRollConfigs\n  }\n\n  // No need to override create if we don't expose RollBuilder methods that use it,\n  // but HalfRollBuilder extends RollBuilder so it does.\n  // However, HalfRollBuilder seems to just wrap another roll.\n  // If we call .plus() on HalfRollBuilder, it returns a HalfRollBuilder?\n  // No, RollBuilder.plus returns RollBuilder.\n  // The inheritance here is a bit tricky.\n  // Existing code for HalfRollBuilder doesn't seem to implement plus/etc.\n  // So .plus() on a HalfRollBuilder would return a RollBuilder (base class).\n  // Which is fine.\n  // The only issue is if we want it to return HalfRollBuilder, but it doesn't seem designed for that.\n\n  override get lastConfig(): RollConfig {\n    // `lastConfig` is protected on the base class; reach it on the wrapped\n    // instance via a typed view rather than `any`.\n    return (this.innerRoll as unknown as { lastConfig: RollConfig }).lastConfig;\n  }\n\n  getSubRollConfigs(): readonly RollConfig[] {\n    return this.innerRoll.getSubRollConfigs();\n  }\n\n  toExpression(): string {\n    const innerExpression = this.innerRoll.toExpression();\n    return `(${innerExpression}) // 2`;\n  }\n\n  toAST(): ExpressionNode {\n    return {\n      type: \"half\",\n      child: this.innerRoll.toAST(),\n    };\n  }\n\n  toPMF(eps: number = 0): PMF {\n    return pmfFromRollBuilder(this, eps);\n  }\n\n  // Scale the dice, keep the same // 2 (half) transform applied on top -- delegating to the\n  // base class's `create()`-based scaleDice would drop the halving entirely, e.g. a doubled-dice\n  // crit on a resisted hit payload silently losing the resistance.\n  override scaleDice(scale: number): RollBuilder {\n    return new HalfRollBuilder(this.innerRoll.scaleDice(scale));\n  }\n\n  copy(): HalfRollBuilder {\n    return new HalfRollBuilder(this.innerRoll.copy());\n  }\n}\n\n/**\n * A roll whose result is scaled by `numerator / denominator` and rounded — the composable\n * generalization of {@link HalfRollBuilder}. Renders as `N * (inner)`, `(inner) // D`, or\n * `(inner) * N // D`. Terminal (like `half`): use {@link sumRolls} to combine with other rolls.\n */\nexport class ScaleRollBuilder extends RollBuilder {\n  constructor(\n    private readonly innerRoll: RollBuilder,\n    private readonly numerator: number,\n    private readonly denominator: number = 1,\n    private readonly rounding: \"floor\" | \"round\" | \"ceil\" = \"floor\"\n  ) {\n    super(0); // dummy, we override methods\n  }\n\n  override hasHiddenState(): boolean {\n    return this.innerRoll.hasHiddenState();\n  }\n\n  override cacheKey(): string | null {\n    return null; // scale transform not captured by subRollConfigs\n  }\n\n  override get lastConfig(): RollConfig {\n    return (this.innerRoll as unknown as { lastConfig: RollConfig }).lastConfig;\n  }\n\n  getSubRollConfigs(): readonly RollConfig[] {\n    return this.innerRoll.getSubRollConfigs();\n  }\n\n  toExpression(): string {\n    const inner = this.innerRoll.toExpression();\n    const denominator = this.denominator === 0 ? 1 : this.denominator;\n    if (denominator === 1) return `${this.numerator} ** (${inner})`;\n    // The grammar has only floor (`//`) and ceil (`/`) division; there is no round-half token.\n    if (this.rounding === \"round\") {\n      throw new Error(\n        `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.`\n      );\n    }\n    const div = this.rounding === \"ceil\" ? \"/\" : \"//\";\n    // `*` in this grammar is `conditionalApply` (an attack-gate operator: \"if the left side is\n    // nonzero, take the right side\"), NOT multiplication -- `**` is. A scale of e.g. `2/1`\n    // (vulnerability) previously rendered as `2 * (inner)`, which re-parsed as \"if 2 (always\n    // nonzero) then take `inner`\", silently dropping the multiplier entirely on round-trip.\n    if (this.numerator === 1) return `(${inner}) ${div} ${denominator}`;\n    return `(${inner}) ** ${this.numerator} ${div} ${denominator}`;\n  }\n\n  toAST(): ExpressionNode {\n    return {\n      type: \"scale\",\n      numerator: this.numerator,\n      denominator: this.denominator,\n      rounding: this.rounding,\n      child: this.innerRoll.toAST(),\n    };\n  }\n\n  toPMF(eps: number = 0): PMF {\n    return pmfFromRollBuilder(this, eps);\n  }\n\n  // Scale the dice, keep the same numerator/denominator/rounding transform applied on top --\n  // delegating to the base class's `create()`-based scaleDice would drop the scale entirely,\n  // e.g. a doubled-dice crit on a vulnerable hit payload silently losing the vulnerability.\n  override scaleDice(scale: number): RollBuilder {\n    return new ScaleRollBuilder(\n      this.innerRoll.scaleDice(scale),\n      this.numerator,\n      this.denominator,\n      this.rounding\n    );\n  }\n\n  copy(): ScaleRollBuilder {\n    return new ScaleRollBuilder(\n      this.innerRoll.copy(),\n      this.numerator,\n      this.denominator,\n      this.rounding\n    );\n  }\n}\n\nexport class MaxOfRollBuilder extends RollBuilder {\n  constructor(\n    private readonly innerRoll: RollBuilder,\n    private readonly count: number,\n    private readonly diceCount?: number,\n    private readonly diceSides?: number\n  ) {\n    super(0); // dummy, we override methods\n  }\n\n  override hasHiddenState(): boolean {\n    return this.innerRoll.hasHiddenState();\n  }\n\n  override cacheKey(): string | null {\n    return null; // max-of transform not captured by subRollConfigs\n  }\n\n  override get lastConfig(): RollConfig {\n    // `lastConfig` is protected on the base class; reach it on the wrapped\n    // instance via a typed view rather than `any`.\n    return (this.innerRoll as unknown as { lastConfig: RollConfig }).lastConfig;\n  }\n\n  getSubRollConfigs(): readonly RollConfig[] {\n    return this.innerRoll.getSubRollConfigs();\n  }\n\n  toExpression(): string {\n    // Use the stored dice info to create the expression directly\n    if (this.diceCount && this.diceSides) {\n      return `max${this.count}(${this.diceCount}d${this.diceSides})`;\n    }\n\n    // If no stored dice info, fallback to simple max expression\n    return `max${this.count}(?d?)`;\n  }\n\n  toAST(): ExpressionNode {\n    // Use the stored dice info if available\n    if (this.diceCount && this.diceSides) {\n      const sumChild: ExpressionNode = {\n        type: \"sum\",\n        count: this.diceCount,\n        child: { type: \"die\", sides: this.diceSides },\n      };\n      return {\n        type: \"maxOf\",\n        count: this.count,\n        child: sumChild,\n      };\n    }\n\n    // Fallback: try to get from innerRoll\n    try {\n      const configs = this.innerRoll.getSubRollConfigs();\n      if (configs.length === 1 && configs[0].sides) {\n        const config = configs[0];\n        const sumChild: ExpressionNode = {\n          type: \"sum\",\n          count: config.count,\n          child: { type: \"die\", sides: config.sides },\n        };\n        return {\n          type: \"maxOf\",\n          count: this.count,\n          child: sumChild,\n        };\n      }\n    } catch {\n      // Last resort: try parsing the expression (though this shouldn't work with current RollBuilder)\n    }\n\n    // Fallback - this shouldn't happen in normal usage\n    throw new Error(\n      `MaxOfRollBuilder.toAST(): Unsupported innerRoll configuration`\n    );\n  }\n\n  toPMF(eps: number = 0): PMF {\n    return pmfFromRollBuilder(this, eps);\n  }\n\n  // Scale the dice INSIDE each trial (e.g. maxOf(2, 1d12) -> maxOf(2, 2d12)), keeping the same\n  // trial count -- delegating to the base class's `create()`-based scaleDice would collapse\n  // straight to plain dice, losing the \"take the highest of N trials\" semantics entirely.\n  override scaleDice(scale: number): RollBuilder {\n    const scaleInt = validateScaleInt(scale);\n    return new MaxOfRollBuilder(\n      this.innerRoll.scaleDice(scaleInt),\n      this.count,\n      this.diceCount ? this.diceCount * scaleInt : undefined,\n      this.diceSides\n    );\n  }\n\n  copy(): MaxOfRollBuilder {\n    return new MaxOfRollBuilder(this.innerRoll.copy(), this.count);\n  }\n}\n\nexport class AlwaysHitBuilder extends RollBuilder {\n  readonly attackConfig: CritConfig;\n\n  constructor(baseRoll: RollBuilder, attackConfig?: CritConfig) {\n    if (baseRoll.hasHiddenState()) {\n      throw new Error(\n        \"Cannot create AlwaysHitBuilder from a roll with hidden state.\"\n      );\n    }\n    super(baseRoll.getSubRollConfigs());\n\n    if (attackConfig) {\n      this.attackConfig = { ...attackConfig };\n    } else {\n      this.attackConfig = { critThreshold: 20 };\n    }\n  }\n\n  protected create(configs: readonly RollConfig[]): RollBuilder {\n    return new RollBuilder(configs);\n  }\n\n  onHit(val: number): AttackBuilder;\n  onHit(val: string): AttackBuilder;\n  onHit(val: RollBuilder): AttackBuilder;\n  onHit(count: number, die: RollBuilder): AttackBuilder;\n  onHit(count: number, sides: number): AttackBuilder;\n  onHit(count: number, die: RollBuilder, modifier: number): AttackBuilder;\n  onHit(count: number, sides: number, modifier: number): AttackBuilder;\n  onHit(...args: any[]): AttackBuilder {\n    const damageRoll = RollBuilder.fromArgs(...args);\n    return new AttackBuilder(this, damageRoll);\n  }\n\n  get critThreshold(): number {\n    return this.attackConfig.critThreshold;\n  }\n\n  override cacheKey(): string | null {\n    const base = super.cacheKey();\n    return base === null ? null : `H|${this.attackConfig.critThreshold}|${base}`;\n  }\n\n  // TODO - move this to AC Builder… or if we create a DC builder that has critOn, throw an error?\n  critOn(critThreshold: number): AlwaysHitBuilder {\n    const newConfig = { critThreshold };\n    return new AlwaysHitBuilder(this, newConfig);\n  }\n\n  alwaysCrits(): AlwaysCritBuilder {\n    return new AlwaysCritBuilder(this, undefined, true);\n  }\n\n  // Legacy expressions\n  override toExpression(): string {\n    const configs = this.getSubRollConfigs();\n    return new RollBuilder(configs).toExpression();\n  }\n\n  override toPMF(): PMF {\n    return resolveRootD20(this);\n  }\n\n  override copy(): AlwaysHitBuilder {\n    const baseCopy = new RollBuilder(this.getSubRollConfigs());\n    const critThreshold = this.critThreshold;\n    const newConfig = { critThreshold };\n    return new AlwaysHitBuilder(baseCopy, newConfig);\n  }\n}\n\nexport class AlwaysCritBuilder extends RollBuilder {\n  readonly attackConfig: CritConfig & { ac?: number };\n  readonly fromAlwaysHit: boolean;\n\n  constructor(\n    baseRoll: RollBuilder,\n    attackConfig?: CritConfig & { ac?: number },\n    fromAlwaysHit: boolean = false\n  ) {\n    if (baseRoll.hasHiddenState()) {\n      throw new Error(\n        \"Cannot create AlwaysCritBuilder from a roll with hidden state.\"\n      );\n    }\n    super(baseRoll.getSubRollConfigs());\n\n    if (attackConfig) {\n      this.attackConfig = { ...attackConfig };\n    } else {\n      this.attackConfig = { critThreshold: 20 };\n    }\n    this.fromAlwaysHit = fromAlwaysHit || baseRoll instanceof AlwaysHitBuilder;\n  }\n\n  protected create(configs: readonly RollConfig[]): RollBuilder {\n    return new RollBuilder(configs);\n  }\n\n  onHit(val: number): AttackBuilder;\n  onHit(val: string): AttackBuilder;\n  onHit(val: RollBuilder): AttackBuilder;\n  onHit(count: number, die: RollBuilder): AttackBuilder;\n  onHit(count: number, sides: number): AttackBuilder;\n  onHit(count: number, die: RollBuilder, modifier: number): AttackBuilder;\n  onHit(count: number, sides: number, modifier: number): AttackBuilder;\n  onHit(...args: any[]): AttackBuilder {\n    const damageRoll = RollBuilder.fromArgs(...args);\n    return new AttackBuilder(this, damageRoll);\n  }\n\n  get critThreshold(): number {\n    return this.attackConfig.critThreshold;\n  }\n\n  override cacheKey(): string | null {\n    const base = super.cacheKey();\n    return base === null ? null : `C|${this.fromAlwaysHit ? 1 : 0}|${this.attackConfig.critThreshold}|${this.attackConfig.ac ?? \"\"}|${base}`;\n  }\n\n  critOn(critThreshold: number): AlwaysCritBuilder {\n    const newConfig = { critThreshold, ac: this.attackConfig.ac };\n    return new AlwaysCritBuilder(this, newConfig, this.fromAlwaysHit);\n  }\n\n  // Legacy expressions\n  override toExpression(): string {\n    const configs = this.getSubRollConfigs();\n    return new RollBuilder(configs).toExpression();\n  }\n\n  override toPMF(): PMF {\n    return resolveRootD20(this);\n  }\n\n  override copy(): AlwaysCritBuilder {\n    const baseCopy = new RollBuilder(this.getSubRollConfigs());\n    const critThreshold = this.critThreshold;\n    const newConfig = { critThreshold, ac: this.attackConfig.ac };\n    return new AlwaysCritBuilder(baseCopy, newConfig, this.fromAlwaysHit);\n  }\n}\n\nexport class ParsedRollBuilder extends RollBuilder {\n  private readonly cachedPMF: PMF;\n  private readonly originalExpression: string;\n\n  constructor(expression: string) {\n    super([]); // Empty configs since we're bypassing the normal builder flow\n    this.originalExpression = expression;\n    this.cachedPMF = parse(expression, 0);\n  }\n\n  override hasHiddenState(): boolean {\n    return true;\n  }\n\n  override cacheKey(): string | null {\n    return null; // parsed expression not captured by subRollConfigs\n  }\n\n  protected create(configs: readonly RollConfig[]): RollBuilder {\n    return new RollBuilder(configs);\n  }\n\n  override toPMF(_eps: number = 0): PMF {\n    // Return the pre-computed PMF, ignoring epsilon for now\n    // The parse() function was already called with eps=0\n    return this.cachedPMF;\n  }\n\n  override toExpression(): string {\n    return this.originalExpression;\n  }\n\n  override toAST(): ExpressionNode {\n    // Since we don't have the actual AST structure, return a constant node\n    // This is a limitation but shouldn't matter for terminal damage expressions\n    throw new Error(\n      \"ParsedRollBuilder does not support AST conversion. Use the builder API instead.\"\n    );\n  }\n\n  override copy(): ParsedRollBuilder {\n    return new ParsedRollBuilder(this.originalExpression);\n  }\n\n  override doubleDice(): ParsedRollBuilder {\n    throw new Error(\n      \"ParsedRollBuilder does not support doubleDice(). Use explicit onCrit() with the crit damage expression instead.\"\n    );\n  }\n}\n\nexport class PooledRollBuilder extends RollBuilder {\n  constructor(\n    private readonly baseAST: ExpressionNode,\n    private readonly baseExpression: string,\n    configs: readonly RollConfig[] = []\n  ) {\n    // Initialize with empty config if none provided\n    super(configs.length > 0 ? configs : 0);\n  }\n\n  protected create(configs: readonly RollConfig[]): PooledRollBuilder {\n    // This is the key fix: we preserve the baseAST and baseExpression\n    // and only update the configs\n    return new PooledRollBuilder(this.baseAST, this.baseExpression, configs);\n  }\n\n  override hasHiddenState(): boolean {\n    return true;\n  }\n\n  override cacheKey(): string | null {\n    return null; // pooled keep-highest not captured by subRollConfigs\n  }\n\n  override d(_sides: number | undefined): RollBuilder {\n    throw new Error(\"Cannot add dice to a pooled roll. The pool is finalized.\");\n  }\n\n  override reroll(_value: number): RollBuilder {\n    throw new Error(\"Cannot set reroll on a pooled roll.\");\n  }\n\n  override explode(_count: number | undefined = Infinity): RollBuilder {\n    throw new Error(\"Cannot set explode on a pooled roll.\");\n  }\n\n  override minimum(_val: number | undefined): RollBuilder {\n    throw new Error(\"Cannot set minimum on a pooled roll.\");\n  }\n\n  override bestOf(_count: number | undefined): RollBuilder {\n    throw new Error(\"Cannot set bestOf on a pooled roll.\");\n  }\n\n  override keepHighest(_total: number, _count: number): RollBuilder {\n    throw new Error(\n      \"Cannot use keepHighest on a pooled roll. Use keepHighestAll again if you want nested pooling.\"\n    );\n  }\n\n  override keepLowest(_total: number, _count: number): RollBuilder {\n    throw new Error(\n      \"Cannot use keepLowest on a pooled roll. Use keepLowestAll again if you want nested pooling.\"\n    );\n  }\n\n  override withAdvantage(): RollBuilder {\n    throw new Error(\"Cannot set advantage on a pooled roll.\");\n  }\n\n  override withDisadvantage(): RollBuilder {\n    throw new Error(\"Cannot set disadvantage on a pooled roll.\");\n  }\n\n  override withElvenAccuracy(): RollBuilder {\n    throw new Error(\"Cannot set elven accuracy on a pooled roll.\");\n  }\n\n  override toAST(): ExpressionNode {\n    const configsAST = super.toAST();\n\n    // Check if configsAST is effectively zero/empty\n    const isZero = configsAST.type === \"constant\" && configsAST.value === 0;\n\n    if (isZero) {\n      return this.baseAST;\n    }\n\n    const children: { node: ExpressionNode; sign: 1 | -1 }[] = [\n      { node: this.baseAST, sign: 1 },\n      { node: configsAST, sign: 1 },\n    ];\n\n    return { type: \"add\", children };\n  }\n\n  override toExpression(): string {\n    const configsExpression = super.toExpression();\n\n    // If no configs added, just return base expression\n    if (configsExpression === \"0\") {\n      return this.baseExpression;\n    }\n\n    // Clean up the join\n    if (configsExpression.startsWith(\"-\")) {\n      // If it's a negative number/expression, format as \" - value\"\n      // configsExpression is like \"-2\" or \"-1d6\"\n      return `${this.baseExpression} - ${configsExpression.substring(1)}`;\n    }\n    return `${this.baseExpression} + ${configsExpression}`;\n  }\n\n  override copy(): PooledRollBuilder {\n    return new PooledRollBuilder(\n      this.baseAST,\n      this.baseExpression,\n      this.getSubRollConfigs()\n    );\n  }\n\n  override scaleDice(scale: number): RollBuilder {\n    const scaleInt = Math.floor(scale);\n    if (scaleInt !== scale) throw new Error(\"Scale must be an integer\");\n    if (scaleInt <= 0) throw new Error(\"Scale must be > 0\");\n\n    // Scale the base pool (treat it as a die/unit)\n    // We wrap the base AST in a SumNode\n    const newBaseAST: SumNode = {\n      type: \"sum\",\n      count: scaleInt,\n      child: this.baseAST,\n    };\n    const newBaseExpr =\n      scaleInt === 1\n        ? this.baseExpression\n        : `${scaleInt}(${this.baseExpression})`;\n\n    // We preserve the existing modifiers (subRollConfigs) without scaling them,\n    // because scaleDice() generally only scales \"dice\", not flat modifiers.\n    // Since we forbid adding dice to PooledRollBuilder, subRollConfigs are only modifiers.\n    return new PooledRollBuilder(\n      newBaseAST,\n      newBaseExpr,\n      this.getSubRollConfigs()\n    );\n  }\n\n  times(count: number): PooledRollBuilder {\n    if (isNaN(count)) throw new Error(\"Invalid NaN value for times\");\n    if (Math.floor(count) !== count)\n      throw new Error(\"times() requires an integer\");\n    if (count < 0) throw new Error(\"times() requires a non-negative integer\");\n\n    // We wrap the current state (base + modifiers) into a new pool repeated N times\n    const currentAST = this.toAST();\n    const currentExpr = this.toExpression();\n\n    const sumNode: SumNode = {\n      type: \"sum\",\n      count,\n      child: currentAST,\n    };\n\n    const newExpr = count === 1 ? currentExpr : `${count}(${currentExpr})`;\n\n    return new PooledRollBuilder(sumNode, newExpr);\n  }\n}\n\n/**\n * An additive composite of independent rolls that preserves each part's AST — the piece\n * that lets a scaled/halved sub-roll (which the flat `.plus()` merge would otherwise drop)\n * sit beside plain rolls in one damage payload. Its PMF convolves the parts; its expression\n * joins them with ` + `. Built via {@link sumRolls}; terminal (used as an onHit/onCrit/\n * onSaveFailure payload), so it reports hidden state to reject accidental flat merges.\n */\nclass CompositeSumRollBuilder extends RollBuilder {\n  constructor(private readonly parts: readonly RollBuilder[]) {\n    super(0); // dummy, we override methods\n  }\n\n  override hasHiddenState(): boolean {\n    return true;\n  }\n\n  override cacheKey(): string | null {\n    return null; // composite sum not captured by subRollConfigs\n  }\n\n  override getSubRollConfigs(): readonly RollConfig[] {\n    return [];\n  }\n\n  override toAST(): ExpressionNode {\n    return {\n      type: \"add\",\n      children: this.parts.map((p) => ({\n        node: p.toAST(),\n        sign: 1 as const,\n      })),\n    };\n  }\n\n  override toExpression(): string {\n    const exprs = this.parts\n      .map((p) => p.toExpression())\n      .filter((e) => e && e !== \"0\");\n    if (exprs.length === 0) return \"0\";\n    let result = exprs[0];\n    for (let i = 1; i < exprs.length; i++) {\n      const e = exprs[i];\n      result += e.startsWith(\"-\") ? ` - ${e.substring(1)}` : ` + ${e}`;\n    }\n    return result.replace(/\\+ -/g, \"-\");\n  }\n\n  override toPMF(eps: number = 0): PMF {\n    return pmfFromRollBuilder(this, eps);\n  }\n\n  // Scaling a composite (mixed damage types, e.g. base + resisted) must scale each PART's own\n  // dice while preserving its own half/scale wrapper -- delegating to the base class's\n  // `create()`-based scaleDice would lose every part's transform, collapsing straight to plain\n  // dice. This is what auto-crit doubling (attack.ts's `hitEffect.copy().doubleDice()`) relies\n  // on for a mixed-resistance hit payload.\n  override scaleDice(scale: number): RollBuilder {\n    validateScaleInt(scale);\n    return new CompositeSumRollBuilder(\n      this.parts.map((p) => p.scaleDice(scale))\n    );\n  }\n\n  override copy(): CompositeSumRollBuilder {\n    return new CompositeSumRollBuilder(this.parts.map((p) => p.copy()));\n  }\n}\n\n/**\n * Combine several rolls into one additive payload whose PMF is their convolution and whose\n * expression is them joined with ` + `. Unlike `a.plus(b)`, this preserves parts that carry\n * hidden state (e.g. `roll.scaleResult(1, 2)` / `roll.half()`), so per-damage-type resistance\n * and vulnerability survive into both the distribution and the rendered expression.\n * Empty parts collapse to `0`; a single part is returned unwrapped.\n */\nexport function sumRolls(parts: readonly RollBuilder[]): RollBuilder {\n  const meaningful = parts.filter((p): p is RollBuilder => p !== undefined);\n  if (meaningful.length === 0) return new RollBuilder(0);\n  if (meaningful.length === 1) return meaningful[0];\n  return new CompositeSumRollBuilder(meaningful);\n}\n","import { LRUCache } from \"../common/lru-cache\";\nimport type { PMF } from \"../pmf/pmf\";\nimport { RollBuilder } from \"./roll\";\nimport type { RollFactory } from \"./types\";\n\nconst rollFn = (\n  count: number,\n  sidesOrDie?: number | RollBuilder,\n  modifier?: number\n): RollBuilder => {\n  if (sidesOrDie instanceof RollBuilder) {\n    if (sidesOrDie.hasHiddenState()) {\n      throw new Error(\n        \"Cannot use a roll with hidden state (like a pooled roll) as a die type.\"\n      );\n    }\n    // roll(2, d6, 5)\n    // Create a new config, using the base die's config but overriding the count\n    const subRollConfigs = sidesOrDie.getSubRollConfigs();\n    if (subRollConfigs.length === 0) return new RollBuilder(0).plus(modifier);\n\n    const absCount = Math.abs(count);\n\n    const newConfigs = subRollConfigs.map((config) => ({\n      ...config,\n      count: config.count * absCount,\n      modifier: config.modifier * absCount,\n    }));\n\n    let resultBuilder = new RollBuilder(newConfigs);\n\n    if (count < 0) {\n      const negatedConfigs = resultBuilder\n        .getSubRollConfigs()\n        .map((c) => ({ ...c, isSubtraction: !c.isSubtraction }));\n      resultBuilder = new RollBuilder(negatedConfigs);\n    }\n\n    return resultBuilder.plus(modifier);\n  } else {\n    // roll(2, 6, 5)\n    let builder = new RollBuilder(count);\n    if (sidesOrDie && sidesOrDie > 0) {\n      builder = builder.d(sidesOrDie);\n    }\n    return builder.plus(modifier);\n  }\n};\n\nrollFn.d = (sides: number | string): RollBuilder => {\n  if (typeof sides === \"string\") {\n    return RollBuilder.fromArgs(sides);\n  }\n  return new RollBuilder(1).d(sides);\n};\nrollFn.hd20 = (): RollBuilder => new RollBuilder(1).d20().reroll(1);\nrollFn.d4 = (): RollBuilder => new RollBuilder(1).d4();\nrollFn.d6 = (): RollBuilder => new RollBuilder(1).d6();\nrollFn.d8 = (): RollBuilder => new RollBuilder(1).d8();\nrollFn.d10 = (): RollBuilder => new RollBuilder(1).d10();\nrollFn.d12 = (): RollBuilder => new RollBuilder(1).d12();\nrollFn.d20 = (): RollBuilder => new RollBuilder(1).d20();\nrollFn.d100 = (): RollBuilder => new RollBuilder(1).d100();\nrollFn.flat = (n: number): RollBuilder => new RollBuilder(0).plus(n);\n\nexport function d(sides: number | string): RollBuilder {\n  if (typeof sides === \"string\") {\n    return RollBuilder.fromArgs(sides);\n  }\n  return new RollBuilder(1).d(sides);\n}\n\nexport const d4 = new RollBuilder(1).d4();\nexport const d6 = new RollBuilder(1).d6();\nexport const d8 = new RollBuilder(1).d8();\nexport const d10 = new RollBuilder(1).d10();\nexport const d12 = new RollBuilder(1).d12();\nexport const d20 = new RollBuilder(1).d20();\nexport const hd20 = new RollBuilder(1).d20().reroll(1);\nexport const d100 = new RollBuilder(1).d100();\nexport const flat = (n: number) => new RollBuilder(0).plus(n);\n\nexport const roll: RollFactory = rollFn as RollFactory;\n\nexport const builderPMFCache = new LRUCache<string, PMF>(1000);\n","import { LRUCache, PMF } from \"../\";\nimport { d20RollPMF } from \"./d20\";\nimport { builderPMFCache } from \"./factory\";\nimport type {\n  AddNode,\n  ConstantNode,\n  D20RollNode,\n  DieNode,\n  ExpressionNode,\n  KeepNode,\n  MaxOfNode,\n  SumNode,\n} from \"./nodes\";\nimport type { RollBuilder } from \"./roll\";\nimport type { RollConfig, RollType } from \"./types\";\n\n// For now, default to 0 epsilon. Later we can tighten to EPS.\nconst defaultEps = 0;\n\nconst singleDiePMFCache = new LRUCache<string, PMF>(1000);\n\nexport function dieNodeFromConfig(cfg: RollConfig): DieNode {\n  return {\n    type: \"die\",\n    sides: cfg.sides,\n    reroll: cfg.reroll > 0 ? cfg.reroll : undefined,\n    minimum: cfg.minimum > 0 ? cfg.minimum : undefined,\n    explode:\n      cfg.explode && Number.isFinite(cfg.explode) && cfg.explode > 0\n        ? cfg.explode\n        : undefined,\n  };\n}\n\nexport function astFromRollConfigs(\n  configs: readonly RollConfig[]\n): ExpressionNode | undefined {\n  // TODO add cache for this\n  if (!configs || configs.length === 0) return undefined;\n\n  const children: { node: ExpressionNode; sign: 1 | -1 }[] = [];\n  let constantSum = 0;\n\n  for (const cfg of configs) {\n    const sign: 1 | -1 = cfg.isSubtraction || cfg.count < 0 ? -1 : 1;\n    const count = Math.abs(cfg.count || 0);\n\n    constantSum += cfg.modifier || 0;\n\n    if ((cfg.sides || 0) <= 0) continue;\n\n    // `bestOf(k)` (\"roll N, keep the highest k\") is exactly `keep = {total: N, count: k, mode:\n    // \"highest\"}` over the same die -- fold it into an equivalent synthetic `keep` up front so it\n    // reuses the keep-DP branch below instead of being silently ignored (the die count alone,\n    // with no keep applied, previously determined the PMF -- e.g. `5d10.bestOf(3)` resolved as\n    // plain 5d10 despite `toExpression()` correctly rendering \"5d10kh3\").\n    const isSynthesizedBestOf =\n      !cfg.keep && cfg.bestOf > 0 && cfg.bestOf < count;\n    const effectiveKeep = isSynthesizedBestOf\n      ? { total: count, count: Math.floor(cfg.bestOf), mode: \"highest\" as const }\n      : cfg.keep;\n\n    const die: DieNode = dieNodeFromConfig(cfg);\n\n    let node: ExpressionNode = die;\n\n    let appliedRollType = false;\n    if (cfg.rollType && cfg.rollType !== \"flat\") {\n      if (cfg.sides === 20) {\n        node = {\n          type: \"d20Roll\",\n          rollType: cfg.rollType,\n          child: node,\n        } as D20RollNode;\n      } else {\n        const n = cfg.rollType === \"elven accuracy\" ? 3 : 2;\n        const mode = cfg.rollType === \"disadvantage\" ? \"lowest\" : \"highest\";\n        const base: SumNode = { type: \"sum\", count: n, child: node };\n        node = { type: \"keep\", mode, count: 1, child: base } as KeepNode;\n      }\n      appliedRollType = true;\n    }\n\n    if (cfg.rollType === \"flat\" && effectiveKeep && effectiveKeep.total > 0) {\n      const baseCount = Math.max(1, Math.floor(Math.abs(count || 1)));\n      const trials = Math.max(1, Math.floor(effectiveKeep.total));\n      const k = Math.max(0, Math.floor(effectiveKeep.count));\n\n      // For keep-highest of 1, always treat as trials-of-sums: max over trial sums\n      // A synthesized `bestOf` trial is a SINGLE die, never `baseCount` dice, so it must not\n      // take the maxOf-of-sums shape.\n      if (k === 1 && effectiveKeep.mode === \"highest\" && !isSynthesizedBestOf) {\n        const perTrial: SumNode = {\n          type: \"sum\",\n          count: baseCount,\n          child: node,\n        };\n        if (trials === 1) {\n          node = perTrial;\n        } else {\n          node = {\n            type: \"maxOf\",\n            count: trials,\n            child: perTrial,\n          } as MaxOfNode;\n        }\n      } else if (trials === baseCount) {\n        // Classic pool: keep K of N faces from N iid dice\n        const base: SumNode = { type: \"sum\", count: trials, child: node };\n        node = {\n          type: \"keep\",\n          mode: effectiveKeep.mode,\n          count: k,\n          child: base,\n        } as KeepNode;\n      } else {\n        // General trials-of-sums: trials of (baseCount dice sum), keep K trial sums\n        const perTrial: SumNode = {\n          type: \"sum\",\n          count: baseCount,\n          child: node,\n        };\n        if (trials === 1) {\n          node = perTrial;\n        } else {\n          const trialPool: SumNode = {\n            type: \"sum\",\n            count: trials,\n            child: perTrial,\n          };\n          node = {\n            type: \"keep\",\n            mode: effectiveKeep.mode,\n            count: k,\n            child: trialPool,\n          } as KeepNode;\n        }\n      }\n    } else {\n      const c = appliedRollType ? 1 : Math.max(1, count || 1);\n      node = { type: \"sum\", count: c, child: node } as SumNode;\n    }\n\n    children.push({ node, sign });\n  }\n\n  if (children.length === 0) {\n    return { type: \"constant\", value: constantSum } as ConstantNode;\n  }\n\n  const add: AddNode = { type: \"add\", children };\n  if (constantSum !== 0)\n    add.children.push({\n      node: { type: \"constant\", value: constantSum },\n      sign: 1,\n    });\n  return add;\n}\n\nexport function resolve(node: ExpressionNode, eps: number = defaultEps): PMF {\n  const signature = getASTSignature(node);\n  const cacheKey = `${signature}_${eps}`;\n\n  const cached = builderPMFCache.get(cacheKey);\n  if (cached) return cached;\n\n  const result = ((): PMF => {\n    switch (node.type) {\n      case \"constant\":\n        return PMF.delta(node.value, eps);\n\n      case \"die\": {\n        return resolveSingleDie(node, eps);\n      }\n\n      case \"sum\": {\n        const base = resolve(node.child, eps);\n        const n = Math.max(0, Math.floor(node.count));\n        if (n === 0) return PMF.delta(0, eps);\n        if (n === 1) return base;\n        return base.power(n, eps);\n      }\n\n      case \"add\": {\n        let shift = 0;\n        const parts: PMF[] = [];\n        for (const c of node.children) {\n          if (c.node.type === \"constant\") {\n            shift += c.sign * c.node.value;\n          } else {\n            const p = resolve(c.node, eps);\n            parts.push(c.sign === 1 ? p : p.mapDamage((v) => -v));\n          }\n        }\n        if (parts.length === 0) return PMF.delta(shift, eps);\n        let res = parts.length === 1 ? parts[0] : PMF.convolveMany(parts, eps);\n        if (shift !== 0) res = res.mapDamage((v) => v + shift);\n        return res;\n      }\n\n      case \"keep\": {\n        const totalTrials = getTotalCount(node);\n        const keepCount = Math.max(0, Math.min(node.count, totalTrials));\n        if (keepCount === 0 || totalTrials === 0) return PMF.delta(0, eps);\n\n        // Resolve the per-trial PMF (the child of the Sum inside Keep)\n        const perTrialNode = node.child.child; // Sum(child: perTrial)\n        const perTrialPMF = resolve(perTrialNode, eps);\n\n        return keepSumPMF(\n          perTrialPMF,\n          totalTrials,\n          keepCount,\n          node.mode === \"highest\",\n          eps\n        );\n      }\n\n      case \"d20Roll\": {\n        const childDie = findDie(node.child);\n        if (!childDie) return d20RollPMF(node.rollType, false);\n        return resolveD20Roll(childDie, node.rollType);\n      }\n\n      case \"half\": {\n        const childPMF = resolve(node.child, eps);\n        return childPMF.scaleDamage(0.5, \"floor\");\n      }\n\n      case \"maxOf\": {\n        const childPMF = resolve(node.child, eps);\n        const count = Math.max(1, Math.floor(node.count));\n        if (count === 1) return childPMF;\n\n        // Compute the maximum of count independent rolls of childPMF\n        return computeMaxOfPMF(childPMF, count, eps);\n      }\n\n      case \"scale\": {\n        const childPMF = resolve(node.child, eps);\n        const denom = node.denominator === 0 ? 1 : node.denominator;\n        return childPMF.scaleDamage(node.numerator / denom, node.rounding);\n      }\n    }\n  })();\n\n  builderPMFCache.set(cacheKey, result);\n  return result;\n}\n\nexport function pmfFromRollBuilder(\n  rb: RollBuilder,\n  eps: number = defaultEps\n): PMF {\n  const ast = rb.toAST();\n  return resolve(ast, eps);\n}\n\nconst d20RollLiftCache = new LRUCache<string, PMF>(500);\n\n/**\n * Resolve a d20-shaped die (honoring reroll/minimum/explode via {@link resolveSingleDie}) then\n * lift it into advantage/disadvantage/elven accuracy. Each of the 2 or 3 rolls compared is an\n * independent draw from that SAME resolved marginal — so a Halfling Lucky reroll or a\n * Trance-of-Order floor applies per-die, matching RAW (you reroll/floor each d20 you roll, not\n * just a single \"representative\" one). This generalizes {@link d20RollPMF}, which only ever\n * modeled the plain-uniform-plus-reroll-1 case; callers that resolve a die with no minimum/\n * explode/deeper reroll get bit-identical results to `d20RollPMF` (verified: the reroll-only\n * formula below reduces to the same closed form).\n *\n * Deliberately ignores any caller-facing output-precision `eps` (matching `d20RollPMF`'s own\n * contract): this builds the FOUNDATIONAL check-die distribution, where every face carries real\n * probability mass (e.g. 1/20 per face on a flat d20) — pruning it against an output-rounding\n * epsilon (some callers request eps as coarse as 0.1 purely to round the FINAL hit/miss/crit\n * mixture) would silently delete real faces instead of real noise. Always resolves at the\n * library's near-zero {@link defaultEps} internally; only the mixture built on top of this\n * result should be pruned against the caller's requested eps.\n */\nexport function resolveD20Roll(die: DieNode, rollType: RollType | undefined): PMF {\n  const base = resolveSingleDie(die, defaultEps);\n  const type = rollType || \"flat\";\n  if (type === \"flat\") return base;\n\n  const cacheKey = `${getASTSignature(die)}|${type}`;\n  const cached = d20RollLiftCache.get(cacheKey);\n  if (cached) return cached;\n\n  const support = [...base.support()].sort((a, b) => a - b);\n  const out = new Map<number, number>();\n  let cum = 0;\n  let prevLifted = 0;\n  for (const k of support) {\n    cum += base.pAt(k);\n    // advantage: best of 2 (F^2); elven accuracy: best of 3 (F^3); disadvantage: worst of 2\n    // (1-(1-F)^2). `type` can't be \"flat\" here — that returns above before the cache lookup.\n    const curLifted =\n      type === \"advantage\"\n        ? cum * cum\n        : type === \"elven accuracy\"\n          ? cum * cum * cum\n          : 1 - (1 - cum) * (1 - cum);\n    const pk = curLifted - prevLifted;\n    if (pk > 0) out.set(k, pk);\n    prevLifted = curLifted;\n  }\n  const result = PMF.fromMap(out, defaultEps);\n  d20RollLiftCache.set(cacheKey, result);\n  return result;\n}\n\n/**\n * Resolve a check builder's root die (the to-hit/save d20, or whatever die it wraps), honoring\n * that die's reroll/minimum/explode, then lift by its `rollType`. The single entry point every\n * attack/save check builder ({@link ACBuilder}, {@link AttackBuilder}, {@link AlwaysHitBuilder},\n * {@link AlwaysCritBuilder}, `DCBuilder`, save `resolveProbabilities`) should use instead of\n * reaching for `d20RollPMF(rollType, baseReroll > 0)` directly — that 2-argument summary silently\n * drops `minimum`/`explode` on the root config.\n */\nexport function resolveRootD20(check: RollBuilder): PMF {\n  const rootConfig = check.getRootDieConfig();\n  const rollType = check.rollType;\n  if (!rootConfig || !(rootConfig.sides > 0)) {\n    return d20RollPMF(rollType, check.baseReroll > 0);\n  }\n  return resolveD20Roll(dieNodeFromConfig(rootConfig), rollType);\n}\n\nexport function resolveSingleDie(die: DieNode, eps: number = defaultEps): PMF {\n  const signature = getASTSignature(die);\n  const cacheKey = `${signature}_${eps}`;\n\n  const cached = singleDiePMFCache.get(cacheKey);\n  if (cached) return cached;\n\n  const s = Math.max(0, Math.floor(die.sides));\n  if (s <= 0) return PMF.delta(0, eps);\n\n  let probs = new Map<number, number>();\n  for (let v = 1; v <= s; v++) probs.set(v, 1 / s);\n\n  // TODO - check if this is correct. Sequential reroll passes? Or at once?\n  const r = Math.max(0, Math.floor(die.reroll || 0));\n  if (r > 0) {\n    const k = Math.min(r, s);\n    const rerollMass = k / s; // total probability rerolled once\n    const uniformReroll = rerollMass / s; // mass added to each face from reroll\n    const next = new Map<number, number>();\n    for (let v = 1; v <= s; v++) {\n      const keep = v <= k ? 0 : 1 / s;\n      next.set(v, keep + uniformReroll);\n    }\n    probs = next;\n  }\n\n  let pmf = PMF.fromMap(new Map(probs), eps);\n\n  // Minimum per die\n  const minV = Math.max(0, Math.floor(die.minimum || 0));\n  if (minV > 0) pmf = pmf.mapDamage((v) => Math.max(v, minV));\n\n  // Exploding dice (finite, capped at `times` additional dice) on max face only.\n  const explode = die.explode;\n  if (explode && Number.isFinite(explode) && explode > 0) {\n    const times = Math.floor(explode);\n    const maxFace = s;\n\n    // Split pmf into a max-face slice and a non-max slice. `PMF.fromMap` always normalizes to\n    // mass 1 (divides by its own sum), so `nonMaxPMF` is already the correct conditional \"given\n    // the roll wasn't max, what was it\" distribution — exactly the shape `PMF.branch` requires\n    // for its failure argument. It must NOT be rescaled again afterward: `PMF.branch` weights\n    // each branch's bins by (p, 1-p) directly, so a `nonMaxPMF` still holding raw mass (1-pMax)\n    // would contribute (1-pMax)^2 instead of (1-pMax) to the result — the source of the\n    // previously measured 0.861 total mass on `d6.explode(1)`.\n    const nonMax = new Map<number, number>();\n    const pMax = pmf.pAt(maxFace);\n    for (const v of pmf.support()) {\n      if (v !== maxFace) nonMax.set(v, pmf.pAt(v));\n    }\n    const nonMaxPMF = PMF.fromMap(nonMax, eps);\n\n    // Capped geometric chain, built bottom-up. `chain` holds the distribution of \"one more die\n    // roll, with `remaining` further explosions still allowed if THAT roll is also max\" for\n    // `remaining` running from 0 (a final roll that can't chain further, however it lands) up to\n    // `times - 1`. Each step wraps the previous chain in one more branch: on a max roll (prob\n    // pMax) add another maxFace and recurse into the shorter chain; otherwise stop at a non-max\n    // value. This reduces to exactly `explode(1)`'s \"maxFace + one more untouched die\" for\n    // `times === 1`, and never lets more than `times` extra dice enter the total.\n    let chain = pmf; // remaining = 0: an unconstrained extra die, chains no further either way\n    for (let remaining = 1; remaining <= times - 1; remaining++) {\n      chain = PMF.branch(chain.mapDamage((v) => v + maxFace), nonMaxPMF, pMax);\n    }\n    const exploded = PMF.branch(chain.mapDamage((v) => v + maxFace), nonMaxPMF, pMax);\n    pmf = exploded;\n  }\n\n  singleDiePMFCache.set(cacheKey, pmf);\n  return pmf;\n}\n\n// Getters\n\nfunction findDie(node: ExpressionNode): DieNode | undefined {\n  switch (node.type) {\n    case \"die\":\n      return node;\n    case \"constant\":\n      return undefined;\n    case \"sum\":\n    case \"d20Roll\":\n    case \"half\":\n    case \"maxOf\":\n    case \"scale\":\n      return findDie(node.child);\n    case \"keep\":\n      return findDie(node.child.child);\n    case \"add\":\n      for (const c of node.children) {\n        const d = findDie(c.node);\n        if (d) return d;\n      }\n      return undefined;\n  }\n}\n\nfunction getTotalCount(node: KeepNode): number {\n  // The total dice count is encoded in the nearest SumNode under child\n  let cur = node.child;\n  while (cur.type === \"keep\") cur = cur.child;\n  return cur.type === \"sum\" ? Math.max(0, Math.floor(cur.count)) : 0;\n}\n\nfunction computeMaxOfPMF(\n  pmf: PMF,\n  count: number,\n  eps: number = defaultEps\n): PMF {\n  // Compute the maximum of 'count' independent rolls of the given PMF\n  if (count <= 1) return pmf;\n\n  const support = pmf.support();\n  const out = new Map<number, number>();\n\n  // For small counts, we can enumerate all outcomes\n  if (count <= 6 && support.length <= 20) {\n    function dfs(\n      rollsLeft: number,\n      currentMax: number,\n      probability: number\n    ): void {\n      if (rollsLeft === 0) {\n        out.set(currentMax, (out.get(currentMax) || 0) + probability);\n        return;\n      }\n\n      for (const value of support) {\n        const p = pmf.pAt(value);\n        if (p > 0) {\n          const newMax = Math.max(currentMax, value);\n          dfs(rollsLeft - 1, newMax, probability * p);\n        }\n      }\n    }\n\n    dfs(count, -Infinity, 1);\n  } else {\n    // For larger cases, use the CDF method. Walk the sorted support once while\n    // accumulating a running CDF, so each P(max = v) costs O(1) instead of a\n    // full-map cdfAt() scan (previously O(N) per value → O(N²) overall).\n    // Between two consecutive support points there is no probability mass, so\n    // the running CDF up to (but not including) v equals cdfAt(v - 1).\n    const sortedSupport = [...support].sort((a, b) => a - b);\n    let runningCdf = 0;\n    for (const value of sortedSupport) {\n      const prevCdf = runningCdf;\n      runningCdf += pmf.pAt(value);\n\n      // P(max = value) = P(all rolls <= value) - P(all rolls <= value-1)\n      const probMax = Math.pow(runningCdf, count) - Math.pow(prevCdf, count);\n      if (probMax > eps) {\n        out.set(value, probMax);\n      }\n    }\n  }\n\n  return PMF.fromMap(out, eps);\n}\n\nfunction keepSumPMF(\n  single: PMF,\n  total: number,\n  keep: number,\n  highest: boolean,\n  eps: number = defaultEps\n): PMF {\n  // Trivial/fast paths\n  if (keep >= total) return single.power(total, eps);\n  if (keep <= 0) return PMF.delta(0, eps);\n\n  const sortedSupport = [...single.support()].sort((a, b) => a - b);\n  const pmfSig = sortedSupport\n    .map((val) => `${val}:${single.pAt(val).toPrecision(6)}`)\n    .join(\",\");\n  const cacheKey = `keep|${pmfSig}|t:${total}|k:${keep}|h:${\n    highest ? 1 : 0\n  }|e:${eps}`;\n\n  const cached = builderPMFCache.get(cacheKey);\n  if (cached) return cached;\n\n  // kh1/kl1 fast paths using max-of machinery\n  if (keep === 1) {\n    if (highest) {\n      return computeMaxOfPMF(single, total, eps);\n    } else {\n      // min of n i.i.d. == -max of n of negated variable\n      const neg = single.mapDamage((v) => -v);\n      const minPMF = computeMaxOfPMF(neg, total, eps).mapDamage((v) => -v);\n      builderPMFCache.set(cacheKey, minPMF);\n      return minPMF;\n    }\n  }\n\n  // DP over descending values; state = (used, remainingTrials) → map(sum -> prob)\n  // Transition by drawing X occurrences at current value v from remainingTrials r: X ~ Binom(r, p)\n  // Select t = min(X, keep - used) into the sum (highest picks first), then continue with r - X.\n\n  type SumMap = Map<number, number>;\n  let state: Map<number, SumMap> = new Map();\n  // Pack the (used, remainingTrials) state into a single integer key instead of\n  // a \"used|r\" string. r ∈ [0, total], so a stride of (total + 1) is collision\n  // free, and decoding is plain integer math — no split()/parseInt() per\n  // transition in the hot loop. Behavior is identical (same states, same order).\n  const stride = total + 1;\n  const keyOf = (used: number, r: number) => used * stride + r;\n\n  state.set(keyOf(0, total), new Map([[0, 1]]));\n\n  const valuesDesc = highest\n    ? [...sortedSupport].sort((a, b) => b - a)\n    : [...sortedSupport].sort((a, b) => a - b);\n\n  const binomPMF = (r: number, p: number): number[] => {\n    if (r <= 0) return [1];\n    if (p <= eps) {\n      const arr = new Array(r + 1).fill(0);\n      arr[0] = 1;\n      return arr;\n    }\n    if (1 - p <= eps) {\n      const arr = new Array(r + 1).fill(0);\n      arr[r] = 1;\n      return arr;\n    }\n    const q = 1 - p;\n    const arr = new Array(r + 1).fill(0);\n\n    // stable recurrence from k=0\n    arr[0] = Math.pow(q, r);\n    const ratio = p / q;\n    for (let x = 1; x <= r; x++)\n      arr[x] = ((arr[x - 1] * (r - x + 1)) / x) * ratio;\n\n    // Normalize minor drift\n    let s = 0;\n    for (let x = 0; x <= r; x++) s += arr[x];\n    if (Math.abs(1 - s) > 1e-12) for (let x = 0; x <= r; x++) arr[x] /= s;\n\n    return arr;\n  };\n\n  const pruneMap = (m: SumMap, threshold: number): SumMap => {\n    if (threshold <= 0) return m;\n    const out = new Map<number, number>();\n    for (const [sum, pr] of m) if (pr >= threshold) out.set(sum, pr);\n    return out.size === m.size ? m : out;\n  };\n\n  const pruneState = (st: Map<number, SumMap>, threshold: number) => {\n    if (threshold <= 0) return st;\n    const out = new Map<number, SumMap>();\n    for (const [k, m] of st) {\n      const mm = pruneMap(m, threshold);\n      if (mm.size > 0) out.set(k, mm);\n    }\n    return out;\n  };\n\n  let processedMass = 0;\n  for (const v of valuesDesc) {\n    const p = single.pAt(v);\n    if (p <= 0) continue;\n    const q = Math.max(eps, 1 - processedMass);\n    const pCond = Math.min(1, p / q);\n    const next: Map<number, SumMap> = new Map();\n\n    for (const [k, m] of state) {\n      const used = Math.floor(k / stride);\n      const r = k - used * stride;\n      if (r === 0) {\n        // No trials left; carry state forward unchanged\n        const destKey = keyOf(used, 0);\n        const dest = next.get(destKey) ?? new Map<number, number>();\n        for (const [sum, pr] of m) dest.set(sum, (dest.get(sum) || 0) + pr);\n        next.set(destKey, dest);\n        continue;\n      }\n\n      const bin = binomPMF(r, pCond);\n      const remainingCapacity = keep - used;\n\n      for (let x = 0; x <= r; x++) {\n        const px = bin[x];\n        if (px <= eps) continue;\n        const t = Math.min(x, remainingCapacity);\n        const used2 = used + t;\n        const r2 = r - x;\n        const add = t * v;\n\n        const destKey = keyOf(used2, r2);\n        const dest = next.get(destKey) ?? new Map<number, number>();\n        for (const [sum, pr] of m) {\n          const s2 = sum + add;\n          const prob = pr * px;\n          const cur = dest.get(s2) || 0;\n          const nv = cur + prob;\n          if (nv >= eps) dest.set(s2, nv);\n        }\n        if (dest.size > 0) next.set(destKey, dest);\n      }\n    }\n\n    // Light pruning proportional to eps\n    state = pruneState(next, eps * 1e-6);\n    processedMass += p;\n  }\n\n  // Collect results where all trials assigned and exactly keep were used\n  const finalKey = keyOf(keep, 0);\n  const dist = state.get(finalKey) ?? new Map<number, number>();\n\n  if (dist.size === 0) {\n    // Fallback safety: return empty mass (should not happen)\n    return PMF.emptyMass();\n  }\n\n  const result = PMF.fromMap(dist, eps);\n  builderPMFCache.set(cacheKey, result);\n  return result;\n}\n\nexport function getASTSignature(node: ExpressionNode): string {\n  switch (node.type) {\n    case \"constant\":\n      return `c:${node.value}`;\n    case \"die\": {\n      // Use a fixed order for properties to ensure a stable signature.\n      const parts: string[] = [];\n      parts.push(`s:${node.sides}`);\n      if (node.reroll) parts.push(`r:${node.reroll}`);\n      if (node.minimum) parts.push(`m:${node.minimum}`);\n      if (node.explode) parts.push(`e:${node.explode}`);\n      return `d{${parts.join(\",\")}}`;\n    }\n    case \"sum\":\n      return `sum{c:${node.count},ch:${getASTSignature(node.child)}}`;\n    case \"d20Roll\":\n      return `d20{t:${node.rollType},ch:${getASTSignature(node.child)}}`;\n    case \"keep\":\n      return `keep{c:${node.count},m:${node.mode},ch:${getASTSignature(\n        node.child\n      )}}`;\n    case \"half\":\n      return `half{ch:${getASTSignature(node.child)}}`;\n    case \"maxOf\":\n      return `maxOf{c:${node.count},ch:${getASTSignature(node.child)}}`;\n    case \"scale\":\n      return `scale{n:${node.numerator},d:${node.denominator},r:${\n        node.rounding\n      },ch:${getASTSignature(node.child)}}`;\n    case \"add\": {\n      let constantValue = 0;\n      const otherChildrenSigs: string[] = [];\n      for (const c of node.children) {\n        if (c.node.type === \"constant\") {\n          constantValue += c.sign * c.node.value;\n        } else {\n          otherChildrenSigs.push(\n            `${c.sign === -1 ? \"-\" : \"+\"}${getASTSignature(c.node)}`\n          );\n        }\n      }\n\n      if (constantValue !== 0) {\n        otherChildrenSigs.push(\n          constantValue > 0 ? `+c:${constantValue}` : `-c:${-constantValue}`\n        );\n      }\n\n      // Sort to handle commutative nature of addition.\n      otherChildrenSigs.sort();\n\n      return `add[${otherChildrenSigs.join(\"\")}]`;\n    }\n  }\n}\n","import type { OutcomeType } from \"../common/types\";\nimport { EPS } from \"../common/types\";\nimport { LRUCache } from \"../common/lru-cache\";\nimport { Mixture } from \"../pmf/mixture\";\nimport { PMF } from \"../pmf/pmf\";\nimport type { DiceQuery } from \"../pmf/query\";\nimport type { ACBuilder } from \"./ac\";\nimport { pmfFromRollBuilder, resolveRootD20 } from \"./ast\";\nimport {\n  AlwaysCritBuilder,\n  AlwaysHitBuilder,\n  ParsedRollBuilder,\n  RollBuilder,\n} from \"./roll\";\nimport type { AttackResolution, CheckBuilder } from \"./types\";\n\ntype ActionEffect = RollBuilder;\n\n/**\n * Resolved-attack PMF cache. `resolve()`/`toPMF()` re-runs the damage convolution + hit/crit/miss mixture\n * every call; a DPR sweep resolves the SAME attack thousands of times (dprcalc measured ~99.9% repeats).\n * Keyed by {@link AttackBuilder.cacheKey} — a cheap serialization of the check + effect {@link RollConfig}s\n * (NOT the AST-walking `toExpression`), which fully determines the PMF. `null` key ⇒ an effect opted out\n * (parsed/pooled/half/scale/max/composite) ⇒ resolve uncached. Cached PMFs are immutable (every PMF op\n * returns a new instance), so sharing is safe.\n */\nconst attackPMFCache = new LRUCache<string, PMF>(4000);\n\n/** Clears the resolved-attack PMF cache (test/bench seam; mirrors {@link clearParserCache}). */\nexport function clearAttackCache(): void {\n  attackPMFCache.clear();\n}\n\nexport class AttackBuilder implements CheckBuilder {\n  constructor(\n    readonly check: ACBuilder | AlwaysHitBuilder | AlwaysCritBuilder,\n    private readonly hitEffect?: ActionEffect,\n    private readonly critEffect?: ActionEffect | null,\n    private readonly missEffect?: ActionEffect\n  ) {}\n\n  onCrit(val: number): AttackBuilder;\n  onCrit(val: string): AttackBuilder;\n  onCrit(val: RollBuilder): AttackBuilder;\n  onCrit(count: number, die: RollBuilder): AttackBuilder;\n  onCrit(count: number, sides: number): AttackBuilder;\n  onCrit(count: number, die: RollBuilder, modifier: number): AttackBuilder;\n  onCrit(count: number, sides: number, modifier: number): AttackBuilder;\n  onCrit(...args: any[]): AttackBuilder {\n    const damageRoll = RollBuilder.fromArgs(...args);\n    return new AttackBuilder(\n      this.check,\n      this.hitEffect,\n      damageRoll,\n      this.missEffect\n    );\n  }\n\n  onMiss(val: number): AttackBuilder;\n  onMiss(val: string): AttackBuilder;\n  onMiss(val: RollBuilder): AttackBuilder;\n  onMiss(count: number, die: RollBuilder): AttackBuilder;\n  onMiss(count: number, sides: number): AttackBuilder;\n  onMiss(count: number, die: RollBuilder, modifier: number): AttackBuilder;\n  onMiss(count: number, sides: number, modifier: number): AttackBuilder;\n  onMiss(...args: any[]): AttackBuilder {\n    const damageRoll = RollBuilder.fromArgs(...args);\n    return new AttackBuilder(\n      this.check,\n      this.hitEffect,\n      this.critEffect,\n      damageRoll\n    );\n  }\n\n  noCrit(): AttackBuilder {\n    return new AttackBuilder(this.check, this.hitEffect, null, this.missEffect);\n  }\n\n  // Legacy expressions\n  toExpression(): string {\n    const checkPart = this.check.toExpression();\n\n    let effectPart = \"\";\n\n    if (this.hitEffect) {\n      effectPart = `(${this.hitEffect.toExpression()})`;\n      if (this.critEffect !== null) {\n        let crit: RollBuilder;\n        if (this.critEffect) {\n          crit = this.critEffect;\n        } else {\n          // For ParsedRollBuilder, we can't double dice, so skip the crit expression\n          if (this.hitEffect instanceof ParsedRollBuilder) {\n            // Don't try to double ParsedRollBuilder - leave it out of expression\n            crit = RollBuilder.fromArgs(0);\n          } else {\n            crit =\n              this.hitEffect?.copy().doubleDice() ?? RollBuilder.fromArgs(0);\n          }\n        }\n\n        const critThreshold = this.check.critThreshold;\n        if (critThreshold < 1 || critThreshold > 20) {\n          throw new Error(\n            `Invalid crit threshold: ${critThreshold}. Must be between 1 and 20.`\n          );\n        }\n\n        // Only include crit expression if crit is not zero\n        const critExpression = crit.toExpression();\n        if (critExpression !== \"0\") {\n          if (critThreshold === 20) {\n            effectPart += ` crit (${critExpression})`;\n          } else {\n            const xcritNumber = 21 - critThreshold;\n            effectPart += ` xcrit${xcritNumber} (${critExpression})`;\n          }\n        }\n      }\n\n      if (this.missEffect) {\n        effectPart += ` miss (${this.missEffect.toExpression()})`;\n      }\n    }\n\n    return `${checkPart} * ${effectPart}`;\n  }\n\n  resolveProbabilities(\n    check: ACBuilder | AlwaysHitBuilder | AlwaysCritBuilder,\n    eps: number = 0\n  ): { pSuccess: number; pHit: number; pCrit: number; pMiss: number } {\n    const critThreshold = check.critThreshold;\n    const d20 = resolveRootD20(check);\n\n    if (check instanceof AlwaysCritBuilder) {\n      // If fromAlwaysHit is true, everything is a crit (no misses)\n      if (check.fromAlwaysHit) {\n        return { pSuccess: 1, pHit: 0, pCrit: 1, pMiss: 0 };\n      }\n\n      // If fromAlwaysHit is false (came from ACBuilder), we need to check AC\n      // Natural 1s always miss, everything else that would hit becomes a crit\n      const ac = check.attackConfig.ac ?? 0;\n      const staticMod = this.check.modifier;\n      const bonusDicePMFs = this.check.getBonusDicePMFs(this.check, eps);\n      const bonusPMF = bonusDicePMFs.length\n        ? PMF.convolveMany(bonusDicePMFs, eps)\n        : PMF.delta(0, eps);\n\n      let pcrit = 0;\n      let pmiss = 0;\n\n      for (const [r, bin] of d20) {\n        const pr = bin.p;\n        if (pr <= 0) continue;\n\n        // Natural 1 always misses\n        if (r === 1) {\n          pmiss += pr;\n          continue;\n        }\n\n        // Check if this roll would hit the AC\n        const need = ac - staticMod - r;\n        const pBonusHit = bonusPMF.tailProbGE(need);\n\n        // Everything that hits becomes a crit\n        pcrit += pr * pBonusHit;\n        pmiss += pr * (1 - pBonusHit);\n      }\n\n      return { pSuccess: pcrit, pHit: 0, pCrit: pcrit, pMiss: pmiss };\n    }\n\n    if (check instanceof AlwaysHitBuilder) {\n      // Preserve rollType for crit odds\n      let pCrit = 0;\n      for (const [r, bin] of d20) {\n        const pr = bin.p;\n        if (pr <= 0) continue;\n        if (r >= critThreshold) pCrit += pr;\n      }\n      const pHit = 1 - pCrit;\n      const pMiss = 0;\n\n      return { pSuccess: 1, pHit, pCrit, pMiss };\n    }\n\n    const ac = check.attackConfig.ac;\n    const staticMod = this.check.modifier;\n\n    const bonusDicePMFs = this.check.getBonusDicePMFs(this.check, eps);\n    const bonusPMF = bonusDicePMFs.length\n      ? PMF.convolveMany(bonusDicePMFs, eps)\n      : PMF.delta(0, eps);\n\n    let pcrit = 0;\n    let phit = 0;\n    let pmiss = 0;\n\n    for (const [r, bin] of d20) {\n      const pr = bin.p;\n      if (pr <= 0) continue;\n\n      // Handle auto-miss\n      if (r === 1) {\n        pmiss += pr;\n        continue;\n      }\n\n      // A natural 20 always hits and always crits (RAW), independent of AC or critThreshold.\n      if (r === 20) {\n        pcrit += pr;\n        continue;\n      }\n\n      // Handle normal hit/miss, and an expanded crit range (critThreshold < 20): a non-natural-20\n      // roll in the crit range still has to beat AC to hit at all -- it is not an auto-hit.\n      const need = ac - staticMod - r;\n      const pBonusHit = bonusPMF.tailProbGE(need);\n\n      if (r >= critThreshold) {\n        pcrit += pr * pBonusHit;\n      } else {\n        phit += pr * pBonusHit;\n      }\n      pmiss += pr * (1 - pBonusHit);\n    }\n\n    const psuccess = phit + pcrit;\n    return { pSuccess: psuccess, pHit: phit, pCrit: pcrit, pMiss: pmiss };\n  }\n\n  resolve(eps: number = EPS): AttackResolution {\n    const {\n      pHit,\n      pCrit,\n      pMiss: pmiss,\n    } = this.resolveProbabilities(this.check, eps);\n    const hitPMF = this.hitEffect\n      ? this.hitEffect instanceof ParsedRollBuilder\n        ? this.hitEffect.toPMF(eps)\n        : pmfFromRollBuilder(this.hitEffect, eps)\n      : PMF.delta(0, eps);\n\n    let critPMF: PMF | null = null;\n    let phit = pHit;\n    let pcrit = pCrit;\n\n    if (this.critEffect === null) {\n      critPMF = null;\n      phit += pcrit;\n      pcrit = 0;\n    } else {\n      let critBuilder: RollBuilder | undefined;\n      \n      if (this.critEffect) {\n        critBuilder = this.critEffect;\n      } else if (this.hitEffect instanceof ParsedRollBuilder) {\n        // For ParsedRollBuilder, we can't automatically double dice\n        // So treat it as noCrit() - roll crit probability into hit\n        critPMF = null;\n        phit += pcrit;\n        pcrit = 0;\n        critBuilder = undefined;\n      } else {\n        critBuilder = this.hitEffect?.copy().doubleDice();\n      }\n\n      if (critBuilder) {\n        critPMF = critBuilder instanceof ParsedRollBuilder\n          ? critBuilder.toPMF(eps)\n          : pmfFromRollBuilder(critBuilder, eps);\n      }\n    }\n    const missPMF = this.missEffect\n      ? this.missEffect instanceof ParsedRollBuilder\n        ? this.missEffect.toPMF(eps)\n        : pmfFromRollBuilder(this.missEffect, eps)\n      : PMF.delta(0, eps);\n\n    // Mix them up\n    const mix = new Mixture<OutcomeType>(eps);\n    if (phit > 0) mix.add(\"hit\", hitPMF, phit);\n    if (critPMF && pcrit > 0) mix.add(\"crit\", critPMF, pcrit);\n    if (pmiss > 0)\n      mix.add(this.missEffect ? \"missDamage\" : \"missNone\", missPMF, pmiss);\n\n    return {\n      pmf: mix.buildPMF(eps) ?? PMF.delta(0, eps),\n      check: this.check.toPMF(eps) ?? PMF.delta(0, eps),\n      hit: hitPMF ?? PMF.delta(0, eps),\n      crit: critPMF ?? PMF.delta(0, eps),\n      miss: missPMF ?? PMF.delta(0, eps),\n      weights: { hit: phit, crit: pcrit, miss: pmiss },\n    };\n  }\n\n  /**\n   * A cheap, complete key for this attack's resolved PMF, or `null` when it can't be cached soundly (an\n   * effect whose PMF isn't captured by its {@link RollConfig}s — see {@link RollBuilder.cacheKey}). Composed\n   * from the check + hit/crit/miss effect keys + `eps`. `critEffect === null` (noCrit) and `undefined`\n   * (auto-double the hit dice) are distinct crit states, encoded separately.\n   */\n  private cacheKey(eps: number): string | null {\n    const checkKey = this.check.cacheKey();\n    if (checkKey === null) return null;\n\n    let hitKey = \"\";\n    if (this.hitEffect) {\n      const k = this.hitEffect.cacheKey();\n      if (k === null) return null;\n      hitKey = k;\n    }\n\n    let critKey: string;\n    if (this.critEffect === null) critKey = \"n\";\n    else if (this.critEffect === undefined) critKey = \"a\";\n    else {\n      const k = this.critEffect.cacheKey();\n      if (k === null) return null;\n      critKey = k;\n    }\n\n    let missKey = \"\";\n    if (this.missEffect) {\n      const k = this.missEffect.cacheKey();\n      if (k === null) return null;\n      missKey = k;\n    }\n\n    return `${checkKey}*H${hitKey}*C${critKey}*M${missKey}*e${eps}`;\n  }\n\n  // By default, create PMF with no pruning. Cached by the cheap config key across identical rebuilds.\n  toPMF(eps: number = 0): PMF {\n    const key = this.cacheKey(eps);\n    if (key === null) return this.resolve(eps).pmf;\n    const cached = attackPMFCache.get(key);\n    if (cached) return cached;\n    const pmf = this.resolve(eps).pmf;\n    attackPMFCache.set(key, pmf);\n    return pmf;\n  }\n\n  get pmf() {\n    return this.toPMF();\n  }\n\n  // By default, create query on PMF with no pruning\n  toQuery(eps: number = 0): DiceQuery {\n    return this.toPMF(eps).query();\n  }\n}\n","import { PMF } from \"../pmf/pmf\";\nimport { AttackBuilder } from \"./attack\";\nimport { resolveRootD20 } from \"./ast\";\nimport { AlwaysCritBuilder, RollBuilder } from \"./roll\";\n\nexport interface AttackConfig {\n  ac: number;\n  critThreshold: number;\n}\nexport class ACBuilder extends RollBuilder {\n  readonly attackConfig: AttackConfig;\n\n  constructor(baseRoll: RollBuilder, ac: number, attackConfig?: AttackConfig) {\n    super(baseRoll.getSubRollConfigs());\n\n    if (attackConfig) {\n      this.attackConfig = { ...attackConfig, ac };\n    } else {\n      this.attackConfig = { ac, critThreshold: 20 };\n    }\n  }\n\n  //   onHit(effect: RollBuilder): AttackBuilder {\n  //     return new AttackBuilder(this).onHit(effect)\n  //   }\n\n  onHit(val: number): AttackBuilder;\n  onHit(val: string): AttackBuilder;\n  onHit(val: RollBuilder): AttackBuilder;\n  onHit(count: number, die: RollBuilder): AttackBuilder;\n  onHit(count: number, sides: number): AttackBuilder;\n  onHit(count: number, die: RollBuilder, modifier: number): AttackBuilder;\n  onHit(count: number, sides: number, modifier: number): AttackBuilder;\n  onHit(...args: any[]): AttackBuilder {\n    const damageRoll = RollBuilder.fromArgs(...args);\n    return new AttackBuilder(this, damageRoll);\n  }\n\n  get critThreshold(): number {\n    return this.attackConfig.critThreshold;\n  }\n\n  override cacheKey(): string | null {\n    const base = super.cacheKey();\n    return base === null ? null : `A|${this.attackConfig.ac}|${this.attackConfig.critThreshold}|${base}`;\n  }\n\n  // TODO - move this to AC Builder… or if we create a DC builder that has critOn, throw an error?\n  critOn(threshold: number): ACBuilder {\n    const newConfig: AttackConfig = {\n      ...this.attackConfig,\n      critThreshold: threshold,\n    };\n    return new ACBuilder(this, this.attackConfig.ac, newConfig);\n  }\n\n  alwaysCrits(): AlwaysCritBuilder {\n    return new AlwaysCritBuilder(\n      this,\n      {\n        critThreshold: this.attackConfig.critThreshold,\n        ac: this.attackConfig.ac,\n      },\n      false\n    );\n  }\n\n  // Legacy expressions\n  override toExpression(): string {\n    const configs = this.getSubRollConfigs(); // This already includes bonus dice, no need to add them again\n    const expression = new RollBuilder(configs).toExpression();\n    return this.attackConfig.ac\n      ? `(${expression} AC ${this.attackConfig.ac})`\n      : expression;\n  }\n\n  override toPMF(eps: number = 0): PMF {\n    const ac = this.attackConfig.ac;\n    const d20 = resolveRootD20(this);\n    const staticMod = this.modifier;\n    const bonusPMFs = this.getBonusDicePMFs(this, eps);\n\n    // Build total to-hit value distribution attackRollPMF = d20 ⊕ bonusDice, then shift by staticMod\n    const parts = [d20, ...bonusPMFs];\n    let attackRollPMF = parts.length === 1 ? d20 : PMF.convolveMany(parts, eps);\n    if (staticMod !== 0)\n      attackRollPMF = attackRollPMF.mapDamage(\n        (rollValue) => rollValue + staticMod\n      );\n\n    // Map to 0 when below AC\n    const out = new Map<number, number>();\n    for (const rollValue of attackRollPMF.support()) {\n      const p = attackRollPMF.pAt(rollValue);\n      const key = rollValue >= ac ? rollValue : 0;\n      out.set(key, (out.get(key) || 0) + p);\n    }\n    return PMF.fromMap(out, eps);\n  }\n\n  override copy(): ACBuilder {\n    const baseCopy = new RollBuilder(this.getSubRollConfigs());\n    const newConfig = {\n      ac: this.attackConfig.ac,\n      critThreshold: this.attackConfig.critThreshold,\n    };\n    return new ACBuilder(baseCopy, newConfig.ac, newConfig);\n  }\n}\n\n// Augment the RollBuilder prototype to implement the ac method\nRollBuilder.prototype.ac = function (targetAC: number): ACBuilder {\n  if (isNaN(targetAC)) throw new Error(\"Invalid NaN value for targetAC\");\n  return new ACBuilder(this, targetAC);\n};\n","import type { OutcomeType } from \"../common/types\";\nimport { EPS } from \"../common/types\";\nimport { LRUCache } from \"../common/lru-cache\";\nimport { Mixture } from \"../pmf/mixture\";\nimport { PMF } from \"../pmf/pmf\";\nimport type { DiceQuery } from \"../pmf/query\";\nimport { pmfFromRollBuilder, resolveRootD20 } from \"./ast\";\nimport type { DCBuilder } from \"./dc\";\nimport { ParsedRollBuilder, type RollBuilder } from \"./roll\";\nimport type { CheckBuilder, SaveResolution } from \"./types\";\n\nexport type SaveOutcome = \"normal\" | \"half\";\n\n/**\n * Resolved-save PMF cache, the save-side sibling of {@link attackPMFCache}. `resolve()` re-runs the failure\n * PMF, the half-damage scale and the success/fail mixture on every call; a save-based DPR sweep (a caster's\n * Fireball, a Paladin's smite) resolves the SAME save thousands of times. Keyed by\n * {@link SaveBuilder.cacheKey}; a `null` key resolves uncached.\n */\nconst savePMFCache = new LRUCache<string, PMF>(4000);\n\n/** Clears the resolved-save PMF cache (test/bench seam; mirrors {@link clearAttackCache}). */\nexport function clearSaveCache(): void {\n  savePMFCache.clear();\n}\n\nexport class SaveBuilder implements CheckBuilder {\n  constructor(\n    readonly check: DCBuilder,\n    private readonly failureEffect?: RollBuilder,\n    private readonly saveOutcome: SaveOutcome = \"normal\"\n  ) {}\n\n  saveHalf(): SaveBuilder {\n    return new SaveBuilder(this.check, this.failureEffect, \"half\");\n  }\n\n  toExpression(): string {\n    const checkPart = this.check.toExpression();\n    if (!this.failureEffect) return checkPart;\n\n    const failureEffectPart = this.failureEffect.toExpression();\n    const result = `${checkPart} * (${failureEffectPart})`;\n    return this.saveOutcome === \"half\" ? `${result} save half` : result;\n  }\n\n  resolve(eps: number = EPS): SaveResolution {\n    const { pSuccess: psuccess = 0, pFail: pfail = 1 } = resolveProbabilities(\n      this.check\n    );\n    const failPMF = this.failureEffect\n      ? this.failureEffect instanceof ParsedRollBuilder\n        ? this.failureEffect.toPMF(eps)\n        : pmfFromRollBuilder(this.failureEffect)\n      : PMF.delta(0);\n    const onSuccess = this.saveOutcome ?? \"half\";\n\n    let successPMF: PMF = PMF.delta(0, eps);\n    if (onSuccess === \"half\") successPMF = failPMF.scaleDamage(0.5, \"floor\");\n\n    const successLabel: OutcomeType =\n      onSuccess === \"normal\" ? \"missNone\" : \"saveHalf\";\n    const failLabel: OutcomeType = \"saveFail\";\n    const baseMix = new Mixture<OutcomeType>(eps);\n    const mixture = baseMix\n      .add(successLabel, successPMF, psuccess)\n      .add(failLabel, failPMF, pfail);\n\n    return {\n      pmf: mixture.buildPMF(eps) ?? PMF.delta(0, eps),\n      check:\n        PMF.exclusive([[PMF.delta(1), psuccess]], eps) ?? PMF.delta(0, eps),\n      saveFail: failPMF ?? PMF.delta(0, eps),\n      saveSuccess: successPMF ?? PMF.delta(0, eps),\n      weights: { success: psuccess, fail: pfail },\n    };\n  }\n\n  /**\n   * A cheap, complete key for this save's resolved PMF, or `null` when it can't be cached soundly.\n   * {@link resolve} reads exactly three things: the DC check (via `resolveProbabilities`), the failure\n   * effect's PMF, and the save outcome — so composing their keys pins it. A `ParsedRollBuilder` failure\n   * effect returns `null`, which correctly forces this uncached.\n   */\n  private cacheKey(eps: number): string | null {\n    const checkKey = this.check.cacheKey();\n    if (checkKey === null) return null;\n\n    let failKey = \"\";\n    if (this.failureEffect) {\n      const k = this.failureEffect.cacheKey();\n      if (k === null) return null;\n      failKey = k;\n    }\n\n    return `${checkKey}*F${failKey}*O${this.saveOutcome}*e${eps}`;\n  }\n\n  // By default, create PMF with no pruning. Cached by the cheap config key across identical rebuilds.\n  toPMF(eps: number = 0): PMF {\n    const key = this.cacheKey(eps);\n    if (key === null) return this.resolve(eps).pmf;\n    const cached = savePMFCache.get(key);\n    if (cached) return cached;\n    const pmf = this.resolve(eps).pmf;\n    savePMFCache.set(key, pmf);\n    return pmf;\n  }\n\n  get pmf() {\n    return this.toPMF();\n  }\n\n  // By default, create query on PMF with no pruning\n  toQuery(eps: number = 0): DiceQuery {\n    return this.toPMF(eps).query();\n  }\n}\n\nfunction resolveProbabilities(check: DCBuilder): {\n  pSuccess: number;\n  pFail: number;\n} {\n  const saveBonus = check.modifier;\n  const dc = check.saveDC;\n  const eps = 0;\n\n  const die = resolveRootD20(check);\n  const faceP = new Map<number, number>();\n  for (const [r, bin] of die) {\n    const pr = bin.p;\n    if (pr > 0) faceP.set(r, pr);\n  }\n\n  // Now add bonus dice to the PMF (bless, bane, bardic, etc)\n  const bonusDicePMFs = check.getBonusDicePMFs(check, eps);\n  const bonusPMF =\n    bonusDicePMFs.length > 0\n      ? PMF.convolveMany(bonusDicePMFs, eps)\n      : PMF.zero(eps);\n\n  let pSuccess = 0;\n  for (const [r, pr] of faceP) {\n    const need = dc - saveBonus - r;\n    pSuccess += pr * bonusPMF.tailProbGE(need);\n  }\n\n  const pFail = Math.max(0, 1 - pSuccess);\n  return { pSuccess, pFail: pFail };\n}\n","import { LRUCache } from \"../common/lru-cache\";\nimport { PMF } from \"../pmf/pmf\";\nimport { pmfFromRollBuilder, resolveRootD20 } from \"./ast\";\nimport { RollBuilder } from \"./roll\";\nimport { SaveBuilder } from \"./save\";\n\ninterface SaveConfig {\n  dc: number;\n}\n\n/**\n * DC-check PMF cache. The two-outcome success/fail PMF is re-derived on every `toPMF()`, and a save-based\n * DPR sweep asks for the SAME check thousands of times. Keyed by {@link DCBuilder.cacheKey} + `eps`.\n */\nconst dcPMFCache = new LRUCache<string, PMF>(4000);\n\n/** Clears the DC-check PMF cache (test/bench seam). */\nexport function clearDCCache(): void {\n  dcPMFCache.clear();\n}\n\nexport class DCBuilder extends RollBuilder {\n  private readonly saveConfig: SaveConfig;\n\n  constructor(baseRoll: RollBuilder, saveConfig?: SaveConfig) {\n    super(baseRoll.getSubRollConfigs());\n    this.saveConfig = saveConfig ? { ...saveConfig } : { dc: 10 };\n  }\n\n  override dc(saveDC: number): DCBuilder {\n    if (this.rollType && this.rollType === \"elven accuracy\") {\n      throw new Error(\n        \"Cannot use dc() on an AttackRollBuilder. Use ac() for attack rolls instead.\"\n      );\n    }\n    return new DCBuilder(this, { dc: saveDC });\n  }\n\n  get saveDC(): number {\n    return this.saveConfig.dc;\n  }\n\n  override add(anotherRoll: RollBuilder): DCBuilder {\n    const newBuilder = super.add(anotherRoll);\n    return new DCBuilder(newBuilder, this.saveConfig);\n  }\n\n  override addRoll(count?: number): DCBuilder {\n    const newBuilder = super.addRoll(count);\n    return new DCBuilder(newBuilder, this.saveConfig);\n  }\n\n  onSaveFailure(val: number): SaveBuilder;\n  onSaveFailure(val: string): SaveBuilder;\n  onSaveFailure(val: RollBuilder): SaveBuilder;\n  onSaveFailure(count: number, die: RollBuilder): SaveBuilder;\n  onSaveFailure(count: number, sides: number): SaveBuilder;\n  onSaveFailure(count: number, die: RollBuilder, modifier: number): SaveBuilder;\n  onSaveFailure(count: number, sides: number, modifier: number): SaveBuilder;\n  onSaveFailure(...args: any[]): SaveBuilder {\n    const damageRoll = RollBuilder.fromArgs(...args);\n    return new SaveBuilder(this, damageRoll);\n  }\n\n  override withElvenAccuracy(): never {\n    throw new Error(\n      \"Elven Accuracy cannot be used with saving throws (DC checks). It is only valid for attack rolls (AC checks).\"\n    );\n  }\n\n  // Legacy expressions\n  override toExpression(): string {\n    const subConfigs = this.getSubRollConfigs();\n    const allConfigs = [...subConfigs];\n    const expression = new RollBuilder(allConfigs).toExpression();\n    return `(${expression} DC ${this.saveConfig.dc})`;\n  }\n\n  /**\n   * The DC check's PMF is fully determined by the save DC plus everything `toPMF` below reads off the roll\n   * configs (`rollType`, `baseReroll`, `modifier`, bonus dice) — all of which `super.cacheKey()` already\n   * serializes. So extend the base key with the DC, mirroring {@link AlwaysHitBuilder.cacheKey}.\n   */\n  override cacheKey(): string | null {\n    const base = super.cacheKey();\n    return base === null ? null : `DC|${this.saveConfig.dc}|${base}`;\n  }\n\n  override toPMF(eps: number = 0): PMF {\n    const key = this.cacheKey();\n    const fullKey = key === null ? null : `${key}*e${eps}`;\n    if (fullKey !== null) {\n      const cached = dcPMFCache.get(fullKey);\n      if (cached) return cached;\n    }\n\n    const saveDC = this.saveDC;\n    const d20 = resolveRootD20(this);\n    const staticMod = this.modifier;\n    const bonusDicePMFs = this.getBonusDiceConfigs().map((cfg) =>\n      pmfFromRollBuilder(RollBuilder.fromConfigs([cfg]), eps)\n    );\n    const bonusPMF = bonusDicePMFs.length\n      ? PMF.convolveMany(bonusDicePMFs, eps)\n      : PMF.delta(0, eps);\n\n    let psuccess = 0;\n    for (const [r, bin] of d20) {\n      const pr = bin.p;\n      if (pr <= 0) continue;\n      const need = saveDC - staticMod - r;\n      psuccess += pr * bonusPMF.tailProbGE(need);\n    }\n\n    const pfail = Math.max(0, 1 - psuccess);\n    const m = new Map<number, number>([\n      [0, psuccess > 0 ? psuccess : 0],\n      [1, pfail > 0 ? pfail : 0],\n    ]);\n    const pmf = PMF.fromMap(m, eps);\n    if (fullKey !== null) dcPMFCache.set(fullKey, pmf);\n    return pmf;\n  }\n}\n\n// Augment the RollBuilder prototype to implement the dc method\nRollBuilder.prototype.dc = function (saveDC: number): DCBuilder {\n  if (isNaN(saveDC)) throw new Error(\"Invalid NaN value for saveDC\");\n  return new DCBuilder(this).dc(saveDC);\n};\n","import type { PMF } from \"../pmf/pmf\";\n\n/**\n * Triggers that read the outcomes of source attacks, as opposed to `not-fired`,\n * which reads another rider. Includes `any-miss`, so this is not \"hit triggers\".\n */\nexport type AttackTriggerOn =\n  | \"first-hit\"\n  | \"any-crit\"\n  | \"any-miss\"\n  | \"every-hit\";\n\n/**\n * When a rider fires. JSON-safe, so a consumer can persist this verbatim and hand\n * it straight back in a {@link TurnSpec}.\n *\n * - `first-hit` — the first source that lands. Fires in that source's mode, so a\n *   crit on the *first* landing attack doubles the rider's dice (Sneak Attack).\n * - `any-crit` — at least one source crit. Always fires in crit mode (Divine Smite).\n * - `any-miss` — at least one source missed. The reroll gate (Unerring Accuracy, Lucky).\n * - `every-hit` — once per landing source, in that hit's mode (Hunter's Mark, Hex, Rage).\n * - `not-fired` — the named rider did **not** fire (\"flurry of blows if I didn't smite\").\n *\n * For the attack triggers `of` is a list of attack ids and defaults to every\n * declared attack, which is what most riders mean. For `not-fired` it is the\n * single required id of the rider being negated — negating a set of riders has\n * no unambiguous meaning, so the type does not offer it.\n */\nexport type Trigger =\n  | { on: AttackTriggerOn; of?: readonly string[] }\n  | { on: \"not-fired\"; of: string };\n\n/** Anything that can produce a PMF: `RollBuilder`, `AttackBuilder`, `SaveBuilder`, or a `PMF`. */\nexport interface ToPMF {\n  toPMF(eps?: number): PMF;\n}\n\n/**\n * Rider or attack damage. Strings are not accepted: a parsed expression cannot\n * have its dice doubled, so a string rider would deal single dice on a crit. Call\n * `parse()` yourself if that is what you want.\n */\nexport type Damage = PMF | ToPMF;\n\n/**\n * Same shape as {@link Damage}, named separately because the requirement is\n * stronger: a source must resolve to an *outcome-labelled* PMF carrying\n * hit/crit/miss, which no type can express. Supplying one that does not is a\n * `not-an-attack` {@link TurnSpecError} at build time, not a compile error.\n */\nexport type Source = Damage;\n\n/** One payload, or several to convolve: Flurry of Blows is `[flurry, flurry]`. */\nexport type RiderDamage = Damage | readonly Damage[];\n\n/** Everything about a rider except what it does and when — see `Turn.onFirstHit`. */\nexport interface RiderOptions {\n  /** Required only if another rider names this one in `of`. */\n  id?: string;\n  /** Which attacks to watch. Defaults to every declared attack. */\n  of?: readonly string[];\n  /** Defaults to `damage` with dice doubled when that is possible, else `damage`. */\n  critDamage?: RiderDamage;\n}\n\nexport type Rider = Trigger & {\n  id?: string;\n  damage: RiderDamage;\n  critDamage?: RiderDamage;\n};\n\n/**\n * A bare source gets the id `attack 1`, `attack 2`, … in declaration order.\n *\n * Unlike {@link Rider}, the id lives in a wrapper rather than on the value\n * itself: an attack's value is a builder or PMF that this module does not own,\n * so there is nowhere to hang a field.\n */\nexport type Attack = Source | { id: string; source: Source };\n\nexport interface TurnSpec {\n  attacks: readonly Attack[];\n  riders?: readonly Rider[];\n}\n\nexport type TurnSpecErrorCode =\n  | \"unknown-id\"\n  | \"duplicate-id\"\n  | \"self-reference\"\n  | \"cycle\"\n  | \"not-an-attack\"\n  | \"unused-crit-damage\"\n  | \"too-many-groups\";\n\n/**\n * A malformed turn. `code` is a stable contract: consumer UIs map it to their own\n * states (greyed dropdown option, \"trigger missing\" row error, …) instead of\n * re-implementing validation.\n */\nexport class TurnSpecError extends Error {\n  constructor(\n    readonly code: TurnSpecErrorCode,\n    readonly id: string,\n    message: string\n  ) {\n    super(message);\n    this.name = \"TurnSpecError\";\n  }\n}\n\n/**\n * How many distinct `of` sets a single turn may track.\n *\n * Each group multiplies the state space, so the cap is a cost ceiling rather\n * than a modelling limit. Measured on four attacks with two riders per group:\n * 2.1ms for one group, 3.1 for two, 5.9 for three, 23.5 for four — roughly 4x\n * per group. Real builds use one or two (the goliath rogue/monk/paladin uses\n * one), so four leaves plenty of room while keeping an AC sweep viable.\n */\nexport const MAX_TRIGGER_GROUPS = 4;\n","import { EPS } from \"../common/types\";\nimport { PMF } from \"../pmf/pmf\";\nimport type {\n  Attack,\n  Damage,\n  Rider,\n  ToPMF,\n  Trigger,\n  TurnSpec,\n  TurnSpecErrorCode,\n} from \"./types\";\nimport { MAX_TRIGGER_GROUPS, TurnSpecError } from \"./types\";\n\n/**\n * A resolved, validated turn: the ordered steps to walk, plus the trigger\n * groups it tracks. Building this is where every {@link TurnSpecError} is raised,\n * so the walk itself can assume a well-formed plan.\n */\nexport interface TurnPlan {\n  steps: readonly Step[];\n  /** One entry per distinct `of` set; each holds the step indices that update it. */\n  groupCount: number;\n  /** Declared attacks only, in order — what `DiceQuery.singles` gets. */\n  attackPMFs: readonly PMF[];\n  /** Every attack id, in declaration order. */\n  attackIds: readonly string[];\n  /** Every rider id, in declaration order, including `every-hit` riders. */\n  riderIds: readonly string[];\n  /** Rider id → step index, for `fireProbability` and `not-fired`. */\n  riderSteps: ReadonlyMap<string, number>;\n  /**\n   * `every-hit` rider id → the group index whose \"something landed\" bit answers\n   * P(it fired at least once). Such riders are folded into their sources' slices\n   * rather than becoming steps, so they have no step index.\n   */\n  perHitGroups: ReadonlyMap<string, number>;\n}\n\n/**\n * One step of the turn. `slices` non-null ⇒ the step rolls its own attack and\n * advances the groups listed in `updates`; null ⇒ it is pure damage whose amount\n * depends only on the mode it fires in.\n */\nexport interface Step {\n  id: string;\n  /** Declared attacks always fire; riders consult their trigger. */\n  trigger: Trigger | null;\n  /** Outcome-labelled sub-mass PMFs, masses summing to 1. */\n  slices: { hit: PMF; crit: PMF; miss: PMF } | null;\n  /** Pure-damage payloads, mass 1 each. */\n  damage: { hit: PMF; crit: PMF } | null;\n  /** Group indices this step's outcome advances. */\n  updates: readonly number[];\n  /** Group index this step's trigger reads, or -1 for `not-fired` / always-fires. */\n  reads: number;\n  /** For `not-fired`: the step index of the rider being negated. */\n  negates: number;\n}\n\nconst IS_HIT_TRIGGER: Record<string, true> = {\n  \"first-hit\": true,\n  \"any-crit\": true,\n  \"any-miss\": true,\n  \"every-hit\": true,\n};\n\nfunction toPMF(\n  damage: Damage | readonly Damage[],\n  eps: number,\n  id = \"\"\n): PMF {\n  const parts = Array.isArray(damage) ? damage : [damage as Damage];\n  if (parts.length === 0) return PMF.delta(0, eps);\n  const pmfs = parts.map((part) => {\n    if (part instanceof PMF) return part;\n    // `Damage` rules this out, but a consumer deserializing UI state reaches\n    // here untyped. Reporting it as a spec error beats a bare TypeError from\n    // calling a method that isn't there.\n    if (typeof (part as Partial<ToPMF>).toPMF !== \"function\") {\n      throw new TurnSpecError(\n        \"not-an-attack\",\n        id,\n        `\"${id}\" is neither a PMF nor a builder with toPMF().`\n      );\n    }\n    // Also checked on the way out: a callable `toPMF` that returns something\n    // else would otherwise reach PMF.convolveMany and fail deep inside it.\n    const resolved = part.toPMF(eps);\n    if (!(resolved instanceof PMF)) {\n      throw new TurnSpecError(\n        \"not-an-attack\",\n        id,\n        `\"${id}\" has a toPMF() that did not return a PMF.`\n      );\n    }\n    return resolved;\n  });\n  return PMF.convolveMany(pmfs, eps);\n}\n\n/**\n * Crit payload for a rider: an explicit `critDamage` wins; otherwise double the\n * dice if the builder supports it. `ParsedRollBuilder.doubleDice()` throws (a\n * parsed expression has no AST to scale) and a raw `PMF` has no dice to double,\n * so both fall back to the base damage — the same rule `AttackBuilder.resolve`\n * already applies to `onHit` without an `onCrit`.\n */\nfunction critPMF(rider: Rider, base: PMF, eps: number): PMF {\n  if (rider.critDamage !== undefined) return toPMF(rider.critDamage, eps);\n\n  const parts = Array.isArray(rider.damage)\n    ? rider.damage\n    : [rider.damage as Damage];\n  const doubled: PMF[] = [];\n  for (const part of parts) {\n    const doublable = part as { doubleDice?: () => Damage };\n    if (part instanceof PMF || typeof doublable.doubleDice !== \"function\") {\n      return base;\n    }\n    try {\n      doubled.push(toPMF(doublable.doubleDice(), eps));\n    } catch {\n      return base;\n    }\n  }\n  if (doubled.length === 0) return base;\n  return PMF.convolveMany(doubled, eps);\n}\n\n/**\n * Split a source into hit / crit / miss sub-mass PMFs, or return null when the\n * PMF carries no outcome labels (a plain damage roll is not an attack).\n */\nfunction sliceSource(pmf: PMF): { hit: PMF; crit: PMF; miss: PMF } | null {\n  const labels = pmf.outcomes();\n  if (!labels.includes(\"hit\") && !labels.includes(\"crit\")) return null;\n\n  const missParts = [\"missNone\", \"missDamage\"]\n    .filter((label) => labels.includes(label))\n    .map((label) => pmf.filterOutcome(label));\n\n  return {\n    hit: labels.includes(\"hit\") ? pmf.filterOutcome(\"hit\") : PMF.emptyMass(),\n    crit: labels.includes(\"crit\") ? pmf.filterOutcome(\"crit\") : PMF.emptyMass(),\n    miss: missParts.length\n      ? missParts.reduce((all, part) => all.add(part))\n      : PMF.emptyMass(),\n  };\n}\n\nexport function buildPlan(spec: TurnSpec, eps: number = EPS): TurnPlan {\n  const fail = (code: TurnSpecErrorCode, id: string, message: string): never => {\n    throw new TurnSpecError(code, id, message);\n  };\n\n  // --- attacks -------------------------------------------------------------\n  const attackIds: string[] = [];\n  const attackPMFs: PMF[] = [];\n  const attackSlices: ({ hit: PMF; crit: PMF; miss: PMF } | null)[] = [];\n\n  spec.attacks.forEach((entry: Attack, index) => {\n    const named = entry as { id?: string; source?: Damage };\n    const hasWrapper =\n      typeof named.id === \"string\" && named.source !== undefined;\n    const id = hasWrapper ? (named.id as string) : `attack ${index + 1}`;\n    const source = hasWrapper ? (named.source as Damage) : (entry as Damage);\n    const pmf = toPMF(source, eps, id);\n\n    attackIds.push(id);\n    attackPMFs.push(pmf);\n    attackSlices.push(sliceSource(pmf));\n  });\n\n  const riders = spec.riders ?? [];\n\n  // --- ids -----------------------------------------------------------------\n  const riderIds = riders.map((rider, index) => rider.id ?? `rider ${index + 1}`);\n  const seen = new Set<string>();\n  for (const id of [...attackIds, ...riderIds]) {\n    if (seen.has(id)) fail(\"duplicate-id\", id, `Duplicate id \"${id}\".`);\n    seen.add(id);\n  }\n\n  const attackIndexById = new Map(attackIds.map((id, index) => [id, index]));\n  const riderIndexById = new Map(riderIds.map((id, index) => [id, index]));\n\n  // --- references ----------------------------------------------------------\n  // `of` lists for hit triggers, defaulted to every declared attack.\n  const sourceIdsByRider: string[][] = riders.map((rider, index) => {\n    const id = riderIds[index];\n\n    if (rider.on === \"not-fired\") {\n      const target = rider.of;\n      if (target === id) {\n        fail(\"self-reference\", id, `Rider \"${id}\" cannot depend on itself.`);\n      }\n      const targetIndex = riderIndexById.get(target);\n      if (targetIndex === undefined) {\n        fail(\n          \"unknown-id\",\n          target,\n          `Rider \"${id}\" negates \"${target}\", which is not a rider in this turn.`\n        );\n      }\n      if (riders[targetIndex as number].on === \"every-hit\") {\n        fail(\n          \"not-an-attack\",\n          target,\n          `Rider \"${id}\" negates \"${target}\", an every-hit rider, which can fire more than once and so has no single \"did not fire\" branch.`\n        );\n      }\n      return [target];\n    }\n\n    // Deduplicated, so `of: [\"a\", \"a\"]` shares a trigger group with `of: [\"a\"]`\n    // instead of consuming a second slot and tripping `too-many-groups` on a\n    // turn that is really tracking one source set. Repeats are otherwise\n    // harmless: advancing a group twice for one outcome is idempotent.\n    const of = [...new Set(rider.of ?? attackIds)];\n    if (of.length === 0) {\n      fail(\"unknown-id\", id, `Rider \"${id}\" has no sources.`);\n    }\n    for (const sourceId of of) {\n      if (sourceId === id) {\n        fail(\"self-reference\", id, `Rider \"${id}\" cannot depend on itself.`);\n      }\n      const riderIndex = riderIndexById.get(sourceId);\n      const isAttack = attackIndexById.has(sourceId);\n      if (!isAttack && riderIndex === undefined) {\n        fail(\n          \"unknown-id\",\n          sourceId,\n          `Rider \"${id}\" depends on \"${sourceId}\", which is not in this turn.`\n        );\n      }\n      if (riderIndex !== undefined && riders[riderIndex].on === \"every-hit\") {\n        fail(\n          \"not-an-attack\",\n          sourceId,\n          `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 — point at the attacks instead.`\n        );\n      }\n      const slices = isAttack\n        ? attackSlices[attackIndexById.get(sourceId) as number]\n        : sliceSource(\n            toPMF(riders[riderIndex as number].damage, eps, sourceId)\n          );\n      if (!slices) {\n        fail(\n          \"not-an-attack\",\n          sourceId,\n          `Rider \"${id}\" triggers on \"${sourceId}\", which has no hit/crit outcomes.`\n        );\n      }\n    }\n    return [...of];\n  });\n\n  // --- ordering ------------------------------------------------------------\n  // Riders may only reference riders that resolve before them.\n  const order: number[] = [];\n  const visiting = new Set<number>();\n  const done = new Set<number>();\n\n  const visit = (index: number): void => {\n    if (done.has(index)) return;\n    const id = riderIds[index];\n    if (visiting.has(index)) {\n      fail(\"cycle\", id, `Rider \"${id}\" is part of a dependency cycle.`);\n    }\n    visiting.add(index);\n    for (const sourceId of sourceIdsByRider[index]) {\n      const dependency = riderIndexById.get(sourceId);\n      if (dependency !== undefined) visit(dependency);\n    }\n    visiting.delete(index);\n    done.add(index);\n    order.push(index);\n  };\n  riders.forEach((_, index) => visit(index));\n\n  // --- groups --------------------------------------------------------------\n  // One group per distinct source set. Sharing matters: sneak attack and Fire's\n  // Burn over the same two daggers are ONE group, so they resolve jointly.\n  const groupIndexByKey = new Map<string, number>();\n  const groupSources: string[][] = [];\n  const groupOf = (sourceIds: readonly string[]): number => {\n    // JSON, not a delimiter join: an id is consumer-supplied, and a delimiter\n    // that can appear inside one makes the encoding non-injective, so two\n    // distinct source sets could share a group.\n    const key = JSON.stringify([...sourceIds].sort());\n    const existing = groupIndexByKey.get(key);\n    if (existing !== undefined) return existing;\n    if (groupSources.length >= MAX_TRIGGER_GROUPS) {\n      fail(\n        \"too-many-groups\",\n        key,\n        `A turn may track at most ${MAX_TRIGGER_GROUPS} distinct trigger source sets.`\n      );\n    }\n    const index = groupSources.length;\n    groupIndexByKey.set(key, index);\n    groupSources.push([...sourceIds]);\n    return index;\n  };\n\n  const readsByRider = new Map<number, number>();\n  const perHitGroups = new Map<string, number>();\n  for (const index of order) {\n    const rider = riders[index];\n    if (!IS_HIT_TRIGGER[rider.on]) continue;\n    const group = groupOf(sourceIdsByRider[index]);\n    readsByRider.set(index, group);\n    if (rider.on === \"every-hit\") perHitGroups.set(riderIds[index], group);\n  }\n\n  // --- steps ---------------------------------------------------------------\n  // `every-hit` riders are not steps: they are convolved into each source's own\n  // hit/crit slices, so one hit means one application with no extra state.\n  const perHitBySource = new Map<string, { hit: PMF; crit: PMF }[]>();\n  for (const index of order) {\n    const rider = riders[index];\n    if (rider.on !== \"every-hit\") continue;\n    const hit = toPMF(rider.damage, eps, riderIds[index]);\n    const payload = { hit, crit: critPMF(rider, hit, eps) };\n    for (const sourceId of sourceIdsByRider[index]) {\n      const existing = perHitBySource.get(sourceId);\n      if (existing) existing.push(payload);\n      else perHitBySource.set(sourceId, [payload]);\n    }\n  }\n\n  const updatesById = new Map<string, number[]>();\n  groupSources.forEach((sourceIds, groupIndex) => {\n    for (const sourceId of sourceIds) {\n      const existing = updatesById.get(sourceId);\n      if (existing) existing.push(groupIndex);\n      else updatesById.set(sourceId, [groupIndex]);\n    }\n  });\n\n  const withPerHit = (\n    slices: { hit: PMF; crit: PMF; miss: PMF },\n    id: string\n  ): { hit: PMF; crit: PMF; miss: PMF } => {\n    const payloads = perHitBySource.get(id);\n    if (!payloads) return slices;\n    let hit = slices.hit;\n    let crit = slices.crit;\n    for (const payload of payloads) {\n      hit = hit.convolve(payload.hit, eps, true);\n      crit = crit.convolve(payload.crit, eps, true);\n    }\n    return { hit, crit, miss: slices.miss };\n  };\n\n  const steps: Step[] = attackIds.map((id, index) => ({\n    id,\n    trigger: null,\n    slices: withPerHit(\n      attackSlices[index] ?? {\n        hit: attackPMFs[index],\n        crit: PMF.emptyMass(),\n        miss: PMF.emptyMass(),\n      },\n      id\n    ),\n    damage: null,\n    updates: updatesById.get(id) ?? [],\n    reads: -1,\n    negates: -1,\n  }));\n\n  const stepIndexByRider = new Map<number, number>();\n  const riderSteps = new Map<string, number>();\n\n  for (const index of order) {\n    const rider = riders[index];\n    if (rider.on === \"every-hit\") continue;\n\n    const id = riderIds[index];\n    const hit = toPMF(rider.damage, eps, id);\n    const slices = sliceSource(hit);\n    if (slices && rider.critDamage !== undefined) {\n      // An attack-shaped rider rolls its own d20 and crits on its own terms —\n      // a bonus attack triggered by a crit does not deal doubled dice — so\n      // there is nothing for `critDamage` to mean. Silently dropping it would\n      // hide a real misunderstanding.\n      fail(\n        \"unused-crit-damage\",\n        id,\n        `Rider \"${id}\" rolls its own attack, so its critDamage would never be used. Remove it, or pass plain damage dice instead.`\n      );\n    }\n    const negatedRider =\n      rider.on === \"not-fired\"\n        ? (riderIndexById.get(rider.of) as number)\n        : undefined;\n\n    const step: Step = {\n      id,\n      trigger: rider,\n      slices: slices ? withPerHit(slices, id) : null,\n      damage: slices ? null : { hit, crit: critPMF(rider, hit, eps) },\n      updates: updatesById.get(id) ?? [],\n      reads: readsByRider.get(index) ?? -1,\n      negates:\n        negatedRider === undefined\n          ? -1\n          : (stepIndexByRider.get(negatedRider) as number),\n    };\n    steps.push(step);\n\n    stepIndexByRider.set(index, steps.length - 1);\n    riderSteps.set(id, steps.length - 1);\n  }\n\n  return {\n    steps,\n    groupCount: groupSources.length,\n    attackPMFs,\n    attackIds,\n    riderIds,\n    riderSteps,\n    perHitGroups,\n  };\n}\n","/**\n * Per-group trigger state, packed into one byte.\n *\n * A \"group\" is one distinct set of source ids referenced by a trigger. Everything\n * any trigger needs to know about a group is which outcome landed *first*, whether\n * anything crit, and whether anything missed — so the whole turn state is one byte\n * per group and the state space stays small (12 codes per group, ~10 reachable).\n *\n * Layout: `first << 2 | anyCrit << 1 | anyMiss`, where `first` is one of\n * {@link FIRST_NONE} / {@link FIRST_HIT} / {@link FIRST_CRIT}. Readers decode with\n * `code >> 2`, `code & CRIT_BIT`, `code & MISS_BIT`.\n */\nexport const FIRST_NONE = 0;\nexport const FIRST_HIT = 1;\nexport const FIRST_CRIT = 2;\n\nexport const CRIT_BIT = 2;\nexport const MISS_BIT = 1;\n\n/** A group that has seen nothing yet: no first landing, no crit, no miss. */\nexport const START_CODE = FIRST_NONE << 2;\n\nexport type StepOutcome = \"hit\" | \"crit\" | \"miss\";\n\n/** Fold one source outcome into a group's state. */\nexport function advance(code: number, outcome: StepOutcome): number {\n  if (outcome === \"miss\") return code | MISS_BIT;\n\n  const first = code >> 2;\n  const withCrit = outcome === \"crit\" ? code | CRIT_BIT : code;\n  if (first !== FIRST_NONE) return withCrit;\n\n  const nextFirst = outcome === \"crit\" ? FIRST_CRIT : FIRST_HIT;\n  return (nextFirst << 2) | (withCrit & (CRIT_BIT | MISS_BIT));\n}\n","import { EPS } from \"../common/types\";\nimport { PMF } from \"../pmf/pmf\";\nimport { DiceQuery } from \"../pmf/query\";\nimport type { Step, TurnPlan } from \"./plan\";\nimport { buildPlan } from \"./plan\";\nimport type { StepOutcome } from \"./state\";\nimport {\n  advance,\n  CRIT_BIT,\n  FIRST_CRIT,\n  FIRST_NONE,\n  MISS_BIT,\n  START_CODE,\n} from \"./state\";\nimport type {\n  Attack,\n  Rider,\n  RiderDamage,\n  RiderOptions,\n  Source,\n  TurnSpec,\n} from \"./types\";\nimport { TurnSpecError } from \"./types\";\n\n/** Which payload a rider uses when it fires, or `null` when it doesn't fire. */\ntype FireMode = \"hit\" | \"crit\" | null;\n\nconst OUTCOMES: readonly StepOutcome[] = [\"hit\", \"crit\", \"miss\"];\n\n/**\n * Decide whether `step` fires in state `codes`, and in which mode.\n *\n * Every group a trigger reads is fully determined before its own step runs\n * (sources always precede dependents), so a trigger can be evaluated once, at\n * its step, and again at the end for {@link Turn.fireProbability} — both give the\n * same answer.\n */\nfunction fireMode(\n  step: Step,\n  codes: readonly number[],\n  firedByStep: readonly FireMode[]\n): FireMode {\n  const trigger = step.trigger;\n  if (!trigger) return \"hit\";\n\n  if (trigger.on === \"not-fired\") {\n    return firedByStep[step.negates] === null ? \"hit\" : null;\n  }\n\n  const code = codes[step.reads];\n  const first = code >> 2;\n\n  switch (trigger.on) {\n    case \"first-hit\":\n      if (first === FIRST_NONE) return null;\n      return first === FIRST_CRIT ? \"crit\" : \"hit\";\n    case \"any-crit\":\n      return (code & CRIT_BIT) !== 0 ? \"crit\" : null;\n    case \"any-miss\":\n      return (code & MISS_BIT) !== 0 ? \"hit\" : null;\n    default:\n      // `every-hit` never becomes a step — it is folded into its sources' slices.\n      return null;\n  }\n}\n\n/**\n * A turn of attacks plus conditional damage riders, resolved to one **exact**\n * joint distribution.\n *\n * Riders are correlated with the attacks that trigger them, so a rider cannot be\n * a separate `DiceQuery` single convolved in afterwards: that preserves the mean\n * but corrupts the distribution (two daggers + Sneak Attack report P(0 damage) of\n * 0.015 instead of the true 0.1225). `Turn` owns the sources and enumerates the\n * joint outcome space instead, carrying one byte of state per trigger group.\n *\n * @example\n * const dagger = d20.plus(8).ac(16).onHit(d4.plus(4));\n * const rogue = turn([dagger, dagger]).rider({ damage: roll(3, d6), on: \"first-hit\" });\n * rogue.mean();     // 18.6225\n */\nexport class Turn {\n  private readonly eps: number;\n  private readonly declaredAttacks: readonly Attack[];\n  private readonly riders: readonly Rider[];\n  private readonly plan: TurnPlan;\n  private resolved?: { pmf: PMF; fireMass: ReadonlyMap<string, number> };\n\n  private constructor(\n    attacks: readonly Attack[],\n    riders: readonly Rider[],\n    eps: number\n  ) {\n    // Copied, because a caller can hand in an array they still hold and keep\n    // mutating it. Shallow is the right depth: the entries are builders and\n    // PMFs this module does not own and which are immutable by convention\n    // throughout this library.\n    this.declaredAttacks = [...attacks];\n    this.riders = [...riders];\n    this.eps = eps;\n    // Built here, not on first use, so every way of constructing a Turn\n    // validates at the same moment: the call that introduced the mistake.\n    this.plan = buildPlan({ attacks: this.declaredAttacks, riders: this.riders }, eps);\n  }\n\n  /**\n   * Builds a turn from plain data, throwing {@link TurnSpecError} if it is\n   * malformed. Use this from a UI, where `error.code` maps to the field state to\n   * show.\n   */\n  static from(spec: TurnSpec, eps: number = EPS): Turn {\n    return new Turn(spec.attacks, spec.riders ?? [], eps);\n  }\n\n  /**\n   * Appends an attack, throwing {@link TurnSpecError} if that makes the turn\n   * invalid.\n   *\n   * A rider with no explicit `of` watches every declared attack *including ones\n   * appended after it*, because `of` is resolved when the plan is built rather\n   * than when the rider is added. Pass an explicit `of` to pin a rider to the\n   * attacks it already saw. One attack must exist before a rider with a default\n   * `of` is added, or the build fails `unknown-id`.\n   */\n  attack(source: Source, id?: string): Turn {\n    const entry: Attack = id === undefined ? source : { id, source };\n    return new Turn([...this.declaredAttacks, entry], this.riders, this.eps);\n  }\n\n  /**\n   * Appends `count` copies of the same attack — the Extra Attack case, which is\n   * most of 5e. Argument order mirrors `roll(count, die)`.\n   *\n   * ```ts\n   * turn().attacks(4, greatsword).onEveryHit(d6); // fighter 20 + hunter's mark\n   * ```\n   *\n   * @throws {RangeError} if `count` is not a positive integer.\n   */\n  attacks(count: number, source: Source): Turn {\n    if (!Number.isInteger(count) || count < 1) {\n      throw new RangeError(\n        `attacks(count) needs a positive integer, got ${count}.`\n      );\n    }\n    const added: Attack[] = new Array<Attack>(count).fill(source);\n    return new Turn([...this.declaredAttacks, ...added], this.riders, this.eps);\n  }\n\n  /**\n   * Appends a rider, throwing {@link TurnSpecError} if that makes the turn\n   * invalid. The `onX` methods below are the readable way to call this.\n   */\n  rider(rider: Rider): Turn {\n    return new Turn(this.declaredAttacks, [...this.riders, rider], this.eps);\n  }\n\n  /**\n   * Fires once, on the first source that lands, in that source's mode — so a\n   * crit on the first landing attack doubles the rider's dice. Sneak Attack.\n   */\n  onFirstHit(damage: RiderDamage, options: RiderOptions = {}): Turn {\n    return this.rider({ ...options, damage, on: \"first-hit\" });\n  }\n\n  /**\n   * Fires once if any source crit, always in crit mode. Divine Smite: nothing is\n   * lost by holding it for a crit, so this is \"any\", not \"first\".\n   */\n  onAnyCrit(damage: RiderDamage, options: RiderOptions = {}): Turn {\n    return this.rider({ ...options, damage, on: \"any-crit\" });\n  }\n\n  /**\n   * Fires once if any source missed. The reroll gate: a reroll is a fresh attack,\n   * so pass one as the damage. Kensei's Unerring Accuracy, Lucky.\n   */\n  onAnyMiss(damage: RiderDamage, options: RiderOptions = {}): Turn {\n    return this.rider({ ...options, damage, on: \"any-miss\" });\n  }\n\n  /**\n   * Fires once per source that lands, in that hit's mode — so it can fire several\n   * times in a turn. Hunter's Mark, Hex, Rage.\n   */\n  onEveryHit(damage: RiderDamage, options: RiderOptions = {}): Turn {\n    return this.rider({ ...options, damage, on: \"every-hit\" });\n  }\n\n  /**\n   * Damage for the turns where the rider added just before this one did *not*\n   * fire: \"flurry of blows if I didn't smite\".\n   *\n   * ```ts\n   * turn([dagger, dagger])\n   *   .onAnyCrit(roll(2, d8))      // smite\n   *   .otherwise([flurry, flurry]) // ... or two more attacks\n   * ```\n   *\n   * Always binds to the *immediately* preceding rider, so the two are branches of\n   * one decision and can never both land. Note that chaining it therefore\n   * alternates rather than laddering: `a.otherwise(b).otherwise(c)` makes `c`\n   * fire whenever `b` did not, which is exactly when `a` did. For a genuine\n   * three-way priority chain, name the riders and use explicit `not-fired`\n   * triggers against the right one.\n   */\n  otherwise(\n    damage: RiderDamage,\n    options: Omit<RiderOptions, \"of\"> = {}\n  ): Turn {\n    const index = this.riders.length - 1;\n    if (index < 0) {\n      throw new TurnSpecError(\n        \"unknown-id\",\n        \"\",\n        \"otherwise() needs a preceding rider to negate.\"\n      );\n    }\n    const previous = this.riders[index];\n    if (previous.on === \"every-hit\") {\n      throw new TurnSpecError(\n        \"not-an-attack\",\n        previous.id ?? `rider ${index + 1}`,\n        \"otherwise() cannot negate an every-hit rider: it can fire more than once.\"\n      );\n    }\n\n    // `of` must name the previous rider, so give it the id `buildPlan` would.\n    const target = previous.id ?? `rider ${index + 1}`;\n    const riders: Rider[] = [...this.riders];\n    riders[index] = { ...previous, id: target };\n    riders.push({ ...options, damage, on: \"not-fired\", of: target });\n    return new Turn(this.declaredAttacks, riders, this.eps);\n  }\n\n  /**\n   * The exact joint distribution: mass 1, outcome-labelled. Resolved once and\n   * cached.\n   *\n   * There is no `toPMF(eps)` to match the builders: a turn's epsilon is fixed\n   * when it is constructed, because the plan is validated and its sources are\n   * resolved at that point.\n   */\n  get pmf(): PMF {\n    return this.resolve().pmf;\n  }\n\n  /** Mean damage for the turn. */\n  mean(): number {\n    return this.pmf.mean();\n  }\n\n  /**\n   * A query whose `singles` are the **declared attacks** and whose combined\n   * distribution is the exact turn PMF.\n   *\n   * Riders are inside the combined PMF, not in `singles`, so singles-based\n   * helpers (`probAtLeastOne`, `countSinglesWith`, `outcomeStats`) describe the\n   * attacks only. Read rider-inclusive statistics off the combined PMF —\n   * `outcomeTotals`, `outcomeDamageRanges`, `damageAttributionChartModel`.\n   */\n  toQuery(): DiceQuery {\n    return new DiceQuery([...this.plan.attackPMFs], this.pmf, this.eps);\n  }\n\n  /**\n   * Attack ids in declaration order, including the `attack 1`, `attack 2`, …\n   * defaults given to bare sources. These are the names `of` accepts.\n   */\n  get attackIds(): readonly string[] {\n    return this.plan.attackIds;\n  }\n\n  /**\n   * Rider ids in declaration order, including the `rider 1`, `rider 2`, …\n   * defaults. These are the names {@link Turn.fireProbability} accepts.\n   */\n  get riderIds(): readonly string[] {\n    return this.plan.riderIds;\n  }\n\n  /**\n   * P(this rider fired). For an `every-hit` rider it is P(at least one source\n   * hit), since that rider can fire more than once in a turn.\n   *\n   * @throws {TurnSpecError} `unknown-id` if `id` is not a rider — attack ids\n   * included, since attacks always happen and have no firing probability.\n   */\n  fireProbability(id: string): number {\n    const mass = this.resolve().fireMass.get(id);\n    if (mass === undefined) {\n      throw new TurnSpecError(\n        \"unknown-id\",\n        id,\n        `\"${id}\" is not a rider in this turn. Riders: ${this.plan.riderIds\n          .map((each) => `\"${each}\"`)\n          .join(\", \")}.`\n      );\n    }\n    return mass;\n  }\n\n  private resolve(): { pmf: PMF; fireMass: ReadonlyMap<string, number> } {\n    if (this.resolved) return this.resolved;\n\n    const plan = this.plan;\n    const eps = this.eps;\n    const width = plan.groupCount;\n\n    // state key -> { codes, accumulated sub-mass damage, per-step firing }\n    type State = {\n      codes: number[];\n      pmf: PMF;\n      fired: FireMode[];\n    };\n\n    const start: State = {\n      codes: new Array<number>(width).fill(START_CODE),\n      pmf: PMF.delta(0, eps),\n      fired: new Array<FireMode>(plan.steps.length).fill(null),\n    };\n    let states = new Map<string, State>([[String.fromCharCode(), start]]);\n\n    plan.steps.forEach((step, stepIndex) => {\n      const next = new Map<string, State>();\n\n      const merge = (state: State): void => {\n        // Whether each rider fired is part of the state: two paths that agree on\n        // group codes but disagree on a rider's firing must not merge, or a\n        // `not-fired` rider downstream would see an ill-defined predicate.\n        //\n        // Only the fired/not-fired bit belongs in the key, though — nothing\n        // reads the mode back, and keying on it would split otherwise identical\n        // states and multiply the convolutions for no change in the result.\n        const key =\n          String.fromCharCode(...state.codes) +\n          \"\\u0001\" +\n          state.fired.map((mode) => (mode === null ? \"-\" : \"+\")).join(\"\");\n        const existing = next.get(key);\n        if (existing) existing.pmf = existing.pmf.add(state.pmf);\n        else next.set(key, state);\n      };\n\n      for (const state of states.values()) {\n        const mode = fireMode(step, state.codes, state.fired);\n        const fired = [...state.fired];\n        fired[stepIndex] = mode;\n\n        if (mode === null) {\n          merge({ codes: state.codes, pmf: state.pmf, fired });\n          continue;\n        }\n\n        if (!step.slices) {\n          const payload = step.damage as { hit: PMF; crit: PMF };\n          merge({\n            codes: state.codes,\n            pmf: state.pmf.convolve(\n              mode === \"crit\" ? payload.crit : payload.hit,\n              eps,\n              true\n            ),\n            fired,\n          });\n          continue;\n        }\n\n        for (const outcome of OUTCOMES) {\n          const slice = step.slices[outcome];\n          const sliceMass = slice.mass();\n          if (sliceMass <= eps) continue;\n\n          const codes = [...state.codes];\n          for (const group of step.updates) {\n            codes[group] = advance(codes[group], outcome);\n          }\n          merge({\n            codes,\n            pmf: state.pmf.convolve(slice, eps, true),\n            fired,\n          });\n        }\n      }\n\n      states = next;\n    });\n\n    // Collapse: sum every terminal state, and tally per-rider firing mass.\n    const fireMass = new Map<string, number>();\n    for (const id of plan.riderSteps.keys()) fireMass.set(id, 0);\n    for (const id of plan.perHitGroups.keys()) fireMass.set(id, 0);\n\n    let total: PMF | undefined;\n    for (const state of states.values()) {\n      total = total ? total.add(state.pmf) : state.pmf;\n      const mass = state.pmf.mass();\n      for (const [id, stepIndex] of plan.riderSteps) {\n        if (state.fired[stepIndex] !== null) {\n          fireMass.set(id, (fireMass.get(id) as number) + mass);\n        }\n      }\n      // `every-hit` riders have no step: they fired iff something landed.\n      for (const [id, group] of plan.perHitGroups) {\n        if (state.codes[group] >> 2 !== FIRST_NONE) {\n          fireMass.set(id, (fireMass.get(id) as number) + mass);\n        }\n      }\n    }\n\n    const pmf = total ?? PMF.delta(0, eps);\n    const totalMass = pmf.mass();\n    const needsNormalizing = Math.abs(totalMass - 1) > eps && totalMass > 0;\n\n    // Firing masses are accumulated in the same unnormalized units as the\n    // terminal states, so they have to follow the distribution through\n    // normalization or `fireProbability` stops agreeing with `pmf`. Reachable\n    // whenever a caller supplies a source PMF whose own mass is not 1.\n    if (needsNormalizing) {\n      for (const [id, mass] of fireMass) fireMass.set(id, mass / totalMass);\n    }\n\n    this.resolved = {\n      pmf: needsNormalizing ? pmf.normalize() : pmf,\n      fireMass,\n    };\n    return this.resolved;\n  }\n}\n\n/**\n * Starts a {@link Turn}. Takes one attack or a list of them, so the two common\n * shapes both read straight:\n *\n * ```ts\n * turn(greatsword).onAnyCrit(roll(4, d8));      // one attack\n * turn([dagger, dagger]).onFirstHit(roll(3, d6)); // two\n * turn().attacks(4, greatsword);                 // four\n * ```\n */\nexport function turn(\n  attacks: Attack | readonly Attack[] = [],\n  eps: number = EPS\n): Turn {\n  return Turn.from(\n    { attacks: Array.isArray(attacks) ? attacks : [attacks as Attack] },\n    eps\n  );\n}\n"]}