chore lint

Author: arnog

src/api.md

@@ -49,6 +49,19 @@ This interface is augmented by `types-engine.ts` with the concrete
 
 <MemberCard>
 
+##### ExpressionComputeEngine.latexSyntax
+
+```ts
+readonly latexSyntax: ILatexSyntax;
+```
+
+The LatexSyntax instance used for LaTeX parsing/serialization.
+ `undefined` when no LatexSyntax was provided to the constructor.
+
+</MemberCard>
+
+<MemberCard>
+
 ##### ExpressionComputeEngine.True
 
 ```ts
@@ -1913,7 +1926,11 @@ and functions.
 toMathJson(options?): MathJsonExpression
 ```
 
-Serialize to a MathJSON expression with specified options
+Serialize to a MathJSON expression with specified options.
+
+Use `{ fractionalDigits: 'auto' }` to round arbitrary-precision
+numbers to `ce.precision` significant digits. The default
+(`'max'`) emits all available digits with no rounding.
 
 ####### options?
 
@@ -1943,6 +1960,12 @@ For more control over the serialization, use `expr.toMathJson()`.
 
 Note that lazy collections are *not* eagerly evaluated.
 
+For arbitrary-precision numbers, the full raw `BigDecimal` value is
+emitted with no rounding (same as `toJSON()`). This preserves data
+fidelity for round-tripping but may include trailing digits beyond
+`ce.precision` that are not meaningful. Use
+`toMathJson({ fractionalDigits: 'auto' })` for rounded output.
+
 :::info[Note]
 Applicable to canonical and non-canonical expressions.
 :::
@@ -1962,6 +1985,10 @@ Return a LaTeX representation of this expression.
 This is a convenience getter that delegates to the standalone
 `serialize()` function from the `latex-syntax` module.
 
+Numeric values are rounded to `ce.precision` significant digits.
+Noise digits from precision-bounded operations (division,
+transcendentals) are not displayed.
+
 </MemberCard>
 
 <MemberCard>
@@ -1975,6 +2002,8 @@ toLatex(options?): string
 Return a LaTeX representation of this expression with custom
 serialization options.
 
+Numeric values are rounded to `ce.precision` significant digits.
+
 ####### options?
 
 `Record`\<`string`, `any`\>
@@ -3440,6 +3469,12 @@ Note that lazy collections are eagerly evaluated.
 
 Used when coercing a `Expression` to a `String`.
 
+For arbitrary-precision numbers (`BigNumericValue`), the output is
+rounded to `BigDecimal.precision` significant digits. Digits beyond the
+working precision are noise from precision-bounded operations (division,
+transcendentals) and are not displayed. Machine-precision numbers use
+their native `Number.toString()`.
+
 </MemberCard>
 
 <MemberCard>
@@ -3458,6 +3493,12 @@ Based on `Object.toJSON()`.
 
 Note that lazy collections are *not* eagerly evaluated.
 
+The output preserves the full raw `BigDecimal` value with no rounding,
+ensuring lossless round-tripping via `ce.box(expr.json)`. Digits beyond
+`ce.precision` may be present but are not guaranteed to be accurate.
+Use `toMathJson({ fractionalDigits: 'auto' })` for precision-rounded
+MathJSON output.
+
 </MemberCard>
 
 <MemberCard>
@@ -8404,6 +8445,47 @@ type SymbolTable = {
 
 </MemberCard>
 
+### ILatexSyntax
+
+Minimal interface for a LaTeX parser/serializer.
+ Structurally compatible with `LatexSyntax` without importing it.
+
+<MemberCard>
+
+##### ILatexSyntax.parse()
+
+```ts
+parse(latex, options?): MathJsonExpression
+```
+
+####### latex
+
+`string`
+
+####### options?
+
+`Partial`\<[`ParseLatexOptions`](#parselatexoptions)\>
+
+</MemberCard>
+
+<MemberCard>
+
+##### ILatexSyntax.serialize()
+
+```ts
+serialize(expr, options?): string
+```
+
+####### expr
+
+[`MathJsonExpression`](#mathjsonexpression)
+
+####### options?
+
+`Record`\<`string`, `unknown`\>
+
+</MemberCard>
+
 <MemberCard>
 
 ### RuleStep

src/big-decimal/transcendentals.ts

@@ -6,7 +6,18 @@
  */
 
 import { BigDecimal, fromRaw } from './big-decimal';
-import { bigintAbs, fpmul, fpdiv, fpsqrt, fpexp, fpln, fpsincos, fpatan, bigintDigits, pow10 } from './utils';
+import {
+  bigintAbs,
+  fpmul,
+  fpdiv,
+  fpsqrt,
+  fpexp,
+  fpln,
+  fpsincos,
+  fpatan,
+  bigintDigits,
+  pow10,
+} from './utils';
 
 // ---------- Declaration merging ----------
 
@@ -71,10 +82,7 @@ declare module './big-decimal' {
  * `precision` is the number of significant decimal digits in the
  * fixed-point representation.
  */
-function toFixedPoint(
-  x: BigDecimal,
-  precision: number
-): [bigint, bigint] {
+function toFixedPoint(x: BigDecimal, precision: number): [bigint, bigint] {
   const scale = pow10(precision);
   // value = significand * 10^exponent
   // fixed-point = value * scale = significand * 10^(exponent + precision)
@@ -339,10 +347,11 @@ BigDecimal.prototype.log = function (base: BigDecimal | number): BigDecimal {
     return x.exp();
   };
 
-(BigDecimal as unknown as { ln: (x: BigDecimal) => BigDecimal }).ln =
-  function (x: BigDecimal): BigDecimal {
-    return x.ln();
-  };
+(BigDecimal as unknown as { ln: (x: BigDecimal) => BigDecimal }).ln = function (
+  x: BigDecimal
+): BigDecimal {
+  return x.ln();
+};
 
 (BigDecimal as unknown as { log10: (x: BigDecimal) => BigDecimal }).log10 =
   function (x: BigDecimal): BigDecimal {
@@ -398,7 +407,9 @@ BigDecimal.prototype.tan = function (): BigDecimal {
   // tan = sin / cos
   if (cosFp === 0n) {
     // cos = 0 means we're at π/2 + nπ → tan is ±Infinity
-    return sinFp > 0n ? BigDecimal.POSITIVE_INFINITY : BigDecimal.NEGATIVE_INFINITY;
+    return sinFp > 0n
+      ? BigDecimal.POSITIVE_INFINITY
+      : BigDecimal.NEGATIVE_INFINITY;
   }
 
   // Fixed-point division: (sinFp * scale) / cosFp

src/big-decimal/utils.ts

@@ -16,7 +16,10 @@ const _pow10Cache: Map<number, bigint> = new Map();
 export function pow10(n: number): bigint {
   if (n <= 100) {
     let v = _pow10Cache.get(n);
-    if (v === undefined) { v = 10n ** BigInt(n); _pow10Cache.set(n, v); }
+    if (v === undefined) {
+      v = 10n ** BigInt(n);
+      _pow10Cache.set(n, v);
+    }
     return v;
   }
   return 10n ** BigInt(n);
@@ -152,7 +155,10 @@ export function bigintDigits(n: bigint): number {
   while (tmp >> BigInt(high) > 0n) high *= 2;
   // Binary search within [0, high]
   for (let shift = high >> 1; shift >= 1; shift >>= 1) {
-    if (tmp >> BigInt(shift) > 0n) { bits += shift; tmp >>= BigInt(shift); }
+    if (tmp >> BigInt(shift) > 0n) {
+      bits += shift;
+      tmp >>= BigInt(shift);
+    }
   }
   bits += 1;
   const approx = Math.ceil(bits * 0.30102999566398);
@@ -193,14 +199,14 @@ export function fpexp(x: bigint, scale: bigint): bigint {
   sum += term;
 
   for (let n = 2; ; n++) {
-    term = term * r / (BigInt(n) * scale);
+    term = (term * r) / (BigInt(n) * scale);
     if (bigintAbs(term) === 0n) break;
     sum += term;
   }
 
   // Squaring phase: exp(x/scale) = exp(r/scale)^(2^k)
   for (let i = 0; i < k; i++) {
-    sum = sum * sum / scale;
+    sum = (sum * sum) / scale;
   }
 
   return sum;
@@ -229,7 +235,12 @@ export function fpln(x: bigint, scale: bigint): bigint {
   let target = x; // the value we compute ln of (may be reduced)
   let k = 0; // number of sqrt halvings applied
 
-  if (Number.isFinite(xNum) && Number.isFinite(scaleNum) && xNum > 0 && scaleNum > 0) {
+  if (
+    Number.isFinite(xNum) &&
+    Number.isFinite(scaleNum) &&
+    xNum > 0 &&
+    scaleNum > 0
+  ) {
     const ratio = xNum / scaleNum;
     if (Number.isFinite(ratio) && ratio > 0) {
       const approx = Math.log(ratio);
@@ -288,8 +299,13 @@ export function fpln(x: bigint, scale: bigint): bigint {
     const absDelta = bigintAbs(yn - y);
     if (absDelta <= 1n) break;
     // Detect limit cycle: both deltas are small and convergence stalled
-    if (absDelta < 100000n && prevAbsDelta > 0n && prevAbsDelta < 100000n
-      && absDelta * 4n >= prevAbsDelta) break;
+    if (
+      absDelta < 100000n &&
+      prevAbsDelta > 0n &&
+      prevAbsDelta < 100000n &&
+      absDelta * 4n >= prevAbsDelta
+    )
+      break;
     prevAbsDelta = absDelta;
     y = yn;
   }
@@ -341,7 +357,8 @@ export const PI_DIGITS =
 let _fppiCache: { scale: bigint; value: bigint } | null = null;
 
 function fppi(scale: bigint): bigint {
-  if (_fppiCache !== null && _fppiCache.scale === scale) return _fppiCache.value;
+  if (_fppiCache !== null && _fppiCache.scale === scale)
+    return _fppiCache.value;
 
   // Compute PI * scale using the shared PI_DIGITS constant.
   // scale = 10^p, so we need ~p+10 digits of PI.
@@ -475,10 +492,10 @@ export function fpsincos(x: bigint, scale: bigint): [bigint, bigint] {
   for (let n = 2; ; n += 2) {
     // cos term: cosTerm = cosTerm * (-r²) / (n*(n-1)*scale²)
     // But we compute sign explicitly
-    cosTerm = cosTerm * r2 / (BigInt(n) * BigInt(n - 1) * scale2);
+    cosTerm = (cosTerm * r2) / (BigInt(n) * BigInt(n - 1) * scale2);
     if (cosTerm === 0n) {
       // Also check sin at next step
-      sinTerm = sinTerm * r2 / (BigInt(n + 1) * BigInt(n) * scale2);
+      sinTerm = (sinTerm * r2) / (BigInt(n + 1) * BigInt(n) * scale2);
       if (sinTerm !== 0n) {
         if (n % 4 === 2) {
           cosVal -= cosTerm;
@@ -492,7 +509,7 @@ export function fpsincos(x: bigint, scale: bigint): [bigint, bigint] {
     }
 
     // sin term at n+1: sinTerm = sinTerm * r² / ((n+1)*n*scale²)
-    sinTerm = sinTerm * r2 / (BigInt(n + 1) * BigInt(n) * scale2);
+    sinTerm = (sinTerm * r2) / (BigInt(n + 1) * BigInt(n) * scale2);
 
     if (n % 4 === 2) {
       // n=2: subtract for cos (term 2: -r²/2!), subtract for sin (term 3: -r³/3!)
@@ -511,8 +528,8 @@ export function fpsincos(x: bigint, scale: bigint): [bigint, bigint] {
   // sin(2θ) = 2·sin(θ)·cos(θ)
   // cos(2θ) = 2·cos²(θ) - 1
   for (let i = 0; i < k; i++) {
-    const newSin = 2n * sinVal * cosVal / scale;
-    const newCos = 2n * cosVal * cosVal / scale - scale;
+    const newSin = (2n * sinVal * cosVal) / scale;
+    const newCos = (2n * cosVal * cosVal) / scale - scale;
     sinVal = newSin;
     cosVal = newCos;
   }
@@ -549,13 +566,13 @@ export function fpatan(x: bigint, scale: bigint): bigint {
   // If x/scale > 1, use atan(x/scale) = π/2 - atan(scale/x)
   // In fixed-point: atan(x, scale) = halfPi - atan(scale² / x, scale)
   if (x > scale) {
-    const reciprocal = scale * scale / x; // scale²/x represents scale/x in fp
+    const reciprocal = (scale * scale) / x; // scale²/x represents scale/x in fp
     return halfPi - fpatan(reciprocal, scale);
   }
 
   // Halving: if x > 0.4 * scale, use atan(x) = 2*atan(x / (1 + sqrt(1 + x²)))
   // In fixed-point: threshold = 4*scale/10
-  const threshold = 4n * scale / 10n;
+  const threshold = (4n * scale) / 10n;
   let halvings = 0;
   let r = x;
 
@@ -568,7 +585,7 @@ export function fpatan(x: bigint, scale: bigint): bigint {
     const r2 = r * r;
     const val = (scale * scale + r2) / scale;
     const sqrtVal = fpsqrt(val, scale); // sqrt(1 + t²) * scale
-    r = r * scale / (scale + sqrtVal);
+    r = (r * scale) / (scale + sqrtVal);
     halvings++;
   }
 
@@ -581,7 +598,7 @@ export function fpatan(x: bigint, scale: bigint): bigint {
   const scale2 = scale * scale; // hoisted: saves one bigint multiply per term
 
   for (let n = 3; ; n += 2) {
-    term = term * r2 / scale2;
+    term = (term * r2) / scale2;
     if (term === 0n) break;
     // Late division by n: the per-term truncation error is < 1 ULP each,
     // so total error is bounded by ~nTerms/2 ULP — well within the 15 guard digits.

src/common/one-of.ts

@@ -3,7 +3,7 @@
 // eslint-disable-next-line @typescript-eslint/no-empty-object-type
 type MergeTypes<TypesArray extends any[], Res = {}> = TypesArray extends [
   infer Head,
-  ...infer Rem
+  ...infer Rem,
 ]
   ? MergeTypes<Rem, Res & Head>
   : Res;
@@ -12,7 +12,7 @@ type MergeTypes<TypesArray extends any[], Res = {}> = TypesArray extends [
 export type OneOf<
   TypesArray extends any[],
   Res = never,
-  AllProperties = MergeTypes<TypesArray>
+  AllProperties = MergeTypes<TypesArray>,
 > = TypesArray extends [infer Head, ...infer Rem]
   ? OneOf<Rem, Res | OnlyFirst<Head, AllProperties>, AllProperties>
   : Res;

src/common/type/parse.ts

@@ -265,7 +265,7 @@ class TypeParser {
     required: NamedElement[],
     optional: NamedElement[],
     variadic: NamedElement | undefined,
-    variadicMin: 0 | 1 | undefined
+    variadicMin: 0 | 1 | undefined,
   ] {
     const reqArgs: NamedElement[] = [];
     const optArgs: NamedElement[] = [];

src/compute-engine/boxed-expression/arithmetic-add.ts

@@ -444,7 +444,6 @@ function nvSum(
   ce: ComputeEngine,
   numericValues: NumericValue[]
 ): NumericValue[] {
-  const makeExact = (x) => new ExactNumericValue(x, factory);
   const factory =
     ce.precision > MACHINE_PRECISION
       ? (x) => new BigNumericValue(x)

src/compute-engine/boxed-expression/ascii-math.ts

@@ -92,7 +92,7 @@ const OPERATORS: Record<
   string,
   [
     string | ((x: Expression, AsciiMathSerializer) => string),
-    precedence: number
+    precedence: number,
   ]
 > = {
   Add: [