@yipe/dice 0.2.20 → 0.2.21

package/dist/builder/index.d.cts

@@ -112,7 +112,9 @@ declare const defaultConfig: RollConfig;
 declare class RollBuilder {
     protected readonly subRollConfigs: readonly RollConfig[];
     constructor(countOrConfigs?: number | readonly RollConfig[]);
+    protected create(configs: readonly RollConfig[]): RollBuilder;
     protected get lastConfig(): RollConfig;
+    hasHiddenState(): boolean;
     getSubRollConfigs(): readonly RollConfig[];
     static fromConfig(config: Partial<RollConfig>): RollBuilder;
     static fromConfigs(configs: Partial<RollConfig>[]): RollBuilder;
@@ -131,6 +133,8 @@ declare class RollBuilder {
     bestOf(count: number | undefined): RollBuilder;
     keepHighest(total: number, count: number): RollBuilder;
     keepLowest(total: number, count: number): RollBuilder;
+    keepHighestAll(total: number, count: number): PooledRollBuilder;
+    keepLowestAll(total: number, count: number): PooledRollBuilder;
     withAdvantage(): RollBuilder;
     withDisadvantage(): RollBuilder;
     add(anotherRoll: RollBuilder | undefined): RollBuilder;
@@ -168,6 +172,7 @@ declare class RollBuilder {
 declare class HalfRollBuilder extends RollBuilder {
     private readonly innerRoll;
     constructor(innerRoll: RollBuilder);
+    hasHiddenState(): boolean;
     get lastConfig(): any;
     getSubRollConfigs(): readonly RollConfig[];
     toExpression(): string;
@@ -181,6 +186,7 @@ declare class MaxOfRollBuilder extends RollBuilder {
     private readonly diceCount?;
     private readonly diceSides?;
     constructor(innerRoll: RollBuilder, count: number, diceCount?: number, diceSides?: number);
+    hasHiddenState(): boolean;
     get lastConfig(): any;
     getSubRollConfigs(): readonly RollConfig[];
     toExpression(): string;
@@ -191,6 +197,7 @@ declare class MaxOfRollBuilder extends RollBuilder {
 declare class AlwaysHitBuilder extends RollBuilder {
     readonly attackConfig: CritConfig;
     constructor(baseRoll: RollBuilder, attackConfig?: CritConfig);
+    protected create(configs: readonly RollConfig[]): RollBuilder;
     onHit(val: number): AttackBuilder;
     onHit(val: string): AttackBuilder;
     onHit(val: RollBuilder): AttackBuilder;
@@ -213,6 +220,7 @@ declare class AlwaysCritBuilder extends RollBuilder {
     constructor(baseRoll: RollBuilder, attackConfig?: CritConfig & {
         ac?: number;
     }, fromAlwaysHit?: boolean);
+    protected create(configs: readonly RollConfig[]): RollBuilder;
     onHit(val: number): AttackBuilder;
     onHit(val: string): AttackBuilder;
     onHit(val: RollBuilder): AttackBuilder;
@@ -226,22 +234,40 @@ declare class AlwaysCritBuilder extends RollBuilder {
     toPMF(): PMF;
     copy(): AlwaysCritBuilder;
 }
-/**
- * A RollBuilder that wraps a pre-computed PMF from a parsed string expression.
- * This is used to support string-based damage expressions in onHit/onCrit/onMiss.
- * The builder is not fully composable (e.g., you can't call .plus() on it),
- * but it can be used anywhere a RollBuilder is expected for terminal damage.
- */
 declare class ParsedRollBuilder extends RollBuilder {
     private readonly cachedPMF;
     private readonly originalExpression;
     constructor(expression: string);
-    toPMF(eps?: number): PMF;
+    hasHiddenState(): boolean;
+    protected create(configs: readonly RollConfig[]): RollBuilder;
+    toPMF(_eps?: number): PMF;
     toExpression(): string;
     toAST(): ExpressionNode;
     copy(): ParsedRollBuilder;
     doubleDice(): ParsedRollBuilder;
 }
+declare class PooledRollBuilder extends RollBuilder {
+    private readonly baseAST;
+    private readonly baseExpression;
+    constructor(baseAST: ExpressionNode, baseExpression: string, configs?: readonly RollConfig[]);
+    protected create(configs: readonly RollConfig[]): PooledRollBuilder;
+    hasHiddenState(): boolean;
+    d(_sides: number | undefined): RollBuilder;
+    reroll(_value: number): RollBuilder;
+    explode(_count?: number | undefined): RollBuilder;
+    minimum(_val: number | undefined): RollBuilder;
+    bestOf(_count: number | undefined): RollBuilder;
+    keepHighest(_total: number, _count: number): RollBuilder;
+    keepLowest(_total: number, _count: number): RollBuilder;
+    withAdvantage(): RollBuilder;
+    withDisadvantage(): RollBuilder;
+    withElvenAccuracy(): RollBuilder;
+    toAST(): ExpressionNode;
+    toExpression(): string;
+    copy(): PooledRollBuilder;
+    scaleDice(scale: number): RollBuilder;
+    times(count: number): PooledRollBuilder;
+}
 
 type ActionEffect = RollBuilder;
 declare class AttackBuilder implements CheckBuilder {
@@ -359,4 +385,4 @@ declare const flat: (n: number) => RollBuilder;
 declare const roll: RollFactory;
 declare const builderPMFCache: LRUCache<string, PMF>;
 
-export { ACBuilder, AlwaysCritBuilder, AlwaysHitBuilder, type AttackConfig, type AttackResolution, type CheckBuilder, DCBuilder, HalfRollBuilder, type KeepMode, MaxOfRollBuilder, ParsedRollBuilder, type Resolution, RollBuilder, type RollConfig, type RollFactory, type RollType, SaveBuilder, type SaveOutcome, type SaveResolution, builderPMFCache, d, d10, d100, d12, d20, d4, d6, d8, defaultConfig, flat, hd20, roll };
+export { ACBuilder, AlwaysCritBuilder, AlwaysHitBuilder, type AttackConfig, type AttackResolution, type CheckBuilder, DCBuilder, HalfRollBuilder, type KeepMode, MaxOfRollBuilder, ParsedRollBuilder, PooledRollBuilder, type Resolution, RollBuilder, type RollConfig, type RollFactory, type RollType, SaveBuilder, type SaveOutcome, type SaveResolution, builderPMFCache, d, d10, d100, d12, d20, d4, d6, d8, defaultConfig, flat, hd20, roll };

package/dist/builder/index.d.ts

@@ -112,7 +112,9 @@ declare const defaultConfig: RollConfig;
 declare class RollBuilder {
     protected readonly subRollConfigs: readonly RollConfig[];
     constructor(countOrConfigs?: number | readonly RollConfig[]);
+    protected create(configs: readonly RollConfig[]): RollBuilder;
     protected get lastConfig(): RollConfig;
+    hasHiddenState(): boolean;
     getSubRollConfigs(): readonly RollConfig[];
     static fromConfig(config: Partial<RollConfig>): RollBuilder;
     static fromConfigs(configs: Partial<RollConfig>[]): RollBuilder;
@@ -131,6 +133,8 @@ declare class RollBuilder {
     bestOf(count: number | undefined): RollBuilder;
     keepHighest(total: number, count: number): RollBuilder;
     keepLowest(total: number, count: number): RollBuilder;
+    keepHighestAll(total: number, count: number): PooledRollBuilder;
+    keepLowestAll(total: number, count: number): PooledRollBuilder;
     withAdvantage(): RollBuilder;
     withDisadvantage(): RollBuilder;
     add(anotherRoll: RollBuilder | undefined): RollBuilder;
@@ -168,6 +172,7 @@ declare class RollBuilder {
 declare class HalfRollBuilder extends RollBuilder {
     private readonly innerRoll;
     constructor(innerRoll: RollBuilder);
+    hasHiddenState(): boolean;
     get lastConfig(): any;
     getSubRollConfigs(): readonly RollConfig[];
     toExpression(): string;
@@ -181,6 +186,7 @@ declare class MaxOfRollBuilder extends RollBuilder {
     private readonly diceCount?;
     private readonly diceSides?;
     constructor(innerRoll: RollBuilder, count: number, diceCount?: number, diceSides?: number);
+    hasHiddenState(): boolean;
     get lastConfig(): any;
     getSubRollConfigs(): readonly RollConfig[];
     toExpression(): string;
@@ -191,6 +197,7 @@ declare class MaxOfRollBuilder extends RollBuilder {
 declare class AlwaysHitBuilder extends RollBuilder {
     readonly attackConfig: CritConfig;
     constructor(baseRoll: RollBuilder, attackConfig?: CritConfig);
+    protected create(configs: readonly RollConfig[]): RollBuilder;
     onHit(val: number): AttackBuilder;
     onHit(val: string): AttackBuilder;
     onHit(val: RollBuilder): AttackBuilder;
@@ -213,6 +220,7 @@ declare class AlwaysCritBuilder extends RollBuilder {
     constructor(baseRoll: RollBuilder, attackConfig?: CritConfig & {
         ac?: number;
     }, fromAlwaysHit?: boolean);
+    protected create(configs: readonly RollConfig[]): RollBuilder;
     onHit(val: number): AttackBuilder;
     onHit(val: string): AttackBuilder;
     onHit(val: RollBuilder): AttackBuilder;
@@ -226,22 +234,40 @@ declare class AlwaysCritBuilder extends RollBuilder {
     toPMF(): PMF;
     copy(): AlwaysCritBuilder;
 }
-/**
- * A RollBuilder that wraps a pre-computed PMF from a parsed string expression.
- * This is used to support string-based damage expressions in onHit/onCrit/onMiss.
- * The builder is not fully composable (e.g., you can't call .plus() on it),
- * but it can be used anywhere a RollBuilder is expected for terminal damage.
- */
 declare class ParsedRollBuilder extends RollBuilder {
     private readonly cachedPMF;
     private readonly originalExpression;
     constructor(expression: string);
-    toPMF(eps?: number): PMF;
+    hasHiddenState(): boolean;
+    protected create(configs: readonly RollConfig[]): RollBuilder;
+    toPMF(_eps?: number): PMF;
     toExpression(): string;
     toAST(): ExpressionNode;
     copy(): ParsedRollBuilder;
     doubleDice(): ParsedRollBuilder;
 }
+declare class PooledRollBuilder extends RollBuilder {
+    private readonly baseAST;
+    private readonly baseExpression;
+    constructor(baseAST: ExpressionNode, baseExpression: string, configs?: readonly RollConfig[]);
+    protected create(configs: readonly RollConfig[]): PooledRollBuilder;
+    hasHiddenState(): boolean;
+    d(_sides: number | undefined): RollBuilder;
+    reroll(_value: number): RollBuilder;
+    explode(_count?: number | undefined): RollBuilder;
+    minimum(_val: number | undefined): RollBuilder;
+    bestOf(_count: number | undefined): RollBuilder;
+    keepHighest(_total: number, _count: number): RollBuilder;
+    keepLowest(_total: number, _count: number): RollBuilder;
+    withAdvantage(): RollBuilder;
+    withDisadvantage(): RollBuilder;
+    withElvenAccuracy(): RollBuilder;
+    toAST(): ExpressionNode;
+    toExpression(): string;
+    copy(): PooledRollBuilder;
+    scaleDice(scale: number): RollBuilder;
+    times(count: number): PooledRollBuilder;
+}
 
 type ActionEffect = RollBuilder;
 declare class AttackBuilder implements CheckBuilder {
@@ -359,4 +385,4 @@ declare const flat: (n: number) => RollBuilder;
 declare const roll: RollFactory;
 declare const builderPMFCache: LRUCache<string, PMF>;
 
-export { ACBuilder, AlwaysCritBuilder, AlwaysHitBuilder, type AttackConfig, type AttackResolution, type CheckBuilder, DCBuilder, HalfRollBuilder, type KeepMode, MaxOfRollBuilder, ParsedRollBuilder, type Resolution, RollBuilder, type RollConfig, type RollFactory, type RollType, SaveBuilder, type SaveOutcome, type SaveResolution, builderPMFCache, d, d10, d100, d12, d20, d4, d6, d8, defaultConfig, flat, hd20, roll };
+export { ACBuilder, AlwaysCritBuilder, AlwaysHitBuilder, type AttackConfig, type AttackResolution, type CheckBuilder, DCBuilder, HalfRollBuilder, type KeepMode, MaxOfRollBuilder, ParsedRollBuilder, PooledRollBuilder, type Resolution, RollBuilder, type RollConfig, type RollFactory, type RollType, SaveBuilder, type SaveOutcome, type SaveResolution, builderPMFCache, d, d10, d100, d12, d20, d4, d6, d8, defaultConfig, flat, hd20, roll };

package/dist/builder/index.js

@@ -3338,9 +3338,15 @@ var RollBuilder = class _RollBuilder {
       this.subRollConfigs = countOrConfigs.map((c) => ({ ...c }));
     }
   }
+  create(configs) {
+    return new _RollBuilder(configs);
+  }
   get lastConfig() {
     return this.subRollConfigs[this.subRollConfigs.length - 1];
   }
+  hasHiddenState() {
+    return false;
+  }
   getSubRollConfigs() {
     return this.subRollConfigs.map((c) => ({ ...c }));
   }
@@ -3374,6 +3380,11 @@ var RollBuilder = class _RollBuilder {
       }
       if (isNaN(count)) throw new Error("Invalid NaN value for count argument");
       if (sidesOrDie instanceof _RollBuilder) {
+        if (sidesOrDie.hasHiddenState()) {
+          throw new Error(
+            "Cannot use a roll with hidden state (like a pooled roll) as a die type."
+          );
+        }
         const subRollConfigs = sidesOrDie.getSubRollConfigs();
         if (subRollConfigs.length === 0) {
           const result = new _RollBuilder(0);
@@ -3414,12 +3425,17 @@ var RollBuilder = class _RollBuilder {
     if (sides === 0) return this;
     const newConfigs = this.getSubRollConfigs();
     newConfigs[newConfigs.length - 1].sides = sides;
-    return new this.constructor(newConfigs);
+    return this.create(newConfigs);
   }
   plus(modOrRoll, die) {
     if (typeof modOrRoll === "number" && isNaN(modOrRoll))
       throw new Error("Invalid NaN value for modOrRoll");
     if (die instanceof _RollBuilder && typeof modOrRoll === "number") {
+      if (die.hasHiddenState()) {
+        throw new Error(
+          "Cannot use a roll with hidden state (like a pooled roll) as a die type."
+        );
+      }
       const count = modOrRoll;
       const subRollConfigs = die.getSubRollConfigs();
       if (subRollConfigs.length === 0) return this;
@@ -3444,7 +3460,7 @@ var RollBuilder = class _RollBuilder {
       if (modOrRoll === 0) return this;
       const newConfigs = this.getSubRollConfigs();
       newConfigs[newConfigs.length - 1].modifier += modOrRoll;
-      return new this.constructor(newConfigs);
+      return this.create(newConfigs);
     }
     return this.add(modOrRoll);
   }
@@ -3462,7 +3478,7 @@ var RollBuilder = class _RollBuilder {
     if (value === this.lastConfig.reroll) return this;
     const newConfigs = this.getSubRollConfigs();
     newConfigs[newConfigs.length - 1].reroll = value;
-    return new this.constructor(newConfigs);
+    return this.create(newConfigs);
   }
   /** Set finite explode count for max-face explosions (Infinity allowed). */
   explode(count = Infinity) {
@@ -3473,7 +3489,7 @@ var RollBuilder = class _RollBuilder {
     if (count < 0) throw new Error("Explode count must be >= 0");
     const newConfigs = this.getSubRollConfigs();
     newConfigs[newConfigs.length - 1].explode = count;
-    return new this.constructor(newConfigs);
+    return this.create(newConfigs);
   }
   /** Apply per-die minimum value (min > 0). */
   minimum(val) {
@@ -3484,7 +3500,7 @@ var RollBuilder = class _RollBuilder {
     if (val < 0) throw new Error("Minimum value must be >= 0");
     const newConfigs = this.getSubRollConfigs();
     newConfigs[newConfigs.length - 1].minimum = val + 1;
-    return new this.constructor(newConfigs);
+    return this.create(newConfigs);
   }
   bestOf(count) {
     if (count !== void 0 && isNaN(count))
@@ -3493,40 +3509,83 @@ var RollBuilder = class _RollBuilder {
     if (count <= 0) throw new Error("Best of count must be > 0");
     const newConfigs = this.getSubRollConfigs();
     newConfigs[newConfigs.length - 1].bestOf = count;
-    return new this.constructor(newConfigs);
+    return this.create(newConfigs);
   }
   keepHighest(total, count) {
     if (isNaN(total) || isNaN(count))
       throw new Error("Invalid NaN value for keepHighest");
     const newConfigs = this.getSubRollConfigs();
     newConfigs[newConfigs.length - 1].keep = { total, count, mode: "highest" };
-    return new this.constructor(newConfigs);
+    return this.create(newConfigs);
   }
   keepLowest(total, count) {
     if (isNaN(total) || isNaN(count))
       throw new Error("Invalid NaN value for keepLowest");
     const newConfigs = this.getSubRollConfigs();
     newConfigs[newConfigs.length - 1].keep = { total, count, mode: "lowest" };
-    return new this.constructor(newConfigs);
+    return this.create(newConfigs);
+  }
+  keepHighestAll(total, count) {
+    if (isNaN(total) || isNaN(count))
+      throw new Error("Invalid NaN value for keepHighestAll");
+    const currentAST = this.toAST();
+    const trialPool = {
+      type: "sum",
+      count: total,
+      child: currentAST
+    };
+    const keepNode = {
+      type: "keep",
+      mode: "highest",
+      count,
+      child: trialPool
+    };
+    const currentExpr = this.toExpression();
+    const expression = `${total}kh${count}(${currentExpr})`;
+    return new PooledRollBuilder(keepNode, expression);
+  }
+  keepLowestAll(total, count) {
+    if (isNaN(total) || isNaN(count))
+      throw new Error("Invalid NaN value for keepLowestAll");
+    const currentAST = this.toAST();
+    const trialPool = {
+      type: "sum",
+      count: total,
+      child: currentAST
+    };
+    const keepNode = {
+      type: "keep",
+      mode: "lowest",
+      count,
+      child: trialPool
+    };
+    const currentExpr = this.toExpression();
+    const expression = `${total}kl${count}(${currentExpr})`;
+    return new PooledRollBuilder(keepNode, expression);
   }
   withAdvantage() {
     const newConfigs = this.getSubRollConfigs();
     newConfigs[newConfigs.length - 1].rollType = "advantage";
-    return new this.constructor(newConfigs);
+    return this.create(newConfigs);
   }
   withDisadvantage() {
     const configs = this.getSubRollConfigs();
     configs[configs.length - 1].rollType = "disadvantage";
-    return new this.constructor(configs);
+    return this.create(configs);
   }
   add(anotherRoll) {
     if (anotherRoll === void 0) return this;
+    if (anotherRoll.hasHiddenState()) {
+      throw new Error(
+        "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)."
+      );
+    }
     const configs = [...this.subRollConfigs, ...anotherRoll.subRollConfigs];
-    return new this.constructor(configs);
+    return this.create(configs);
   }
   withBonus(anotherRoll) {
     const configs = [...this.subRollConfigs, ...anotherRoll.subRollConfigs];
-    return new this.constructor(configs);
+    return this.create(configs);
   }
   addRoll(count = 1) {
     if (isNaN(count)) throw new Error("Invalid NaN value for count");
@@ -3538,7 +3597,7 @@ var RollBuilder = class _RollBuilder {
         isSubtraction: count < 0
       }
     ];
-    return new this.constructor(configs);
+    return this.create(configs);
   }
   scaleDice(scale) {
     const scaleInt = Math.floor(scale);
@@ -3548,7 +3607,7 @@ var RollBuilder = class _RollBuilder {
       if (!config.sides || config.sides <= 0) return config;
       return { ...config, count: config.count * scaleInt };
     });
-    return new this.constructor(newConfigs);
+    return this.create(newConfigs);
   }
   doubleDice() {
     return this.scaleDice(2);
@@ -3560,12 +3619,12 @@ var RollBuilder = class _RollBuilder {
     return new AlwaysCritBuilder(this);
   }
   copy() {
-    return new this.constructor(this.getSubRollConfigs());
+    return this.create(this.getSubRollConfigs());
   }
   withElvenAccuracy() {
     const newConfigs = this.getSubRollConfigs();
     newConfigs[newConfigs.length - 1].rollType = "elven accuracy";
-    return new this.constructor(newConfigs);
+    return this.create(newConfigs);
   }
   toExpression() {
     const originalDiceConfigs = this.subRollConfigs.filter(
@@ -3779,6 +3838,19 @@ var HalfRollBuilder = class _HalfRollBuilder extends RollBuilder {
     super(0);
     this.innerRoll = innerRoll;
   }
+  hasHiddenState() {
+    return this.innerRoll.hasHiddenState();
+  }
+  // No need to override create if we don't expose RollBuilder methods that use it,
+  // but HalfRollBuilder extends RollBuilder so it does.
+  // However, HalfRollBuilder seems to just wrap another roll.
+  // If we call .plus() on HalfRollBuilder, it returns a HalfRollBuilder?
+  // No, RollBuilder.plus returns RollBuilder.
+  // The inheritance here is a bit tricky.
+  // Existing code for HalfRollBuilder doesn't seem to implement plus/etc.
+  // So .plus() on a HalfRollBuilder would return a RollBuilder (base class).
+  // Which is fine.
+  // The only issue is if we want it to return HalfRollBuilder, but it doesn't seem designed for that.
   get lastConfig() {
     return this.innerRoll.lastConfig;
   }
@@ -3810,6 +3882,9 @@ var MaxOfRollBuilder = class _MaxOfRollBuilder extends RollBuilder {
     this.diceCount = diceCount;
     this.diceSides = diceSides;
   }
+  hasHiddenState() {
+    return this.innerRoll.hasHiddenState();
+  }
   get lastConfig() {
     return this.innerRoll.lastConfig;
   }
@@ -3865,6 +3940,11 @@ var MaxOfRollBuilder = class _MaxOfRollBuilder extends RollBuilder {
 };
 var AlwaysHitBuilder = class _AlwaysHitBuilder extends RollBuilder {
   constructor(baseRoll, attackConfig) {
+    if (baseRoll.hasHiddenState()) {
+      throw new Error(
+        "Cannot create AlwaysHitBuilder from a roll with hidden state."
+      );
+    }
     super(baseRoll.getSubRollConfigs());
     __publicField(this, "attackConfig");
     if (attackConfig) {
@@ -3873,6 +3953,9 @@ var AlwaysHitBuilder = class _AlwaysHitBuilder extends RollBuilder {
       this.attackConfig = { critThreshold: 20 };
     }
   }
+  create(configs) {
+    return new RollBuilder(configs);
+  }
   onHit(...args) {
     const damageRoll = RollBuilder.fromArgs(...args);
     return new AttackBuilder(this, damageRoll);
@@ -3907,6 +3990,11 @@ var AlwaysHitBuilder = class _AlwaysHitBuilder extends RollBuilder {
 };
 var AlwaysCritBuilder = class _AlwaysCritBuilder extends RollBuilder {
   constructor(baseRoll, attackConfig, fromAlwaysHit = false) {
+    if (baseRoll.hasHiddenState()) {
+      throw new Error(
+        "Cannot create AlwaysCritBuilder from a roll with hidden state."
+      );
+    }
     super(baseRoll.getSubRollConfigs());
     __publicField(this, "attackConfig");
     __publicField(this, "fromAlwaysHit");
@@ -3917,6 +4005,9 @@ var AlwaysCritBuilder = class _AlwaysCritBuilder extends RollBuilder {
     }
     this.fromAlwaysHit = fromAlwaysHit || baseRoll instanceof AlwaysHitBuilder;
   }
+  create(configs) {
+    return new RollBuilder(configs);
+  }
   onHit(...args) {
     const damageRoll = RollBuilder.fromArgs(...args);
     return new AttackBuilder(this, damageRoll);
@@ -3953,7 +4044,13 @@ var ParsedRollBuilder = class _ParsedRollBuilder extends RollBuilder {
     this.originalExpression = expression;
     this.cachedPMF = parse(expression, 0);
   }
-  toPMF(eps = 0) {
+  hasHiddenState() {
+    return true;
+  }
+  create(configs) {
+    return new RollBuilder(configs);
+  }
+  toPMF(_eps = 0) {
     return this.cachedPMF;
   }
   toExpression() {
@@ -3973,10 +4070,122 @@ var ParsedRollBuilder = class _ParsedRollBuilder extends RollBuilder {
     );
   }
 };
+var PooledRollBuilder = class _PooledRollBuilder extends RollBuilder {
+  constructor(baseAST, baseExpression, configs = []) {
+    super(configs.length > 0 ? configs : 0);
+    this.baseAST = baseAST;
+    this.baseExpression = baseExpression;
+  }
+  create(configs) {
+    return new _PooledRollBuilder(this.baseAST, this.baseExpression, configs);
+  }
+  hasHiddenState() {
+    return true;
+  }
+  d(_sides) {
+    throw new Error("Cannot add dice to a pooled roll. The pool is finalized.");
+  }
+  reroll(_value) {
+    throw new Error("Cannot set reroll on a pooled roll.");
+  }
+  explode(_count = Infinity) {
+    throw new Error("Cannot set explode on a pooled roll.");
+  }
+  minimum(_val) {
+    throw new Error("Cannot set minimum on a pooled roll.");
+  }
+  bestOf(_count) {
+    throw new Error("Cannot set bestOf on a pooled roll.");
+  }
+  keepHighest(_total, _count) {
+    throw new Error(
+      "Cannot use keepHighest on a pooled roll. Use keepHighestAll again if you want nested pooling."
+    );
+  }
+  keepLowest(_total, _count) {
+    throw new Error(
+      "Cannot use keepLowest on a pooled roll. Use keepLowestAll again if you want nested pooling."
+    );
+  }
+  withAdvantage() {
+    throw new Error("Cannot set advantage on a pooled roll.");
+  }
+  withDisadvantage() {
+    throw new Error("Cannot set disadvantage on a pooled roll.");
+  }
+  withElvenAccuracy() {
+    throw new Error("Cannot set elven accuracy on a pooled roll.");
+  }
+  toAST() {
+    const configsAST = super.toAST();
+    const isZero = configsAST.type === "constant" && configsAST.value === 0;
+    if (isZero) {
+      return this.baseAST;
+    }
+    const children = [
+      { node: this.baseAST, sign: 1 },
+      { node: configsAST, sign: 1 }
+    ];
+    return { type: "add", children };
+  }
+  toExpression() {
+    const configsExpression = super.toExpression();
+    if (configsExpression === "0") {
+      return this.baseExpression;
+    }
+    if (configsExpression.startsWith("-")) {
+      return `${this.baseExpression} - ${configsExpression.substring(1)}`;
+    }
+    return `${this.baseExpression} + ${configsExpression}`;
+  }
+  copy() {
+    return new _PooledRollBuilder(
+      this.baseAST,
+      this.baseExpression,
+      this.getSubRollConfigs()
+    );
+  }
+  scaleDice(scale) {
+    const scaleInt = Math.floor(scale);
+    if (scaleInt !== scale) throw new Error("Scale must be an integer");
+    if (scaleInt <= 0) throw new Error("Scale must be > 0");
+    const newBaseAST = {
+      type: "sum",
+      count: scaleInt,
+      child: this.baseAST
+    };
+    const newBaseExpr = scaleInt === 1 ? this.baseExpression : `${scaleInt}(${this.baseExpression})`;
+    return new _PooledRollBuilder(
+      newBaseAST,
+      newBaseExpr,
+      this.getSubRollConfigs()
+    );
+  }
+  times(count) {
+    if (isNaN(count)) throw new Error("Invalid NaN value for times");
+    if (Math.floor(count) !== count)
+      throw new Error("times() requires an integer");
+    if (count < 0) throw new Error("times() requires a non-negative integer");
+    const currentAST = this.toAST();
+    const currentExpr = this.toExpression();
+    const sumNode = {
+      type: "sum",
+      count,
+      child: currentAST
+    };
+    const newExpr = count === 1 ? currentExpr : `${count}(${currentExpr})`;
+    return new _PooledRollBuilder(sumNode, newExpr);
+  }
+};
 
 // src/builder/factory.ts
 var rollFn = (count, sidesOrDie, modifier) => {
   if (sidesOrDie instanceof RollBuilder) {
+    if (sidesOrDie.hasHiddenState()) {
+      throw new Error(
+        "Cannot use a roll with hidden state (like a pooled roll) as a die type."
+      );
+    }
     const subRollConfigs = sidesOrDie.getSubRollConfigs();
     if (subRollConfigs.length === 0) return new RollBuilder(0).plus(modifier);
     const absCount = Math.abs(count);
@@ -4878,6 +5087,6 @@ RollBuilder.prototype.dc = function(saveDC) {
   return new DCBuilder(this).dc(saveDC);
 };
 
-export { ACBuilder, AlwaysCritBuilder, AlwaysHitBuilder, DCBuilder, HalfRollBuilder, MaxOfRollBuilder, ParsedRollBuilder, RollBuilder, SaveBuilder, builderPMFCache, d, d10, d100, d12, d20, d4, d6, d8, defaultConfig, flat, hd20, roll };
+export { ACBuilder, AlwaysCritBuilder, AlwaysHitBuilder, DCBuilder, HalfRollBuilder, MaxOfRollBuilder, ParsedRollBuilder, PooledRollBuilder, RollBuilder, SaveBuilder, builderPMFCache, d, d10, d100, d12, d20, d4, d6, d8, defaultConfig, flat, hd20, roll };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map