aontu 0.52.1 → 0.53.0

package/src/val/ListVal.ts

@@ -17,6 +17,8 @@ import { unite } from '../unify'
 
 import {
   propagateMarks,
+  canonRiders,
+  constantIdFunc,
   explainOpen,
   ec,
   explainClose,
@@ -32,6 +34,8 @@ import {
 import { ConjunctVal } from './ConjunctVal'
 import { NilVal } from './NilVal'
 import { BagVal } from './BagVal'
+import { repathInstance } from './Val'
+import { markSpread } from '../provenance'
 
 
 class ListVal extends BagVal {
@@ -55,7 +59,10 @@ class ListVal extends BagVal {
     if (spread) {
       if ('&' === spread.o) {
 
-        // TODO: handle existing spread!
+        // Multiple same-level spreads conjoin; an unequal spread from
+        // another statement meets this one in unify's combination
+        // below (see the MapVal constructor note — the combined
+        // template is stateless, BUGS.md §6-§7).
         this.spread.cj =
           Array.isArray(spread.v) ?
             1 < spread.v.length ?
@@ -63,6 +70,22 @@ class ListVal extends BagVal {
               spread.v[0] :
             spread.v
 
+        // Clearing rule 3 (G4 phase 1): a CONSTANT id in the template
+        // would declare every child to be one entity. The refusal
+        // replaces the template, so it reaches every child and the
+        // bag itself (see the isNil arm where the spread is applied)
+        // as ONE nil identity — made here, once, rather than per
+        // pass, so the report names it once.
+        const idfn: any = constantIdFunc(this.spread.cj)
+        if (undefined !== idfn) {
+          const nil: any = new NilVal({ why: 'id_spread' }, ctx)
+          nil.site.row = idfn.site.row
+          nil.site.col = idfn.site.col
+          nil.site.url = idfn.site.url
+          nil.primary = idfn
+          this.spread.cj = nil
+        }
+
         // let tmv = Array.isArray(spread.v) ? spread.v : [spread.v]
         // this.spread.cj = new ConjunctVal({ peg: tmv }, ctx)
       }
@@ -121,24 +144,81 @@ class ListVal extends BagVal {
 
       let spread_cj = out.spread.cj || TOP
 
+      // The template REFUSED at construction (clearing rule 3, G4
+      // phase 1): the bag itself is that refusal. Returning the nil
+      // here rather than only letting it reach the children is what
+      // makes an EMPTY bag with a bad template an error too — there
+      // are no children to carry it.
+      //
+      // Narrow to THIS code on purpose. A nil spread from any other
+      // cause keeps its existing behaviour of driving every key
+      // (coverage3 `nil-spread-drives-every-key`): a template that has
+      // merely not resolved yet must not permanently kill the bag that
+      // holds it.
+      if ('id_spread' === (spread_cj as any).why) {
+        return spread_cj
+      }
+
       // Always unify 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]
 
         propagateMarks(this, child)
 
-        // child is non-nullish: propagateMarks above dereferences it.
-        out.peg[key] =
-          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, 'PEG:' + key) }) : keyctx,
-                      child, key_spread_cj, 'list-own')
+        // APPLIED ONCE PER ELEMENT, the guard MapVal has carried since
+        // the spread was written: an element that already holds this
+        // template's contribution is progressed by self-unification
+        // instead of having the template met into it a second time.
+        // Re-applying is the identity for a template that has already
+        // RESOLVED, which is why the missing guard went unnoticed here
+        // — but a template that residuates (`&: id(key(1))`, G8 phase
+        // 0) is not yet a value to be idempotent about, so each pass
+        // conjoined another copy and the element's canon DOUBLED per
+        // pass. The old `ctx.cc < 3` key delay hid it by ending the
+        // growth at three passes; the staging rule waits for the model
+        // to settle, and a model whose canon doubles every pass never
+        // does.
+        let oval: Val
+        if (!spread_cj.isTop
+          && (child as any)._spr === (spread_cj as any).id) {
+          oval = child.done ? child :
+            unite(te ? keyctx.clone({ explain: ec(te, 'PEG:' + key) }) : keyctx,
+              child, TOP, 'list-own')
+          ; (oval as any)._spr = (spread_cj as any).id
+        }
+        else {
+          const key_spread_cj = spread_cj.spreadClone(keyctx)
+          // The spread mark the provenance recorder reads (G7 phase 3),
+          // as in MapVal: this is where a template becomes a per-element
+          // contribution. Instrumented runs only.
+          if (undefined !== keyctx.prov) {
+            markSpread(key_spread_cj)
+          }
+
+          // child is non-nullish: propagateMarks above dereferences it.
+          oval =
+            child.isNil ? child :
+                key_spread_cj.isNil ? key_spread_cj :
+                  // The no-op meet is SKIPPED on the normal path (it is the
+                  // identity) but TAKEN while recording: a value written once
+                  // and never met is still a contribution the author wants
+                  // pointed at, and the Go port's unite sees that meet (G7
+                  // phase 4). Instrumented runs pay knowingly.
+                  key_spread_cj.isTop && child.done && undefined === keyctx.prov
+                    ? child :
+                    child.isTop && key_spread_cj.done ? key_spread_cj :
+                      unite(te ? keyctx.clone({ explain: ec(te, 'PEG:' + key) }) : keyctx,
+                        child, key_spread_cj, 'list-own')
+
+          if (!spread_cj.isTop && !oval.isNil) {
+            ; (oval as any)._spr = (spread_cj as any).id
+          }
+        }
+
+        out.peg[key] = oval
 
-        done = (done && DONE === out.peg[key].dc)
+        done = (done && DONE === oval.dc)
       }
 
       const allowedKeys: string[] = this.closed ? Object.keys(this.peg) : []
@@ -171,6 +251,9 @@ class ListVal extends BagVal {
 
           if (this.spread.cj) {
             let key_spread_cj = spread_cj.spreadClone(peerctx)
+            if (undefined !== peerctx.prov) {
+              markSpread(key_spread_cj)
+            }
 
             oval = out.peg[peerkey] =
               unite(te ? peerctx.clone({ explain: ec(te, 'PSP:' + peerkey) }) : peerctx,
@@ -226,7 +309,11 @@ class ListVal extends BagVal {
     }
 
     if (!allScalarKind) {
-      return this.clone(ctx)
+      // A full instance (`dup`, ADR-005), paths normalised to the
+      // destination: see Val.spreadClone and repathInstance.
+      const out = this.clone(ctx, { dup: true })
+      repathInstance(out, out.path)
+      return out
     }
 
     let out = (super.clone(ctx) as ListVal)
@@ -249,12 +336,16 @@ class ListVal extends BagVal {
 
   clone(ctx: AontuContext, spec?: ValSpec): Val {
     let out = (super.clone(ctx, spec) as ListVal)
+    // The instantiation flag descends with the mark (ADR-005): a
+    // template's elements are part of the instance.
+    const childspec = spec?.mark || spec?.dup ?
+      { mark: spec?.mark, dup: spec?.dup } : {}
     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]
+        (entry[1] as any)?.isVal ? (entry[1] as Val).clone(ctx, childspec) : entry[1]
     }
     if (this.spread.cj) {
-      out.spread.cj = this.spread.cj.clone(ctx, spec?.mark ? { mark: spec.mark } : {})
+      out.spread.cj = this.spread.cj.clone(ctx, childspec)
     }
 
     out.closed = this.closed
@@ -280,7 +371,9 @@ class ListVal extends BagVal {
       // key. The Go port's ListVal.Canon has no such arm either, and the
       // two canons must agree -- a canon is round-trippable, and a marker
       // on an element the grammar cannot produce would not reparse.
-      keys.map(k => this.peg[k].canon).join(',') +
+      // canonRiders, not .canon: a deprecated element renders
+      // back as its `deprecate(x, m)` call, reparseably (G3).
+      keys.map(k => canonRiders(this.peg[k])).join(',') +
       ']'
   }
 } /* node:coverage ignore next 8 */

package/src/val/LowerFuncVal.ts

@@ -13,7 +13,6 @@ import {
 import { makeNilErr } from '../err'
 
 
-import { NilVal } from '../val/NilVal'
 import { ScalarKindVal } from '../val/ScalarKindVal'
 import { makeScalarLike } from '../val/valutil'
 import { Decimal } from '../val/Decimal'

package/src/val/MapVal.ts

@@ -16,6 +16,8 @@ import { unite } from '../unify'
 
 import {
   propagateMarks,
+  canonRiders,
+  constantIdFunc,
   walk,
   explainOpen,
   ec,
@@ -32,7 +34,9 @@ import {
 import { ConjunctVal } from './ConjunctVal'
 import { NilVal } from './NilVal'
 import { BagVal } from './BagVal'
+import { repathInstance } from './Val'
 import { cmpCodePoint } from '../keyorder'
+import { markSpread } from '../provenance'
 
 
 // Structural snapshots of ref spreads (see MapVal.unify), keyed by the
@@ -60,7 +64,9 @@ function snapshotRefSpread(cj: any, ctx: AontuContext): Val | undefined {
   const sk = spreadSnapKey(cj)
   let snap: Val | undefined = snapmap.get(sk)
   if (undefined === snap) {
-    let tgt: Val | undefined = cj.find(ctx)
+    // snap mode: the pending-mark-wrapper defer in find must not
+    // apply here — the snapshot WANTS the pre-resolution structure.
+    let tgt: Val | undefined = cj.find(ctx, true)
     // 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]
@@ -104,13 +110,34 @@ class MapVal extends BagVal {
 
     if (spread) {
       if ('&' === spread.o) {
-        // TODO: handle existing spread!
+        // Multiple same-level spreads arrive as an array and conjoin;
+        // an unequal spread arriving from ANOTHER statement meets this
+        // one in unify's spread combination below — sound since the
+        // combined template became stateless (pure ExpectVal, BUGS.md
+        // §6-§7): each child meets the combined constraint
+        // independently and children never meet each other's data.
         this.spread.cj =
           Array.isArray(spread.v) ?
             1 < spread.v.length ?
               new ConjunctVal({ peg: spread.v }, ctx) :
               spread.v[0] :
             spread.v
+
+        // Clearing rule 3 (G4 phase 1): a CONSTANT id in the template
+        // would declare every child to be one entity. The refusal
+        // replaces the template, so it reaches every child and the
+        // bag itself (see the isNil arm where the spread is applied)
+        // as ONE nil identity — made here, once, rather than per
+        // pass, so the report names it once.
+        const idfn: any = constantIdFunc(this.spread.cj)
+        if (undefined !== idfn) {
+          const nil: any = new NilVal({ why: 'id_spread' }, ctx)
+          nil.site.row = idfn.site.row
+          nil.site.col = idfn.site.col
+          nil.site.url = idfn.site.url
+          nil.primary = idfn
+          this.spread.cj = nil
+        }
       }
     }
 
@@ -184,6 +211,13 @@ class MapVal extends BagVal {
         // 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).
+        //
+        // The combined template must stay STATELESS: this meet wraps a
+        // key present in only one side as an ExpectVal, the combined
+        // map is shared across destinations when path-independent
+        // (spreadClone tier 1), and a stateful expect accumulated the
+        // first sibling's data and met it into the next (BUGS.md
+        // §6-§7). ExpectVal.unify is pure for exactly this reason.
         out.spread.cj = null == out.spread.cj ? peer.spread.cj : (
           null == peer.spread.cj ? out.spread.cj :
             out.spread.cj.canon === peer.spread.cj.canon ? out.spread.cj :
@@ -204,6 +238,21 @@ class MapVal extends BagVal {
 
       let spread_cj = out.spread.cj ?? TOP
 
+      // The template REFUSED at construction (clearing rule 3, G4
+      // phase 1): the bag itself is that refusal. Returning the nil
+      // here rather than only letting it reach the children is what
+      // makes an EMPTY bag with a bad template an error too — there
+      // are no children to carry it.
+      //
+      // Narrow to THIS code on purpose. A nil spread from any other
+      // cause keeps its existing behaviour of driving every key
+      // (coverage3 `nil-spread-drives-every-key`): a template that has
+      // merely not resolved yet must not permanently kill the bag that
+      // holds it.
+      if ('id_spread' === (spread_cj as any).why) {
+        return spread_cj
+      }
+
       // 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
@@ -252,11 +301,25 @@ class MapVal extends BagVal {
         else {
           const key_spread_cj = spread_cj.spreadClone(keyctx)
 
+          // The one place a spread is APPLIED, so the one place that
+          // knows a contribution came from a template rather than
+          // from the key itself (G7 phase 3). Only when someone is
+          // recording: the walk is O(template) per key per pass.
+          if (undefined !== keyctx.prov) {
+            markSpread(key_spread_cj)
+          }
+
           // child is non-nullish: propagateMarks above dereferences it.
           oval =
             child.isNil ? child :
                 key_spread_cj.isNil ? key_spread_cj :
-                  key_spread_cj.isTop && child.done ? child :
+                  // The no-op meet is SKIPPED on the normal path (it is the
+                  // identity) but TAKEN while recording: a value written once
+                  // and never met is still a contribution the author wants
+                  // pointed at, and the Go port's unite sees that meet (G7
+                  // phase 4). Instrumented runs pay knowingly.
+                  key_spread_cj.isTop && child.done && undefined === keyctx.prov
+                    ? 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')
@@ -268,6 +331,7 @@ class MapVal extends BagVal {
 
         out.peg[key] = oval
 
+
         done = (done && DONE === oval.dc)
       }
 
@@ -296,7 +360,19 @@ class MapVal extends BagVal {
           const peerctx = ctx.descend(peerkey)
 
           let oval = out.peg[peerkey] =
-            undefined === child ? this.handleExpectedVal(peerkey, peerchild, this, ctx) :
+            // A peer-only key is CARRIED, not met — except on an
+            // instrumented run, where the identity meet is taken so
+            // the recorder sees where the value came from. The Go port
+            // unites a genable peer-only child with TOP unconditionally
+            // (go/mapval.go), and the difference was invisible until
+            // G4's identity merge brought a peer whose children the
+            // recorder counts as WRITTEN: `why $.b.k` on two positions
+            // of one entity named the site in Go and answered "nothing
+            // met here" in TypeScript.
+            undefined === child
+              ? (undefined !== peerctx.prov && peerchild.isGenable
+                ? unite(peerctx, peerchild, TOP, 'map-peer-only')
+                : this.handleExpectedVal(peerkey, peerchild, this, ctx)) :
               child.isTop && peerchild.done ? peerchild :
                 child.isNil ? child :
                   peerchild.isNil ? peerchild :
@@ -382,7 +458,11 @@ class MapVal extends BagVal {
     }
 
     if (!allScalarKind) {
-      return this.clone(ctx)
+      // A full instance (`dup`, ADR-005), paths normalised to the
+      // destination: see Val.spreadClone and repathInstance.
+      const out = this.clone(ctx, { dup: true })
+      repathInstance(out, out.path)
+      return out
     }
 
     let out = (super.clone(ctx) as MapVal)
@@ -414,12 +494,17 @@ class MapVal extends BagVal {
           // (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]]
+            path: [...out.path, entry[0]],
+            // The instantiation flag descends (ADR-005): a template's
+            // children are part of the instance.
+            dup: spec?.dup,
           }) :
           entry[1]
     }
     if (this.spread.cj) {
-      out.spread.cj = this.spread.cj.clone(ctx, spec?.mark ? { mark: spec.mark } : {})
+      out.spread.cj = this.spread.cj.clone(ctx,
+        spec?.mark || spec?.dup ?
+          { mark: spec?.mark, dup: spec?.dup } : {})
     }
 
     out.closed = this.closed
@@ -450,7 +535,13 @@ class MapVal extends BagVal {
           JSON.stringify(k) +
           (this.optionalKeys.includes(k) ? '?' : '') +
           ':' +
-          (this.peg[k]?.canon ?? this.peg[k])
+          // canonRiders, not .canon: a deprecated field renders
+          // back as its `deprecate(x, m)` call, reparseably (G3). The
+          // guard is the isVal FLAG, never the canon getter: computing
+          // canon in the guard and again in the render doubles the
+          // recursion per level, which is 2^depth on a nested document.
+          (true === this.peg[k]?.isVal
+            ? canonRiders(this.peg[k]) : this.peg[k])
         ])
         .join(',') +
       '}' // + '<' + (this.mark.hide ? 'H' : '') + '>'

package/src/val/MatchFuncVal.ts

@@ -0,0 +1,176 @@
+/* Copyright (c) 2025 Richard Rodger, MIT License */
+
+// GENERATION: `match(v, p1, r1, p2, r2, …, d?)` (G8 phase 2,
+// docs/capability-review/g8-generation.md). A BOUNDED conditional:
+// alternating pattern/result arguments and an optional trailing
+// default. The first pattern IN ARGUMENT ORDER that `v` unifies with
+// SELECTS its result, and the result is the answer.
+//
+// The design said the answer was `v & p & r` -- the scrutinee narrowed
+// by the arm rather than replaced by it. That cannot be what a match
+// is for: it makes every arm whose result is not already a `v` a
+// contradiction, and the design's own example
+// (`match($.tier, small, {cpu:1}, …)`, a string scrutinee and map
+// results) cannot be evaluated at all under it. A match MAPS a value
+// to another value; a document that wants the scrutinee kept can say
+// so, because the scrutinee is a value it can name.
+//
+//   size: match($.tier, small, {cpu:1}, large, {cpu:8}, {cpu:2})
+//
+// WHAT KEEPS IT FROM BECOMING A CONDITIONAL LANGUAGE. The scrutinee is
+// matched by UNIFIABILITY only: no boolean guards, no comparisons
+// beyond what the constraint atoms already are, no fallthrough (first
+// match wins, in a spec-pinned order), and no way to write a pattern
+// that is not an ordinary Aontu value. The whole form is total.
+//
+// NO MATCH AND NO DEFAULT IS AN ERROR, not an empty answer, and the
+// report names the patterns that were tried -- the admissible-
+// alternatives shape (G2's error contract). A default is how a
+// document says it meant to allow the rest.
+//
+// A RESULT IS NOT EVALUATED UNTIL IT IS SELECTED. Only the scrutinee
+// and the patterns are driven; an unselected result never runs, so a
+// broken arm nobody takes is not an error the document has to carry
+// (which multi-error collection, G2 phase 6, would otherwise report).
+
+import type {
+  Val,
+  ValSpec,
+} from '../type'
+
+import {
+  AontuContext,
+} from '../ctx'
+
+import { makeNilErr } from '../err'
+import { top } from './top'
+import { prefInnerPeg } from './PrefVal'
+import { FuncBaseVal, trialUnify } from './FuncBaseVal'
+
+
+// THE DEFAULTED-SCRUTINEE RULE (ADR-004, use-cases/BUGS.md §5). The
+// generation-effective view of a settled scrutinee: a preference — or
+// a disjunction carrying one — means "this value unless something
+// overrides it", and by resolve time the model has SETTLED (staging
+// rule), so nothing will. The value generation is about to emit is
+// therefore the value the patterns must be tested against. Testing
+// against the still-open preference instead let a pattern SELECT an
+// arm by overriding the default: `side_effect:*readonly|write|
+// destructive` beside `match(.side_effect, destructive, true, false)`
+// answered `true` while generating "readonly" next to it — a derived
+// value contradicting the very value it derives from, exit 0.
+// A pref-free scrutinee (open disjunction included) is untouched:
+// matching by unifiability is its documented meaning.
+// Exported for the multi-pref unit test (ADR-002, the subsumeNode
+// precedent): rankPrefs leaves a settled disjunct at most one pref, so
+// the min-rank scan below cannot be reached through a document.
+export function effectiveScrutinee(v: Val): Val {
+  let out: any = v
+  if (true === out?.isDisjunct && Array.isArray(out.peg)) {
+    const prefs = out.peg.filter((m: any) => true === m?.isPref)
+    if (0 === prefs.length) {
+      return v
+    }
+    // Generation picks the LOWEST rank (effectiveDefault in
+    // subsume.ts; `a:**1|*2` generates 2). rankPrefs leaves at most
+    // one pref standing in a settled disjunct, so the scan is
+    // defensive.
+    out = prefs.reduce((a: any, b: any) => b.rank < a.rank ? b : a)
+  }
+  return prefInnerPeg(out)
+}
+
+
+class MatchFuncVal extends FuncBaseVal {
+  isMatchFunc = true
+
+  // THE STAGING RULE (G8 phase 0). A scrutinee that is still being
+  // narrowed can match an EARLIER pattern than the one it will end up
+  // matching, and the arm a match takes is not a thing to guess at.
+  staged = true
+
+  constructor(
+    spec: ValSpec,
+    ctx?: AontuContext
+  ) {
+    super(spec, ctx)
+  }
+
+
+  funcname() {
+    return 'match'
+  }
+
+
+  prepare(_ctx: AontuContext, _args: Val[]) {
+    return null
+  }
+
+
+  // The scrutinee is argument 0 and the patterns are the odd
+  // arguments; the results are the even ones after 0, and the last
+  // argument is a DEFAULT when the count is even. Written once, read
+  // by both the driver below and resolve.
+  hasDefault() {
+    return 0 === this.peg.length % 2
+  }
+
+
+  unify(peer: Val, ctx: AontuContext): Val {
+    // The scrutinee and the PATTERNS are driven; the results are not
+    // (see the header). driveStagedArgs takes a prefix, so the odd
+    // positions are driven one at a time.
+    let ready = this.driveStagedArgs(ctx, 1)
+    const last = this.peg.length - (this.hasDefault() ? 1 : 0)
+    for (let i = 1; i < last; i += 2) {
+      const arg: Val = this.peg[i]
+      if (!arg.done) {
+        this.peg[i] = arg.unify(top(), ctx)
+      }
+      ready = ready && true === this.peg[i].done
+    }
+
+    if (!ready || !ctx.settle) {
+      return this.residuate(peer, ctx)
+    }
+
+    return super.unify(peer, ctx)
+  }
+
+
+  resolve(ctx: AontuContext, args: Val[]) {
+    const scrutinee: Val = effectiveScrutinee(args[0])
+    const dflt: Val | undefined = this.hasDefault() ?
+      args[args.length - 1] : undefined
+    const last = args.length - (undefined === dflt ? 0 : 1)
+
+    const tried: string[] = []
+
+    for (let i = 1; i < last; i += 2) {
+      const pattern: Val = args[i]
+      tried.push(pattern.canon)
+
+      // The trial is against CLONES: `unite` refines a bag in place
+      // against a TOP peer, and a pattern that failed must be
+      // untouched for the next document that reads its canon.
+      if (undefined !== trialUnify(ctx, scrutinee.clone(ctx), pattern.clone(ctx))) {
+        return args[i + 1].clone(ctx)
+      }
+    }
+
+    if (undefined !== dflt) {
+      return dflt.clone(ctx)
+    }
+
+    return makeNilErr(ctx, 'match_none', this, undefined, 'resolve', {
+      value: scrutinee.canon,
+      tried: tried.join(' '),
+    })
+  }
+
+} /* node:coverage ignore next 5 */
+
+
+export {
+  MatchFuncVal,
+}

package/src/val/MoveFuncVal.ts

@@ -12,7 +12,6 @@ import {
 
 import { makeNilErr } from '../err'
 
-import { NilVal } from '../val/NilVal'
 
 import {
   walk
@@ -21,7 +20,6 @@ import {
 
 
 import { FuncBaseVal } from './FuncBaseVal'
-import { CopyFuncVal } from './CopyFuncVal'
 import { PrefFuncVal } from './PrefFuncVal'
 
 

package/src/val/NilVal.ts

@@ -79,6 +79,31 @@ class NilVal extends Val {
       }
     }
 
+    // THE PATH IS WHERE THE MEET IS, NOT WHERE THE OPERAND WAS WRITTEN
+    // (use-cases/BUGS.md §41). The operand path above decides the SITE
+    // correctly and the path only by accident: a value that arrives by
+    // REFERENCE is re-pathed to the referring field, and its children
+    // are re-pathed to that same field rather than rebased under it, so
+    // every conflict inside `q: $.M` reported `$.q` — the enclosing
+    // record, not the key to edit, and the SAME path for every one of
+    // its fields. The context has descended to the child by the time
+    // the meet fails, and Go reads the path off the tree position for
+    // exactly this reason.
+    //
+    // Only EXTENDS, never redirects: the context path is taken when the
+    // operand's path is a PREFIX of it, so a nil minted away from the
+    // descent (a func resolving an argument, a generator's own probe,
+    // an anchored `--at` run whose operand is already correctly placed)
+    // keeps the path its operand carries. Taking the context path
+    // unconditionally was tried and reverted -- it moved the closed-key,
+    // spread-template and every `--at` finding to the driving location,
+    // which is not where those belong.
+    if (null != ctx?.path && null != nil.path &&
+      nil.path.length < ctx.path.length &&
+      nil.path.every((p, i) => p === ctx.path[i])) {
+      nil.path = [...ctx.path]
+    }
+
     if (ctx) {
       ctx.adderr(nil)
     }

package/src/val/OpBaseVal.ts

@@ -31,6 +31,7 @@ import {
 
 import { ConjunctVal } from './ConjunctVal'
 import { FeatureVal } from './FeatureVal'
+import { hasPlace, fillPlace } from './PlaceVal'
 
 
 
@@ -66,6 +67,17 @@ class OpBaseVal extends FeatureVal {
 
 
   unify(peer: Val, ctx: AontuContext): Val {
+
+    // THE PLACEHOLDER (G8 phase 3, see PlaceVal), on the operator side:
+    // `x: {&: {m: _ + 2}}` meeting `1` is `3`. Same rule as
+    // FuncBaseVal's -- the peer fills the hole and the operation is
+    // what answers.
+    if (!peer.isTop && !peer.isNil && this.id !== peer.id && hasPlace(this)) {
+      if (hasPlace(peer)) {
+        return makeNilErr(ctx, 'place_pair', this, peer)
+      }
+      return fillPlace(this, peer, ctx).unify(top(), ctx)
+    }
     const te = ctx.explain && explainOpen(ctx, ctx.explain, 'Op:' + this.opname(), this, peer)
     // Declared without an initial value: every arm below assigns it, and
     // seeding it with `this` made the two arms that stand the op read as
@@ -165,10 +177,17 @@ class OpBaseVal extends FeatureVal {
   }
 
 
-  clone(ctx: AontuContext, _spec?: ValSpec): Val {
+  clone(ctx: AontuContext, spec?: ValSpec): Val {
     let out = (super.clone(ctx, {
       peg: this.peg,
     }) as OpBaseVal)
+    // THE PER-DESTINATION INSTANTIATION RULE (ADR-005): an operation
+    // inside a template clones its operands as instances — the
+    // default clone shares them (see FuncBaseVal.clone). Every
+    // operand is a Val by construction, as in the Go twin's []Val.
+    if (true === spec?.dup) {
+      out.peg = this.peg.map((a: Val) => a.clone(ctx, { dup: true }))
+    }
     return out
   }