@erpg/dicecore 3.1.0

package/dist/v3/runtime/xoshiro128ss.d.ts

@@ -0,0 +1,14 @@
+import type { RandomCallBudget } from './budget.js';
+import type { RandomSource } from './mt19937.js';
+/** The public-domain xoshiro128** 1.1 generator by Blackman and Vigna. */
+export declare class Xoshiro128StarStar implements RandomSource {
+    private state0;
+    private state1;
+    private state2;
+    private state3;
+    private readonly budget;
+    constructor(seed: ArrayLike<number>, budget?: RandomCallBudget | null);
+    nextUint32(): number;
+    integer(min: number, max: number): number;
+    real(): number;
+}

package/dist/v3/syntax/ast.d.cts

@@ -0,0 +1,132 @@
+import type { SourceSpan } from '../errors.cjs';
+export type { SourceSpan } from '../errors.cjs';
+export type NodeId = string;
+export type BinaryOperator = '+' | '-' | '*' | '/' | '%' | '^' | '**';
+export type UnaryOperator = '+' | '-';
+export type ComparisonOperator = '=' | '!=' | '<>' | '<' | '>' | '<=' | '>=';
+export type UnaryFunctionName = 'abs' | 'ceil' | 'cos' | 'exp' | 'floor' | 'log' | 'round' | 'sign' | 'sin' | 'sqrt' | 'tan';
+export type BinaryFunctionName = 'pow' | 'max' | 'min';
+export interface SyntaxNodeBase {
+    readonly id: NodeId;
+    readonly span: SourceSpan;
+}
+export interface NumberNode extends SyntaxNodeBase {
+    readonly kind: 'number';
+    readonly value: number;
+    readonly raw: string;
+    readonly implicit: boolean;
+}
+export interface UnaryNode extends SyntaxNodeBase {
+    readonly kind: 'unary';
+    readonly operator: UnaryOperator;
+    readonly operand: ExpressionNode;
+}
+export interface BinaryNode extends SyntaxNodeBase {
+    readonly kind: 'binary';
+    readonly operator: BinaryOperator;
+    readonly left: ExpressionNode;
+    readonly right: ExpressionNode;
+}
+export interface ParenthesizedNode extends SyntaxNodeBase {
+    readonly kind: 'parenthesized';
+    readonly expression: ExpressionNode;
+}
+export interface UnaryFunctionNode extends SyntaxNodeBase {
+    readonly kind: 'function';
+    readonly functionKind: 'unary';
+    readonly name: UnaryFunctionName;
+    readonly arguments: readonly [ExpressionNode];
+}
+export interface BinaryFunctionNode extends SyntaxNodeBase {
+    readonly kind: 'function';
+    readonly functionKind: 'binary';
+    readonly name: BinaryFunctionName;
+    readonly arguments: readonly [ExpressionNode, ExpressionNode];
+}
+export type FunctionNode = UnaryFunctionNode | BinaryFunctionNode;
+export type DiceArgumentNode = NumberNode | ParenthesizedNode;
+export interface StandardDiceNode extends SyntaxNodeBase {
+    readonly kind: 'dice';
+    readonly diceKind: 'standard';
+    readonly quantity: DiceArgumentNode;
+    readonly sides: DiceArgumentNode;
+    readonly modifiers: readonly ModifierNode[];
+}
+export interface PercentileDiceNode extends SyntaxNodeBase {
+    readonly kind: 'dice';
+    readonly diceKind: 'percentile';
+    readonly quantity: DiceArgumentNode;
+    readonly modifiers: readonly ModifierNode[];
+}
+export interface FudgeDiceNode extends SyntaxNodeBase {
+    readonly kind: 'dice';
+    readonly diceKind: 'fudge';
+    readonly quantity: DiceArgumentNode;
+    readonly variant: 1 | 2;
+    readonly modifiers: readonly ModifierNode[];
+}
+export type DiceNode = StandardDiceNode | PercentileDiceNode | FudgeDiceNode;
+export interface GroupNode extends SyntaxNodeBase {
+    readonly kind: 'group';
+    readonly expressions: readonly ExpressionNode[];
+    readonly modifiers: readonly ModifierNode[];
+}
+export type ExpressionNode = NumberNode | UnaryNode | BinaryNode | ParenthesizedNode | FunctionNode | DiceNode | GroupNode;
+export interface ComparePointNode extends SyntaxNodeBase {
+    readonly kind: 'compare-point';
+    readonly operator: ComparisonOperator;
+    readonly value: number;
+}
+export interface ExplodeModifierNode extends SyntaxNodeBase {
+    readonly kind: 'explode';
+    readonly compound: boolean;
+    readonly penetrate: boolean;
+    readonly compare: ComparePointNode | null;
+}
+export interface TargetModifierNode extends SyntaxNodeBase {
+    readonly kind: 'target';
+    readonly success: ComparePointNode;
+    readonly failure: ComparePointNode | null;
+}
+export interface DropModifierNode extends SyntaxNodeBase {
+    readonly kind: 'drop';
+    readonly selection: 'lowest' | 'highest';
+    readonly quantity: number;
+}
+export interface KeepModifierNode extends SyntaxNodeBase {
+    readonly kind: 'keep';
+    readonly selection: 'lowest' | 'highest';
+    readonly quantity: number;
+}
+export interface MinimumModifierNode extends SyntaxNodeBase {
+    readonly kind: 'min';
+    readonly value: number;
+}
+export interface MaximumModifierNode extends SyntaxNodeBase {
+    readonly kind: 'max';
+    readonly value: number;
+}
+export interface RerollModifierNode extends SyntaxNodeBase {
+    readonly kind: 'reroll';
+    readonly once: boolean;
+    readonly compare: ComparePointNode | null;
+}
+export interface UniqueModifierNode extends SyntaxNodeBase {
+    readonly kind: 'unique';
+    readonly once: boolean;
+    readonly compare: ComparePointNode | null;
+}
+export interface CriticalSuccessModifierNode extends SyntaxNodeBase {
+    readonly kind: 'critical-success';
+    readonly compare: ComparePointNode | null;
+}
+export interface CriticalFailureModifierNode extends SyntaxNodeBase {
+    readonly kind: 'critical-failure';
+    readonly compare: ComparePointNode | null;
+}
+export interface SortModifierNode extends SyntaxNodeBase {
+    readonly kind: 'sort';
+    readonly direction: 'ascending' | 'descending';
+}
+export type ModifierNode = ExplodeModifierNode | TargetModifierNode | DropModifierNode | KeepModifierNode | MinimumModifierNode | MaximumModifierNode | RerollModifierNode | UniqueModifierNode | CriticalSuccessModifierNode | CriticalFailureModifierNode | SortModifierNode;
+export declare function createNodeId(kind: string, span: SourceSpan): NodeId;

package/dist/v3/syntax/ast.d.ts

@@ -0,0 +1,132 @@
+import type { SourceSpan } from '../errors.js';
+export type { SourceSpan } from '../errors.js';
+export type NodeId = string;
+export type BinaryOperator = '+' | '-' | '*' | '/' | '%' | '^' | '**';
+export type UnaryOperator = '+' | '-';
+export type ComparisonOperator = '=' | '!=' | '<>' | '<' | '>' | '<=' | '>=';
+export type UnaryFunctionName = 'abs' | 'ceil' | 'cos' | 'exp' | 'floor' | 'log' | 'round' | 'sign' | 'sin' | 'sqrt' | 'tan';
+export type BinaryFunctionName = 'pow' | 'max' | 'min';
+export interface SyntaxNodeBase {
+    readonly id: NodeId;
+    readonly span: SourceSpan;
+}
+export interface NumberNode extends SyntaxNodeBase {
+    readonly kind: 'number';
+    readonly value: number;
+    readonly raw: string;
+    readonly implicit: boolean;
+}
+export interface UnaryNode extends SyntaxNodeBase {
+    readonly kind: 'unary';
+    readonly operator: UnaryOperator;
+    readonly operand: ExpressionNode;
+}
+export interface BinaryNode extends SyntaxNodeBase {
+    readonly kind: 'binary';
+    readonly operator: BinaryOperator;
+    readonly left: ExpressionNode;
+    readonly right: ExpressionNode;
+}
+export interface ParenthesizedNode extends SyntaxNodeBase {
+    readonly kind: 'parenthesized';
+    readonly expression: ExpressionNode;
+}
+export interface UnaryFunctionNode extends SyntaxNodeBase {
+    readonly kind: 'function';
+    readonly functionKind: 'unary';
+    readonly name: UnaryFunctionName;
+    readonly arguments: readonly [ExpressionNode];
+}
+export interface BinaryFunctionNode extends SyntaxNodeBase {
+    readonly kind: 'function';
+    readonly functionKind: 'binary';
+    readonly name: BinaryFunctionName;
+    readonly arguments: readonly [ExpressionNode, ExpressionNode];
+}
+export type FunctionNode = UnaryFunctionNode | BinaryFunctionNode;
+export type DiceArgumentNode = NumberNode | ParenthesizedNode;
+export interface StandardDiceNode extends SyntaxNodeBase {
+    readonly kind: 'dice';
+    readonly diceKind: 'standard';
+    readonly quantity: DiceArgumentNode;
+    readonly sides: DiceArgumentNode;
+    readonly modifiers: readonly ModifierNode[];
+}
+export interface PercentileDiceNode extends SyntaxNodeBase {
+    readonly kind: 'dice';
+    readonly diceKind: 'percentile';
+    readonly quantity: DiceArgumentNode;
+    readonly modifiers: readonly ModifierNode[];
+}
+export interface FudgeDiceNode extends SyntaxNodeBase {
+    readonly kind: 'dice';
+    readonly diceKind: 'fudge';
+    readonly quantity: DiceArgumentNode;
+    readonly variant: 1 | 2;
+    readonly modifiers: readonly ModifierNode[];
+}
+export type DiceNode = StandardDiceNode | PercentileDiceNode | FudgeDiceNode;
+export interface GroupNode extends SyntaxNodeBase {
+    readonly kind: 'group';
+    readonly expressions: readonly ExpressionNode[];
+    readonly modifiers: readonly ModifierNode[];
+}
+export type ExpressionNode = NumberNode | UnaryNode | BinaryNode | ParenthesizedNode | FunctionNode | DiceNode | GroupNode;
+export interface ComparePointNode extends SyntaxNodeBase {
+    readonly kind: 'compare-point';
+    readonly operator: ComparisonOperator;
+    readonly value: number;
+}
+export interface ExplodeModifierNode extends SyntaxNodeBase {
+    readonly kind: 'explode';
+    readonly compound: boolean;
+    readonly penetrate: boolean;
+    readonly compare: ComparePointNode | null;
+}
+export interface TargetModifierNode extends SyntaxNodeBase {
+    readonly kind: 'target';
+    readonly success: ComparePointNode;
+    readonly failure: ComparePointNode | null;
+}
+export interface DropModifierNode extends SyntaxNodeBase {
+    readonly kind: 'drop';
+    readonly selection: 'lowest' | 'highest';
+    readonly quantity: number;
+}
+export interface KeepModifierNode extends SyntaxNodeBase {
+    readonly kind: 'keep';
+    readonly selection: 'lowest' | 'highest';
+    readonly quantity: number;
+}
+export interface MinimumModifierNode extends SyntaxNodeBase {
+    readonly kind: 'min';
+    readonly value: number;
+}
+export interface MaximumModifierNode extends SyntaxNodeBase {
+    readonly kind: 'max';
+    readonly value: number;
+}
+export interface RerollModifierNode extends SyntaxNodeBase {
+    readonly kind: 'reroll';
+    readonly once: boolean;
+    readonly compare: ComparePointNode | null;
+}
+export interface UniqueModifierNode extends SyntaxNodeBase {
+    readonly kind: 'unique';
+    readonly once: boolean;
+    readonly compare: ComparePointNode | null;
+}
+export interface CriticalSuccessModifierNode extends SyntaxNodeBase {
+    readonly kind: 'critical-success';
+    readonly compare: ComparePointNode | null;
+}
+export interface CriticalFailureModifierNode extends SyntaxNodeBase {
+    readonly kind: 'critical-failure';
+    readonly compare: ComparePointNode | null;
+}
+export interface SortModifierNode extends SyntaxNodeBase {
+    readonly kind: 'sort';
+    readonly direction: 'ascending' | 'descending';
+}
+export type ModifierNode = ExplodeModifierNode | TargetModifierNode | DropModifierNode | KeepModifierNode | MinimumModifierNode | MaximumModifierNode | RerollModifierNode | UniqueModifierNode | CriticalSuccessModifierNode | CriticalFailureModifierNode | SortModifierNode;
+export declare function createNodeId(kind: string, span: SourceSpan): NodeId;

package/dist/v3/syntax/index.d.cts

@@ -0,0 +1,4 @@
+export * from './ast.cjs';
+export * from './parser.cjs';
+export * from './scanner.cjs';
+export type * from './tokens.cjs';

package/dist/v3/syntax/index.d.ts

@@ -0,0 +1,4 @@
+export * from './ast.js';
+export * from './parser.js';
+export * from './scanner.js';
+export type * from './tokens.js';

package/dist/v3/syntax/parser.d.cts

@@ -0,0 +1,7 @@
+import { type ExpressionNode } from './ast.cjs';
+export interface DiceParserLimits {
+    readonly maxDepth: number;
+    readonly maxNodes: number;
+}
+/** Parses one compact, comment-free roll formula (without an `N#` prefix). */
+export declare function parseDiceNotation(input: string, limits?: DiceParserLimits): ExpressionNode;

package/dist/v3/syntax/parser.d.ts

@@ -0,0 +1,7 @@
+import { type ExpressionNode } from './ast.js';
+export interface DiceParserLimits {
+    readonly maxDepth: number;
+    readonly maxNodes: number;
+}
+/** Parses one compact, comment-free roll formula (without an `N#` prefix). */
+export declare function parseDiceNotation(input: string, limits?: DiceParserLimits): ExpressionNode;

package/dist/v3/syntax/scanner.d.cts

@@ -0,0 +1,3 @@
+import type { SyntaxToken } from './tokens.cjs';
+/** Tokenizes compact V3 notation while retaining exact source offsets. */
+export declare function tokenizeDiceNotation(input: string): readonly SyntaxToken[];

package/dist/v3/syntax/scanner.d.ts

@@ -0,0 +1,3 @@
+import type { SyntaxToken } from './tokens.js';
+/** Tokenizes compact V3 notation while retaining exact source offsets. */
+export declare function tokenizeDiceNotation(input: string): readonly SyntaxToken[];

package/dist/v3/syntax/tokens.d.cts

@@ -0,0 +1,38 @@
+import type { BinaryOperator, ComparisonOperator } from './ast.cjs';
+import type { SourceSpan } from '../errors.cjs';
+export interface NumberToken {
+    readonly kind: 'number';
+    readonly lexeme: string;
+    readonly value: number;
+    readonly span: SourceSpan;
+}
+export interface IdentifierToken {
+    readonly kind: 'identifier';
+    readonly lexeme: string;
+    readonly value: string;
+    readonly span: SourceSpan;
+}
+export interface OperatorToken {
+    readonly kind: 'operator';
+    readonly lexeme: string;
+    readonly value: BinaryOperator;
+    readonly span: SourceSpan;
+}
+export interface ComparisonToken {
+    readonly kind: 'comparison';
+    readonly lexeme: string;
+    readonly value: Exclude<ComparisonOperator, '!='>;
+    readonly span: SourceSpan;
+}
+export type PunctuationKind = 'left-parenthesis' | 'right-parenthesis' | 'left-brace' | 'right-brace' | 'comma' | 'dot' | 'bang';
+export interface PunctuationToken {
+    readonly kind: PunctuationKind;
+    readonly lexeme: string;
+    readonly span: SourceSpan;
+}
+export interface EofToken {
+    readonly kind: 'eof';
+    readonly lexeme: '';
+    readonly span: SourceSpan;
+}
+export type SyntaxToken = NumberToken | IdentifierToken | OperatorToken | ComparisonToken | PunctuationToken | EofToken;

package/dist/v3/syntax/tokens.d.ts

@@ -0,0 +1,38 @@
+import type { BinaryOperator, ComparisonOperator } from './ast.js';
+import type { SourceSpan } from '../errors.js';
+export interface NumberToken {
+    readonly kind: 'number';
+    readonly lexeme: string;
+    readonly value: number;
+    readonly span: SourceSpan;
+}
+export interface IdentifierToken {
+    readonly kind: 'identifier';
+    readonly lexeme: string;
+    readonly value: string;
+    readonly span: SourceSpan;
+}
+export interface OperatorToken {
+    readonly kind: 'operator';
+    readonly lexeme: string;
+    readonly value: BinaryOperator;
+    readonly span: SourceSpan;
+}
+export interface ComparisonToken {
+    readonly kind: 'comparison';
+    readonly lexeme: string;
+    readonly value: Exclude<ComparisonOperator, '!='>;
+    readonly span: SourceSpan;
+}
+export type PunctuationKind = 'left-parenthesis' | 'right-parenthesis' | 'left-brace' | 'right-brace' | 'comma' | 'dot' | 'bang';
+export interface PunctuationToken {
+    readonly kind: PunctuationKind;
+    readonly lexeme: string;
+    readonly span: SourceSpan;
+}
+export interface EofToken {
+    readonly kind: 'eof';
+    readonly lexeme: '';
+    readonly span: SourceSpan;
+}
+export type SyntaxToken = NumberToken | IdentifierToken | OperatorToken | ComparisonToken | PunctuationToken | EofToken;

package/dist/v3/types.d.cts

@@ -0,0 +1,251 @@
+import type { DiceRollError, SourceSpan } from './errors.cjs';
+import type { DiceLimits } from './runtime/limits.cjs';
+import type { RandomAlgorithm, ReplayDescriptor, SeedInput } from './runtime/replay.cjs';
+export type DiceSides = number | 'F';
+export type DiceState = 'compound' | 'critical-failure' | 'critical-success' | 'dropped' | 'exploded' | 'maximum' | 'minimum' | 'penetrated' | 'rerolled' | 'target-failure' | 'target-neutral' | 'target-success' | 'unique-rerolled';
+export type GroupState = 'dropped' | 'sorted-ascending' | 'sorted-descending';
+export interface DiceInspectionCost {
+    readonly staticDice: number;
+    readonly worstCaseGeneratedDice: number;
+    readonly worstCaseRandomCalls: number;
+    readonly totalStaticDice: number;
+    readonly totalWorstCaseGeneratedDice: number;
+    readonly totalWorstCaseRandomCalls: number;
+}
+export interface RollPlanGroup {
+    readonly id: string;
+    readonly sourceNodeId: string;
+    readonly kind: 'dice' | 'expression' | 'function' | 'group';
+    readonly notation: string;
+    readonly span: SourceSpan;
+    readonly childIds: readonly string[];
+}
+export interface RollPlan {
+    readonly type: 'roll-plan';
+    readonly schemaVersion: 3;
+    readonly compilerVersion: 1;
+    readonly planFingerprint: string;
+    readonly input: string;
+    readonly comment: string;
+    readonly notation: string;
+    readonly normalizedNotation: string;
+    readonly isMultiRoll: boolean;
+    readonly rollCount: number;
+    readonly groups: readonly RollPlanGroup[];
+    readonly cost: DiceInspectionCost;
+}
+export interface EntityRange {
+    readonly start: number;
+    readonly count: number;
+}
+export interface ResolvedDie {
+    readonly id: string;
+    readonly sourceNodeId: string;
+    readonly parentDieId: string | null;
+    readonly rollIndex: number;
+    readonly rollDieIndex: number;
+    readonly groupId: string;
+    readonly sides: DiceSides;
+    readonly rawValue: number;
+    readonly value: number;
+    readonly contribution: number;
+    readonly included: boolean;
+    readonly states: readonly DiceState[];
+}
+export interface ResolvedGroup {
+    readonly id: string;
+    readonly sourceNodeId: string;
+    readonly rollIndex: number;
+    readonly kind: 'dice' | 'expression' | 'function' | 'group';
+    readonly notation: string;
+    readonly span: SourceSpan;
+    readonly value: number;
+    readonly contribution: number;
+    readonly included: boolean;
+    readonly states: readonly GroupState[];
+    readonly childIds: readonly string[];
+}
+export interface PoolSummary {
+    readonly successes: number;
+    readonly failures: number;
+    readonly netSuccesses: number;
+}
+interface EventBase {
+    readonly sequence: number;
+    readonly rollIndex: number;
+    readonly sourceNodeId: string;
+}
+interface DieEventBase extends EventBase {
+    readonly subject: 'die';
+    readonly dieId: string;
+    readonly parentDieId: string | null;
+}
+interface GroupEventBase extends EventBase {
+    readonly subject: 'group';
+    readonly groupId: string;
+}
+export interface RollDiceEvent extends DieEventBase {
+    readonly type: 'roll';
+    readonly value: number;
+}
+export interface RerollDiceEvent extends DieEventBase {
+    readonly type: 'reroll';
+    readonly from: number;
+    readonly to: number;
+    readonly reason: 'reroll' | 'reroll-once' | 'unique' | 'unique-once';
+}
+export interface ExplodeDiceEvent extends DieEventBase {
+    readonly type: 'explode';
+    readonly childDieId: string;
+    readonly value: number;
+    readonly reason: 'explode' | 'compound' | 'penetrate';
+}
+export interface TransformDiceEvent extends DieEventBase {
+    readonly type: 'transform';
+    readonly from: number;
+    readonly to: number;
+    readonly reason: 'minimum' | 'maximum' | 'penetrate' | 'compound';
+}
+export interface TransformGroupEvent extends GroupEventBase {
+    readonly type: 'transform';
+    readonly from: readonly string[];
+    readonly to: readonly string[];
+    readonly reason: 'sort-ascending' | 'sort-descending';
+}
+export interface IncludeDiceEvent extends DieEventBase {
+    readonly type: 'include';
+    readonly contribution: number;
+}
+export interface IncludeGroupEvent extends GroupEventBase {
+    readonly type: 'include';
+    readonly value: number;
+    readonly contribution: number;
+}
+export interface ExcludeDiceEvent extends DieEventBase {
+    readonly type: 'exclude';
+    readonly reason: 'drop' | 'keep' | 'compound-absorbed';
+}
+export interface ExcludeGroupEvent extends GroupEventBase {
+    readonly type: 'exclude';
+    readonly value: number;
+    readonly reason: 'drop' | 'keep';
+}
+export interface ClassifyDiceEvent extends DieEventBase {
+    readonly type: 'classify';
+    readonly outcome: 'success' | 'failure' | 'neutral' | 'critical-success' | 'critical-failure';
+}
+export type DiceEvent = RollDiceEvent | RerollDiceEvent | ExplodeDiceEvent | TransformDiceEvent | TransformGroupEvent | IncludeDiceEvent | IncludeGroupEvent | ExcludeDiceEvent | ExcludeGroupEvent | ClassifyDiceEvent;
+export interface ExecutionStats {
+    readonly rolls: number;
+    readonly initialDice: number;
+    readonly generatedDice: number;
+    readonly randomCalls: number;
+    readonly modifierSteps: number;
+    readonly events: number;
+    readonly resolvedGroups: number;
+    readonly resultItems: number;
+}
+export interface ResolvedRoll {
+    readonly index: number;
+    readonly total: number;
+    readonly pool: PoolSummary | null;
+    readonly diceRange: EntityRange;
+    readonly groupRange: EntityRange;
+    readonly eventRange: EntityRange;
+}
+interface RollResultBase {
+    readonly schemaVersion: 3;
+    readonly input: string;
+    readonly notation: string;
+    readonly normalizedNotation: string;
+    readonly comment: string;
+    readonly total: number;
+    readonly replay: ReplayDescriptor;
+    readonly stats: ExecutionStats;
+    readonly pool: PoolSummary | null;
+}
+export interface DiceRollResult extends RollResultBase {
+    readonly type: 'dice-roll';
+    readonly output: string;
+    readonly rolls: readonly ResolvedRoll[];
+    readonly groups: readonly ResolvedGroup[];
+    readonly dice: readonly ResolvedDie[];
+    readonly events: readonly DiceEvent[];
+}
+export interface ResolvedRollSummary {
+    readonly index: number;
+    readonly total: number;
+    readonly pool: PoolSummary | null;
+}
+export interface DiceRollSummary extends RollResultBase {
+    readonly type: 'dice-roll-summary';
+    readonly rolls: readonly ResolvedRollSummary[];
+}
+interface DiceNotationInspectionBase {
+    readonly type: 'dice-notation-inspection';
+    readonly input: string;
+    readonly notation: string;
+    readonly normalizedNotation: string;
+    readonly comment: string;
+}
+interface ValidDiceNotationInspection extends DiceNotationInspectionBase {
+    readonly isValid: true;
+    readonly plan: RollPlan;
+    readonly groups: readonly RollPlanGroup[];
+    readonly cost: DiceInspectionCost;
+    readonly error: null;
+}
+interface InvalidDiceNotationInspection extends DiceNotationInspectionBase {
+    readonly isValid: false;
+    readonly plan: null;
+    readonly groups: readonly RollPlanGroup[];
+    readonly cost: null;
+    readonly error: DiceRollError;
+}
+export type DiceNotationInspection = ValidDiceNotationInspection | InvalidDiceNotationInspection;
+export type FreezeResultsMode = 'development' | 'always' | 'never';
+export interface DiceCacheOptions {
+    readonly maxInputEntries?: number;
+    readonly maxProgramEntries?: number;
+    readonly maxProgramNodes?: number;
+}
+export interface DiceCacheStats {
+    readonly inputEntries: number;
+    readonly programEntries: number;
+    readonly programNodes: number;
+    readonly hits: number;
+    readonly misses: number;
+    readonly evictions: number;
+}
+export interface DiceEngineOptions {
+    readonly limits?: Partial<DiceLimits>;
+    readonly freezeResults?: FreezeResultsMode;
+    readonly cache?: false | DiceCacheOptions;
+    readonly randomAlgorithm?: RandomAlgorithm;
+}
+export interface CompileOptions {
+    readonly limits?: Partial<DiceLimits>;
+}
+type SeededRollOptions = {
+    readonly seed?: SeedInput;
+    readonly replay?: never;
+    readonly randomAlgorithm?: RandomAlgorithm;
+};
+type ReplayRollOptions = {
+    readonly seed?: never;
+    readonly replay: ReplayDescriptor;
+    readonly randomAlgorithm?: never;
+};
+export type RollOptions = CompileOptions & (SeededRollOptions | ReplayRollOptions);
+export interface DiceEngine {
+    readonly limits: DiceLimits;
+    clearCache(): void;
+    compile(input: string, options?: CompileOptions): RollPlan;
+    getCacheStats(): DiceCacheStats;
+    inspect(input: string, options?: CompileOptions): DiceNotationInspection;
+    normalize(input: string): string;
+    roll(input: string | RollPlan, options?: RollOptions): DiceRollResult;
+    rollSummary(input: string | RollPlan, options?: RollOptions): DiceRollSummary;
+    verify(input: string, options?: CompileOptions): boolean;
+}
+export {};