aontu 0.46.0 → 0.48.1

package/src/val/LowerFuncVal.ts

@@ -23,7 +23,7 @@ import { FuncBaseVal } from './FuncBaseVal'
 
 
 class LowerFuncVal extends FuncBaseVal {
-  isLower = true
+  isLowerFunc = true
 
   constructor(
     spec: ValSpec,

package/src/val/MapVal.ts

@@ -16,6 +16,7 @@ import { unite } from '../unify'
 
 import {
   propagateMarks,
+  walk,
   explainOpen,
   ec,
   explainClose,
@@ -33,6 +34,54 @@ import { NilVal } from './NilVal'
 import { BagVal } from './BagVal'
 
 
+// Structural snapshots of ref spreads (see MapVal.unify), keyed by the
+// ref's canon + source site rather than object identity: spread
+// application clones templates (and the refs inside them) freely, and a
+// clone must find the snapshot its parse-origin ref captured on an early
+// 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)
+}
+
+// Snapshot a path-dependent ref spread to its structural target once,
+// while inner key()/path() funcs in the target are still unresolved (see
+// the call site comments in MapVal.unify). Shared by the direct
+// application path and the deferred-spread early-snapshot walk.
+function snapshotRefSpread(cj: any, ctx: AontuContext): Val | undefined {
+  let snapmap: Map<string, Val> | undefined = (ctx as any).snapmap
+  if (undefined === snapmap) {
+    // Direct Val.unify use without a Unify run: degrade to a ctx-local
+    // map (snapshots then live only for that subtree, as before).
+    snapmap = new Map()
+    ; (ctx as any).snapmap = snapmap
+  }
+  const sk = spreadSnapKey(cj)
+  let snap: Val | undefined = snapmap.get(sk)
+  if (undefined === snap) {
+    let tgt: Val | undefined = cj.find(ctx)
+    // A ref to a type() resolves to its inner template — snapshot that,
+    // so a type-wrapped ref behaves like a plain-map ref spread.
+    if (tgt && (tgt as any).isTypeFunc) tgt = (tgt as any).peg?.[0]
+    // Only snapshot a found, path-dependent target. If the target is not
+    // present yet (it may be introduced by a later conjunct/merge), do
+    // NOT cache — retry on the next fixpoint pass.
+    if (tgt && tgt.isVal && tgt.isPathDependent) {
+      snap = tgt.clone(ctx)
+      // Clear TYPE marks on the snapshot (recursively): a type() template
+      // constrains values but must not make the spread destination
+      // type-invisible at any depth. HIDE marks are preserved.
+      walk(snap, (_k: any, v: Val) => {
+        v.mark.type = false
+        return v
+      })
+      snapmap.set(sk, snap)
+    }
+  }
+  return snap
+}
+
+
 class MapVal extends BagVal {
   isMap = true
 
@@ -112,12 +161,22 @@ class MapVal extends BagVal {
       }
 
       if (!exit) {
+        // Combine two spread constraints. Identical templates (same canon)
+        // collapse to one: re-unifying them resolves key()/path() at the
+        // shared intermediate path, producing spurious values (f1bb1063).
+        // Distinct templates are unified in place — unite is idempotent,
+        // whereas deferring the distinct case into a fresh ConjunctVal (as
+        // f1bb1063 did) re-wraps every fixpoint pass, growing the conjunct
+        // without bound and non-terminating on real models (the apidef +
+        // sdkgen entity schemas each contribute a `&:` spread with name:key(),
+        // combined here). unite resolves key()/path() at each destination via
+        // spreadClone below, so nested + sibling key() cases stay correct
+        // (test/spec/spread-nested-key, spread-key-all).
         out.spread.cj = null == out.spread.cj ? peer.spread.cj : (
-          null == peer.spread.cj ? out.spread.cj : (
-            out.spread.cj =
-            unite(te ? ctx.clone({ explain: ec(te, 'SPR') }) : ctx,
-              out.spread.cj, peer.spread.cj, 'map-self')
-          )
+          null == peer.spread.cj ? out.spread.cj :
+            out.spread.cj.canon === peer.spread.cj.canon ? out.spread.cj :
+              unite(te ? ctx.clone({ explain: ec(te, 'SPR') }) : ctx,
+                out.spread.cj, peer.spread.cj, 'map-self')
         )
       }
     }
@@ -133,25 +192,69 @@ class MapVal extends BagVal {
 
       let spread_cj = out.spread.cj ?? TOP
 
+      // Snapshot a path-dependent *ref* spread to its structural target
+      // once (while inner key()/path() funcs are still unresolved), so
+      // later fixpoint passes don't re-resolve the ref against the mutated
+      // tree and capture the target's own resolved key()/path() literals,
+      // which would leak the source key into the spread destination.
+      if (spread_cj.isRef && (spread_cj as any).find) {
+        const snap = snapshotRefSpread(spread_cj, ctx)
+        if (snap) spread_cj = snap
+      }
+
+      // A type() used as a spread applies as its inner template: emit the
+      // (constrained) values at each destination rather than marking the
+      // destination as a type. I.e. `&:type({k:key(),x:number})` behaves
+      // like the non-type spread `&:{k:key(),x:number}` — key() resolves
+      // to the destination key, kinds constrain, fields are emitted.
+      if ((spread_cj as any).isTypeFunc) {
+        spread_cj = (spread_cj as any).peg?.[0] ?? TOP
+      }
+
       // Always unify own children first
       for (let key in this.peg) {
-        const keyctx = ctx.descend(key)
-
-        const key_spread_cj = spread_cj.spreadClone(keyctx)
         const child = this.peg[key]
+        const keyctx = ctx.descend(key)
 
         propagateMarks(this, child)
 
-        out.peg[key] =
-          undefined === child ? key_spread_cj :
-            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 :
-                    unite(te ? keyctx.clone({ explain: ec(te, 'KEY:' + key) }) : keyctx,
-                      child, key_spread_cj, 'map-own')
+        // Apply the spread constraint ONCE per child (marked with the
+        // constraint's id below): the first application merges the
+        // template into the child (with key()/path() placeholders that
+        // resolve in place on later passes), so the constraint content
+        // is inside the child from then on and only self-unification is
+        // needed to progress it. Re-applying on every fixpoint pass and
+        // every conjunct-fold step is the identity (unite is idempotent)
+        // 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
+          && (child as any)._spr === (spread_cj as any).id) {
+          oval = child.done ? child :
+            unite(te ? keyctx.clone({ explain: ec(te, 'KEY:' + key) }) : keyctx,
+              child, TOP, 'map-own')
+          ; (oval as any)._spr = (spread_cj as any).id
+        }
+        else {
+          const key_spread_cj = spread_cj.spreadClone(keyctx)
+
+          oval =
+            undefined === child ? key_spread_cj :
+              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 :
+                      unite(te ? keyctx.clone({ explain: ec(te, 'KEY:' + key) }) : keyctx,
+                        child, key_spread_cj, 'map-own')
+
+          if (!spread_cj.isTop && !oval.isNil) {
+            ; (oval as any)._spr = (spread_cj as any).id
+          }
+        }
 
-        done = (done && DONE === out.peg[key].dc)
+        out.peg[key] = oval
+
+        done = (done && DONE === oval.dc)
       }
 
       const allowedKeys: string[] = this.closed ? Object.keys(this.peg) : []
@@ -187,11 +290,20 @@ class MapVal extends BagVal {
                       child, peerchild, 'map-peer')
 
           if (this.spread.cj) {
-            let key_spread_cj = spread_cj.spreadClone(peerctx)
-
-            oval = out.peg[peerkey] =
-              unite(te ? peerctx.clone({ explain: ec(te, 'PSP:' + peerkey) }) : peerctx,
-                oval, key_spread_cj, 'map-peer-spread')
+            // Same apply-once discipline as the own-key loop: once the
+            // constraint is merged into the value (marked with the
+            // constraint's id), later passes only self-unify.
+            if ((oval as any)._spr !== (spread_cj as any).id) {
+              let key_spread_cj = spread_cj.spreadClone(peerctx)
+
+              oval = out.peg[peerkey] =
+                unite(te ? peerctx.clone({ explain: ec(te, 'PSP:' + peerkey) }) : peerctx,
+                  oval, key_spread_cj, 'map-peer-spread')
+
+              if (!spread_cj.isTop && !oval.isNil) {
+                ; (oval as any)._spr = (spread_cj as any).id
+              }
+            }
           }
 
           propagateMarks(this, oval)
@@ -307,7 +419,10 @@ class MapVal extends BagVal {
 
 
   get canon() {
-    let keys = Object.keys(this.peg)
+    // 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()
     return '' +
       // this.errcanon() +
       // (this.mark.type ? '<type>' : '') +

package/src/val/NumberVal.ts

@@ -27,7 +27,9 @@ class NumberVal extends ScalarVal {
     spec: ValSpec,
     ctx?: AontuContext
   ) {
-    if (isNaN(spec.peg)) {
+    // Number.isFinite (not the coercing global isNaN, which lets null/''
+    // through as "numbers") — only an actual finite number is valid.
+    if (!Number.isFinite(spec.peg)) {
       // TODO: use Nil?
       throw new AontuError('not-number: ' + spec.peg)
     }
@@ -47,9 +49,12 @@ class NumberVal extends ScalarVal {
       }
       else if (
         peer.isScalar &&
+        peer.kind === this.kind &&
         peer.peg === this.peg
       ) {
-        out = peer.isInteger ? peer : this
+        // Same kind (both Number) and equal value: integer/float no
+        // longer cross-unify, so peer is necessarily a NumberVal here.
+        out = this
       }
       else if (peer.isTop) {
         out = this

package/src/val/OpBaseVal.ts

@@ -36,7 +36,7 @@ import { FeatureVal } from './FeatureVal'
 
 
 class OpBaseVal extends FeatureVal {
-  isPlusOp = true
+  isOp = true
 
   constructor(
     spec: ValSpec,

package/src/val/ScalarVal.ts

@@ -92,7 +92,9 @@ class ScalarVal extends Val {
 
 
   gen(_ctx?: AontuContext) {
-    return this.peg
+    // Normalize negative zero to 0 for deterministic output (JSON has
+    // no -0, and the Go port produces 0).
+    return Object.is(this.peg, -0) ? 0 : this.peg
   }
 
 

package/src/val/Val.ts

@@ -54,6 +54,12 @@ const SPREAD = Symbol('spread')
 const EMPTY_ERR: any[] = Object.freeze([]) as unknown as any[]
 
 
+// Process-global, monotonic Val id source. Correctness only requires ids
+// to be unique within a single unify run (fast-path identity checks,
+// `same()`), which holds. It is NOT reset between generate() calls, so in
+// a long-running host (e.g. the LSP) it grows for the process lifetime;
+// that is acceptable — an id is a small number and is never used as a
+// memory key. TODO: switch to the per-run ctx.vc counter (see ctx.ts).
 let ID = 1000
 
 
@@ -65,6 +71,7 @@ abstract class Val {
 
   declare isTop: boolean
   declare isNil: boolean
+  declare isNull: boolean
   declare isMap: boolean
   declare isList: boolean
   declare isScalar: boolean
@@ -79,6 +86,7 @@ abstract class Val {
   declare isBoolean: boolean
   declare isConjunct: boolean
   declare isDisjunct: boolean
+  declare isExpect: boolean
   declare isJunction: boolean
 
   // Conjunct sort order. Lower values sort first in norm().
@@ -272,7 +280,14 @@ abstract class Val {
     return v
   }
 
-  // NOTE: MUST not mutate! Val immutability is a critical assumption.
+  // CONTRACT: implementations should treat `this` and `peer` as
+  // immutable and return a new Val. KNOWN EXCEPTION: the MapVal/ListVal
+  // fast-path for a TOP peer returns and refines `this` in place (an
+  // intentional optimization for the fixpoint loop). The practical
+  // consequence is that a parsed/unified tree is SINGLE-USE — do not
+  // re-unify or re-generate the same Val, and do not share it across
+  // threads. The public Aontu.unify/generate entry points re-parse per
+  // call, so this only matters if you hold and reuse a Val yourself.
   unify(_peer: Val, _ctx: AontuContext): Val { return this }
 
   // TODO: indicate marks in some way that is ignored by reparse.
@@ -363,6 +378,7 @@ Object.assign(Val.prototype, {
 
   isTop: false,
   isNil: false,
+  isNull: false,
   isMap: false,
   isList: false,
   isScalar: false,
@@ -377,6 +393,7 @@ Object.assign(Val.prototype, {
   isBoolean: false,
   isConjunct: false,
   isDisjunct: false,
+  isExpect: false,
   isJunction: false,
 
   cjo: 99999,

package/src/val/VarVal.ts

@@ -79,13 +79,15 @@ class VarVal extends FeatureVal {
     if (!(nameVal.isRef) && DONE === nameVal.dc) {
       if (nameVal instanceof StringVal) {
         let found = ctx.vars[nameVal.peg]
-        if (undefined === found) {
-          out = makeNilErr(ctx, 'unknown_var', this, peer)
-        }
 
         // TODO: support complex values
         const ft = typeof found
-        if (null === found) {
+        // Single ladder: a missing var must report `unknown_var` and not
+        // fall through to the `invalid_var_kind` default below.
+        if (undefined === found) {
+          out = makeNilErr(ctx, 'unknown_var', this, peer)
+        }
+        else if (null === found) {
           out = this.place(new NullVal({ peg: null }))
         }
         else if ('string' === ft) {