roll-parser 3.0.0-alpha.0 → 3.0.0-beta.0

package/dist/errors.d.ts

@@ -10,14 +10,17 @@
  *
  * Lexer: `UNEXPECTED_CHARACTER`, `UNEXPECTED_IDENTIFIER`
  * Parser: `UNEXPECTED_TOKEN`, `UNEXPECTED_END`, `EXPECTED_TOKEN`,
- *   `INVALID_EXPLODE_TARGET`, `INVALID_SUCCESS_COUNT_TARGET`, `NESTED_VERSUS`,
- *   `INVALID_FUNCTION_ARITY`
+ *   `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`
  * 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`
+ *   `INVALID_THRESHOLD`, `NESTED_VERSUS`, `UNKNOWN_FUNCTION`, `UNDEFINED_VARIABLE`,
+ *   `INVALID_VARIABLE_VALUE`, `NON_FINITE_RESULT`
  */
-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", "EXPLODE_LIMIT_EXCEEDED", "INVALID_EXPLODE_TARGET", "REROLL_LIMIT_EXCEEDED", "INVALID_SUCCESS_COUNT_TARGET", "INVALID_THRESHOLD", "NESTED_VERSUS", "INVALID_FUNCTION_ARITY", "UNKNOWN_FUNCTION"];
+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];
 /**
  * Base error class for all roll-parser errors.

package/dist/errors.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH;;;;;;;;;;;;;GAaG;AACH,QAAA,MAAM,uBAAuB,ieAsBnB,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":"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"}

package/dist/evaluator/evaluator.d.ts

@@ -3,18 +3,26 @@
  *
  * @module evaluator/evaluator
  */
-import type { RollParserErrorCode } from '../errors';
-import { RollParserError } from '../errors';
-import type { ASTNode } from '../parser/ast';
-import type { RNG } from '../rng/types';
-import type { EvaluateOptions, RollResult } from '../types';
-import { DEFAULT_MAX_EXPLODE_ITERATIONS } from './modifiers/explode';
-import { DEFAULT_MAX_REROLL_ITERATIONS } from './modifiers/reroll';
+import type { RollParserErrorCode } from '../errors.js';
+import { RollParserError } from '../errors.js';
+import type { ASTNode } from '../parser/ast.js';
+import type { RNG } from '../rng/types.js';
+import type { DieResult, EvaluateOptions, RollResult } from '../types.js';
+import { DegreeOfSuccess } from '../types.js';
+import { DEFAULT_MAX_EXPLODE_ITERATIONS } from './modifiers/explode.js';
+import { DEFAULT_MAX_REROLL_ITERATIONS } from './modifiers/reroll.js';
 /**
  * Error thrown during AST evaluation.
  */
 export declare class EvaluatorError extends RollParserError {
     readonly nodeType: string | undefined;
+    /**
+     * Source span of the tightest AST node that was being evaluated when the
+     * error was thrown — stamped by `evalNode` on the way up, so the innermost
+     * node wins. `undefined` when the AST was built without parser spans.
+     */
+    start: number | undefined;
+    end: number | undefined;
     constructor(message: string, code: RollParserErrorCode, nodeType?: string);
 }
 /** Default maximum total dice allowed per evaluation. */
@@ -44,7 +52,55 @@ export type EvalEnv = {
      * 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';
 };
+/**
+ * Per-branch mutable accumulator for tracking rolls and output during recursion.
+ *
+ * @internal exported for targeted `mergeMetaRolls` tests only; not a public API.
+ */
+export type EvalContext = {
+    rolls: DieResult[];
+    expressionParts: string[];
+    renderedParts: string[];
+    /**
+     * Populated by `evalVersus` with the resolved degree and natural value.
+     * `evaluate()` reads this from the top-level ctx to surface `degree` and
+     * `natural` on the final `RollResult`. Only populated when `vs` is the
+     * root of the expression.
+     */
+    versusMetadata?: {
+        degree: DegreeOfSuccess;
+        natural: number | undefined;
+        dcTotal: number;
+    };
+};
+/**
+ * Forwards rolls from a throwaway sub-expression context into the parent
+ * audit trail, tagging them as `'meta'` + `'dropped'`. Meta dice are dice
+ * rolled to compute parameters (dice count, sides, threshold, modifier
+ * count) — they consume RNG and count against `maxDice`, so they must be
+ * inspectable. Tagging them `'dropped'` keeps totals correct via
+ * `sumKeptDice`; `'meta'` lets renderers hide them and lets callers
+ * distinguish them from ordinary pool dice.
+ *
+ * `'success'`/`'failure'` tags are stripped here as defense-in-depth against
+ * a SuccessCount leaking into a meta sub-expression (parser rejects all such
+ * wrappings; this strip ensures a future parse regression cannot leak tags
+ * into the top-level `successes`/`failures` scan).
+ */
+/** @internal exported for targeted defense-in-depth tests only. */
+export declare function mergeMetaRolls(parent: EvalContext, source: EvalContext): void;
 /**
  * Evaluates a parsed AST and returns the roll result.
  *

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

@@ -1 +1 @@
-{"version":3,"file":"evaluator.d.ts","sourceRoot":"","sources":["../../src/evaluator/evaluator.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,WAAW,CAAC;AACrD,OAAO,EAAE,eAAe,EAAE,MAAM,WAAW,CAAC;AAC5C,OAAO,KAAK,EACV,OAAO,EAWR,MAAM,eAAe,CAAC;AAEvB,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,cAAc,CAAC;AACxC,OAAO,KAAK,EAA2B,eAAe,EAAE,UAAU,EAAE,MAAM,UAAU,CAAC;AAErF,OAAO,EAKL,8BAA8B,EAC/B,MAAM,qBAAqB,CAAC;AAS7B,OAAO,EAGL,6BAA6B,EAC9B,MAAM,oBAAoB,CAAC;AAG5B;;GAEG;AACH,qBAAa,cAAe,SAAQ,eAAe;IACjD,QAAQ,CAAC,QAAQ,EAAE,MAAM,GAAG,SAAS,CAAC;gBAE1B,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,mBAAmB,EAAE,QAAQ,CAAC,EAAE,MAAM;CAK1E;AAED,yDAAyD;AACzD,eAAO,MAAM,gBAAgB,QAAS,CAAC;AAEvC,OAAO,EAAE,8BAA8B,EAAE,6BAA6B,EAAE,CAAC;AAEzE;;;;;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;CACvB,CAAC;AAspBF;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,QAAQ,CAAC,GAAG,EAAE,OAAO,EAAE,GAAG,EAAE,GAAG,EAAE,OAAO,GAAE,eAAoB,GAAG,UAAU,CAqE1F"}
+{"version":3,"file":"evaluator.d.ts","sourceRoot":"","sources":["../../src/evaluator/evaluator.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,cAAc,CAAC;AACxD,OAAO,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AAC/C,OAAO,KAAK,EACV,OAAO,EAkBR,MAAM,kBAAkB,CAAC;AAE1B,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,iBAAiB,CAAC;AAC3C,OAAO,KAAK,EAEV,SAAS,EACT,eAAe,EAGf,UAAU,EACX,MAAM,aAAa,CAAC;AACrB,OAAO,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAE9C,OAAO,EAKL,8BAA8B,EAC/B,MAAM,wBAAwB,CAAC;AAShC,OAAO,EAGL,6BAA6B,EAC9B,MAAM,uBAAuB,CAAC;AAI/B;;GAEG;AACH,qBAAa,cAAe,SAAQ,eAAe;IACjD,QAAQ,CAAC,QAAQ,EAAE,MAAM,GAAG,SAAS,CAAC;IACtC;;;;OAIG;IACH,KAAK,EAAE,MAAM,GAAG,SAAS,CAAC;IAC1B,GAAG,EAAE,MAAM,GAAG,SAAS,CAAC;gBAEZ,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,mBAAmB,EAAE,QAAQ,CAAC,EAAE,MAAM;CAO1E;AAED,yDAAyD;AACzD,eAAO,MAAM,gBAAgB,QAAS,CAAC;AAEvC,OAAO,EAAE,8BAA8B,EAAE,6BAA6B,EAAE,CAAC;AAEzE;;;;;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;;;;GAIG;AACH,MAAM,MAAM,WAAW,GAAG;IACxB,KAAK,EAAE,SAAS,EAAE,CAAC;IACnB,eAAe,EAAE,MAAM,EAAE,CAAC;IAC1B,aAAa,EAAE,MAAM,EAAE,CAAC;IACxB;;;;;OAKG;IACH,cAAc,CAAC,EAAE;QACf,MAAM,EAAE,eAAe,CAAC;QACxB,OAAO,EAAE,MAAM,GAAG,SAAS,CAAC;QAC5B,OAAO,EAAE,MAAM,CAAC;KACjB,CAAC;CACH,CAAC;AA+FF;;;;;;;;;;;;;GAaG;AACH,mEAAmE;AACnE,wBAAgB,cAAc,CAAC,MAAM,EAAE,WAAW,EAAE,MAAM,EAAE,WAAW,GAAG,IAAI,CAa7E;AA8pCD;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,QAAQ,CAAC,GAAG,EAAE,OAAO,EAAE,GAAG,EAAE,GAAG,EAAE,OAAO,GAAE,eAAoB,GAAG,UAAU,CAmF1F"}

package/dist/evaluator/index.d.ts

@@ -3,6 +3,6 @@
  *
  * @module evaluator
  */
-export { DEFAULT_MAX_DICE, evaluate, EvaluatorError } from './evaluator';
-export { applyDropHighest, applyDropLowest, applyKeepHighest, applyKeepLowest, sumKeptDice, } from './modifiers/keep-drop';
+export { DEFAULT_MAX_DICE, evaluate, EvaluatorError } from './evaluator.js';
+export { applyDropHighest, applyDropLowest, applyKeepHighest, applyKeepLowest, sumKeptDice, } from './modifiers/keep-drop.js';
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/evaluator/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,gBAAgB,EAAE,QAAQ,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AACzE,OAAO,EACL,gBAAgB,EAChB,eAAe,EACf,gBAAgB,EAChB,eAAe,EACf,WAAW,GACZ,MAAM,uBAAuB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/evaluator/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,gBAAgB,EAAE,QAAQ,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAC5E,OAAO,EACL,gBAAgB,EAChB,eAAe,EACf,gBAAgB,EAChB,eAAe,EACf,WAAW,GACZ,MAAM,0BAA0B,CAAC"}

package/dist/evaluator/modifiers/compare.d.ts

@@ -7,7 +7,7 @@
  *
  * @module evaluator/modifiers/compare
  */
-import type { CompareOp } from '../../types';
+import type { CompareOp } from '../../types.js';
 /**
  * Compares a die result against a fixed comparison threshold.
  */

package/dist/evaluator/modifiers/compare.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"compare.d.ts","sourceRoot":"","sources":["../../../src/evaluator/modifiers/compare.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAE7C;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,SAAS,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAa5F"}
+{"version":3,"file":"compare.d.ts","sourceRoot":"","sources":["../../../src/evaluator/modifiers/compare.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAEhD;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,SAAS,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAa5F"}

package/dist/evaluator/modifiers/crit-threshold.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Critical / fumble threshold modifier.
+ *
+ * Overrides the default `critical`/`fumble` flag logic for a dice pool.
+ * `cs` and `cf` are independent (Roll20 semantics): the evaluator passes
+ * `['default']` for a side with no explicit thresholds, so overriding one
+ * side never wipes the other. An empty threshold array (not produced by the
+ * evaluator) would force the corresponding flag to `false` on every die.
+ * Meta dice (rolled to compute counts/sides/modifier args) are skipped so
+ * their bookkeeping stays untouched.
+ *
+ * Display-only: does not alter `total`, explosion triggers, success
+ * counting, or any other modifier flag. Dropped dice still participate —
+ * their `critical`/`fumble` metadata reflects what they rolled, not
+ * whether they contributed to the total.
+ *
+ * @module evaluator/modifiers/crit-threshold
+ */
+import type { DieResult, ResolvedCritThreshold } from '../../types.js';
+export type { ResolvedCritThreshold } from '../../types.js';
+/**
+ * Applies success/fail threshold arrays to a dice pool, overriding each
+ * die's `critical` and `fumble` flags in place. A die matches `'default'`
+ * on the success side when `result === sides && sides > 1`, and on the
+ * fail side when `result === 1`. Meta dice are skipped.
+ */
+export declare function applyCritThresholds(dice: DieResult[], successThresholds: ResolvedCritThreshold[], failThresholds: ResolvedCritThreshold[]): void;
+//# sourceMappingURL=crit-threshold.d.ts.map

package/dist/evaluator/modifiers/crit-threshold.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"crit-threshold.d.ts","sourceRoot":"","sources":["../../../src/evaluator/modifiers/crit-threshold.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,qBAAqB,EAAE,MAAM,gBAAgB,CAAC;AAKvE,YAAY,EAAE,qBAAqB,EAAE,MAAM,gBAAgB,CAAC;AAE5D;;;;;GAKG;AACH,wBAAgB,mBAAmB,CACjC,IAAI,EAAE,SAAS,EAAE,EACjB,iBAAiB,EAAE,qBAAqB,EAAE,EAC1C,cAAc,EAAE,qBAAqB,EAAE,GACtC,IAAI,CAON"}

package/dist/evaluator/modifiers/explode.d.ts

@@ -7,10 +7,10 @@
  *
  * @module evaluator/modifiers/explode
  */
-import type { RNG } from '../../rng/types';
-import type { CompareOp } from '../../types';
-import type { DieResult } from '../../types';
-import { type EvalEnv } from '../evaluator';
+import type { RNG } from '../../rng/types.js';
+import type { CompareOp } from '../../types.js';
+import type { DieResult } from '../../types.js';
+import { type EvalEnv } from '../evaluator.js';
 /** Default maximum explosion iterations per die. */
 export declare const DEFAULT_MAX_EXPLODE_ITERATIONS = 1000;
 /**
@@ -33,6 +33,10 @@ export declare function applyStandardExplode(pool: DieResult[], shouldExplode: S
  * Compound explode: pool length stays the same. Each original die's `result`
  * accumulates every explosion roll, and gains the `'exploded'` modifier once
  * it actually exploded at least once.
+ *
+ * Mutates exploded dice in place — the same `DieResult` objects are shared
+ * between `RollResult.rolls` and the `RollPart` tree, and both must reflect
+ * post-explosion state.
  */
 export declare function applyCompoundExplode(pool: DieResult[], shouldExplode: ShouldExplode, rng: RNG, env: EvalEnv): DieResult[];
 /**

package/dist/evaluator/modifiers/explode.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"explode.d.ts","sourceRoot":"","sources":["../../../src/evaluator/modifiers/explode.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,iBAAiB,CAAC;AAC3C,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAC7C,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAC7C,OAAO,EAAkB,KAAK,OAAO,EAAE,MAAM,cAAc,CAAC;AAE5D,oDAAoD;AACpD,eAAO,MAAM,8BAA8B,OAAQ,CAAC;AAEpD;;;;GAIG;AACH,MAAM,MAAM,aAAa,GAAG,CAAC,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,KAAK,OAAO,CAAC;AAE1E;;;GAGG;AACH,wBAAgB,kBAAkB,CAChC,QAAQ,EAAE,SAAS,GAAG,SAAS,EAC/B,cAAc,EAAE,MAAM,GAAG,SAAS,GACjC,aAAa,CAgBf;AAsCD;;;GAGG;AACH,wBAAgB,oBAAoB,CAClC,IAAI,EAAE,SAAS,EAAE,EACjB,aAAa,EAAE,aAAa,EAC5B,GAAG,EAAE,GAAG,EACR,GAAG,EAAE,OAAO,GACX,SAAS,EAAE,CA6Bb;AAED;;;;GAIG;AACH,wBAAgB,oBAAoB,CAClC,IAAI,EAAE,SAAS,EAAE,EACjB,aAAa,EAAE,aAAa,EAC5B,GAAG,EAAE,GAAG,EACR,GAAG,EAAE,OAAO,GACX,SAAS,EAAE,CAoCb;AAED;;;;GAIG;AACH,wBAAgB,uBAAuB,CACrC,IAAI,EAAE,SAAS,EAAE,EACjB,aAAa,EAAE,aAAa,EAC5B,GAAG,EAAE,GAAG,EACR,GAAG,EAAE,OAAO,GACX,SAAS,EAAE,CA8Bb"}
+{"version":3,"file":"explode.d.ts","sourceRoot":"","sources":["../../../src/evaluator/modifiers/explode.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,oBAAoB,CAAC;AAC9C,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAChD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAChD,OAAO,EAAkB,KAAK,OAAO,EAAE,MAAM,iBAAiB,CAAC;AAE/D,oDAAoD;AACpD,eAAO,MAAM,8BAA8B,OAAQ,CAAC;AAEpD;;;;GAIG;AACH,MAAM,MAAM,aAAa,GAAG,CAAC,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,KAAK,OAAO,CAAC;AAE1E;;;GAGG;AACH,wBAAgB,kBAAkB,CAChC,QAAQ,EAAE,SAAS,GAAG,SAAS,EAC/B,cAAc,EAAE,MAAM,GAAG,SAAS,GACjC,aAAa,CAgBf;AAyCD;;;GAGG;AACH,wBAAgB,oBAAoB,CAClC,IAAI,EAAE,SAAS,EAAE,EACjB,aAAa,EAAE,aAAa,EAC5B,GAAG,EAAE,GAAG,EACR,GAAG,EAAE,OAAO,GACX,SAAS,EAAE,CA6Bb;AAED;;;;;;;;GAQG;AACH,wBAAgB,oBAAoB,CAClC,IAAI,EAAE,SAAS,EAAE,EACjB,aAAa,EAAE,aAAa,EAC5B,GAAG,EAAE,GAAG,EACR,GAAG,EAAE,OAAO,GACX,SAAS,EAAE,CAiCb;AAED;;;;GAIG;AACH,wBAAgB,uBAAuB,CACrC,IAAI,EAAE,SAAS,EAAE,EACjB,aAAa,EAAE,aAAa,EAC5B,GAAG,EAAE,GAAG,EACR,GAAG,EAAE,OAAO,GACX,SAAS,EAAE,CA8Bb"}

package/dist/evaluator/modifiers/keep-drop.d.ts

@@ -3,7 +3,7 @@
  *
  * @module evaluator/modifiers/keep-drop
  */
-import type { DieResult } from '../../types';
+import type { DieResult } from '../../types.js';
 /**
  * Marks all eligible dice as `'kept'`. Dice that already carry `'dropped'`
  * (e.g., intermediate rerolls, or the loser of a prior modifier) are left

package/dist/evaluator/modifiers/keep-drop.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"keep-drop.d.ts","sourceRoot":"","sources":["../../../src/evaluator/modifiers/keep-drop.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAE7C;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,SAAS,EAAE,GAAG,SAAS,EAAE,CAQ1D;AAmDD;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,SAAS,EAAE,EAAE,KAAK,EAAE,MAAM,GAAG,SAAS,EAAE,CAU9E;AAED;;;GAGG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,SAAS,EAAE,EAAE,KAAK,EAAE,MAAM,GAAG,SAAS,EAAE,CAU7E;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,SAAS,EAAE,EAAE,KAAK,EAAE,MAAM,GAAG,SAAS,EAAE,CAU9E;AAED;;;GAGG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,SAAS,EAAE,EAAE,KAAK,EAAE,MAAM,GAAG,SAAS,EAAE,CAU7E;AAED;;;;;GAKG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,SAAS,EAAE,GAAG,MAAM,CAIrD"}
+{"version":3,"file":"keep-drop.d.ts","sourceRoot":"","sources":["../../../src/evaluator/modifiers/keep-drop.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAEhD;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,SAAS,EAAE,GAAG,SAAS,EAAE,CAQ1D;AAmDD;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,SAAS,EAAE,EAAE,KAAK,EAAE,MAAM,GAAG,SAAS,EAAE,CAU9E;AAED;;;GAGG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,SAAS,EAAE,EAAE,KAAK,EAAE,MAAM,GAAG,SAAS,EAAE,CAU7E;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,SAAS,EAAE,EAAE,KAAK,EAAE,MAAM,GAAG,SAAS,EAAE,CAU9E;AAED;;;GAGG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,SAAS,EAAE,EAAE,KAAK,EAAE,MAAM,GAAG,SAAS,EAAE,CAU7E;AAED;;;;;GAKG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,SAAS,EAAE,GAAG,MAAM,CAIrD"}

package/dist/evaluator/modifiers/reroll.d.ts

@@ -8,10 +8,10 @@
  *
  * @module evaluator/modifiers/reroll
  */
-import type { RNG } from '../../rng/types';
-import type { CompareOp, DieResult } from '../../types';
-import { type EvalEnv } from '../evaluator';
-import { matchesCondition } from './compare';
+import type { RNG } from '../../rng/types.js';
+import type { CompareOp, DieResult } from '../../types.js';
+import { type EvalEnv } from '../evaluator.js';
+import { matchesCondition } from './compare.js';
 /** Default maximum reroll iterations per die. */
 export declare const DEFAULT_MAX_REROLL_ITERATIONS = 1000;
 export { matchesCondition };

package/dist/evaluator/modifiers/reroll.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"reroll.d.ts","sourceRoot":"","sources":["../../../src/evaluator/modifiers/reroll.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,iBAAiB,CAAC;AAC3C,OAAO,KAAK,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AACxD,OAAO,EAAkB,KAAK,OAAO,EAAE,MAAM,cAAc,CAAC;AAC5D,OAAO,EAAE,gBAAgB,EAAE,MAAM,WAAW,CAAC;AAE7C,iDAAiD;AACjD,eAAO,MAAM,6BAA6B,OAAQ,CAAC;AAEnD,OAAO,EAAE,gBAAgB,EAAE,CAAC;AA8D5B;;;;;;;GAOG;AACH,wBAAgB,oBAAoB,CAClC,IAAI,EAAE,SAAS,EAAE,EACjB,QAAQ,EAAE,SAAS,EACnB,KAAK,EAAE,MAAM,EACb,GAAG,EAAE,GAAG,EACR,GAAG,EAAE,OAAO,GACX,SAAS,EAAE,CAiCb;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAC7B,IAAI,EAAE,SAAS,EAAE,EACjB,QAAQ,EAAE,SAAS,EACnB,KAAK,EAAE,MAAM,EACb,GAAG,EAAE,GAAG,EACR,GAAG,EAAE,OAAO,GACX,SAAS,EAAE,CA8Bb"}
+{"version":3,"file":"reroll.d.ts","sourceRoot":"","sources":["../../../src/evaluator/modifiers/reroll.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,oBAAoB,CAAC;AAC9C,OAAO,KAAK,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAC3D,OAAO,EAAkB,KAAK,OAAO,EAAE,MAAM,iBAAiB,CAAC;AAC/D,OAAO,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AAEhD,iDAAiD;AACjD,eAAO,MAAM,6BAA6B,OAAQ,CAAC;AAEnD,OAAO,EAAE,gBAAgB,EAAE,CAAC;AA8D5B;;;;;;;GAOG;AACH,wBAAgB,oBAAoB,CAClC,IAAI,EAAE,SAAS,EAAE,EACjB,QAAQ,EAAE,SAAS,EACnB,KAAK,EAAE,MAAM,EACb,GAAG,EAAE,GAAG,EACR,GAAG,EAAE,OAAO,GACX,SAAS,EAAE,CA+Bb;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAC7B,IAAI,EAAE,SAAS,EAAE,EACjB,QAAQ,EAAE,SAAS,EACnB,KAAK,EAAE,MAAM,EACb,GAAG,EAAE,GAAG,EACR,GAAG,EAAE,OAAO,GACX,SAAS,EAAE,CAyBb"}

package/dist/evaluator/modifiers/sort.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Sort modifier implementation.
+ *
+ * Sort is purely cosmetic — it reorders the dice produced by its target in
+ * ascending or descending order of `result` without touching any flag
+ * (`kept`, `dropped`, `critical`, `fumble`, `rerolled`, `meta`) or the total.
+ * Dropped dice stay in the pool and sort alongside kept dice so readers can
+ * see where the dropped value landed in the ordered sequence.
+ *
+ * @module evaluator/modifiers/sort
+ */
+import type { DieResult } from '../../types.js';
+/**
+ * Returns a sorted copy of `dice` in the given order, preserving every die's
+ * original flags and metadata. Comparison is on `.result` — the raw face
+ * value is what the user sees in rendered output, so ordering by raw value
+ * matches the visual intent regardless of any `kept`/`dropped` flagging.
+ *
+ * Relies on `Array.prototype.sort` being stable — equal-valued dice retain
+ * their original insertion order.
+ */
+export declare function sortDice(dice: DieResult[], order: 'ascending' | 'descending'): DieResult[];
+//# sourceMappingURL=sort.d.ts.map

package/dist/evaluator/modifiers/sort.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sort.d.ts","sourceRoot":"","sources":["../../../src/evaluator/modifiers/sort.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAEhD;;;;;;;;GAQG;AACH,wBAAgB,QAAQ,CAAC,IAAI,EAAE,SAAS,EAAE,EAAE,KAAK,EAAE,WAAW,GAAG,YAAY,GAAG,SAAS,EAAE,CAM1F"}

package/dist/evaluator/modifiers/success-count.d.ts

@@ -14,7 +14,7 @@
  *
  * @module evaluator/modifiers/success-count
  */
-import type { CompareOp, DieResult } from '../../types';
+import type { CompareOp, DieResult } from '../../types.js';
 export type ResolvedThreshold = {
     operator: CompareOp;
     value: number;

package/dist/evaluator/modifiers/success-count.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"success-count.d.ts","sourceRoot":"","sources":["../../../src/evaluator/modifiers/success-count.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAGxD,MAAM,MAAM,iBAAiB,GAAG;IAC9B,QAAQ,EAAE,SAAS,CAAC;IACpB,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAEF,MAAM,MAAM,kBAAkB,GAAG;IAC/B,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,MAAM,CAAC;CAClB,CAAC;AAEF,wBAAgB,cAAc,CAC5B,IAAI,EAAE,SAAS,EAAE,EACjB,SAAS,EAAE,iBAAiB,EAC5B,aAAa,CAAC,EAAE,iBAAiB,GAChC,kBAAkB,CAuBpB"}
+{"version":3,"file":"success-count.d.ts","sourceRoot":"","sources":["../../../src/evaluator/modifiers/success-count.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAG3D,MAAM,MAAM,iBAAiB,GAAG;IAC9B,QAAQ,EAAE,SAAS,CAAC;IACpB,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAEF,MAAM,MAAM,kBAAkB,GAAG;IAC/B,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,MAAM,CAAC;CAClB,CAAC;AAEF,wBAAgB,cAAc,CAC5B,IAAI,EAAE,SAAS,EAAE,EACjB,SAAS,EAAE,iBAAiB,EAC5B,aAAa,CAAC,EAAE,iBAAiB,GAChC,kBAAkB,CAuBpB"}

package/dist/index.d.ts

@@ -3,18 +3,18 @@
  *
  * @module roll-parser
  */
-export { RollParserError, isRollParserError } from './errors';
-export type { RollParserErrorCode } from './errors';
-export { LexerError } from './lexer/lexer';
-export { parse, ParseError } from './parser/parser';
-export type { ASTNode, BinaryOpNode, DiceNode, ExplodeNode, FateDiceNode, FunctionCallNode, LiteralNode, ModifierNode, RerollNode, SuccessCountNode, UnaryOpNode, VersusNode, } from './parser/ast';
-export { isBinaryOp, isDice, isExplode, isFateDice, isFunctionCall, isLiteral, isModifier, isReroll, isSuccessCount, isUnaryOp, isVersus, } from './parser/ast';
-export type { RNG } from './rng/types';
-export { SeededRNG } from './rng/seeded';
-export { DEFAULT_MAX_DICE, DEFAULT_MAX_EXPLODE_ITERATIONS, DEFAULT_MAX_REROLL_ITERATIONS, evaluate, EvaluatorError, } from './evaluator/evaluator';
-export type { CompareOp, ComparePoint, DieModifier, DieResult, EvaluateOptions, RollResult, } from './types';
-export { DegreeOfSuccess } from './types';
-export { roll } from './roll';
-export type { RollOptions } from './roll';
+export { RollParserError, isRollParserError } from './errors.js';
+export type { RollParserErrorCode } from './errors.js';
+export { LexerError } from './lexer/lexer.js';
+export { parse, ParseError } from './parser/parser.js';
+export type { ASTNode, BinaryOpNode, DiceNode, NodeSpan, ExplodeNode, FateDiceNode, FunctionCallNode, GroupedNode, LiteralNode, ModifierNode, RerollNode, SuccessCountNode, SortNode, CritThresholdNode, GroupNode, UnaryOpNode, VariableNode, VersusNode, } from './parser/ast.js';
+export { isBinaryOp, isCritThreshold, isDice, isExplode, isFateDice, isFunctionCall, isGroup, isGrouped, isLiteral, isModifier, isReroll, isSort, isSuccessCount, isUnaryOp, isVariable, isVersus, } from './parser/ast.js';
+export type { RNG } from './rng/types.js';
+export { SeededRNG } from './rng/seeded.js';
+export { DEFAULT_MAX_DICE, DEFAULT_MAX_EXPLODE_ITERATIONS, DEFAULT_MAX_REROLL_ITERATIONS, evaluate, EvaluatorError, } from './evaluator/evaluator.js';
+export type { CompareOp, ComparePoint, DieModifier, DieResult, EvaluateOptions, ModifierSpec, ResolvedComparePoint, ResolvedCritThreshold, RollPart, RollPartType, RollResult, } from './types.js';
+export { DegreeOfSuccess } from './types.js';
+export { roll } from './roll.js';
+export type { RollOptions } from './roll.js';
 export declare const VERSION: string;
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,EAAE,eAAe,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAC9D,YAAY,EAAE,mBAAmB,EAAE,MAAM,UAAU,CAAC;AAGpD,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAG3C,OAAO,EAAE,KAAK,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AACpD,YAAY,EACV,OAAO,EACP,YAAY,EACZ,QAAQ,EACR,WAAW,EACX,YAAY,EACZ,gBAAgB,EAChB,WAAW,EACX,YAAY,EACZ,UAAU,EACV,gBAAgB,EAChB,WAAW,EACX,UAAU,GACX,MAAM,cAAc,CAAC;AACtB,OAAO,EACL,UAAU,EACV,MAAM,EACN,SAAS,EACT,UAAU,EACV,cAAc,EACd,SAAS,EACT,UAAU,EACV,QAAQ,EACR,cAAc,EACd,SAAS,EACT,QAAQ,GACT,MAAM,cAAc,CAAC;AAGtB,YAAY,EAAE,GAAG,EAAE,MAAM,aAAa,CAAC;AACvC,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAGzC,OAAO,EACL,gBAAgB,EAChB,8BAA8B,EAC9B,6BAA6B,EAC7B,QAAQ,EACR,cAAc,GACf,MAAM,uBAAuB,CAAC;AAC/B,YAAY,EACV,SAAS,EACT,YAAY,EACZ,WAAW,EACX,SAAS,EACT,eAAe,EACf,UAAU,GACX,MAAM,SAAS,CAAC;AACjB,OAAO,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAG1C,OAAO,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAC9B,YAAY,EAAE,WAAW,EAAE,MAAM,QAAQ,CAAC;AAI1C,eAAO,MAAM,OAAO,EAAE,MAAoB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,EAAE,eAAe,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AACjE,YAAY,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAC;AAGvD,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAG9C,OAAO,EAAE,KAAK,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AACvD,YAAY,EACV,OAAO,EACP,YAAY,EACZ,QAAQ,EACR,QAAQ,EACR,WAAW,EACX,YAAY,EACZ,gBAAgB,EAChB,WAAW,EACX,WAAW,EACX,YAAY,EACZ,UAAU,EACV,gBAAgB,EAChB,QAAQ,EACR,iBAAiB,EACjB,SAAS,EACT,WAAW,EACX,YAAY,EACZ,UAAU,GACX,MAAM,iBAAiB,CAAC;AACzB,OAAO,EACL,UAAU,EACV,eAAe,EACf,MAAM,EACN,SAAS,EACT,UAAU,EACV,cAAc,EACd,OAAO,EACP,SAAS,EACT,SAAS,EACT,UAAU,EACV,QAAQ,EACR,MAAM,EACN,cAAc,EACd,SAAS,EACT,UAAU,EACV,QAAQ,GACT,MAAM,iBAAiB,CAAC;AAGzB,YAAY,EAAE,GAAG,EAAE,MAAM,gBAAgB,CAAC;AAC1C,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAG5C,OAAO,EACL,gBAAgB,EAChB,8BAA8B,EAC9B,6BAA6B,EAC7B,QAAQ,EACR,cAAc,GACf,MAAM,0BAA0B,CAAC;AAClC,YAAY,EACV,SAAS,EACT,YAAY,EACZ,WAAW,EACX,SAAS,EACT,eAAe,EACf,YAAY,EACZ,oBAAoB,EACpB,qBAAqB,EACrB,QAAQ,EACR,YAAY,EACZ,UAAU,GACX,MAAM,YAAY,CAAC;AACpB,OAAO,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAG7C,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AACjC,YAAY,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC;AAM7C,eAAO,MAAM,OAAO,EAAE,MAAgB,CAAC"}