@yipe/dice 0.4.0 → 0.6.0

package/dist/index.d.ts

@@ -1,111 +1,9 @@
-import { P as PMF } from './pmf-D5VRghZI.js';
-export { A as ALL_OUTCOME_TYPES, B as Bin, C as CritConfig, D as DamageDistribution, l as DiceQuery, E as EPS, L as LRUCache, M as MISS_NONE_OUTCOME, d as OUTCOME_DISPLAY_ORDER, O as OutcomeLabelMap, m as OutcomeSnapshot, a as OutcomeType, b as RollType, R as Rounding, S as Snapshot, c as critProbability, o as onAnyHit, e as onCritOnly, f as onHitOnly, h as onMissDamageOnly, g as onMissOnly, k as onPotentCantripOnly, j as onSaveFailOnly, i as onSaveHalfOnly, p as pmfCache, s as sortOutcomes } from './pmf-D5VRghZI.js';
-
-/**
- * Bounce odds — the "birthday problem" for bouncing damage dice (e.g. Chromatic
- * Orb): the probability that at least two of K dice with S faces show the same
- * value, which is what lets the spell jump to another target.
- *
- * Accounts for two modifiers:
- * - **Elemental Adept** (`minimumDieRoll >= 2`): rolls below the minimum are
- *   bumped up to it, collapsing the low faces onto a single heavier value.
- * - **Empowered Spell** (`rerollDamageDice > 0`): a number of dice may be
- *   rerolled once, giving a second chance at a match.
- *
- * The base and Elemental-Adept cases are computed exactly (see
- * {@link pAllDistinct}); the Empowered-Spell reroll is an explicit model layered
- * on the exact base match probability.
- */
-/** Options that modify bounce odds via metamagic / feats. */
-interface BounceOddsOptions {
-    /** Minimum die roll — e.g. 2 for Elemental Adept, 3 for Great Weapon Fighting 2024. */
-    minimumDieRoll?: number;
-    /** Number of dice that may be rerolled once — e.g. CHA modifier for Empowered Spell. */
-    rerollDamageDice?: number;
-}
-/**
- * P(at least two of `diceCount` dice with `dieFaces` faces match), honoring
- * Elemental Adept and Empowered Spell. Returns a probability in [0, 1].
- *
- * @param diceCount Number of dice rolled.
- * @param dieFaces Faces per die (e.g. 8 for d8).
- * @param options Optional metamagic / feat modifiers.
- */
-declare function calculateBounceOdds(diceCount: number, dieFaces: number, options?: BounceOddsOptions): number;
-
-/**
- * Error thrown when a dice expression cannot be parsed.
- *
- * Extends the built-in {@link Error}, so existing `catch (e)` / message checks
- * continue to work, while callers can now narrow with `instanceof DiceParseError`.
- *
- * @example
- * try {
- *   parse("d6@3");
- * } catch (e) {
- *   if (e instanceof DiceParseError) {
- *     // e.expression === "d6@3"
- *   }
- * }
- */
-declare class DiceParseError extends Error {
-    /** The original expression that failed to parse, when available. */
-    readonly expression?: string;
-    /** The underlying error that triggered this one, when available. */
-    readonly cause?: unknown;
-    constructor(message: string, options?: {
-        expression?: string;
-        cause?: unknown;
-    });
-}
-
-/** Enable or disable the internal parse cache. */
-declare function setCachingEnabled(enabled: boolean): void;
-/** Returns whether the internal parse cache is currently enabled. */
-declare function getCachingEnabled(): boolean;
-/** Clears the internal parse cache. */
-declare function clearParserCache(): void;
-/**
- * Parse a dice expression into a PMF.
- *
- * - Expression is case-insensitive and ignores spaces.
- */
-declare function parse(expression: string, n?: number): PMF;
-
-/** A labeled mixture builder that preserves provenance in Bin.count. */
-declare class Mixture<L extends string = string> {
-    private readonly totals;
-    private readonly labelMass;
-    private readonly eps;
-    constructor(eps?: number);
-    /** Remove all accumulated state. */
-    clear(): this;
-    /** Number of distinct outcome values currently accumulated. */
-    size(): number;
-    /** Whether a label was ever added. */
-    hasLabel(label: L): boolean;
-    /**
-     * Add a labeled component with a mixture weight.
-     * Weight can be any positive finite number. Very small contributions are pruned by eps.
-     */
-    add(label: L, pmf: PMF, weight?: number): this;
-    buildPMF(eps?: number): PMF;
-    /**
-     * Produce normalized *per-label* PMFs (labels independent).
-     * These are unlabeled PMFs built from the raw mass of that label alone.
-     */
-    byOutcome(): Record<L, PMF>;
-    /**
-     * Mixture weights per label, normalized to sum to 1 over labels that appeared.
-     * Uses raw mass before per-outcome normalization.
-     */
-    weights(): Record<L, number>;
-    toJSON(): {
-        totals: Array<[number, number]>;
-        labels: Array<[number, Record<L, number>]>;
-        eps: number;
-    };
-    static mix<L extends string = string>(items: Array<[label: L, pmf: PMF, weight: number]>, eps?: number): PMF;
-}
-
-export { type BounceOddsOptions, DiceParseError, Mixture, PMF, calculateBounceOdds, clearParserCache, getCachingEnabled, parse, setCachingEnabled };
+export * from "./common/bounce.js";
+export * from "./common/errors.js";
+export * from "./common/lru-cache.js";
+export * from "./common/types.js";
+export * from "./parser/parser.js";
+export * from "./pmf/mixture.js";
+export * from "./pmf/pmf.js";
+export * from "./pmf/query.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,iBAAiB,CAAC;AAChC,cAAc,iBAAiB,CAAC;AAChC,cAAc,oBAAoB,CAAC;AACnC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,iBAAiB,CAAC;AAChC,cAAc,eAAe,CAAC;AAC9B,cAAc,WAAW,CAAC;AAC1B,cAAc,aAAa,CAAC"}

package/dist/parser/dice.d.ts

@@ -0,0 +1,70 @@
+import type { DamageDistribution, OutcomeType } from "../common/types.js";
+import { PMF } from "../pmf/pmf.js";
+/** Internal bookkeeping attached to a {@link Dice} during parsing. */
+export interface DicePrivateData {
+    /** Marks a DC (saving-throw) check so outcomes are attributed correctly. */
+    isDCCheck?: boolean;
+    /** The "other" distribution recorded by {@link Dice.combine}. */
+    except?: Dice | Record<string, never>;
+    /** Keep-highest/lowest selector applied when a die is multiplied out. */
+    keep?: (values: number[]) => number;
+}
+/**
+ * @internal
+ */
+export declare class Dice {
+    private readonly faces;
+    privateData: DicePrivateData;
+    private outcomeData;
+    private hasHitDistributionCalculated;
+    identifier?: string;
+    constructor(x?: number);
+    getOutcomeDistribution(key: OutcomeType): DamageDistribution | undefined;
+    getFullOutcomeDistribution(): Partial<Record<OutcomeType, DamageDistribution>>;
+    setOutcomeDistribution(key: OutcomeType, data: DamageDistribution | undefined): void;
+    hasOutcomeData(key: OutcomeType): boolean;
+    getOutcomeCount(key: OutcomeType, face: number): number;
+    getAverage(key: OutcomeType): number;
+    calculateHitDistribution(): DamageDistribution;
+    private ensureHitDistribution;
+    private binaryOp;
+    private removeFaces;
+    getFaceEntries(): [number, number][];
+    getFaceMap(): DamageDistribution;
+    get(face: number): number;
+    keys(): number[];
+    values(): number[];
+    total(): number;
+    setFace(key: number, value: number): void;
+    static scalar(value: number): Dice;
+    maxFace(): number;
+    minFace(): number;
+    increment(face: number, count: number): void;
+    normalize(scalar: number): Dice;
+    add(other: Dice | number): Dice;
+    subtract(other: Dice | number): Dice;
+    conditionalApply(other: Dice | number): Dice;
+    multiply(other: Dice | number): Dice;
+    addNonZero(other: Dice | number): Dice;
+    eq(other: Dice | number): Dice;
+    max(other: Dice | number): Dice;
+    min(other: Dice | number): Dice;
+    advantage(): Dice;
+    ge(other: Dice | number): Dice;
+    divide(other: Dice | number): Dice;
+    divideRoundUp(other: Dice | number): Dice;
+    divideRoundDown(other: Dice | number): Dice;
+    and(other: Dice | number): Dice;
+    private checkTarget;
+    dc(other: Dice | number): Dice;
+    ac(other: Dice | number): Dice;
+    deleteFace(face: number): Dice;
+    reroll(toReroll: Dice | number): Dice;
+    combine(other: Dice | number): Dice;
+    combineInPlace(other: Dice): void;
+    percent(): DamageDistribution;
+    average(): number;
+    toPMF(numEpsilon?: number): PMF;
+}
+export type _DiceInternal = never;
+//# sourceMappingURL=dice.d.ts.map

package/dist/parser/dice.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dice.d.ts","sourceRoot":"","sources":["../../src/parser/dice.ts"],"names":[],"mappings":"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"}

package/dist/parser/parser.d.ts

@@ -0,0 +1,14 @@
+import type { PMF } from "../pmf/pmf.js";
+/** Enable or disable the internal parse cache. */
+export declare function setCachingEnabled(enabled: boolean): void;
+/** Returns whether the internal parse cache is currently enabled. */
+export declare function getCachingEnabled(): boolean;
+/** Clears the internal parse cache. */
+export declare function clearParserCache(): void;
+/**
+ * Parse a dice expression into a PMF.
+ *
+ * - Expression is case-insensitive and ignores spaces.
+ */
+export declare function parse(expression: string, n?: number): PMF;
+//# sourceMappingURL=parser.d.ts.map

package/dist/parser/parser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parser.d.ts","sourceRoot":"","sources":["../../src/parser/parser.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,YAAY,CAAC;AA2BtC,kDAAkD;AAClD,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CAGxD;AAED,qEAAqE;AACrE,wBAAgB,iBAAiB,IAAI,OAAO,CAE3C;AAED,uCAAuC;AACvC,wBAAgB,gBAAgB,IAAI,IAAI,CAEvC;AAED;;;;GAIG;AACH,wBAAgB,KAAK,CAAC,UAAU,EAAE,MAAM,EAAE,CAAC,GAAE,MAAU,GAAG,GAAG,CAyC5D"}

package/dist/pmf/mixture.d.ts

@@ -0,0 +1,37 @@
+import { PMF } from "./pmf.js";
+/** A labeled mixture builder that preserves provenance in Bin.count. */
+export declare class Mixture<L extends string = string> {
+    private readonly totals;
+    private readonly labelMass;
+    private readonly eps;
+    constructor(eps?: number);
+    /** Remove all accumulated state. */
+    clear(): this;
+    /** Number of distinct outcome values currently accumulated. */
+    size(): number;
+    /** Whether a label was ever added. */
+    hasLabel(label: L): boolean;
+    /**
+     * Add a labeled component with a mixture weight.
+     * Weight can be any positive finite number. Very small contributions are pruned by eps.
+     */
+    add(label: L, pmf: PMF, weight?: number): this;
+    buildPMF(eps?: number): PMF;
+    /**
+     * Produce normalized *per-label* PMFs (labels independent).
+     * These are unlabeled PMFs built from the raw mass of that label alone.
+     */
+    byOutcome(): Record<L, PMF>;
+    /**
+     * Mixture weights per label, normalized to sum to 1 over labels that appeared.
+     * Uses raw mass before per-outcome normalization.
+     */
+    weights(): Record<L, number>;
+    toJSON(): {
+        totals: Array<[number, number]>;
+        labels: Array<[number, Record<L, number>]>;
+        eps: number;
+    };
+    static mix<L extends string = string>(items: Array<[label: L, pmf: PMF, weight: number]>, eps?: number): PMF;
+}
+//# sourceMappingURL=mixture.d.ts.map

package/dist/pmf/mixture.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mixture.d.ts","sourceRoot":"","sources":["../../src/pmf/mixture.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,GAAG,EAAE,MAAM,OAAO,CAAC;AAE5B,wEAAwE;AACxE,qBAAa,OAAO,CAAC,CAAC,SAAS,MAAM,GAAG,MAAM;IAC5C,OAAO,CAAC,QAAQ,CAAC,MAAM,CAA6B;IACpD,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAwC;IAClE,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAS;IAE7B,YAAY,GAAG,GAAE,MAAY,EAE5B;IAED,oCAAoC;IACpC,KAAK,IAAI,IAAI,CAIZ;IAED,+DAA+D;IAC/D,IAAI,IAAI,MAAM,CAEb;IAED,sCAAsC;IACtC,QAAQ,CAAC,KAAK,EAAE,CAAC,GAAG,OAAO,CAG1B;IAED;;;OAGG;IACH,GAAG,CAAC,KAAK,EAAE,CAAC,EAAE,GAAG,EAAE,GAAG,EAAE,MAAM,SAAI,GAAG,IAAI,CAkBxC;IAED,QAAQ,CAAC,GAAG,GAAE,MAAY,GAAG,GAAG,CAmB/B;IAED;;;OAGG;IACH,SAAS,IAAI,MAAM,CAAC,CAAC,EAAE,GAAG,CAAC,CAiB1B;IAED;;;OAGG;IACH,OAAO,IAAI,MAAM,CAAC,CAAC,EAAE,MAAM,CAAC,CAqB3B;IAED,MAAM,IAAI;QACR,MAAM,EAAE,KAAK,CAAC,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;QAChC,MAAM,EAAE,KAAK,CAAC,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,EAAE,MAAM,CAAC,CAAC,CAAC,CAAC;QAC3C,GAAG,EAAE,MAAM,CAAC;KACb,CAMA;IAED,MAAM,CAAC,GAAG,CAAC,CAAC,SAAS,MAAM,GAAG,MAAM,EAClC,KAAK,EAAE,KAAK,CAAC,CAAC,KAAK,EAAE,CAAC,EAAE,GAAG,EAAE,GAAG,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC,EAClD,GAAG,GAAE,MAAY,GAChB,GAAG,CAIL;CACF"}

package/dist/pmf/pmf.d.ts

@@ -0,0 +1,380 @@
+import { LRUCache } from "../common/lru-cache.js";
+import type { Bin, Rounding } from "../common/types.js";
+import { DiceQuery } from "./query.js";
+export declare const pmfCache: LRUCache<string, PMF>;
+/**
+ * Probability Mass Function for discrete damage distributions.
+ */
+export declare class PMF {
+    readonly map: Map<number, Bin>;
+    readonly epsilon: number;
+    readonly normalized: boolean;
+    readonly identifier: string;
+    private _preservedProvenance;
+    private static __anonIdCounter;
+    private _support?;
+    private _min?;
+    private _max?;
+    private _totalMass?;
+    private _mean?;
+    private _variance?;
+    private _stdev?;
+    private _fingerprint?;
+    constructor(map?: Map<number, Bin>, epsilon?: number, normalized?: boolean, identifier?: string, _preservedProvenance?: boolean);
+    static empty(epsilon?: number, identifier?: string): PMF;
+    static zero(epsilon?: number): PMF;
+    static delta(value: number, epsilon?: number): PMF;
+    /**
+     * Point mass at damage 0 tagged with the canonical `missNone` outcome.
+     *
+     * Differs from {@link PMF.zero}, which labels its zero bin `miss` — the
+     * builder's attack-resolution vocabulary. This uses the `missNone`
+     * {@link OutcomeType} that the attribution charts and outcome stats key on,
+     * so it is the correct "clean miss / no damage" delta for provenance-aware
+     * mixtures feeding those consumers.
+     */
+    static missNone(epsilon?: number): PMF;
+    static emptyMass(): PMF;
+    [Symbol.iterator](): IterableIterator<[number, Bin]>;
+    static clearCache(): void;
+    /**
+     * Creates a conditional PMF from two branches (success and failure) and a probability.
+     * This is the core logic for modeling any probabilistic event where there are two
+     * distinct outcomes.
+     */
+    static branch(successPMF: PMF, failurePMF: PMF, successProbability: number): PMF;
+    /**
+     * withProbability()
+     *
+     * A convenience wrapper around branch() for the common case where the "failure" branch is always zero().
+     *
+     *  Think of this as a shortcut for:
+     *    pmf.gate(p, PMF.zero())
+     *
+     * Use this to model a *single* Bernoulli event — an outcome that either happens or doesn't,
+     * like an opportunity attack that occurs with probability p, or a single attack that either hits or misses.
+     *
+     * This is **not** for combining multiple independent attacks or mutually exclusive multi-outcome scenarios.
+     * - For multiple independent swings, use DiceQuery with separate PMFs for each attack.
+     * - For modeling "first success" logic across multiple attacks (like Sneak Attack or Smite)
+     *   use query.firstSuccessSplit() to get the exact probabilities.
+     * - For scenarios with several mutually exclusive outcomes (like crit vs hit vs none), use PMF.exclusive().
+     *
+     */
+    static withProbability(successPMF: PMF, probability: number): PMF;
+    /**
+     * gate()
+     *
+     * A conditional wrapper around branch() that applies this PMF with probability `p`,
+     * and applies a provided fallback PMF otherwise.
+     *
+     * This is useful for modeling a binary choice between two outcomes:
+     * - The "success" outcome (this PMF) happens with probability `p`.
+     * - The "failure" outcome (fallback PMF) happens with probability `1 - p`.
+     *
+     * Examples:
+     * - 25% chance to include an opportunity attack, otherwise nothing:
+     *     attackPMF.gate(0.25, PMF.zero())
+     *
+     * - 50% chance to deal fireball damage, otherwise cone of cold damage:
+     *     fireballPMF.gate(0.5, coneOfColdPMF)
+     *
+     * Relationship to other helpers:
+     * - **withProbability()** is a shortcut for the common case where the fallback is `PMF.zero()`.
+     * - **exclusive()** is for three or more mutually exclusive outcomes (e.g., crit vs hit vs none).
+     *
+     * @param p Probability of applying this PMF (between 0 and 1).
+     * @param fallback PMF to apply when this PMF is *not* selected.
+     * @returns A new PMF representing the weighted mixture of this PMF and the fallback.
+     */
+    gate(p: number, fallback: PMF): PMF;
+    /**
+     * PMF.exclusive()
+     *
+     * Builds a single PMF from a set of mutually exclusive weighted outcomes.
+     * Exactly one of the provided options will occur.
+     *
+     * Each option has:
+     *  - A PMF representing its outcome (e.g., damage dice).
+     *  - A weight representing its probability of being selected.
+     *
+     * Notes:
+     *  - If total weight < 1 (within eps), leftover mass is assumed to be PMF.zero()
+     *
+     * @param options Array of `{ pmf, weight }` or `[PMF, number]`.
+     * @param eps Optional tolerance for floating point rounding.
+     */
+    static exclusive(options: Array<{
+        pmf: PMF;
+        weight: number;
+    } | [PMF, number]>, eps?: number): PMF;
+    /**
+     * PMF.mix()
+     *
+     * Builds a PMF as a linear combination of input PMFs with the given weights.
+     * Unlike `exclusive`, this does NOT:
+     *  - enforce that weights sum to 1
+     *  - add leftover probability to δ0 (PMF.zero())
+     *
+     * Use when outcomes are not mutually exclusive, or for interpolation/blending.
+     *
+     * @param options Array of `{ pmf, weight }` or `[PMF, number]`.
+     * @param eps Optional tolerance for skipping tiny weights.
+     */
+    static mix(options: Array<{
+        pmf: PMF;
+        weight: number;
+    } | [PMF, number]>, eps?: number): PMF;
+    /**
+     * Adds damage attribution metadata to this PMF based on existing count metadata.
+     * For each bin, sets attr[outcome] = damage × count[outcome].
+     *
+     * This enables damage attribution charts to work with builder-generated PMFs.
+     * The parser generates attr automatically, but builder PMFs only have count.
+     *
+     * @returns New PMF with attr field populated in each bin
+     */
+    /**
+     * Returns true if this PMF already carries damage attribution metadata.
+     *
+     * Only the first positive-damage bin is inspected (parser-generated PMFs
+     * populate `attr` uniformly), so this is O(1) in practice.
+     */
+    hasAttribution(): boolean;
+    withAttribution(): PMF;
+    /**
+     * General-purpose N-way mixture.
+     * weights: Array of [weight, PMF].
+     *
+     * Example: PMF.mixN([
+     *   [pMiss, zero],
+     *   [pHit, hitPMF],
+     *   [pCrit, critPMF],
+     * ]);
+     */
+    static mixN(weights: [number, PMF][], eps?: number): PMF;
+    private setPreservedProvenance;
+    preservedProvenance(): boolean;
+    private getPowerCacheKey;
+    /**
+     * Efficiently computes this PMF convolved with itself `n` times.
+     * Uses exponentiation by squaring to reduce total convolutions.
+     * n must be a positive integer.
+     * *
+     * * NOTE: This folds multiple independent attacks into a single PMF.
+     * As a result, The power() method causes a loss of data provenance.
+     * This is ONLY SAFE if you are trying to calculate masses.
+     * If you want to query any atLeast probabilities, you should use the DiceQuery class instead without power().
+     */
+    power(n: number, eps?: number): PMF;
+    replicate(n: number): PMF[];
+    mass(): number;
+    outcomeMass(outcome: string): number;
+    faceTotal(): number;
+    normalize(): PMF;
+    /**
+     * Returns a copy with negligible probabilities removed (p < eps).
+     * If keepFinalBin is true, the bin with the largest key is always kept,
+     * even if its probability is below eps. count/attr submaps are still cleaned.
+     */
+    compact(eps?: number, keepFinalBin?: boolean): PMF;
+    support(): number[];
+    min(): number;
+    max(): number;
+    /**
+     * Returns the expected (mean) damage value.
+     * Cached for performance since this requires iterating through all bins.
+     */
+    mean(): number;
+    /**
+     * Returns the variance of the damage distribution.
+     * Cached for performance since this requires mean calculation plus iteration.
+     */
+    variance(): number;
+    /**
+     * Returns the standard deviation of the damage distribution.
+     */
+    stdev(): number;
+    /** Deep-copies a Bin, cloning its count and (optional) attr maps. */
+    private static cloneBin;
+    /** Returns a new Bin with p, count, and attr all multiplied by `factor`. */
+    private static scaleBin;
+    private static mergeInto;
+    add(other: PMF): PMF;
+    /**
+     * Returns a new PMF with a scaled branch added to this one.
+     * The branch PMF is scaled by the given probability before merging
+     * This will be very useful for conditional effects and for being
+     * able to model "I can probably have this opportunity attack 40% of rounds"
+     * Example: `pmf.addScaled(critBranch, 0.05)` → PMF including 5% crit outcomes
+     */
+    addScaled(branch: PMF, probability: number): PMF;
+    /**
+     * Redistributes probability mass to model an effect that only occurs with
+     * probability `frequency` — a conditional attack, an on-hit rider, or a
+     * sub-one AoE target fraction.
+     *
+     * Every hit outcome (damage > 0) is scaled by `frequency` — probability mass,
+     * per-label `count`, AND per-label `attr` — and the freed mass is moved into
+     * the miss bin at damage 0, tagged with the canonical `missNone` outcome.
+     * Total probability mass is preserved.
+     *
+     * Unlike a bare {@link scaleMass} or {@link mapDamage}, this keeps damage
+     * attribution (`attr`) intact, so a frequency-scaled PMF still renders
+     * correctly in the damage-attribution charts.
+     *
+     * `frequency >= 1` (or non-finite) returns this PMF unchanged; `frequency <= 0`
+     * collapses all mass into the miss bin. The miss outcome is assumed to be
+     * encoded at damage value 0.
+     *
+     * @param frequency Probability in [0, 1] that the effect occurs.
+     */
+    applyHitFrequency(frequency: number): PMF;
+    scaleMass(factor: number): PMF;
+    mapDamage(damageTransformFunction: (damageValue: number) => number): PMF;
+    scaleDamage(factor: number, rounding?: "floor" | "round" | "ceil"): PMF;
+    private getPMFCombineCacheKey;
+    /**
+     * A small content fingerprint (mass + bin count + face sum) so convolution
+     * cache keys change if the underlying numbers do. Memoized because a PMF is
+     * immutable once constructed — this avoids re-summing every key on each
+     * convolve() call (including cache hits).
+     */
+    fingerprint(): string;
+    convolve(other: PMF, eps?: number, raw?: boolean): PMF;
+    combineRaw(other: PMF, eps?: number): PMF;
+    private static reduceConvolveLeft;
+    /**
+     * Convolves multiple PMFs using linear convolution with automatic caching.
+     * Uses a left-to-right accumulation approach for maximum cache reuse.
+     * Each convolve() call automatically uses the convolution cache for performance.
+     *
+     * This linear approach provides better cache hits than pairwise because:
+     * - Intermediate results are more predictable and stable
+     * - Similar PMF lists share common prefixes (A+B, (A+B)+C, etc.)
+     * - Order-independent cache keys work better with consistent build patterns
+     */
+    static convolveMany(pmfList: PMF[], eps?: number): PMF;
+    /**
+     * Returns a plain, JSON-serializable representation of this PMF.
+     *
+     * Follows the standard `toJSON` contract, so `JSON.stringify(pmf)` produces
+     * the expected output (no double-encoding). Use {@link PMF.fromJSON} to
+     * reconstruct, or {@link PMF.toJSONString} if you need the string directly.
+     */
+    toJSON(): {
+        bins: Array<[number, Bin]>;
+        normalized: boolean;
+        identifier: string;
+    };
+    /** Serializes this PMF to a JSON string (equivalent to `JSON.stringify(pmf)`). */
+    toJSONString(): string;
+    static fromJSON(jsonData: {
+        bins: Array<[number, Bin]>;
+        normalized?: boolean;
+        identifier?: string;
+    }): PMF;
+    /**
+     * Relative pruning with optional top-K floor.
+     * Keeps bins with p >= epsRel * peak, always keeps min and max damage,
+     * optionally guarantees at least `minBins` survivors by adding top-K.
+     * Returns a new, non-normalized PMF.
+     */
+    prune(epsRel: number, minBins?: number): PMF;
+    /** Probability mass at exactly x. */
+    pAt(x: number): number;
+    /**
+     * P(any damage) — the mass on all non-zero outcomes, i.e. `1 - P(0)`.
+     * Assumes a miss is encoded as the damage-0 bin (the convention used across
+     * attack/save PMFs). The dual of {@link missProbability}.
+     */
+    hitProbability(): number;
+    /** P(no damage) — the mass at damage 0. The dual of {@link hitProbability}. */
+    missProbability(): number;
+    /**
+     * Coarsen the distribution into at most `maxBuckets` contiguous, equal-width
+     * damage buckets, aggregating probability mass (and `count`/`attr`
+     * provenance) into each bucket's start value. Returns this PMF unchanged when
+     * its integer support already fits within `maxBuckets`.
+     *
+     * This is a lossy display/downsampling transform (bucket start replaces the
+     * exact damage value) — use it for charting wide distributions, not for DPR
+     * math.
+     */
+    rebin(maxBuckets: number): PMF;
+    /** Dense integer support from min..max (inclusive).
+     * Useful for showing empty bars in charts.
+     */
+    denseSupport(): number[];
+    /** CDF at x: P(X ≤ x). */
+    cdfAt(x: number): number;
+    /** Quantile / inverse CDF for p in [0,1]. Returns smallest x with CDF ≥ p. */
+    quantile(p: number): number;
+    /** Get outcome probability at specific damage value. */
+    outcomeAt(damage: number, outcome: string): number;
+    /** Get all outcome types present in this PMF. */
+    outcomes(): string[];
+    /** Get total probability of an outcome across all damage values. */
+    outcomeProbability(outcome: string): number;
+    /** Get damage attribution for an outcome at specific damage value. */
+    outcomeAttributionAt(damage: number, outcome: string): number;
+    /** Get all outcome data at specific damage value. */
+    binAt(damage: number): {
+        p: number;
+        count: Record<string, number>;
+        attr?: Record<string, number>;
+    } | null;
+    /** Check if outcome exists in this PMF. */
+    hasOutcome(outcome: string): boolean;
+    /**
+     * Split each damage value's probability mass across outcome labels, returning
+     * per-label maps of `damage value → probability mass attributable to that
+     * label`. Summing over labels at a given value recovers that value's `p`.
+     *
+     * Damage-bearing bins are split by `attr` weight (the share of damage each
+     * outcome contributed); the clean-miss bin at 0 is split by `count` weight
+     * (there is no damage to attribute). Attribution is computed on demand via
+     * {@link withAttribution} when absent, so builder-generated PMFs work too.
+     *
+     * This is the provenance core of the stacked damage-attribution chart — the
+     * caller only maps these series into its rendering format (colors, binning,
+     * axis labels).
+     */
+    attributionByValue(): Map<string, Map<number, number>>;
+    tailProbGE(t: number): number;
+    tailProbGT(t: number): number;
+    /**
+     * Returns a new PMF containing only bins where the specified outcome has non-zero probability.
+     * This creates a marginal distribution for the given outcome type, with probabilities
+     * scaled to represent the unconditional mass attributable to that outcome.
+     */
+    filterOutcome(outcome: string): PMF;
+    /**
+     * Calculates probabilities for first-success outcomes across n independent attempts.
+     *
+     * @param pSuccess - Total probability of any success on a single attempt.
+     * @param pSpecial - Probability of a specific subset of successes (e.g., critical success).
+     * @param n - Number of independent attempts.
+     *
+     * Returns:
+     *  - pSpecificSuccess: Probability that the first success was of the "special" type
+     *  - pGeneralSuccess: Probability that the first success was of the non-special type
+     *  - pNone: Probability that no successes occurred
+     *  - pAny: Probability that at least one success occurred
+     */
+    static firstSuccessWeights(pSuccess: number, pSpecial: number, n: number): {
+        pSpecificSuccess: number;
+        pGeneralSuccess: number;
+        pNone: number;
+        pAny: number;
+    };
+    mapValues(f: (v: number) => number, eps?: number, opts?: {
+        rounding?: Rounding;
+        preserveCounts?: boolean;
+    }): PMF;
+    static fromMap(m: Map<number, number>, eps?: number, { requireIntegerValues }?: {
+        requireIntegerValues?: boolean;
+    }): PMF;
+    query(): DiceQuery;
+}
+//# sourceMappingURL=pmf.d.ts.map

package/dist/pmf/pmf.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pmf.d.ts","sourceRoot":"","sources":["../../src/pmf/pmf.ts"],"names":[],"mappings":"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"}