tutuca 0.13.3 → 0.14.0

package/dist/tutuca-cli.js

@@ -1039,8 +1039,68 @@ var init_immer2 = __esm({
 });
 
 // src/path.js
-function warnRawDynStep(op, step) {
-  console.warn(`Path.${op} reached a DynStep: call toTransactionPath() first`, step);
+function stepToJson(step) {
+  if (step instanceof SeqStep) return { f: step.field, k: step.key };
+  if (step instanceof FieldStep) return { f: step.field };
+  if (step instanceof SeqAccessStep) return { f: step.seqField, a: step.keyField };
+  return null;
+}
+function stepFromJson(j) {
+  if (j == null || typeof j.f !== "string") return null;
+  if (j.k !== void 0) return new SeqStep(j.f, j.k);
+  if (j.a !== void 0) return new SeqAccessStep(j.f, j.a);
+  return new FieldStep(j.f);
+}
+function pathToJson(path) {
+  const out = [];
+  for (const step of path.steps) {
+    const j = stepToJson(step);
+    if (j === null) return null;
+    out.push(j);
+  }
+  return out;
+}
+function pathFromJson(j) {
+  if (!Array.isArray(j)) return null;
+  const steps = [];
+  for (const item of j) {
+    const step = stepFromJson(item);
+    if (step === null) return null;
+    steps.push(step);
+  }
+  return new Path(steps);
+}
+function walkItems(stack, items, renderPath, path) {
+  let prev = stack.it;
+  for (const step of items) {
+    const next = step.lookup(prev, NONE);
+    if (next === NONE) {
+      console.warn("bad PathItem", { root: stack.it, step, path });
+      return null;
+    }
+    renderPath = renderPath.pushItem(step);
+    stack = step.enterFrame(stack, next, renderPath);
+    prev = next;
+  }
+  return [stack, renderPath];
+}
+function keyedPath(path, key) {
+  const steps = path.steps;
+  const last = steps[steps.length - 1];
+  if (last instanceof SeqStep || last instanceof FieldStep)
+    return new Path(steps.slice(0, -1).concat(new SeqStep(last.field, key)));
+  return null;
+}
+function renderPathText(path) {
+  return JSON.stringify(pathToJson(path));
+}
+function parseRenderPath(text) {
+  try {
+    return pathFromJson(JSON.parse(text));
+  } catch (err) {
+    console.warn("bad render path", err, text);
+    return null;
+  }
 }
 function metaChain(n) {
   const out = [];
@@ -1061,15 +1121,18 @@ function findHandlers(comp, eventIds, vid, eventName) {
   }
   return null;
 }
-function resolvePathStep(comp, nodeIds, vid) {
-  for (let i = 0; i < nodeIds.length; i++) {
-    const ctx = new StepCtx(comp, nodeIds, i, vid);
-    const step = ctx.resolveNode().toPathStep(ctx);
-    if (step !== null) return step;
+function resolvePathPart(comp, nodeRefs, vid) {
+  for (let i = 0; i < nodeRefs.length; i++) {
+    const ref = nodeRefs[i];
+    if (ref.base != null) return { base: ref.base };
+    if (ref.nid === void 0 || ref.nid === null) continue;
+    const ctx = new StepCtx(comp, nodeRefs, i, vid);
+    const step = ctx.resolveNode()?.toPathStep(ctx) ?? null;
+    if (step !== null) return { step };
   }
   return null;
 }
-var NONE, readKey, writeKey, writeSeqKey, Step, BindStep, ScopeBindStep, FieldStep, SeqStep, SeqAccessStep, EachBindStep, EachRenderItStep, DynStep, DynEachStep, Path, StepCtx, NO_EVENT_INFO, BUBBLING_EVENTS, PathBuilder;
+var NONE, readKey, writeKey, writeSeqKey, Step, BindStep, ScopeBindStep, FieldStep, SeqStep, SeqAccessStep, EachBindStep, EachRenderItStep, Path, EMPTY_PATH, DispatchPath, StepCtx, NO_EVENT_INFO, BUBBLING_EVENTS, PathBuilder;
 var init_path = __esm({
   "src/path.js"() {
     init_collection();
@@ -1100,8 +1163,11 @@ var init_path = __esm({
       }
       setDraftValue(_root, _v) {
       }
-      enterFrame(stack, next) {
-        return stack.enter(next, {}, true);
+      // Re-enter this step while rebuilding a stack. `renderPath` is the dispatch
+      // position AFTER this step: a rebuilt frame must carry the same render path
+      // the renderer had there, or the provides it publishes would be located wrong.
+      enterFrame(stack, next, renderPath) {
+        return stack.enter(next, {}, true, renderPath);
       }
       toAbstractPathStep() {
         return this;
@@ -1126,8 +1192,8 @@ var init_path = __esm({
       lookup(v, _dval) {
         return v;
       }
-      enterFrame(stack, next) {
-        return stack.enter(next, { ...this.binds }, false);
+      enterFrame(stack, next, renderPath) {
+        return stack.enter(next, { ...this.binds }, false, renderPath);
       }
       withIndex(i) {
         return new _BindStep({ ...this.binds, key: i });
@@ -1144,9 +1210,9 @@ var init_path = __esm({
         super(binds);
         this.val = val;
       }
-      enterFrame(stack, next) {
+      enterFrame(stack, next, renderPath) {
         const dyn = this.val.evalAsHandler(stack)?.call(stack.it) ?? {};
-        return stack.enter(next, { ...this.binds, ...dyn }, false);
+        return stack.enter(next, { ...this.binds, ...dyn }, false, renderPath);
       }
       withIndex(i) {
         return new _ScopeBindStep(this.val, { ...this.binds, key: i });
@@ -1189,8 +1255,8 @@ var init_path = __esm({
         const seq = readKey(root, this.field, null);
         if (seq != null) writeSeqKey(seq, this.key, v);
       }
-      enterFrame(stack, next) {
-        return stack.enter(next, { key: this.key }, true);
+      enterFrame(stack, next, renderPath) {
+        return stack.enter(next, { key: this.key }, true, renderPath);
       }
       toKey() {
         return { field: this.field, key: this.key };
@@ -1236,57 +1302,21 @@ var init_path = __esm({
       }
       // Replay the renderer's per-item binds (key, value + any @enrich-with binds)
       // so a rebuilt stack matches the one @each rendered with.
-      enterFrame(stack, next) {
-        return stack.enter(next, this.iterInfo.enrichBinds(stack, this.key), false);
+      enterFrame(stack, next, renderPath) {
+        return stack.enter(next, this.iterInfo.enrichBinds(stack, this.key), false, renderPath);
       }
       toAbstractPathStep() {
         return null;
       }
     };
     EachRenderItStep = class extends SeqStep {
-      enterFrame(stack, next) {
-        return stack.enter(next, { key: this.key, value: next }, false).enter(next, {}, true);
+      enterFrame(stack, next, renderPath) {
+        return stack.enter(next, { key: this.key, value: next }, false, renderPath).enter(next, {}, true, renderPath);
       }
       toAbstractPathStep() {
         return new SeqStep(this.field, this.key);
       }
     };
-    DynStep = class extends Step {
-      constructor(producerCompId, producerSteps) {
-        super();
-        this.producerCompId = producerCompId;
-        this.producerSteps = producerSteps;
-        this.interiorCids = /* @__PURE__ */ new Set();
-      }
-      // Steps spliced into the transaction path in place of this marker.
-      teleportSteps() {
-        return this.producerSteps;
-      }
-      lookup(_v, dval = null) {
-        warnRawDynStep("lookup", this);
-        return dval;
-      }
-      enterFrame(stack, _next) {
-        warnRawDynStep("enterFrame", this);
-        return stack;
-      }
-    };
-    DynEachStep = class extends DynStep {
-      constructor(producerCompId, producerSteps, key) {
-        super(producerCompId, producerSteps);
-        this.key = key;
-      }
-      teleportSteps() {
-        const { producerSteps, key } = this;
-        if (producerSteps.length === 0) return producerSteps;
-        const last = producerSteps[producerSteps.length - 1];
-        if (!(last instanceof FieldStep)) {
-          console.warn("DynEachStep: seq-access dynamic cannot be iterated", this);
-          return producerSteps;
-        }
-        return producerSteps.slice(0, -1).concat(new SeqStep(last.field, key));
-      }
-    };
     Path = class _Path {
       constructor(steps = []) {
         this.steps = steps;
@@ -1297,40 +1327,13 @@ var init_path = __esm({
       popStep() {
         return new _Path(this.steps.slice(0, -1));
       }
-      // The dispatch path: frame-only steps removed, one step per crossed component
-      // (DynStep included). `popStep` over it bubbles through every component.
+      // Frame-only steps removed, one step per crossed component: `popStep` over the
+      // result bubbles through every component.
       compact() {
         const out = [];
         for (const step of this.steps) {
           const s = step.toAbstractPathStep();
-          if (s !== null) {
-            if (s !== step) s._originCid = step._originCid;
-            out.push(s);
-          }
-        }
-        return new _Path(out);
-      }
-      // The abstract path used to apply a transaction: every DynStep is teleported —
-      // the steps interior to its producer..consumer span are dropped and the
-      // producer's own path spliced in — so a mutation lands on the data's real
-      // location. A path with no DynStep is returned unchanged.
-      toTransactionPath() {
-        let hasDyn = false;
-        for (const step of this.steps)
-          if (step instanceof DynStep) {
-            hasDyn = true;
-            break;
-          }
-        if (!hasDyn) return this;
-        const out = [];
-        for (const step of this.steps) {
-          if (step instanceof DynStep) {
-            while (out.length > 0 && step.interiorCids.has(out[out.length - 1]._originCid)) out.pop();
-            for (const ts of step.teleportSteps()) {
-              ts._originCid = step.producerCompId;
-              out.push(ts);
-            }
-          } else out.push(step);
+          if (s !== null) out.push(s);
         }
         return new _Path(out);
       }
@@ -1338,7 +1341,6 @@ var init_path = __esm({
       // key as it is *now* so a later lookup/setValue lands on the same item even if the
       // keyField changed meanwhile (e.g. the selected tab moved while an intent was in
       // flight). Returns a new Path with those steps replaced; `this` if nothing pinned.
-      // Must be called on a transaction path (no DynSteps — call toTransactionPath first).
       pinKeys(root) {
         let curVal = root;
         let out = null;
@@ -1361,8 +1363,8 @@ var init_path = __esm({
       }
       // The values entered along the path, root→leaf (root included): index 0 is `root`,
       // the last entry is the leaf this path resolves to. Stops early at the first
-      // unresolvable step. Call on a transaction path (no DynSteps). Used to walk the
-      // component instances on a dispatch path (filter via Components.getCompFor).
+      // unresolvable step. Used to walk the component instances on a dispatch path
+      // (filter via Components.getCompFor).
       resolveChain(root) {
         const out = [root];
         let curVal = root;
@@ -1376,7 +1378,7 @@ var init_path = __esm({
       // A flat `[{ field, key? }]` list of the addressing steps, skipping frame-only
       // steps (binds). Generic path introspection so tooling (e.g. the storybook
       // activity log) can identify which subtree a transaction touched without
-      // depending on Step internals. Call on a transaction path (no DynSteps).
+      // depending on Step internals.
       toKeys() {
         const out = [];
         for (const step of this.steps) {
@@ -1397,62 +1399,133 @@ var init_path = __esm({
         });
       }
       buildStack(stack) {
-        let prev = stack.it;
-        for (const step of this.steps) {
-          const next = step.lookup(prev, NONE);
-          if (next === NONE) {
-            console.warn("bad PathItem", { root: stack.it, step, path: this });
-            return null;
+        return walkItems(stack, this.steps, stack.renderPath ?? new DispatchPath(), this)?.[0] ?? null;
+      }
+    };
+    EMPTY_PATH = new Path([]);
+    DispatchPath = class _DispatchPath {
+      constructor(frames = [{ base: EMPTY_PATH, items: [] }]) {
+        this.frames = frames;
+      }
+      // Plain addressing steps in one frame based at the root: what a caller means
+      // by "this position" when it has no continuation of its own.
+      static ofSteps(steps) {
+        return new _DispatchPath([{ base: EMPTY_PATH, items: steps.slice() }]);
+      }
+      get top() {
+        return this.frames[this.frames.length - 1];
+      }
+      _withTopItems(items) {
+        const frames = this.frames.slice();
+        frames[frames.length - 1] = { base: this.top.base, items };
+        return new _DispatchPath(frames);
+      }
+      concat(steps) {
+        if (this.frames.length === 0) return _DispatchPath.ofSteps(steps);
+        return this._withTopItems(this.top.items.concat(steps));
+      }
+      pushItem(step) {
+        return this.concat([step]);
+      }
+      pushFrame(base) {
+        return new _DispatchPath(this.frames.concat({ base, items: [] }));
+      }
+      // Whether bubbling has anywhere left to go: another step in this frame, or a
+      // visual caller underneath it.
+      canPop() {
+        const n = this.frames.length;
+        return n > 1 || n === 1 && this.frames[0].items.length > 0;
+      }
+      isRoot() {
+        return this.toTransactionPath().steps.length === 0;
+      }
+      // One component closer to the root. At the top of a frame that is popping back
+      // to the visual caller, not to the producer's own parent — the caller is where
+      // the `*name` was written, and where an unhandled message should keep going.
+      popStep() {
+        const n = this.frames.length;
+        if (n === 0) return this;
+        const top = this.frames[n - 1];
+        if (top.items.length > 0) return this._withTopItems(top.items.slice(0, -1));
+        if (n > 1) return new _DispatchPath(this.frames.slice(0, -1));
+        return this;
+      }
+      // Drop frame-only steps inside every frame independently; a frame's base is
+      // already addressing-only.
+      compact() {
+        return new _DispatchPath(
+          this.frames.map(({ base, items }) => ({ base, items: new Path(items).compact().steps }))
+        );
+      }
+      // A stable string for the ADDRESS this path denotes, for the render cache. The
+      // same immutable value can sit at two places in the tree, and a subtree rendered
+      // at one of them bakes that address in — the provides it publishes are located
+      // there. Frame-only steps address nothing, so they are compacted out: two sites
+      // that differ only in binds do render the same subtree.
+      get addressKey() {
+        this._addressKey ??= renderPathText(this.toTransactionPath().compact());
+        return this._addressKey;
+      }
+      // The active transaction address: the top frame's absolute base followed by
+      // its ordinary descendant steps. This is where a mutation lands.
+      toTransactionPath() {
+        const top = this.top;
+        return top === void 0 ? EMPTY_PATH : top.base.concat(top.items);
+      }
+      // Rebuild the render stack this path was dispatched from. A frame with a base
+      // re-enters at that absolute value first — replaying the resume a `*name`
+      // render performed — and then walks its ordinary items.
+      buildStack(stack) {
+        let renderPath = new _DispatchPath();
+        for (let i = 0; i < this.frames.length; i++) {
+          const { base, items } = this.frames[i];
+          if (i > 0 || base.steps.length > 0) {
+            const baseValue = base.lookup(stack.root, NONE);
+            if (baseValue === NONE) {
+              console.warn("bad frame base", { base, path: this });
+              return null;
+            }
+            renderPath = renderPath.pushFrame(base);
+            stack = stack.enter(baseValue, {}, true, renderPath);
           }
-          stack = step.enterFrame(stack, next);
-          prev = next;
+          const walked = walkItems(stack, items, renderPath, this);
+          if (walked === null) return null;
+          [stack, renderPath] = walked;
         }
         return stack;
       }
       static fromNodeAndEventName(node, eventName, rootNode, maxDepth, comps, stopOnNoEvent = true) {
-        const pathSteps = [];
-        const pendingDyns = [];
+        const parts = [];
         const bubbles = BUBBLING_EVENTS.has(eventName);
         let depth = 0;
         let eventIds = [];
         let handlers = null;
-        let nodeIds = [];
+        let nodeRefs = [];
         let isLeafComponent = true;
         const crossComponent = (cidNum, vid) => {
           const comp = comps.getComponentForId(cidNum);
-          let pushStep = true;
+          let pushPart = true;
           if (handlers === null && (isLeafComponent || bubbles)) {
             handlers = findHandlers(comp, eventIds, vid, eventName);
             if (handlers === null) {
               if (isLeafComponent && stopOnNoEvent && !bubbles) return false;
             } else if (!isLeafComponent) {
-              pathSteps.length = 0;
-              pendingDyns.length = 0;
-              pushStep = false;
+              parts.length = 0;
+              pushPart = false;
             }
           }
           isLeafComponent = false;
-          for (const dyn of pendingDyns) dyn.interiorCids.add(cidNum);
-          if (pushStep) {
-            const step = resolvePathStep(comp, nodeIds, vid);
-            if (step) {
-              step._originCid = cidNum;
-              pathSteps.push(step);
-              if (step instanceof DynStep) {
-                step.interiorCids.add(cidNum);
-                pendingDyns.push(step);
-              }
-            }
+          if (pushPart) {
+            const part = resolvePathPart(comp, nodeRefs, vid);
+            if (part) parts.push(part);
           }
-          for (let i = pendingDyns.length - 1; i >= 0; i--)
-            if (pendingDyns[i].producerCompId === cidNum) pendingDyns.splice(i, 1);
           eventIds = [];
-          nodeIds = [];
+          nodeRefs = [];
           return true;
         };
         while (node && node !== rootNode && depth < maxDepth) {
           if (node?.dataset) {
-            const { eid, cid, vid } = node.dataset;
+            const { eid, cid, vid, rp } = node.dataset;
             if (eid !== void 0) eventIds.push(eid);
             const metas = metaChain(node.previousSibling);
             let sawComp = false;
@@ -1460,19 +1533,27 @@ var init_path = __esm({
               if (m.$ === "Comp") {
                 sawComp = true;
                 if (!crossComponent(m.cid, m.vid)) return NO_EVENT_INFO;
-                nodeIds.push({ nid: m.nid });
+                nodeRefs.push({ nid: m.nid, base: pathFromJson(m.base) });
               } else {
-                nodeIds.push({ nid: m.nid, si: m.si, sk: m.sk });
+                nodeRefs.push({ nid: m.nid, si: m.si, sk: m.sk });
+              }
+            }
+            if (!sawComp && cid !== void 0) {
+              if (!crossComponent(+cid, vid)) return NO_EVENT_INFO;
+              if (rp !== void 0) {
+                const base = parseRenderPath(rp);
+                if (base !== null) nodeRefs.push({ base });
               }
             }
-            if (!sawComp && cid !== void 0 && !crossComponent(+cid, vid)) return NO_EVENT_INFO;
           }
           depth += 1;
           node = node.parentNode;
         }
-        if (pendingDyns.length > 0)
-          console.warn("event reconstruction: dynamic-var producer not found", pendingDyns);
-        return [new _Path(pathSteps.reverse()), handlers];
+        parts.reverse();
+        let path = new _DispatchPath();
+        for (const part of parts)
+          path = part.base !== void 0 ? path.pushFrame(part.base) : path.pushItem(part.step);
+        return [path, handlers];
       }
     };
     StepCtx = class _StepCtx {
@@ -1514,6 +1595,9 @@ var init_path = __esm({
       constructor() {
         this.pathChanges = [];
       }
+      toPath() {
+        return new Path(this.pathChanges);
+      }
       add(pathChange) {
         this.pathChanges.push(pathChange);
         return this;
@@ -2702,13 +2786,16 @@ var init_vdom = __esm({
 });
 
 // src/anode.js
-function resolveDynProducer(comp, name) {
-  const own = comp?.provide?.[name];
-  const producerComp = own != null ? comp : comp?.scope?.lookupProvider(name) ?? null;
-  const producerProvide = own ?? producerComp?.provide?.[name];
-  if (producerComp == null || producerProvide == null) return null;
-  const pi = producerProvide.val?.toPathItem?.() ?? null;
-  return { producerCompId: producerComp.id, producerSteps: pi ? [pi] : [] };
+function renderTarget(val, stack) {
+  if (val instanceof DynVal) {
+    const loc = stack.lookupDynamicLocated(val.name);
+    if (loc?.path == null) return [loc?.value ?? null, stack.renderPath, null];
+    return [loc.value, stack.renderPath.pushFrame(loc.path), loc.path];
+  }
+  const step = val.toPathItem?.() ?? null;
+  if (step === null) return [val.eval(stack), stack.renderPath, null];
+  const path = stack.renderPath.pushItem(step);
+  return [val.eval(stack), path, stack.pendingFrame ? path.toTransactionPath() : null];
 }
 function optimizeChilds(childs) {
   for (let i = 0; i < childs.length; i++) {
@@ -2816,11 +2903,6 @@ function makeWrapperNode(data, px) {
   }
   return node;
 }
-function dynRenderStep(comp, name, key) {
-  const p = resolveDynProducer(comp, name);
-  if (!p) return null;
-  return key === void 0 ? new DynStep(p.producerCompId, p.producerSteps) : new DynEachStep(p.producerCompId, p.producerSteps, key);
-}
 function parseRenderEach(px, value, as, attrs) {
   const seqVal = parseXOpVal("render-each", value, px, parseSequence);
   if (seqVal === null) return null;
@@ -3090,26 +3172,29 @@ var init_anode = __esm({
     };
     RenderNode = class extends RenderViewId {
       render(stack, rx) {
-        const newStack = stack.enter(this.val.eval(stack), {}, true);
-        return rx.renderIt(newStack, this, "", this.evalViewName(stack));
+        const [value, renderPath, base] = renderTarget(this.val, stack);
+        const newStack = stack.enter(value, {}, true, renderPath, false);
+        return rx.renderIt(newStack, this, "", this.evalViewName(stack), base);
       }
+      // A `*name` target contributes no step: the site recorded the absolute base it
+      // resumed at, and event reconstruction turns that into a continuation frame.
       toPathStep(ctx) {
-        if (this.val instanceof DynVal) return dynRenderStep(ctx.comp, this.val.name);
+        if (this.val instanceof DynVal) return null;
         return super.toPathStep(ctx);
       }
     };
     RenderItNode = class extends RenderViewId {
       render(stack, rx) {
-        const newStack = stack.enter(stack.it, {}, true);
-        return rx.renderIt(newStack, this, "", this.evalViewName(stack));
+        const base = stack.pendingFrame ? stack.renderPath.toTransactionPath() : null;
+        const newStack = stack.enter(stack.it, {}, true, stack.renderPath, false);
+        return rx.renderIt(newStack, this, "", this.evalViewName(stack), base);
       }
       toPathStep(ctx) {
         const next = ctx.next();
         if (next === null) return null;
         const nextNode = next.resolveNode();
         if (nextNode instanceof EachNode && next.hasKey) {
-          if (nextNode.val instanceof DynVal)
-            return dynRenderStep(ctx.comp, nextNode.val.name, next.key);
+          if (nextNode.val instanceof DynVal) return null;
           return new EachRenderItStep(nextNode.val.name, next.key);
         }
         return null;
@@ -3199,11 +3284,19 @@ var init_anode = __esm({
         this.iterInfo = new IterInfo(val, null, null, null);
       }
       render(stack, rx) {
-        return rx.renderEachWhen(stack, this.iterInfo, this.node, this.nodeId);
+        return rx.renderEachWhen(stack, this);
       }
       toPathStep(ctx) {
         return ctx.hasKey ? new EachBindStep(this.iterInfo, ctx.key) : null;
       }
+      // Where one item lives, for the render path. `@each` re-binds `it` to the item
+      // whether or not the body is a component, so the position moves either way and
+      // the step has to address it — `.rows` iterated at `key` IS `rows[key]`.
+      // Null for a dynamic sequence: `*rows` carries its own absolute path and enters
+      // a continuation frame instead (see Renderer.renderEachWhen).
+      itemStep(key) {
+        return this.val instanceof FieldVal ? new SeqStep(this.val.name, key) : null;
+      }
       static register = true;
     };
     IterInfo = class {
@@ -3424,11 +3517,227 @@ var init_anode = __esm({
   }
 });
 
+// src/stack.js
+function routeLookup(route, lex, dyn) {
+  for (let i = 0; i < route.length; i++) {
+    const leg = route[i];
+    if (leg === "dyn") {
+      const v = dyn();
+      if (v != null) return v;
+    } else if (leg === "lex") {
+      const v = lex();
+      if (v != null) return v;
+    } else {
+      console.warn("unknown lookup route leg", leg, '- expected "dyn" or "lex"');
+    }
+  }
+  return null;
+}
+function lookup(chain, name, dv = null) {
+  let n = chain;
+  while (n !== null) {
+    const r = n[0].lookup(name);
+    if (r === STOP) return dv;
+    if (r !== NEXT) return r;
+    n = n[1];
+  }
+  return dv;
+}
+function computeViewsId(views) {
+  let s = "";
+  let n = views;
+  while (n !== null) {
+    s += n[0];
+    n = n[1];
+  }
+  return s === "main" ? "" : s;
+}
+var STOP, NEXT, DEFAULT_ROUTE, isTypeName, BindFrame, DynFrame, Stack, NOT_FOUND;
+var init_stack = __esm({
+  "src/stack.js"() {
+    init_path();
+    STOP = /* @__PURE__ */ Symbol("STOP");
+    NEXT = /* @__PURE__ */ Symbol("NEXT");
+    DEFAULT_ROUTE = ["dyn", "lex"];
+    isTypeName = (s) => {
+      const c = s.charCodeAt(0);
+      return c >= 65 && c <= 90;
+    };
+    BindFrame = class {
+      constructor(it, binds, isFrame) {
+        this.it = it;
+        this.binds = binds;
+        this.isFrame = isFrame;
+      }
+      lookup(name) {
+        const v = this.binds[name];
+        return v === void 0 ? this.isFrame ? STOP : NEXT : v;
+      }
+    };
+    DynFrame = class {
+      constructor(binds, types) {
+        this.binds = binds;
+        this.types = types;
+      }
+      lookup(name) {
+        const v = (isTypeName(name) ? this.types : this.binds)[name];
+        return v === void 0 ? NEXT : v;
+      }
+    };
+    Stack = class _Stack {
+      constructor(fields) {
+        Object.assign(this, fields);
+      }
+      _with(patch) {
+        return new _Stack({ ...this, ...patch });
+      }
+      // Evaluate every provide the entered component publishes and push them as one
+      // dynBinds frame, keyed by NAME. A value is published together with the absolute
+      // path it lives at: the same declaration is read as `*name` AND resumed at by
+      // `<x render="*name">`, so a consumer needs both halves. Types go in the same
+      // frame's other map. No-op with no provides.
+      _pushProvides() {
+        const comp = this.comps.getCompFor(this.it);
+        if (comp == null) return this;
+        const { provide, provideType } = comp;
+        const binds = {};
+        const types = {};
+        let has2 = false;
+        const base = this._publishBase();
+        for (const k in provide) {
+          const step = provide[k].val.toPathItem?.() ?? null;
+          if (step === null) continue;
+          const value = provide[k].val.eval(this);
+          binds[k] = { value, path: base === null ? null : base.concat([step]) };
+          has2 = true;
+        }
+        for (const k in provideType) {
+          types[k] = provideType[k];
+          has2 = true;
+        }
+        if (!has2) return this;
+        return this._with({ dynBinds: [new DynFrame(binds, types), this.dynBinds] });
+      }
+      // The absolute address of the component being entered, or null when this
+      // position cannot be written down as one. Frame-only steps carry bindings and
+      // address nothing, so they are compacted away first; what is left is checked
+      // against the value actually being rendered, because a scope CAN move the
+      // render position without contributing an addressing step (a plain `@each`
+      // body re-binds `it` to the item while its rebuild step is an identity).
+      //
+      // A null base still publishes the VALUE — `*name` reads it fine — but there is
+      // nowhere to resume, so `<x render="*name">` renders nothing rather than
+      // editing whatever happens to live at the address we guessed.
+      _publishBase() {
+        const base = this.renderPath.toTransactionPath().compact();
+        return base.lookup(this.root, NOT_FOUND) === this.it ? base : null;
+      }
+      static root(comps, it, ctx = null) {
+        return new _Stack({
+          comps,
+          root: it,
+          it,
+          binds: [new BindFrame(it, {}, true), null],
+          dynBinds: [new DynFrame({}, {}), null],
+          views: ["main", null],
+          viewsId: "",
+          renderPath: new DispatchPath(),
+          pendingFrame: false,
+          ctx
+        })._pushProvides();
+      }
+      // `renderPath` defaults to this stack's own: an ordinary scope does not move.
+      // `pendingFrame` clears on a component frame (which emits the base) and is
+      // inherited by transparent scopes, which have to carry it to the next boundary.
+      enter(it, bindings = {}, isFrame = true, renderPath = this.renderPath, pendingFrame = null) {
+        const stack = this._with({
+          it,
+          binds: [new BindFrame(it, bindings, isFrame), this.binds],
+          renderPath,
+          pendingFrame: pendingFrame ?? (isFrame ? false : this.pendingFrame)
+        });
+        return isFrame ? stack._pushProvides() : stack;
+      }
+      pushViewName(name) {
+        const views = [name, this.views];
+        return this._with({ views, viewsId: computeViewsId(views) });
+      }
+      // Published types are stable per scope and would only churn the render cache, so
+      // the cache key covers values alone.
+      _pushDynBindValuesToArray(arr, comp) {
+        for (const k in comp.provide) arr.push(this.lookupDynamic(k));
+        for (const k in comp.lookup) arr.push(this.lookupDynamic(k));
+      }
+      // `*name`: the nearest binding above (including this component's own provides,
+      // pushed on entering it), else a path registered in the component's lexical
+      // scope, else this component's declared default, else null.
+      //
+      // One chain walk and no producer resolution: a lookup names what it WANTS, so the
+      // frame it wants is keyed by that name. The default belongs to the CONSUMER's
+      // declaration and is evaluated against the consumer's stack, which is why it is
+      // consulted only after the whole chain has missed.
+      lookupDynamicLocated(name) {
+        if (isTypeName(name)) return null;
+        const v = lookup(this.dynBinds, name);
+        if (v != null) return v;
+        const comp = this.comps.getCompFor(this.it);
+        if (comp == null) return null;
+        const path = comp.scope?.lookupPath?.(name) ?? null;
+        if (path !== null) {
+          const value2 = path.lookup(this.root, NOT_FOUND);
+          if (value2 !== NOT_FOUND) return { value: value2, path };
+        }
+        const dval = comp.lookup[name]?.val ?? null;
+        if (dval === null) return null;
+        const step = dval.toPathItem?.() ?? null;
+        const value = dval.eval(this);
+        return step === null ? { value, path: null } : { value, path: this.renderPath.toTransactionPath().concat([step]) };
+      }
+      lookupDynamic(name) {
+        if (isTypeName(name)) return lookup(this.dynBinds, name);
+        return this.lookupDynamicLocated(name)?.value ?? null;
+      }
+      lookupBind(name) {
+        return lookup(this.binds, name);
+      }
+      lookupFieldRaw(name) {
+        return this.it[name] ?? null;
+      }
+      lookupMethod(name) {
+        const fn = this.it[name];
+        return fn instanceof Function ? fn.call(this.it) : null;
+      }
+      // The dispatched DOM event / drag info, read only by EventMemberVal's
+      // `e.<member>` handler args. Null outside a live event transaction.
+      lookupEvent() {
+        return this.ctx?.event ?? null;
+      }
+      lookupDragInfo() {
+        return this.ctx?.dragInfo ?? null;
+      }
+      getHandlerFor(name, key) {
+        return this.comps.getHandlerFor(this.it, name, key);
+      }
+      lookupBestView(views, defaultViewName) {
+        let n = this.views;
+        while (n !== null) {
+          const view = views[n[0]];
+          if (view !== void 0) return view;
+          n = n[1];
+        }
+        return views[defaultViewName];
+      }
+    };
+    NOT_FOUND = /* @__PURE__ */ Symbol("NOT_FOUND");
+  }
+});
+
 // src/components.js
-var COMPONENT, Components, ComponentStack, ProvideInfo, LookupInfo, isString, isTypeName, _rawSpecKeys, KNOWN_SPEC_KEYS, _compId, Component;
+var COMPONENT, Components, ComponentStack, ProvideInfo, LookupInfo, isString, _rawSpecKeys, KNOWN_SPEC_KEYS, _compId, Component;
 var init_components = __esm({
   "src/components.js"() {
     init_anode();
+    init_stack();
     init_value();
     COMPONENT = /* @__PURE__ */ Symbol.for("tutuca.component");
     Components = class {
@@ -3467,12 +3776,14 @@ var init_components = __esm({
         this.byName = {};
         this.intentsByName = {};
         this.macros = {};
+        this.paths = {};
       }
       enter() {
         return new _ComponentStack(this.comps, this);
       }
       registerComponents(comps, opts) {
-        const { aliases: aliases2 = {} } = opts ?? {};
+        const { aliases: aliases2 = {}, paths } = opts ?? {};
+        if (paths) this.registerPaths(paths);
         for (let i = 0; i < comps.length; i++) {
           const Comp = comps[i];
           Comp[COMPONENT].scope = this.enter();
@@ -3486,6 +3797,27 @@ var init_components = __esm({
           else console.warn("alias", alias, "to inexistent component", aliases2[alias]);
         }
       }
+      // Register lowercase names as absolute paths from the app state root. A
+      // descendant that declares one in its `lookup` reads and renders `*name` without
+      // anything above it publishing one — which is what makes a session, a theme or a
+      // host-owned value available in its natural registration scope, instead of forcing
+      // an application root whose only job is to `provide` it. Register on a nested
+      // scope to narrow a name; nearest registration wins.
+      //
+      // Uppercase names are ignored: a component TYPE is what `lookupComponent` already
+      // answers, and a type has no path.
+      registerPaths(paths) {
+        for (const name in paths) {
+          if (isTypeName(name)) {
+            console.warn("registerPaths: a type name has no path", name);
+            continue;
+          }
+          this.paths[name] = paths[name].toPath?.() ?? paths[name];
+        }
+      }
+      lookupPath(name) {
+        return this.paths[name] ?? this.parent?.lookupPath(name) ?? null;
+      }
       registerMacros(macros) {
         for (const key in macros) {
           const lower = key.toLowerCase();
@@ -3517,17 +3849,16 @@ var init_components = __esm({
       lookupComponent(name) {
         return this.byName[name] ?? this.parent?.lookupComponent(name) ?? null;
       }
-      // The component in this scope chain that provides `name`, innermost first. A lookup
-      // names a value without naming its producer, so the render-target teleport
-      // (resolveDynProducer) recovers the producer here instead. Sound because
-      // PROVIDE_NAME_COLLISION keeps a provide name to one producer per chain; with two,
-      // this returns the innermost and the linter has already reported the ambiguity.
-      lookupProvider(name) {
+      // Whether anything in this scope chain provides `name`. Existence only: a lookup
+      // names what it WANTS and takes whoever is nearest above it at render time, so
+      // there is no producer to identify — several components may publish one name and
+      // the live render ancestry decides. Used by the linter to tell a lookup that can
+      // be satisfied from one that never will be.
+      hasProvider(name) {
         for (const compName in this.byName) {
-          const Comp = this.byName[compName];
-          if (Comp.provide?.[name] !== void 0) return Comp;
+          if (this.byName[compName].provide?.[name] !== void 0) return true;
         }
-        return this.parent?.lookupProvider(name) ?? null;
+        return this.parent?.hasProvider(name) ?? false;
       }
       lookupMacro(name) {
         return this.macros[name] ?? this.parent?.lookupMacro(name) ?? null;
@@ -3544,10 +3875,6 @@ var init_components = __esm({
       }
     };
     isString = (v) => typeof v === "string";
-    isTypeName = (s) => {
-      const c = s.charCodeAt(0);
-      return c >= 65 && c <= 90;
-    };
     _rawSpecKeys = "name view style commonStyle globalStyle receive intent alter views provide lookup fields methods statics";
     KNOWN_SPEC_KEYS = new Set(_rawSpecKeys.split(" "));
     _compId = 0;
@@ -5958,7 +6285,6 @@ function checkComponent(Comp, lx = new LintContext(), { wellKnownExtras = EMPTY_
     checkFieldMethodNameCollisions(lx, Comp);
     checkProvidesAreAddressable(lx, Comp);
     checkProvidedTypes(lx, Comp);
-    checkProvideNameCollisions(lx, Comp);
     checkLookupShapes(lx, Comp);
     checkLookupTypesResolve(lx, Comp);
     checkLookupsHaveProviders(lx, Comp);
@@ -6533,19 +6859,6 @@ function checkProvidedTypes(lx, Comp) {
     if (raw !== "self") lx.error(PROVIDE_TYPE_BAD_SHAPE, { name, value: raw });
   }
 }
-function checkProvideNameCollisions(lx, Comp) {
-  const scope = Comp.scope;
-  if (!scope) return;
-  for (const name in Comp.provide) {
-    for (let s = scope; s; s = s.parent) {
-      for (const otherName in s.byName) {
-        const Other = s.byName[otherName];
-        if (Other !== Comp && Other.provide?.[name] !== void 0)
-          lx.error(PROVIDE_NAME_COLLISION, { name, other: Other.name });
-      }
-    }
-  }
-}
 function checkLookupShapes(lx, Comp) {
   const raw = Comp._rawLookup;
   if (!Array.isArray(raw)) {
@@ -6586,7 +6899,7 @@ function checkLookupsHaveProviders(lx, Comp) {
   if (!scope) return;
   for (const name in Comp.lookup) {
     if (isTypeName2(name)) continue;
-    if (scope.lookupProvider?.(name)) continue;
+    if (scope.hasProvider?.(name) || scope.lookupPath?.(name)) continue;
     const info = { name, hasDefault: Comp.lookup[name].val != null };
     if (info.hasDefault) lx.hint(LOOKUP_NO_PROVIDER, info);
     else lx.error(LOOKUP_NO_PROVIDER, info);
@@ -6608,7 +6921,7 @@ function checkUnreferencedDynamics(lx, Comp, referencedDynamics) {
     }
   }
 }
-var KNOWN_COMPONENT_SPEC_KEYS, EMPTY_SET, FRAMEWORK_WELL_KNOWN_EXTRAS, KNOWN_DIRECTIVE_NAMES, isTypeName2, ALT_HANDLER_NOT_DEFINED, ALT_HANDLER_NOT_REFERENCED, DYN_VAL_NOT_DEFINED, DYN_ALIAS_NOT_REFERENCED, PROVIDE_NOT_ADDRESSABLE, PROVIDE_TYPE_BAD_SHAPE, PROVIDE_NAME_COLLISION, LOOKUP_BAD_SHAPE, LOOKUP_NO_PROVIDER, RENDER_IT_OUTSIDE_OF_LOOP, UNKNOWN_EVENT_MODIFIER, RECEIVE_HANDLER_NOT_IMPLEMENTED, EVENT_HANDLER_METHOD_NOT_ALLOWED, HANDLER_NAME_COLLISION, FIELD_VAL_NOT_DEFINED, FIELD_VAL_IS_METHOD, METHOD_VAL_NOT_DEFINED, METHOD_VAL_IS_FIELD, DUPLICATE_ATTR_DEFINITION, IF_NO_BRANCH_SET, UNKNOWN_COMPONENT_NAME, UNKNOWN_MACRO_ARG, UNKNOWN_DIRECTIVE, UNKNOWN_X_OP, UNKNOWN_X_ATTR, X_OP_IGNORES_CHILDREN, MAYBE_DROP_AT_PREFIX, MAYBE_ADD_AT_PREFIX, BAD_VALUE, UNSUPPORTED_EXPR_SYNTAX, BINDING_MEMBER_TOO_DEEP, SUGGEST_BINDING_MEMBER, REDUNDANT_TEMPLATE_STRING, PLACEHOLDERLESS_TEMPLATE_STRING, CONSTANT_CONDITION, UNKNOWN_COMPONENT_SPEC_KEY, COMP_FIELD_BAD_SHAPE, ASYNC_HANDLER, TOP_LEVEL_AT_RULE_IN_SCOPED_STYLE, GLOBAL_SELECTOR_IN_SCOPED_STYLE, FIELD_METHOD_NAME_COLLISION, X_KNOWN_OP_NAMES, X_KNOWN_ATTR_NAMES, HOST_DIRECTIVE_ONLY_NAMES, LEVEL_WARN2, LEVEL_ERROR2, LEVEL_HINT, PARSE_ISSUES, BINDING_MEMBER_TOO_DEEP_RE, UNSUPPORTED_EXPR_GUIDANCE, HTML_LINT_OPTS, NO_WRAPPERS2, ANY_EVENT_MODIFIERS, fixTo, BOOL_CONDITION_ORIGINS, isBoolConditionCtx, ATTR_VAL_CHECKERS, NODE_KIND_TO_CTX, HANDLER_CHANNELS, ASYNC_HANDLER_HELP, NON_NESTABLE_AT_RULE, GLOBAL_LEADING_SELECTOR, IGNORE_DIRECTIVE, blankRun, STYLE_TO_GLOBAL_HELP, KNOWN_LOOKUP_KEYS, LintContext, LintParseContext;
+var KNOWN_COMPONENT_SPEC_KEYS, EMPTY_SET, FRAMEWORK_WELL_KNOWN_EXTRAS, KNOWN_DIRECTIVE_NAMES, isTypeName2, ALT_HANDLER_NOT_DEFINED, ALT_HANDLER_NOT_REFERENCED, DYN_VAL_NOT_DEFINED, DYN_ALIAS_NOT_REFERENCED, PROVIDE_NOT_ADDRESSABLE, PROVIDE_TYPE_BAD_SHAPE, LOOKUP_BAD_SHAPE, LOOKUP_NO_PROVIDER, RENDER_IT_OUTSIDE_OF_LOOP, UNKNOWN_EVENT_MODIFIER, RECEIVE_HANDLER_NOT_IMPLEMENTED, EVENT_HANDLER_METHOD_NOT_ALLOWED, HANDLER_NAME_COLLISION, FIELD_VAL_NOT_DEFINED, FIELD_VAL_IS_METHOD, METHOD_VAL_NOT_DEFINED, METHOD_VAL_IS_FIELD, DUPLICATE_ATTR_DEFINITION, IF_NO_BRANCH_SET, UNKNOWN_COMPONENT_NAME, UNKNOWN_MACRO_ARG, UNKNOWN_DIRECTIVE, UNKNOWN_X_OP, UNKNOWN_X_ATTR, X_OP_IGNORES_CHILDREN, MAYBE_DROP_AT_PREFIX, MAYBE_ADD_AT_PREFIX, BAD_VALUE, UNSUPPORTED_EXPR_SYNTAX, BINDING_MEMBER_TOO_DEEP, SUGGEST_BINDING_MEMBER, REDUNDANT_TEMPLATE_STRING, PLACEHOLDERLESS_TEMPLATE_STRING, CONSTANT_CONDITION, UNKNOWN_COMPONENT_SPEC_KEY, COMP_FIELD_BAD_SHAPE, ASYNC_HANDLER, TOP_LEVEL_AT_RULE_IN_SCOPED_STYLE, GLOBAL_SELECTOR_IN_SCOPED_STYLE, FIELD_METHOD_NAME_COLLISION, X_KNOWN_OP_NAMES, X_KNOWN_ATTR_NAMES, HOST_DIRECTIVE_ONLY_NAMES, LEVEL_WARN2, LEVEL_ERROR2, LEVEL_HINT, PARSE_ISSUES, BINDING_MEMBER_TOO_DEEP_RE, UNSUPPORTED_EXPR_GUIDANCE, HTML_LINT_OPTS, NO_WRAPPERS2, ANY_EVENT_MODIFIERS, fixTo, BOOL_CONDITION_ORIGINS, isBoolConditionCtx, ATTR_VAL_CHECKERS, NODE_KIND_TO_CTX, HANDLER_CHANNELS, ASYNC_HANDLER_HELP, NON_NESTABLE_AT_RULE, GLOBAL_LEADING_SELECTOR, IGNORE_DIRECTIVE, blankRun, STYLE_TO_GLOBAL_HELP, KNOWN_LOOKUP_KEYS, LintContext, LintParseContext;
 var init_lint_check = __esm({
   "tools/core/lint-check.js"() {
     init_anode();
@@ -6646,7 +6959,6 @@ var init_lint_check = __esm({
     DYN_ALIAS_NOT_REFERENCED = "DYN_ALIAS_NOT_REFERENCED";
     PROVIDE_NOT_ADDRESSABLE = "PROVIDE_NOT_ADDRESSABLE";
     PROVIDE_TYPE_BAD_SHAPE = "PROVIDE_TYPE_BAD_SHAPE";
-    PROVIDE_NAME_COLLISION = "PROVIDE_NAME_COLLISION";
     LOOKUP_BAD_SHAPE = "LOOKUP_BAD_SHAPE";
     LOOKUP_NO_PROVIDER = "LOOKUP_NO_PROVIDER";
     RENDER_IT_OUTSIDE_OF_LOOP = "RENDER_IT_OUTSIDE_OF_LOOP";
@@ -6974,7 +7286,7 @@ var init_lint_rules = __esm({
         code: LOOKUP_NO_PROVIDER,
         level: "error",
         group: "Dynamic bindings",
-        summary: "`lookup` name is provided by no component in scope."
+        summary: "`lookup` name is neither provided in scope nor a registered path."
       },
       {
         code: PROVIDE_TYPE_BAD_SHAPE,
@@ -6982,12 +7294,6 @@ var init_lint_rules = __esm({
         group: "Dynamic bindings",
         summary: 'A PascalCase `provide` publishes a component type; its value must be `"self"`.'
       },
-      {
-        code: PROVIDE_NAME_COLLISION,
-        level: "error",
-        group: "Dynamic bindings",
-        summary: "Two components in one scope chain `provide` the same name."
-      },
       // Templates / events
       {
         code: RENDER_IT_OUTSIDE_OF_LOOP,
@@ -7276,15 +7582,13 @@ function lintIdToMessage(id, info) {
     case "DYN_ALIAS_NOT_REFERENCED":
       return `Lookup '${info.name}' is defined but never used — remove it or reference it as '*${info.name}' in a view`;
     case "PROVIDE_NOT_ADDRESSABLE":
-      return `Provide '${info.name}' value '${info.value}' must be a field ('.f') or seq-access ('.s[.k]') — a method/constant can't be a render target`;
+      return `Provide '${info.name}' value '${info.value}' must be a field ('.f') or seq-access ('.s[.k]') — a provide doubles as the path '<x render="*${info.name}">' resumes at, so this one is dropped and '*${info.name}' resolves to nothing`;
     case "LOOKUP_BAD_SHAPE":
       return `Lookup '${info.name}' has an invalid shape: ${info.problem}`;
     case "LOOKUP_NO_PROVIDER":
-      return info.hasDefault ? `Lookup '${info.name}' is provided by no component in scope, so it always resolves to its default` : `Lookup '${info.name}' is provided by no component in scope — add a 'provide' for it, or give this lookup a default`;
+      return info.hasDefault ? `Lookup '${info.name}' is provided by no component in scope and matches no registered path, so it always resolves to its default` : `Lookup '${info.name}' is provided by no component in scope and matches no registered path — add a 'provide' for it, register a path under that name, or give this lookup a default`;
     case "PROVIDE_TYPE_BAD_SHAPE":
       return `Provide '${info.name}' starts uppercase, so it publishes a component type — its value must be 'self', not '${info.value}'`;
-    case "PROVIDE_NAME_COLLISION":
-      return `Provide '${info.name}' is also provided by '${info.other}' in the same scope — one name, one provider, so a lookup can find it`;
     case "UNKNOWN_MACRO_ARG":
       return `Argument '${info.name}' is not declared in macro '${info.macroName}'`;
     case "UNKNOWN_DIRECTIVE":
@@ -12759,165 +13063,6 @@ var init_list = __esm({
   }
 });
 
-// src/stack.js
-function routeLookup(route, lex, dyn) {
-  for (let i = 0; i < route.length; i++) {
-    const leg = route[i];
-    if (leg === "dyn") {
-      const v = dyn();
-      if (v != null) return v;
-    } else if (leg === "lex") {
-      const v = lex();
-      if (v != null) return v;
-    } else {
-      console.warn("unknown lookup route leg", leg, '- expected "dyn" or "lex"');
-    }
-  }
-  return null;
-}
-function lookup(chain, name, dv = null) {
-  let n = chain;
-  while (n !== null) {
-    const r = n[0].lookup(name);
-    if (r === STOP) return dv;
-    if (r !== NEXT) return r;
-    n = n[1];
-  }
-  return dv;
-}
-function computeViewsId(views) {
-  let s = "";
-  let n = views;
-  while (n !== null) {
-    s += n[0];
-    n = n[1];
-  }
-  return s === "main" ? "" : s;
-}
-var STOP, NEXT, DEFAULT_ROUTE, BindFrame, ObjectFrame, Stack;
-var init_stack = __esm({
-  "src/stack.js"() {
-    STOP = /* @__PURE__ */ Symbol("STOP");
-    NEXT = /* @__PURE__ */ Symbol("NEXT");
-    DEFAULT_ROUTE = ["dyn", "lex"];
-    BindFrame = class {
-      constructor(it, binds, isFrame) {
-        this.it = it;
-        this.binds = binds;
-        this.isFrame = isFrame;
-      }
-      lookup(name) {
-        const v = this.binds[name];
-        return v === void 0 ? this.isFrame ? STOP : NEXT : v;
-      }
-    };
-    ObjectFrame = class {
-      constructor(binds) {
-        this.binds = binds;
-      }
-      lookup(key) {
-        const v = this.binds[key];
-        return v === void 0 ? NEXT : v;
-      }
-    };
-    Stack = class _Stack {
-      constructor(comps, it, binds, dynBinds, views, viewsId, ctx = null) {
-        this.comps = comps;
-        this.it = it;
-        this.binds = binds;
-        this.dynBinds = dynBinds;
-        this.views = views;
-        this.viewsId = viewsId;
-        this.ctx = ctx;
-      }
-      // Evaluate every provide the entered component publishes and push them as one
-      // dynBinds frame, keyed by NAME. Published types go in the same frame: a type name
-      // starts A-Z and a value name does not, so the two namespaces cannot collide and
-      // nearest-ancestor-wins falls out of frame order for both. No-op with no provides.
-      _pushProvides() {
-        const comp = this.comps.getCompFor(this.it);
-        if (comp == null) return this;
-        const { provide, provideType } = comp;
-        const dynObj = {};
-        let has2 = false;
-        for (const k in provide) {
-          dynObj[k] = provide[k].val.eval(this);
-          has2 = true;
-        }
-        for (const k in provideType) {
-          dynObj[k] = provideType[k];
-          has2 = true;
-        }
-        if (!has2) return this;
-        const newDynBinds = [new ObjectFrame(dynObj), this.dynBinds];
-        const { comps, it, binds, views, viewsId, ctx } = this;
-        return new _Stack(comps, it, binds, newDynBinds, views, viewsId, ctx);
-      }
-      static root(comps, it, ctx) {
-        const binds = [new BindFrame(it, {}, true), null];
-        const dynBinds = [new ObjectFrame({}), null];
-        const views = ["main", null];
-        return new _Stack(comps, it, binds, dynBinds, views, "", ctx)._pushProvides();
-      }
-      enter(it, bindings = {}, isFrame = true) {
-        const { comps, binds, dynBinds, views, viewsId, ctx } = this;
-        const newBinds = [new BindFrame(it, bindings, isFrame), binds];
-        const stack = new _Stack(comps, it, newBinds, dynBinds, views, viewsId, ctx);
-        return isFrame ? stack._pushProvides() : stack;
-      }
-      pushViewName(name) {
-        const { comps, it, binds, dynBinds, views, ctx } = this;
-        const newViews = [name, views];
-        return new _Stack(comps, it, binds, dynBinds, newViews, computeViewsId(newViews), ctx);
-      }
-      // Published types are stable per scope and would only churn the render cache, so
-      // the cache key covers values alone.
-      _pushDynBindValuesToArray(arr, comp) {
-        for (const k in comp.provide) arr.push(this.lookupDynamic(k));
-        for (const k in comp.lookup) arr.push(this.lookupDynamic(k));
-      }
-      // `*name`: the nearest binding above (including this component's own provides,
-      // pushed on entering it), else this component's declared default, else null.
-      lookupDynamic(name) {
-        const v = lookup(this.dynBinds, name);
-        if (v != null) return v;
-        const comp = this.comps.getCompFor(this.it);
-        return comp?.lookup[name]?.val?.eval(this) ?? null;
-      }
-      lookupBind(name) {
-        return lookup(this.binds, name);
-      }
-      lookupFieldRaw(name) {
-        return this.it[name] ?? null;
-      }
-      lookupMethod(name) {
-        const fn = this.it[name];
-        return fn instanceof Function ? fn.call(this.it) : null;
-      }
-      // The dispatched DOM event / drag info, read only by EventMemberVal's
-      // `e.<member>` handler args. Null outside a live event transaction.
-      lookupEvent() {
-        return this.ctx?.event ?? null;
-      }
-      lookupDragInfo() {
-        return this.ctx?.dragInfo ?? null;
-      }
-      getHandlerFor(name, key) {
-        return this.comps.getHandlerFor(this.it, name, key);
-      }
-      lookupBestView(views, defaultViewName) {
-        let n = this.views;
-        while (n !== null) {
-          const view = views[n[0]];
-          if (view !== void 0) return view;
-          n = n[1];
-        }
-        return views[defaultViewName];
-      }
-    };
-  }
-});
-
 // src/oo.js
 function mkCompField(field, scope, args) {
   const Comp = scope?.lookupComponent(field.type) ?? null;
@@ -13203,7 +13348,7 @@ function warnNotIntent(verb) {
   console.warn(`ctx.${verb}() is only meaningful in an "intent" handler - ignored`);
 }
 function rootDispatcher(transactor) {
-  return new Dispatcher(new Path([]), transactor, null);
+  return new Dispatcher(new DispatchPath(), transactor, null);
 }
 var State2, Transactor, Transaction, InputEvent, NameArgsTransaction, SendEvent, IntentEvent, PASS, REFUSAL_RING_CAP, INTENT_DEPTH, IntentWalk, Completion, Dispatcher, EventContext, PathChanges;
 var init_transactor = __esm({
@@ -13340,9 +13485,11 @@ var init_transactor = __esm({
       // intent's answerPath is: a reply must reach the sender that asked even if a key
       // moved while the message was in flight. Null when nobody is waiting — a host
       // sendAtRoot or a view's own `@on.*` — and ctx.sendReply refuses on that.
-      pushSend(path, name, args = [], parent = null, origin = null) {
+      pushSend(path, name, args = [], parent = null, origin = null, txnPath = null) {
         const t = new SendEvent(path, this, name, args, parent);
-        t.origin = origin === null ? null : origin.toTransactionPath().pinKeys(this.state.val);
+        t.txnPath = txnPath;
+        t.origin = origin;
+        t.originPinned = origin === null ? null : origin.toTransactionPath().pinKeys(this.state.val);
         this.pushTransaction(t);
         return this._link(t, parent);
       }
@@ -13392,6 +13539,7 @@ var init_transactor = __esm({
     Transaction = class {
       constructor(path, transactor, parentTransaction = null) {
         this.path = path;
+        this.txnPath = null;
         this.transactor = transactor;
         this.parentTransaction = parentTransaction;
         this._completion = null;
@@ -13440,9 +13588,11 @@ var init_transactor = __esm({
       getHandlerAndArgs(_root, _instance, _comps) {
         return null;
       }
-      // The path used to apply the mutation. Teleports dynamic-var renders so it lands on
-      // the data's real location (the dispatch `this.path` keeps intermediates).
+      // The path used to apply the mutation: the ACTIVE frame of the dispatch path, so
+      // an event inside a `<x render="*name">` subtree updates the value where it
+      // really lives (the dispatch `this.path` keeps the visual callers, for bubbling).
       getTransactionPath() {
+        if (this.txnPath !== null) return this.txnPath;
         return this.path.toTransactionPath().compact();
       }
       run(curRoot, comps) {
@@ -13467,8 +13617,9 @@ var init_transactor = __esm({
         this.dragInfo = dragInfo;
         this._dispatchPath = null;
       }
-      // Frame steps removed, DynStep + one step per crossed component kept: bubbling
-      // it visits every component (including intermediates of a dynamic-var render).
+      // Frame-only steps removed, one step per crossed component kept — inside every
+      // continuation frame independently, so bubbling it visits every component and
+      // then returns to the caller that wrote the `*name`.
       get dispatchPath() {
         this._dispatchPath ??= this.path.compact();
         return this._dispatchPath;
@@ -13503,7 +13654,7 @@ var init_transactor = __esm({
         this.transactor.pushIntent(this.dispatchPath, name, args, rest, this);
       }
       getHandlerAndArgs(root, _instance, comps) {
-        const stack = this.path.toTransactionPath().buildStack(Stack.root(comps, root, this));
+        const stack = this.path.buildStack(Stack.root(comps, root, this));
         const [handler, args] = this.handler.getHandlerAndArgs(stack, this);
         this._handlerArgs = [...args];
         const path = this.dispatchPath;
@@ -13629,7 +13780,7 @@ var init_transactor = __esm({
         while (this.legIndex < this.route.length) {
           const leg = this.route[this.legIndex];
           if (leg === "dyn") {
-            if (this.dynAt.steps.length === 0) {
+            if (!this.dynAt.canPop()) {
               this.legIndex++;
               continue;
             }
@@ -13726,8 +13877,8 @@ var init_transactor = __esm({
         if (this.ended) return;
         this.ended = true;
         if (name === null) return this.release?.();
-        const path = this.answerPath ?? this.origin;
-        const t = new SendEvent(path, this.transactor, name, args, this.parent);
+        const t = new SendEvent(this.origin, this.transactor, name, args, this.parent);
+        t.txnPath = this.answerPath;
         t._isAnswer = true;
         this.transactor.pushTransaction(t);
         if (this.release) t.completion.whenSubtreeSettled().then(this.release);
@@ -13822,7 +13973,9 @@ var init_transactor = __esm({
       // replayed; provides are pushed on every component frame either way, so a provide
       // that reads a loop binding is the one case this cannot reproduce faithfully.
       _stack() {
-        this._stackMemo ??= this.path.toTransactionPath().buildStack(Stack.root(this.transactor.comps, this.root, this.parent));
+        this._stackMemo ??= this.path.buildStack(
+          Stack.root(this.transactor.comps, this.root, this.parent)
+        );
         return this._stackMemo;
       }
       // Resolve a name the way the renderer would. `opts.route` takes the same legs in
@@ -13836,14 +13989,19 @@ var init_transactor = __esm({
         );
       }
       // The `lex` leg without a Stack: the scope of the component whose handler is
-      // running, which is the leaf of this ctx's path.
+      // running, which is the leaf of this ctx's path. A type name resolves to the
+      // component registered under it; a value name to a path registered under it
+      // (see ComponentStack.registerPaths), read against the current root.
       _lookupLex(name) {
         let Comp = null;
         this.walkPath((c) => {
           Comp = c;
           return false;
         });
-        return Comp?.scope?.lookupComponent(name) ?? null;
+        const scope = Comp?.scope;
+        if (scope == null) return null;
+        if (isTypeName(name)) return scope.lookupComponent(name) ?? null;
+        return scope.lookupPath(name)?.lookup(this.root) ?? null;
       }
       // A component lookup is a value lookup constrained to a component. The `lex` leg
       // can only ever answer with one; the `dyn` leg reads a binding an ancestor
@@ -13904,7 +14062,14 @@ var init_transactor = __esm({
           this.transactor.refuse("NO_SENDER", { name });
           return null;
         }
-        return this.sendAtPath(origin, name, args);
+        return this.transactor.pushSend(
+          origin,
+          name,
+          args,
+          this.parent,
+          this.path,
+          this.parent.originPinned
+        );
       }
       // End the walk answering nothing — "served, and no answer".
       stop() {
@@ -14015,7 +14180,7 @@ var init_app = __esm({
         const { type: type3 } = e;
         const isDrag = type3 === "dragover" || type3 === "dragstart" || type3 === "dragend" || type3 === "drop";
         const { rootNode: root, maxEventNodeDepth: maxDepth, comps, transactor } = this;
-        const [path, handlers] = Path.fromNodeAndEventName(
+        const [path, handlers] = DispatchPath.fromNodeAndEventName(
           e.target,
           type3,
           root,
@@ -14083,7 +14248,7 @@ var init_app = __esm({
           const txnPath = path.compact().toTransactionPath();
           const value = txnPath.lookup(rootValue);
           const dragType = e.target.dataset.dragtype ?? "?";
-          const stack = path.toTransactionPath().buildStack(this.makeStack(rootValue));
+          const stack = path.buildStack(this.makeStack(rootValue));
           this.dragInfo = new DragInfo(stack, value, dragType, e.target);
         } else if (type3 === "drop") {
           e.preventDefault();
@@ -14158,7 +14323,7 @@ var init_app = __esm({
           this.rootNode.removeEventListener(name, this, listenerOpts(name));
       }
       sendAtRoot(name, args) {
-        this.transactor.pushSend(new Path([]), name, args);
+        this.transactor.pushSend(new DispatchPath(), name, args);
       }
       registerComponents(comps, opts) {
         const scope = this.compStack.enter();
@@ -14302,13 +14467,28 @@ var init_cache = __esm({
 });
 
 // src/renderer.js
+function stampRenderBase(vdom, text) {
+  if (vdom instanceof VNode)
+    return new VNode(
+      vdom.tag,
+      { ...vdom.attrs, "data-rp": text },
+      vdom.childs,
+      vdom.key,
+      vdom.namespace
+    );
+  if (vdom instanceof VFragment)
+    return new VFragment(vdom.childs.map((c) => stampRenderBase(c, text)));
+  return vdom;
+}
 var DATASET_ATTRS, Renderer;
 var init_renderer = __esm({
   "src/renderer.js"() {
     init_cache();
     init_iteration();
+    init_path();
+    init_value();
     init_vdom();
-    DATASET_ATTRS = ["nid", "cid", "eid", "vid", "si", "sk"];
+    DATASET_ATTRS = ["nid", "cid", "eid", "vid", "si", "sk", "rp"];
     Renderer = class {
       constructor(comps) {
         this.comps = comps;
@@ -14345,17 +14525,17 @@ var init_renderer = __esm({
         if (comp === null) return null;
         return this._rValComp(stack, val, comp, comp.getView(viewName).anode, "ROOT", viewName);
       }
-      renderIt(stack, node, key, viewName) {
+      renderIt(stack, node, key, viewName, base = null) {
         const comp = this.comps.getCompFor(stack.it);
-        return comp ? this._rValComp(stack, stack.it, comp, node, key, viewName) : null;
+        return comp ? this._rValComp(stack, stack.it, comp, node, key, viewName, base) : null;
       }
       // `node` is the parse node of the render site (`<x render>` / `render-it` /
       // `render-each`, or the view's root anode for the app root). It keys the
       // cache as a globally-unique object: node ids alone are unique only within a
       // single view, so the same value rendered by two components (e.g. through a
       // shared dynamic-var sequence) would otherwise collide in the cache.
-      _rValComp(stack, val, comp, node, key, viewName) {
-        const cacheKey = `${viewName ?? ""}${stack.viewsId ?? ""}${key}`;
+      _rValComp(stack, val, comp, node, key, viewName, base = null) {
+        const cacheKey = `${viewName ?? ""}${stack.viewsId ?? ""}${key}${stack.renderPath.addressKey}`;
         const cachePath = [node, val];
         stack._pushDynBindValuesToArray(cachePath, comp);
         const cachedNode = this.cache.get(cachePath, cacheKey);
@@ -14363,30 +14543,43 @@ var init_renderer = __esm({
         const view = viewName ? comp.getView(viewName) : stack.lookupBestView(comp.views, "main");
         const body = this.renderView(view, stack);
         if (body == null) return null;
+        const baseJson = base === null ? null : pathToJson(base);
         const meta = this._renderMetadata({
           $: "Comp",
           nid: node?.nodeId ?? null,
           cid: comp.id,
-          vid: view.name
+          vid: view.name,
+          ...baseJson === null ? null : { base: baseJson }
         });
-        const dom = new VFragment([meta, body]);
+        const dom = new VFragment([
+          meta,
+          baseJson === null ? body : stampRenderBase(body, JSON.stringify(baseJson))
+        ]);
         this.cache.set(cachePath, cacheKey, dom);
         return dom;
       }
       pushEachEntry(r, nid, attrName, key, dom) {
         r.push(this._renderMetadata({ $: "Each", nid, [attrName]: key }), dom);
       }
-      renderEachWhen(stack, iterInfo, view, nid) {
+      renderEachWhen(stack, each2) {
+        const { iterInfo, node: view, nodeId: nid } = each2;
         const { seq, filter, loopWith, enricher } = iterInfo.eval(stack);
+        const seqPath = iterInfo.val instanceof DynVal ? stack.lookupDynamicLocated(iterInfo.val.name)?.path ?? null : null;
         const r = [];
         const it = stack.it;
         const renderOne = (key, value, attrName, binds) => {
+          const itemBase = seqPath === null ? null : keyedPath(seqPath, key);
+          const itemStep = itemBase === null ? each2.itemStep(key) : null;
+          const itemPath = itemBase !== null ? stack.renderPath.pushFrame(itemBase) : itemStep !== null ? stack.renderPath.pushItem(itemStep) : stack.renderPath;
           const cachePath = enricher ? [view, it, value] : [view, value];
-          const cacheKey = `${stack.viewsId ?? ""}${nid}${key}`;
+          const cacheKey = `${stack.viewsId ?? ""}${nid}${key}${itemPath.addressKey}`;
           const cachedNode = this.cache.get(cachePath, cacheKey);
           if (cachedNode) this.pushEachEntry(r, nid, attrName, key, cachedNode);
           else {
-            const dom = this.renderView(view, stack.enter(value, binds, false));
+            const dom = this.renderView(
+              view,
+              stack.enter(value, binds, false, itemPath, itemBase !== null)
+            );
             if (dom != null) this.pushEachEntry(r, nid, attrName, key, dom);
             this.cache.set(cachePath, cacheKey, dom);
           }
@@ -14442,7 +14635,7 @@ function renderToHTMLNode(document2, components, macros, rootState, ParseContext
   const comps = new Components();
   const renderer = new Renderer(comps);
   const app = new App(container, comps, renderer, ParseContext2);
-  const scope = app.registerComponents(components);
+  const scope = app.registerComponents(components, { paths: opts.paths });
   if (macros) scope.registerMacros(macros);
   if (opts.intentHandlers) scope.registerIntentHandlers(opts.intentHandlers);
   app.rootViewName = opts.view ?? null;
@@ -14468,7 +14661,7 @@ async function renderToHTMLDriven(document2, components, macros, rootState, Pars
   );
   try {
     if (phase) {
-      dispatchPhase(rootDispatcher(app.transactor), new Path([]), phase, app.state.val);
+      dispatchPhase(rootDispatcher(app.transactor), new DispatchPath(), phase, app.state.val);
       await app.transactor.settle();
     }
     return serializeContainer(container);
@@ -14706,7 +14899,7 @@ async function driveStack(stack, value, phase, opts = {}) {
         val
       );
     });
-  dispatchPhase(rootDispatcher(transactor), new Path([]), phase, value);
+  dispatchPhase(rootDispatcher(transactor), new DispatchPath(), phase, value);
   await transactor.settle();
   return transactor.state.val;
 }