aontu 0.50.1 → 0.52.0

package/src/lang.ts

@@ -63,9 +63,18 @@ import {
 
 
 
-import { ScalarKindVal, Integer } from './val/ScalarKindVal'
+import {
+  ScalarKindVal,
+  BigDecimal,
+  BigInteger,
+  Float,
+  Integer,
+} from './val/ScalarKindVal'
 
 
+import { BigDecimalVal } from './val/BigDecimalVal'
+import { BigIntegerVal } from './val/BigIntegerVal'
+import { BIG_LITERAL_RE, readBigLiteral } from './val/Decimal'
 import { BooleanVal } from './val/BooleanVal'
 import { ConjunctVal } from './val/ConjunctVal'
 import { DisjunctVal } from './val/DisjunctVal'
@@ -75,6 +84,7 @@ import { MapVal } from './val/MapVal'
 import { NilVal } from './val/NilVal'
 import { NullVal } from './val/NullVal'
 import { NumberVal } from './val/NumberVal'
+import { isIntegerKind, isLossyIntegerLiteral } from './val/numkind'
 import { PrefVal } from './val/PrefVal'
 import { RefVal } from './val/RefVal'
 import { StringVal } from './val/StringVal'
@@ -92,10 +102,58 @@ import { PrefFuncVal } from './val/PrefFuncVal'
 import { CloseFuncVal } from './val/CloseFuncVal'
 import { OpenFuncVal } from './val/OpenFuncVal'
 import { SuperFuncVal } from './val/SuperFuncVal'
+import {
+  MinConstraintVal,
+  MaxConstraintVal,
+  AboveConstraintVal,
+  BelowConstraintVal,
+  NeqConstraintVal,
+} from './val/ConstraintVal'
 
 
 const asPlugin = (p: unknown): Plugin => p as Plugin
 
+
+// Build the Val for a matched `0d` literal (see the `0d` value matcher
+// below). Leaf by source: digits only is a biginteger, a `.` or an
+// exponent makes it a bigdecimal.
+//
+// A literal over the D6 exactness budget becomes a LOCATED ERROR here
+// and not a rounded or expanded value: `0d1e1000000000` has a one-digit
+// coefficient, so only the scale bound catches it, and it is caught at
+// parse -- before plain-form rendering would try to materialise a
+// gigabyte of zeros.
+// The source text of a negated exact literal. `-` is a prefix OPERATOR,
+// not part of the literal, so the text has to be rebuilt here to keep
+// `src` meaning "how this value is spelled" (see bigVal).
+function negsrc(src: string): string {
+  // src is never empty here: it is a BIG_LITERAL_RE match (at minimum
+  // the two chars `0d`) or an already-negated spelling. Computed exact
+  // values do carry src '', but they are built at unify time, long
+  // after this parse-time opmap.
+  return src.startsWith('-') ? src.slice(1) : '-' + src
+}
+
+
+function bigVal(res: RegExpExecArray): Val {
+  const lit = readBigLiteral(res)
+  // `src` is the literal's own text, and it is not decoration: a path
+  // segment is spelled text, so `$.a.0d1` must address the key `0d1` --
+  // the same key `a:{0d1:7}` creates -- rather than the number 1. See
+  // RefVal.append. Without it the segment was empty and the reference
+  // silently resolved to its own container.
+  const src = res[0]
+  return 'biginteger' === lit.leaf ? new BigIntegerVal({ peg: lit.int, src }) :
+    'bigdecimal' === lit.leaf ? new BigDecimalVal({ peg: lit.dec, src }) :
+      new NilVal({ why: lit.code })
+}
+
+
+// Char codes of the literal's fixed opening, for the guard below.
+const CC_0 = 48
+const CC_d = 100
+const CC_D = 68
+
 let AontuJsonic: Plugin = function AontuLang(jsonic: Jsonic) {
 
   jsonic.use(asPlugin(Path))
@@ -104,6 +162,12 @@ let AontuJsonic: Plugin = function AontuLang(jsonic: Jsonic) {
   // docs/reference-language.md; go/lang.go sets the same). Clear the
   // underlying jsonic comment markers entirely, then define # directly,
   // so the comment set is hash-only regardless of those defaults.
+  let dotRef = (r: Rule, ctx: JsonicContext, terms: any, prefix: boolean) => {
+    terms = dropUnfilled(terms)
+    if (0 === terms.length) return incompleteNil(r, ctx)
+    return addsite(new RefVal({ peg: terms, prefix }), r, ctx)
+  }
+
   jsonic.options({ comment: { def: null } })
   jsonic.options({
     comment: {
@@ -114,6 +178,104 @@ let AontuJsonic: Plugin = function AontuLang(jsonic: Jsonic) {
     },
   })
 
+  // Digit separators are legal only as a SINGLE separator BETWEEN
+  // digits (the rule test/spec/engine-parity.tsv records as the engine's
+  // adjudication; pinned by the sep-* rows in
+  // test/spec/number-model.tsv). The engine's number matcher
+  // enforces most of that already — `1_`, `_1`, `1_.5`, `1._5`, `1e_2`,
+  // `1e2_` all fall through to text — but two gaps remain: a REPEATED
+  // separator (`1__0` lexed as 10) and a separator at the edge of a
+  // base-prefixed digit run (`0x_ff`, `0xff_` lexed as 255). Both
+  // silently accept a typo as a different number, so aontu declines the
+  // whole run instead and it lexes as text ("1__0"), exactly as `1_`
+  // already does.
+  //
+  // `number.exclude` is tested against the matched number source and,
+  // when it matches, makes the matcher decline the entire span. Kept in
+  // lock-step with sepInvalid in go/lang.go, which is wired to the
+  // equivalent `Number.Exclude` hook (and to the Check hook, which
+  // constructs big base-prefixed tokens itself and so bypasses Exclude).
+  jsonic.options({
+    number: {
+      // `__` repeated separator; `0x_`/`0o_`/`0b_` separator opening a
+      // base-prefixed run; `_` closing any run. The prefix letter is
+      // matched case-insensitively so the rule does not depend on which
+      // prefix spellings the engine accepts.
+      exclude: /__|^[-+]?0[xXoObB]_|_$/,
+    },
+  })
+
+  // D3 -- the `0d` literal, the only route to the exact leaves
+  // (biginteger and bigdecimal). See BIG_LITERAL_RE for the grammar and
+  // the leaf-by-source rule.
+  //
+  // The literal is claimed by the TEXT MATCHER'S CHECK HOOK (the sibling
+  // of the `Number.Check` hook the Go port already uses for big
+  // base-prefixed literals), not by a `value.def` entry, because a `0d`
+  // run may contain a `.` and the two claim source differently:
+  //
+  //   - A value def -- even a consuming one, matched against the full
+  //     forward source -- is applied INSIDE the text matcher, AFTER its
+  //     ender regexp has already carved the run at the `.`. The def
+  //     claims `0d1.5` whole, but the matcher then still emits the
+  //     ender's `.` as a fixed token, so `x:0d1.5` lexed as the
+  //     bigdecimal FOLLOWED BY a dangling member-access dot (a path
+  //     cycle). Verified, not theorised.
+  //   - The check hook runs BEFORE that ender regexp and returns the
+  //     token outright, so the run is claimed whole and nothing else is
+  //     emitted.
+  //
+  // A `match.value` matcher (which runs ahead of every other matcher)
+  // also claims it correctly, but it is a candidate at EVERY lex
+  // position and materializes the forward source there: ~8% on a
+  // text-heavy document, for a syntax almost none of them use. The check
+  // hook only runs where the text matcher already runs, and measures at
+  // parity with not having it.
+  //
+  // The number matcher never sees these runs at all: it declines `0d…`
+  // outright, since `d` is not an ender.
+  jsonic.options({
+    text: {
+      check: (lex: any) => {
+        // Guard first, on char codes: this hook runs at every text
+        // position, and the common case (any run that cannot be a `0d`
+        // literal) must cost two char reads and no allocation.
+        const pnt = lex.pnt
+        const src = lex.src
+        if (CC_0 !== src.charCodeAt(pnt.sI)) {
+          return undefined
+        }
+        const c1 = src.charCodeAt(pnt.sI + 1)
+        if (CC_d !== c1 && CC_D !== c1) {
+          return undefined
+        }
+
+        // BIG_LITERAL_RE is `^`-anchored and read against the forward
+        // source (memoized per position by refwd), which is what lets
+        // it claim the `.` of `0d1.5`.
+        const res = BIG_LITERAL_RE.exec(lex.refwd())
+        if (null == res) {
+          return undefined
+        }
+
+        const msrc = res[0]
+        // The token value is a FUNCTION so Val construction happens at
+        // parse time, where the rule and context needed for the site
+        // exist (jsonic calls a #VL token's function value with them).
+        // A `0d` literal never spans a line, so only the source and
+        // column positions advance.
+        const tkn = lex.token(
+          '#VL',
+          (r: Rule, ctx: JsonicContext) => addsite(bigVal(res), r, ctx),
+          msrc,
+          pnt)
+        pnt.sI += msrc.length
+        pnt.cI += msrc.length
+        return { done: true, token: tkn }
+      },
+    },
+  })
+
   // TODO: refactor Val constructor
   // let addsite = (v: Val, p: string[]) => (v.path = [...(p || [])], v)
   let addsite = (v: Val, r: Rule, ctx: JsonicContext) => {
@@ -121,7 +283,8 @@ let AontuJsonic: Plugin = function AontuLang(jsonic: Jsonic) {
     v.site.row = null == r.o0 ? -1 : r.o0.rI
     v.site.col = null == r.o0 ? -1 : r.o0.cI
     v.site.url = ctx.meta.multisource ? ctx.meta.multisource.path : ''
-    v.path = r.k ? [...(r.k.path || [])] : []
+    // A keyed rule always carries a path array; a keyless one has none.
+    v.path = r.k ? [...r.k.path] : []
 
     return v
   }
@@ -161,6 +324,9 @@ help isolate the syntax error.`,
           val: (r: Rule, ctx: JsonicContext) =>
             addsite(new ScalarKindVal({ peg: String }), r, ctx)
         },
+        // `number` is a pure supertype: it matches a concrete value of
+        // any numeric leaf and never tags one itself. `integer` and
+        // `float` are the leaves (see ScalarKindVal for the lattice).
         'number': {
           val: (r: Rule, ctx: JsonicContext) =>
             addsite(new ScalarKindVal({ peg: Number }), r, ctx)
@@ -169,6 +335,21 @@ help isolate the syntax error.`,
           val: (r: Rule, ctx: JsonicContext) =>
             addsite(new ScalarKindVal({ peg: Integer }), r, ctx)
         },
+        'float': {
+          val: (r: Rule, ctx: JsonicContext) =>
+            addsite(new ScalarKindVal({ peg: Float }), r, ctx)
+        },
+        // The two exact leaves. Their keywords are the marker class
+        // names lowercased, which is also how ScalarKindVal canons them.
+        'biginteger': {
+          val: (r: Rule, ctx: JsonicContext) =>
+            addsite(new ScalarKindVal({ peg: BigInteger }), r, ctx)
+        },
+        'bigdecimal': {
+          val: (r: Rule, ctx: JsonicContext) =>
+            addsite(new ScalarKindVal({ peg: BigDecimal }), r, ctx)
+        },
+
         'boolean': {
           val: (r: Rule, ctx: JsonicContext) =>
             addsite(new ScalarKindVal({ peg: Boolean }), r, ctx)
@@ -229,6 +410,16 @@ help isolate the syntax error.`,
     close: CloseFuncVal,
     open: OpenFuncVal,
     super: SuperFuncVal,
+
+    // The constraint algebra's Band A atoms (G1 phase 1;
+    // docs/reference-language.md, "The constraint algebra"): bounds
+    // and exclusion enter through the function registry — the
+    // established extension point — with zero grammar change.
+    min: MinConstraintVal,
+    max: MaxConstraintVal,
+    above: AboveConstraintVal,
+    below: BelowConstraintVal,
+    neq: NeqConstraintVal,
   }
 
 
@@ -249,17 +440,14 @@ help isolate the syntax error.`,
     'disjunct-infix': (r: Rule, ctx: JsonicContext, _op: Op, terms: any) =>
       addsite(new DisjunctVal({ peg: dropUnfilled(terms) }), r, ctx),
 
-    'dot-prefix': (r: Rule, ctx: JsonicContext, _op: Op, terms: any) => {
-      terms = dropUnfilled(terms)
-      if (0 === terms.length) return incompleteNil(r, ctx)
-      return addsite(new RefVal({ peg: terms, prefix: true }), r, ctx)
-    },
+    // `.a` (prefix) and `a.b` (infix) build the same reference; only the
+    // prefix flag differs, and both need the same missing-operand guard,
+    // so they share one builder.
+    'dot-prefix': (r: Rule, ctx: JsonicContext, _op: Op, terms: any) =>
+      dotRef(r, ctx, terms, true),
 
-    'dot-infix': (r: Rule, ctx: JsonicContext, _op: Op, terms: any) => {
-      terms = dropUnfilled(terms)
-      if (0 === terms.length) return incompleteNil(r, ctx)
-      return addsite(new RefVal({ peg: terms }), r, ctx)
-    },
+    'dot-infix': (r: Rule, ctx: JsonicContext, _op: Op, terms: any) =>
+      dotRef(r, ctx, terms, false),
 
     'star-prefix': (r: Rule, ctx: JsonicContext, _op: Op, terms: any) => {
       if (null == terms[0]) return incompleteNil(r, ctx)
@@ -284,6 +472,18 @@ help isolate the syntax error.`,
     'negative-prefix': (r: Rule, ctx: JsonicContext, _op: Op, terms: any) => {
       let val = terms[0]
       if (null == val) return incompleteNil(r, ctx)
+      // The exact leaves negate exactly and never change kind. R2/D5
+      // holds here too: bigint has a single zero, and Decimal's
+      // normalising constructor sends every zero to the same form, so
+      // `-0d0` is `0d0` and `-0d0.0` is `0d0.0`.
+      if (val instanceof BigIntegerVal) {
+        return addsite(new BigIntegerVal(
+          { peg: -val.peg, src: negsrc(val.src) }), r, ctx)
+      }
+      if (val instanceof BigDecimalVal) {
+        return addsite(new BigDecimalVal(
+          { peg: val.peg.negate(), src: negsrc(val.src) }), r, ctx)
+      }
       // Negating a non-numeric operand (`k-x` splits into k, -x) is an
       // error nil, not NaN (mirrors negate() in go/lang.go).
       if (!(val instanceof IntegerVal) && !(val instanceof NumberVal)) {
@@ -296,7 +496,11 @@ help isolate the syntax error.`,
       let peg = -1 * val.peg
       // Normalize -0 to 0 (keeps the AST and canon free of negative zero).
       if (0 === peg) peg = 0
-      const out = val instanceof IntegerVal
+      // Negation never narrows the kind: a number stays a number. An
+      // integer stays an integer unless the negation leaves the int64
+      // range (only -(-2^63), which no literal can express), in which
+      // case it widens to a number rather than failing.
+      const out = val instanceof IntegerVal && isIntegerKind(peg)
         ? new IntegerVal({ peg })
         : new NumberVal({ peg })
       return addsite(out, r, ctx)
@@ -347,6 +551,28 @@ help isolate the syntax error.`,
           right: 21_000_000,
         },
 
+        // Re-base the unary prefixes for the same reason. Every aontu
+        // operator sits far above the @tabnas/expr defaults, so the
+        // default prefix binding power of 4_000_000 left unary `-`/`+`
+        // LOOSER than every infix operator: `-1 & integer` parsed as
+        // `-(1 & integer)`, and negative-prefix (below) then rejected
+        // the composite operand as a `negative` error nil (likewise
+        // `-2+3`, `-1|2`). Unary minus must bind tighter than `+`, `&`
+        // and `|` — but still looser than `.` (dot-infix left is
+        // 25_000_000), so `-0xFF.5` stays `-(0xFF.5)` and `$`.
+        // Kept in lock-step with the op table in go/lang.go.
+        'negative': {
+          src: '-',
+          prefix: true,
+          right: 22_000_000,
+        },
+
+        'positive': {
+          src: '+',
+          prefix: true,
+          right: 22_000_000,
+        },
+
         'dollar-prefix': {
           src: '$',
           prefix: true,
@@ -489,8 +715,28 @@ help isolate the syntax error.`,
           if (!Number.isFinite(r.node)) {
             valnode = addsite(new NilVal({ why: 'not_number' }), r, ctx)
           }
-          // 1.0 in source is *not* an integer
-          else if (Number.isInteger(r.node) && !r.o0.src.includes('.')) {
+          // D7 -- A LOSSY INTEGER LITERAL IS REFUSED, NOT ROUNDED. The
+          // token above is already a double, so a literal the double
+          // cannot hold exactly (2^53+1, 0x7fffffffffffffff,
+          // 0xffffffffffffffff) has ALREADY become a different number by
+          // the time it gets here. Storing it would mean the document
+          // silently means something other than what it says, so the
+          // literal becomes a located error whose hint names the escape:
+          // write it `0d…` and get the exact value.
+          //
+          // The rule is EXACTNESS, not magnitude -- 10^20 and 2^124 are
+          // both far outside the int64 window and both land exactly on a
+          // binary64, so both stay values (see isLossyIntegerLiteral).
+          else if (isLossyIntegerLiteral(r.node, r.o0.src)) {
+            const nil = new NilVal({ why: 'lossy_integer_literal' })
+            nil.details = { src: r.o0.src }
+            valnode = addsite(nil, r, ctx)
+          }
+          // A literal is integer kind only if its source has no '.', its
+          // value is integral, and it fits the int64 range: `1.0` is a
+          // number, and so are 1e21 and 100000000000000000000 (see
+          // isIntegerKind).
+          else if (isIntegerKind(r.node, r.o0.src)) {
             valnode = addsite(new IntegerVal({ peg: r.node, src: r.o0.src }), r, ctx)
           }
           else {
@@ -588,18 +834,10 @@ help isolate the syntax error.`,
           }
         }
 
-        if (ao.___merge) {
-          let aop = [...ao]
-          delete (aop as any).___merge
-
-          // TODO: needs addpath?
-          let aopv = new ListVal({ peg: aop })
-          aopv.optionalKeys = optionalKeys
-
-          r.node =
-            addsite(new ConjunctVal({ peg: [aopv, ...ao.___merge] }), r, ctx)
-        }
-        else {
+        // No ___merge arm here: the deferred map.merge that writes it
+        // only ever fires for a `pair` rule, whose parent is always a
+        // `map` rule with a plain-object node — never a list.
+        {
           r.node = addsite(new ListVal({ peg: ao }), r, ctx)
           r.node.optionalKeys = optionalKeys
         }
@@ -779,7 +1017,10 @@ function makeModelResolver(options: any) {
     jsonic: Tabnas
   ) {
 
-    let path = 'string' === typeof spec ? spec : spec?.peg
+    // The aontu val rule's ac has already wrapped every raw string node
+    // as a StringVal, so spec is a Val here (or a raw object from a
+    // .json/.js include, whose peg is undefined -> not found).
+    let path = spec?.peg
 
     // A bare `@` with no path (`a:@`) has nothing to resolve; report
     // not-found instead of crashing in the underlying resolvers.
@@ -821,6 +1062,34 @@ function makeModelResolver(options: any) {
 // the aontu val rule conversions (mirrors asVal in go/lang.go; like
 // there, source text is unavailable, so an integral number is an
 // integer).
+// The targeted parse hint for CUE-trained authors and models: `>` and
+// `<` are not Aontu operators (the op-chars reservation stands), and an
+// agent that emits `number > 0` should be redirected to the bound
+// atoms, not left with a bare "unexpected character". Appended to a
+// parse error's message when the source carries an unquoted `<` or
+// `>`; the Go twin is opCharHint in go/lang.go, byte-identical text.
+function opCharHint(src: string): string {
+  let q = ''
+  for (let i = 0; i < src.length; i++) {
+    const c = src[i]
+    if ('' !== q) {
+      if (c === q && '\\' !== src[i - 1]) {
+        q = ''
+      }
+      continue
+    }
+    if ('"' === c || '\'' === c || '`' === c) {
+      q = c
+    }
+    else if ('<' === c || '>' === c) {
+      return '\nThe > and < characters are not Aontu operators: write the ' +
+        'bound functions min(x), max(x), above(x), below(x) instead.'
+    }
+  }
+  return ''
+}
+
+
 function rawToVal(n: any): Val {
   if (null == n) {
     return new NullVal({ peg: null })
@@ -836,7 +1105,10 @@ function rawToVal(n: any): Val {
     return new StringVal({ peg: n })
   }
   if ('number' === t) {
-    return Number.isInteger(n) ?
+    // No source text here, so the "no '.'" condition is vacuous and the
+    // integral + int64-range conditions decide (same helper as the val
+    // rule, so the two paths cannot drift).
+    return isIntegerKind(n) ?
       new IntegerVal({ peg: n }) : new NumberVal({ peg: n })
   }
   if ('boolean' === t) {
@@ -940,7 +1212,7 @@ class Lang {
           why: 'parse',
           err: new NilVal({
             why: 'syntax',
-            msg: e.message,
+            msg: e.message + opCharHint(src),
             err: e,
           })
         })
@@ -952,7 +1224,7 @@ class Lang {
 
     return val
   }
-}
+} /* node:coverage ignore next 6 */
 
 export {
   Lang,

package/src/lsp-server.ts

@@ -1,4 +1,3 @@
-#!/usr/bin/env node
 /* Copyright (c) 2025 Richard Rodger, MIT License */
 
 // Aontu Language Server (stdio).
@@ -85,25 +84,28 @@ class FrameCodec {
 }
 
 
-function main() {
+// The streams and exit are injectable (defaulting to real stdio) so the
+// full wiring is unit-testable — the same shape as the Go server's
+// serve(in, out, logw).
+function main(
+  stdin: NodeJS.ReadableStream = process.stdin,
+  write: (chunk: Buffer) => void = (chunk) => void process.stdout.write(chunk),
+  exit: (code: number) => void = (code) => process.exit(code),
+): FrameCodec {
   const handler = new LspHandler()
-  const codec = new FrameCodec(
-    handler,
-    (chunk) => process.stdout.write(chunk),
-    (code) => process.exit(code),
-  )
-
-  process.stdin.on('data', (chunk: Buffer) => codec.push(chunk))
-  process.stdin.on('end', () => codec.end())
-}
+  const codec = new FrameCodec(handler, write, exit)
 
+  stdin.on('data', (chunk: Buffer) => codec.push(chunk))
+  stdin.on('end', () => codec.end())
+  return codec
+} /* node:coverage ignore next 11 */
 
-// Only auto-run when invoked as a program, not when imported by tests.
-if (require.main === module) {
-  main()
-}
+
+// No require.main guard here: bin/aontu-lsp.js is the executable entry
+// and calls main() itself, so this module stays import-only.
 
 
 export {
   FrameCodec,
+  main,
 }

package/src/lsp.ts

@@ -78,8 +78,9 @@ function computeDiagnostics(
   const aontu = new Aontu()
 
   let root: any
+  let ac: any
   try {
-    const ac = aontu.ctx({ collect: true })
+    ac = aontu.ctx({ collect: true })
     if (opts?.vars) {
       Object.assign(ac.vars, opts.vars)
     }
@@ -92,7 +93,21 @@ function computeDiagnostics(
   }
 
   const nils: any[] = []
-  walkNils(root, nils, new Set())
+  const seen = new Set()
+  walkNils(root, nils, seen)
+
+  // Errors recorded on the context but not present in the tree — e.g. a
+  // budget_passes exhaustion nil, which is about the whole evaluation
+  // rather than any node — would otherwise be invisible here, and the
+  // trust contract forbids silent truncation (docs/trust.md clause 2).
+  // Tree nils are already on ctx.err too, so dedup by identity; the
+  // transient disjunct-trial sentinel never surfaces.
+  for (const e of ac.err) {
+    if (e?.isNil && '|:trial-nil' !== e.why && !seen.has(e)) {
+      seen.add(e)
+      nils.push(e)
+    }
+  }
 
   return nils.map(nilToDiagnostic)
 }
@@ -277,8 +292,8 @@ function collectHoverCandidates(
   if (seen.has(v)) return
   seen.add(v)
 
-  const row = v.site?.row ?? -1
-  const col = v.site?.col ?? -1
+  const row = v.site.row
+  const col = v.site.col
   let canon = ''
   try { canon = v.canon } catch { canon = '' }
   // Hover targets concrete values (scalars, kinds, refs, …), not
@@ -305,8 +320,9 @@ function collectHoverCandidates(
 
 
 function hoverMarkdown(val: any): string {
-  let canon = ''
-  try { canon = val.canon } catch { canon = '' }
+  // No try needed: a Val only becomes a hover candidate after
+  // collectHoverCandidates read this same getter successfully.
+  const canon = val.canon
   return '```aontu\n' + canon + '\n```\n\n' + '*' + valKind(val) + '*'
 }
 
@@ -315,11 +331,14 @@ function hoverMarkdown(val: any): string {
 function valKind(val: any): string {
   if (val.isNil) return 'error'
   if (val.isScalarKind) return 'type'
-  if (val.isMap) return 'map'
-  if (val.isList) return 'list'
+  if (val.isConstraint) return 'constraint'
   if (val.isRef) return 'reference'
   if (val.isInteger) return 'integer'
-  if (val.isNumber) return 'number'
+  // NumberVal is the binary64 leaf, whose kind keyword is `float`;
+  // `number` is the supertype and never labels a concrete value.
+  if (val.isNumber) return 'float'
+  if (val.isBigInteger) return 'biginteger'
+  if (val.isBigDecimal) return 'bigdecimal'
   if (val.isString) return 'string'
   if (val.isBoolean) return 'boolean'
   if (val.isScalar) return 'scalar'
@@ -339,15 +358,19 @@ type CompletionItem = {
 const COMPLETION_FUNCTION = 3
 const COMPLETION_KEYWORD = 14
 
-// The twelve built-in functions. Kept in sync with the engine by
+// The seventeen built-in functions. Kept in sync with the engine by
 // `lsp.test.ts`, which asserts each is recognised and no others are.
 const BUILTIN_FUNCS = [
-  'close', 'copy', 'hide', 'key', 'lower', 'move',
-  'open', 'path', 'pref', 'super', 'type', 'upper',
+  'above', 'below', 'close', 'copy', 'hide', 'key', 'lower', 'max',
+  'min', 'move', 'neq', 'open', 'path', 'pref', 'super', 'type', 'upper',
 ]
 
 // Scalar-kind and literal keywords.
-const KIND_KEYWORDS = ['string', 'number', 'integer', 'boolean']
+// `number` is the numeric supertype; `integer`, `float`, `biginteger`
+// and `bigdecimal` are its leaves. New leaves join this list as they land.
+const KIND_KEYWORDS = [
+  'string', 'number', 'integer', 'float', 'biginteger', 'bigdecimal', 'boolean',
+]
 const LITERAL_KEYWORDS = ['true', 'false', 'null', 'top']
 
 
@@ -456,7 +479,7 @@ class LspHandler {
   private publish(uri: string): OutMessage {
     return publishDiagnosticsMsg(uri, computeDiagnostics(this.docs.get(uri) ?? ''))
   }
-}
+} /* node:coverage ignore next 28 */
 
 
 export {

package/src/site.ts

@@ -20,7 +20,7 @@ class Site {
     this.col = site?.col ?? -1
     this.url = site?.url ?? ''
   }
-}
+} /* node:coverage ignore next 6 */
 
 
 export {

package/src/type.ts

@@ -50,7 +50,7 @@ type ValList = Val[]
 type ErrContext = {
   src?: string,
   fs?: FST
-}
+} /* node:coverage ignore next 20 */
 
 export type {
   Val,