aontu 0.40.0 → 0.42.0

package/src/val/ConjunctVal.ts

@@ -36,6 +36,57 @@ import {
   top
 } from './top'
 
+import { MapVal } from './MapVal'
+
+
+// Shallow merge two MapVals: combine keys without deep unification.
+// For shared keys, merge child terms from both maps into one ConjunctVal
+// so spreads at that level see all children from both terms.
+function shallowMerge(a: MapVal, b: MapVal, ctx: AontuContext): MapVal {
+  const out = new MapVal({ peg: {} }, ctx)
+  out.site = a.site
+  out.closed = a.closed || b.closed
+  out.optionalKeys = [...a.optionalKeys]
+  for (const k of b.optionalKeys) {
+    if (!out.optionalKeys.includes(k)) out.optionalKeys.push(k)
+  }
+
+  let done = true
+
+  // Copy all keys from a
+  for (const k in a.peg) {
+    out.peg[k] = a.peg[k]
+  }
+
+  // Merge keys from b
+  for (const k in b.peg) {
+    if (k in out.peg) {
+      const av = out.peg[k]
+      const bv = b.peg[k]
+
+      // Flatten both sides' terms into a single ConjunctVal
+      const terms: Val[] = []
+      if (av.isConjunct) { terms.push(...av.peg) } else { terms.push(av) }
+      if (bv.isConjunct) { terms.push(...bv.peg) } else { terms.push(bv) }
+
+      out.peg[k] = new ConjunctVal({ peg: terms }, ctx)
+      done = false
+    }
+    else {
+      out.peg[k] = b.peg[k]
+    }
+  }
+
+  for (const k in out.peg) {
+    done = done && (DONE === out.peg[k]?.dc)
+  }
+
+  out.dc = done ? DONE : 1
+  propagateMarks(a, out)
+  propagateMarks(b, out)
+  return out
+}
+
 
 
 // TODO: move main logic to op/conjunct
@@ -71,6 +122,11 @@ class ConjunctVal extends JunctionVal {
   unify(peer: Val, ctx: AontuContext): Val {
     peer = peer ?? top()
 
+    // Fast path: done conjunct self-unifying with TOP.
+    if (this.done && peer.isTop) {
+      return this
+    }
+
     const te = ctx.explain && explainOpen(ctx, ctx.explain, 'Conjunct', this, peer)
 
     let done = true
@@ -96,8 +152,13 @@ class ConjunctVal extends JunctionVal {
       this.peg[vI].mark.hide = newhide
       // console.log('CONJUNCT-TERM', this.id, vI, this.peg[vI].canon)
 
+      // Defer unify-with-TOP for map terms with spreads when other
+      // map terms exist — the shallow merge fold handles them instead.
+      const hasMapPeers = this.peg.length > 1 && this.peg[vI].isMap &&
+        this.peg.some((p: Val, i: number) => i !== vI && p.isMap)
       upeer[vI] = (this.peg[vI].done && peer.isTop) ? this.peg[vI] :
-        unite(ctx.clone({ explain: ec(te, 'OWN') }), this.peg[vI], peer, 'cj-own')
+        (hasMapPeers && hasSpreads(this.peg[vI])) ? this.peg[vI] :
+        unite(te ? ctx.clone({ explain: ec(te, 'OWN') }) : ctx, this.peg[vI], peer, 'cj-own')
 
       upeer[vI].mark.type = newtype = newtype || upeer[vI].mark.type
       upeer[vI].mark.hide = newhide = newhide || upeer[vI].mark.hide
@@ -117,7 +178,22 @@ class ConjunctVal extends JunctionVal {
     }
 
     upeer = norm(upeer)
-    // console.log('CONJUNCT-UPEER', this.id, upeer.map((v: Val) => v.canon))
+
+    // Stable partition: fold pure terms first, spread-bearing terms
+    // last. Pure terms (no spreads, no path-dependent functions)
+    // unify cheaply. Dynamic terms are then folded in, applying
+    // spread constraints once to the merged result rather than
+    // incrementally at every intermediate fold step.
+    const pure: Val[] = []
+    const dyn: Val[] = []
+    for (const term of upeer) {
+      if (term.isPathDependent || hasSpreads(term)) {
+        dyn.push(term)
+      } else {
+        pure.push(term)
+      }
+    }
+    upeer = pure.concat(dyn)
 
     // Unify terms against each other
 
@@ -141,25 +217,36 @@ class ConjunctVal extends JunctionVal {
 
       // Can't unite with a RefVal, unless also a RefVal with same path.
       // else if (t0 instanceof RefVal && !(t1 instanceof RefVal)) {
-      else if (t0.isRef && !(t1.isRef)) {
+      else if (t0.isPath && !(t1.isPath)) {
         outvals.push(t0)
         t0 = t1
       }
 
-      else if (t1.isRef && !(t0.isRef)) {
+      else if (t1.isPath && !(t0.isPath)) {
         outvals.push(t0)
         t0 = t1
       }
 
 
+      // Shallow merge: when both are maps AND the conjunct contains spreads,
+      // combine keys into inner ConjunctVals instead of deep unification.
+      // This ensures spreads see ALL children across terms before being applied.
+      else if (t0.isMap && t1.isMap && (hasSpreads(t0) || hasSpreads(t1))) {
+        const merged = shallowMerge(t0 as any, t1 as any, ctx)
+        done = done && DONE === merged.dc
+        newtype = this.mark.type || merged.mark.type
+        newhide = this.mark.hide || merged.mark.hide
+        t0 = merged
+      }
+
       else {
-        val = unite(ctx.clone({ explain: ec(te, 'DEF') }), t0, t1, 'cj-peer-t0t1')
+        val = unite(te ? ctx.clone({ explain: ec(te, 'DEF') }) : ctx, t0, t1, 'cj-peer-t0t1')
         // console.log('CONJUNCT-T', t0.canon, t1?.canon, '->', val.canon)
         done = done && DONE === val.dc
         newtype = this.mark.type || val.mark.type
         newhide = this.mark.hide || val.mark.hide
 
-        // Unite was just a conjunt anyway, so discard.
+        // Unite was just a conjunct anyway, so discard.
         if (val.isConjunct) {
           outvals.push(t0)
           t0 = t1
@@ -215,6 +302,15 @@ class ConjunctVal extends JunctionVal {
 
 
   gen(ctx?: AontuContext) {
+    // If this conjunct contains a SpreadVal + a generable Val,
+    // gen the generable Val (spread is an unresolved constraint
+    // that's a no-op at gen time — e.g., empty map with spread).
+    if (this.peg.length === 2) {
+      const [a, b] = this.peg
+      if (a.isSpread && b.isGenable) return b.gen(ctx as any)
+      if (b.isSpread && a.isGenable) return a.gen(ctx as any)
+    }
+
     // Unresolved conjunct cannot be generated, so always an error.
     let nil = makeNilErr(
       ctx,
@@ -247,18 +343,17 @@ class ConjunctVal extends JunctionVal {
 function norm(terms: Val[]): Val[] {
 
   let expand: Val[] = []
-  for (let tI = 0, pI = 0; tI < terms.length; tI++, pI++) {
-    if (terms[tI].isConjunct) {
-      const cterms = terms[tI].peg
-      for (let cI = 0; cI < cterms.length; cI++) {
-        expand[pI + cI] = cterms[cI]
+  function flattenTerms(terms: Val[]) {
+    for (let tI = 0; tI < terms.length; tI++) {
+      if (terms[tI].isConjunct) {
+        flattenTerms(terms[tI].peg)
+      }
+      else {
+        expand.push(terms[tI])
       }
-      pI += cterms.length - 1
-    }
-    else {
-      expand[pI] = terms[tI]
     }
   }
+  flattenTerms(terms)
 
 
   // Consistent ordering ensures order independent unification.
@@ -282,6 +377,29 @@ function norm(terms: Val[]): Val[] {
 }
 
 
+// Check if a Val tree contains any SpreadVal constraints.
+// Cached on _hasSpreads for performance.
+function hasSpreads(v: any): boolean {
+  if (v._hasSpreads !== undefined) return v._hasSpreads
+  let result = false
+  if (v.isSpread) {
+    result = true
+  }
+  else if (v.isMap || v.isList) {
+    for (const k in v.peg) {
+      if (v.peg[k]?.isVal && hasSpreads(v.peg[k])) { result = true; break }
+    }
+  }
+  else if (v.isJunction) {
+    for (const p of v.peg) {
+      if (p?.isVal && hasSpreads(p)) { result = true; break }
+    }
+  }
+  v._hasSpreads = result
+  return result
+}
+
+
 export {
   norm,
   ConjunctVal,

package/src/val/CopyFuncVal.ts

@@ -61,9 +61,10 @@ class CopyFuncVal extends FuncBaseVal {
 
     // console.log('CR', out)
 
-    if (!out.isRef) {
+    if (!out.isPath) {
+      out.mark.type = false
+      out.mark.hide = false
       walk(out, (_key: string | number | undefined, val: Val) => {
-        // console.log('WALK', val)
         val.mark.type = false
         val.mark.hide = false
         return val

package/src/val/DisjunctVal.ts

@@ -30,7 +30,8 @@ import {
   top
 } from './top'
 
-import { NilVal } from '../val/NilVal'
+
+import { NilVal, TRIAL_NIL } from '../val/NilVal'
 import { PrefVal } from '../val/PrefVal'
 import { JunctionVal } from '../val/JunctionVal'
 
@@ -67,6 +68,11 @@ class DisjunctVal extends JunctionVal {
   unify(peer: Val, ctx: AontuContext): Val {
     peer = peer ?? top()
 
+    // Fast path: already-done disjunct unifying with TOP.
+    if (this.done && peer.isTop) {
+      return this
+    }
+
     const te = ctx.explain && explainOpen(ctx, ctx.explain, 'Disjunct', this, peer)
 
     if (!this.prefsRanked) {
@@ -79,21 +85,46 @@ class DisjunctVal extends JunctionVal {
 
     let oval: Val[] = []
 
-    // Conjunction (&) distributes over disjunction (|)
+    // Conjunction (&) distributes over disjunction (|).
+    //
+    // Each member is tried against peer in isolation: if that trial
+    // produces any errors, the member fails and is marked with a NilVal.
+    // Previously this used `ctx?.clone({err: []})` per member - a
+    // per-iteration context clone (two Object.creates) just to hold a
+    // throwaway error array. For schemas with many disjunctions
+    // (e.g. `*true | boolean`, `method: GET | PUT | ...`) this was the
+    // single largest source of clones in the unify hot path.
+    //
+    // Swap-and-restore avoids the clone: the existing ctx's err array
+    // is saved, replaced with a fresh array for each trial, then
+    // restored. ctx mutation is scoped to this loop and fully undone
+    // before return.
+    const savedErr = ctx.err
+    const savedTrialMode = ctx._trialMode
+    // C1-inner: tell `makeNilErr` to return TRIAL_NIL in this scope
+    // instead of allocating per-failure NilVals. Save/restore so
+    // nested DisjunctVal trials (and the outer non-trial code) are
+    // not affected.
+    ctx._trialMode = true
     for (let vI = 0; vI < this.peg.length; vI++) {
       const v = this.peg[vI]
-      const cloneCtx = ctx?.clone({ err: [] })
+      const trialErr: any[] = []
+      ctx.err = trialErr
 
-      // // // console.log('DJ-DIST-A', this.peg[vI].canon, peer.canon)
-      oval[vI] = unite(cloneCtx.clone({ explain: ec(te, 'DIST:' + vI) }), v, peer, 'dj-peer')
-      // // // console.log('DJ-DIST-B', oval[vI].canon, cloneCtx?.err)
+      oval[vI] = unite(te ? ctx.clone({ explain: ec(te, 'DIST:' + vI) }) : ctx, v, peer, 'dj-peer')
 
-      if (0 < cloneCtx?.err.length) {
-        oval[vI] = makeNilErr(cloneCtx, '|:empty-dist', this)
+      if (0 < trialErr.length) {
+        // C1: failed-trial marker is never user-visible — it just
+        // signals "this disjunct member doesn't match" and is
+        // filtered out before the result is built. Use the shared
+        // sentinel instead of allocating a fresh NilVal per trial.
+        oval[vI] = TRIAL_NIL
       }
 
       done = done && DONE === oval[vI].dc
     }
+    ctx._trialMode = savedTrialMode
+    ctx.err = savedErr
 
     // // // console.log('DISJUNCT-unify-B', this.id, oval.map(v => v.canon))
 
@@ -107,12 +138,13 @@ class DisjunctVal extends JunctionVal {
 
       // // // console.log('DISJUNCT-unify-C', this.id, oval.map(v => v.id + '=' + v.canon))
 
-      // TODO: not an error Nil!
-      let remove = new NilVal()
+      // Dedup: duplicate Vals in the disjunct are replaced with the
+      // trial sentinel, which is filtered out a few lines below.
+      // (No need for a fresh NilVal — any isNil value gets filtered.)
       for (let vI = 0; vI < oval.length; vI++) {
         for (let kI = vI + 1; kI < oval.length; kI++) {
           if (oval[kI].same(oval[vI])) {
-            oval[kI] = remove
+            oval[kI] = TRIAL_NIL
           }
         }
       }

package/src/val/ExpectVal.ts

@@ -49,13 +49,27 @@ class ExpectVal extends FeatureVal {
 
     if (!peer.isTop) {
       this.peer = undefined === this.peer ? peer :
-        unite(ctx.clone({ explain: ec(te, 'PEER') }), this.peer, peer, 'expect-peer')
+        unite(te ? ctx.clone({ explain: ec(te, 'PEER') }) : ctx, this.peer, peer, 'expect-peer')
 
-      const peeru =
-        unite(ctx.clone({ explain: ec(te, 'EXPECT') }), this.peer, this.peg, 'expect-self')
+      // Unwrap nested ExpectVals to prevent infinite recursion
+      let peg = this.peg
+      while (peg?.isExpect) {
+        peg = peg.peg
+      }
 
-      if (peeru.isGenable) {
-        out = peeru
+      // Guard against re-entrant recursion
+      if ((this as any)._expectDepth > 0) {
+        out.dc = this.dc + 1
+      }
+      else {
+        (this as any)._expectDepth = ((this as any)._expectDepth || 0) + 1
+        const peeru =
+          unite(te ? ctx.clone({ explain: ec(te, 'EXPECT') }) : ctx, this.peer, peg, 'expect-self')
+        ;(this as any)._expectDepth--
+
+        if (peeru.isGenable) {
+          out = peeru
+        }
       }
     }
 

package/src/val/FuncBaseVal.ts

@@ -100,7 +100,7 @@ class FuncBaseVal extends FeatureVal {
 
             let newarg = arg
             if (!arg.done) {
-              newarg = arg.unify(TOP, ctx.clone({ explain: ec(te, 'ARG') }))
+              newarg = arg.unify(TOP, te ? ctx.clone({ explain: ec(te, 'ARG') }) : ctx)
               newtype = newtype || newarg.mark.type
               newhide = newhide || newarg.mark.hide
               // console.log('FUNCBASE-UNIFY-PEG-B', arg.canon, arg.done, '->', newarg.canon, newarg.done)
@@ -118,7 +118,7 @@ class FuncBaseVal extends FeatureVal {
           // console.log('FUNC-RESOLVED', ctx.cc, resolved?.canon)
 
           out = resolved.done && peer.isTop ? resolved :
-            unite(ctx.clone({ explain: ec(te, 'PEG') }),
+            unite(te ? ctx.clone({ explain: ec(te, 'PEG') }) : ctx,
               resolved, peer, 'func-' + this.funcname() + '/' + this.id)
           propagateMarks(this, out)
 

package/src/val/IntegerVal.ts

@@ -43,7 +43,7 @@ class IntegerVal extends ScalarVal {
 
     if (null != peer) {
       if (peer.isScalarKind) {
-        out = peer.unify(this, ctx.clone({ explain: ec(te, 'KND') }))
+        out = peer.unify(this, te ? ctx.clone({ explain: ec(te, 'KND') }) : ctx)
       }
       else if (
         peer.isScalar &&

package/src/val/JunctionVal.ts

@@ -17,6 +17,7 @@ import { FeatureVal } from './FeatureVal'
 // (ConjunctVal and DisjunctVal)
 abstract class JunctionVal extends FeatureVal {
   isJunction = true
+  _canonCache?: string
 
   constructor(
     spec: ValSpec,
@@ -38,10 +39,13 @@ abstract class JunctionVal extends FeatureVal {
   }
 
   get canon() {
-    return this.peg.map((v: Val) => {
+    if (this._canonCache !== undefined) return this._canonCache
+    const c = this.peg.map((v: Val) => {
       return (v as any).isJunction && Array.isArray(v.peg) && 1 < v.peg.length ?
         '(' + v.canon + ')' : v.canon // v.id + '=' + v.canon
     }).join(this.getJunctionSymbol()) // + '<' + (this.mark.hide ? 'H' : '') + '>'
+    if (this.done) this._canonCache = c
+    return c
   }
 
   // Abstract method to be implemented by subclasses to define their junction symbol

package/src/val/KeyFuncVal.ts

@@ -18,7 +18,6 @@ import { ConjunctVal } from '../val/ConjunctVal'
 
 import { FuncBaseVal } from './FuncBaseVal'
 
-
 class KeyFuncVal extends FuncBaseVal {
   isKeyFunc = true
 
@@ -41,14 +40,12 @@ class KeyFuncVal extends FuncBaseVal {
 
 
   unify(peer: Val, ctx: AontuContext): Val {
-    // TODO: this delay makes keys in spreads and refs work, but it is a hack - find a better way.
     let out: Val = this
 
     if (ctx.cc < 3) {
       this.notdone()
 
       if (peer.isTop || (peer.id === this.id)) {
-        // TODO: clone needed to avoid triggering unify_cycle - find a better way
         out = this.clone(ctx)
       }
       else if (peer.isNil) {

package/src/val/ListVal.ts

@@ -9,7 +9,6 @@ import type {
 
 import {
   DONE,
-  SPREAD,
 } from '../type'
 
 import { AontuContext } from '../ctx'
@@ -30,7 +29,6 @@ import {
   top
 } from './top'
 
-import { ConjunctVal } from './ConjunctVal'
 import { NilVal } from './NilVal'
 import { BagVal } from './BagVal'
 import { empty } from './Val'
@@ -38,6 +36,7 @@ import { empty } from './Val'
 
 class ListVal extends BagVal {
   isList = true
+  _canonCache?: string
 
   constructor(
     spec: {
@@ -51,24 +50,6 @@ class ListVal extends BagVal {
       throw new AontuError('ListVal spec.peg undefined')
     }
 
-    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
-
-        // let tmv = Array.isArray(spread.v) ? spread.v : [spread.v]
-        // this.spread.cj = new ConjunctVal({ peg: tmv }, ctx)
-      }
-    }
   }
 
 
@@ -86,24 +67,16 @@ class ListVal extends BagVal {
     let out: ListVal | NilVal = (peer.isTop ? this : new ListVal({ peg: [] }, ctx))
 
     out.closed = this.closed
-    out.optionalKeys = [...this.optionalKeys]
-    out.spread.cj = this.spread.cj
+    out.optionalKeys = 0 < this.optionalKeys.length ? [...this.optionalKeys] : this.optionalKeys
     out.site = this.site
 
     if (peer instanceof ListVal) {
       if (!this.closed && peer.closed) {
-        out = peer.unify(this, ctx.clone({ explain: ec(te, 'PMC') })) as ListVal
+        out = peer.unify(this, te ? ctx.clone({ explain: ec(te, 'PMC') }) : ctx) as ListVal
         exit = true
       }
       else {
         out.closed = out.closed || peer.closed
-        out.spread.cj = null == out.spread.cj ? peer.spread.cj : (
-          null == peer.spread.cj ? out.spread.cj : (
-            out.spread.cj =
-            unite(ctx.clone({ explain: ec(te, 'SPR') }),
-              out.spread.cj, peer.spread.cj, 'list-peer')
-          )
-        )
       }
     }
 
@@ -111,29 +84,39 @@ class ListVal extends BagVal {
     if (!exit) {
       out.dc = this.dc + 1
 
-      let spread_cj = out.spread.cj || TOP
+      // Fast path: self-unify with TOP.
+      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
+        }
+      }
 
-      // Always unify children first
+      // Unify own children
       for (let key in this.peg) {
         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 ? key_spread_cj :
+          undefined === child ? top() :
             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(keyctx.clone({ explain: ec(te, 'PEG:' + key) }),
-                      child, key_spread_cj, 'list-own')
+              child.done ? child :
+                unite(te ? keyctx.clone({ explain: ec(te, 'PEG:' + key) }) : keyctx,
+                  child, top(), 'list-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 ListVal) {
@@ -141,11 +124,10 @@ class ListVal extends BagVal {
           te ? ctx.clone({ explain: ec(te, 'PER') }) : ctx,
           peer, TOP, 'list-peer-list') as ListVal)
 
-        // NOTE: peerkey is the index
         for (let peerkey in upeer.peg) {
           let peerchild = upeer.peg[peerkey]
 
-          if (this.closed && !allowedKeys.includes(peerkey)) {
+          if (this.closed && !(peerkey in this.peg)) {
             bad = makeNilErr(ctx, 'closed', peerchild, undefined)
           }
 
@@ -155,19 +137,11 @@ class ListVal extends BagVal {
 
           let oval = out.peg[peerkey] =
             undefined === child ? peerchild :
-              child.isTop && peerchild.done ? peerchild :
-                child.isNil ? child :
-                  peerchild.isNil ? peerchild :
-                    unite(te ? peerctx.clone({ explain: ec(te, 'CHD') }) : peerctx,
-                      child, peerchild, 'list-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,
-                out.peg[peerkey], key_spread_cj, 'list-spread')
-          }
+                child.isTop && peerchild.done ? peerchild :
+                  child.isNil ? child :
+                    peerchild.isNil ? peerchild :
+                      unite(te ? peerctx.clone({ explain: ec(te, 'CHD') }) : peerctx,
+                        child, peerchild, 'list-peer')
 
           propagateMarks(this, oval)
 
@@ -197,35 +171,18 @@ class ListVal extends BagVal {
   }
 
 
-  // Spread clone: only deep-clone children that are path-dependent
-  // (isFunc, isRef). Share all other children directly.
-  // Spread clone: when all children are ScalarKindVal (simple type
-  // constraints like `string`, `number`), share them directly to avoid
-  // N x M allocations. ScalarKindVal is safe to share: it is immutable,
-  // always done, never path-dependent, and never has marks mutated.
-  // For anything more complex, fall back to full deep clone.
+  // Spread clone: share path-independent children directly, clone
+  // only path-dependent ones. See MapVal.spreadClone for rationale.
   spreadClone(ctx: AontuContext): Val {
-    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)
-    }
+    if (!this.isPathDependent) return this
 
     let out = (super.clone(ctx) as ListVal)
 
     for (let entry of Object.entries(this.peg)) {
-      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,
+      const child = entry[1] as Val
+      out.peg[entry[0]] = child?.isPathDependent
+        ? child.clone(ctx, { mark: {} })
+        : child
     }
 
     out.closed = this.closed
@@ -241,10 +198,6 @@ class ListVal extends BagVal {
       out.peg[entry[0]] =
         (entry[1] as any)?.isVal ? (entry[1] as Val).clone(ctx, spec?.mark ? { mark: spec.mark } : {}) : 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]
 
@@ -254,18 +207,19 @@ class ListVal extends BagVal {
 
 
   get canon() {
+    if (this._canonCache !== undefined) return this._canonCache
     // console.log('LISTVAL-CANON', this.optionalKeys)
     let keys = Object.keys(this.peg)
-    return '' +
+    const c = '' +
       // this.errcanon() +
       '[' +
-      (this.spread.cj ? '&:' + this.spread.cj.canon +
-        (0 < keys.length ? ',' : '') : '') +
       keys
         .map(k => this.optionalKeys.includes(k) ?
           k + '?:' + this.peg[k].canon :
           this.peg[k].canon).join(',') +
       ']'
+    if (this.done) this._canonCache = c
+    return c
   }
 }