aontu 0.41.0 → 0.43.0

package/src/val/MoveFuncVal.ts

@@ -13,6 +13,7 @@ import {
 import { makeNilErr } from '../err'
 
 import { NilVal } from '../val/NilVal'
+import { PathVal } from '../val/PathVal'
 
 import {
   walk
@@ -26,6 +27,60 @@ 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
 
@@ -50,30 +105,40 @@ class MoveFuncVal extends FuncBaseVal {
   }
 
   resolve(ctx: AontuContext, args: Val[]) {
-    let out = args[0] ?? makeNilErr(ctx, 'arg', this)
+    let arg = args[0] ?? makeNilErr(ctx, 'arg', this)
+    if (arg.isNil) return arg
 
-    const orig = out
+    let src: Val
 
-    if (!orig.isNil) {
-      const src = orig.clone(ctx)
+    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 (src.isRef) {
-        src.mark._hide_found = true
-      }
+      // Hide the source in the tree by navigating to it
+      hideAtPath(ctx.root as Val, arg)
+    }
+    else {
+      src = arg.clone(ctx)
 
-      walk(orig, (_key: string | number | undefined, val: Val) => {
+      // Hide the original
+      arg.mark.hide = true
+      walk(arg, (_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)
+    // 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
+    })
 
-    return out
+    return new PrefFuncVal({ peg: [src] }, ctx)
   }
 }
 

package/src/val/PathFuncVal.ts

@@ -6,6 +6,10 @@ import type {
   ValSpec,
 } from '../type'
 
+import {
+  DONE,
+} from '../type'
+
 import {
   AontuContext,
 } from '../ctx'
@@ -13,7 +17,7 @@ import {
 import { makeNilErr } from '../err'
 
 import { NilVal } from '../val/NilVal'
-import { RefVal } from '../val/RefVal'
+import { PathVal } from '../val/PathVal'
 import { FuncBaseVal } from './FuncBaseVal'
 
 
@@ -45,12 +49,26 @@ class PathFuncVal extends FuncBaseVal {
     let arg = args[0]
 
     if (0 === this.prepared) {
-      if (arg.isScalar) {
-        arg = this.place(new RefVal({ peg: [arg], absolute: false }))
+      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
       }
-      else if (!arg.isRef) {
+      else if (arg.isNil || (arg.isScalar && (arg.peg === '' || arg.peg == null))) {
         arg = makeNilErr(ctx, 'invalid-arg', this)
       }
+      // else: already resolved by preprocessing — pass through
     }
 
     args[0] = arg
@@ -64,6 +82,13 @@ 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/PathVal.ts

@@ -0,0 +1,435 @@
+/* Copyright (c) 2025 Richard Rodger, MIT License */
+
+
+import type {
+  Val,
+  ValSpec,
+} from '../type'
+
+import {
+  DONE,
+} from '../type'
+
+import {
+  walk,
+} from '../utility'
+
+import { AontuContext } from '../ctx'
+import { unite } from '../unify'
+
+import { makeNilErr } from '../err'
+
+import {
+  top
+} from './top'
+
+import { StringVal } from './StringVal'
+import { IntegerVal } from './IntegerVal'
+import { NumberVal } from './NumberVal'
+import { VarVal } from './VarVal'
+import { ConjunctVal } from './ConjunctVal'
+import { DisjunctVal } from './DisjunctVal'
+import { FeatureVal } from './FeatureVal'
+
+
+class PathVal extends FeatureVal {
+  isPath = true
+  isGenable = true
+  cjo = 32500
+
+  absolute: boolean = false
+  prefix: boolean = false
+  _resolved: Val | undefined = undefined
+
+  constructor(
+    spec: {
+      peg: any[],
+      absolute?: boolean,
+      prefix?: boolean
+    },
+    ctx?: AontuContext
+  ) {
+    super(spec, ctx)
+    this.peg = []
+
+    this.absolute = true === this.absolute ? true : // absolute sticks
+      true === spec.absolute ? true : false
+
+    this.prefix = true === spec.prefix
+
+    for (let pI = 0; pI < spec.peg.length; pI++) {
+      this.append(spec.peg[pI])
+    }
+  }
+
+
+  append(part: any) {
+    let partval
+
+    if ('string' === typeof part) {
+      partval = part
+      this.peg.push(partval)
+    }
+
+    else if (part instanceof StringVal) {
+      partval = part.peg
+      this.peg.push(partval)
+    }
+
+    else if (part instanceof IntegerVal) {
+      partval = part.src
+      this.peg.push(partval)
+    }
+
+    else if (part instanceof NumberVal) {
+      let partvals: string[] = part.src.split('.')
+      this.peg.push(...partvals)
+    }
+
+    else if (part instanceof VarVal) {
+      partval = part
+      this.peg.push(partval)
+    }
+
+    else if (part instanceof PathVal) {
+      if (part.absolute) {
+        this.absolute = true
+      }
+
+      if (this.prefix) {
+        if (part.prefix) {
+          this.peg.push('.')
+        }
+      }
+      else {
+        if (part.prefix) {
+          if (0 === this.peg.length) {
+            this.prefix = true
+          }
+
+          else if (0 < this.peg.length) {
+            this.peg.push('.')
+          }
+        }
+      }
+
+      this.peg.push(...part.peg)
+    }
+  }
+
+
+  unify(peer: Val, ctx: AontuContext): Val {
+    peer = peer ?? top()
+
+    // Already resolved (e.g. path value from path() function) — skip find
+    if (this.done) return this
+
+    let out: Val = this
+    const found = this.find(ctx)
+
+    if (found != null && !found.isNil) {
+      out = unite(ctx, found, peer, 'path')
+    }
+    else if (found?.isNil) {
+      out = found
+    }
+    else {
+      // Not yet resolvable — increment dc to signal not done
+      this.dc = DONE === this.dc ? DONE : this.dc + 1
+    }
+
+    return out
+  }
+
+
+  find(ctx: AontuContext) {
+    let out: Val | undefined = undefined
+
+    // Check if self.path starts with peg (cycle detection).
+    // Element-by-element comparison avoids string join+startsWith allocations.
+    let isprefixpath = this.peg.length <= this.path.length
+    if (isprefixpath) {
+      for (let i = 0; i < this.peg.length; i++) {
+        if (this.peg[i] !== this.path[i]) {
+          isprefixpath = false
+          break
+        }
+      }
+    }
+    // Degenerate case: peg is all empty strings (e.g. path("")) and path is empty.
+    if (!isprefixpath && this.peg.length > 0 && this.path.length === 0) {
+      let allEmpty = true
+      for (let i = 0; i < this.peg.length; i++) {
+        if ('' !== this.peg[i]) { allEmpty = false; break }
+      }
+      isprefixpath = allEmpty
+    }
+
+    let refpath: string[] = []
+    let pI = 0
+    // let descent = ''
+
+    if (isprefixpath) {
+      // console.log('SELFPATH', selfpath, 'PEGPATH', pegpath)
+      out = makeNilErr(ctx, 'path_cycle', this)
+    }
+    else {
+
+      let parts: string[] = []
+
+      let modes: string[] = []
+
+      for (let pI = 0; pI < this.peg.length; pI++) {
+        let part = this.peg[pI]
+        if (part instanceof VarVal) {
+          let strval = (part as VarVal).peg
+          let name = strval ? '' + strval.peg : ''
+
+          if ('KEY' === name) {
+            if (pI === this.peg.length - 1) {
+              modes.push(name)
+            }
+            else {
+              // TODO: return a Nil explaining error
+              return
+            }
+          }
+
+          if ('SELF' === name) {
+            if (pI === 0) {
+              modes.push(name)
+            }
+            else {
+              // TODO: return a Nil explaining error
+              return
+            }
+          }
+          else if ('PARENT' === name) {
+            if (pI === 0) {
+              modes.push(name)
+            }
+            else {
+              // TODO: return a Nil explaining error
+              return
+            }
+          }
+          else if (0 === modes.length) {
+            part = (part as VarVal).unify(top(), ctx)
+            if (part.isNil) {
+              // TODO: var not found, so can't find path
+              return
+            }
+            else {
+              part = '' + part.peg
+            }
+          }
+        }
+        else {
+          parts.push(part)
+        }
+      }
+
+      if (this.absolute) {
+        refpath = parts
+      }
+      else {
+        // TODO: deprecate $KEY, etc
+        refpath = this.path.slice(
+          0,
+          (
+            modes.includes('SELF') ? 0 :
+              modes.includes('PARENT') ? -1 :
+                -1 // siblings
+          )
+        ).concat(parts)
+      }
+
+      let sep = '.'
+      refpath = refpath
+        .reduce(((a: string[], p: string) =>
+          (p === sep ? a.length = a.length - 1 : a.push(p), a)), [])
+
+      if (modes.includes('KEY')) {
+        let key = this.path[this.path.length - 2]
+        let sv = new StringVal({ peg: null == key ? '' : key }, ctx)
+
+        // TODO: other props?
+        sv.dc = DONE
+        sv.path = this.path
+
+        return sv
+      }
+
+      let node: Val | null = ctx.root as Val
+
+      let nopath = false
+
+      if (null != node) {
+        for (; pI < refpath.length; pI++) {
+          let part = refpath[pI]
+          // console.log('PART', pI, part, node)
+
+          // descent += (' | ' + pI + '=' + node.canon) // Util.inspect(node))
+
+          if (node.isMap) {
+            node = node.peg[part]
+          }
+          else if (node.isList) {
+            node = node.peg[part]
+          }
+          else if (node.isConjunct || node.isDisjunct) {
+            // Collect matching children from all junction terms,
+            // flattening nested conjuncts and disjuncts.
+            // Spreads match any key — their peg is always included.
+            const matches: Val[] = []
+            const stack = [...node.peg]
+            while (stack.length > 0) {
+              const term = stack.pop()!
+              if (term.isConjunct || term.isDisjunct) {
+                stack.push(...term.peg)
+              }
+              else if (term.isSpread) {
+                matches.push(term.peg)
+              }
+              else if ((term.isMap || term.isList) && term.peg[part] != null) {
+                matches.push(term.peg[part])
+              }
+            }
+            if (matches.length === 1) {
+              node = matches[0]
+            }
+            else if (matches.length > 1) {
+              node = node.isConjunct
+                ? new ConjunctVal({ peg: matches })
+                : new DisjunctVal({ peg: matches })
+            }
+            else {
+              node = null
+            }
+          }
+          else if (node.done) {
+            nopath = true
+            break;
+          }
+          else {
+            break;
+          }
+
+          if (null == node) {
+            nopath = true
+            break
+          }
+
+        }
+      }
+
+      // console.log('REFPATH', ctx.cc, pI, refpath, nopath, ctx.root, node)
+
+
+      if (nopath) {
+        out = makeNilErr(ctx, 'no_path', this)
+      }
+      else if (pI === refpath.length && node != null) {
+        out = node
+
+        // Types and hidden values are cloned and made concrete
+        if (null != out) { //  && (out.mark.type || out.mark.hide)) {
+
+          // console.log('FOUND-A', out)
+
+          if (this.mark.type || this.mark.hide) {
+            out.mark.type = this.mark.type
+            out.mark.hide = this.mark.hide
+          }
+
+          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)
+            out.mark.type = false
+            out.mark.hide = false
+
+            walk(out, (_key: string | number | undefined, val: Val) => {
+              val.mark.type = false
+              val.mark.hide = false
+              return val
+            })
+
+            cache?.set(cacheKey, out)
+          }
+        }
+      }
+    }
+
+    // console.log('REF-FIND', ctx.cc, this.id, selfpath, 'PEG=', pegpath, 'RP', pI, refpath.join('.'), descent, 'O=', out?.id, out?.canon, out?.done)
+
+    return out
+  }
+
+
+
+  same(peer: Val): boolean {
+    return null == peer ? false : this.peg === peer.peg
+  }
+
+
+  clone(ctx: AontuContext, spec?: ValSpec): Val {
+    let out = (super.clone(ctx, {
+      peg: this.peg,
+      absolute: this.absolute,
+      ...(spec || {})
+    }) as PathVal)
+    return out
+  }
+
+
+  get canon() {
+    let str =
+      (this.absolute ? '$' : '') +
+      (0 < this.peg.length ? '.' : '') +
+      this.peg.map((p: any) => '.' === p ? '' :
+        (p.isVal ? p.canon : '' + p))
+        .join('.')
+    return str
+  }
+
+
+  gen(ctx: AontuContext) {
+    let nil = makeNilErr(
+      ctx,
+      'ref',
+      this,
+      undefined,
+    )
+
+    nil.path = this.path
+    nil.site.url = this.site.url
+    nil.site.row = this.site.row
+    nil.site.col = this.site.col
+
+    return undefined
+  }
+
+
+  inspection() {
+    return [
+      this.absolute ? 'absolute' : '',
+      this.prefix ? 'prefix' : '',
+    ].filter(p => '' != p).join(',')
+  }
+
+}
+
+
+export {
+  PathVal,
+}

package/src/val/PrefVal.ts

@@ -22,6 +22,7 @@ import {
 
 import { top } from './top'
 
+import { ConjunctVal } from './ConjunctVal'
 import { FeatureVal } from './FeatureVal'
 
 
@@ -64,10 +65,13 @@ 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-'
@@ -106,11 +110,20 @@ class PrefVal extends FeatureVal {
     else if (!peer.isTop) {
       why += 'super-'
 
-      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'
+      // 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'
+        }
       }
 
       // }