aontu 0.50.1 → 0.52.0

package/src/val/ListVal.ts

@@ -20,7 +20,6 @@ import {
   explainOpen,
   ec,
   explainClose,
-  items,
 } from '../utility'
 
 import { makeNilErr, AontuError } from '../err'
@@ -33,7 +32,6 @@ import {
 import { ConjunctVal } from './ConjunctVal'
 import { NilVal } from './NilVal'
 import { BagVal } from './BagVal'
-import { empty } from './Val'
 
 
 class ListVal extends BagVal {
@@ -121,9 +119,9 @@ class ListVal extends BagVal {
 
         propagateMarks(this, child)
 
+        // child is non-nullish: propagateMarks above dereferences it.
         out.peg[key] =
-          undefined === child ? key_spread_cj :
-            child.isNil ? child :
+          child.isNil ? child :
               key_spread_cj.isNil ? key_spread_cj :
                 key_spread_cj.isTop && child.done ? child :
                   child.isTop && key_spread_cj.done ? key_spread_cj :
@@ -271,7 +269,7 @@ class ListVal extends BagVal {
           this.peg[k].canon).join(',') +
       ']'
   }
-}
+} /* node:coverage ignore next 8 */
 
 
 

package/src/val/LowerFuncVal.ts

@@ -15,7 +15,8 @@ import { makeNilErr } from '../err'
 
 import { NilVal } from '../val/NilVal'
 import { ScalarKindVal } from '../val/ScalarKindVal'
-import { makeScalar } from '../val/valutil'
+import { makeScalarLike } from '../val/valutil'
+import { Decimal } from '../val/Decimal'
 
 
 
@@ -43,14 +44,30 @@ class LowerFuncVal extends FuncBaseVal {
 
 
   resolve(ctx: AontuContext | undefined, args: Val[]) {
-    const oldpeg = args?.[0].peg
+    // A missing argument (`lower()`) must produce an invalid-arg error
+    // value, as the Go port does — reading .peg off nothing threw a
+    // TypeError that the unifier could only report as an opaque
+    // internal error.
+    const arg = args?.[0]
+    const oldpeg = arg?.peg
     const peg = 'string' === typeof oldpeg ? oldpeg.toLowerCase() :
       'number' === typeof oldpeg ? Math.floor(oldpeg) :
-        undefined
+        // The exact leaves take an EXACT floor and keep their kind: a
+        // biginteger is already integral so it is its own floor, and a
+        // bigdecimal floors by coefficient arithmetic. Math.floor is not
+        // an option for either — it would round the value into binary64
+        // first, which is the loss the `0d` leaves exist to refuse.
+        'bigint' === typeof oldpeg ? oldpeg :
+          oldpeg instanceof Decimal ? oldpeg.floor() :
+            undefined
     const out = this.place(
       null == peg ?
         makeNilErr(ctx, 'invalid-arg', this) :
-        makeScalar(peg)
+        // The floor keeps the ARGUMENT's kind (lower(2) is an integer 2,
+        // lower(1.9) is a number 1) — the function must not narrow
+        // number to integer, and this also makes the actual result kind
+        // agree with the superior() advertised below.
+        makeScalarLike(peg, arg)
     )
     return out
   }
@@ -65,7 +82,7 @@ class LowerFuncVal extends FuncBaseVal {
       super.superior()
   }
 
-}
+} /* node:coverage ignore next 6 */
 
 
 export {

package/src/val/MapVal.ts

@@ -32,6 +32,7 @@ import {
 import { ConjunctVal } from './ConjunctVal'
 import { NilVal } from './NilVal'
 import { BagVal } from './BagVal'
+import { cmpCodePoint } from '../keyorder'
 
 
 // Structural snapshots of ref spreads (see MapVal.unify), keyed by the
@@ -41,7 +42,7 @@ import { BagVal } from './BagVal'
 // pass. The map lives on the unify root ctx (see Unify), so it persists
 // across fixpoint passes and is GC'd with the run.
 function spreadSnapKey(cj: any): string {
-  return cj.canon + '~' + (cj.site?.row ?? -1) + ':' + (cj.site?.col ?? -1)
+  return cj.canon + '~' + cj.site.row + ':' + cj.site.col
 }
 
 // Snapshot a path-dependent ref spread to its structural target once,
@@ -228,7 +229,9 @@ class MapVal extends BagVal {
         // but costs O(keys) deep template clones per pass on large
         // models — the dominant cost on generated-SDK model trees.
         let oval: Val
-        if (undefined !== child && !spread_cj.isTop
+        // No `undefined !== child` here: propagateMarks above already
+        // dereferenced it, so a missing child would have thrown there.
+        if (!spread_cj.isTop
           && (child as any)._spr === (spread_cj as any).id) {
           oval = child.done ? child :
             unite(te ? keyctx.clone({ explain: ec(te, 'KEY:' + key) }) : keyctx,
@@ -238,9 +241,9 @@ class MapVal extends BagVal {
         else {
           const key_spread_cj = spread_cj.spreadClone(keyctx)
 
+          // child is non-nullish: propagateMarks above dereferences it.
           oval =
-            undefined === child ? key_spread_cj :
-              child.isNil ? child :
+            child.isNil ? child :
                 key_spread_cj.isNil ? key_spread_cj :
                   key_spread_cj.isTop && child.done ? child :
                     child.isTop && key_spread_cj.done ? key_spread_cj :
@@ -419,10 +422,11 @@ class MapVal extends BagVal {
 
 
   get canon() {
-    // Keys are emitted alphabetically so the canonical form is
-    // independent of insertion/unification order (and matches the Go
-    // port, whose JSON marshaling also sorts keys).
-    let keys = Object.keys(this.peg).sort()
+    // Keys are emitted in CODE POINT order so the canonical form is
+    // independent of insertion/unification order and matches the Go
+    // port. A bare .sort() is UTF-16 code-unit order, which puts an
+    // astral key ahead of everything in U+E000-U+FFFF -- see cmpCodePoint.
+    let keys = Object.keys(this.peg).sort(cmpCodePoint)
     return '' +
       // this.errcanon() +
       // (this.mark.type ? '<type>' : '') +
@@ -447,7 +451,7 @@ class MapVal extends BagVal {
     return this.spread.cj ? '&:' + this.spread.cj.inspect(null == d ? 0 : d + 1) : ''
   }
 
-}
+} /* node:coverage ignore next 6 */
 
 
 export {

package/src/val/MoveFuncVal.ts

@@ -57,25 +57,42 @@ class MoveFuncVal extends FuncBaseVal {
     if (!orig.isNil) {
       const src = orig.clone(ctx)
 
-      if (src.isRef) {
-        src.mark._hide_found = true
+      // THE HIDE-WALK ONLY RUNS WHEN THE CLONE IS A SEPARATE OBJECT.
+      //
+      // move() is the only function that marks the ORIGINAL rather than
+      // the clone -- that is how the value disappears from its old home
+      // and reappears at the destination. It relies on clone() returning
+      // something distinct to carry to the destination.
+      //
+      // TopVal.clone is the IDENTITY function, so for `move(top)` the
+      // clone and the original are the same object and the walk hid the
+      // very value being returned: the key vanished from generated output
+      // with no error, while canon still showed `x:top` -- the port
+      // disagreeing with itself.
+      //
+      // With the walk skipped, `move(top)` keeps `top` at the destination
+      // and then errors there because top is not generable, which is
+      // already what `x:top`, `x:copy(top)` and `x:pref(top)` do in both
+      // ports, and what `move(number)` does for the same reason.
+      if (src !== orig) {
+        if (src.isRef) {
+          src.mark._hide_found = true
+        }
+
+        walk(orig, (_key: string | number | undefined, val: Val) => {
+          val.mark.hide = true
+          return val
+        })
       }
 
-      walk(orig, (_key: string | number | undefined, val: Val) => {
-        val.mark.hide = true
-        return val
-      })
-
-      // out = new CopyFuncVal({ peg: [src] }, ctx)
       out = new PrefFuncVal({ peg: [src] }, ctx)
-      // out = src
     }
 
     // console.log('MOVE-resolve', orig, out)
 
     return out
   }
-}
+} /* node:coverage ignore next 6 */
 
 
 export {

package/src/val/NilVal.ts

@@ -18,6 +18,8 @@ import { Val, EMPTY_ERR } from './Val'
 
 import { AontuError, descErr } from '../err'
 
+import { codeClass } from '../hints'
+
 
 class NilVal extends Val {
   isNil = true
@@ -98,10 +100,10 @@ class NilVal extends Val {
     if (spec && 'object' === typeof spec) {
       this.why = spec?.why
       this.msg = 'string' === typeof spec?.msg ? spec.msg : this.msg
-      this.err = spec ?
+      this.err =
         Array.isArray(spec.err) ? [...spec.err] :
           null != spec.err ? [spec.err] :
-            EMPTY_ERR : EMPTY_ERR
+            EMPTY_ERR
     }
 
     // Nil is always DONE, by definition.
@@ -135,6 +137,14 @@ class NilVal extends Val {
   }
 
 
+  // The code's class from the shared registry (test/spec/errcodes.tsv):
+  // conflict | incomplete | reference | parse | budget | internal.
+  // A why-less nil classifies as its eventual gen-time code, nil_gen.
+  get class(): string {
+    return codeClass(null == this.why ? 'nil_gen' : String(this.why))
+  }
+
+
   gen(ctx: AontuContext) {
     // Unresolved nil cannot be generated, so always an error.
 
@@ -174,7 +184,7 @@ class NilVal extends Val {
 //
 // Do NOT use this sentinel for errors that may surface: those need
 // real NilVals with proper site/path info for descErr formatting.
-const TRIAL_NIL = new NilVal({ why: '|:trial-nil' })
+const TRIAL_NIL = new NilVal({ why: '|:trial-nil' }) /* node:coverage ignore next 7 */
 
 
 export {

package/src/val/NullVal.ts

@@ -29,7 +29,7 @@ class NullVal extends ScalarVal {
   unify(peer: Val, ctx: AontuContext): Val {
     return super.unify(peer, ctx)
   }
-}
+} /* node:coverage ignore next 7 */
 
 
 export {

package/src/val/NumberVal.ts

@@ -12,6 +12,7 @@ import {
 import { makeNilErr, AontuError } from '../err'
 
 import { ScalarVal } from './ScalarVal'
+import { Float } from './ScalarKindVal'
 
 import {
   explainOpen,
@@ -20,6 +21,10 @@ import {
 
 
 
+// The IEEE-754 binary64 leaf of the number tower. Its KIND is Float (the
+// keyword `float`), not the `number` supertype: `number` names the family
+// of numeric leaves and never tags a concrete value. The class name is
+// historical -- `number` used to name this leaf.
 class NumberVal extends ScalarVal {
   isNumber = true
 
@@ -34,7 +39,7 @@ class NumberVal extends ScalarVal {
       throw new AontuError('not-number: ' + spec.peg)
     }
 
-    super({ ...spec, kind: Number }, ctx)
+    super({ ...spec, kind: Float }, ctx)
   }
 
 
@@ -44,7 +49,7 @@ class NumberVal extends ScalarVal {
     let out: Val = this
 
     if (null != peer) {
-      if (peer.isScalarKind) {
+      if (peer.isScalarKind || (peer as any).isConstraint) {
         out = peer.unify(this, ctx)
       }
       else if (
@@ -52,7 +57,7 @@ class NumberVal extends ScalarVal {
         peer.kind === this.kind &&
         peer.peg === this.peg
       ) {
-        // Same kind (both Number) and equal value: integer/float no
+        // Same kind (both Float) and equal value: integer/float no
         // longer cross-unify, so peer is necessarily a NumberVal here.
         out = this
       }
@@ -72,7 +77,25 @@ class NumberVal extends ScalarVal {
 
     return out
   }
-}
+
+
+  // Canon must round-trip kind: reparsing the canon of a float-kind
+  // value has to yield a float-kind value again. A rendering with no
+  // '.' and no exponent (1 -> "1") would reparse as an integer, so it
+  // gains a ".0" suffix. Renderings that already carry a fraction, an
+  // exponent, or are NaN/Infinity are left alone.
+  //
+  // This is the CANON path only. String coercion inside `+` keeps plain
+  // JS parity ("a"+1.0 is "a1"), so it must not pick up the suffix.
+  get canon() {
+    const s = super.canon
+    return (s.includes('.') ||
+      s.includes('e') ||
+      s.includes('E') ||
+      s.includes('N') ||
+      s.includes('I')) ? s : s + '.0'
+  }
+} /* node:coverage ignore next 6 */
 
 
 export {

package/src/val/OpBaseVal.ts

@@ -67,7 +67,11 @@ class OpBaseVal extends FeatureVal {
 
   unify(peer: Val, ctx: AontuContext): Val {
     const te = ctx.explain && explainOpen(ctx, ctx.explain, 'Op:' + this.opname(), this, peer)
-    let out: Val = this
+    // Declared without an initial value: every arm below assigns it, and
+    // seeding it with `this` made the two arms that stand the op read as
+    // redundant self-assignments. The arms themselves stay as they are —
+    // they mirror the dispatch switch in go/op.go arm for arm (ADR-001).
+    let out: Val
 
     if (this.id == peer.id) {
       return this
@@ -88,16 +92,12 @@ class OpBaseVal extends FeatureVal {
     // console.log('OPVAL', this.id, this.opname(), pegdone, newpeg.map(p => p.canon))
 
     if (pegdone) {
-      let result: Val | undefined = null == ctx ? this : this.operate(ctx, newpeg)
-
-      result = result || this
-
-      if (null == result && this.canon === peer.canon) {
-        out = this
-      }
+      // `|| this` makes result truthy, so an op that cannot compute yet
+      // takes the OpBaseVal arm below rather than a separate null arm.
+      let result: Val = this.operate(ctx, newpeg) || this
 
       // TODO: should be result.isOp
-      else if (result instanceof OpBaseVal) {
+      if (result instanceof OpBaseVal) {
         if (peer.isTop) {
           out = this
         }
@@ -223,7 +223,7 @@ class OpBaseVal extends FeatureVal {
 
     return undefined
   }
-}
+} /* node:coverage ignore next 6 */
 
 
 export {

package/src/val/OpenFuncVal.ts

@@ -52,7 +52,7 @@ class OpenFuncVal extends FuncBaseVal {
     return argval
   }
 
-}
+} /* node:coverage ignore next 6 */
 
 
 export {

package/src/val/PathFuncVal.ts

@@ -45,7 +45,15 @@ class PathFuncVal extends FuncBaseVal {
     let arg = args[0]
 
     if (0 === this.prepared) {
-      if (arg.isScalar) {
+      // A missing argument (`path()`) must produce an invalid-arg error
+      // value, as the Go port does -- reading .isScalar off nothing threw
+      // a TypeError that the unifier could only report as an opaque
+      // internal error. Same discipline breach, and same fix, as the one
+      // UpperFuncVal records; path() was missed in that sweep.
+      if (null == arg) {
+        arg = makeNilErr(ctx, 'invalid-arg', this)
+      }
+      else if (arg.isScalar) {
         arg = this.place(new RefVal({ peg: [arg], absolute: false }))
       }
       else if (!arg.isRef) {
@@ -67,7 +75,7 @@ class PathFuncVal extends FuncBaseVal {
     return out
   }
 
-}
+} /* node:coverage ignore next 6 */
 
 
 export {

package/src/val/PlusOpVal.ts

@@ -12,14 +12,53 @@ import {
 } from '../ctx'
 
 
+import { makeNilErr } from '../err'
 
 import { IntegerVal } from '../val/IntegerVal'
 import { NumberVal } from '../val/NumberVal'
 import { StringVal } from '../val/StringVal'
 import { BooleanVal } from '../val/BooleanVal'
+import { BigIntegerVal } from '../val/BigIntegerVal'
+import { BigDecimalVal } from '../val/BigDecimalVal'
+import { Decimal, decimalOverBudget } from '../val/Decimal'
+import { integerDigits } from '../val/numkind'
+import { isIntegerStorable } from '../val/numkind'
 import { OpBaseVal } from './OpBaseVal'
 
 
+// The operand kinds `+` understands. Anything else (a kind, map, list,
+// null, top, func) is not an operand at all and leaves the op
+// unresolved.
+type OpKind =
+  'string' | 'boolean' | 'integer' | 'float' | 'biginteger' | 'bigdecimal'
+
+
+// D6 -- THE EXACT LADDER: integer < biginteger < bigdecimal. A mixed
+// operation between exact leaves promotes to the WIDEST operand and is
+// computed exactly, so `1 + 0d2` is a biginteger and `1 + 0d0.5` a
+// bigdecimal.
+//
+// `float` is deliberately absent: it is OFF the ladder, keeping only its
+// classic contagion against `integer`. Its absence from this table is
+// what makes the float-with-big pairs fall through to the hard error
+// below rather than promoting.
+//
+// Results NEVER demote: `0d5 + -0d2` stays a biginteger even though 3
+// would fit an int64. Demotion would make the result kind depend on the
+// values rather than on the operand kinds, and a document could then
+// change leaf under a value edit.
+const EXACT_RANK: Record<string, number> = {
+  integer: 1,
+  biginteger: 2,
+  bigdecimal: 3,
+}
+
+
+function isBig(k: OpKind): boolean {
+  return 'biginteger' === k || 'bigdecimal' === k
+}
+
+
 class PlusOpVal extends OpBaseVal {
   isPlusOp = true
 
@@ -40,60 +79,122 @@ class PlusOpVal extends OpBaseVal {
   }
 
 
-  operate(_ctx: AontuContext, args: Val[]) {
+  operate(ctx: AontuContext, args: Val[]) {
     // Only concrete scalar operands are valid: anything else (kinds,
     // maps, lists, null, top, funcs) must not coerce — the JS `+` would
     // leak internals like "[object Object]" into output. A non-scalar
     // operand leaves the op unresolved, which generate() reports.
-    const prim = (v: any) => {
-      // A pref operand contributes its preferred value (`pref(1)+2`).
+    const operand = (v: any) => {
+      // A pref operand contributes its preferred value (`pref(1)+2`),
+      // and therefore that value's kind too.
       while (v?.isPref) {
         v = v.peg
       }
-      const p = v?.isVal && v.isScalar ? v.peg : undefined
-      const t = typeof p
-      return 'string' === t || 'number' === t || 'boolean' === t ? p : undefined
+      return v
     }
-    let a: any = prim(args[0])
-    let b: any = prim(args[1])
 
-    if (undefined === a || undefined === b) {
-      return undefined
+    // The operand's LEAF, not the JavaScript type of its peg: integer
+    // and float share `number`, while the exact leaves are told apart
+    // from each other and from everything else by their own flags. The
+    // whole ladder below dispatches on this and never on `typeof`.
+    const opkind = (v: any): OpKind | undefined => {
+      if (!(v?.isVal && v.isScalar)) {
+        return undefined
+      }
+      if (v.isBigInteger) {
+        return 'biginteger'
+      }
+      if (v.isBigDecimal) {
+        return 'bigdecimal'
+      }
+      if (v.isInteger) {
+        return 'integer'
+      }
+      const t = typeof v.peg
+      return 'number' === t ? 'float' :
+        'string' === t ? 'string' :
+          'boolean' === t ? 'boolean' :
+            undefined
     }
 
-    const at = typeof a
-    const bt = typeof b
+    const av: any = operand(args[0])
+    const bv: any = operand(args[1])
+    const ak = opkind(av)
+    const bk = opkind(bv)
 
-    let peg = undefined
-    if ('boolean' === at && 'boolean' === bt) {
-      peg = a || b
-    }
-    else if ('string' === at || 'string' === bt) {
-      peg = String(a) + String(b)
-    }
-    else if ('boolean' === at || 'boolean' === bt) {
-      // boolean mixed with a number does not coerce (no JS 0/1).
+    if (undefined === ak || undefined === bk) {
       return undefined
     }
-    else {
-      peg = a + b
+
+    if ('boolean' === ak && 'boolean' === bk) {
+      return new BooleanVal({ peg: av.peg || bv.peg })
+    }
+
+    // STRING CONCATENATION RENDERS DIGITS, NOT KIND DECORATION. The `0d`
+    // marker is canon's way of naming the leaf and never belongs in a
+    // string, exactly as R4's `.0` float suffix does not ("q" + 0d0.1 is
+    // "q0.1", and "q" + 1.0 is "q1"). Decimal.toString() is that
+    // marker-free rendering, which is why canon() wraps it rather than
+    // the other way round.
+    if ('string' === ak || 'string' === bk) {
+      return new StringVal({ peg: digits(av, ak) + digits(bv, bk) })
     }
 
-    let pegtype = typeof peg
+    // A boolean mixed with a number does not coerce (no JS 0/1).
+    if ('boolean' === ak || 'boolean' === bk) {
+      return undefined
+    }
 
-    let out = undefined
+    // FLOAT IS OFF THE EXACT LADDER, and mixing it with either big leaf
+    // is a hard error in BOTH operand orders: a big type never silently
+    // becomes a binary float. Promotion the other way is no better —
+    // binary64 cannot hold every exact value, so either direction throws
+    // away exactness the document explicitly asked for by writing `0d`.
+    // The error names both leaves in operand order.
+    if (('float' === ak && isBig(bk)) || (isBig(ak) && 'float' === bk)) {
+      return makeNilErr(ctx, 'exact_float_mix', this, undefined, 'add',
+        { left: ak, right: bk })
+    }
 
-    if ('string' === pegtype) {
-      out = new StringVal({ peg })
+    // Float with float or integer: unchanged R5 contagion, binary64
+    // addition, float result (`1 + 2.0` is `3.0`).
+    if ('float' === ak || 'float' === bk) {
+      return new NumberVal({ peg: av.peg + bv.peg })
     }
-    else if ('boolean' === pegtype) {
-      out = new BooleanVal({ peg })
+
+    // Both operands are on the exact ladder: promote to the widest.
+    const rank = EXACT_RANK[bk] < EXACT_RANK[ak] ? EXACT_RANK[ak] : EXACT_RANK[bk]
+
+    if (EXACT_RANK.bigdecimal === rank) {
+      // Exact scaled-decimal addition. The budget applies to results as
+      // well as literals (D6): an exact sum too wide to hold is refused,
+      // never rounded to fit.
+      const sum = decimal(av, ak).add(decimal(bv, bk))
+      return decimalOverBudget(sum) ?
+        makeNilErr(ctx, 'decimal_budget', this, undefined, 'add') :
+        new BigDecimalVal({ peg: sum })
     }
-    else if ('number' === pegtype) {
-      out = Number.isInteger(peg) ? new IntegerVal({ peg }) : new NumberVal({ peg })
+
+    // integer and biginteger both add as exact integers.
+    const sum = integer(av, ak) + integer(bv, bk)
+
+    if (EXACT_RANK.biginteger === rank) {
+      // Unbounded and exact: nothing to check, and no demotion to
+      // `integer` however small the result.
+      return new BigIntegerVal({ peg: sum })
     }
 
-    return out
+    // INTEGER + INTEGER IS COMPUTED EXACTLY, then offered to the integer
+    // leaf under the same storage contract R1 applies to a literal.
+    // Adding through float64 (as this did) silently rounded sums of
+    // exact operands — 4503599627370496 + 4503599627370497 came back as
+    // …992 — which is precisely the corruption the tower refuses. The
+    // sum that will not fit is an error pointing at `0d`, not a rounded
+    // answer.
+    return isIntegerStorable(sum) ?
+      new IntegerVal({ peg: Number(sum) }) :
+      makeNilErr(ctx, 'inexact_integer_sum', this, undefined, 'add',
+        { sum: sum.toString() })
   }
 
 
@@ -104,6 +205,41 @@ class PlusOpVal extends OpBaseVal {
 }
 
 
+// The digits of an operand for string concatenation: no `0d` marker, no
+// R4 `.0` suffix — the plain rendering of the number, in every leaf.
+//
+// INTEGER KIND GOES THROUGH integerDigits. This was the THIRD site to
+// render an integer-kind peg with JavaScript's shortest round-tripping
+// form, so `"" + 1152921504606846976` produced "1152921504606847000" — a
+// different integer — where Go produced the exact digits. See #21 and
+// integerDigits, which exists so the set of such sites is greppable.
+//
+// The other leaves are already exact or already correct: a bigint
+// stringifies to its exact digits, a Decimal renders its own, and a FLOAT
+// must keep String() because its shortest form is the right answer and is
+// what Go prints too (`"a" + 1.0` is "a1").
+function digits(v: any, k: OpKind): string {
+  return 'bigdecimal' === k ? v.peg.toString() :
+    'integer' === k ? integerDigits(v.peg) :
+      String(v.peg)
+}
+
+
+// An exact-ladder operand as an exact integer. Only reached for the two
+// integral leaves; an `integer` peg is integral by construction, so
+// BigInt() is exact.
+function integer(v: any, k: OpKind): bigint {
+  return 'biginteger' === k ? v.peg : BigInt(v.peg)
+}
+
+
+// An exact-ladder operand as a Decimal, for the promotion to bigdecimal.
+// Scale 0 normalises to the one decimal place the leaf keeps.
+function decimal(v: any, k: OpKind): Decimal {
+  return 'bigdecimal' === k ? v.peg : new Decimal(integer(v, k), 0)
+} /* node:coverage ignore next 6 */
+
+
 export {
   PlusOpVal,
 }

package/src/val/PrefFuncVal.ts

@@ -65,7 +65,7 @@ class PrefFuncVal extends FuncBaseVal {
     return out
   }
 
-}
+} /* node:coverage ignore next 6 */
 
 
 export {