roll-parser 3.0.0-beta.0 → 3.1.0

package/dist/rng/seeded.d.ts

@@ -1,33 +1,165 @@
 /**
- * Seedable RNG using xorshift128 algorithm.
+ * Seedable RNG using the xoshiro128** algorithm.
  *
  * @module rng/seeded
  */
 import type { RNG } from './types.js';
 /**
- * Seedable pseudo-random number generator using xorshift128.
+ * A snapshot of {@link SeededRNG}'s internal state: a format version followed
+ * by the four state words as unsigned 32-bit integers. Pass one back to the
+ * constructor to resume the exact sequence it was taken from.
  *
- * Produces reproducible sequences from identical seeds.
- * Period: 2^128 - 1
+ * Opaque and bound to the major version, the same contract seeds carry: the
+ * words mean nothing outside the engine that produced them, and a release that
+ * changes that engine bumps the leading version. A snapshot from a different
+ * version is rejected with an `INCOMPATIBLE_RNG_STATE` error rather than
+ * resumed under the wrong semantics — safe to hold in memory or serialize for
+ * a save file, and loud rather than silent across an upgrade.
+ *
+ * @category RNG
+ */
+export type RngState = readonly [version: number, s0: number, s1: number, s2: number, s3: number];
+/**
+ * Seedable pseudo-random number generator using xoshiro128**. The default
+ * randomness source — `roll(notation)` builds one per call, and
+ * `roll(notation, { seed })` builds one from your seed.
+ *
+ * Period 2^128 - 1. Every seed is stringified and hashed with cyrb128 into
+ * the full 128-bit state, so numeric seeds keep all 53 bits and unrelated
+ * strings are overwhelmingly unlikely to share a state; an omitted seed hashes
+ * `Date.now()` together with two `Math.random()` draws, roughly 100 bits of
+ * width rather than 32 — wide enough that concurrently created generators are
+ * very unlikely to collide, though unpredictability stays bounded by the host
+ * engine's `Math.random()` seeding. The first 8 draws are discarded as a run-in.
+ *
+ * Stringifying means `42` and `'42'` are the same seed — the two forms share
+ * one namespace, which matters when seeds arrive from a CLI flag or JSON.
+ *
+ * {@link state} snapshots the state words as a versioned {@link RngState}, and
+ * passing one to the constructor resumes that exact sequence — restore copies
+ * the words verbatim, skipping both the hash and the run-in. A snapshot from
+ * another format version throws `INCOMPATIBLE_RNG_STATE`; within the current
+ * version the type is the contract, and a hand-built tuple is coerced to 32
+ * bits per word rather than rejected.
+ *
+ * Reproducibility guarantee: the same seed and the same notation produce the
+ * same dice for the lifetime of a major version, and `RngState` carries that
+ * binding. The one exception is a genuine distribution bug — bias, faulty
+ * rejection sampling — which may change the mapping in a minor release, never
+ * silently in a patch, and always with a `BREAKING` changelog note. The
+ * sequence is *not* cryptographically secure. To pin a roll beyond that,
+ * persist the {@link RollResult} rather than re-deriving it from a seed.
  *
  * @example
  * ```typescript
+ * import { SeededRNG, roll } from 'roll-parser';
+ *
  * // Same seed = same sequence
- * const rng1 = new SeededRNG('test-seed');
- * const rng2 = new SeededRNG('test-seed');
- * rng1.nextInt(1, 6) === rng2.nextInt(1, 6); // true
+ * const a = new SeededRNG('test-seed');
+ * const b = new SeededRNG('test-seed');
+ * a.nextInt(1, 6) === b.nextInt(1, 6); // true
+ *
+ * // An injected instance keeps advancing across rolls; `{ seed }` restarts
+ * // the stream on every call.
+ * const rng = new SeededRNG('demo');
+ * roll('1d20', { rng }).total; // 1
+ * roll('1d20', { rng }).total; // 20 — the stream moved on
+ * roll('1d20', { seed: 'demo' }).total; // 1, every single time
  * ```
+ *
+ * @category RNG
  */
 export declare class SeededRNG implements RNG {
     private s0;
     private s1;
     private s2;
     private s3;
-    constructor(seed?: string | number);
+    constructor(seed?: string | number | RngState);
     private initState;
-    private hashString;
+    /** All-zero is a fixed point for xoshiro — at least one word must be non-zero. */
+    private guardZeroState;
+    /**
+     * Returns the current state as a format version followed by four unsigned
+     * 32-bit words. Feeding the snapshot back to the constructor resumes this
+     * exact sequence; the source instance is untouched, and the two then advance
+     * independently.
+     *
+     * The words are {@link RngState} — opaque, restorable within the major
+     * version that produced them, and rejected with `INCOMPATIBLE_RNG_STATE`
+     * outside it.
+     *
+     * @returns A snapshot of the version and the four state words
+     *
+     * @example Replay a roll that was never seeded
+     * ```typescript
+     * import { SeededRNG, roll } from 'roll-parser';
+     *
+     * const rng = new SeededRNG();
+     * const snapshot = rng.state();
+     *
+     * const first = roll('1d20', { rng });
+     * const replay = roll('1d20', { rng: new SeededRNG(snapshot) });
+     * first.total === replay.total; // true
+     * ```
+     *
+     * Not a fork primitive. A restored generator replays the parent's stream, so
+     * children taken at different points are the same sequence at an offset, not
+     * independent substreams — derive a seed per entity instead.
+     *
+     * @example Per-entity streams — derive seeds, do not fork state
+     * ```typescript
+     * import { SeededRNG } from 'roll-parser';
+     *
+     * const goblin = new SeededRNG('world:goblin');
+     * const orc = new SeededRNG('world:orc');
+     * ```
+     */
+    state(): RngState;
+    /**
+     * Normalizes the constructor seed into a string. Numbers are stringified
+     * rather than coerced to uint32, so all 53 exact bits reach the hash.
+     */
+    private toSeedString;
+    /** cyrb128 — hashes the seed into all four state words at once. */
+    private hashSeed;
     private nextUint32;
+    /**
+     * Returns a float in `[0, 1)`, derived from one uint32 draw. Resolution is
+     * 2^-32, not the full 2^-53 a double can hold.
+     *
+     * Not used by the evaluator — dice go through {@link nextInt}.
+     *
+     * @returns A float in `[0, 1)`
+     */
     next(): number;
+    /**
+     * Returns an integer in the inclusive range `[min, max]`, uniformly
+     * distributed — rejection sampling removes the modulo bias a plain
+     * `% range` would introduce.
+     *
+     * Bounds handling, in order:
+     * - `min > max` is normalized by swapping, so `nextInt(6, 1)` behaves as
+     *   `nextInt(1, 6)`. (The mock RNG throws instead; see {@link RNG.nextInt}.)
+     * - `min === max` returns that value without consuming a draw.
+     * - Ranges wider than 2^32 use two draws composed into a 53-bit value.
+     * - Ranges wider than 2^53 cannot be sampled exactly and throw a
+     *   `RangeError` rather than silently skewing.
+     *
+     * @param min - Lower bound, inclusive
+     * @param max - Upper bound, inclusive
+     * @returns An integer in `[min, max]`
+     * @throws {RangeError} If `max - min + 1` exceeds 2^53
+     *
+     * @example
+     * ```typescript
+     * import { SeededRNG } from 'roll-parser';
+     *
+     * const rng = new SeededRNG('demo');
+     * rng.nextInt(1, 6); // 1..6
+     * rng.nextInt(3, 3); // 3, always
+     * rng.nextInt(1, Number.MAX_SAFE_INTEGER); // fine — two-draw path
+     * ```
+     */
     nextInt(min: number, max: number): number;
     /**
      * Unbiased sampling in `[0, range)` for ranges above 2^32, built from two

package/dist/rng/seeded.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"seeded.d.ts","sourceRoot":"","sources":["../../src/rng/seeded.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,YAAY,CAAC;AAEtC;;;;;;;;;;;;;GAaG;AACH,qBAAa,SAAU,YAAW,GAAG;IACnC,OAAO,CAAC,EAAE,CAAS;IACnB,OAAO,CAAC,EAAE,CAAS;IACnB,OAAO,CAAC,EAAE,CAAS;IACnB,OAAO,CAAC,EAAE,CAAS;gBAEP,IAAI,CAAC,EAAE,MAAM,GAAG,MAAM;IAelC,OAAO,CAAC,SAAS;IA+BjB,OAAO,CAAC,UAAU;IASlB,OAAO,CAAC,UAAU;IAgBlB,IAAI,IAAI,MAAM;IAKd,OAAO,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM;IA6BzC;;;;;OAKG;IACH,OAAO,CAAC,eAAe;CAiBxB"}
+{"version":3,"file":"seeded.d.ts","sourceRoot":"","sources":["../../src/rng/seeded.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,YAAY,CAAC;AAEtC;;;;;;;;;;;;;GAaG;AACH,MAAM,MAAM,QAAQ,GAAG,SAAS,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,CAAC,CAAC;AAiFlG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiDG;AACH,qBAAa,SAAU,YAAW,GAAG;IAKnC,OAAO,CAAC,EAAE,CAAS;IACnB,OAAO,CAAC,EAAE,CAAS;IACnB,OAAO,CAAC,EAAE,CAAS;IACnB,OAAO,CAAC,EAAE,CAAS;IAEnB,YAAY,IAAI,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,QAAQ,EAwB5C;IAED,OAAO,CAAC,SAAS;IAKjB,kFAAkF;IAClF,OAAO,CAAC,cAAc;IAMtB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAmCG;IACH,KAAK,IAAI,QAAQ,CAEhB;IAED;;;OAGG;IACH,OAAO,CAAC,YAAY;IAMpB,mEAAmE;IACnE,OAAO,CAAC,QAAQ;IA+BhB,OAAO,CAAC,UAAU;IAmBlB;;;;;;;OAOG;IACH,IAAI,IAAI,MAAM,CAEb;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;OA2BG;IACH,OAAO,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,CAyBxC;IAED;;;;;OAKG;IACH,OAAO,CAAC,eAAe;CAexB"}

package/dist/rng/seeded.js

@@ -0,0 +1,138 @@
+import { RollParserError } from '../errors.js';
+const RNG_STATE_VERSION = 1;
+const RNG_STATE_LENGTH = 5;
+const rotl = (value, bits) => (value << bits) | (value >>> (32 - bits));
+const WARMUP_DRAWS = 8;
+const UINT32_SPACE = 0x100000000;
+const MAX_EXACT_INT = 2 ** 53;
+const HIGH_DRAW_SCALE = 0x200000;
+const LOW_DRAW_SHIFT = 11;
+const CYRB128_BASIS_1 = 1779033703;
+const CYRB128_BASIS_2 = 3144134277;
+const CYRB128_BASIS_3 = 1013904242;
+const CYRB128_BASIS_4 = 2773480762;
+const SCRAMBLE_MULTIPLIER_1 = 5;
+const SCRAMBLE_ROTATION = 7;
+const SCRAMBLE_MULTIPLIER_2 = 9;
+const STATE_SHIFT = 9;
+const STATE_ROTATION = 11;
+const CYRB128_MULTIPLIER_1 = 597399067;
+const CYRB128_MULTIPLIER_2 = 2869860233;
+const CYRB128_MULTIPLIER_3 = 951274213;
+const CYRB128_MULTIPLIER_4 = 2716044179;
+function assertRestorable(state) {
+    if (state.length !== RNG_STATE_LENGTH) {
+        throw new RollParserError(`Incompatible RngState: expected ${RNG_STATE_LENGTH} values, received ${state.length}`, 'INCOMPATIBLE_RNG_STATE');
+    }
+    if (state[0] !== RNG_STATE_VERSION) {
+        throw new RollParserError(`Incompatible RngState version: expected ${RNG_STATE_VERSION}, received ${state[0]}`, 'INCOMPATIBLE_RNG_STATE');
+    }
+}
+export class SeededRNG {
+    s0;
+    s1;
+    s2;
+    s3;
+    constructor(seed) {
+        this.s0 = 0;
+        this.s1 = 0;
+        this.s2 = 0;
+        this.s3 = 0;
+        if (seed !== null && typeof seed === 'object') {
+            assertRestorable(seed);
+            this.s0 = seed[1] | 0;
+            this.s1 = seed[2] | 0;
+            this.s2 = seed[3] | 0;
+            this.s3 = seed[4] | 0;
+            this.guardZeroState();
+            return;
+        }
+        this.initState(seed);
+        for (let i = 0; i < WARMUP_DRAWS; i++) {
+            this.nextUint32();
+        }
+    }
+    initState(seed) {
+        this.hashSeed(this.toSeedString(seed));
+        this.guardZeroState();
+    }
+    guardZeroState() {
+        if (this.s0 === 0 && this.s1 === 0 && this.s2 === 0 && this.s3 === 0) {
+            this.s0 = 1;
+        }
+    }
+    state() {
+        return [RNG_STATE_VERSION, this.s0 >>> 0, this.s1 >>> 0, this.s2 >>> 0, this.s3 >>> 0];
+    }
+    toSeedString(seed) {
+        if (seed == null)
+            return `${Date.now()}-${Math.random()}-${Math.random()}`;
+        return String(seed);
+    }
+    hashSeed(str) {
+        let h1 = CYRB128_BASIS_1;
+        let h2 = CYRB128_BASIS_2;
+        let h3 = CYRB128_BASIS_3;
+        let h4 = CYRB128_BASIS_4;
+        for (let i = 0; i < str.length; i++) {
+            const k = str.charCodeAt(i);
+            h1 = h2 ^ Math.imul(h1 ^ k, CYRB128_MULTIPLIER_1);
+            h2 = h3 ^ Math.imul(h2 ^ k, CYRB128_MULTIPLIER_2);
+            h3 = h4 ^ Math.imul(h3 ^ k, CYRB128_MULTIPLIER_3);
+            h4 = h1 ^ Math.imul(h4 ^ k, CYRB128_MULTIPLIER_4);
+        }
+        h1 = Math.imul(h3 ^ (h1 >>> 18), CYRB128_MULTIPLIER_1);
+        h2 = Math.imul(h4 ^ (h2 >>> 22), CYRB128_MULTIPLIER_2);
+        h3 = Math.imul(h1 ^ (h3 >>> 17), CYRB128_MULTIPLIER_3);
+        h4 = Math.imul(h2 ^ (h4 >>> 19), CYRB128_MULTIPLIER_4);
+        const mixed = h1 ^ h2 ^ h3 ^ h4;
+        this.s0 = mixed;
+        this.s1 = h2 ^ mixed;
+        this.s2 = h3 ^ mixed;
+        this.s3 = h4 ^ mixed;
+    }
+    nextUint32() {
+        const scrambled = rotl(Math.imul(this.s1, SCRAMBLE_MULTIPLIER_1), SCRAMBLE_ROTATION);
+        const result = Math.imul(scrambled, SCRAMBLE_MULTIPLIER_2) >>> 0;
+        const t = this.s1 << STATE_SHIFT;
+        this.s2 ^= this.s0;
+        this.s3 ^= this.s1;
+        this.s1 ^= this.s2;
+        this.s0 ^= this.s3;
+        this.s2 ^= t;
+        this.s3 = rotl(this.s3, STATE_ROTATION);
+        return result;
+    }
+    next() {
+        return this.nextUint32() / UINT32_SPACE;
+    }
+    nextInt(min, max) {
+        const lo = min > max ? max : min;
+        const hi = min > max ? min : max;
+        const range = hi - lo + 1;
+        if (range <= 1) {
+            return lo;
+        }
+        if (range > UINT32_SPACE) {
+            return lo + this.nextBoundedWide(range);
+        }
+        const threshold = (UINT32_SPACE - range) % range;
+        let value;
+        do {
+            value = this.nextUint32();
+        } while (value < threshold);
+        return lo + (value % range);
+    }
+    nextBoundedWide(range) {
+        if (range > MAX_EXACT_INT) {
+            throw new RangeError(`nextInt range ${range} exceeds 2^53 and cannot be sampled exactly`);
+        }
+        const limit = Math.floor(MAX_EXACT_INT / range) * range;
+        let value;
+        do {
+            value = this.nextUint32() * HIGH_DRAW_SCALE + (this.nextUint32() >>> LOW_DRAW_SHIFT);
+        } while (value >= limit);
+        return value % range;
+    }
+}
+//# sourceMappingURL=seeded.js.map

package/dist/rng/seeded.js.map

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

package/dist/rng/types.d.ts

@@ -7,6 +7,57 @@
  */
 /**
  * Random Number Generator interface for dice rolling.
+ *
+ * Guaranteed by every implementation:
+ *
+ * - `next()` returns a float in `[0, 1)`.
+ * - `nextInt(min, max)` returns an integer in `[min, max]` when `min <= max`.
+ * - `nextInt(n, n)` returns `n`.
+ *
+ * Deliberately NOT guaranteed: behavior when `min > max`. The two shipped
+ * implementations differ, and each difference is load-bearing — see
+ * {@link nextInt}. Evaluator code never inverts its bounds, so callers should
+ * treat inverted bounds as a programming error rather than an API.
+ *
+ * The evaluator only ever calls `nextInt`, once per die, left to right;
+ * `next` exists for implementations that want a float source of their own.
+ * Two shipped implementations satisfy the interface — {@link SeededRNG} and
+ * the mock from `roll-parser/testing` — and anything structurally compatible
+ * works, so a crypto-backed or table-driven generator drops straight in.
+ *
+ * @example A crypto-backed RNG
+ * ```typescript
+ * import { roll, type RNG } from 'roll-parser';
+ *
+ * const cryptoRng: RNG = {
+ *   next: () => crypto.getRandomValues(new Uint32Array(1))[0]! / 2 ** 32,
+ *   nextInt: (min, max) => min + Math.floor(cryptoRng.next() * (max - min + 1)),
+ * };
+ *
+ * roll('4d6kh3', { rng: cryptoRng }).total; // 3..18
+ * ```
+ *
+ * @example Wrapping an RNG to log every draw
+ * ```typescript
+ * import { SeededRNG, roll, type RNG } from 'roll-parser';
+ *
+ * function withLog(inner: RNG, log: number[]): RNG {
+ *   return {
+ *     next: () => inner.next(),
+ *     nextInt: (min, max) => {
+ *       const value = inner.nextInt(min, max);
+ *       log.push(value);
+ *       return value;
+ *     },
+ *   };
+ * }
+ *
+ * const draws: number[] = [];
+ * roll('4d6kh3', { rng: withLog(new SeededRNG('demo'), draws) });
+ * draws; // [4, 3, 3, 3] — every face, including the dropped one
+ * ```
+ *
+ * @category RNG
  */
 export type RNG = {
     /**
@@ -16,6 +67,12 @@ export type RNG = {
     /**
      * Returns a random integer in the inclusive range [min, max].
      *
+     * Inverted bounds (`min > max`) are implementation-defined:
+     * `SeededRNG` normalizes by swapping them, so `nextInt(6, 1)` yields the
+     * same sequence as `nextInt(1, 6)`; the mock RNG from `roll-parser/testing`
+     * raises `RangeError`, because a scripted value can never satisfy an empty
+     * range and silently accepting it would hide a miscounted test sequence.
+     *
      * @param min - Minimum value (inclusive)
      * @param max - Maximum value (inclusive)
      */

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

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/rng/types.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH;;GAEG;AACH,MAAM,MAAM,GAAG,GAAG;IAChB;;OAEG;IACH,IAAI,IAAI,MAAM,CAAC;IAEf;;;;;OAKG;IACH,OAAO,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,CAAC;CAC3C,CAAC"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/rng/types.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqDG;AACH,MAAM,MAAM,GAAG,GAAG;IAChB;;OAEG;IACH,IAAI,IAAI,MAAM,CAAC;IAEf;;;;;;;;;;;OAWG;IACH,OAAO,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,CAAC;CAC3C,CAAC"}

package/dist/rng/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/dist/rng/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/rng/types.ts"],"names":[],"mappings":""}

package/dist/roll.d.ts

@@ -4,48 +4,78 @@
  * @module roll
  */
 import type { RNG } from './rng/types.js';
-import type { RollResult } from './types.js';
+import type { EvaluationOptions, RollResult } from './types.js';
 /**
- * Options for the roll function.
+ * Everything {@link roll} accepts on top of the shared {@link EvaluationOptions}:
+ * a randomness source, given either as a ready-made {@link RNG} or as a seed.
+ *
+ * @category Core
+ *
+ * @example
+ * ```typescript
+ * import { roll, SeededRNG } from 'roll-parser';
+ *
+ * roll('4d6', { seed: 'character-1' });     // reproducible
+ * roll('4d6', { rng: new SeededRNG(42) });  // rng wins over seed
+ * roll('1d20+@str', { context: { str: 4 } });
+ * ```
  */
-export type RollOptions = {
-    /** Custom RNG instance (takes precedence over seed) */
+export type RollOptions = EvaluationOptions & {
+    /**
+     * Randomness source. Takes precedence over `seed` — when both are given,
+     * `seed` is ignored.
+     */
     rng?: RNG;
-    /** Seed for deterministic rolls (ignored if rng provided) */
+    /**
+     * Seed for a fresh `SeededRNG`. Equal seeds replay the same die sequence for
+     * the same notation. Ignored when `rng` is set.
+     */
     seed?: string | number;
-    /** Maximum total dice allowed per evaluation (default: 10,000) */
-    maxDice?: number;
-    /** Maximum explosion iterations allowed per die (default: 1,000) */
-    maxExplodeIterations?: number;
-    /** Maximum reroll iterations allowed per die (default: 1,000) */
-    maxRerollIterations?: number;
-    /** Variable context for `@name` / `@{name}` references (default: empty) */
-    context?: Record<string, number>;
-    /** Behavior when a referenced variable is missing from context (default: 'throw') */
-    onMissingVariable?: 'throw' | 'zero';
 };
 /**
- * Parses and evaluates a dice notation string.
+ * Parses and evaluates a dice notation string in one call — the main entry
+ * point of the library.
  *
- * @param notation - Dice notation (e.g., "2d6+3", "4d6kh3")
- * @param options - Optional configuration (RNG or seed)
- * @returns Complete roll result with total and metadata
+ * Equivalent to `evaluate(parse(notation), rng, { notation })`. Each call
+ * builds a fresh `SeededRNG` unless `options.rng` is supplied, so reuse
+ * {@link parse} + {@link evaluate} directly when rolling the same notation in
+ * a loop.
+ *
+ * @param notation - Dice notation, e.g. `'2d6+3'` or `'4d6kh3'`
+ * @param options - RNG or seed, plus the shared {@link EvaluationOptions}
+ * @returns Complete {@link RollResult} with total, per-die results and the
+ *   structured `parts` tree
+ * @throws {LexerError} On an invalid character
+ * @throws {ParseError} On invalid syntax
+ * @throws {EvaluatorError} On a limit breach or an impossible expression
+ * @throws {RollParserError} `INVALID_EVALUATION_LIMIT` when a supplied limit is
+ *   not an integer in range — raised before any die is rolled
+ * @throws {RollParserError} `INVALID_NOTATION_TYPE` when `notation` is not a
+ *   string, so `isRollParserError` still filters untrusted input completely
  *
  * @example
  * ```typescript
+ * import { roll } from 'roll-parser';
+ *
  * // Random roll
- * const result = roll('2d6+3');
- * console.log(result.total); // 5-15
+ * roll('2d6+3').total; // 5..15
+ *
+ * // Seeded — same seed, same sequence
+ * roll('2d6+3', { seed: 'demo' }).rendered; // '2d6[1, 6] + 3 = 10'
+ * roll('2d6+3', { seed: 'demo' }).total; // 10
+ * ```
  *
- * // Seeded for reproducibility
- * const r1 = roll('4d6', { seed: 'test' });
- * const r2 = roll('4d6', { seed: 'test' });
- * r1.total === r2.total; // true
+ * @example Deterministic tests with the testing mock
+ * ```typescript
+ * import { roll } from 'roll-parser';
+ * import { createMockRng } from 'roll-parser/testing';
  *
- * // Custom RNG for testing
- * const result = roll('1d20', { rng: createMockRng([15]) });
- * result.total; // 15
+ * const result = roll('4d6kh3', { rng: createMockRng([3, 6, 2, 5]) });
+ * result.total; // 14
+ * result.rendered; // '4d6[3, 6, ~~2~~, 5] = 14'
  * ```
+ *
+ * @category Core
  */
 export declare function roll(notation: string, options?: RollOptions): RollResult;
 //# sourceMappingURL=roll.d.ts.map

package/dist/roll.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"roll.d.ts","sourceRoot":"","sources":["../src/roll.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,gBAAgB,CAAC;AAC1C,OAAO,KAAK,EAAmB,UAAU,EAAE,MAAM,YAAY,CAAC;AAM9D;;GAEG;AACH,MAAM,MAAM,WAAW,GAAG;IACxB,uDAAuD;IACvD,GAAG,CAAC,EAAE,GAAG,CAAC;IACV,6DAA6D;IAC7D,IAAI,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IACvB,kEAAkE;IAClE,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,oEAAoE;IACpE,oBAAoB,CAAC,EAAE,MAAM,CAAC;IAC9B,iEAAiE;IACjE,mBAAmB,CAAC,EAAE,MAAM,CAAC;IAC7B,2EAA2E;IAC3E,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACjC,qFAAqF;IACrF,iBAAiB,CAAC,EAAE,OAAO,GAAG,MAAM,CAAC;CACtC,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,IAAI,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,GAAE,WAAgB,GAAG,UAAU,CAiB5E"}
+{"version":3,"file":"roll.d.ts","sourceRoot":"","sources":["../src/roll.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAKH,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,gBAAgB,CAAC;AAC1C,OAAO,KAAK,EAAE,iBAAiB,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAEhE;;;;;;;;;;;;;;GAcG;AACH,MAAM,MAAM,WAAW,GAAG,iBAAiB,GAAG;IAC5C;;;OAGG;IACH,GAAG,CAAC,EAAE,GAAG,CAAC;IACV;;;OAGG;IACH,IAAI,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;CACxB,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AACH,wBAAgB,IAAI,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,GAAE,WAAgB,GAAG,UAAU,CAK5E"}

package/dist/roll.js

@@ -0,0 +1,8 @@
+import { evaluate } from './evaluator/evaluator.js';
+import { parse } from './parser/parser.js';
+import { SeededRNG } from './rng/seeded.js';
+export function roll(notation, options = {}) {
+    const { rng, seed, ...limits } = options;
+    return evaluate(parse(notation), rng ?? new SeededRNG(seed), { ...limits, notation });
+}
+//# sourceMappingURL=roll.js.map

package/dist/roll.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"roll.js","sourceRoot":"","sources":["../src/roll.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AACpD,OAAO,EAAE,KAAK,EAAE,MAAM,oBAAoB,CAAC;AAC3C,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AA6E5C,MAAM,UAAU,IAAI,CAAC,QAAgB,EAAE,OAAO,GAAgB,EAAE;IAE9D,MAAM,EAAE,GAAG,EAAE,IAAI,EAAE,GAAG,MAAM,EAAE,GAAG,OAAO,CAAC;IAEzC,OAAO,QAAQ,CAAC,KAAK,CAAC,QAAQ,CAAC,EAAE,GAAG,IAAI,IAAI,SAAS,CAAC,IAAI,CAAC,EAAE,EAAE,GAAG,MAAM,EAAE,QAAQ,EAAE,CAAC,CAAC;AACxF,CAAC"}

package/dist/testing.d.ts

@@ -1,11 +1,12 @@
 /**
  * Test utilities for roll-parser consumers.
  *
- * Import from `roll-parser/testing` for deterministic dice testing.
+ * Import from `roll-parser/testing` for deterministic dice testing. The full
+ * TSDoc lives on the implementations in `./rng/mock.ts`; this entry point is
+ * a plain re-export barrel.
  *
  * @module testing
  */
-import { MockRNGExhaustedError as _MockRNGExhaustedError, createMockRng as _createMockRng } from './rng/mock.js';
-export declare const createMockRng: typeof _createMockRng;
-export declare const MockRNGExhaustedError: typeof _MockRNGExhaustedError;
+export { createMockRng, MockRNGExhaustedError } from './rng/mock.js';
+export type { RNG } from './rng/types.js';
 //# sourceMappingURL=testing.d.ts.map

package/dist/testing.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"testing.d.ts","sourceRoot":"","sources":["../src/testing.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAGH,OAAO,EACL,qBAAqB,IAAI,sBAAsB,EAC/C,aAAa,IAAI,cAAc,EAChC,MAAM,eAAe,CAAC;AAEvB,eAAO,MAAM,aAAa,uBAAiB,CAAC;AAC5C,eAAO,MAAM,qBAAqB,+BAAyB,CAAC"}
+{"version":3,"file":"testing.d.ts","sourceRoot":"","sources":["../src/testing.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,EAAE,aAAa,EAAE,qBAAqB,EAAE,MAAM,eAAe,CAAC;AACrE,YAAY,EAAE,GAAG,EAAE,MAAM,gBAAgB,CAAC"}

package/dist/testing.js

@@ -1,41 +1,2 @@
-// src/rng/mock.ts
-class MockRNGExhaustedError extends Error {
-  consumed;
-  constructor(consumed) {
-    super(`MockRNG exhausted: consumed ${consumed} values, no more available`);
-    this.name = "MockRNGExhaustedError";
-    this.consumed = consumed;
-  }
-}
-function createMockRng(values) {
-  let index = 0;
-  const getNext = () => {
-    const value = values[index];
-    if (value === undefined) {
-      throw new MockRNGExhaustedError(index);
-    }
-    index++;
-    return value;
-  };
-  return {
-    next: getNext,
-    nextInt: (min, max) => {
-      const value = getNext();
-      if (value < min || value > max) {
-        throw new RangeError(`MockRNG value ${value} is out of bounds [${min}, ${max}]`);
-      }
-      return value;
-    }
-  };
-}
-
-// src/testing.ts
-var createMockRng2 = createMockRng;
-var MockRNGExhaustedError2 = MockRNGExhaustedError;
-export {
-  createMockRng2 as createMockRng,
-  MockRNGExhaustedError2 as MockRNGExhaustedError
-};
-
-//# debugId=916ECEA68894E64864756E2164756E21
-//# sourceMappingURL=testing.js.map
+export { createMockRng, MockRNGExhaustedError } from './rng/mock.js';
+//# sourceMappingURL=testing.js.map

package/dist/testing.js.map

@@ -1,11 +1 @@
-{
-  "version": 3,
-  "sources": ["../src/rng/mock.ts", "../src/testing.ts"],
-  "sourcesContent": [
-    "/**\n * Mock RNG for deterministic testing.\n *\n * @module rng/mock\n */\n\nimport type { RNG } from './types.js';\n\n/**\n * Error thrown when MockRNG exhausts its predefined values.\n *\n * This is intentional behavior to catch incorrect roll counts in tests.\n * If you see this error, your test is consuming more random values than expected.\n */\nexport class MockRNGExhaustedError extends Error {\n  readonly consumed: number;\n\n  constructor(consumed: number) {\n    super(`MockRNG exhausted: consumed ${consumed} values, no more available`);\n    this.name = 'MockRNGExhaustedError';\n    this.consumed = consumed;\n  }\n}\n\n/**\n * Creates a mock RNG that returns predefined values in sequence.\n *\n * IMPORTANT: Throws MockRNGExhaustedError when all values are consumed.\n * This behavior catches incorrect roll counts in tests - it never wraps around.\n *\n * @param values - Array of values to return (dice results for nextInt, floats for next)\n * @returns RNG instance returning predefined values\n *\n * @example\n * ```typescript\n * const rng = createMockRng([4, 2, 6]);\n * rng.nextInt(1, 6);  // Returns 4\n * rng.nextInt(1, 6);  // Returns 2\n * rng.nextInt(1, 6);  // Returns 6\n * rng.nextInt(1, 6);  // Throws MockRNGExhaustedError\n * ```\n */\nexport function createMockRng(values: number[]): RNG {\n  let index = 0;\n\n  const getNext = (): number => {\n    const value = values[index];\n    if (value === undefined) {\n      throw new MockRNGExhaustedError(index);\n    }\n    index++;\n    return value;\n  };\n\n  return {\n    next: getNext,\n    nextInt: (min: number, max: number): number => {\n      const value = getNext();\n      if (value < min || value > max) {\n        throw new RangeError(`MockRNG value ${value} is out of bounds [${min}, ${max}]`);\n      }\n      return value;\n    },\n  };\n}\n",
-    "/**\n * Test utilities for roll-parser consumers.\n *\n * Import from `roll-parser/testing` for deterministic dice testing.\n *\n * @module testing\n */\n\n// Direct value exports force the bundler to inline the code\nimport {\n  MockRNGExhaustedError as _MockRNGExhaustedError,\n  createMockRng as _createMockRng,\n} from './rng/mock.js';\n\nexport const createMockRng = _createMockRng;\nexport const MockRNGExhaustedError = _MockRNGExhaustedError;\n"
-  ],
-  "mappings": ";AAcO,MAAM,8BAA8B,MAAM;AAAA,EACtC;AAAA,EAET,WAAW,CAAC,UAAkB;AAAA,IAC5B,MAAM,+BAA+B,oCAAoC;AAAA,IACzE,KAAK,OAAO;AAAA,IACZ,KAAK,WAAW;AAAA;AAEpB;AAoBO,SAAS,aAAa,CAAC,QAAuB;AAAA,EACnD,IAAI,QAAQ;AAAA,EAEZ,MAAM,UAAU,MAAc;AAAA,IAC5B,MAAM,QAAQ,OAAO;AAAA,IACrB,IAAI,UAAU,WAAW;AAAA,MACvB,MAAM,IAAI,sBAAsB,KAAK;AAAA,IACvC;AAAA,IACA;AAAA,IACA,OAAO;AAAA;AAAA,EAGT,OAAO;AAAA,IACL,MAAM;AAAA,IACN,SAAS,CAAC,KAAa,QAAwB;AAAA,MAC7C,MAAM,QAAQ,QAAQ;AAAA,MACtB,IAAI,QAAQ,OAAO,QAAQ,KAAK;AAAA,QAC9B,MAAM,IAAI,WAAW,iBAAiB,2BAA2B,QAAQ,MAAM;AAAA,MACjF;AAAA,MACA,OAAO;AAAA;AAAA,EAEX;AAAA;;;ACjDK,IAAM,iBAAgB;AACtB,IAAM,yBAAwB;",
-  "debugId": "916ECEA68894E64864756E2164756E21",
-  "names": []
-}
+{"version":3,"file":"testing.js","sourceRoot":"","sources":["../src/testing.ts"],"names":[],"mappings":"AAUA,OAAO,EAAE,aAAa,EAAE,qBAAqB,EAAE,MAAM,eAAe,CAAC"}