roll-parser 3.0.0-beta.0 → 3.0.0

package/dist/evaluator/evaluator.js

@@ -0,0 +1,906 @@
+import { describeValue, EvaluatorError, RollParserError, stampEvaluatorSpan } from '../errors.js';
+import { isKeepDrop } from '../parser/ast.js';
+import { containsVersus } from '../parser/guards.js';
+import { DegreeOfSuccess } from '../types.js';
+import { createDieResult, createFateDieResult } from './die.js';
+import { chargeDice } from './env.js';
+import { applyCritThresholds } from './modifiers/crit-threshold.js';
+import { applyDieBound } from './modifiers/die-bound.js';
+import { applyCompoundExplode, applyPenetratingExplode, applyStandardExplode, buildShouldExplode, DEFAULT_MAX_EXPLODE_ITERATIONS, } from './modifiers/explode.js';
+import { isVersusDc, rewriteFlags, SELECTION_AND_TALLY_FLAGS, SELECTION_FLAGS, } from './modifiers/flags.js';
+import { markDroppedIndices, sumKeptDice } from './modifiers/keep-drop.js';
+import { applyRecursiveReroll, applyRerollOnce, DEFAULT_MAX_REROLL_ITERATIONS, } from './modifiers/reroll.js';
+import { sortDice } from './modifiers/sort.js';
+import { countSuccesses } from './modifiers/success-count.js';
+export { EvaluatorError };
+export const DEFAULT_MAX_DICE = 10_000;
+const MAX_DICE_SIDES = Number.MAX_SAFE_INTEGER;
+function resolveLimit(value, option, fallback, min) {
+    if (value == null)
+        return fallback;
+    if (typeof value !== 'number' || !Number.isSafeInteger(value) || value < min) {
+        throw new RollParserError(`Option '${option}' must be an integer >= ${min}, received ${describeValue(value)}`, 'INVALID_EVALUATION_LIMIT');
+    }
+    return value;
+}
+export { DEFAULT_MAX_EXPLODE_ITERATIONS, DEFAULT_MAX_REROLL_ITERATIONS };
+function createContext() {
+    return { rolls: [], expressionParts: [], renderedParts: [] };
+}
+function partSpan(node) {
+    if (node.start == null || node.end == null)
+        return {};
+    return { start: node.start, end: node.end };
+}
+function appendAll(target, source) {
+    for (const item of source) {
+        target.push(item);
+    }
+}
+function toPublicSpecs(specs) {
+    return specs.map(({ code: _code, ...spec }) => spec);
+}
+function renderDice(dice) {
+    let rendered = '[';
+    let isFirst = true;
+    for (const die of dice) {
+        const { modifiers } = die;
+        if (modifiers.length === 1 && modifiers[0] === 'kept') {
+            rendered = isFirst ? `${rendered}${die.result}` : `${rendered}, ${die.result}`;
+            isFirst = false;
+            continue;
+        }
+        if (modifiers.includes('meta'))
+            continue;
+        if (!isFirst)
+            rendered += ', ';
+        isFirst = false;
+        rendered += renderDie(die.result, modifiers);
+    }
+    return `${rendered}]`;
+}
+function renderDie(result, modifiers) {
+    if (modifiers.includes('dropped'))
+        return `~~${result}~~`;
+    if (modifiers.includes('success'))
+        return `**${result}**`;
+    if (modifiers.includes('failure'))
+        return `__${result}__`;
+    return String(result);
+}
+export function mergeMetaRolls(parent, source) {
+    for (const die of source.rolls) {
+        parent.rolls.push({
+            ...die,
+            modifiers: rewriteFlags(die.modifiers, SELECTION_AND_TALLY_FLAGS, 'meta', 'dropped'),
+        });
+    }
+}
+function evalNode(node, rng, ctx, env) {
+    try {
+        return evalNodeInner(node, rng, ctx, env);
+    }
+    catch (error) {
+        if (error instanceof EvaluatorError && node.start != null) {
+            stampEvaluatorSpan(error, node.start, node.end);
+        }
+        throw error;
+    }
+}
+function evalNodeInner(node, rng, ctx, env) {
+    switch (node.type) {
+        case 'Literal':
+            return evalLiteral(node, ctx);
+        case 'Dice':
+            return evalDice(node, rng, ctx, env);
+        case 'FateDice':
+            return evalFateDice(node, rng, ctx, env);
+        case 'BinaryOp':
+            return evalBinaryOp(node, rng, ctx, env);
+        case 'UnaryOp':
+            return evalUnaryOp(node, rng, ctx, env);
+        case 'KeepDrop':
+            return evalKeepDrop(node, rng, ctx, env);
+        case 'Explode':
+            return evalExplode(node, rng, ctx, env);
+        case 'Reroll':
+            return evalReroll(node, rng, ctx, env);
+        case 'DieBound':
+            return evalDieBound(node, rng, ctx, env);
+        case 'SuccessCount':
+            return evalSuccessCount(node, rng, ctx, env);
+        case 'Versus':
+            return evalVersus(node, rng, ctx, env);
+        case 'FunctionCall':
+            return evalFunctionCall(node, rng, ctx, env);
+        case 'Grouped':
+            return evalGrouped(node, rng, ctx, env);
+        case 'Group':
+            return evalGroup(node, rng, ctx, env);
+        case 'Sort':
+            return evalSort(node, rng, ctx, env);
+        case 'CritThreshold':
+            return evalCritThreshold(node, rng, ctx, env);
+        case 'Variable':
+            return evalVariable(node, ctx, env);
+        default: {
+            const exhaustive = node;
+            throw new EvaluatorError(`Unknown node type: ${exhaustive.type}`, 'UNKNOWN_NODE_TYPE', exhaustive.type);
+        }
+    }
+}
+function evalLiteral(node, ctx) {
+    const { value } = node;
+    ctx.expressionParts.push(String(value));
+    ctx.renderedParts.push(String(value));
+    return { total: value, part: { type: 'literal', value, total: value, ...partSpan(node) } };
+}
+function variableNeedsBraces(name) {
+    return !/^[A-Za-z_][A-Za-z0-9_]*$/.test(name);
+}
+function evalVariable(node, ctx, env) {
+    const present = Object.hasOwn(env.context, node.name);
+    if (!present) {
+        if (env.onMissingVariable === 'throw') {
+            throw new EvaluatorError(`Undefined variable: ${node.name}`, 'UNDEFINED_VARIABLE', 'Variable');
+        }
+        const display = variableNeedsBraces(node.name) ? `@{${node.name}}` : `@${node.name}`;
+        ctx.expressionParts.push('0');
+        ctx.renderedParts.push(`${display}[0]`);
+        return {
+            total: 0,
+            part: { type: 'variable', name: node.name, value: 0, total: 0, ...partSpan(node) },
+        };
+    }
+    const value = env.context[node.name];
+    if (!Number.isFinite(value)) {
+        throw new EvaluatorError(`Invalid variable value: ${node.name} = ${value}`, 'INVALID_VARIABLE_VALUE', 'Variable');
+    }
+    const display = variableNeedsBraces(node.name) ? `@{${node.name}}` : `@${node.name}`;
+    ctx.expressionParts.push(String(value));
+    ctx.renderedParts.push(`${display}[${value}]`);
+    return {
+        total: value,
+        part: { type: 'variable', name: node.name, value, total: value, ...partSpan(node) },
+    };
+}
+function evalMetaOperand(node, rng, ctx, env) {
+    if (node.type === 'Literal')
+        return node.value;
+    if (containsVersus(node)) {
+        const error = new EvaluatorError('Versus cannot be used as a meta-expression', 'NESTED_VERSUS', 'Versus');
+        if (node.start != null)
+            stampEvaluatorSpan(error, node.start, node.end);
+        throw error;
+    }
+    const metaCtx = createContext();
+    const value = evalNode(node, rng, metaCtx, env).total;
+    mergeMetaRolls(ctx, metaCtx);
+    return value;
+}
+function requireDiceCount(count, nodeType) {
+    if (!Number.isInteger(count) || count < 0) {
+        throw new EvaluatorError(`Invalid dice count: ${count}`, 'INVALID_DICE_COUNT', nodeType);
+    }
+}
+function rollPool(count, notation, rollDie, ctx) {
+    const dice = [];
+    let total = 0;
+    for (let i = 0; i < count; i++) {
+        const die = rollDie();
+        dice.push(die);
+        total += die.result;
+    }
+    appendAll(ctx.rolls, dice);
+    ctx.expressionParts.push(notation);
+    ctx.renderedParts.push(`${notation}${renderDice(dice)}`);
+    return { total, rolls: dice };
+}
+function evalDice(node, rng, ctx, env) {
+    const count = evalMetaOperand(node.count, rng, ctx, env);
+    const sides = evalMetaOperand(node.sides, rng, ctx, env);
+    requireDiceCount(count, 'Dice');
+    if (!Number.isInteger(sides) || sides < 1) {
+        throw new EvaluatorError(`Invalid dice sides: ${sides}`, 'INVALID_DICE_SIDES', 'Dice');
+    }
+    if (sides > MAX_DICE_SIDES) {
+        throw new EvaluatorError(`Dice sides ${sides} exceeds maximum of ${MAX_DICE_SIDES}`, 'INVALID_DICE_SIDES', 'Dice');
+    }
+    chargeDice(env, count, 'Dice');
+    const { total, rolls } = rollPool(count, `${count}d${sides}`, () => createDieResult(sides, rng.nextInt(1, sides), ['kept']), ctx);
+    return { total, part: { type: 'dice', count, sides, rolls, total, ...partSpan(node) } };
+}
+function evalFateDice(node, rng, ctx, env) {
+    const count = evalMetaOperand(node.count, rng, ctx, env);
+    requireDiceCount(count, 'FateDice');
+    chargeDice(env, count, 'FateDice');
+    const { total, rolls } = rollPool(count, `${count}dF`, () => createFateDieResult(rng.nextInt(-1, 1), ['kept']), ctx);
+    return { total, part: { type: 'fateDice', count, rolls, total, ...partSpan(node) } };
+}
+function propagateMetadata(parent, metadata) {
+    if (!metadata)
+        return;
+    if (parent.versusMetadata) {
+        throw new EvaluatorError('Multiple versus operators in the same expression', 'NESTED_VERSUS', 'Versus');
+    }
+    parent.versusMetadata = metadata;
+}
+function mergeContext(parent, child) {
+    appendAll(parent.rolls, child.rolls);
+    propagateMetadata(parent, child.versusMetadata);
+}
+function evalBinaryOp(node, rng, ctx, env) {
+    const leftCtx = createContext();
+    const rightCtx = createContext();
+    const left = evalNode(node.left, rng, leftCtx, env);
+    const right = evalNode(node.right, rng, rightCtx, env);
+    mergeContext(ctx, leftCtx);
+    mergeContext(ctx, rightCtx);
+    const leftExpr = leftCtx.expressionParts.join('');
+    const rightExpr = rightCtx.expressionParts.join('');
+    const leftRendered = leftCtx.renderedParts.join('');
+    const rightRendered = rightCtx.renderedParts.join('');
+    ctx.expressionParts.push(`${leftExpr} ${node.operator} ${rightExpr}`);
+    ctx.renderedParts.push(`${leftRendered} ${node.operator} ${rightRendered}`);
+    const total = applyBinaryOperator(node.operator, left.total, right.total);
+    return {
+        total,
+        part: {
+            type: 'binaryOp',
+            operator: node.operator,
+            left: left.part,
+            right: right.part,
+            total,
+            ...partSpan(node),
+        },
+    };
+}
+function applyBinaryOperator(operator, left, right) {
+    switch (operator) {
+        case '+':
+            return left + right;
+        case '-':
+            return left - right;
+        case '*':
+            return left * right;
+        case '/':
+            if (right === 0) {
+                throw new EvaluatorError('Division by zero', 'DIVISION_BY_ZERO', 'BinaryOp');
+            }
+            return left / right;
+        case '%':
+            if (right === 0) {
+                throw new EvaluatorError('Modulo by zero', 'MODULO_BY_ZERO', 'BinaryOp');
+            }
+            return left % right;
+        case '**':
+            return left ** right;
+        default: {
+            const exhaustive = operator;
+            throw new EvaluatorError(`Unknown operator: ${exhaustive}`, 'UNKNOWN_OPERATOR', 'BinaryOp');
+        }
+    }
+}
+function evalUnaryOp(node, rng, ctx, env) {
+    const innerCtx = createContext();
+    const inner = evalNode(node.operand, rng, innerCtx, env);
+    mergeContext(ctx, innerCtx);
+    const innerExpr = innerCtx.expressionParts.join('');
+    const innerRendered = innerCtx.renderedParts.join('');
+    ctx.expressionParts.push(`-${innerExpr}`);
+    ctx.renderedParts.push(`-${innerRendered}`);
+    const total = -inner.total;
+    return {
+        total,
+        part: { type: 'unaryOp', operator: '-', operand: inner.part, total, ...partSpan(node) },
+    };
+}
+function evalGrouped(node, rng, ctx, env) {
+    const innerCtx = createContext();
+    const inner = evalNode(node.expression, rng, innerCtx, env);
+    mergeContext(ctx, innerCtx);
+    ctx.expressionParts.push(`(${innerCtx.expressionParts.join('')})`);
+    ctx.renderedParts.push(`(${innerCtx.renderedParts.join('')})`);
+    return {
+        total: inner.total,
+        part: { type: 'grouped', inner: inner.part, total: inner.total, ...partSpan(node) },
+    };
+}
+function evalGroup(node, rng, ctx, env) {
+    const subExprs = [];
+    const subRendered = [];
+    const subParts = [];
+    let total = 0;
+    for (const expr of node.expressions) {
+        const subCtx = createContext();
+        const sub = evalNode(expr, rng, subCtx, env);
+        mergeContext(ctx, subCtx);
+        subExprs.push(subCtx.expressionParts.join(''));
+        subRendered.push(subCtx.renderedParts.join(''));
+        subParts.push(sub.part);
+        total += sub.total;
+    }
+    ctx.expressionParts.push(`{${subExprs.join(', ')}}`);
+    ctx.renderedParts.push(`{${subRendered.join(', ')}}`);
+    return { total, part: { type: 'group', parts: subParts, total, ...partSpan(node) } };
+}
+function evalFunctionCall(node, rng, ctx, env) {
+    const argCtxs = [];
+    const argResults = [];
+    for (const arg of node.args) {
+        const argCtx = createContext();
+        argResults.push(evalNode(arg, rng, argCtx, env));
+        argCtxs.push(argCtx);
+    }
+    for (const argCtx of argCtxs) {
+        mergeContext(ctx, argCtx);
+    }
+    const argExprs = argCtxs.map((c) => c.expressionParts.join(''));
+    const argRendereds = argCtxs.map((c) => c.renderedParts.join(''));
+    ctx.expressionParts.push(`${node.name}(${argExprs.join(', ')})`);
+    ctx.renderedParts.push(`${node.name}(${argRendereds.join(', ')})`);
+    const total = applyFunction(node.name, argResults.map((r) => r.total));
+    return {
+        total,
+        part: {
+            type: 'functionCall',
+            name: node.name,
+            args: argResults.map((r) => r.part),
+            total,
+            ...partSpan(node),
+        },
+    };
+}
+function applyFunction(name, values) {
+    switch (name) {
+        case 'floor':
+            return Math.floor(requireUnaryArg(name, values));
+        case 'ceil':
+            return Math.ceil(requireUnaryArg(name, values));
+        case 'round':
+            return Math.round(requireUnaryArg(name, values));
+        case 'abs':
+            return Math.abs(requireUnaryArg(name, values));
+        case 'sqrt':
+            return Math.sqrt(requireUnaryArg(name, values));
+        case 'pow': {
+            const [base, exponent] = requireBinaryArgs(name, values);
+            return base ** exponent;
+        }
+        case 'max':
+            return extremumOf(values, 'max');
+        case 'min':
+            return extremumOf(values, 'min');
+        default:
+            throw new EvaluatorError(`Unknown function: ${name}`, 'UNKNOWN_FUNCTION', 'FunctionCall');
+    }
+}
+function extremumOf(values, kind) {
+    let result = kind === 'max' ? Number.NEGATIVE_INFINITY : Number.POSITIVE_INFINITY;
+    for (const value of values) {
+        if (Number.isNaN(value))
+            return Number.NaN;
+        if (kind === 'max' ? value > result : value < result)
+            result = value;
+    }
+    return result;
+}
+function requireUnaryArg(name, values) {
+    const [x] = values;
+    if (x == null) {
+        throw new EvaluatorError(`Function '${name}' requires an argument`, 'UNKNOWN_FUNCTION', 'FunctionCall');
+    }
+    return x;
+}
+function requireBinaryArgs(name, values) {
+    const [a, b] = values;
+    if (a == null || b == null) {
+        throw new EvaluatorError(`Function '${name}' requires two arguments`, 'UNKNOWN_FUNCTION', 'FunctionCall');
+    }
+    return [a, b];
+}
+const KEEP_DROP_CODES = {
+    keep: { highest: 'kh', lowest: 'kl' },
+    drop: { highest: 'dh', lowest: 'dl' },
+};
+function keepDropCode(kind, selector) {
+    return KEEP_DROP_CODES[kind][selector];
+}
+function flattenKeepDropChain(node, rng, ctx, env) {
+    const specs = [];
+    let current = node;
+    while (isKeepDrop(current)) {
+        const modCount = evalMetaOperand(current.count, rng, ctx, env);
+        if (!Number.isInteger(modCount) || modCount < 0) {
+            throw new EvaluatorError(`Invalid keep/drop count: ${modCount}`, 'INVALID_KEEP_DROP_COUNT', 'KeepDrop');
+        }
+        specs.push({
+            kind: current.kind,
+            selector: current.selector,
+            count: modCount,
+            code: keepDropCode(current.kind, current.selector),
+        });
+        current = current.target;
+    }
+    specs.reverse();
+    return { specs, baseTarget: current };
+}
+function mergeDropSets(baseDice, specs) {
+    const droppedMask = new Uint8Array(baseDice.length);
+    for (const spec of specs) {
+        markDroppedIndices(baseDice, spec.count, spec.kind, spec.selector, droppedMask);
+    }
+    for (let index = 0; index < baseDice.length; index++) {
+        const die = baseDice[index];
+        if (die == null)
+            continue;
+        const marker = droppedMask[index] === 1 ? 'dropped' : 'kept';
+        const { modifiers } = die;
+        if (modifiers.length === 1 && modifiers[0] === marker)
+            continue;
+        die.modifiers = rewriteFlags(modifiers, SELECTION_FLAGS, marker);
+    }
+    return baseDice;
+}
+const EXPLODE_MARKERS = {
+    standard: '!',
+    compound: '!!',
+    penetrating: '!p',
+};
+const EXPLODE_APPLIERS = {
+    standard: applyStandardExplode,
+    compound: applyCompoundExplode,
+    penetrating: applyPenetratingExplode,
+};
+function formatExplodeCode(variant, threshold, thresholdValue) {
+    const marker = EXPLODE_MARKERS[variant];
+    if (threshold == null || thresholdValue == null)
+        return marker;
+    return `${marker}${threshold.operator}${thresholdValue}`;
+}
+function evalExplode(node, rng, ctx, env) {
+    const targetCtx = createContext();
+    const target = evalNode(node.target, rng, targetCtx, env);
+    const targetExpr = targetCtx.expressionParts.join('');
+    let thresholdValue;
+    if (node.threshold != null) {
+        thresholdValue = evalMetaOperand(node.threshold.value, rng, ctx, env);
+    }
+    const code = formatExplodeCode(node.variant, node.threshold, thresholdValue);
+    const buildPart = (total) => {
+        const part = {
+            type: 'explode',
+            variant: node.variant,
+            target: target.part,
+            total,
+            ...partSpan(node),
+        };
+        if (node.threshold != null && thresholdValue != null) {
+            part.threshold = { operator: node.threshold.operator, value: thresholdValue };
+        }
+        return part;
+    };
+    if (targetCtx.rolls.length === 0) {
+        ctx.expressionParts.push(`${targetExpr}${code}`);
+        ctx.renderedParts.push(`${targetExpr}${code}`);
+        return { total: target.total, part: buildPart(target.total) };
+    }
+    const shouldExplode = buildShouldExplode(node.threshold?.operator, thresholdValue);
+    const expanded = EXPLODE_APPLIERS[node.variant](targetCtx.rolls, shouldExplode, rng, env);
+    appendAll(ctx.rolls, expanded);
+    ctx.expressionParts.push(`${targetExpr}${code}`);
+    ctx.renderedParts.push(`${targetExpr}${code}${renderDice(expanded)}`);
+    const total = sumKeptDice(expanded);
+    return { total, part: buildPart(total) };
+}
+function evalReroll(node, rng, ctx, env) {
+    const targetCtx = createContext();
+    const target = evalNode(node.target, rng, targetCtx, env);
+    const targetExpr = targetCtx.expressionParts.join('');
+    const thresholdValue = evalMetaOperand(node.condition.value, rng, ctx, env);
+    const code = `${node.once ? 'ro' : 'r'}${node.condition.operator}${thresholdValue}`;
+    const condition = {
+        operator: node.condition.operator,
+        value: thresholdValue,
+    };
+    if (targetCtx.rolls.length === 0) {
+        ctx.expressionParts.push(`${targetExpr}${code}`);
+        ctx.renderedParts.push(`${targetExpr}${code}`);
+        const total = sumKeptDice(targetCtx.rolls);
+        return {
+            total,
+            part: {
+                type: 'reroll',
+                once: node.once,
+                condition,
+                target: target.part,
+                total,
+                ...partSpan(node),
+            },
+        };
+    }
+    const pool = node.once
+        ? applyRerollOnce(targetCtx.rolls, node.condition.operator, thresholdValue, rng, env)
+        : applyRecursiveReroll(targetCtx.rolls, node.condition.operator, thresholdValue, rng, env);
+    appendAll(ctx.rolls, pool);
+    ctx.expressionParts.push(`${targetExpr}${code}`);
+    ctx.renderedParts.push(`${targetExpr}${code}${renderDice(pool)}`);
+    const total = sumKeptDice(pool);
+    return {
+        total,
+        part: {
+            type: 'reroll',
+            once: node.once,
+            condition,
+            target: target.part,
+            total,
+            ...partSpan(node),
+        },
+    };
+}
+function evalDieBound(node, rng, ctx, env) {
+    const targetCtx = createContext();
+    const target = evalNode(node.target, rng, targetCtx, env);
+    const boundValue = evalMetaOperand(node.value, rng, ctx, env);
+    if (!Number.isFinite(boundValue)) {
+        throw new EvaluatorError(`Invalid ${node.bound} bound: ${boundValue}`, 'INVALID_THRESHOLD', 'DieBound');
+    }
+    applyDieBound(targetCtx.rolls, node.bound, boundValue);
+    appendAll(ctx.rolls, targetCtx.rolls);
+    const targetExpr = targetCtx.expressionParts.join('');
+    const code = boundValue < 0 ? `${node.bound}(${boundValue})` : `${node.bound}${boundValue}`;
+    ctx.expressionParts.push(`${targetExpr}${code}`);
+    ctx.renderedParts.push(`${targetExpr}${code}${renderDice(targetCtx.rolls)}`);
+    const total = sumKeptDice(targetCtx.rolls);
+    return {
+        total,
+        part: {
+            type: 'dieBound',
+            bound: node.bound,
+            value: boundValue,
+            target: target.part,
+            total,
+            ...partSpan(node),
+        },
+    };
+}
+function evalSort(node, rng, ctx, env) {
+    const targetCtx = createContext();
+    const target = evalNode(node.target, rng, targetCtx, env);
+    const sortedRolls = sortDice(targetCtx.rolls, node.order);
+    appendAll(ctx.rolls, sortedRolls);
+    propagateMetadata(ctx, targetCtx.versusMetadata);
+    const code = node.order === 'ascending' ? 's' : 'sd';
+    const targetExpr = targetCtx.expressionParts.join('');
+    ctx.expressionParts.push(`${targetExpr}${code}`);
+    ctx.renderedParts.push(`${targetExpr}${code}${renderDice(sortedRolls)}`);
+    return {
+        total: target.total,
+        part: {
+            type: 'sort',
+            order: node.order,
+            rolls: sortedRolls,
+            target: target.part,
+            total: target.total,
+            ...partSpan(node),
+        },
+    };
+}
+function evalCritThreshold(node, rng, ctx, env) {
+    const targetCtx = createContext();
+    const target = evalNode(node.target, rng, targetCtx, env);
+    const successResolved = node.successThresholds.map((t) => resolveCritThreshold(t, rng, ctx, env));
+    const failResolved = node.failThresholds.map((t) => resolveCritThreshold(t, rng, ctx, env));
+    const successApplied = successResolved.length > 0 ? successResolved : ['default'];
+    const failApplied = failResolved.length > 0 ? failResolved : ['default'];
+    applyCritThresholds(targetCtx.rolls, successApplied, failApplied);
+    appendAll(ctx.rolls, targetCtx.rolls);
+    propagateMetadata(ctx, targetCtx.versusMetadata);
+    const targetExpr = targetCtx.expressionParts.join('');
+    const codes = [
+        ...successResolved.map((t) => (t === 'default' ? 'cs' : `cs${t.operator}${t.value}`)),
+        ...failResolved.map((t) => (t === 'default' ? 'cf' : `cf${t.operator}${t.value}`)),
+    ].join('');
+    ctx.expressionParts.push(`${targetExpr}${codes}`);
+    ctx.renderedParts.push(`${targetExpr}${codes}${renderDice(targetCtx.rolls)}`);
+    return {
+        total: target.total,
+        part: {
+            type: 'critThreshold',
+            successThresholds: successResolved,
+            failThresholds: failResolved,
+            target: target.part,
+            total: target.total,
+            ...partSpan(node),
+        },
+    };
+}
+function resolveCritThreshold(threshold, rng, ctx, env) {
+    if (threshold === 'default')
+        return 'default';
+    const resolved = evalMetaOperand(threshold.value, rng, ctx, env);
+    if (!Number.isFinite(resolved)) {
+        throw new EvaluatorError(`Invalid crit threshold: ${resolved}`, 'INVALID_THRESHOLD', 'CritThreshold');
+    }
+    return { operator: threshold.operator, value: resolved };
+}
+function evalKeepDrop(node, rng, ctx, env) {
+    const { specs, baseTarget } = flattenKeepDropChain(node, rng, ctx, env);
+    if (baseTarget.type === 'Group' && baseTarget.expressions.length >= 2) {
+        return evalGroupKeepDrop(node, baseTarget, specs, rng, ctx, env);
+    }
+    const targetCtx = createContext();
+    const target = evalNode(baseTarget, rng, targetCtx, env);
+    const mergedDice = mergeDropSets(targetCtx.rolls, specs);
+    appendAll(ctx.rolls, mergedDice);
+    const total = sumKeptDice(mergedDice);
+    const targetExpr = targetCtx.expressionParts.join('');
+    const keepDropCodes = specs.map((s) => `${s.code}${s.count}`).join('');
+    ctx.expressionParts.push(`${targetExpr}${keepDropCodes}`);
+    ctx.renderedParts.push(`${targetExpr}${renderDice(mergedDice)}`);
+    return {
+        total,
+        part: {
+            type: 'keepDrop',
+            specs: toPublicSpecs(specs),
+            target: target.part,
+            total,
+            ...partSpan(node),
+        },
+    };
+}
+function stripInnerMarkers(rendered) {
+    return rendered
+        .replace(/\*\*(-?\d+)\*\*/g, '$1')
+        .replace(/__(-?\d+)__/g, '$1')
+        .replace(/~~(-?\d+)~~/g, '$1');
+}
+function evalGroupKeepDrop(node, group, specs, rng, ctx, env) {
+    const subRolls = group.expressions.map((expr) => {
+        const subCtx = createContext();
+        const sub = evalNode(expr, rng, subCtx, env);
+        return {
+            subtotal: sub.total,
+            part: sub.part,
+            rolls: subCtx.rolls,
+            expr: subCtx.expressionParts.join(''),
+            rendered: subCtx.renderedParts.join(''),
+            versusMetadata: subCtx.versusMetadata,
+        };
+    });
+    const syntheticDice = subRolls.map((sub) => ({
+        sides: 0,
+        result: sub.subtotal,
+        modifiers: [],
+        critical: false,
+        fumble: false,
+    }));
+    const mergedSynthetic = mergeDropSets(syntheticDice, specs);
+    const outerRendered = [];
+    const keptIndices = [];
+    let total = 0;
+    for (let i = 0; i < subRolls.length; i++) {
+        const sub = subRolls[i];
+        const synth = mergedSynthetic[i];
+        const isDropped = synth.modifiers.includes('dropped');
+        if (isDropped) {
+            for (const die of sub.rolls) {
+                die.modifiers = rewriteFlags(die.modifiers, SELECTION_AND_TALLY_FLAGS, 'dropped');
+            }
+            appendAll(ctx.rolls, sub.rolls);
+            outerRendered.push(`~~${stripInnerMarkers(sub.rendered)}~~`);
+        }
+        else {
+            keptIndices.push(i);
+            appendAll(ctx.rolls, sub.rolls);
+            outerRendered.push(sub.rendered);
+            total += sub.subtotal;
+        }
+        if (!isDropped) {
+            propagateMetadata(ctx, sub.versusMetadata);
+        }
+    }
+    const subExprStrs = subRolls.map((s) => s.expr);
+    const keepDropCodes = specs.map((s) => `${s.code}${s.count}`).join('');
+    ctx.expressionParts.push(`{${subExprStrs.join(', ')}}${keepDropCodes}`);
+    ctx.renderedParts.push(`{${outerRendered.join(', ')}}`);
+    const groupPart = {
+        type: 'group',
+        parts: subRolls.map((s) => s.part),
+        keptIndices,
+        total,
+        ...partSpan(group),
+    };
+    return {
+        total,
+        part: {
+            type: 'keepDrop',
+            specs: toPublicSpecs(specs),
+            target: groupPart,
+            total,
+            ...partSpan(node),
+        },
+    };
+}
+function resolveThreshold(value, rng, ctx, env, role) {
+    const resolved = evalMetaOperand(value, rng, ctx, env);
+    if (!Number.isFinite(resolved)) {
+        throw new EvaluatorError(`Invalid ${role}: ${resolved}`, 'INVALID_THRESHOLD', 'SuccessCount');
+    }
+    return resolved;
+}
+function formatFailCode(operator, value) {
+    return operator === '=' ? `f${value}` : `f${operator}${value}`;
+}
+function evalSuccessCount(node, rng, ctx, env) {
+    env.hasSuccessCount = true;
+    const targetCtx = createContext();
+    const target = evalNode(node.target, rng, targetCtx, env);
+    const targetExpr = targetCtx.expressionParts.join('');
+    const thresholdValue = resolveThreshold(node.threshold.value, rng, ctx, env, 'threshold');
+    const failValue = node.failThreshold != null
+        ? resolveThreshold(node.failThreshold.value, rng, ctx, env, 'fail threshold')
+        : undefined;
+    const failCode = failValue != null && node.failThreshold != null
+        ? formatFailCode(node.failThreshold.operator, failValue)
+        : '';
+    const code = `${node.threshold.operator}${thresholdValue}${failCode}`;
+    const buildPart = (total, successes, failures) => {
+        const part = {
+            type: 'successCount',
+            threshold: { operator: node.threshold.operator, value: thresholdValue },
+            target: target.part,
+            successes,
+            failures,
+            total,
+            ...partSpan(node),
+        };
+        if (failValue != null && node.failThreshold != null) {
+            part.failThreshold = { operator: node.failThreshold.operator, value: failValue };
+        }
+        return part;
+    };
+    if (targetCtx.rolls.length === 0) {
+        ctx.expressionParts.push(`${targetExpr}${code}`);
+        ctx.renderedParts.push(`${targetExpr}${code}`);
+        return { total: target.total, part: buildPart(target.total, 0, 0) };
+    }
+    const result = countSuccesses(targetCtx.rolls, { operator: node.threshold.operator, value: thresholdValue }, failValue != null && node.failThreshold != null
+        ? { operator: node.failThreshold.operator, value: failValue }
+        : undefined);
+    appendAll(ctx.rolls, targetCtx.rolls);
+    ctx.expressionParts.push(`${targetExpr}${code}`);
+    ctx.renderedParts.push(`${targetExpr}${code}${renderDice(targetCtx.rolls)}`);
+    return {
+        total: result.total,
+        part: buildPart(result.total, result.successes, result.failures),
+    };
+}
+function extractNatural(rolls) {
+    const primaries = rolls.filter((d) => d.sides === 20 &&
+        !d.modifiers.includes('dropped') &&
+        !(d.modifiers.includes('exploded') && d.initialResult == null));
+    if (primaries.length !== 1)
+        return undefined;
+    const die = primaries[0];
+    return die?.initialResult ?? die?.result;
+}
+function calculateDegree(total, dc, natural) {
+    let degree;
+    if (total >= dc + 10)
+        degree = DegreeOfSuccess.CriticalSuccess;
+    else if (total >= dc)
+        degree = DegreeOfSuccess.Success;
+    else if (total > dc - 10)
+        degree = DegreeOfSuccess.Failure;
+    else
+        degree = DegreeOfSuccess.CriticalFailure;
+    if (natural === 20 && degree < DegreeOfSuccess.CriticalSuccess)
+        degree++;
+    if (natural === 1 && degree > DegreeOfSuccess.CriticalFailure)
+        degree--;
+    return degree;
+}
+function degreeLabel(degree) {
+    switch (degree) {
+        case DegreeOfSuccess.CriticalFailure:
+            return 'Critical Failure';
+        case DegreeOfSuccess.Failure:
+            return 'Failure';
+        case DegreeOfSuccess.Success:
+            return 'Success';
+        case DegreeOfSuccess.CriticalSuccess:
+            return 'Critical Success';
+    }
+}
+function evalVersus(node, rng, ctx, env) {
+    if (env.insideVersus) {
+        throw new EvaluatorError('Cannot nest versus operators', 'NESTED_VERSUS', 'Versus');
+    }
+    env.insideVersus = true;
+    try {
+        const rollCtx = createContext();
+        const rollResult = evalNode(node.roll, rng, rollCtx, env);
+        const natural = extractNatural(rollCtx.rolls);
+        const dcCtx = createContext();
+        const dcResult = evalNode(node.dc, rng, dcCtx, env);
+        const degree = calculateDegree(rollResult.total, dcResult.total, natural);
+        appendAll(ctx.rolls, rollCtx.rolls);
+        for (const die of dcCtx.rolls) {
+            die.modifiers.push('dc');
+        }
+        appendAll(ctx.rolls, dcCtx.rolls);
+        const rollExpr = rollCtx.expressionParts.join('');
+        const dcExpr = dcCtx.expressionParts.join('');
+        const rollRendered = rollCtx.renderedParts.join('');
+        const dcRendered = dcCtx.renderedParts.join('');
+        ctx.expressionParts.push(`${rollExpr} vs ${dcExpr}`);
+        ctx.renderedParts.push(`${rollRendered} vs ${dcRendered}`);
+        ctx.versusMetadata = { degree, natural, dcTotal: dcResult.total };
+        return {
+            total: rollResult.total,
+            part: {
+                type: 'versus',
+                roll: rollResult.part,
+                dc: dcResult.part,
+                degree,
+                total: rollResult.total,
+                ...partSpan(node),
+            },
+        };
+    }
+    finally {
+        env.insideVersus = false;
+    }
+}
+export function evaluate(ast, rng, options = {}) {
+    const maxDice = resolveLimit(options.maxDice, 'maxDice', DEFAULT_MAX_DICE, 1);
+    const maxExplodeIterations = resolveLimit(options.maxExplodeIterations, 'maxExplodeIterations', DEFAULT_MAX_EXPLODE_ITERATIONS, 0);
+    const maxRerollIterations = resolveLimit(options.maxRerollIterations, 'maxRerollIterations', DEFAULT_MAX_REROLL_ITERATIONS, 0);
+    const context = options.context ?? {};
+    const onMissingVariable = options.onMissingVariable ?? 'throw';
+    const env = {
+        maxDice,
+        maxExplodeIterations,
+        maxRerollIterations,
+        totalDiceRolled: 0,
+        hasSuccessCount: false,
+        insideVersus: false,
+        context,
+        onMissingVariable,
+    };
+    const ctx = createContext();
+    const { total, part } = evalNode(ast, rng, ctx, env);
+    if (!Number.isFinite(total)) {
+        throw new EvaluatorError(`Result is not a finite number: ${total}`, 'NON_FINITE_RESULT', ast.type);
+    }
+    const expression = ctx.expressionParts.join('');
+    const trailing = ctx.versusMetadata ? degreeLabel(ctx.versusMetadata.degree) : String(total);
+    const rendered = `${ctx.renderedParts.join('')} = ${trailing}`;
+    const versus = ctx.versusMetadata;
+    return {
+        total,
+        notation: options.notation ?? expression,
+        expression,
+        rendered,
+        rolls: ctx.rolls,
+        parts: part,
+        ...(env.hasSuccessCount ? countTaggedDice(ctx.rolls) : {}),
+        ...(versus ? { degree: versus.degree } : {}),
+        ...(versus?.natural != null ? { natural: versus.natural } : {}),
+    };
+}
+function countTaggedDice(rolls) {
+    let successes = 0;
+    let failures = 0;
+    for (const die of rolls) {
+        if (isVersusDc(die))
+            continue;
+        if (die.modifiers.includes('success'))
+            successes += 1;
+        else if (die.modifiers.includes('failure'))
+            failures += 1;
+    }
+    return { successes, failures };
+}
+//# sourceMappingURL=evaluator.js.map