@platonic-dice/dice 2.0.2 → 2.0.3

package/dist/{src/components → components}/die-history/history-cache.js

@@ -1,4 +1,4 @@
-import { RollRecordManager, DEFAULT_MAX_RECORDS } from "./internal";
+import { RollRecordManager, DEFAULT_MAX_RECORDS } from "./internal/index.js";
 /**
  * A wrapper for RollRecordManager that maintains multiple, independently capped histories.
  *

package/dist/components/die-history/index.js

@@ -0,0 +1,2 @@
+export { RollRecordFactory } from "./roll-record-factory.js";
+export { HistoryCache } from "./history-cache.js";

package/dist/components/die-history/internal/index.js

@@ -0,0 +1,2 @@
+export { RollRecordManager, DEFAULT_MAX_RECORDS } from "./roll-record-manager/index.js";
+export * from "./roll-record-validator.js";

package/dist/{src/components → components}/die-history/internal/roll-record-manager/index.js

@@ -1 +1 @@
-export { RollRecordManager, DEFAULT_MAX_RECORDS } from "./roll-record-manager";
+export { RollRecordManager, DEFAULT_MAX_RECORDS } from "./roll-record-manager.js";

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

@@ -0,0 +1 @@
+export * from "./roll-record-storage.js";

package/dist/{src/components → components}/die-history/internal/roll-record-manager/roll-record-manager.js

@@ -1,5 +1,5 @@
-import { isDieRollRecord, isModifiedDieRollRecord, isTargetDieRollRecord, stripTimestamp, } from "../roll-record-validator";
-import { RollRecordStorage } from "./internal";
+import { isDieRollRecord, isModifiedDieRollRecord, isTargetDieRollRecord, stripTimestamp, } from "../roll-record-validator.js";
+import { RollRecordStorage } from "./internal/index.js";
 /**
  * Default maximum number of roll records stored.
  */

package/dist/{src/components → components}/die-history/internal/roll-record-validator.js

@@ -1,4 +1,5 @@
-import { Outcome } from "@platonic-dice/core";
+import core from "@platonic-dice/core";
+const { Outcome } = core;
 /**
  * Runtime type-guards for RollRecord shapes.
  * Kept intentionally small and side-effect free.

package/dist/{src/components → components}/die-history/roll-record-factory.js

@@ -1,5 +1,6 @@
-import { RollType, roll as coreRoll, rollMod as coreRollMod, rollTest as coreRollTest, } from "@platonic-dice/core";
-import { isDieRollRecord, isModifiedDieRollRecord, isTargetDieRollRecord, } from "./internal";
+import core from "@platonic-dice/core";
+const { RollType, roll: coreRoll, rollMod: coreRollMod, rollTest: coreRollTest, } = core;
+import { isDieRollRecord, isModifiedDieRollRecord, isTargetDieRollRecord, } from "./internal/index.js";
 /**
  * Default implementation that delegates to `@platonic-dice/core` and uses
  * the system clock. This keeps the public API simple and avoids DI.

package/dist/components/index.js

@@ -0,0 +1 @@
+export * from "./die-history/index.js";

package/dist/{src/die.js → die.js}

@@ -1,5 +1,6 @@
-import { DieType, RollType } from "@platonic-dice/core";
-import { RollRecordFactory, HistoryCache } from "@dice/components";
+import core from "@platonic-dice/core";
+const { DieType, RollType } = core;
+import { RollRecordFactory, HistoryCache } from "./components/index.js";
 /**
  * Represents a single die with flexible history tracking.
  *

package/dist/index.js

@@ -0,0 +1,11 @@
+/**
+ * @module @platonic-dice/dice
+ * @description
+ * Persistent dice objects with roll history and TypeScript support.
+ */
+// Main Die class
+export { Die } from "./die.js";
+// Re-export core types and values that consumers will need
+// Note: Import from default due to CommonJS/ESM interop
+import core from "@platonic-dice/core";
+export const { DieType, RollType } = core;

package/dist/types/index.js

@@ -0,0 +1 @@
+export * from "./roll-record.types.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@platonic-dice/dice",
-  "version": "2.0.2",
+  "version": "2.0.3",
   "description": "Persistent dice objects with roll history and TypeScript support.",
   "type": "module",
   "main": "dist/index.js",
@@ -33,15 +33,16 @@
   },
   "homepage": "https://github.com/sjs2k20/platonic-dice.git#readme",
   "scripts": {
-    "build": "tsc -p tsconfig.json",
+    "build": "tsc -p tsconfig.build.json && tsc-alias -p tsconfig.build.json",
     "prepublishOnly": "npm run build",
     "test": "vitest run",
     "test:watch": "vitest"
   },
   "dependencies": {
-    "@platonic-dice/core": "^2.0.2"
+    "@platonic-dice/core": "^2.0.3"
   },
   "devDependencies": {
+    "tsc-alias": "^1.8.16",
     "vite-tsconfig-paths": "^5.1.4",
     "vitest": "^4.0.9"
   }

package/dist/__tests__/components/die-history/history-cache.spec.js

@@ -1,106 +0,0 @@
-/// <reference types="vitest" />
-import { describe, it, expect, beforeEach } from "vitest";
-import { HistoryCache } from "@dice/components/die-history";
-describe("RollHistoryCache", () => {
-    let cache;
-    beforeEach(() => {
-        cache = new HistoryCache({
-            maxRecordsPerKey: 3,
-            maxKeys: 2,
-        });
-    });
-    it("starts empty", () => {
-        expect(cache.activeManager).toBeUndefined();
-        expect(cache.getAll()).toEqual([]);
-    });
-    it("throws if add called before setting active key", () => {
-        expect(() => cache.add({ roll: 1, timestamp: new Date() })).toThrow(/No active history key set/);
-    });
-    it("creates and sets an active key", () => {
-        cache.setActiveKey("first");
-        expect(cache.activeManager).toBeDefined();
-        expect(cache.getAll()).toEqual([]);
-    });
-    it("adds records to the active key", () => {
-        cache.setActiveKey("key1");
-        const record = { roll: 5, timestamp: new Date() };
-        cache.add(record);
-        const all = cache.getAll(true);
-        expect(all.length).toBe(1);
-        expect(all[0].roll).toBe(5);
-    });
-    it("respects maxRecordsPerKey", () => {
-        cache.setActiveKey("key1");
-        const now = new Date();
-        for (let i = 1; i <= 5; i++) {
-            cache.add({ roll: i, timestamp: new Date(now.getTime() + i) });
-        }
-        const all = cache.getAll(true);
-        expect(all.length).toBe(3); // capped
-        expect(all[0].roll).toBe(3); // oldest removed
-        expect(all[2].roll).toBe(5);
-    });
-    it("switching keys creates independent histories", () => {
-        cache.setActiveKey("A");
-        cache.add({ roll: 1, timestamp: new Date() });
-        cache.setActiveKey("B");
-        cache.add({ roll: 2, timestamp: new Date() });
-        cache.setActiveKey("A");
-        expect(cache.getAll(true)[0].roll).toBe(1);
-        cache.setActiveKey("B");
-        expect(cache.getAll(true)[0].roll).toBe(2);
-    });
-    it("evicts oldest key when maxKeys exceeded", () => {
-        cache.setActiveKey("K1");
-        cache.add({ roll: 1, timestamp: new Date() });
-        cache.setActiveKey("K2");
-        cache.add({ roll: 2, timestamp: new Date() });
-        // Max keys = 2, next key should evict K1
-        cache.setActiveKey("K3");
-        cache.add({ roll: 3, timestamp: new Date() });
-        const report = cache.report({ verbose: true });
-        expect(Object.keys(report)).not.toContain("K1");
-        expect(Object.keys(report)).toContain("K2");
-        expect(Object.keys(report)).toContain("K3");
-    });
-    it("clearActive clears only the active key", () => {
-        cache.setActiveKey("A");
-        cache.add({ roll: 1, timestamp: new Date() });
-        cache.setActiveKey("B");
-        cache.add({ roll: 2, timestamp: new Date() });
-        cache.setActiveKey("A");
-        cache.clearActive();
-        expect(cache.getAll(true)).toEqual([]);
-        cache.setActiveKey("B");
-        expect(cache.getAll(true).length).toBe(1);
-    });
-    it("clearAll clears everything", () => {
-        cache.setActiveKey("X");
-        cache.add({ roll: 1, timestamp: new Date() });
-        cache.setActiveKey("Y");
-        cache.add({ roll: 2, timestamp: new Date() });
-        cache.clearAll();
-        expect(cache.getAll()).toEqual([]);
-        expect(Object.keys(cache.report())).toEqual([]);
-    });
-    it("report returns correct verbose and non-verbose data", () => {
-        cache.setActiveKey("R1");
-        cache.add({ roll: 10, timestamp: new Date() });
-        const reportsVerbose = cache.report({ verbose: true });
-        const reportsNonVerbose = cache.report({ verbose: false });
-        expect(reportsVerbose["R1"][0]).toHaveProperty("timestamp");
-        expect(reportsNonVerbose["R1"][0]).not.toHaveProperty("timestamp");
-    });
-    it("toString returns a readable summary", () => {
-        cache.setActiveKey("Active");
-        expect(cache.toString()).toMatch(/HistoryCache: 1 keys \(active: Active\)/);
-    });
-    it("toJSON returns object with arrays of RollRecords", () => {
-        cache.setActiveKey("J");
-        const record = { roll: 7, timestamp: new Date() };
-        cache.add(record);
-        const json = cache.toJSON();
-        expect(json).toHaveProperty("J");
-        expect(json["J"][0].roll).toBe(7);
-    });
-});

package/dist/__tests__/components/die-history/internal/roll-record-manager/internal/roll-record-storage.spec.js

@@ -1,40 +0,0 @@
-import { describe, it, expect } from "vitest";
-import RollRecordStorage from "@dice/components/die-history/internal/roll-record-manager/internal/roll-record-storage";
-describe("RollRecordStorage", () => {
-    it("evicts oldest when capacity exceeded", () => {
-        const s = new RollRecordStorage(2);
-        s.add({ roll: 1, timestamp: new Date() });
-        s.add({ roll: 2, timestamp: new Date() });
-        s.add({ roll: 3, timestamp: new Date() });
-        expect(s.size).toBe(2);
-        expect(s.full.map((r) => r.roll)).toEqual([2, 3]);
-    });
-    it("last returns correct slice and order", () => {
-        const s = new RollRecordStorage(10);
-        s.add({ roll: 1, timestamp: new Date() });
-        s.add({ roll: 2, timestamp: new Date() });
-        s.add({ roll: 3, timestamp: new Date() });
-        s.add({ roll: 4, timestamp: new Date() });
-        const last2 = s.last(2);
-        expect(last2.map((r) => r.roll)).toEqual([3, 4]);
-    });
-    it("getters return array copies (mutating returned arrays doesn't affect storage)", () => {
-        const s = new RollRecordStorage(3);
-        s.add({ roll: 1, timestamp: new Date() });
-        const full = s.full;
-        full.pop();
-        expect(s.size).toBe(1);
-        const last = s.last(1);
-        // mutating the returned array should not affect internal storage length
-        last.pop();
-        expect(s.size).toBe(1);
-    });
-    it("throws for invalid constructor args and parameters", () => {
-        // call via any to test runtime throw without TS compile errors
-        expect(() => new RollRecordStorage(0)).toThrow(TypeError);
-        const s = new RollRecordStorage(2);
-        expect(() => s.last(0)).toThrow(TypeError);
-        // pass null to add
-        expect(() => s.add(null)).toThrow(TypeError);
-    });
-});

package/dist/__tests__/components/die-history/internal/roll-record-manager/roll-record-manager.spec.js

@@ -1,112 +0,0 @@
-import { describe, it, expect, beforeEach } from "vitest";
-import { Outcome } from "@platonic-dice/core";
-import { DEFAULT_MAX_RECORDS, RollRecordManager, } from "@dice/components/die-history/internal";
-describe("RollRecordManager", () => {
-    let manager;
-    const dieRoll = {
-        roll: 5,
-        timestamp: new Date(),
-    };
-    const modifiedDieRoll = {
-        roll: 3,
-        modified: 1,
-        timestamp: new Date(),
-    };
-    const targetDieRoll = {
-        roll: 20,
-        outcome: Outcome.Success,
-        timestamp: new Date(),
-    };
-    beforeEach(() => {
-        manager = new RollRecordManager();
-    });
-    it("should initialize empty with default maxRecords", () => {
-        expect(manager.length).toBe(0);
-        expect(manager.maxRecordsCount).toBe(DEFAULT_MAX_RECORDS);
-        expect(manager.full).toEqual([]);
-        expect(manager.all).toEqual([]);
-    });
-    it("should add DieRollRecord correctly", () => {
-        manager.add(dieRoll);
-        expect(manager.length).toBe(1);
-        expect(manager.full[0]).toEqual(dieRoll);
-        expect(manager.all[0]).toEqual({ roll: dieRoll.roll });
-    });
-    it("should add ModifiedDieRollRecord correctly", () => {
-        manager.add(modifiedDieRoll);
-        expect(manager.length).toBe(1);
-        expect(manager.full[0]).toEqual(modifiedDieRoll);
-        expect(manager.all[0]).toEqual({
-            roll: modifiedDieRoll.roll,
-            modified: modifiedDieRoll.modified,
-        });
-    });
-    it("should add TargetDieRollRecord correctly", () => {
-        manager.add(targetDieRoll);
-        expect(manager.length).toBe(1);
-        expect(manager.full[0]).toEqual(targetDieRoll);
-        expect(manager.all[0]).toEqual({
-            roll: targetDieRoll.roll,
-            outcome: targetDieRoll.outcome,
-        });
-    });
-    it("should throw TypeError for invalid records", () => {
-        // @ts-expect-error testing runtime validation
-        expect(() => manager.add({})).toThrow(TypeError);
-        // @ts-expect-error testing runtime validation
-        expect(() => manager.add(null)).toThrow(TypeError);
-        // @ts-expect-error testing runtime validation
-        expect(() => manager.add({ roll: 5, foo: "bar" })).toThrow(TypeError);
-    });
-    it("should maintain maxRecords correctly", () => {
-        const smallManager = new RollRecordManager(2);
-        smallManager.add({ roll: 1, timestamp: new Date() });
-        smallManager.add({ roll: 2, timestamp: new Date() });
-        smallManager.add({ roll: 3, timestamp: new Date() }); // should push out oldest
-        expect(smallManager.length).toBe(2);
-        expect(smallManager.full.map((r) => r.roll)).toEqual([2, 3]);
-    });
-    it("should return last N records with last()", () => {
-        manager.add(dieRoll);
-        manager.add(modifiedDieRoll);
-        manager.add(targetDieRoll);
-        const lastOne = manager.last();
-        expect(lastOne).toEqual([
-            { roll: targetDieRoll.roll, outcome: targetDieRoll.outcome },
-        ]);
-        const lastTwo = manager.last(2);
-        expect(lastTwo).toEqual([
-            { roll: modifiedDieRoll.roll, modified: modifiedDieRoll.modified },
-            { roll: targetDieRoll.roll, outcome: targetDieRoll.outcome },
-        ]);
-        const verboseLastTwo = manager.last(2, true);
-        expect(verboseLastTwo).toEqual([modifiedDieRoll, targetDieRoll]);
-    });
-    it("should report records with report()", () => {
-        manager.add(dieRoll);
-        manager.add(modifiedDieRoll);
-        manager.add(targetDieRoll);
-        expect(manager.report()).toEqual(manager.all);
-        expect(manager.report({ verbose: true })).toEqual(manager.full);
-        expect(manager.report({ limit: 2 })).toEqual(manager.all.slice(-2));
-        expect(manager.report({ limit: 2, verbose: true })).toEqual(manager.full.slice(-2));
-    });
-    it("should clear records with clear()", () => {
-        manager.add(dieRoll);
-        manager.clear();
-        expect(manager.length).toBe(0);
-        expect(manager.full).toEqual([]);
-    });
-    it("toString() should reflect last roll", () => {
-        expect(manager.toString()).toContain("empty");
-        manager.add(dieRoll);
-        const str = manager.toString();
-        expect(str).toContain("1/");
-        expect(str).toContain(dieRoll.roll.toString());
-        expect(str).toContain(dieRoll.timestamp.toISOString());
-    });
-    it("toJSON() should return full records", () => {
-        manager.add(dieRoll);
-        expect(manager.toJSON()).toEqual(manager.full);
-    });
-});

package/dist/__tests__/components/die-history/internal/roll-record-validator.spec.js

@@ -1,38 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { Outcome } from "@platonic-dice/core";
-import { isDieRollRecord, isModifiedDieRollRecord, isTargetDieRollRecord, stripTimestamp, } from "@dice/components/die-history/internal";
-describe("RollRecord validator", () => {
-    const now = new Date();
-    const dieRecord = {
-        roll: 5,
-        timestamp: now,
-    };
-    const modifiedRecord = {
-        roll: 10,
-        modified: 12,
-        timestamp: now,
-    };
-    const targetRecord = {
-        roll: 17,
-        outcome: Outcome.Success,
-        timestamp: now,
-    };
-    it("recognises valid shapes", () => {
-        expect(isDieRollRecord(dieRecord)).toBe(true);
-        expect(isModifiedDieRollRecord(modifiedRecord)).toBe(true);
-        expect(isTargetDieRollRecord(targetRecord)).toBe(true);
-    });
-    it("rejects invalid shapes", () => {
-        // missing timestamp
-        expect(isDieRollRecord({ roll: 5 })).toBe(false);
-        // wrong modified type
-        expect(isModifiedDieRollRecord({ roll: 5, modified: "x" })).toBe(false);
-        // invalid outcome
-        expect(isTargetDieRollRecord({ roll: 5, outcome: "nope" })).toBe(false);
-    });
-    it("stripTimestamp removes timestamp and preserves other fields", () => {
-        const stripped = stripTimestamp(dieRecord);
-        expect(stripped.timestamp).toBeUndefined();
-        expect(stripped.roll).toBe(dieRecord.roll);
-    });
-});

package/dist/__tests__/components/die-history/roll-record-factory.spec.js

@@ -1,43 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { RollRecordFactory } from "@dice/components/die-history";
-import { DieType } from "@platonic-dice/core";
-describe("RollRecordFactory", () => {
-    const factory = new RollRecordFactory();
-    it("should create a valid DieRollRecord for normal rolls", () => {
-        const record = factory.createNormalRoll(DieType.D6);
-        expect(record).toMatchObject({
-            roll: expect.any(Number),
-            timestamp: expect.any(Date),
-        });
-        expect(record.roll).toBeGreaterThanOrEqual(1);
-        expect(record.roll).toBeLessThanOrEqual(6);
-    });
-    it("should create a valid ModifiedDieRollRecord for modified rolls", () => {
-        const record = factory.createModifiedRoll(DieType.D20, (n) => n + 2);
-        expect(record).toMatchObject({
-            roll: expect.any(Number),
-            modified: expect.any(Number),
-            timestamp: expect.any(Date),
-        });
-        expect(record.roll).toBeGreaterThanOrEqual(1);
-        expect(record.roll).toBeLessThanOrEqual(20);
-        expect(record.modified).toBe(record.roll + 2);
-    });
-    it("should create a valid TestDieRollRecord for test rolls", () => {
-        const record = factory.createTestRoll(DieType.D10, {
-            testType: "at_least",
-            target: 5,
-        });
-        expect(record).toMatchObject({
-            roll: expect.any(Number),
-            outcome: expect.any(String),
-            timestamp: expect.any(Date),
-        });
-        expect(record.roll).toBeGreaterThanOrEqual(1);
-        expect(record.roll).toBeLessThanOrEqual(10);
-        expect(["Success", "Failure"].map((o) => o.toLowerCase())).toContain(record.outcome.toLowerCase());
-    });
-    it("should throw an error for invalid RollType in createNormalRoll", () => {
-        expect(() => factory.createNormalRoll(DieType.D6, "InvalidRollType")).toThrow(TypeError);
-    });
-});

package/dist/__tests__/die.spec.js

@@ -1,140 +0,0 @@
-/// <reference types="vitest" />
-import { describe, it, expect, beforeEach, vi } from "vitest";
-import { Die } from "@dice/die";
-import { DieType, RollType, roll as coreRoll, rollMod as coreRollMod, rollTest as coreRollTest, } from "@platonic-dice/core";
-// ------------------------
-// MOCK @platonic-dice/core
-// ------------------------
-vi.mock("@platonic-dice/core", async (importOriginal) => {
-    const actual = await importOriginal();
-    return {
-        ...actual,
-        roll: vi.fn(),
-        rollMod: vi.fn(),
-        rollTest: vi.fn(),
-    };
-});
-// ------------------------
-// TEST SUITE
-// ------------------------
-describe("Die class", () => {
-    beforeEach(() => {
-        vi.clearAllMocks();
-    });
-    // ---------------------
-    // CONSTRUCTOR VALIDATION
-    // ---------------------
-    it("creates a die with a valid type", () => {
-        const die = new Die(DieType.D6);
-        expect(die.type).toBe(DieType.D6);
-        expect(die.result).toBe(undefined);
-        expect(die.history("normal")).toEqual([]);
-    });
-    it("throws for invalid die type", () => {
-        expect(() => new Die("INVALID")).toThrowError(/Invalid die type/);
-    });
-    // ---------------------
-    // FACE COUNT
-    // ---------------------
-    it("returns the correct faceCount", () => {
-        expect(new Die(DieType.D4).faceCount).toBe(4);
-        expect(new Die(DieType.D6).faceCount).toBe(6);
-        expect(new Die(DieType.D20).faceCount).toBe(20);
-    });
-    // ---------------------
-    // BASIC ROLL
-    // ---------------------
-    it("rolls and records a basic DieRollRecord", () => {
-        const die = new Die(DieType.D6);
-        coreRoll.mockReturnValue(4);
-        const result = die.roll();
-        expect(result).toBe(4);
-        expect(die.result).toBe(4);
-        const history = die.history("normal", true);
-        expect(history.length).toBe(1);
-        expect(history[0]).toMatchObject({ roll: 4 });
-    });
-    it("passes through rollType to coreRoll()", () => {
-        const die = new Die(DieType.D20);
-        coreRoll.mockReturnValue(17);
-        die.roll(RollType.Advantage);
-        expect(coreRoll).toHaveBeenCalledWith(DieType.D20, RollType.Advantage);
-    });
-    it("throws for invalid rollType", () => {
-        const die = new Die(DieType.D8);
-        expect(() => die.roll("INVALID")).toThrowError(/Invalid roll type/);
-    });
-    // ---------------------
-    // MODIFIED ROLL
-    // ---------------------
-    it("rollMod records ModifiedDieRollRecord", () => {
-        const die = new Die(DieType.D6);
-        coreRollMod.mockReturnValue({ base: 3, modified: 5 });
-        const result = die.rollMod((n) => n + 2);
-        expect(result).toBe(5);
-        expect(die.result).toBe(5);
-        const history = die.history("modifier", true);
-        expect(history.length).toBe(1);
-        expect(history[0]).toMatchObject({ roll: 3, modified: 5 });
-    });
-    // ---------------------
-    // TEST ROLL
-    // ---------------------
-    it("rollTest records TargetDieRollRecord", () => {
-        const die = new Die(DieType.D6);
-        coreRollTest.mockReturnValue({ base: 4, outcome: "success" });
-        const result = die.rollTest({ testType: "at_least", target: 3 });
-        expect(result).toBe(4);
-        expect(die.result).toBe(4);
-        const history = die.history("test", true);
-        expect(history.length).toBe(1);
-        expect(history[0]).toMatchObject({ roll: 4, outcome: "success" });
-    });
-    // ---------------------
-    // HISTORY ACCESS
-    // ---------------------
-    it("history returns timestamp-stripped records when verbose=false", () => {
-        const die = new Die(DieType.D6);
-        coreRoll.mockReturnValue(2);
-        die.roll();
-        const hist = die.history("normal", false);
-        expect(hist[0]).not.toHaveProperty("timestamp");
-        const histVerbose = die.history("normal", true);
-        expect(histVerbose[0]).toHaveProperty("timestamp");
-    });
-    // ---------------------
-    // RESET
-    // ---------------------
-    it("reset clears latest result and optionally all histories", () => {
-        const die = new Die(DieType.D6);
-        coreRoll.mockReturnValue(5);
-        die.roll();
-        die.reset();
-        expect(die.result).toBeUndefined();
-        die.roll();
-        die.reset(true);
-        expect(die.result).toBeUndefined();
-        expect(die.history("normal")).toEqual([]);
-        expect(die.history("modifier")).toEqual([]);
-        expect(die.history("test")).toEqual([]);
-    });
-    // ---------------------
-    // toString / toJSON
-    // ---------------------
-    it("toString reports correctly", () => {
-        const die = new Die(DieType.D6);
-        expect(die.toString()).toMatch(/not rolled yet/);
-        coreRoll.mockReturnValue(3);
-        die.roll();
-        expect(die.toString()).toMatch(/latest=3/);
-    });
-    it("toJSON returns all histories keyed by type", () => {
-        const die = new Die(DieType.D6);
-        coreRoll.mockReturnValue(4);
-        die.roll();
-        const json = die.toJSON();
-        expect(json).toHaveProperty("normal");
-        expect(json.normal.length).toBe(1);
-        expect(json.normal[0]).toMatchObject({ roll: 4 });
-    });
-});

package/dist/__tests__/types/roll-record.types.spec.js

@@ -1,41 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { Outcome } from "@platonic-dice/core/entities";
-describe("RollRecord types (runtime shape validation)", () => {
-    const now = new Date();
-    const dieRecord = {
-        roll: 5,
-        timestamp: now,
-    };
-    const modifiedRecord = {
-        roll: 10,
-        modified: 12,
-        timestamp: now,
-    };
-    const targetRecord = {
-        roll: 17,
-        outcome: Outcome.Success,
-        timestamp: now,
-    };
-    it("should have the correct shape for DieRollRecord", () => {
-        expect(dieRecord).toHaveProperty("roll");
-        expect(dieRecord).toHaveProperty("timestamp");
-        expect(dieRecord.timestamp).toBeInstanceOf(Date);
-        expect(Object.keys(dieRecord)).toHaveLength(2);
-    });
-    it("should have the correct shape for ModifiedDieRollRecord", () => {
-        expect(modifiedRecord).toHaveProperty("roll");
-        expect(modifiedRecord).toHaveProperty("modified");
-        expect(modifiedRecord).toHaveProperty("timestamp");
-        expect(modifiedRecord.timestamp).toBeInstanceOf(Date);
-    });
-    it("should have the correct shape for TargetDieRollRecord", () => {
-        expect(targetRecord).toHaveProperty("roll");
-        expect(targetRecord).toHaveProperty("outcome");
-        expect(targetRecord).toHaveProperty("timestamp");
-        expect(targetRecord.timestamp).toBeInstanceOf(Date);
-    });
-    it("should be compatible with the RollRecord union", () => {
-        const records = [dieRecord, modifiedRecord, targetRecord];
-        expect(records).toHaveLength(3);
-    });
-});

package/dist/src/components/die-history/index.js

@@ -1,2 +0,0 @@
-export { RollRecordFactory } from "./roll-record-factory";
-export { HistoryCache } from "./history-cache";

package/dist/src/components/die-history/internal/index.js

@@ -1,2 +0,0 @@
-export { RollRecordManager, DEFAULT_MAX_RECORDS } from "./roll-record-manager";
-export * from "./roll-record-validator";

package/dist/src/components/die-history/internal/roll-record-manager/internal/index.js

@@ -1 +0,0 @@
-export * from "./roll-record-storage";

package/dist/src/components/index.js

@@ -1 +0,0 @@
-export * from "./die-history";

package/dist/src/types/index.js

@@ -1 +0,0 @@
-export * from "./roll-record.types";