@yipe/dice 0.2.23 → 0.3.0

package/dist/{pmf-BC1poIqF.d.cts → pmf-DqUCnYN9.d.cts}

@@ -57,9 +57,20 @@ declare const onPotentCantripOnly: OutcomeType[];
  */
 declare class DiceQuery {
     readonly singles: PMF[];
-    readonly combined: PMF;
+    private readonly _eps;
+    private readonly _combinedProvided;
+    private _combined?;
     private _combinedWithAttr?;
     constructor(singles: PMF | PMF[], combined?: PMF, eps?: number);
+    /**
+     * The combined damage distribution of all single PMFs (their convolution),
+     * normalized to total probability 1.
+     *
+     * Computed lazily on first access and cached. Queries that only need
+     * additive statistics — {@link DiceQuery.mean}, {@link DiceQuery.variance},
+     * {@link DiceQuery.stddev} — never trigger this convolution.
+     */
+    get combined(): PMF;
     private static readonly DEFAULT_OUTCOMES;
     /**
      * Returns a new PMF with damage attribution metadata populated.
@@ -104,6 +115,8 @@ declare class DiceQuery {
      * Used to determine how consistent the damage is.
      */
     stddev(): number;
+    /** Alias of {@link DiceQuery.stddev}, matching {@link PMF.stdev}. */
+    stdev(): number;
     /**
      * Returns the Cumulative Distribution Function.
      */
@@ -148,6 +161,18 @@ declare class DiceQuery {
      */
     max(): number;
     private singleProb;
+    /**
+     * Full count distribution [P(0), P(1), …, P(n)] for "an attack succeeds if it
+     * carries ANY of `labels`", over the n independent singles.
+     *
+     * Each single's per-event success probability is the Poisson-binomial
+     * marginal P(≥1 of labels) from {@link probabilityOf} (i.e. probAtLeastOne),
+     * computed exactly once. The binomial DP then runs once to produce the whole
+     * distribution, so the array-label paths of probExactlyK / probAtLeastK /
+     * probAtMostK can slice or sum from it instead of rebuilding a DiceQuery and
+     * re-running the DP per requested k.
+     */
+    private countDistribution;
     probAtLeastK(labels: OutcomeType | OutcomeType[], k: number): number;
     /**
      * Returns the probability that at least one attack has the specified outcome(s).
@@ -192,7 +217,7 @@ declare class DiceQuery {
      * Array examples:
      * - probExactlyK(['hit', 'crit'], 2) = probability exactly 2 attacks succeed
      * - probExactlyK(['hit', 'crit'], 1) = probability exactly 1 attack succeeds
-     * - probExactlyK(['miss', 'missNone'], 0) = probability no attacks miss
+     * - probExactlyK(['missDamage', 'missNone'], 0) = probability no attacks miss
      *
      * Use cases:
      * - "What's the chance exactly one of my attacks hits?"
@@ -209,7 +234,7 @@ declare class DiceQuery {
      * Single label examples:
      * - probAtMostK('hit', 1) = probability 0 or 1 attacks hit (at most 1)
      * - probAtMostK('crit', 0) = probability no attacks crit
-     * - probAtMostK('miss', 2) = probability at most 2 attacks miss
+     * - probAtMostK('missDamage', 2) = probability at most 2 attacks miss
      *
      * Array examples:
      * - probAtMostK(['hit', 'crit'], 1) = probability at most 1 attack succeeds
@@ -253,7 +278,7 @@ declare class DiceQuery {
      *
      * Array examples:
      * - damageStatsFrom(['hit', 'crit']) = damage range when at least one attack succeeds
-     * - damageStatsFrom(['miss', 'missNone']) = damage range when at least one attack misses
+     * - damageStatsFrom(['missDamage', 'missNone']) = damage range when at least one attack misses
      *
      * Tactical Use Cases:
      * - "Given that I don't completely whiff (99% of turns), what damage should I expect?"
@@ -271,6 +296,12 @@ declare class DiceQuery {
      * This includes mixed scenarios (2 hits + 1 crit, 3 hits + 1 miss, etc.) which
      * occur far more frequently than pure scenarios. For pure scenarios, use combinedDamageStats.
      *
+     * KNOWN LIMITATION (multi-attack, single label): the returned `count` is an
+     * EXPECTED COUNT (E[#label], so > 1 for N≥2 attacks, not a probability), and
+     * `avg` is the size-biased conditional mean E[dmg·#label]/E[#label] rather than
+     * E[dmg | the label occurs]. For a single attack both are the plain
+     * conditional figures. Use {@link probAtLeastOne} for the scenario probability.
+     *
      * @example
      * // High-level tactical planning
      * const successStats = query.damageStatsFrom('hit')
@@ -335,7 +366,8 @@ declare class DiceQuery {
         count: number;
     };
     /**
-     * Returns the probability that a result includes ANY of the specified labels.
+     * Returns the probability that at least one attack carries ANY of the
+     * specified labels (the marginal P(≥1) across the independent attacks).
      *
      * Examples:
      * - `query.probabilityOf('hit')` → 0.88 (probability at least one hit occurs)
@@ -344,6 +376,12 @@ declare class DiceQuery {
      * Use cases:
      * - "What's the chance my resolution includes a success label?"
      * - "How likely am I to get any hits or crits across all attacks?"
+     *
+     * Note: this must NOT be computed by summing `combined` bin probabilities. A
+     * single combined damage total is reachable by many outcome combinations and
+     * a bin can hold several labels at once, so summing `bin.p` over bins that
+     * contain a label over-counts. The correct marginal is the Poisson-binomial
+     * complement over the per-attack probabilities, i.e. {@link probAtLeastOne}.
      */
     probabilityOf(labels: OutcomeType | OutcomeType[]): number;
     /**
@@ -525,6 +563,16 @@ declare class DiceQuery {
      * Snapshot of the distribution in the exact shape the UI consumes.
      * - outcome probabilities are "at least one" (and equal to "all" for a single PMF)
      * - damageRange is conditional on the outcome occurring
+     *
+     * The outcome probabilities use the correct Poisson-binomial marginals
+     * (`atLeastOneProbability` = P(≥1 attack has it), `allProbability` = P(all do)),
+     * so they are always valid probabilities in [0,1].
+     *
+     * KNOWN LIMITATION (multi-attack): `damageRange.avg` is still aggregated from
+     * the combined PMF's `count`, which the convolution accumulates as an EXPECTED
+     * COUNT, so for N≥2 attacks it is the size-biased mean E[dmg·#label]/E[#label]
+     * rather than a clean conditional expectation. It is correct for a single
+     * attack.
      */
     snapshot(order?: readonly OutcomeType[]): Snapshot;
     /**
@@ -629,7 +677,7 @@ declare class DiceQuery {
      *
      * Returns tuple: [pFirstNonSubset, pFirstSubset, pAnySuccess, pNone]
      */
-    firstSuccessSplit(successOutcome: string | string[], subsetOutcome: string | string[], eps?: number): readonly [pSuccess: number, pSubset: number, pAny: number, pNone: number];
+    firstSuccessSplit(successOutcome: OutcomeType | OutcomeType[], subsetOutcome: OutcomeType | OutcomeType[], eps?: number): readonly [pSuccess: number, pSubset: number, pAny: number, pNone: number];
 }
 type OutcomeSnapshot = {
     atLeastOneProbability: number;
@@ -669,6 +717,7 @@ declare class PMF {
     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;
@@ -726,7 +775,7 @@ declare class PMF {
      * @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, zero: PMF): PMF;
+    gate(p: number, fallback: PMF): PMF;
     /**
      * PMF.exclusive()
      *
@@ -773,6 +822,13 @@ declare class PMF {
      *
      * @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.
@@ -827,6 +883,10 @@ declare class PMF {
      * 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;
     /**
@@ -841,6 +901,13 @@ declare class 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;
@@ -855,7 +922,20 @@ declare class PMF {
      * - Order-independent cache keys work better with consistent build patterns
      */
     static convolveMany(pmfList: PMF[], eps?: number): PMF;
-    toJSON(): string;
+    /**
+     * 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;
@@ -868,7 +948,6 @@ declare class PMF {
      * Returns a new, non-normalized PMF.
      */
     prune(epsRel: number, minBins?: number): PMF;
-    /** NEW - REVIEW IF THESE ARE USEFUL OR DUPLCIATIVE?  */
     /** Probability mass at exactly x. */
     pAt(x: number): number;
     /** Dense integer support from min..max (inclusive).
@@ -932,4 +1011,4 @@ declare class PMF {
     query(): DiceQuery;
 }
 
-export { type Bin as B, type CritConfig as C, type DamageDistribution as D, EPS as E, LRUCache as L, type OutcomeLabelMap as O, PMF as P, type Rounding as R, type Snapshot as S, type OutcomeType as a, onCritOnly as b, onHitOnly as c, onMissOnly as d, onMissDamageOnly as e, onSaveHalfOnly as f, onSaveFailOnly as g, onPotentCantripOnly as h, DiceQuery as i, type OutcomeSnapshot as j, onAnyHit as o, pmfCache as p };
+export { type Bin as B, type CritConfig as C, DiceQuery as D, EPS as E, LRUCache as L, type OutcomeLabelMap as O, PMF as P, type Rounding as R, type Snapshot as S, type DamageDistribution as a, type OutcomeSnapshot as b, type OutcomeType as c, onCritOnly as d, onHitOnly as e, onMissDamageOnly as f, onMissOnly as g, onPotentCantripOnly as h, onSaveFailOnly as i, onSaveHalfOnly as j, onAnyHit as o, pmfCache as p };

package/dist/{pmf-BC1poIqF.d.ts → pmf-DqUCnYN9.d.ts}

@@ -57,9 +57,20 @@ declare const onPotentCantripOnly: OutcomeType[];
  */
 declare class DiceQuery {
     readonly singles: PMF[];
-    readonly combined: PMF;
+    private readonly _eps;
+    private readonly _combinedProvided;
+    private _combined?;
     private _combinedWithAttr?;
     constructor(singles: PMF | PMF[], combined?: PMF, eps?: number);
+    /**
+     * The combined damage distribution of all single PMFs (their convolution),
+     * normalized to total probability 1.
+     *
+     * Computed lazily on first access and cached. Queries that only need
+     * additive statistics — {@link DiceQuery.mean}, {@link DiceQuery.variance},
+     * {@link DiceQuery.stddev} — never trigger this convolution.
+     */
+    get combined(): PMF;
     private static readonly DEFAULT_OUTCOMES;
     /**
      * Returns a new PMF with damage attribution metadata populated.
@@ -104,6 +115,8 @@ declare class DiceQuery {
      * Used to determine how consistent the damage is.
      */
     stddev(): number;
+    /** Alias of {@link DiceQuery.stddev}, matching {@link PMF.stdev}. */
+    stdev(): number;
     /**
      * Returns the Cumulative Distribution Function.
      */
@@ -148,6 +161,18 @@ declare class DiceQuery {
      */
     max(): number;
     private singleProb;
+    /**
+     * Full count distribution [P(0), P(1), …, P(n)] for "an attack succeeds if it
+     * carries ANY of `labels`", over the n independent singles.
+     *
+     * Each single's per-event success probability is the Poisson-binomial
+     * marginal P(≥1 of labels) from {@link probabilityOf} (i.e. probAtLeastOne),
+     * computed exactly once. The binomial DP then runs once to produce the whole
+     * distribution, so the array-label paths of probExactlyK / probAtLeastK /
+     * probAtMostK can slice or sum from it instead of rebuilding a DiceQuery and
+     * re-running the DP per requested k.
+     */
+    private countDistribution;
     probAtLeastK(labels: OutcomeType | OutcomeType[], k: number): number;
     /**
      * Returns the probability that at least one attack has the specified outcome(s).
@@ -192,7 +217,7 @@ declare class DiceQuery {
      * Array examples:
      * - probExactlyK(['hit', 'crit'], 2) = probability exactly 2 attacks succeed
      * - probExactlyK(['hit', 'crit'], 1) = probability exactly 1 attack succeeds
-     * - probExactlyK(['miss', 'missNone'], 0) = probability no attacks miss
+     * - probExactlyK(['missDamage', 'missNone'], 0) = probability no attacks miss
      *
      * Use cases:
      * - "What's the chance exactly one of my attacks hits?"
@@ -209,7 +234,7 @@ declare class DiceQuery {
      * Single label examples:
      * - probAtMostK('hit', 1) = probability 0 or 1 attacks hit (at most 1)
      * - probAtMostK('crit', 0) = probability no attacks crit
-     * - probAtMostK('miss', 2) = probability at most 2 attacks miss
+     * - probAtMostK('missDamage', 2) = probability at most 2 attacks miss
      *
      * Array examples:
      * - probAtMostK(['hit', 'crit'], 1) = probability at most 1 attack succeeds
@@ -253,7 +278,7 @@ declare class DiceQuery {
      *
      * Array examples:
      * - damageStatsFrom(['hit', 'crit']) = damage range when at least one attack succeeds
-     * - damageStatsFrom(['miss', 'missNone']) = damage range when at least one attack misses
+     * - damageStatsFrom(['missDamage', 'missNone']) = damage range when at least one attack misses
      *
      * Tactical Use Cases:
      * - "Given that I don't completely whiff (99% of turns), what damage should I expect?"
@@ -271,6 +296,12 @@ declare class DiceQuery {
      * This includes mixed scenarios (2 hits + 1 crit, 3 hits + 1 miss, etc.) which
      * occur far more frequently than pure scenarios. For pure scenarios, use combinedDamageStats.
      *
+     * KNOWN LIMITATION (multi-attack, single label): the returned `count` is an
+     * EXPECTED COUNT (E[#label], so > 1 for N≥2 attacks, not a probability), and
+     * `avg` is the size-biased conditional mean E[dmg·#label]/E[#label] rather than
+     * E[dmg | the label occurs]. For a single attack both are the plain
+     * conditional figures. Use {@link probAtLeastOne} for the scenario probability.
+     *
      * @example
      * // High-level tactical planning
      * const successStats = query.damageStatsFrom('hit')
@@ -335,7 +366,8 @@ declare class DiceQuery {
         count: number;
     };
     /**
-     * Returns the probability that a result includes ANY of the specified labels.
+     * Returns the probability that at least one attack carries ANY of the
+     * specified labels (the marginal P(≥1) across the independent attacks).
      *
      * Examples:
      * - `query.probabilityOf('hit')` → 0.88 (probability at least one hit occurs)
@@ -344,6 +376,12 @@ declare class DiceQuery {
      * Use cases:
      * - "What's the chance my resolution includes a success label?"
      * - "How likely am I to get any hits or crits across all attacks?"
+     *
+     * Note: this must NOT be computed by summing `combined` bin probabilities. A
+     * single combined damage total is reachable by many outcome combinations and
+     * a bin can hold several labels at once, so summing `bin.p` over bins that
+     * contain a label over-counts. The correct marginal is the Poisson-binomial
+     * complement over the per-attack probabilities, i.e. {@link probAtLeastOne}.
      */
     probabilityOf(labels: OutcomeType | OutcomeType[]): number;
     /**
@@ -525,6 +563,16 @@ declare class DiceQuery {
      * Snapshot of the distribution in the exact shape the UI consumes.
      * - outcome probabilities are "at least one" (and equal to "all" for a single PMF)
      * - damageRange is conditional on the outcome occurring
+     *
+     * The outcome probabilities use the correct Poisson-binomial marginals
+     * (`atLeastOneProbability` = P(≥1 attack has it), `allProbability` = P(all do)),
+     * so they are always valid probabilities in [0,1].
+     *
+     * KNOWN LIMITATION (multi-attack): `damageRange.avg` is still aggregated from
+     * the combined PMF's `count`, which the convolution accumulates as an EXPECTED
+     * COUNT, so for N≥2 attacks it is the size-biased mean E[dmg·#label]/E[#label]
+     * rather than a clean conditional expectation. It is correct for a single
+     * attack.
      */
     snapshot(order?: readonly OutcomeType[]): Snapshot;
     /**
@@ -629,7 +677,7 @@ declare class DiceQuery {
      *
      * Returns tuple: [pFirstNonSubset, pFirstSubset, pAnySuccess, pNone]
      */
-    firstSuccessSplit(successOutcome: string | string[], subsetOutcome: string | string[], eps?: number): readonly [pSuccess: number, pSubset: number, pAny: number, pNone: number];
+    firstSuccessSplit(successOutcome: OutcomeType | OutcomeType[], subsetOutcome: OutcomeType | OutcomeType[], eps?: number): readonly [pSuccess: number, pSubset: number, pAny: number, pNone: number];
 }
 type OutcomeSnapshot = {
     atLeastOneProbability: number;
@@ -669,6 +717,7 @@ declare class PMF {
     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;
@@ -726,7 +775,7 @@ declare class PMF {
      * @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, zero: PMF): PMF;
+    gate(p: number, fallback: PMF): PMF;
     /**
      * PMF.exclusive()
      *
@@ -773,6 +822,13 @@ declare class PMF {
      *
      * @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.
@@ -827,6 +883,10 @@ declare class PMF {
      * 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;
     /**
@@ -841,6 +901,13 @@ declare class 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;
@@ -855,7 +922,20 @@ declare class PMF {
      * - Order-independent cache keys work better with consistent build patterns
      */
     static convolveMany(pmfList: PMF[], eps?: number): PMF;
-    toJSON(): string;
+    /**
+     * 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;
@@ -868,7 +948,6 @@ declare class PMF {
      * Returns a new, non-normalized PMF.
      */
     prune(epsRel: number, minBins?: number): PMF;
-    /** NEW - REVIEW IF THESE ARE USEFUL OR DUPLCIATIVE?  */
     /** Probability mass at exactly x. */
     pAt(x: number): number;
     /** Dense integer support from min..max (inclusive).
@@ -932,4 +1011,4 @@ declare class PMF {
     query(): DiceQuery;
 }
 
-export { type Bin as B, type CritConfig as C, type DamageDistribution as D, EPS as E, LRUCache as L, type OutcomeLabelMap as O, PMF as P, type Rounding as R, type Snapshot as S, type OutcomeType as a, onCritOnly as b, onHitOnly as c, onMissOnly as d, onMissDamageOnly as e, onSaveHalfOnly as f, onSaveFailOnly as g, onPotentCantripOnly as h, DiceQuery as i, type OutcomeSnapshot as j, onAnyHit as o, pmfCache as p };
+export { type Bin as B, type CritConfig as C, DiceQuery as D, EPS as E, LRUCache as L, type OutcomeLabelMap as O, PMF as P, type Rounding as R, type Snapshot as S, type DamageDistribution as a, type OutcomeSnapshot as b, type OutcomeType as c, onCritOnly as d, onHitOnly as e, onMissDamageOnly as f, onMissOnly as g, onPotentCantripOnly as h, onSaveFailOnly as i, onSaveHalfOnly as j, onAnyHit as o, pmfCache as p };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yipe/dice",
-  "version": "0.2.23",
+  "version": "0.3.0",
   "description": "A high-performance dice probability engine for D&D 5e DPR calculations. Powers dprcalc.com.",
   "keywords": [
     "dnd",
@@ -62,6 +62,7 @@
     "./dist/builder/dc.js"
   ],
   "scripts": {
+    "format": "eslint . --fix",
     "lint": "eslint .",
     "typecheck": "tsc -p config/tsconfig.build.json --noEmit",
     "build": "tsup --config config/tsup.config.ts",
@@ -79,17 +80,14 @@
     "node": ">=18.17"
   },
   "devDependencies": {
-    "@types/node": "^24.3.1",
-    "@typescript-eslint/eslint-plugin": "^8.43.0",
-    "@typescript-eslint/parser": "^8.43.0",
-    "@vitest/coverage-v8": "^3.2.4",
-    "eslint": "^9.35.0",
-    "eslint-plugin-import": "^2.32.0",
-    "ts-node": "^10.9.2",
-    "tsconfig-paths": "^4.2.0",
-    "tsup": "^8.5.0",
-    "tsx": "^4.20.5",
-    "typescript": "^5.9.2",
-    "vitest": "^3.2.4"
+    "@types/node": "^26.0.1",
+    "@typescript-eslint/eslint-plugin": "^8.62.0",
+    "@typescript-eslint/parser": "^8.62.0",
+    "@vitest/coverage-v8": "^4.1.9",
+    "eslint": "^10.6.0",
+    "tsup": "^8.5.1",
+    "tsx": "^4.22.4",
+    "typescript": "^6.0.3",
+    "vitest": "^4.1.9"
   }
 }