aontu 0.43.0 → 0.45.1

package/src/val/MapVal.ts

@@ -8,6 +8,7 @@ import type {
 
 import {
   DONE,
+  SPREAD,
 } from '../type'
 
 import { AontuContext } from '../ctx'
@@ -27,13 +28,13 @@ import {
 } from './top'
 
 
+import { ConjunctVal } from './ConjunctVal'
 import { NilVal } from './NilVal'
 import { BagVal } from './BagVal'
 
 
 class MapVal extends BagVal {
   isMap = true
-  _canonCache?: string
 
   constructor(
     spec: ValSpec,
@@ -47,6 +48,23 @@ class MapVal extends BagVal {
 
     this.mark.type = !!spec.mark?.type
     this.mark.hide = !!spec.mark?.hide
+
+    let spread = (this.peg as any)[SPREAD]
+    delete (this.peg as any)[SPREAD]
+
+    if (spread) {
+      if ('&' === spread.o) {
+        // TODO: handle existing spread!
+        this.spread.cj =
+          Array.isArray(spread.v) ?
+            1 < spread.v.length ?
+              new ConjunctVal({ peg: spread.v }, ctx) :
+              spread.v[0] :
+            spread.v
+      }
+    }
+
+    // console.log('MAPVAL-ctor', this.type, spec)
   }
 
 
@@ -57,23 +75,6 @@ class MapVal extends BagVal {
 
     const TOP = top()
     peer = peer ?? TOP
-
-    // Fast path: both maps done, no spreads, peer's keys are a
-    // subset of this's keys with the same child references, and
-    // neither side has type/hide marks. No new information.
-    if (this.done && peer instanceof MapVal && peer.done
-        && !this.mark.type && !this.mark.hide
-        && !peer.mark.type && !peer.mark.hide) {
-      let canSkip = true
-      for (const k in peer.peg) {
-        if (this.peg[k] !== peer.peg[k]) {
-          canSkip = false
-          break
-        }
-      }
-      if (canSkip) return this
-    }
-
     const te = ctx.explain && explainOpen(ctx, ctx.explain, 'Map', this, peer)
 
     let done: boolean = true
@@ -83,7 +84,8 @@ class MapVal extends BagVal {
     let out: MapVal | NilVal = (peer.isTop ? this : new MapVal({ peg: {} }, ctx))
 
     out.closed = this.closed
-    out.optionalKeys = 0 < this.optionalKeys.length ? [...this.optionalKeys] : this.optionalKeys
+    out.optionalKeys = [...this.optionalKeys]
+    out.spread.cj = this.spread.cj
     out.site = this.site
 
     if (peer instanceof MapVal) {
@@ -106,47 +108,53 @@ class MapVal extends BagVal {
           out = peer.unify(this, te ? ctx.clone({ explain: ec(te, 'SPC') }) : ctx) as MapVal
           exit = true
         }
+
       }
+
+      if (!exit) {
+        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')
+          )
+        )
+      }
+    }
+    else {
+      // console.log('MAPVAL-PEER-OTHER', this.id, this.canon, this.done, peer.id, peer.canon, peer.done)
     }
 
 
     if (!exit) {
       out.dc = this.dc + 1
 
-      // Fast path: self-unify with TOP.
-      // If all children are already done, the map is fully converged.
-      if (peer.isTop) {
-        let allChildrenDone = true
-        for (let key in this.peg) {
-          if (DONE !== this.peg[key]?.dc) {
-            allChildrenDone = false
-            break
-          }
-        }
-        if (allChildrenDone) {
-          out.dc = DONE
-          ctx.explain && explainClose(te, out)
-          return out
-        }
-      }
+      // let newtype = this.type || peer.type
+
+      let spread_cj = out.spread.cj ?? TOP
 
-      // Unify own children
+      // Always unify own children first
       for (let key in this.peg) {
-        const child = this.peg[key]
         const keyctx = ctx.descend(key)
 
+        const key_spread_cj = spread_cj.spreadClone(keyctx)
+        const child = this.peg[key]
+
         propagateMarks(this, child)
 
         out.peg[key] =
-          undefined === child ? top() :
+          undefined === child ? key_spread_cj :
             child.isNil ? child :
-              child.done ? child :
-                unite(te ? keyctx.clone({ explain: ec(te, 'KEY:' + key) }) : keyctx,
-                  child, top(), 'map-own')
+              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')
 
         done = (done && DONE === out.peg[key].dc)
       }
 
+      const allowedKeys: string[] = this.closed ? Object.keys(this.peg) : []
       let bad: NilVal | undefined = undefined
 
       if (peer instanceof MapVal) {
@@ -157,14 +165,12 @@ class MapVal extends BagVal {
         for (let peerkey in upeer.peg) {
           let peerchild = upeer.peg[peerkey]
 
-          if (this.closed && !(peerkey in this.peg)) {
+          if (this.closed && !allowedKeys.includes(peerkey)) {
             bad = makeNilErr(ctx, 'closed', peerchild, undefined)
           }
 
           // key optionality is additive
-          if (0 < upeer.optionalKeys.length
-              && upeer.optionalKeys.includes(peerkey)
-              && !out.optionalKeys.includes(peerkey)) {
+          if (upeer.optionalKeys.includes(peerkey) && !out.optionalKeys.includes(peerkey)) {
             out.optionalKeys.push(peerkey)
           }
 
@@ -174,11 +180,19 @@ class MapVal extends BagVal {
 
           let oval = out.peg[peerkey] =
             undefined === child ? this.handleExpectedVal(peerkey, peerchild, this, ctx) :
-                child.isTop && peerchild.done ? peerchild :
-                  child.isNil ? child :
-                    peerchild.isNil ? peerchild :
-                      unite(te ? peerctx.clone({ explain: ec(te, 'CHD') }) : peerctx,
-                        child, peerchild, 'map-peer')
+              child.isTop && peerchild.done ? peerchild :
+                child.isNil ? child :
+                  peerchild.isNil ? peerchild :
+                    unite(te ? peerctx.clone({ explain: ec(te, 'CHD') }) : peerctx,
+                      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')
+          }
 
           propagateMarks(this, oval)
 
@@ -199,41 +213,66 @@ class MapVal extends BagVal {
         out.dc = done ? DONE : out.dc
         propagateMarks(peer, out)
         propagateMarks(this, out)
-
       }
     }
 
+    // console.log(
+    //   'MAPVAL-OUT', out.canon,
+    //   '\n  SELF', this,
+    //   '\n  PEER', peer,
+    //   '\n  OUT', out,
+    //   '\n  FROM', (out as any).spread.cj
+    // )
+
     ctx.explain && explainClose(te, out)
 
     return out
   }
 
 
-  // Optimized clone for use as a spread constraint: share
-  // path-independent children, clone only path-dependent ones.
+  // Spread clone: return a Val usable as the per-key spread constraint.
+  //
+  // Three tiers:
+  //   1. tree is path-independent (no RefVal/KeyFuncVal/PathFuncVal/
+  //      MoveFuncVal/SuperFuncVal anywhere below): return `this` directly.
+  //      Nothing in the unify path mutates the spread root, and no
+  //      child depends on its own stored .path, so sharing is safe.
+  //   2. top-level children are all ScalarKindVal: shallow clone
+  //      (share children, fresh MapVal wrapper).
+  //   3. otherwise: full deep clone via `this.clone(ctx)`.
+  //
+  // Tier 1 handles the foo-sdk common case of simple type-constraint
+  // spreads like `&:{active: *true | boolean, version: *'0.0.1' | string}`,
+  // which are cloned thousands of times per run.
   spreadClone(ctx: AontuContext): Val {
     if (!this.isPathDependent) return this
 
+    let allScalarKind = true
+    for (let key in this.peg) {
+      if (!(this.peg[key] as any)?.isScalarKind) {
+        allScalarKind = false
+        break
+      }
+    }
+
+    if (!allScalarKind) {
+      return this.clone(ctx)
+    }
+
     let out = (super.clone(ctx) as MapVal)
     out.peg = {}
 
     for (let entry of Object.entries(this.peg)) {
-      const child = entry[1] as Val
-      if (child?.isVal && child.isPathDependent) {
-        out.peg[entry[0]] = child.clone(ctx, { path: [...out.path, entry[0]] })
-      }
-      else if (child?.isVal) {
-        const wrapper = Object.create(child)
-        wrapper.mark = { ...child.mark }
-        out.peg[entry[0]] = wrapper
-      }
-      else {
-        out.peg[entry[0]] = child
-      }
+      out.peg[entry[0]] = entry[1]
+    }
+
+    // Must create a new spread object to avoid mutating the original.
+    out.spread = {
+      cj: this.spread.cj ? this.spread.cj.spreadClone(ctx) : undefined,
     }
 
     out.closed = this.closed
-    out.optionalKeys = 0 < this.optionalKeys.length ? [...this.optionalKeys] : this.optionalKeys
+    out.optionalKeys = [...this.optionalKeys]
 
     return out
   }
@@ -246,25 +285,36 @@ class MapVal extends BagVal {
     for (let entry of Object.entries(this.peg)) {
       out.peg[entry[0]] =
         (entry[1] as any)?.isVal ?
+          // (entry[1] as Val).clone(ctx, spec?.mark ? { mark: spec.mark } : {}) :
           (entry[1] as Val).clone(ctx, {
             mark: spec?.mark ?? {},
             path: [...out.path, entry[0]]
           }) :
           entry[1]
     }
+    if (this.spread.cj) {
+      out.spread.cj = this.spread.cj.clone(ctx, spec?.mark ? { mark: spec.mark } : {})
+    }
 
     out.closed = this.closed
     out.optionalKeys = [...this.optionalKeys]
 
+    // out.from = this.from
+
+    // console.log('MAPVAL-CLONE', this.canon, '->', out.canon)
     return out
   }
 
 
   get canon() {
-    if (this._canonCache !== undefined) return this._canonCache
-    let keys = Object.keys(this.peg).sort()
-    const c = '' +
+    let keys = Object.keys(this.peg)
+    return '' +
+      // this.errcanon() +
+      // (this.mark.type ? '<type>' : '') +
+      // (this.id + '=') +
       '{' +
+      (this.spread.cj ? '&:' + this.spread.cj.canon +
+        (0 < keys.length ? ',' : '') : '') +
       keys
         .map(k => [
           JSON.stringify(k) +
@@ -273,19 +323,18 @@ class MapVal extends BagVal {
           (this.peg[k]?.canon ?? this.peg[k])
         ])
         .join(',') +
-      '}'
-    if (this.done) this._canonCache = c
-    return c
+      '}' // + '<' + (this.mark.hide ? 'H' : '') + '>'
+
   }
 
 
-  inspection(_d?: number) {
-    return ''
+  inspection(d?: number) {
+    return this.spread.cj ? '&:' + this.spread.cj.inspect(null == d ? 0 : d + 1) : ''
   }
 
 }
 
 
 export {
-  MapVal,
+  MapVal
 }

package/src/val/MoveFuncVal.ts

@@ -13,7 +13,6 @@ import {
 import { makeNilErr } from '../err'
 
 import { NilVal } from '../val/NilVal'
-import { PathVal } from '../val/PathVal'
 
 import {
   walk
@@ -27,60 +26,6 @@ import { PrefFuncVal } from './PrefFuncVal'
 
 
 
-// Navigate the tree using a PathVal's resolved path and hide the source.
-function hideAtPath(root: Val, pv: PathVal) {
-  // Compute the refpath the same way PathVal.find does
-  const parts: string[] = []
-  for (const part of pv.peg) {
-    if ('string' === typeof part) parts.push(part)
-  }
-
-  let refpath: string[]
-  if (pv.absolute) {
-    refpath = parts
-  }
-  else {
-    refpath = pv.path.slice(0, -1).concat(parts)
-  }
-
-  // Walk to the source, handling conjuncts/disjuncts
-  let node: any = root
-  for (let i = 0; i < refpath.length; i++) {
-    const part = refpath[i]
-    if (node?.isMap || node?.isList) {
-      node = node.peg[part]
-    }
-    else if (node?.isConjunct || node?.isDisjunct) {
-      // Search junction terms for the key
-      let found = null
-      const stack = [...node.peg]
-      while (stack.length > 0) {
-        const term = stack.pop()
-        if (term?.isConjunct || term?.isDisjunct) {
-          stack.push(...term.peg)
-        }
-        else if ((term?.isMap || term?.isList) && term.peg[part] != null) {
-          found = term.peg[part]
-          break
-        }
-      }
-      node = found
-    }
-    else {
-      return
-    }
-    if (node == null) return
-  }
-
-  // Mark the source value hidden
-  node.mark.hide = true
-  walk(node, (_key: string | number | undefined, val: Val) => {
-    val.mark.hide = true
-    return val
-  })
-}
-
-
 class MoveFuncVal extends FuncBaseVal {
   isMoveFunc = true
 
@@ -105,40 +50,30 @@ class MoveFuncVal extends FuncBaseVal {
   }
 
   resolve(ctx: AontuContext, args: Val[]) {
-    let arg = args[0] ?? makeNilErr(ctx, 'arg', this)
-    if (arg.isNil) return arg
+    let out = args[0] ?? makeNilErr(ctx, 'arg', this)
 
-    let src: Val
+    const orig = out
 
-    if (arg instanceof PathVal) {
-      // Get clone for the destination
-      src = arg.find(ctx) as Val
-      if (src == null || src.isNil) return makeNilErr(ctx, 'arg', this)
+    if (!orig.isNil) {
+      const src = orig.clone(ctx)
 
-      // Hide the source in the tree by navigating to it
-      hideAtPath(ctx.root as Val, arg)
-    }
-    else {
-      src = arg.clone(ctx)
+      if (src.isRef) {
+        src.mark._hide_found = true
+      }
 
-      // Hide the original
-      arg.mark.hide = true
-      walk(arg, (_key: string | number | undefined, val: 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
     }
 
-    // Clear marks on the clone (like copy)
-    src.mark.type = false
-    src.mark.hide = false
-    walk(src, (_key: string | number | undefined, val: Val) => {
-      val.mark.type = false
-      val.mark.hide = false
-      return val
-    })
+    // console.log('MOVE-resolve', orig, out)
 
-    return new PrefFuncVal({ peg: [src] }, ctx)
+    return out
   }
 }
 

package/src/val/PathFuncVal.ts

@@ -6,10 +6,6 @@ import type {
   ValSpec,
 } from '../type'
 
-import {
-  DONE,
-} from '../type'
-
 import {
   AontuContext,
 } from '../ctx'
@@ -17,7 +13,7 @@ import {
 import { makeNilErr } from '../err'
 
 import { NilVal } from '../val/NilVal'
-import { PathVal } from '../val/PathVal'
+import { RefVal } from '../val/RefVal'
 import { FuncBaseVal } from './FuncBaseVal'
 
 
@@ -49,26 +45,12 @@ class PathFuncVal extends FuncBaseVal {
     let arg = args[0]
 
     if (0 === this.prepared) {
-      if (arg instanceof PathVal) {
-        // PathVal from dotted arg — resolve via find().
-        const found = arg.find(ctx)
-        if (found != null && !found.isNil) {
-          arg = found
-        }
-        else {
-          arg.dc = DONE
-        }
-      }
-      else if (arg.isScalar && arg.peg != null && arg.peg !== ''
-        && ('string' === typeof arg.peg || arg.isNumber)) {
-        // String or number arg like path("foo") or path(0.2) — create a path value
-        arg = this.place(new PathVal({ peg: [arg], absolute: false })) as PathVal
-        arg.dc = DONE
+      if (arg.isScalar) {
+        arg = this.place(new RefVal({ peg: [arg], absolute: false }))
       }
-      else if (arg.isNil || (arg.isScalar && (arg.peg === '' || arg.peg == null))) {
+      else if (!arg.isRef) {
         arg = makeNilErr(ctx, 'invalid-arg', this)
       }
-      // else: already resolved by preprocessing — pass through
     }
 
     args[0] = arg
@@ -82,13 +64,6 @@ class PathFuncVal extends FuncBaseVal {
   resolve(ctx: AontuContext, args: Val[]) {
     let out = args[0] ?? makeNilErr(ctx, 'arg', this)
 
-    if (out instanceof PathVal) {
-      const found = out.find(ctx)
-      if (found != null && !found.isNil) {
-        out = found
-      }
-    }
-
     return out
   }
 

package/src/val/PrefVal.ts

@@ -22,7 +22,6 @@ import {
 
 import { top } from './top'
 
-import { ConjunctVal } from './ConjunctVal'
 import { FeatureVal } from './FeatureVal'
 
 
@@ -65,13 +64,10 @@ class PrefVal extends FeatureVal {
     if (!this.peg.done) {
       const resolved = unite(te ? ctx.clone({ explain: ec(te, 'RES') }) : ctx,
         this.peg, top(), 'pref/resolve')
+      // console.log('PREF-RESOLVED', this.peg.canon, '->', resolved)
       this.peg = resolved
       this.superpeg = this.peg.superior()
     }
-    else if (this.superpeg.isTop && !this.peg.isTop) {
-      // Stale superpeg from pre-resolved PathVal — recalculate
-      this.superpeg = this.peg.superior()
-    }
 
     if (peer instanceof PrefVal) {
       why += 'pref-'
@@ -110,20 +106,11 @@ class PrefVal extends FeatureVal {
     else if (!peer.isTop) {
       why += 'super-'
 
-      // If peg is unresolved (e.g. deferred ref), don't decide yet —
-      // preserve both sides so a later pass can resolve.
-      if (!this.peg.done) {
-        out = new ConjunctVal({ peg: [this, peer] }, ctx)
-        done = false
-        why += 'defer'
-      }
-      else {
-        out = unite(te ? ctx.clone({ explain: ec(te, 'SUPER') }) : ctx,
-          this.superpeg, peer, 'pref-super/' + this.id)
-        if (out.same(this.superpeg)) {
-          out = this.peg
-          why += 'same'
-        }
+      out = unite(te ? ctx.clone({ explain: ec(te, 'SUPER') }) : ctx,
+        this.superpeg, peer, 'pref-super/' + this.id)
+      if (out.same(this.superpeg)) {
+        out = this.peg
+        why += 'same'
       }
 
       // }

package/src/val/{RefVal.ts.old → RefVal.ts}

@@ -1,6 +1,8 @@
 /* Copyright (c) 2021-2025 Richard Rodger, MIT License */
 
 
+import Util from 'node:util'
+
 import {
   walk,
   explainOpen,
@@ -14,7 +16,6 @@ import type {
   ValSpec,
 } from '../type'
 
-
 import {
   DONE,
 } from '../type'
@@ -136,23 +137,10 @@ class RefVal extends FeatureVal {
   unify(peer: Val, ctx: AontuContext): Val {
     peer = peer ?? top()
 
-    // TEMPORARY: nerf RefVals to verify spread-first resolution
-    return makeNilErr(ctx, 'ref_test_block', this, peer)
-
     const te = ctx.explain && explainOpen(ctx, ctx.explain, 'Ref', this, peer)
     let out: Val = this
     let why = 'id'
 
-    // Defer ref resolution on first pass and while spreads remain
-    if (0 === ctx.cc || 0 < ctx.sc) {
-      if (!peer.isTop && this.id !== peer.id) {
-        out = new ConjunctVal({ peg: [this, peer] }, ctx)
-      }
-      out.dc = DONE === out.dc ? DONE : this.dc + 1
-      explainClose(te, out)
-      return out
-    }
-
     if (this.id !== peer.id) {
 
       // TODO: not resolved when all Vals in path are done is an error
@@ -371,30 +359,31 @@ class RefVal extends FeatureVal {
           if (this.mark.type || this.mark.hide) {
             out.mark.type = this.mark.type
             out.mark.hide = this.mark.hide
+
+            // walk(out, (_key: string | number | undefined, val: Val) => {
+            //   val.mark.type = this.mark.type
+            //   val.mark.hide = this.mark.hide
+            //   return val
+            // })
           }
 
           if (this.mark._hide_found) {
             out.mark.hide = true
           }
 
-          // Cache clone+walk results per (ref, target) per iteration.
-          const cacheKey = this.id + '|' + out.id
-          const cache = ctx._refCloneCache
-          const cached = cache?.get(cacheKey)
-          if (cached !== undefined) {
-            out = cached
-          }
-          else {
-            out = out.clone(ctx)
+          // console.log('FOUND-B', out)
 
-            walk(out, (_key: string | number | undefined, val: Val) => {
-              val.mark.type = false
-              val.mark.hide = false
-              return val
-            })
+          out = out.clone(ctx)
 
-            cache?.set(cacheKey, out)
-          }
+          // if (this.mark.type || this.mark.hide) {
+          walk(out, (_key: string | number | undefined, val: Val) => {
+            val.mark.type = false
+            val.mark.hide = false
+            return val
+          })
+          //}
+
+          // onsole.log('FOUND-C', out)
         }
       }
     }