aontu 0.43.0 → 0.45.1

package/src/lang.ts

@@ -25,10 +25,6 @@ import {
   makeFileResolver
 } from '@jsonic/multisource/resolver/file'
 
-import {
-  preloadFiles
-} from '@jsonic/multisource'
-
 import {
   makePkgResolver
 } from '@jsonic/multisource/resolver/pkg'
@@ -79,8 +75,7 @@ import { NilVal } from './val/NilVal'
 import { NullVal } from './val/NullVal'
 import { NumberVal } from './val/NumberVal'
 import { PrefVal } from './val/PrefVal'
-import { PathVal } from './val/PathVal'
-// RefVal replaced by PathVal — see RefVal.ts.old
+import { RefVal } from './val/RefVal'
 import { StringVal } from './val/StringVal'
 import { VarVal } from './val/VarVal'
 import { PlusOpVal } from './val/PlusOpVal'
@@ -96,7 +91,6 @@ import { PrefFuncVal } from './val/PrefFuncVal'
 import { CloseFuncVal } from './val/CloseFuncVal'
 import { OpenFuncVal } from './val/OpenFuncVal'
 import { SuperFuncVal } from './val/SuperFuncVal'
-import { SpreadVal } from './val/SpreadVal'
 
 
 let AontuJsonic: Plugin = function AontuLang(jsonic: Jsonic) {
@@ -116,17 +110,6 @@ let AontuJsonic: Plugin = function AontuLang(jsonic: Jsonic) {
   }
 
 
-  // Helper: create a SpreadVal from the raw SPREAD symbol data.
-  function makeSpreadVal(rawSpread: any): SpreadVal {
-    const constraint = Array.isArray(rawSpread.v)
-      ? (rawSpread.v.length > 1
-        ? new ConjunctVal({ peg: rawSpread.v })
-        : rawSpread.v[0])
-      : rawSpread.v
-    return new SpreadVal({ peg: constraint })
-  }
-
-
   jsonic.options({
     hint: {
       unknown: `
@@ -240,25 +223,12 @@ help isolate the syntax error.`,
       addsite(new DisjunctVal({ peg: terms }), r, ctx),
 
     'dot-prefix': (r: Rule, ctx: JsonicContext, _op: Op, terms: any) => {
-      const pv = addsite(new PathVal({ peg: terms, prefix: true }), r, ctx)
-      if (ctx.meta.paths) { ctx.meta.paths.push(pv) }
-      return pv
+      return addsite(new RefVal({ peg: terms, prefix: true }), r, ctx)
     },
 
     'dot-infix': (r: Rule, ctx: JsonicContext, _op: Op, terms: any) => {
-      const paths = ctx.meta.paths
-      if (paths) {
-        // Remove consumed intermediates
-        for (const t of terms) {
-          if (t instanceof PathVal) {
-            const idx = paths.indexOf(t)
-            if (idx >= 0) paths.splice(idx, 1)
-          }
-        }
-      }
-      const pv = addsite(new PathVal({ peg: terms }), r, ctx)
-      if (paths) { paths.push(pv) }
-      return pv
+      // // console.log('DOT-INFIX-OP', terms)
+      return addsite(new RefVal({ peg: terms }), r, ctx)
     },
 
     'star-prefix': (r: Rule, ctx: JsonicContext, _op: Op, terms: any) =>
@@ -266,7 +236,7 @@ help isolate the syntax error.`,
 
     'dollar-prefix': (r: Rule, ctx: JsonicContext, _op: Op, terms: any) => {
       // $.a.b absolute path
-      if (terms[0] instanceof PathVal) {
+      if (terms[0] instanceof RefVal) {
         terms[0].absolute = true
         return terms[0]
       }
@@ -301,9 +271,6 @@ help isolate the syntax error.`,
           })
       }
       const out = addsite(val, r, ctx)
-      if (out.isKeyFunc && ctx.meta.keys) {
-        ctx.meta.keys.push(out)
-      }
       return out
     },
   }
@@ -314,11 +281,11 @@ help isolate the syntax error.`,
       op: {
         // disjunct < conjunct: c & b | a -> (c & b) | a
         'conjunct': {
-          infix: true, src: '&', left: 16_000_000, right: 17_000_000,
+          infix: true, src: '&', left: 16_000_000, right: 17_000_000
         },
 
         'disjunct': {
-          infix: true, src: '|', left: 14_000_000, right: 15_000_000,
+          infix: true, src: '|', left: 14_000_000, right: 15_000_000
         },
 
         'plus-infix': {
@@ -357,6 +324,7 @@ help isolate the syntax error.`,
           paren: true,
           preval: {
             active: true,
+            // allow: ['floor'], //Object.keys(funcMap)
           },
           osrc: '(',
           csrc: ')',
@@ -477,46 +445,26 @@ help isolate the syntax error.`,
         { s: [OPTKEY, QM], p: 'pair', b: 2, g: 'pair,list,val,imp,jsonic,aontu-optional' },
       ])
 
-
       .bc((r: Rule, ctx: JsonicContext) => {
         const optionalKeys = r.u.aontu_optional_keys ?? []
 
         let mo = r.node
 
-        // Extract spread constraint before creating MapVal.
-        // If a spread exists, wrap: ConjunctVal([MapVal, SpreadVal])
-        const rawSpread = (mo as any)[SPREAD]
-        if (rawSpread) {
-          delete (mo as any)[SPREAD]
-        }
-
         //  Handle defered conjuncts, e.g. `{x:1 @"foo"}`
         if (mo.___merge) {
           let mop = { ...mo }
           delete mop.___merge
 
+          // TODO: needs addpath?
           let mopv = new MapVal({ peg: mop })
           mopv.optionalKeys = optionalKeys
 
-          let terms = [mopv, ...mo.___merge]
-          if (rawSpread && '&' === rawSpread.o) {
-            terms.push(makeSpreadVal(rawSpread))
-          }
-
-          r.node = addsite(new ConjunctVal({ peg: terms }), r, ctx)
+          r.node =
+            addsite(new ConjunctVal({ peg: [mopv, ...mo.___merge] }), r, ctx)
         }
         else {
-          let mapVal = new MapVal({ peg: mo })
-          mapVal.optionalKeys = optionalKeys
-
-          if (rawSpread && '&' === rawSpread.o) {
-            const spreadVal = makeSpreadVal(rawSpread)
-            r.node = addsite(
-              new ConjunctVal({ peg: [mapVal, spreadVal] }), r, ctx)
-          }
-          else {
-            r.node = addsite(mapVal, r, ctx)
-          }
+          r.node = addsite(new MapVal({ peg: mo }), r, ctx)
+          r.node.optionalKeys = optionalKeys
         }
 
         return undefined
@@ -538,39 +486,20 @@ help isolate the syntax error.`,
 
         let ao = r.node
 
-        // Extract spread from list before creating ListVal.
-        const rawSpread = (ao as any)[SPREAD]
-        if (rawSpread) {
-          delete (ao as any)[SPREAD]
-        }
-
         if (ao.___merge) {
           let aop = [...ao]
           delete (aop as any).___merge
 
+          // TODO: needs addpath?
           let aopv = new ListVal({ peg: aop })
           aopv.optionalKeys = optionalKeys
 
-          let terms = [aopv, ...ao.___merge]
-          if (rawSpread && '&' === rawSpread.o) {
-            terms.push(makeSpreadVal(rawSpread))
-          }
-
           r.node =
-            addsite(new ConjunctVal({ peg: terms }), r, ctx)
+            addsite(new ConjunctVal({ peg: [aopv, ...ao.___merge] }), r, ctx)
         }
         else {
-          let listVal = new ListVal({ peg: ao })
-          listVal.optionalKeys = optionalKeys
-
-          if (rawSpread && '&' === rawSpread.o) {
-            const spreadVal = makeSpreadVal(rawSpread)
-            r.node = addsite(
-              new ConjunctVal({ peg: [listVal, spreadVal] }), r, ctx)
-          }
-          else {
-            r.node = addsite(listVal, r, ctx)
-          }
+          r.node = addsite(new ListVal({ peg: ao }), r, ctx)
+          r.node.optionalKeys = optionalKeys
         }
 
         return undefined
@@ -626,13 +555,11 @@ help isolate the syntax error.`,
         }
       ])
 
-      // Spread children inherit the parent path directly.
-      // The path gets adjusted correctly when SpreadVal applies
-      // the constraint via spreadClone(keyctx).
+      // NOTE: manually adjust path - @jsonic/path ignores as not pair:true
       .ao((r) => {
         if (0 < r.d && r.u.spread) {
-          r.child.k.path = r.k.path
-          r.child.k.key = r.k.key
+          r.child.k.path = [...r.k.path, '&']
+          r.child.k.key = '&'
         }
       })
 
@@ -720,18 +647,10 @@ function makeModelResolver(options: any) {
     ...(options.resolver?.mem || {})
   })
 
-  const pathfinder = (spec: any) => {
+  // TODO: make this consistent with other resolvers
+  let fileResolver = makeFileResolver((spec: any) => {
     return 'string' === typeof spec ? spec : spec?.peg
-  }
-
-  let preload: { [fullpath: string]: string } | undefined
-  if (options.preload) {
-    preload = preloadFiles(options.preload)
-  }
-
-  let fileResolver = makeFileResolver(
-    preload ? { pathfinder, preload } : pathfinder
-  )
+  })
 
   let pkgResolver = makePkgResolver({
     require: useRequire,
@@ -780,8 +699,6 @@ class Lang {
   jsonic: Jsonic
   opts: AontuOptions
   idcount: number | undefined
-  paths: PathVal[] = []
-  keys: KeyFuncVal[] = []
 
 
   constructor(options?: Partial<AontuOptions>) {
@@ -815,14 +732,9 @@ class Lang {
     // const start = performance.now()
 
     // JSONIC-UPDATE - check meta
-    this.paths = []
-    this.keys = []
-
     let jm: any = {
       fs: opts?.fs,
       fileName: opts?.path ?? this.opts.path,
-      paths: this.paths,
-      keys: this.keys,
       multisource: {
         path: opts?.path ?? this.opts.path,
         deps: (opts && opts.deps) || undefined
@@ -867,7 +779,5 @@ class Lang {
 
 export {
   Lang,
-  PathVal,
-  KeyFuncVal,
   Site,
 }

package/src/type.ts

@@ -30,11 +30,6 @@ type AontuOptions = {
   collect?: boolean // Collect errors into an errs property, rather than throw them.
   err?: any[]
   explain?: any[]
-  preload?: {          // Preload files into memory before parsing.
-    folders: string[]  // Folders to scan.
-    ext?: string[]     // Extensions (default: ['.jsonic', '.json']).
-    recursive?: boolean // Recurse into subfolders (default: false).
-  }
 }
 
 

package/src/unify.ts

@@ -10,9 +10,6 @@ import { DONE } from './type'
 import { makeNilErr } from './err'
 
 import { NilVal } from './val/NilVal'
-import { StringVal } from './val/StringVal'
-import { PathVal } from './val/PathVal'
-import { KeyFuncVal } from './val/KeyFuncVal'
 
 import {
   Lang
@@ -29,9 +26,8 @@ import {
 } from './val/top'
 
 
-
 // TODO: FIX: false positive when too many top unifications
-const MAXCYCLE = 9999
+const MAXCYCLE = 999
 
 // Vals should only have to unify downwards (in .unify) over Vals they understand.
 // and for complex Vals, TOP, which means self unify if not yet done
@@ -54,19 +50,12 @@ const unite = (ctx: AontuContext, a: any, b: any, whence: string) => {
       if (a.done && b.done) {
         if (a.id === b.id) return a
         if (a.constructor === b.constructor && a.peg === b.peg
-          && !a.isNil && !b.isNil
-          && !a.isConjunct && !a.isDisjunct
-          && !a.isPath && !a.isPref && !a.isFunc && !a.isExpect) {
+            && !a.isNil && !b.isNil
+            && !a.isMap && !a.isList
+            && !a.isConjunct && !a.isDisjunct
+            && !a.isRef && !a.isPref && !a.isFunc && !a.isExpect) {
           return a
         }
-
-        // Id-keyed cache: reuse results for the exact same Val pair.
-        const uc = ctx._uniteCache
-        if (uc !== undefined) {
-          const ucKey = a.id + '|' + b.id
-          const ucHit = uc.get(ucKey)
-          if (ucHit !== undefined) return ucHit
-        }
       }
     }
   }
@@ -78,25 +67,21 @@ const unite = (ctx: AontuContext, a: any, b: any, whence: string) => {
 
   // Cycle-detection key. Use numeric path index for speed; fall back to
   // full string key when debug is enabled so the saw value is human-readable.
-  let saw: string
-  if (ctx.opts.debug) {
-    saw = (a ? a.id + (a.done ? '' : '*') : '') + '~' +
+  const saw = ctx.opts.debug
+    ? (a ? a.id + (a.done ? '' : '*') : '') + '~' +
       (b ? b.id + (b.done ? '' : '*') : '') + '@' + ctx.pathstr
-  }
-  else {
-    saw = (a ? a.id + (a.done ? 'd' : '') : 0) + '~' +
+    : (a ? a.id + (a.done ? 'd' : '') : 0) + '~' +
       (b ? b.id + (b.done ? 'd' : '') : 0) + '~' + ctx.pathidx
-  }
 
   // NOTE: if this error occurs "unreasonably", attemp to avoid unnecesary unification
   // See for example PrefVal peg.id equality inspection.
-  const sawCount = ctx.seen.get(saw) ?? 0
+  const sawCount = ctx.seen[saw] ?? 0
   if (MAXCYCLE < sawCount) {
     // console.log('SAW', sawCount, saw, a?.id, a?.canon, b?.id, b?.canon, ctx.cc)
     out = makeNilErr(ctx, 'unify_cycle', a, b)
   }
   else {
-    ctx.seen.set(saw, sawCount + 1)
+    ctx.seen[saw] = sawCount + 1
 
     try {
       let unified = false
@@ -133,7 +118,7 @@ const unite = (ctx: AontuContext, a: any, b: any, whence: string) => {
         out = update(b, a)
         why = 'bn'
       }
-      else if (a.isConjunct || a.isExpect || a.isSpread) {
+      else if (a.isConjunct || a.isExpect) {
         out = a.unify(b, te ? ctx.clone({ explain: ec(te, 'AC') }) : ctx)
         unified = true
         why = 'a*'
@@ -141,11 +126,10 @@ const unite = (ctx: AontuContext, a: any, b: any, whence: string) => {
       else if (
         b.isConjunct
         || b.isDisjunct
-        || b.isPath
+        || b.isRef
         || b.isPref
         || b.isFunc
         || b.isExpect
-        || b.isSpread
       ) {
         out = b.unify(a, te ? ctx.clone({ explain: ec(te, 'BW') }) : ctx)
         unified = true
@@ -185,11 +169,6 @@ const unite = (ctx: AontuContext, a: any, b: any, whence: string) => {
 
   ctx.explain && explainClose(te, out)
 
-  // Store in id-keyed cache when both operands were done.
-  if (a?.done && b?.done && out?.done && ctx._uniteCache !== undefined) {
-    ctx._uniteCache.set(a.id + '|' + b.id, out)
-  }
-
   return out
 }
 
@@ -200,269 +179,6 @@ function update(x: Val, _y: Val) {
 }
 
 
-// Resolve all PathVals using the pre-collected paths list.
-// Mutates the tree in place, replacing each PathVal with its cloned target.
-function resolvePaths(root: Val, ctx: AontuContext, paths: PathVal[]) {
-  for (const pv of paths) {
-    if (pv.done) continue
-
-    // Resolve: find target, following chains.
-    // Suppress errors during pre-resolution — intermediate PathVals
-    // (from multi-dot expressions like ..a.q) may fail here but the
-    // final PathVal resolves correctly during unification.
-    const savedErr = ctx.err
-    ctx.err = []
-    let found: any = pv.find(ctx)
-    ctx.err = savedErr
-    if (found == null || found.isNil) continue
-
-    // Skip if target or container contains a mark-setting function
-    // (type/hide/move) — let unification resolve it first.
-    if (hasMarkFunc(found)) continue
-    if (hasMarkFuncAtPath(root, pv.path)) continue
-
-    while (found instanceof PathVal) {
-      if (found.done && found._resolved) {
-        found = found._resolved
-        break
-      }
-      const next = found.find(ctx)
-      if (next == null || next.isNil) break
-      found.dc = DONE
-      found._resolved = next
-      found = next
-    }
-
-    // If found value is a key() function, set its path to the
-    // destination so it evaluates at the right position.
-    if (found.isKeyFunc) {
-      found.path = pv.path
-    }
-
-    pv.dc = DONE
-    pv._resolved = found
-
-    // Replace PathVal in tree using its path
-    replaceAtPath(root, pv.path, pv, found)
-
-    // Walk the placed value to resolve any PathVals cloned into it
-    resolveNestedPaths(found, ctx)
-  }
-}
-
-
-// Check if a value contains a type() or hide() function.
-// Check if the value AT the path position is inside a mark-setting function.
-function hasMarkFuncAtPath(root: Val, path: string[]): boolean {
-  let node: any = root
-  for (let i = 0; i < path.length; i++) {
-    const part = path[i]
-    if (node.isMap || node.isList) {
-      node = node.peg[part]
-    }
-    else if (node.isConjunct || node.isDisjunct) {
-      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 false
-    }
-    if (node == null) return false
-  }
-  return hasMarkFunc(node)
-}
-
-
-function hasMarkFunc(val: any): boolean {
-  if (val == null || !val.isVal) return false
-  if (val.isTypeFunc || val.isHideFunc || val.isMoveFunc) return true
-  if (val.isConjunct || val.isDisjunct) {
-    for (const t of val.peg) {
-      if (hasMarkFunc(t)) return true
-    }
-  }
-  return false
-}
-
-
-// Resolve any PathVals found inside a value (e.g. cloned subtrees).
-// Iterative stack-based walk — no recursion.
-function resolveNestedPaths(val: any, ctx: AontuContext) {
-  const stack: any[] = [val]
-  while (stack.length > 0) {
-    const v = stack.pop()
-    if (v == null || !v.isVal) continue
-
-    if (v.isMap || v.isList) {
-      for (const k in v.peg) {
-        const child = v.peg[k]
-        if (child instanceof PathVal && !child.done) {
-          const found = child.find(ctx)
-          if (found != null && !found.isNil) {
-            v.peg[k] = found
-            child.dc = DONE
-            child._resolved = found
-            stack.push(found)
-          }
-        }
-        else if (child?.isVal) {
-          stack.push(child)
-        }
-      }
-    }
-    else if (v.isConjunct || v.isDisjunct) {
-      for (let i = 0; i < v.peg.length; i++) {
-        const child = v.peg[i]
-        if (child instanceof PathVal && !child.done) {
-          const found = child.find(ctx)
-          if (found != null && !found.isNil) {
-            v.peg[i] = found
-            child.dc = DONE
-            child._resolved = found
-            stack.push(found)
-          }
-        }
-        else if (child?.isVal) {
-          stack.push(child)
-        }
-      }
-    }
-    else if (v.isFeature) {
-      if (v.peg instanceof PathVal && !v.peg.done) {
-        const found = v.peg.find(ctx)
-        if (found != null && !found.isNil) {
-          v.peg.dc = DONE
-          v.peg._resolved = found
-          v.peg = found
-          stack.push(found)
-        }
-      }
-      else if (Array.isArray(v.peg)) {
-        for (let i = 0; i < v.peg.length; i++) {
-          if (v.peg[i]?.isVal) stack.push(v.peg[i])
-        }
-      }
-      else if (v.peg?.isVal) {
-        stack.push(v.peg)
-      }
-    }
-  }
-}
-
-
-// Replace target Val in the tree, using path to navigate and a stack
-// to search through junctions, features, and nested structures.
-// No recursion — uses a single loop with an explicit stack.
-function replaceAtPath(root: Val, path: string[], target: Val, replacement: Val,
-  intoSpreads: boolean = true): boolean {
-  let node: any = root
-
-  // Descend through map/list using path segments.
-  // When a non-map/list is encountered (junction, feature),
-  // push its children onto the search stack and stop descending.
-  let pi = 0
-  for (; pi < path.length; pi++) {
-    if (node.isMap || node.isList) {
-      const child = node.peg[path[pi]]
-      if (child == null) break
-
-      // Last segment: check for direct replacement
-      if (pi === path.length - 1) {
-        if (child === target) {
-          node.peg[path[pi]] = replacement
-          return true
-        }
-        // Target not at this position — search within child
-        node = child
-        pi++
-        break
-      }
-
-      node = child
-    }
-    else {
-      // Hit a non-navigable node — search it
-      break
-    }
-  }
-
-  // If path fully consumed with no match, or hit a junction/feature,
-  // search the current node using a stack.
-  const stack: any[] = [node]
-
-  while (stack.length > 0) {
-    const val = stack.pop()
-    if (val == null || !val.isVal) continue
-
-    if (val.isMap || val.isList) {
-      for (const k in val.peg) {
-        if (val.peg[k] === target) {
-          val.peg[k] = replacement
-          return true
-        }
-        if (val.peg[k]?.isVal) stack.push(val.peg[k])
-      }
-    }
-    else if (val.isConjunct || val.isDisjunct) {
-      for (let i = 0; i < val.peg.length; i++) {
-        if (val.peg[i] === target) {
-          val.peg[i] = replacement
-          return true
-        }
-        stack.push(val.peg[i])
-      }
-    }
-    else if (val.isFeature) {
-      if (val.peg === target) {
-        val.peg = replacement
-        return true
-      }
-      if (intoSpreads || !val.isSpread) {
-        if (Array.isArray(val.peg)) {
-          for (let i = 0; i < val.peg.length; i++) {
-            if (val.peg[i] === target) {
-              val.peg[i] = replacement
-              return true
-            }
-            if (val.peg[i]?.isVal) stack.push(val.peg[i])
-          }
-        }
-        else if (val.peg?.isVal) {
-          stack.push(val.peg)
-        }
-      }
-    }
-  }
-
-  return false
-}
-
-
-// Resolve all KeyFuncVals (not inside spreads) to StringVals.
-// Uses the KeyFuncVal's path to determine the key name.
-function resolveKeys(root: Val, keys: KeyFuncVal[]) {
-  for (const kv of keys) {
-    const resolved = kv.resolve(null as any, kv.peg)
-    if (resolved instanceof StringVal) {
-      resolved.dc = DONE
-      resolved.path = kv.path
-      replaceAtPath(root, kv.path, kv, resolved, false)
-    }
-  }
-}
-
-
 class Unify {
   root: Val
   res: Val
@@ -513,28 +229,15 @@ class Unify {
       uctx.err = this.err
       uctx.explain = this.explain
 
-      // Path resolution phase: replace all PathVals with cloned targets.
-      // Pure structural replacement — no unification.
-      resolvePaths(res, uctx, this.lang.paths)
-      uctx = uctx.clone({ root: res })
-
-      // Key resolution phase: replace key() functions (not in spreads)
-      // with their resolved StringVal.
-      resolveKeys(res, this.lang.keys)
-
       const explain = null == ctx?.explain ? undefined : ctx?.explain
       const te = explain && explainOpen(uctx, explain, 'root', res)
 
       // NOTE: if true === res.done already, then this loop never needs to run.
-      // RefVals defer on cc=0 and while ctx.sc > 0.
-      // SpreadVal.unify maintains ctx.sc via increment/decrement.
       let maxcc = 9 // 99
       for (; this.cc < maxcc && DONE !== res.dc; this.cc++) {
         // console.log('CC', this.cc, res.canon)
         uctx.cc = this.cc
-        uctx.seen = new Map()
-        uctx._refCloneCache = new Map()
-        uctx._uniteCache = new Map()
+        uctx.seen = {}
         res = unite(te ? uctx.clone({ explain: ec(te, 'run') }) : uctx, res, top(), 'unify')
 
         if (0 < uctx.err.length) {