@platonic-dice/dice 2.1.1 → 2.2.1

package/dist/components/die-history/history-cache.d.ts

@@ -0,0 +1,85 @@
+import { RollRecordManager } from "./internal/index.js";
+import type { RollRecord } from "../../types/index.js";
+/**
+ * A wrapper for RollRecordManager that maintains multiple, independently capped histories.
+ *
+ * Useful for scenarios where a single RollRecordManager needs to support "history parking",
+ * such as storing separate roll histories per modifier or context.
+ *
+ * @template R - The type of roll records stored
+ */
+/**
+ * A wrapper for RollRecordManager that maintains multiple, independently capped histories.
+ *
+ * Useful for scenarios where a single RollRecordManager needs to support "history parking",
+ * such as storing separate roll histories per modifier or context.
+ *
+ * @template R - The type of roll records stored
+ */
+export declare class HistoryCache<R extends RollRecord = RollRecord> {
+    private readonly cache;
+    private readonly maxRecordsPerKey;
+    private readonly maxKeys;
+    private activeKey;
+    constructor({ maxRecordsPerKey, maxKeys, }?: {
+        maxRecordsPerKey?: number | undefined;
+        maxKeys?: number | undefined;
+    });
+    /**
+     * Sets the currently active history key. If the key does not exist it will be created.
+     *
+     * @param {string} key - History key to activate.
+     */
+    setActiveKey(key: string): void;
+    /**
+     * Returns the currently active RollRecordManager for the active key.
+     *
+     * @returns {RollRecordManager<R> | undefined} The manager for the active key (if any).
+     */
+    get activeManager(): RollRecordManager<R> | undefined;
+    /**
+     * Adds a roll record to the active history.
+     *
+     * @param {R} record - The roll record to add.
+     * @throws {Error} If no active history key is set.
+     */
+    add(record: R): void;
+    /**
+     * Returns a copy of the roll records for the active key.
+     *
+     * @param {boolean} [verbose=false] - When true include timestamps.
+     * @returns {R[] | Omit<R, "timestamp">[]} Array of records for the active key.
+     */
+    getAll(verbose?: boolean): R[] | Omit<R, "timestamp">[];
+    /**
+     * Clears all roll records for the active key.
+     */
+    clearActive(): void;
+    /**
+     * Clears all cached histories and resets the active key.
+     */
+    clearAll(): void;
+    /**
+     * Returns a roll history report for all cached keys.
+     *
+     * @param {{limit?: number, verbose?: boolean}} [options] - Report options.
+     * @returns {Record<string, (R | Omit<R, "timestamp">)[]>} Map of key→records.
+     */
+    report({ limit, verbose, }?: {
+        limit?: number;
+        verbose?: boolean;
+    }): Record<string, (R | Omit<R, "timestamp">)[]>;
+    /**
+     * Returns a string summary of the cache.
+     *
+     * @returns {string} Summary containing number of keys and active key.
+     */
+    toString(): string;
+    /**
+     * Returns a JSON-friendly object mapping keys to arrays of RollRecords.
+     *
+     * @returns {Record<string, R[]>} The cache contents as plain arrays.
+     */
+    toJSON(): Record<string, R[]>;
+}
+//# sourceMappingURL=history-cache.d.ts.map

package/dist/components/die-history/history-cache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"history-cache.d.ts","sourceRoot":"","sources":["../../../src/components/die-history/history-cache.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAuB,MAAM,YAAY,CAAC;AACpE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAE9C;;;;;;;GAOG;AACH;;;;;;;GAOG;AACH,qBAAa,YAAY,CAAC,CAAC,SAAS,UAAU,GAAG,UAAU;IACzD,OAAO,CAAC,QAAQ,CAAC,KAAK,CAA2C;IACjE,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAAS;IAC1C,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAS;IACjC,OAAO,CAAC,SAAS,CAAqB;gBAE1B,EACV,gBAAuD,EACvD,OAAY,GACb;;;KAAK;IAKN;;;;OAIG;IACH,YAAY,CAAC,GAAG,EAAE,MAAM;IAaxB;;;;OAIG;IACH,IAAI,aAAa,IAAI,iBAAiB,CAAC,CAAC,CAAC,GAAG,SAAS,CAGpD;IAED;;;;;OAKG;IACH,GAAG,CAAC,MAAM,EAAE,CAAC;IAOb;;;;;OAKG;IACH,MAAM,CAAC,OAAO,UAAQ,GAAG,CAAC,EAAE,GAAG,IAAI,CAAC,CAAC,EAAE,WAAW,CAAC,EAAE;IAMrD;;OAEG;IACH,WAAW;IAKX;;OAEG;IACH,QAAQ;IAKR;;;;;OAKG;IACH,MAAM,CAAC,EACL,KAAK,EACL,OAAe,GAChB,GAAE;QAAE,KAAK,CAAC,EAAE,MAAM,CAAC;QAAC,OAAO,CAAC,EAAE,OAAO,CAAA;KAAO,GAAG,MAAM,CACpD,MAAM,EACN,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC,EAAE,WAAW,CAAC,CAAC,EAAE,CAC7B;IAQD;;;;OAIG;IACH,QAAQ,IAAI,MAAM;IAMlB;;;;OAIG;IACH,MAAM,IAAI,MAAM,CAAC,MAAM,EAAE,CAAC,EAAE,CAAC;CAO9B"}

package/dist/components/die-history/index.d.ts

@@ -0,0 +1,3 @@
+export { RollRecordFactory } from "./roll-record-factory.js";
+export { HistoryCache } from "./history-cache.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/components/die-history/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/components/die-history/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AAC1D,OAAO,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC"}

package/dist/components/die-history/internal/index.d.ts

@@ -0,0 +1,3 @@
+export { RollRecordManager, DEFAULT_MAX_RECORDS } from "./roll-record-manager/index.js";
+export * from "./roll-record-validator.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/components/die-history/internal/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/components/die-history/internal/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AAC/E,cAAc,yBAAyB,CAAC"}

package/dist/components/die-history/internal/roll-record-manager/index.d.ts

@@ -0,0 +1,2 @@
+export { RollRecordManager, DEFAULT_MAX_RECORDS } from "./roll-record-manager.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/components/die-history/internal/roll-record-manager/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/components/die-history/internal/roll-record-manager/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC"}

package/dist/components/die-history/internal/roll-record-manager/internal/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./roll-record-storage.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/components/die-history/internal/roll-record-manager/internal/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/components/die-history/internal/roll-record-manager/internal/index.ts"],"names":[],"mappings":"AAAA,cAAc,uBAAuB,CAAC"}

package/dist/components/die-history/internal/roll-record-manager/internal/roll-record-storage.d.ts

@@ -0,0 +1,37 @@
+import type { RollRecord } from "../../../../../types/index.js";
+/**
+ * Simple in-memory storage for roll records with a fixed capacity.
+ *
+ * This class focuses solely on storage and eviction policy. It does not
+ * perform shape validation of records (delegated to validators elsewhere).
+ */
+export declare class RollRecordStorage<R extends RollRecord = RollRecord> {
+    private records;
+    private readonly maxRecords;
+    /**
+     * Create a new storage container.
+     * @param maxRecords Maximum number of records to retain (FIFO eviction).
+     */
+    /**
+     * Create a new storage container.
+     *
+     * @param {number} [maxRecords=1000] Maximum number of records to retain (FIFO eviction).
+     */
+    constructor(maxRecords?: number);
+    /** Number of records currently stored */
+    get size(): number;
+    /** Configured maximum number of records */
+    get maxRecordsCount(): number;
+    /** Returns a shallow copy of all records (timestamps preserved) */
+    get full(): R[];
+    /** Add a new record and evict oldest if capacity exceeded */
+    add(record: R): void;
+    /** Clear all stored records */
+    clear(): void;
+    /** Return the most recent N records in chronological order (oldest first) */
+    last(n?: number): R[];
+    /** JSON-friendly copy of stored records */
+    toJSON(): R[];
+}
+export default RollRecordStorage;
+//# sourceMappingURL=roll-record-storage.d.ts.map

package/dist/components/die-history/internal/roll-record-manager/internal/roll-record-storage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"roll-record-storage.d.ts","sourceRoot":"","sources":["../../../../../../src/components/die-history/internal/roll-record-manager/internal/roll-record-storage.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAE9C;;;;;GAKG;AACH,qBAAa,iBAAiB,CAAC,CAAC,SAAS,UAAU,GAAG,UAAU;IAC9D,OAAO,CAAC,OAAO,CAAW;IAC1B,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAS;IAEpC;;;OAGG;IACH;;;;OAIG;gBACS,UAAU,GAAE,MAAa;IAOrC,yCAAyC;IACzC,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED,2CAA2C;IAC3C,IAAI,eAAe,IAAI,MAAM,CAE5B;IAED,mEAAmE;IACnE,IAAI,IAAI,IAAI,CAAC,EAAE,CAEd;IAED,6DAA6D;IAC7D,GAAG,CAAC,MAAM,EAAE,CAAC,GAAG,IAAI;IAWpB,+BAA+B;IAC/B,KAAK,IAAI,IAAI;IAIb,6EAA6E;IAC7E,IAAI,CAAC,CAAC,GAAE,MAAU,GAAG,CAAC,EAAE;IAUxB,2CAA2C;IAC3C,MAAM,IAAI,CAAC,EAAE;CAGd;AAED,eAAe,iBAAiB,CAAC"}

package/dist/components/die-history/internal/roll-record-manager/roll-record-manager.d.ts

@@ -0,0 +1,87 @@
+import type { RollRecord } from "../../../../types/index.js";
+/**
+ * Default maximum number of roll records stored.
+ */
+export declare const DEFAULT_MAX_RECORDS = 1000;
+/**
+ * Utility class for managing roll history of Die and child/composite classes.
+ *
+ * Provides methods to add roll records, retrieve the last N rolls,
+ * produce history reports, and manage roll record storage.
+ *
+ * @template R Type of roll record, defaults to all RollRecord variants.
+ */
+export declare class RollRecordManager<R extends RollRecord = RollRecord> {
+    /** Internal storage of roll records */
+    private storage;
+    /** Maximum number of roll records to retain */
+    private maxRecords;
+    /**
+     * Create a RollRecordManager.
+     *
+     * @param {number} [maxRecords=DEFAULT_MAX_RECORDS] - Maximum records to retain.
+     */
+    constructor(maxRecords?: number);
+    /**
+     * Returns a copy of all roll records (including timestamps).
+     *
+     * @returns {R[]} All records (timestamps preserved).
+     */
+    get full(): R[];
+    /**
+     * Returns a copy of all roll records with timestamps stripped.
+     *
+     * @returns {Omit<R, "timestamp">[]} Records without timestamps.
+     */
+    get all(): Omit<R, "timestamp">[];
+    /**
+     * Returns the number of roll records stored.
+     *
+     * @returns {number} Number of stored records.
+     */
+    get length(): number;
+    /**
+     * Returns the configured maximum number of roll records.
+     *
+     * @returns {number} Maximum records configured.
+     */
+    get maxRecordsCount(): number;
+    /**
+     * Adds a roll record to the history.
+     *
+     * @param {R} record - The record to add.
+     * @throws {TypeError} If the record is not a valid roll record shape.
+     */
+    add(record: R): void;
+    /**
+     * Clears the roll history storage.
+     */
+    clear(): void;
+    /**
+     * Returns the last N roll records.
+     *
+     * @param {number} [n=1] - Number of records to retrieve.
+     * @param {boolean} [verbose=false] - Include timestamps when true.
+     * @returns {(R | Omit<R, "timestamp">)[]} Array of records.
+     */
+    last(n?: number, verbose?: boolean): (R | Omit<R, "timestamp">)[];
+    /**
+     * Produces a roll history report based on the given options.
+     *
+     * @param {{limit?: number; verbose?: boolean}} [options]
+     * @returns {(R | Omit<R, "timestamp">)[]} An array of records per options.
+     */
+    report(options?: {
+        limit?: number;
+        verbose?: boolean;
+    }): (R | Omit<R, "timestamp">)[];
+    /**
+     * Human-readable string summary of roll history.
+     *
+     * @returns {string} Summary that contains last roll and counts.
+     */
+    toString(): string;
+    /** Returns the full history as an array of records */
+    toJSON(): R[];
+}
+//# sourceMappingURL=roll-record-manager.d.ts.map

package/dist/components/die-history/internal/roll-record-manager/roll-record-manager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"roll-record-manager.d.ts","sourceRoot":"","sources":["../../../../../src/components/die-history/internal/roll-record-manager/roll-record-manager.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAU9C;;GAEG;AACH,eAAO,MAAM,mBAAmB,OAAO,CAAC;AAExC;;;;;;;GAOG;AACH,qBAAa,iBAAiB,CAAC,CAAC,SAAS,UAAU,GAAG,UAAU;IAC9D,uCAAuC;IACvC,OAAO,CAAC,OAAO,CAAuB;IACtC,+CAA+C;IAC/C,OAAO,CAAC,UAAU,CAAS;IAE3B;;;;OAIG;gBACS,UAAU,GAAE,MAA4B;IAKpD;;;;OAIG;IACH,IAAI,IAAI,IAAI,CAAC,EAAE,CAEd;IAED;;;;OAIG;IACH,IAAI,GAAG,IAAI,IAAI,CAAC,CAAC,EAAE,WAAW,CAAC,EAAE,CAEhC;IAED;;;;OAIG;IACH,IAAI,MAAM,IAAI,MAAM,CAEnB;IAED;;;;OAIG;IACH,IAAI,eAAe,IAAI,MAAM,CAE5B;IAED;;;;;OAKG;IACH,GAAG,CAAC,MAAM,EAAE,CAAC;IAkBb;;OAEG;IACH,KAAK;IAIL;;;;;;OAMG;IACH,IAAI,CAAC,CAAC,GAAE,MAAU,EAAE,OAAO,UAAQ,GAAG,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC,EAAE,WAAW,CAAC,CAAC,EAAE;IAWlE;;;;;OAKG;IACH,MAAM,CAAC,OAAO,CAAC,EAAE;QACf,KAAK,CAAC,EAAE,MAAM,CAAC;QACf,OAAO,CAAC,EAAE,OAAO,CAAC;KACnB,GAAG,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC,EAAE,WAAW,CAAC,CAAC,EAAE;IAMhC;;;;OAIG;IACH,QAAQ,IAAI,MAAM;IAUlB,sDAAsD;IACtD,MAAM,IAAI,CAAC,EAAE;CAId"}

package/dist/components/die-history/internal/roll-record-validator.d.ts

@@ -0,0 +1,26 @@
+import type { RollRecord, DieRollRecord, ModifiedDieRollRecord, TestDieRollRecord, ModifiedTestDieRollRecord } from "../../../types/index.js";
+/**
+ * Runtime type-guards for RollRecord shapes.
+ * Kept intentionally small and side-effect free.
+ */
+export declare function isDieRollRecord(record: RollRecord | null | undefined): record is DieRollRecord;
+export declare function isModifiedDieRollRecord(record: RollRecord | null | undefined): record is ModifiedDieRollRecord;
+export declare function isTargetDieRollRecord(record: RollRecord | null | undefined): record is TestDieRollRecord;
+export declare function isModifiedTestDieRollRecord(record: RollRecord | null | undefined): record is ModifiedTestDieRollRecord;
+/**
+ * Remove timestamp property from a record (immutable-friendly).
+ *
+ * @template R
+ * @param {R} record - The record to strip timestamp from.
+ * @returns {Omit<R, "timestamp">} The record without the timestamp property.
+ */
+export declare function stripTimestamp<R extends RollRecord>(record: R): Omit<R, "timestamp">;
+declare const _default: {
+    isDieRollRecord: typeof isDieRollRecord;
+    isModifiedDieRollRecord: typeof isModifiedDieRollRecord;
+    isTargetDieRollRecord: typeof isTargetDieRollRecord;
+    isModifiedTestDieRollRecord: typeof isModifiedTestDieRollRecord;
+    stripTimestamp: typeof stripTimestamp;
+};
+export default _default;
+//# sourceMappingURL=roll-record-validator.d.ts.map

package/dist/components/die-history/internal/roll-record-validator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"roll-record-validator.d.ts","sourceRoot":"","sources":["../../../../src/components/die-history/internal/roll-record-validator.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,UAAU,EACV,aAAa,EACb,qBAAqB,EACrB,iBAAiB,EACjB,yBAAyB,EAC1B,MAAM,aAAa,CAAC;AAErB;;;GAGG;AACH,wBAAgB,eAAe,CAC7B,MAAM,EAAE,UAAU,GAAG,IAAI,GAAG,SAAS,GACpC,MAAM,IAAI,aAAa,CAQzB;AAED,wBAAgB,uBAAuB,CACrC,MAAM,EAAE,UAAU,GAAG,IAAI,GAAG,SAAS,GACpC,MAAM,IAAI,qBAAqB,CAQjC;AAED,wBAAgB,qBAAqB,CACnC,MAAM,EAAE,UAAU,GAAG,IAAI,GAAG,SAAS,GACpC,MAAM,IAAI,iBAAiB,CAS7B;AAED,wBAAgB,2BAA2B,CACzC,MAAM,EAAE,UAAU,GAAG,IAAI,GAAG,SAAS,GACpC,MAAM,IAAI,yBAAyB,CASrC;AAED;;;;;;GAMG;AACH,wBAAgB,cAAc,CAAC,CAAC,SAAS,UAAU,EACjD,MAAM,EAAE,CAAC,GACR,IAAI,CAAC,CAAC,EAAE,WAAW,CAAC,CAGtB;;;;;;;;AAED,wBAME"}

package/dist/components/die-history/roll-record-factory.d.ts

@@ -0,0 +1,90 @@
+import type { RollModifierFunction, RollModifierInstance, TestConditionsInstance } from "@platonic-dice/core";
+import type { DieTypeValue, TestTypeValue, RollTypeValue } from "@platonic-dice/core";
+import type { DieRollRecord, ModifiedDieRollRecord, TestDieRollRecord, ModifiedTestDieRollRecord } from "../../types/index.js";
+/**
+ * Factory interface for producing RollRecord values.
+ *
+ * This module centralizes the creation of roll records (normal, modified
+ * and test rolls). The implementation intentionally keeps a small public
+ * surface: callers request a record and receive a validated object ready
+ * to be persisted in history. The default implementation delegates to the
+ * `@platonic-dice/core` roll functions and stamps records with the system
+ * clock. No constructor-based dependency injection is used here to keep
+ * the API simple; tests can still override behaviour by calling the
+ * factory methods directly.
+ */
+export interface IRollRecordFactory {
+    /**
+     * Create a simple numeric roll record for the given die.
+     *
+     * @param {DieTypeValue} dieType - The die type (e.g. `DieType.D6`).
+     * @param {RollTypeValue} [rollType] - Optional roll mode (advantage/disadvantage).
+     * @returns {DieRollRecord} A validated die roll record containing `roll` and `timestamp`.
+     * @throws {TypeError} If `rollType` is not a valid `RollTypeValue`.
+     */
+    createNormalRoll(dieType: DieTypeValue, rollType?: RollTypeValue): DieRollRecord;
+    /**
+     * Create a modified roll record. The modifier may be a numeric or
+     * functional modifier; the factory resolves base and modified values.
+     *
+     * @param {DieTypeValue} dieType - The die type to roll.
+     * @param {RollModifierFunction|RollModifierInstance} modifier - Modifier applied to the base roll.
+     * @param {RollTypeValue} [rollType] - Optional roll mode.
+     * @returns {ModifiedDieRollRecord} A validated modified roll record.
+     */
+    createModifiedRoll(dieType: DieTypeValue, modifier: RollModifierFunction | RollModifierInstance, rollType?: RollTypeValue): ModifiedDieRollRecord;
+    /**
+     * Create a test roll record. `testConditions` may be a plain object or
+     * a `TestConditionsInstance` — the core library will normalise and
+     * validate it. The returned record contains `roll` and `outcome`.
+     *
+     * @param {DieTypeValue} dieType - The die type to roll.
+     * @param {TestConditionsInstance|{ testType: TestTypeValue; [k: string]: any }} testConditions - Test descriptor or instance.
+     * @param {RollTypeValue} [rollType] - Optional roll mode.
+     * @returns {TestDieRollRecord} A validated test roll record containing `roll`, `outcome`, and `timestamp`.
+     */
+    createTestRoll(dieType: DieTypeValue, testConditions: TestConditionsInstance | {
+        testType: TestTypeValue;
+        [k: string]: any;
+    }, rollType?: RollTypeValue): TestDieRollRecord;
+    /**
+     * Create a modified test roll record. Combines modifier and test evaluation.
+     *
+     * @param {DieTypeValue} dieType - The die type to roll.
+     * @param {RollModifierFunction|RollModifierInstance} modifier - Modifier applied to the base roll.
+     * @param {TestConditionsInstance|{ testType: TestTypeValue; [k: string]: any }} testConditions - Test descriptor or instance.
+     * @param {RollTypeValue} [rollType] - Optional roll mode.
+     * @param {{useNaturalCrits?: boolean}} [options] - Optional configuration for natural crits.
+     * @returns {ModifiedTestDieRollRecord} A validated modified test roll record containing `roll`, `modified`, `outcome`, and `timestamp`.
+     */
+    createModifiedTestRoll(dieType: DieTypeValue, modifier: RollModifierFunction | RollModifierInstance, testConditions: TestConditionsInstance | {
+        testType: TestTypeValue;
+        [k: string]: any;
+    }, rollType?: RollTypeValue, options?: {
+        useNaturalCrits?: boolean;
+    }): ModifiedTestDieRollRecord;
+}
+/**
+ * Default implementation that delegates to `@platonic-dice/core` and uses
+ * the system clock. This keeps the public API simple and avoids DI.
+ */
+/**
+ * Implementation of RollRecordFactory that delegates to @platonic-dice/core and uses the system clock.
+ * This keeps the public API simple and avoids DI.
+ */
+export declare class RollRecordFactory implements IRollRecordFactory {
+    createNormalRoll(dieType: DieTypeValue, rollType?: RollTypeValue): DieRollRecord;
+    createModifiedRoll(dieType: DieTypeValue, modifier: RollModifierFunction | RollModifierInstance, rollType?: RollTypeValue): ModifiedDieRollRecord;
+    createTestRoll(dieType: DieTypeValue, testConditions: TestConditionsInstance | {
+        testType: TestTypeValue;
+        [k: string]: any;
+    }, rollType?: RollTypeValue): TestDieRollRecord;
+    createModifiedTestRoll(dieType: DieTypeValue, modifier: RollModifierFunction | RollModifierInstance, testConditions: TestConditionsInstance | {
+        testType: TestTypeValue;
+        [k: string]: any;
+    }, rollType?: RollTypeValue, options?: {
+        useNaturalCrits?: boolean;
+    }): ModifiedTestDieRollRecord;
+}
+export default RollRecordFactory;
+//# sourceMappingURL=roll-record-factory.d.ts.map

package/dist/components/die-history/roll-record-factory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"roll-record-factory.d.ts","sourceRoot":"","sources":["../../../src/components/die-history/roll-record-factory.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EACV,oBAAoB,EACpB,oBAAoB,EACpB,sBAAsB,EACvB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,KAAK,EACV,YAAY,EACZ,aAAa,EACb,aAAa,EACd,MAAM,qBAAqB,CAAC;AAE7B,OAAO,KAAK,EACV,aAAa,EACb,qBAAqB,EACrB,iBAAiB,EACjB,yBAAyB,EAC1B,MAAM,aAAa,CAAC;AAWrB;;;;;;;;;;;GAWG;AACH,MAAM,WAAW,kBAAkB;IACjC;;;;;;;OAOG;IACH,gBAAgB,CACd,OAAO,EAAE,YAAY,EACrB,QAAQ,CAAC,EAAE,aAAa,GACvB,aAAa,CAAC;IAEjB;;;;;;;;OAQG;IACH,kBAAkB,CAChB,OAAO,EAAE,YAAY,EACrB,QAAQ,EAAE,oBAAoB,GAAG,oBAAoB,EACrD,QAAQ,CAAC,EAAE,aAAa,GACvB,qBAAqB,CAAC;IAEzB;;;;;;;;;OASG;IACH,cAAc,CACZ,OAAO,EAAE,YAAY,EACrB,cAAc,EACV,sBAAsB,GACtB;QAAE,QAAQ,EAAE,aAAa,CAAC;QAAC,CAAC,CAAC,EAAE,MAAM,GAAG,GAAG,CAAA;KAAE,EACjD,QAAQ,CAAC,EAAE,aAAa,GACvB,iBAAiB,CAAC;IAErB;;;;;;;;;OASG;IACH,sBAAsB,CACpB,OAAO,EAAE,YAAY,EACrB,QAAQ,EAAE,oBAAoB,GAAG,oBAAoB,EACrD,cAAc,EACV,sBAAsB,GACtB;QAAE,QAAQ,EAAE,aAAa,CAAC;QAAC,CAAC,CAAC,EAAE,MAAM,GAAG,GAAG,CAAA;KAAE,EACjD,QAAQ,CAAC,EAAE,aAAa,EACxB,OAAO,CAAC,EAAE;QAAE,eAAe,CAAC,EAAE,OAAO,CAAA;KAAE,GACtC,yBAAyB,CAAC;CAC9B;AAED;;;GAGG;AAEH;;;GAGG;AACH,qBAAa,iBAAkB,YAAW,kBAAkB;IAC1D,gBAAgB,CACd,OAAO,EAAE,YAAY,EACrB,QAAQ,CAAC,EAAE,aAAa,GACvB,aAAa;IAsBhB,kBAAkB,CAChB,OAAO,EAAE,YAAY,EACrB,QAAQ,EAAE,oBAAoB,GAAG,oBAAoB,EACrD,QAAQ,CAAC,EAAE,aAAa,GACvB,qBAAqB;IAiBxB,cAAc,CACZ,OAAO,EAAE,YAAY,EACrB,cAAc,EACV,sBAAsB,GACtB;QAAE,QAAQ,EAAE,aAAa,CAAC;QAAC,CAAC,CAAC,EAAE,MAAM,GAAG,GAAG,CAAA;KAAE,EACjD,QAAQ,CAAC,EAAE,aAAa,GACvB,iBAAiB;IAcpB,sBAAsB,CACpB,OAAO,EAAE,YAAY,EACrB,QAAQ,EAAE,oBAAoB,GAAG,oBAAoB,EACrD,cAAc,EACV,sBAAsB,GACtB;QAAE,QAAQ,EAAE,aAAa,CAAC;QAAC,CAAC,CAAC,EAAE,MAAM,GAAG,GAAG,CAAA;KAAE,EACjD,QAAQ,CAAC,EAAE,aAAa,EACxB,OAAO,CAAC,EAAE;QAAE,eAAe,CAAC,EAAE,OAAO,CAAA;KAAE,GACtC,yBAAyB;CAuB7B;AAED,eAAe,iBAAiB,CAAC"}

package/dist/components/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./die-history/index.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/components/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/components/index.ts"],"names":[],"mappings":"AAAA,cAAc,eAAe,CAAC"}

package/dist/die.d.ts

@@ -0,0 +1,197 @@
+import type { DieTypeValue, RollModifierFunction, RollModifierInstance, TestConditionsInstance } from "@platonic-dice/core";
+import type { RollTypeValue, TestTypeValue } from "@platonic-dice/core";
+import { HistoryCache } from "./components/index.js";
+import type { RollRecord } from "./types/index.js";
+/**
+ * Represents a single die with flexible history tracking.
+ *
+ * The Die class provides:
+ * - Normal rolls (numeric)
+ * - Modified rolls (numeric or functional modifiers)
+ * - Test rolls (success/failure evaluation)
+ *
+ * Each roll type is stored independently in a `RollHistoryCache`.
+ *
+ * Example:
+ * ```ts
+ * const d20 = new Die(DieType.D20);
+ * const result = d20.roll(); // normal roll
+ * const modResult = d20.rollMod(n => n + 2); // modified roll
+ * const testResult = d20.rollTest({ testType: "AtLeast", target: 15 });
+ * ```
+ */
+export declare class Die {
+    private readonly typeValue;
+    private readonly rolls;
+    private resultValue?;
+    private readonly recordFactory;
+    /** Keys used internally for history separation */
+    private static readonly NORMAL_KEY;
+    private static readonly MODIFIER_KEY;
+    private static readonly TEST_KEY;
+    private static readonly MODIFIED_TEST_KEY;
+    /**
+     * Create a new Die instance.
+     * @param type - The die type (must be a value from `DieType`)
+     * @param historyCache - Optional custom `RollHistoryCache` instance
+     */
+    /**
+     * Create a new Die instance.
+     *
+     * @param {DieTypeValue} type - The die type (must be a value from `DieType`).
+     * @param {HistoryCache<RollRecord>} [historyCache] - Optional custom history cache instance.
+     * @throws {Error} If `type` is not a valid `DieType` value.
+     */
+    constructor(type: DieTypeValue, historyCache?: HistoryCache<RollRecord>);
+    /**
+     * Notes on behavior and contracts
+     * - `resultValue` holds the most recent numeric value produced by a roll
+     *   operation. It is updated from factory-produced records: for normal and
+     *   test rolls it tracks `record.roll`; for modified rolls it tracks
+     *   `record.modified`.
+     * - `rolls` is a `HistoryCache` that stores separate histories keyed by
+     *   roll type (normal/modifier/test). Each public roll method sets the
+     *   corresponding active key, creates a factory-produced record and adds
+     *   it to the active history. Record shape validation happens at the
+     *   `RollRecordManager.add()` boundary.
+     */
+    /** The die type (e.g., `d6`, `d20`) */
+    get type(): DieTypeValue;
+    /** The most recent numeric roll result, or undefined if not rolled yet */
+    get result(): number | undefined;
+    /** Number of faces on this die */
+    get faceCount(): number;
+    /**
+     * Reset the most recent result.
+     * @param complete - If true, clears all histories for all roll types
+     */
+    reset(complete?: boolean): void;
+    /**
+     * Perform a normal die roll.
+     * @param rollType - Optional roll mode (`RollType.Advantage` / `RollType.Disadvantage`)
+     * @returns The numeric result
+     */
+    /**
+     * Perform a normal die roll.
+     *
+     * @param {RollTypeValue} [rollType] - Optional roll mode (`RollType.Advantage` / `RollType.Disadvantage`).
+     * @returns {number} The numeric result of the roll.
+     * @throws {Error} If `rollType` is provided but invalid.
+     */
+    roll(rollType?: RollTypeValue): number;
+    /**
+     * Perform a roll with a modifier.
+     *
+     * @param modifier - Numeric or functional modifier (function `(n: number) => number` or `RollModifierInstance`)
+     * @param rollType - Optional roll mode (`RollType.Advantage` / `RollType.Disadvantage`)
+     * @returns The modified numeric result
+     *
+     * Example:
+     * ```ts
+     * d20.rollMod(n => n + 2); // adds +2 to the roll
+     * ```
+     */
+    /**
+     * Perform a roll with a modifier.
+     *
+     * @param {RollModifierFunction | RollModifierInstance} modifier - Numeric or functional modifier applied to the base roll.
+     * @param {RollTypeValue} [rollType] - Optional roll mode (`RollType.Advantage` / `RollType.Disadvantage`).
+     * @returns {number} The modified numeric result.
+     * @example
+     * d20.rollMod(n => n + 2); // adds +2 to the roll
+     */
+    rollMod(modifier: RollModifierFunction | RollModifierInstance, rollType?: RollTypeValue): number;
+    /**
+     * Perform a roll against test conditions (success/failure evaluation).
+     *
+     * @param testConditions - Test conditions (plain object or `TestConditionsInstance`)
+     * @param rollType - Optional roll mode (`RollType.Advantage` / `RollType.Disadvantage`)
+     * @returns The base numeric roll
+     *
+     * Example:
+     * ```ts
+     * d20.rollTest({ testType: "AtLeast", target: 15 });
+     * ```
+     */
+    /**
+     * Perform a roll against test conditions (success/failure evaluation).
+     *
+     * @param {TestConditionsInstance | { testType: TestTypeValue; [k: string]: any }} testConditions - Test conditions (plain object or normalized `TestConditions` instance).
+     * @param {RollTypeValue} [rollType] - Optional roll mode (`RollType.Advantage` / `RollType.Disadvantage`).
+     * @returns {number} The base numeric roll used to evaluate the test.
+     * @throws {Error} If `testConditions` or `rollType` are invalid (delegated to core).
+     * @example
+     * d20.rollTest({ testType: "at_least", target: 15 });
+     */
+    rollTest(testConditions: TestConditionsInstance | {
+        testType: TestTypeValue;
+        [k: string]: any;
+    }, rollType?: RollTypeValue): number;
+    /**
+     * Perform a roll with a modifier and evaluate against test conditions.
+     * Combines rollMod and rollTest functionality.
+     *
+     * @param {RollModifierFunction | RollModifierInstance} modifier - Numeric or functional modifier applied to the base roll.
+     * @param {TestConditionsInstance | { testType: TestTypeValue; [k: string]: any }} testConditions - Test conditions (plain object or normalized `TestConditions` instance).
+     * @param {RollTypeValue} [rollType] - Optional roll mode (`RollType.Advantage` / `RollType.Disadvantage`).
+     * @param {{useNaturalCrits?: boolean}} [options] - Optional configuration for natural crits behavior.
+     * @returns {number} The modified numeric result.
+     * @throws {Error} If inputs are invalid (delegated to core).
+     * @example
+     * d20.rollModTest(n => n + 5, { testType: "at_least", target: 15 });
+     */
+    rollModTest(modifier: RollModifierFunction | RollModifierInstance, testConditions: TestConditionsInstance | {
+        testType: TestTypeValue;
+        [k: string]: any;
+    }, rollType?: RollTypeValue, options?: {
+        useNaturalCrits?: boolean;
+    }): number;
+    /**
+     * Retrieve roll history for a given key.
+     *
+     * @param key - `"normal" | "modifier" | "test"`
+     * @param verbose - Include timestamps if true
+     * @returns Array of roll records (timestamps included if verbose)
+     */
+    /**
+     * Retrieve roll history for a given key.
+     *
+     * @param {string} [key=Die.NORMAL_KEY] - One of "normal" | "modifier" | "test" | "modifiedTest".
+     * @param {boolean} [verbose=false] - Include timestamps when true.
+     * @returns {Array} Array of roll records (timestamps included when verbose).
+     */
+    history(key?: string, verbose?: boolean): RollRecord[] | Omit<RollRecord, "timestamp">[];
+    /**
+     * Retrieve a roll report for a specific key.
+     *
+     * @param key - `"normal" | "modifier" | "test"`
+     * @param options - Optional report options (`limit` and `verbose`)
+     * @returns Array of roll records (subject to limit and verbose)
+     */
+    /**
+     * Retrieve a roll report for a specific key.
+     *
+     * @param {string} [key=Die.NORMAL_KEY] - History key to report on.
+     * @param {{limit?: number, verbose?: boolean}} [options] - Report options.
+     * @returns {Array} Array of roll records (subject to `limit` and `verbose`).
+     */
+    report(key?: string, options?: {
+        limit?: number;
+        verbose?: boolean;
+    }): (RollRecord | Omit<RollRecord, "timestamp">)[];
+    /** Human-readable summary of the die */
+    /**
+     * Human-readable summary of the die
+     *
+     * @returns {string} Short description including last result if present.
+     */
+    toString(): string;
+    /** JSON representation of all histories keyed by roll type */
+    /**
+     * JSON representation of all histories keyed by roll type
+     *
+     * @returns {Record<string, RollRecord[]>} Mapping of history keys to arrays of records.
+     */
+    toJSON(): Record<string, RollRecord[]>;
+}
+//# sourceMappingURL=die.d.ts.map

package/dist/die.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"die.d.ts","sourceRoot":"","sources":["../src/die.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EACV,YAAY,EACZ,oBAAoB,EACpB,oBAAoB,EACpB,sBAAsB,EACvB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,KAAK,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAExE,OAAO,EAAqB,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAEnE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAE9C;;;;;;;;;;;;;;;;;GAiBG;AACH,qBAAa,GAAG;IACd,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAe;IACzC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAA2B;IACjD,OAAO,CAAC,WAAW,CAAC,CAAS;IAC7B,OAAO,CAAC,QAAQ,CAAC,aAAa,CAA2B;IAEzD,kDAAkD;IAClD,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,UAAU,CAAY;IAC9C,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,YAAY,CAAc;IAClD,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,QAAQ,CAAU;IAC1C,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,iBAAiB,CAAkB;IAE3D;;;;OAIG;IACH;;;;;;OAMG;gBACS,IAAI,EAAE,YAAY,EAAE,YAAY,CAAC,EAAE,YAAY,CAAC,UAAU,CAAC;IAUvE;;;;;;;;;;;OAWG;IAEH,uCAAuC;IACvC,IAAI,IAAI,IAAI,YAAY,CAEvB;IAED,0EAA0E;IAC1E,IAAI,MAAM,IAAI,MAAM,GAAG,SAAS,CAE/B;IAED,kCAAkC;IAClC,IAAI,SAAS,IAAI,MAAM,CAUtB;IAED;;;OAGG;IACH,KAAK,CAAC,QAAQ,UAAQ,GAAG,IAAI;IAK7B;;;;OAIG;IACH;;;;;;OAMG;IACH,IAAI,CAAC,QAAQ,CAAC,EAAE,aAAa,GAAG,MAAM;IAqBtC;;;;;;;;;;;OAWG;IACH;;;;;;;;OAQG;IACH,OAAO,CACL,QAAQ,EAAE,oBAAoB,GAAG,oBAAoB,EACrD,QAAQ,CAAC,EAAE,aAAa,GACvB,MAAM;IAcT;;;;;;;;;;;OAWG;IACH;;;;;;;;;OASG;IACH,QAAQ,CACN,cAAc,EACV,sBAAsB,GACtB;QAAE,QAAQ,EAAE,aAAa,CAAC;QAAC,CAAC,CAAC,EAAE,MAAM,GAAG,GAAG,CAAA;KAAE,EACjD,QAAQ,CAAC,EAAE,aAAa,GACvB,MAAM;IAcT;;;;;;;;;;;;OAYG;IACH,WAAW,CACT,QAAQ,EAAE,oBAAoB,GAAG,oBAAoB,EACrD,cAAc,EACV,sBAAsB,GACtB;QAAE,QAAQ,EAAE,aAAa,CAAC;QAAC,CAAC,CAAC,EAAE,MAAM,GAAG,GAAG,CAAA;KAAE,EACjD,QAAQ,CAAC,EAAE,aAAa,EACxB,OAAO,CAAC,EAAE;QAAE,eAAe,CAAC,EAAE,OAAO,CAAA;KAAE,GACtC,MAAM;IAgBT;;;;;;OAMG;IACH;;;;;;OAMG;IACH,OAAO,CAAC,GAAG,GAAE,MAAuB,EAAE,OAAO,UAAQ;IAKrD;;;;;;OAMG;IACH;;;;;;OAMG;IACH,MAAM,CACJ,GAAG,GAAE,MAAuB,EAC5B,OAAO,CAAC,EAAE;QAAE,KAAK,CAAC,EAAE,MAAM,CAAC;QAAC,OAAO,CAAC,EAAE,OAAO,CAAA;KAAE;IAMjD,wCAAwC;IACxC;;;;OAIG;IACH,QAAQ,IAAI,MAAM;IAMlB,8DAA8D;IAC9D;;;;OAIG;IACH,MAAM;CAGP"}

package/dist/index.d.ts

@@ -0,0 +1,21 @@
+/**
+ * @module @platonic-dice/dice
+ * @description
+ * Persistent dice objects with roll history and TypeScript support.
+ */
+export { Die } from "./die.js";
+import core from "@platonic-dice/core";
+export declare const DieType: Readonly<{
+    D4: "d4";
+    D6: "d6";
+    D8: "d8";
+    D10: "d10";
+    D12: "d12";
+    D20: "d20";
+}>, RollType: Readonly<{
+    Advantage: "advantage";
+    Disadvantage: "disadvantage";
+}>, rollModTest: typeof core.rollModTest;
+export type { DieTypeValue, RollModifierFunction, RollModifierInstance, TestConditionsInstance, RollTypeValue, TestTypeValue, } from "@platonic-dice/core";
+export type { RollRecord, DieRollRecord, ModifiedDieRollRecord, TestDieRollRecord, ModifiedTestDieRollRecord, } from "./types/roll-record.types.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;;;;GAIG;AAGH,OAAO,EAAE,GAAG,EAAE,MAAM,UAAU,CAAC;AAI/B,OAAO,IAAI,MAAM,qBAAqB,CAAC;AACvC,eAAO,MAAQ,OAAO;;;;;;;IAAE,QAAQ;;;IAAE,WAAW,yBAAS,CAAC;AACvD,YAAY,EACV,YAAY,EACZ,oBAAoB,EACpB,oBAAoB,EACpB,sBAAsB,EACtB,aAAa,EACb,aAAa,GACd,MAAM,qBAAqB,CAAC;AAG7B,YAAY,EACV,UAAU,EACV,aAAa,EACb,qBAAqB,EACrB,iBAAiB,EACjB,yBAAyB,GAC1B,MAAM,8BAA8B,CAAC"}

package/dist/types/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./roll-record.types.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/types/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/types/index.ts"],"names":[],"mappings":"AAAA,cAAc,qBAAqB,CAAC"}

package/dist/types/roll-record.types.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Types for roll records used across the dice package.
+ * These represent the persisted shape for normal, modified and test rolls.
+ */
+import type { OutcomeValue } from "@platonic-dice/core";
+/**
+ * Simple die roll record.
+ */
+export interface DieRollRecord {
+    roll: number;
+    timestamp: Date;
+}
+/**
+ * Modified die roll record.
+ */
+export interface ModifiedDieRollRecord {
+    roll: number;
+    modified: number;
+    timestamp: Date;
+}
+/**
+ * Targeted test roll record (e.g., success/failure).
+ */
+export interface TestDieRollRecord {
+    roll: number;
+    outcome: OutcomeValue;
+    timestamp: Date;
+}
+/**
+ * Modified test roll record (combines modifier and test evaluation).
+ */
+export interface ModifiedTestDieRollRecord {
+    roll: number;
+    modified: number;
+    outcome: OutcomeValue;
+    timestamp: Date;
+}
+/**
+ * Union type for all possible roll records.
+ */
+export type RollRecord = DieRollRecord | ModifiedDieRollRecord | TestDieRollRecord | ModifiedTestDieRollRecord;
+//# sourceMappingURL=roll-record.types.d.ts.map

package/dist/types/roll-record.types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"roll-record.types.d.ts","sourceRoot":"","sources":["../../src/types/roll-record.types.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAExD;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,IAAI,CAAC;CACjB;AAED;;GAEG;AACH,MAAM,WAAW,qBAAqB;IACpC,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,IAAI,CAAC;CACjB;AAED;;GAEG;AACH,MAAM,WAAW,iBAAiB;IAChC,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,YAAY,CAAC;IACtB,SAAS,EAAE,IAAI,CAAC;CACjB;AAED;;GAEG;AACH,MAAM,WAAW,yBAAyB;IACxC,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,YAAY,CAAC;IACtB,SAAS,EAAE,IAAI,CAAC;CACjB;AAED;;GAEG;AACH,MAAM,MAAM,UAAU,GAClB,aAAa,GACb,qBAAqB,GACrB,iBAAiB,GACjB,yBAAyB,CAAC"}

package/package.json

@@ -1,6 +1,7 @@
 {
   "name": "@platonic-dice/dice",
-  "version": "2.1.1",
+  "version": "2.2.1",
+  "packageManager": "pnpm@8.15.9",
   "description": "Persistent dice objects with roll history and TypeScript support.",
   "type": "module",
   "main": "dist/index.js",
@@ -34,16 +35,17 @@
   "homepage": "https://github.com/sjs2k20/platonic-dice.git#readme",
   "scripts": {
     "build": "tsc -p tsconfig.build.json && tsc-alias -p tsconfig.build.json",
-    "prepublishOnly": "npm run build",
+    "prepublishOnly": "pnpm run build",
     "test": "vitest run",
     "test:watch": "vitest"
   },
   "dependencies": {
-    "@platonic-dice/core": "^2.1.2"
+    "@platonic-dice/core": "^2.2.2"
   },
   "devDependencies": {
     "tsc-alias": "^1.8.16",
     "vite-tsconfig-paths": "^5.1.4",
-    "vitest": "^4.0.9"
+    "vitest": "^4.0.9",
+    "@types/node": "^22.13.8"
   }
 }