roll-parser 3.0.0-beta.0 → 3.0.0

package/dist/errors.d.ts

@@ -1,42 +1,357 @@
 /**
- * Common error base class and error codes for roll-parser.
+ * Common error base class, error codes, and span extraction for roll-parser.
  *
  * @module errors
  */
+import type { ASTNode } from './parser/ast.js';
 /**
- * All known roll-parser error codes. Single source of truth — the
- * `RollParserErrorCode` type and the runtime `VALID_CODES` set are
- * both derived from this array.
+ * Every roll-parser error code, as a readonly tuple. Single source of truth —
+ * the {@link RollParserErrorCode} union is derived from it, and it is the
+ * runtime counterpart for the type: validating an untrusted string, driving an
+ * exhaustive UI (a message-catalog completeness check, a settings list), or
+ * iterating the codes in tests.
+ *
+ * @example
+ * ```typescript
+ * import { ROLL_PARSER_ERROR_CODES, type RollParserErrorCode } from 'roll-parser';
+ *
+ * function isKnownCode(value: string): value is RollParserErrorCode {
+ *   return (ROLL_PARSER_ERROR_CODES as readonly string[]).includes(value);
+ * }
+ * ```
+ *
+ * @category Errors
+ */
+export declare const ROLL_PARSER_ERROR_CODES: readonly ['UNEXPECTED_CHARACTER', 'UNEXPECTED_IDENTIFIER', 'UNEXPECTED_TOKEN', 'UNEXPECTED_END', 'EXPECTED_TOKEN', 'INVALID_DICE_COUNT', 'INVALID_DICE_SIDES', 'DICE_LIMIT_EXCEEDED', 'DIVISION_BY_ZERO', 'MODULO_BY_ZERO', 'UNKNOWN_OPERATOR', 'UNKNOWN_NODE_TYPE', 'INVALID_KEEP_DROP_COUNT', 'INVALID_KEEP_DROP_TARGET', 'EXPLODE_LIMIT_EXCEEDED', 'INVALID_EXPLODE_TARGET', 'REROLL_LIMIT_EXCEEDED', 'INVALID_REROLL_TARGET', 'INVALID_SUCCESS_COUNT_TARGET', 'INVALID_SORT_TARGET', 'INVALID_CRIT_THRESHOLD_TARGET', 'INVALID_DIE_BOUND_TARGET', 'INVALID_THRESHOLD', 'NESTED_VERSUS', 'INVALID_FUNCTION_ARITY', 'UNKNOWN_FUNCTION', 'UNDEFINED_VARIABLE', 'INVALID_VARIABLE_VALUE', 'AMBIGUOUS_DICE_CHAIN', 'MAX_DEPTH_EXCEEDED', 'NON_FINITE_RESULT', 'INCOMPATIBLE_RNG_STATE', 'INVALID_EVALUATION_LIMIT', 'INVALID_NOTATION_TYPE'];
+/**
+ * Programmatic identifier carried by every roll-parser error, grouped by the
+ * stage that raises it. The runtime list behind this union is exported as
+ * {@link ROLL_PARSER_ERROR_CODES}.
  *
  * Lexer: `UNEXPECTED_CHARACTER`, `UNEXPECTED_IDENTIFIER`
+ *
  * Parser: `UNEXPECTED_TOKEN`, `UNEXPECTED_END`, `EXPECTED_TOKEN`,
- *   `INVALID_MODIFIER_TARGET`, `INVALID_EXPLODE_TARGET`, `INVALID_REROLL_TARGET`,
- *   `INVALID_SUCCESS_COUNT_TARGET`, `INVALID_SORT_TARGET`,
- *   `INVALID_CRIT_THRESHOLD_TARGET`, `NESTED_VERSUS`, `INVALID_FUNCTION_ARITY`,
- *   `AMBIGUOUS_DICE_CHAIN`, `MAX_DEPTH_EXCEEDED`
+ * `INVALID_KEEP_DROP_TARGET`, `INVALID_EXPLODE_TARGET`, `INVALID_REROLL_TARGET`,
+ * `INVALID_SUCCESS_COUNT_TARGET`, `INVALID_SORT_TARGET`,
+ * `INVALID_CRIT_THRESHOLD_TARGET`, `INVALID_DIE_BOUND_TARGET`, `NESTED_VERSUS`,
+ * `INVALID_FUNCTION_ARITY`, `AMBIGUOUS_DICE_CHAIN`, `MAX_DEPTH_EXCEEDED`
+ *
  * Evaluator: `INVALID_DICE_COUNT`, `INVALID_DICE_SIDES`, `DICE_LIMIT_EXCEEDED`,
- *   `DIVISION_BY_ZERO`, `MODULO_BY_ZERO`, `UNKNOWN_OPERATOR`, `UNKNOWN_NODE_TYPE`,
- *   `INVALID_MODIFIER_COUNT`, `EXPLODE_LIMIT_EXCEEDED`, `REROLL_LIMIT_EXCEEDED`,
- *   `INVALID_THRESHOLD`, `NESTED_VERSUS`, `UNKNOWN_FUNCTION`, `UNDEFINED_VARIABLE`,
- *   `INVALID_VARIABLE_VALUE`, `NON_FINITE_RESULT`
+ * `DIVISION_BY_ZERO`, `MODULO_BY_ZERO`, `UNKNOWN_OPERATOR`, `UNKNOWN_NODE_TYPE`,
+ * `INVALID_KEEP_DROP_COUNT`, `EXPLODE_LIMIT_EXCEEDED`, `REROLL_LIMIT_EXCEEDED`,
+ * `INVALID_THRESHOLD`, `NESTED_VERSUS`, `UNKNOWN_FUNCTION`, `UNDEFINED_VARIABLE`,
+ * `INVALID_VARIABLE_VALUE`, `NON_FINITE_RESULT`
+ *
+ * RNG: `INCOMPATIBLE_RNG_STATE`
+ *
+ * Options: `INVALID_EVALUATION_LIMIT` — raised before evaluation begins, from
+ * the options object rather than from the notation, so it carries no span.
+ *
+ * Input: `INVALID_NOTATION_TYPE` — raised before lexing, when `notation` is not
+ * a string, so it carries no span either.
+ *
+ * New codes are only ever introduced in a minor release, never a patch. Treat
+ * the union as open when you switch over it: give the switch a `default` arm
+ * rather than relying on exhaustiveness, or a minor upgrade turns a new code
+ * into a silent fall-through.
+ *
+ * @example
+ * ```typescript
+ * import { isRollParserError, roll, type RollParserErrorCode } from 'roll-parser';
+ *
+ * const MESSAGES: Partial<Record<RollParserErrorCode, string>> = {
+ *   DICE_LIMIT_EXCEEDED: 'That is too many dice.',
+ *   DIVISION_BY_ZERO: 'Cannot divide by zero.',
+ *   UNEXPECTED_CHARACTER: 'That is not valid dice notation.',
+ * };
+ *
+ * try {
+ *   roll(userInput);
+ * } catch (error) {
+ *   if (isRollParserError(error)) {
+ *     reply(MESSAGES[error.code] ?? error.message);
+ *   }
+ * }
+ * ```
+ *
+ * @category Errors
  */
-declare const ROLL_PARSER_ERROR_CODES: readonly ["UNEXPECTED_CHARACTER", "UNEXPECTED_IDENTIFIER", "UNEXPECTED_TOKEN", "UNEXPECTED_END", "EXPECTED_TOKEN", "INVALID_DICE_COUNT", "INVALID_DICE_SIDES", "DICE_LIMIT_EXCEEDED", "DIVISION_BY_ZERO", "MODULO_BY_ZERO", "UNKNOWN_OPERATOR", "UNKNOWN_NODE_TYPE", "INVALID_MODIFIER_COUNT", "INVALID_MODIFIER_TARGET", "EXPLODE_LIMIT_EXCEEDED", "INVALID_EXPLODE_TARGET", "REROLL_LIMIT_EXCEEDED", "INVALID_REROLL_TARGET", "INVALID_SUCCESS_COUNT_TARGET", "INVALID_SORT_TARGET", "INVALID_CRIT_THRESHOLD_TARGET", "INVALID_THRESHOLD", "NESTED_VERSUS", "INVALID_FUNCTION_ARITY", "UNKNOWN_FUNCTION", "UNDEFINED_VARIABLE", "INVALID_VARIABLE_VALUE", "AMBIGUOUS_DICE_CHAIN", "MAX_DEPTH_EXCEEDED", "NON_FINITE_RESULT"];
 export type RollParserErrorCode = (typeof ROLL_PARSER_ERROR_CODES)[number];
+/**
+ * The subset of {@link ROLL_PARSER_ERROR_CODES} the *input* is answerable for,
+ * as a readonly tuple. Runtime counterpart of {@link NotationErrorCode} and the
+ * list {@link isNotationError} matches against.
+ *
+ * A code is in when `roll(notation)` can raise it for some notation string,
+ * given valid options and a valid `context` — so the right response is to tell
+ * whoever supplied the notation that it was rejected. Six codes are out, because
+ * for each of them the notation is innocent:
+ *
+ * Calling code: `INVALID_EVALUATION_LIMIT` (a bad `maxDice`,
+ * `maxExplodeIterations`, or `maxRerollIterations`), `INVALID_VARIABLE_VALUE` (a
+ * non-finite entry in `context`), `INCOMPATIBLE_RNG_STATE` (a snapshot from
+ * another version)
+ *
+ * Library invariant: `UNKNOWN_NODE_TYPE`, `UNKNOWN_OPERATOR`,
+ * `UNKNOWN_FUNCTION` — the lexer and parser only ever hand the evaluator shapes
+ * it already covers, so reaching one means a hand-built AST or a bug in here.
+ *
+ * Two boundaries are worth knowing. `DIVISION_BY_ZERO`, `MODULO_BY_ZERO`, and
+ * `NON_FINITE_RESULT` are in because notation alone reaches them (`1d6/0`,
+ * `10**400`), but a `context` variable reaches them too, so a `true` is not
+ * proof the notation was at fault. `INVALID_NOTATION_TYPE` is in even though no
+ * user can type a non-string: it means the `notation` you were handed was
+ * `null` or `undefined` — an absent slash-command option, a missing JSON field —
+ * and "give me a dice expression" is the reply that fits.
+ *
+ * @example
+ * ```typescript
+ * import { NOTATION_ERROR_CODES } from 'roll-parser';
+ *
+ * // Prompt copy is only worth writing for the codes a user can actually cause.
+ * const needsCopy = new Set(NOTATION_ERROR_CODES);
+ * ```
+ *
+ * @category Errors
+ */
+export declare const NOTATION_ERROR_CODES: readonly ['UNEXPECTED_CHARACTER', 'UNEXPECTED_IDENTIFIER', 'UNEXPECTED_TOKEN', 'UNEXPECTED_END', 'EXPECTED_TOKEN', 'INVALID_DICE_COUNT', 'INVALID_DICE_SIDES', 'DICE_LIMIT_EXCEEDED', 'DIVISION_BY_ZERO', 'MODULO_BY_ZERO', 'INVALID_KEEP_DROP_COUNT', 'INVALID_KEEP_DROP_TARGET', 'EXPLODE_LIMIT_EXCEEDED', 'INVALID_EXPLODE_TARGET', 'REROLL_LIMIT_EXCEEDED', 'INVALID_REROLL_TARGET', 'INVALID_SUCCESS_COUNT_TARGET', 'INVALID_SORT_TARGET', 'INVALID_CRIT_THRESHOLD_TARGET', 'INVALID_DIE_BOUND_TARGET', 'INVALID_THRESHOLD', 'NESTED_VERSUS', 'INVALID_FUNCTION_ARITY', 'UNDEFINED_VARIABLE', 'AMBIGUOUS_DICE_CHAIN', 'MAX_DEPTH_EXCEEDED', 'NON_FINITE_RESULT', 'INVALID_NOTATION_TYPE'];
+/**
+ * A {@link RollParserErrorCode} the input is answerable for. The runtime list
+ * behind this union is exported as {@link NOTATION_ERROR_CODES}, which documents
+ * where the line falls.
+ *
+ * @category Errors
+ */
+export type NotationErrorCode = (typeof NOTATION_ERROR_CODES)[number];
 /**
  * Base error class for all roll-parser errors.
  *
  * Provides a typed `code` field for programmatic error handling.
  * All library errors (`LexerError`, `ParseError`, `EvaluatorError`)
  * extend this class.
+ *
+ * Error messages never embed the source position — every subclass reports it
+ * through structured fields instead, readable uniformly via
+ * {@link getErrorSpan}. Prefer {@link isRollParserError} over `instanceof`: it
+ * also matches errors from another realm or a duplicate copy of the library.
+ *
+ * @example
+ * ```typescript
+ * import { roll, RollParserError } from 'roll-parser';
+ *
+ * try {
+ *   roll('1d6/0');
+ * } catch (error) {
+ *   const typed = error as RollParserError;
+ *   typed.name; // 'EvaluatorError'
+ *   typed.code; // 'DIVISION_BY_ZERO'
+ *   typed.message; // 'Division by zero'
+ * }
+ * ```
+ *
+ * @category Errors
  */
 export declare class RollParserError extends Error {
+    /**
+     * Stable programmatic identifier for the failure. Branch on this rather
+     * than on `message`, which is free to change between releases.
+     */
     readonly code: RollParserErrorCode;
-    constructor(message: string, code: RollParserErrorCode);
+    constructor(message: string, code: RollParserErrorCode, options?: ErrorOptions);
+}
+/**
+ * Error thrown during AST evaluation.
+ *
+ * Lives here rather than in `evaluator/evaluator.ts` so the modifier
+ * implementations can throw it without importing back into the evaluator —
+ * that value-level round trip was a genuine ESM cycle. `evaluator.ts`
+ * re-exports the class for existing importers.
+ *
+ * Unlike `LexerError` / `ParseError` — which point at a single offset — an
+ * `EvaluatorError` carries a full `start`/`end` span covering the failing
+ * sub-expression, because by evaluation time the AST knows its own extent.
+ *
+ * @example
+ * ```typescript
+ * import { getErrorSpan, roll } from 'roll-parser';
+ *
+ * try {
+ *   roll('2d6+1d0+3');
+ * } catch (error) {
+ *   (error as Error).name; // 'EvaluatorError'
+ *   getErrorSpan(error); // { start: 4, end: 7 } — the '1d0' sub-expression
+ * }
+ * ```
+ *
+ * @category Errors
+ */
+export declare class EvaluatorError extends RollParserError {
+    #private;
+    /**
+     * `ASTNode.type` of the node that raised the error (`'Dice'`, `'BinaryOp'`,
+     * …). `undefined` for failures raised outside a node context, such as the
+     * whole-expression dice budget.
+     */
+    readonly nodeType: ASTNode['type'] | undefined;
+    constructor(message: string, code: RollParserErrorCode, nodeType?: ASTNode['type'], options?: ErrorOptions);
+    /**
+     * Start offset of the tightest AST node that was being evaluated when the
+     * error was thrown. `undefined` when the AST was built without parser spans.
+     */
+    get start(): number | undefined;
+    /** Exclusive end offset of the span described by `start`. */
+    get end(): number | undefined;
 }
 /**
- * Type guard for roll-parser errors. Checks `instanceof` first, then
- * falls back to duck-typing for cross-realm safety.
+ * Source span of an error, in UTF-16 code units into the original notation.
+ * `start` is inclusive; `end` is exclusive and present only when the error
+ * carries a full span (evaluator errors) rather than a single offset.
+ *
+ * @category Errors
+ */
+export type ErrorSpan = {
+    start: number;
+    end?: number;
+};
+/**
+ * Type guard for roll-parser errors. Checks `instanceof` first, then a brand
+ * carried on the error's prototype — so it still matches when `instanceof`
+ * cannot, namely an error from an iframe or `vm` context, or from a second copy
+ * of the library in `node_modules` at this version or newer.
+ *
+ * Use it as the outer filter in every `catch`: anything it rejects came from
+ * somewhere else and should be rethrown. The brand is what makes that sound — a
+ * foreign error is never accepted just for carrying a `code` that happens to
+ * collide with one of ours.
+ *
+ * What it answers is "did this come from us", not "whose fault was it". A `true`
+ * covers bad notation, a bad options object, and a broken invariant in here
+ * alike, so it is the wrong test to hang a user-facing message on. Reach for
+ * {@link isNotationError} for that.
+ *
+ * Only this library's own error prototype carries the brand, so holding it is
+ * proof of origin, and the `code` is trusted rather than re-validated: an error
+ * from a newer minor passes with a code this build has never heard of, which is
+ * what {@link RollParserErrorCode} being an open union already implies. A value
+ * that forges the brand is out of scope, as it is for any brand check.
+ *
+ * The one boundary it cannot cross is a worker. `postMessage` and
+ * `structuredClone` rebuild an `Error` from `message` and `stack` alone,
+ * discarding `code`, `name`, and the prototype with it, so the value that
+ * arrives is no longer recognizable as anything. Send `error.code` yourself as
+ * part of the message payload if the other side needs it.
+ *
+ * @param value - The caught value, of unknown type
+ * @returns `true` when `value` is a roll-parser error
+ *
+ * @example
+ * ```typescript
+ * import { isRollParserError, roll } from 'roll-parser';
+ *
+ * try {
+ *   roll('2d6+&');
+ * } catch (error) {
+ *   if (!isRollParserError(error)) throw error;
+ *   error.code; // 'UNEXPECTED_CHARACTER'
+ *   error.message; // "Unexpected character: '&'"
+ * }
+ * ```
+ *
+ * @category Errors
  */
 export declare function isRollParserError(value: unknown): value is RollParserError;
-export {};
+/**
+ * Type guard for the failures the input is answerable for: a roll-parser error
+ * whose `code` is one of {@link NOTATION_ERROR_CODES}. This is the test to hang
+ * a user-facing message on — {@link isRollParserError} only establishes origin,
+ * and answers `true` for a bad options object and a broken library invariant
+ * too, both of which should page you instead.
+ *
+ * Pair the two: the outer filter rethrows what is not ours, and this one splits
+ * what is left into "tell the user" and "report a bug".
+ *
+ * Unlike {@link isRollParserError}, this one has to read the `code` against the
+ * list this build carries — attribution is not something a brand can express. So
+ * where the outer filter accepts a code it has never heard of, this one rejects
+ * it: an error from a newer minor carrying a notation code added after this build
+ * reads as `false` and is misfiled as internal. That is the safe direction — it
+ * pages a developer rather than blaming a user — but keep the library and its
+ * consumers on one version when the distinction drives more than a message.
+ *
+ * @param value - The caught value, of unknown type
+ * @returns `true` when `value` is a roll-parser error the input caused
+ *
+ * @example Two channels, one catch
+ * ```typescript
+ * import { isNotationError, isRollParserError, roll } from 'roll-parser';
+ *
+ * try {
+ *   roll(userInput);
+ * } catch (error) {
+ *   if (!isRollParserError(error)) throw error;
+ *   if (isNotationError(error)) reply(`Bad notation: ${error.message}`);
+ *   else report(error); // our bug or yours — never the user's
+ * }
+ * ```
+ *
+ * @category Errors
+ */
+export declare function isNotationError(value: unknown): value is RollParserError & {
+    code: NotationErrorCode;
+};
+/**
+ * Renders a rejected value for an error message, never coercing an object:
+ * `String(Object.create(null))` throws, and a hostile `toString` can too —
+ * either would replace the typed error with a raw `TypeError`.
+ *
+ * Module-level export, deliberately absent from `src/index.ts` — the package
+ * surface never mentions it.
+ */
+export declare function describeValue(value: unknown): string;
+/**
+ * Normalizes the three error position shapes into one span.
+ *
+ * `LexerError` and `ParseError` expose a single `position`; `EvaluatorError`
+ * exposes `start`/`end`. Returns `undefined` for errors that are not
+ * roll-parser errors, or that carry no usable offset (an `EvaluatorError`
+ * raised on a hand-built AST, for instance).
+ *
+ * @param error - The caught value, of unknown type
+ * @returns The span, or `undefined` when none is available
+ *
+ * @example Rendering a caret, the way the CLI does
+ * ```typescript
+ * import { getErrorSpan, isRollParserError, roll } from 'roll-parser';
+ *
+ * function explain(notation: string): string | undefined {
+ *   try {
+ *     roll(notation);
+ *     return undefined;
+ *   } catch (error) {
+ *     if (!isRollParserError(error)) throw error;
+ *     const span = getErrorSpan(error);
+ *     if (span == null) return error.message;
+ *     const width = (span.end ?? span.start + 1) - span.start;
+ *     return [
+ *       error.message,
+ *       notation,
+ *       ' '.repeat(span.start) + '^'.repeat(width),
+ *     ].join('\n');
+ *   }
+ * }
+ *
+ * explain('2d6+&');
+ * // Unexpected character: '&'
+ * // 2d6+&
+ * //     ^
+ *
+ * explain('2d6+1d0+3');
+ * // Invalid dice sides: 0
+ * // 2d6+1d0+3
+ * //     ^^^
+ * ```
+ *
+ * @category Errors
+ */
+export declare function getErrorSpan(error: unknown): ErrorSpan | undefined;
 //# sourceMappingURL=errors.d.ts.map

package/dist/errors.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH;;;;;;;;;;;;;;;;GAgBG;AACH,QAAA,MAAM,uBAAuB,gsBA+BnB,CAAC;AAEX,MAAM,MAAM,mBAAmB,GAAG,CAAC,OAAO,uBAAuB,CAAC,CAAC,MAAM,CAAC,CAAC;AAE3E;;;;;;GAMG;AACH,qBAAa,eAAgB,SAAQ,KAAK;IACxC,QAAQ,CAAC,IAAI,EAAE,mBAAmB,CAAC;gBAEvB,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,mBAAmB;CAKvD;AAID;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,eAAe,CAQ1E"}
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"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"}

package/dist/errors.js

@@ -0,0 +1,141 @@
+export const ROLL_PARSER_ERROR_CODES = [
+    'UNEXPECTED_CHARACTER',
+    'UNEXPECTED_IDENTIFIER',
+    'UNEXPECTED_TOKEN',
+    'UNEXPECTED_END',
+    'EXPECTED_TOKEN',
+    'INVALID_DICE_COUNT',
+    'INVALID_DICE_SIDES',
+    'DICE_LIMIT_EXCEEDED',
+    'DIVISION_BY_ZERO',
+    'MODULO_BY_ZERO',
+    'UNKNOWN_OPERATOR',
+    'UNKNOWN_NODE_TYPE',
+    'INVALID_KEEP_DROP_COUNT',
+    'INVALID_KEEP_DROP_TARGET',
+    'EXPLODE_LIMIT_EXCEEDED',
+    'INVALID_EXPLODE_TARGET',
+    'REROLL_LIMIT_EXCEEDED',
+    'INVALID_REROLL_TARGET',
+    'INVALID_SUCCESS_COUNT_TARGET',
+    'INVALID_SORT_TARGET',
+    'INVALID_CRIT_THRESHOLD_TARGET',
+    'INVALID_DIE_BOUND_TARGET',
+    'INVALID_THRESHOLD',
+    'NESTED_VERSUS',
+    'INVALID_FUNCTION_ARITY',
+    'UNKNOWN_FUNCTION',
+    'UNDEFINED_VARIABLE',
+    'INVALID_VARIABLE_VALUE',
+    'AMBIGUOUS_DICE_CHAIN',
+    'MAX_DEPTH_EXCEEDED',
+    'NON_FINITE_RESULT',
+    'INCOMPATIBLE_RNG_STATE',
+    'INVALID_EVALUATION_LIMIT',
+    'INVALID_NOTATION_TYPE',
+];
+export const NOTATION_ERROR_CODES = [
+    'UNEXPECTED_CHARACTER',
+    'UNEXPECTED_IDENTIFIER',
+    'UNEXPECTED_TOKEN',
+    'UNEXPECTED_END',
+    'EXPECTED_TOKEN',
+    'INVALID_DICE_COUNT',
+    'INVALID_DICE_SIDES',
+    'DICE_LIMIT_EXCEEDED',
+    'DIVISION_BY_ZERO',
+    'MODULO_BY_ZERO',
+    'INVALID_KEEP_DROP_COUNT',
+    'INVALID_KEEP_DROP_TARGET',
+    'EXPLODE_LIMIT_EXCEEDED',
+    'INVALID_EXPLODE_TARGET',
+    'REROLL_LIMIT_EXCEEDED',
+    'INVALID_REROLL_TARGET',
+    'INVALID_SUCCESS_COUNT_TARGET',
+    'INVALID_SORT_TARGET',
+    'INVALID_CRIT_THRESHOLD_TARGET',
+    'INVALID_DIE_BOUND_TARGET',
+    'INVALID_THRESHOLD',
+    'NESTED_VERSUS',
+    'INVALID_FUNCTION_ARITY',
+    'UNDEFINED_VARIABLE',
+    'AMBIGUOUS_DICE_CHAIN',
+    'MAX_DEPTH_EXCEEDED',
+    'NON_FINITE_RESULT',
+    'INVALID_NOTATION_TYPE',
+];
+const ERROR_BRAND = Symbol.for('roll-parser.error');
+export class RollParserError extends Error {
+    code;
+    constructor(message, code, options) {
+        super(message, options);
+        this.name = 'RollParserError';
+        this.code = code;
+    }
+    get [ERROR_BRAND]() {
+        return true;
+    }
+}
+export let stampEvaluatorSpan;
+export class EvaluatorError extends RollParserError {
+    nodeType;
+    #start;
+    #end;
+    constructor(message, code, nodeType, options) {
+        super(message, code, options);
+        this.name = 'EvaluatorError';
+        this.nodeType = nodeType;
+    }
+    get start() {
+        return this.#start;
+    }
+    get end() {
+        return this.#end;
+    }
+    static {
+        stampEvaluatorSpan = (error, start, end) => {
+            if (error.#start != null)
+                return;
+            error.#start = start;
+            error.#end = end;
+        };
+    }
+}
+export function isRollParserError(value) {
+    if (value instanceof RollParserError)
+        return true;
+    return (typeof value === 'object' &&
+        value !== null &&
+        value[ERROR_BRAND] === true);
+}
+const NOTATION_CODES = new Set(NOTATION_ERROR_CODES);
+export function isNotationError(value) {
+    return isRollParserError(value) && NOTATION_CODES.has(value.code);
+}
+export function describeValue(value) {
+    if (typeof value === 'string')
+        return JSON.stringify(value);
+    if (value === null)
+        return 'null';
+    if (typeof value === 'object' || typeof value === 'function')
+        return typeof value;
+    return String(value);
+}
+function isOffset(value) {
+    return typeof value === 'number' && Number.isInteger(value) && value >= 0;
+}
+export function getErrorSpan(error) {
+    if (!isRollParserError(error))
+        return undefined;
+    if ('position' in error && isOffset(error.position)) {
+        return { start: error.position };
+    }
+    if ('start' in error && isOffset(error.start)) {
+        const span = { start: error.start };
+        if ('end' in error && isOffset(error.end))
+            span.end = error.end;
+        return span;
+    }
+    return undefined;
+}
+//# sourceMappingURL=errors.js.map

package/dist/errors.js.map

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

package/dist/evaluator/die.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Die-result construction shared by the evaluator and the modifier
+ * implementations.
+ *
+ * Lives in its own module so the crit/fumble rule has exactly one definition —
+ * pool rolling (`evaluator.ts`), explosion continuation dice (`modifiers/
+ * explode.ts`), and reroll replacements (`modifiers/reroll.ts`) all build dice
+ * through here.
+ *
+ * @module evaluator/die
+ */
+import type { DieModifier, DieResult } from '../types.js';
+/**
+ * Creates a die result with critical/fumble detection.
+ *
+ * `modifiers` is taken by the caller because the flags depend on how the die
+ * entered the pool (a fresh pool die starts bare, an explosion continuation
+ * die starts `['exploded', 'kept']`).
+ */
+export declare function createDieResult(sides: number, result: number, modifiers: DieModifier[]): DieResult;
+/**
+ * Creates a Fate/Fudge die result. Uses `sides = 0` as a sentinel — Fate dice
+ * have no max-face concept, so `critical` and `fumble` are always `false`.
+ */
+export declare function createFateDieResult(result: number, modifiers: DieModifier[]): DieResult;
+//# sourceMappingURL=die.d.ts.map

package/dist/evaluator/die.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"die.d.ts","sourceRoot":"","sources":["../../src/evaluator/die.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAE1D;;;;;;GAMG;AACH,wBAAgB,eAAe,CAC7B,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,EACd,SAAS,EAAE,WAAW,EAAE,GACvB,SAAS,CAUX;AAED;;;GAGG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,WAAW,EAAE,GAAG,SAAS,CAQvF"}

package/dist/evaluator/die.js

@@ -0,0 +1,19 @@
+export function createDieResult(sides, result, modifiers) {
+    return {
+        sides,
+        result,
+        modifiers,
+        critical: result === sides && sides > 1,
+        fumble: result === 1 && sides > 1,
+    };
+}
+export function createFateDieResult(result, modifiers) {
+    return {
+        sides: 0,
+        result,
+        modifiers,
+        critical: false,
+        fumble: false,
+    };
+}
+//# sourceMappingURL=die.js.map

package/dist/evaluator/die.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"die.js","sourceRoot":"","sources":["../../src/evaluator/die.ts"],"names":[],"mappings":"AAqBA,MAAM,UAAU,eAAe,CAC7B,KAAa,EACb,MAAc,EACd,SAAwB;IAIxB,OAAO;QACL,KAAK;QACL,MAAM;QACN,SAAS;QACT,QAAQ,EAAE,MAAM,KAAK,KAAK,IAAI,KAAK,GAAG,CAAC;QACvC,MAAM,EAAE,MAAM,KAAK,CAAC,IAAI,KAAK,GAAG,CAAC;KAClC,CAAC;AACJ,CAAC;AAMD,MAAM,UAAU,mBAAmB,CAAC,MAAc,EAAE,SAAwB;IAC1E,OAAO;QACL,KAAK,EAAE,CAAC;QACR,MAAM;QACN,SAAS;QACT,QAAQ,EAAE,KAAK;QACf,MAAM,EAAE,KAAK;KACd,CAAC;AACJ,CAAC"}

package/dist/evaluator/env.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Per-evaluation shared environment.
+ *
+ * Lives in its own module so the modifier implementations under
+ * `./modifiers/*` can type their `env` parameter without importing
+ * `./evaluator.js`, which imports them back.
+ *
+ * @module evaluator/env
+ */
+import type { ASTNode } from '../parser/ast.js';
+/**
+ * Per-evaluation shared environment (created once, shared across all branches).
+ *
+ * Exported for use by modifier implementations under `./modifiers/*`. Not part
+ * of the public library API.
+ */
+export type EvalEnv = {
+    readonly maxDice: number;
+    readonly maxExplodeIterations: number;
+    readonly maxRerollIterations: number;
+    totalDiceRolled: number;
+    /**
+     * Set to `true` by `evalSuccessCount`. Propagates through the shared env
+     * so `evaluate()` can include `successes`/`failures` fields even when no
+     * die was tagged (impossible threshold).
+     */
+    hasSuccessCount: boolean;
+    /**
+     * `true` while the evaluator is inside a `VersusNode`'s roll or DC
+     * sub-evaluation. `evalVersus` rejects nesting via this flag — catches
+     * paren-nested versus (`1d20 vs (5 vs 3)`) that slip past the parser's
+     * left-chain check.
+     */
+    insideVersus: boolean;
+    /**
+     * User-supplied variable map for `@name` / `@{name}` references. Always
+     * defined — `evaluate()` defaults to an empty object so lookups can be
+     * branch-free on presence.
+     */
+    readonly context: Readonly<Record<string, number>>;
+    /**
+     * Behavior when a referenced variable is missing from `context`. Always
+     * defined — `evaluate()` defaults to `'throw'`.
+     */
+    readonly onMissingVariable: 'throw' | 'zero';
+};
+/**
+ * Reserves `count` dice against the global `maxDice` budget, throwing
+ * `DICE_LIMIT_EXCEEDED` when the reservation would overshoot.
+ *
+ * Every path that consumes RNG draws for dice charges through here — initial
+ * pools (`evalDice` / `evalFateDice`), explosion continuations, and reroll
+ * replacements — so the limit and its message have one definition.
+ */
+export declare function chargeDice(env: EvalEnv, count: number, nodeType: ASTNode['type']): void;
+/** Single-die shorthand for {@link chargeDice}. */
+export declare function chargeDie(env: EvalEnv, nodeType: ASTNode['type']): void;
+//# sourceMappingURL=env.d.ts.map

package/dist/evaluator/env.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"env.d.ts","sourceRoot":"","sources":["../../src/evaluator/env.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAGH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,kBAAkB,CAAC;AAEhD;;;;;GAKG;AACH,MAAM,MAAM,OAAO,GAAG;IACpB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,oBAAoB,EAAE,MAAM,CAAC;IACtC,QAAQ,CAAC,mBAAmB,EAAE,MAAM,CAAC;IACrC,eAAe,EAAE,MAAM,CAAC;IACxB;;;;OAIG;IACH,eAAe,EAAE,OAAO,CAAC;IACzB;;;;;OAKG;IACH,YAAY,EAAE,OAAO,CAAC;IACtB;;;;OAIG;IACH,QAAQ,CAAC,OAAO,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;IACnD;;;OAGG;IACH,QAAQ,CAAC,iBAAiB,EAAE,OAAO,GAAG,MAAM,CAAC;CAC9C,CAAC;AAEF;;;;;;;GAOG;AACH,wBAAgB,UAAU,CAAC,GAAG,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,OAAO,CAAC,MAAM,CAAC,GAAG,IAAI,CASvF;AAED,mDAAmD;AACnD,wBAAgB,SAAS,CAAC,GAAG,EAAE,OAAO,EAAE,QAAQ,EAAE,OAAO,CAAC,MAAM,CAAC,GAAG,IAAI,CAEvE"}

package/dist/evaluator/env.js

@@ -0,0 +1,11 @@
+import { EvaluatorError } from '../errors.js';
+export function chargeDice(env, count, nodeType) {
+    if (env.totalDiceRolled + count > env.maxDice) {
+        throw new EvaluatorError(`Total dice count ${env.totalDiceRolled + count} exceeds limit of ${env.maxDice}`, 'DICE_LIMIT_EXCEEDED', nodeType);
+    }
+    env.totalDiceRolled += count;
+}
+export function chargeDie(env, nodeType) {
+    chargeDice(env, 1, nodeType);
+}
+//# sourceMappingURL=env.js.map

package/dist/evaluator/env.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"env.js","sourceRoot":"","sources":["../../src/evaluator/env.ts"],"names":[],"mappings":"AAUA,OAAO,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAgD9C,MAAM,UAAU,UAAU,CAAC,GAAY,EAAE,KAAa,EAAE,QAAyB;IAC/E,IAAI,GAAG,CAAC,eAAe,GAAG,KAAK,GAAG,GAAG,CAAC,OAAO,EAAE,CAAC;QAC9C,MAAM,IAAI,cAAc,CACtB,oBAAoB,GAAG,CAAC,eAAe,GAAG,KAAK,qBAAqB,GAAG,CAAC,OAAO,EAAE,EACjF,qBAAqB,EACrB,QAAQ,CACT,CAAC;IACJ,CAAC;IACD,GAAG,CAAC,eAAe,IAAI,KAAK,CAAC;AAC/B,CAAC;AAGD,MAAM,UAAU,SAAS,CAAC,GAAY,EAAE,QAAyB;IAC/D,UAAU,CAAC,GAAG,EAAE,CAAC,EAAE,QAAQ,CAAC,CAAC;AAC/B,CAAC"}