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

package/CHANGELOG.md

@@ -0,0 +1,91 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]
+
+## [3.0.0-beta.0] - 2026-07-07
+
+### Changed
+
+- **BREAKING:** package is now ESM-only. The `require` export condition shipped a file that was actually ESM (`bun build --target node` emits ESM), so it only ever worked via Node ≥22 `require(esm)` — which continues to work. Bundles are built with `--target node` (no `// @bun` pragma) and include linked sourcemaps; type declarations now resolve under `moduleResolution: node16/nodenext`, validated by `@arethetypeswrong/cli` + `publint` in CI ([#119](https://github.com/edloidas/roll-parser/issues/119))
+- **BREAKING:** `cs`/`cf` are now independent overrides (Roll20 semantics). `1d20cf<3` keeps the default nat-20 crit instead of clearing it; `1d20cs>=19` keeps the default nat-1 fumble. The previous replace semantics required chaining `cscf<3` to preserve defaults ([#118](https://github.com/edloidas/roll-parser/issues/118))
+- **BREAKING:** bare `NdXdY` dice chains (e.g. `4d6d1`) are rejected at parse time with `AMBIGUOUS_DICE_CHAIN` instead of silently parsing as `(4d6)d1` — roll 4d6, use the result as a count of d1 dice — which is almost never intended. Use `4d6dl1` to drop dice or `(4d6)d1` for nested dice ([#118](https://github.com/edloidas/roll-parser/issues/118))
+- **BREAKING:** non-finite totals (`Infinity`/`NaN`, e.g. `2**1024`) now throw `NON_FINITE_RESULT` instead of returning a non-finite `total` ([#118](https://github.com/edloidas/roll-parser/issues/118))
+- **BREAKING:** `1d1` no longer reports `fumble: true` — a d1 always rolls 1, so it is neither critical nor fumble, mirroring the existing `critical` guard ([#118](https://github.com/edloidas/roll-parser/issues/118))
+
+### Added
+
+- Rich structured `RollResult.parts` output — a 16-variant discriminated union mirroring the AST 1:1, always built during evaluation. Each part carries its sub-total, resolved thresholds/specs (`ModifierSpec`, `ResolvedComparePoint`, `ResolvedCritThreshold`), source span, and (for dice parts) the same `DieResult` objects as `RollResult.rolls`. Group parts under keep/drop carry `keptIndices`; versus parts carry `degree`; successCount parts carry `successes`/`failures` with `total === successes - failures`. JSON-serializable with `parts.total === result.total` guaranteed ([#84](https://github.com/edloidas/roll-parser/issues/84))
+- Source spans: lexer tokens carry an exclusive `end` offset, and every parser-produced AST node carries `start`/`end` offsets (`NodeSpan`) into the notation. `EvaluatorError` is stamped with the span of the tightest failing sub-expression, and the CLI caret uses it — `2d6+1d0+3` points at `1d0` ([#120](https://github.com/edloidas/roll-parser/issues/120))
+- Root exports for the previously missing `GroupNode`/`SortNode`/`CritThresholdNode` types and `isGroup`/`isSort`/`isCritThreshold` guards ([#120](https://github.com/edloidas/roll-parser/issues/120))
+- Benchmark suite (`bun bench`, mitata) covering parse, evaluate, and end-to-end roll paths ([#119](https://github.com/edloidas/roll-parser/issues/119))
+- Coverage thresholds enforced in CI (100% functions, ≥95% lines per file); coverage was previously disabled in `bunfig.toml` and unmeasurable even with `--coverage` ([#119](https://github.com/edloidas/roll-parser/issues/119))
+- CLI prints the notation with a caret under the error position for lexer/parser errors ([#118](https://github.com/edloidas/roll-parser/issues/118))
+- Lexer hints at modifier splits for merged identifiers: `4d6khs` now suggests `kh1s` ([#118](https://github.com/edloidas/roll-parser/issues/118))
+- `"./package.json"` export and `CHANGELOG.md` in the published tarball ([#119](https://github.com/edloidas/roll-parser/issues/119))
+
+### Fixed
+
+- Dropped group sub-rolls no longer leak `success`/`failure` tags into `RollResult.successes`/`failures` — `{2d6>=4, 2d6>=4}kh1` counted successes from the dropped sub-roll, and the rendered output showed `**bold**` markers inside `~~strikethrough~~` ([#118](https://github.com/edloidas/roll-parser/issues/118))
+- `SeededRNG.nextInt` no longer silently truncates ranges above 2^32 — a 53-bit two-draw sampling path covers up to `Number.MAX_SAFE_INTEGER`, and wider ranges throw `RangeError` instead of degrading ([#118](https://github.com/edloidas/roll-parser/issues/118))
+- Deeply nested input (e.g. 20,000 parens) throws a typed `MAX_DEPTH_EXCEEDED` `ParseError` instead of an uncaught `RangeError` stack overflow that broke the `isRollParserError` contract ([#118](https://github.com/edloidas/roll-parser/issues/118))
+- PF2e nat-20/nat-1 upgrade now survives standard (`!`) and penetrating (`!p`) explosion under `vs` — explosion continuation dice no longer make `extractNatural` bail as ambiguous, matching the compound (`!!`) behavior ([#118](https://github.com/edloidas/roll-parser/issues/118))
+- Entire `package.json` (scripts, devDependencies, author email) is no longer embedded in every bundle via the `VERSION` import ([#119](https://github.com/edloidas/roll-parser/issues/119))
+- CLI verbose output no longer leaks markdown for dropped group sub-rolls — `{1d8, 1d10}kh1 -v` printed `{~~1d8[2]~~, ...}` because only single-number spans were rewritten ([#118](https://github.com/edloidas/roll-parser/issues/118))
+- Lexer errors report full code points for astral characters (`🎲` instead of a lone surrogate `�`); parser `expect()` errors name symbols and say `end of input` instead of `Expected RPAREN but got ''` ([#118](https://github.com/edloidas/roll-parser/issues/118))
+- Parser now rejects `SuccessCount` wrapped in meta-expression positions — modifier count, dice count/sides (infix and prefix), Fate/percentile dice count, SuccessCount threshold and bare `fN` value, and compare-point values used by Explode/Reroll. `mergeMetaRolls` also strips `success`/`failure` modifier tags on meta-forwarded dice as defense-in-depth ([#69](https://github.com/edloidas/roll-parser/issues/69))
+- Parser now rejects `Versus` wrapped in the same meta-expression positions so a PF2e `vs` outcome cannot be silently dropped by `mergeMetaRolls`, and the `parseVersus` chain guard unwraps `Grouped` so `(1d20 vs 15) vs 10` throws `NESTED_VERSUS` at parse time instead of at eval ([#70](https://github.com/edloidas/roll-parser/issues/70))
+- Single-sub-roll Group passthrough on `cs`/`cf` no longer smuggles a buried multi-sub Group past the parser. `{{1d20, 1d20}kh1}cs>18`, `{{1d6, 2d8}+0}cs>5`, `{abs({1d6, 2d8})}cs>5`, and `{floor({1d6, 2d8}/1)}cs>5` now reject with `INVALID_CRIT_THRESHOLD_TARGET` via a new `containsMultiSubGroup` deep-walk in `rejectGroupTarget` ([#109](https://github.com/edloidas/roll-parser/issues/109))
+- Single-sub-roll Group passthrough no longer flips Fate `+1` faces to fumble. `{4dF+1d6}cf`, `({4dF+1d6})cf`, and `{abs(4dF)}cf` now reject via a new `deepContainsFatePool` mirror of `deepContainsDicePool` used inside `containsFatePool`'s Group case ([#109](https://github.com/edloidas/roll-parser/issues/109))
+- Single-sub-roll Group passthrough no longer smuggles `Versus` past the meta-expression rejection, so `{1d20 vs 15}cs>18`, `{1d20 vs 15}s`, `{1d20 vs 15}kh1`, `{1+(1d20 vs 15)}cs>18`, `{abs(1d20 vs 15)}cs>18`, and `4d6>={1d20 vs 15}` now throw `NESTED_VERSUS`. `parseModifier` also gained the `rejectVersusTarget` call it was missing — closing a pre-existing inconsistency where `(1d20 vs 15)kh1` rejected with a different error code while the brace form silently dropped `degree`/`natural` ([#109](https://github.com/edloidas/roll-parser/issues/109))
+
+### Notes
+
+These are intentional behaviours documented for the first time, not changes — semantics are unchanged.
+
+- Sort flattens additive pools: `(2d6+1d8)s` renders as one combined sorted list rather than per-pool brackets. Same applies to wrapped pools like `floor(4d6)s`. Totals are preserved ([#96](https://github.com/edloidas/roll-parser/issues/96))
+- Outer parens drop from `result.expression` when chained `cs`/`cf` thresholds collapse: `(1d20cs>19)cs=1` renders as `1d20cs>19cs=1`. Re-parses to the same AST; only the textual form differs ([#96](https://github.com/edloidas/roll-parser/issues/96))
+
+## [3.0.0-alpha.0] - 2026-04-20
+
+First alpha of the v3 rewrite. Stage 1 (core engine) is complete; Stage 2 (dice mechanics) is largely in place.
+
+### Added
+
+Core engine (Stage 1):
+
+- Lexer and token system ([#3](https://github.com/edloidas/roll-parser/issues/3))
+- Pratt parser and AST types ([#4](https://github.com/edloidas/roll-parser/issues/4))
+- Seedable RNG system with `SeededRNG` (xorshift128) and `MockRNG` helpers ([#5](https://github.com/edloidas/roll-parser/issues/5))
+- AST evaluator with keep/drop modifiers (`kh`, `kl`, `dh`, `dl`) ([#6](https://github.com/edloidas/roll-parser/issues/6))
+- Public `roll(notation, options)` API with `RollResult` / `DieResult` types ([#7](https://github.com/edloidas/roll-parser/issues/7))
+- `roll-parser` CLI with `--help`, `--version`, `--verbose`, `--seed` flags; ESM + CJS dual build ([#8](https://github.com/edloidas/roll-parser/issues/8))
+
+Dice mechanics (Stage 2):
+
+- Percentile dice notation (`d%`) ([#35](https://github.com/edloidas/roll-parser/issues/35))
+- Fate/Fudge dice (`dF`) ([#36](https://github.com/edloidas/roll-parser/issues/36))
+- Math functions: `floor()`, `ceil()`, `round()`, `abs()`, `max()`, `min()` ([#37](https://github.com/edloidas/roll-parser/issues/37))
+- Exploding dice — `!` (standard), `!!` (compound), `!p` (penetrating) — with optional compare points ([#38](https://github.com/edloidas/roll-parser/issues/38))
+- Reroll mechanics (`r`, `ro`) with compare points ([#39](https://github.com/edloidas/roll-parser/issues/39))
+- Success counting / dice pools with `>`, `>=`, `<`, `<=`, `=` operators and `fN` failure tagging ([#40](https://github.com/edloidas/roll-parser/issues/40))
+- PF2e Degrees of Success via the `vs` keyword, with nat-20/1 upgrade/downgrade ([#41](https://github.com/edloidas/roll-parser/issues/41))
+
+### Changed
+
+- **BREAKING:** complete rewrite from v2.x. Public API, semantics, and notation coverage are not compatible with the 2.x line. Pin to `roll-parser@2.3.2` for the legacy implementation.
+- Public API surface trimmed: `Lexer`, `Parser`, `lex`, `TokenType`, `Token`, and mock RNG exports removed from the root entry. `createMockRng` moved to the `roll-parser/testing` subpath. Added typed `RollParserError` base class with `RollParserErrorCode` union and `isRollParserError()` type guard ([#24](https://github.com/edloidas/roll-parser/issues/24))
+
+### Fixed
+
+- Modifier chaining now matches the Roll20 standard: chained modifiers are flattened and each applies independently to the full pool; drop sets are unioned ([#12](https://github.com/edloidas/roll-parser/issues/12))
+- Dice count safety limit via `maxDice` option (default 10,000), enforced across the whole expression to prevent DoS via additive groups like `5000d6+5000d6` ([#19](https://github.com/edloidas/roll-parser/issues/19))
+- Parser and evaluator correctness: duplicate `kept` modifier entries, implicit modifier count defaulting to 1 (`4d6kh` → `4d6kh1`), `critical` flag suppression when `sides === 1`, negative `--seed` CLI values ([#21](https://github.com/edloidas/roll-parser/issues/21))
+
+[Unreleased]: https://github.com/edloidas/roll-parser/compare/v3.0.0-beta.0...HEAD
+[3.0.0-beta.0]: https://github.com/edloidas/roll-parser/releases/tag/v3.0.0-beta.0
+[3.0.0-alpha.0]: https://github.com/edloidas/roll-parser/releases/tag/v3.0.0-alpha.0

package/README.md

@@ -13,34 +13,32 @@ TypeScript-first, Bun-optimized, Pratt parser architecture.
 
 ## Status
 
-> **v3 Alpha** — Stage 1 (Core Engine) is complete with 300+ tests.
-> Stages 2–3 are planned.
+> **v3 Alpha** — Stages 1–3 (core engine, system compatibility, advanced
+> features incl. rich structured `parts` output) are implemented with 1,000+
+> tests, 100% function coverage, and a property-based test suite.
 >
 > For production use, install [v2.3.2](https://www.npmjs.com/package/roll-parser/v/2.3.2).
 
 ## Features
 
-### Stage 1: Core Engine (Complete)
-
-- Basic dice notation: `2d6`, `d20`, `4d6+4`
-- Full arithmetic: `+`, `-`, `*`, `/`, `%`, `**`
-- Parentheses: `(1d4+1)*2`
-- Keep/Drop modifiers: `4d6kh3`, `2d20kl1`, `4d6dl1`
-- Computed dice: `(1+1)d(3*2)`
-- Seedable RNG for reproducible rolls
-
-### Stage 2: System Compatibility (Planned)
-
-- Exploding dice: `1d6!`, `1d6!!`, `1d6!p`
-- Reroll mechanics: `2d6r<2`, `2d6ro<3`
-- Success counting: `10d10>=6`, `10d10>=6f1`
-- Math functions: `floor()`, `ceil()`, `max()`, `min()`
-
-### Stage 3: Advanced Features (Planned)
-
-- Variables: `1d20+@str`, `1d20+@{modifier}`
-- Grouped rolls: `{1d8, 1d10}kh1`
-- Rich JSON output with roll breakdown
+- **Basic dice**: `2d6`, `d20`, `4d6+4`, percentile `d%`, Fate/Fudge `4dF`
+- **Full arithmetic**: `+`, `-`, `*`, `/`, `%`, `**` (also `^`), parentheses
+- **Computed dice**: `(1+1)d(3*2)`, `(1d4)d6`
+- **Keep/Drop**: `4d6kh3`, `2d20kl1`, `4d6dl1`, shorthand `4d6k3`
+- **Exploding dice**: standard `1d6!`, compound `1d6!!`, penetrating `1d6!p`, with compare points `1d6!>=5`
+- **Rerolls**: recursive `2d6r<2`, once `2d6ro<3`
+- **Success counting**: `10d10>=6`, with failure tagging `10d10>=6f1`
+- **PF2e degrees of success**: `1d20+10 vs 25` with nat-20/nat-1 upgrade/downgrade
+- **Math functions**: `floor()`, `ceil()`, `round()`, `abs()`, `max()`, `min()`
+- **Variables**: `1d20+@str`, `1d20+@{sneak attack}`
+- **Grouped rolls**: `{1d8, 1d10}kh1`, `{4d10+5d6}kh2`
+- **Sorting**: `4d6s`, `4d6sd` (display-only)
+- **Crit thresholds**: `1d20cs>=19`, `1d20cf<3` (display-only, independent overrides)
+- **Structured `parts` output**: every result carries a typed evaluation tree mirroring the AST — per-sub-expression totals, dice, resolved thresholds — for chat-log/character-sheet rendering without re-parsing
+- **Source spans**: every AST node and `RollPart` carries `start`/`end` offsets into the notation; evaluator errors point at the exact failing sub-expression
+- **Seedable RNG** (xorshift128) for reproducible rolls, mock RNG for tests
+- **Typed errors** with stable `code`s and input positions
+- **Safety limits**: `maxDice`, `maxExplodeIterations`, `maxRerollIterations`, parse depth cap
 
 ## Installation
 
@@ -49,30 +47,168 @@ bun add roll-parser
 npm install roll-parser
 ```
 
+The package is **ESM-only**. On Node.js ≥ 22 (required), CommonJS consumers
+can still `require('roll-parser')` via `require(esm)`.
+
 ## Usage
 
 ```typescript
 import { roll } from 'roll-parser';
 
 const result = roll('4d6kh3');
-console.log(result.total);    // e.g., 14
-console.log(result.notation); // "4d6kh3"
+result.total;      // e.g. 14
+result.notation;   // '4d6kh3'
+result.rendered;   // '4d6kh3[3, 6, ~~2~~, 5] = 14'
+result.rolls;      // per-die results with kept/dropped/critical flags
+```
+
+### Options
+
+```typescript
+import { roll, SeededRNG } from 'roll-parser';
+
+roll('4d6', { seed: 'character-1' });     // reproducible rolls
+roll('4d6', { rng: new SeededRNG(42) });  // custom RNG instance (takes precedence)
+
+roll('1d20+@str', {
+  context: { str: 4 },                    // variable values
+  onMissingVariable: 'zero',              // or 'throw' (default)
+});
+
+roll('100d6!', {
+  maxDice: 1_000,                         // total dice cap, default 10,000
+  maxExplodeIterations: 100,              // per-die explosion cap, default 1,000
+  maxRerollIterations: 100,               // per-die reroll cap, default 1,000
+});
+```
+
+### Results
+
+| Field | Type | Notes |
+|-------|------|-------|
+| `total` | `number` | Final computed total (always finite — overflow throws) |
+| `notation` | `string` | Original input |
+| `expression` | `string` | Normalized form; meta-expressions render as their resolved values |
+| `rendered` | `string` | Markdown breakdown: `~~n~~` dropped, `**n**` success, `__n__` failure |
+| `rolls` | `DieResult[]` | Every die: `sides`, `result`, `modifiers`, `critical`, `fumble` |
+| `parts` | `RollPart` | Typed evaluation tree mirroring the AST 1:1 (see below) |
+| `successes` / `failures` | `number?` | Present when success counting was used |
+| `degree` / `natural` | `DegreeOfSuccess?` / `number?` | Present for top-level `vs` expressions |
+
+### Structured breakdown (`parts`)
+
+`result.parts` is a discriminated union (16 variants — `dice`, `binaryOp`,
+`modifier`, `versus`, …) where each part holds its own sub-total, resolved
+thresholds/specs, and — for dice parts — the same `DieResult` objects as
+`result.rolls`. JSON-serializable; `parts.total === result.total` always.
+
+```typescript
+const r = roll('4d6kh3 + 2');
+// r.parts = { type: 'binaryOp', operator: '+', total: 16,
+//   left: { type: 'modifier', specs: [{ kind: 'keep', selector: 'highest', count: 3 }],
+//           target: { type: 'dice', count: 4, sides: 6, rolls: [...], ... }, total: 14 },
+//   right: { type: 'literal', value: 2, total: 2 } }
+```
+
+Meta-expressions (`(1d4)d6` counts, computed thresholds) appear as resolved
+numbers in the owning part; their dice live in `result.rolls` tagged `'meta'`.
+
+### Error handling
+
+All errors extend `RollParserError` with a typed `code`
+(e.g. `DICE_LIMIT_EXCEEDED`, `DIVISION_BY_ZERO`, `AMBIGUOUS_DICE_CHAIN`);
+lexer and parser errors also carry the input `position`.
+
+```typescript
+import { isRollParserError } from 'roll-parser';
+
+try {
+  roll(userInput);
+} catch (error) {
+  if (isRollParserError(error)) console.error(error.code, error.message);
+}
+```
+
+### Testing your integrations
+
+```typescript
+import { createMockRng } from 'roll-parser/testing';
+
+const result = roll('3d6', { rng: createMockRng([4, 2, 6]) });
+result.total; // 12 — throws if the roll consumes more values than provided
 ```
 
 ### CLI
 
 ```bash
 roll-parser 2d6+3
-roll-parser 4d6kh3
+roll-parser 4d6kh3 --verbose --seed test
 roll-parser --help
 ```
 
+## Notation reference
+
+| Notation | Meaning |
+|----------|---------|
+| `NdX`, `dX`, `Nd%`, `NdF` | Roll N X-sided / percentile / Fate dice |
+| `khN` `klN` `dhN` `dlN` (`kN`) | Keep/drop highest/lowest N (default 1) |
+| `!` `!!` `!p` | Explode: standard / compound / penetrating (optional `>=T` etc.) |
+| `r<T`, `ro<T` | Reroll recursively / once while condition matches |
+| `>=T`, `>T`, `=T`, `<T`, `<=T` | Count successes against threshold (terminal) |
+| `fT`, `f<T` | Failure threshold after success counting |
+| `vs DC` | PF2e degree of success against a DC |
+| `s`, `sd` | Sort dice ascending/descending (display-only) |
+| `csT`, `cfT` | Override crit/fumble display thresholds independently |
+| `@name`, `@{any name}` | Variable from `context` |
+| `{a, b}khN` | Grouped rolls; keep/drop by sub-roll subtotal |
+| `floor() ceil() round() abs() max() min()` | Math functions |
+
+## Performance
+
+Run `bun bench` for the mitata suite (parse, evaluate, and end-to-end paths).
+Indicative numbers on a modern x86-64 container (Bun 1.3):
+
+| Operation | Time |
+|-----------|------|
+| `parse('2d6+3')` | ~0.4 µs |
+| `roll('1d20+5')` | ~2.5 µs (~400k rolls/s) |
+| `roll('4d6kh3')` | ~5 µs |
+| `evaluate(parse('100d6'))` | ~17 µs |
+
+Numbers include building the structured `parts` tree (always on).
+
 ## Known Limitations
 
-- **`4d6d1` parses as nested dice, not "drop 1".** The bare `d` token is always
-  interpreted as the dice operator, so `4d6d1` becomes `(4d6)d1` (roll 4d6, then
-  use the result as the count for d1). To drop dice, use the explicit `dl`
-  (drop lowest) or `dh` (drop highest) modifiers: `4d6dl1`.
+- **`4d6d1` is a parse error, not "drop 1".** The bare `d` token is the dice
+  operator, and `4d6d1` reading as "roll 4d6, use the result as a count of
+  d1 dice" is a silent trap — so chaining `d` directly onto a dice expression
+  throws `AMBIGUOUS_DICE_CHAIN`. Use `4d6dl1` to drop dice, or `(4d6)d1` for
+  nested dice.
+- **Threshold comparisons bind tight.** In explode and reroll thresholds,
+  `1d6!>=5+2` parses as `(1d6!>=5)+2` — the comparison binds to the dice
+  pool, not the arithmetic after it. For a computed threshold, parenthesize:
+  `1d6!>=(5+2)`. Success-count thresholds bind the same way, but wrapping the
+  resulting `SuccessCountNode` is a parse error (terminal by design), so
+  `1d6>=5+2` throws — parenthesize: `1d6>=(5+2)`.
+- **Meta-expressions in `result.expression` are substituted with their
+  resolved values.** Dice counts, sides, modifier counts, and threshold
+  expressions are rendered as the integer they evaluated to — so
+  `result.expression` does not round-trip through `parse` when
+  meta-expressions are present.
+
+  ```typescript
+  roll('(1d4)d6').expression;       // '2d6' (if 1d4 rolled 2)
+  roll('1d6!>(1d2+3)').expression;  // '1d6!>5'
+  ```
+
+- **Sort flattens additive pools and drops per-pool brackets.** `(2d6+1d8)s`
+  renders the combined pool as one sorted list — `(2d6 + 1d8)s[3, 4, 5]` —
+  rather than the per-pool form `2d6[3, 4] + 1d8[5]`. Totals are preserved;
+  only the rendered breakdown loses pool boundaries.
+- **Outer parens drop from `result.expression` after threshold collapse.**
+  `(1d20cs>19)cs=1` evaluates with `result.expression = '1d20cs>19cs=1'`
+  because chained `cs` thresholds collapse into a single node. The notation
+  re-parses to the same AST; only the textual form differs.
 
 ## License
 

package/dist/cli/args.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"args.d.ts","sourceRoot":"","sources":["../../src/cli/args.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH;;GAEG;AACH,MAAM,MAAM,OAAO,GAAG;IACpB,QAAQ,EAAE,MAAM,GAAG,SAAS,CAAC;IAC7B,OAAO,EAAE,OAAO,CAAC;IACjB,IAAI,EAAE,MAAM,GAAG,SAAS,CAAC;IACzB,QAAQ,EAAE,OAAO,CAAC;IAClB,WAAW,EAAE,OAAO,CAAC;CACtB,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,eAAe,GAAG;IAAE,EAAE,EAAE,IAAI,CAAC;IAAC,IAAI,EAAE,OAAO,CAAA;CAAE,GAAG;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAC;AAEzF;;;;;GAKG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,eAAe,CAyCzD"}
+{"version":3,"file":"args.d.ts","sourceRoot":"","sources":["../../src/cli/args.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH;;GAEG;AACH,MAAM,MAAM,OAAO,GAAG;IACpB,QAAQ,EAAE,MAAM,GAAG,SAAS,CAAC;IAC7B,OAAO,EAAE,OAAO,CAAC;IACjB,IAAI,EAAE,MAAM,GAAG,SAAS,CAAC;IACzB,QAAQ,EAAE,OAAO,CAAC;IAClB,WAAW,EAAE,OAAO,CAAC;CACtB,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,eAAe,GAAG;IAAE,EAAE,EAAE,IAAI,CAAC;IAAC,IAAI,EAAE,OAAO,CAAA;CAAE,GAAG;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAC;AAEzF;;;;;GAKG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,eAAe,CA0CzD"}

package/dist/cli/format.d.ts

@@ -5,7 +5,7 @@
  *
  * @module cli/format
  */
-import type { RollResult } from '../types';
+import type { RollResult } from '../types.js';
 /**
  * Formats a roll result for terminal display.
  *

package/dist/cli/format.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"format.d.ts","sourceRoot":"","sources":["../../src/cli/format.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,UAAU,CAAC;AAE3C;;;;;;;;;GASG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,UAAU,EAAE,OAAO,EAAE,OAAO,GAAG,MAAM,CAMzE"}
+{"version":3,"file":"format.d.ts","sourceRoot":"","sources":["../../src/cli/format.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAE9C;;;;;;;;;GASG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,UAAU,EAAE,OAAO,EAAE,OAAO,GAAG,MAAM,CAMzE"}