aontu 0.50.1 → 0.52.0

package/src/unify.ts

@@ -205,6 +205,30 @@ function update(x: Val, _y: Val) {
 }
 
 
+// The still-refining paths named by a budget_passes error: the first
+// `max` non-done nodes of the residue, as `$.dotted.paths`. Depth-first
+// over bag children only -- this feeds an error message, not a report,
+// so a small deterministic sample beats completeness.
+function residuePaths(v: Val, max: number): string[] {
+  const out: string[] = []
+  const visit = (n: any, isroot: boolean) => {
+    if (null == n || max <= out.length) {
+      return
+    }
+    if (!isroot && !n.done) {
+      out.push('$' + (0 < (n.path?.length ?? 0) ? '.' + n.path.join('.') : ''))
+    }
+    if (n.isMap || n.isList) {
+      for (const k in n.peg) {
+        visit(n.peg[k], false)
+      }
+    }
+  }
+  visit(v, true)
+  return out
+}
+
+
 class Unify {
   root: Val
   res: Val
@@ -264,6 +288,7 @@ class Unify {
 
       // NOTE: if true === res.done already, then this loop never needs to run.
       let maxcc = 9 // 99
+      let prevCanon: string | undefined = undefined
       for (; this.cc < maxcc && DONE !== res.dc; this.cc++) {
         // console.log('CC', this.cc, res.canon)
         uctx.cc = this.cc
@@ -274,15 +299,41 @@ class Unify {
           break
         }
 
+        // Snapshot the second-to-last pass's result, so exhaustion can
+        // tell "still refining" from "stable residue" below. Only paid
+        // by models still unresolved this late.
+        if (this.cc === maxcc - 2 && DONE !== res.dc) {
+          prevCanon = res.canon
+        }
+
         uctx = uctx.clone({ root: res })
       }
 
+      // The pass budget is spent AND the final pass still made
+      // progress: the model was cut off while converging, and no other
+      // error explains why. Silent truncation would surface later as
+      // ordinary incompleteness, so exhaustion is a semantic error of
+      // its own (class budget, docs/trust.md clause 2) -- retrying with
+      // a larger budget is a valid response to THIS code and useless
+      // for path_cycle or no_path. A STABLE residue (the final pass
+      // changed nothing -- e.g. a stuck `1+true`) is not a budget
+      // failure: it is ordinary incompleteness and stays silent here,
+      // surfacing at generate exactly as before.
+      if (maxcc <= this.cc && DONE !== res.dc && 0 === uctx.err.length
+        && undefined !== prevCanon && prevCanon !== res.canon) {
+        makeNilErr(uctx, 'budget_passes', undefined, undefined, 'resolve', {
+          budget: 'passes',
+          limit: maxcc,
+          paths: residuePaths(res, 4).join(' ') || '$',
+        })
+      }
+
       uctx.explain && explainClose(te, res)
     }
 
     this.res = res
   }
-}
+} /* node:coverage ignore next 9 */
 
 
 

package/src/utility.ts

@@ -84,6 +84,8 @@ function walk(
 
   // Container Vals (Map etc) have peg = plain {} or []
   if (null != child && !child.isVal) {
+    // A ListVal's array peg is an object too, and for-in yields its
+    // indices as string keys, so this one loop covers both bag shapes.
     if ('object' === typeof child) {
       for (let ckey in child) {
         if (child[ckey] && child[ckey].isVal) {
@@ -92,14 +94,6 @@ function walk(
         }
       }
     }
-    else if (Array.isArray(child)) {
-      for (let i = 0; i < child.length; i++) {
-        if (child[i] && child[i].isVal) {
-          child[i] = walk(
-            child[i], before, after, maxdepth, i, out, [...(path || []), '' + i])
-        }
-      }
-    }
   }
 
   out = null == after ? out : after(key, out, parent, path || [])
@@ -194,7 +188,7 @@ function items(o: any) {
   else {
     return []
   }
-}
+} /* node:coverage ignore next 15 */
 
 
 export {

package/src/val/BagVal.ts

@@ -20,6 +20,7 @@ import { Val } from './Val'
 import { NilVal } from './NilVal'
 import { FeatureVal } from './FeatureVal'
 import { ExpectVal } from './ExpectVal'
+import { cmpCodePoint } from '../keyorder'
 
 
 abstract class BagVal extends FeatureVal {
@@ -65,15 +66,17 @@ abstract class BagVal extends FeatureVal {
       return undefined
     }
 
-    // Maps emit their keys alphabetically so the generated output is
-    // independent of insertion/unification order (and matches the Go
-    // port, whose JSON marshaling also sorts map keys). Lists keep their
-    // numeric index order.
+    // Maps emit their keys in CODE POINT order so the generated output
+    // is independent of insertion/unification order and matches the Go
+    // port. Lists keep their numeric index order.
+    //
+    // The keys are String()-coerced because a list entry carries a
+    // numeric index here; the coercion is a no-op for every map key.
     let entries = items(this.peg)
     if (this.isMap) {
       entries = entries
         .slice()
-        .sort((a: any, b: any) => (a[0] < b[0] ? -1 : a[0] > b[0] ? 1 : 0))
+        .sort((a: any, b: any) => cmpCodePoint(String(a[0]), String(b[0])))
     }
 
     for (let item of entries) {
@@ -175,7 +178,7 @@ abstract class BagVal extends FeatureVal {
     return out
   }
 
-}
+} /* node:coverage ignore next 6 */
 
 
 export {

package/src/val/BigDecimalVal.ts

@@ -0,0 +1,117 @@
+/* Copyright (c) 2025 Richard Rodger, MIT License */
+
+import type {
+  Val,
+  ValSpec,
+} from '../type'
+
+import {
+  AontuContext,
+} from '../ctx'
+
+import { makeNilErr, AontuError } from '../err'
+
+import { ScalarVal } from './ScalarVal'
+import { BigDecimal } from './ScalarKindVal'
+import { Decimal } from './Decimal'
+
+import {
+  explainOpen,
+  ec,
+  explainClose,
+} from '../utility'
+
+
+// The exact base-10 decimal leaf of the number tower, reached only by a
+// `0d` literal carrying a `.` or an exponent (`0d1.5`, `0d1e3`) or by
+// direct construction.
+//
+// Its peg is a Decimal -- an OBJECT, so unlike every other scalar leaf
+// its identity cannot be `===` on the peg. Two bigdecimals are the same
+// value when their NUMBERS are equal (D2), which normalisation at
+// construction reduces to a two-field comparison; `samePeg` and `unify`
+// below are the two places that must not forget it.
+class BigDecimalVal extends ScalarVal {
+  isBigDecimal = true
+
+  declare peg: Decimal
+
+  constructor(
+    spec: ValSpec,
+    ctx?: AontuContext
+  ) {
+    // Exact-input construction (D8): a Decimal, or a decimal literal as
+    // text (`'1.5'`, `'0d1e3'`). A JS `number` is deliberately NOT
+    // accepted -- binary64 has already rounded it, so `0.1` could never
+    // arrive exact.
+    let peg = spec.peg
+    if ('string' === typeof peg) {
+      try {
+        peg = Decimal.fromString(peg)
+      }
+      catch {
+        // Includes a budget refusal (Decimal.fromString enforces D6),
+        // so an over-budget string cannot enter through this route
+        // either.
+        throw new AontuError('not-bigdecimal: ' + spec.peg)
+      }
+    }
+    if (!(peg instanceof Decimal)) {
+      throw new AontuError('not-bigdecimal: ' + peg)
+    }
+
+    super({ ...spec, peg, kind: BigDecimal }, ctx)
+  }
+
+
+  unify(peer: any, ctx: AontuContext): Val {
+    const te = ctx.explain && explainOpen(ctx, ctx.explain, 'BigDecimal', this, peer)
+
+    let out: Val = this
+
+    if (null != peer) {
+      if (peer.isScalarKind || (peer as any).isConstraint) {
+        out = peer.unify(this, te ? ctx.clone({ explain: ec(te, 'KND') }) : ctx)
+      }
+      else if (
+        peer.isScalar &&
+        peer.kind === this.kind &&
+        this.peg.equals(peer.peg)
+      ) {
+        // Same kind and equal NUMBER. Never `peer.peg === this.peg`:
+        // that is object identity, and `0d0.10 & 0d0.1` (two Decimals
+        // holding one value) has to succeed.
+        out = this
+      }
+      else if (peer.isTop) {
+        out = this
+      }
+      else {
+        out = makeNilErr(ctx, 'scalar_' +
+          ((peer as any).kind === this.kind ? 'value' : 'kind'), this, peer)
+      }
+    }
+    else {
+      out = super.unify(peer, ctx)
+    }
+
+    explainClose(te, out)
+
+    return out
+  }
+
+
+  samePeg(peg: any): boolean {
+    return peg instanceof Decimal && this.peg.equals(peg)
+  }
+
+
+  get canon() {
+    return this.peg.canon()
+  }
+} /* node:coverage ignore next 6 */
+
+
+export {
+  BigDecimalVal,
+}

package/src/val/BigIntegerVal.ts

@@ -0,0 +1,110 @@
+/* Copyright (c) 2025 Richard Rodger, MIT License */
+
+import type {
+  Val,
+  ValSpec,
+} from '../type'
+
+import {
+  AontuContext,
+} from '../ctx'
+
+import { makeNilErr, AontuError } from '../err'
+
+import { ScalarVal } from './ScalarVal'
+import { BigInteger } from './ScalarKindVal'
+
+import {
+  explainOpen,
+  ec,
+  explainClose,
+} from '../utility'
+
+
+// The unbounded exact integer leaf of the number tower, reached only by
+// a `0d` literal with no fraction and no exponent (`0d5`, `-0d5`,
+// `0d123456789012345678901234567890`) or by direct construction.
+//
+// Its peg is a native bigint: exact at any magnitude, immutable, and
+// compared by VALUE with `===` (D2 -- two separately built bigints
+// holding the same number are `===`, which is exactly the property the
+// Go port has to reproduce by hand for `*big.Int`).
+//
+// `biginteger` is DISJOINT from `integer`: `5 & 0d5` is an error, since
+// a successful meet would have to pick one of the two kinds and either
+// choice makes `&` asymmetric in kind.
+class BigIntegerVal extends ScalarVal {
+  isBigInteger = true
+
+  declare peg: bigint
+
+  constructor(
+    spec: ValSpec,
+    ctx?: AontuContext
+  ) {
+    // Exact-input construction (D8): a bigint, or the digits as text. A
+    // JS `number` is deliberately NOT accepted -- it has already been
+    // rounded before this library could inspect it, so an exact value
+    // above 2^53 could never arrive that way intact.
+    let peg = spec.peg
+    if ('string' === typeof peg) {
+      if (!/^[-+]?[0-9]+$/.test(peg)) {
+        throw new AontuError('not-biginteger: ' + peg)
+      }
+      peg = BigInt(peg)
+    }
+    if ('bigint' !== typeof peg) {
+      throw new AontuError('not-biginteger: ' + peg)
+    }
+
+    super({ ...spec, peg, kind: BigInteger }, ctx)
+  }
+
+
+  unify(peer: any, ctx: AontuContext): Val {
+    const te = ctx.explain && explainOpen(ctx, ctx.explain, 'BigInteger', this, peer)
+
+    let out: Val = this
+
+    if (null != peer) {
+      if (peer.isScalarKind || (peer as any).isConstraint) {
+        out = peer.unify(this, te ? ctx.clone({ explain: ec(te, 'KND') }) : ctx)
+      }
+      else if (
+        peer.isScalar &&
+        peer.kind === this.kind &&
+        peer.peg === this.peg
+      ) {
+        // Same kind and equal NUMBER (bigint `===` is value equality).
+        out = this
+      }
+      else if (peer.isTop) {
+        out = this
+      }
+      else {
+        out = makeNilErr(ctx, 'scalar_' +
+          ((peer as any).kind === this.kind ? 'value' : 'kind'), this, peer)
+      }
+    }
+    else {
+      out = super.unify(peer, ctx)
+    }
+
+    explainClose(te, out)
+
+    return out
+  }
+
+
+  // The sign renders BEFORE the marker (`-0d5`): `0d-5` is not a literal
+  // this language accepts, so canon must not produce it.
+  get canon() {
+    const neg = this.peg < 0n
+    return (neg ? '-0d' : '0d') + (neg ? -this.peg : this.peg).toString()
+  }
+} /* node:coverage ignore next 6 */
+
+
+export {
+  BigIntegerVal,
+}

package/src/val/BooleanVal.ts

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

package/src/val/CloseFuncVal.ts

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

package/src/val/ConjunctVal.ts

@@ -279,7 +279,7 @@ function norm(terms: Val[]): Val[] {
 
 
   return expand
-}
+} /* node:coverage ignore next 7 */
 
 
 export {