tutuca 0.13.3 → 0.15.0

package/dist/tutuca.ext.js

@@ -51,12 +51,6 @@ enableMapSet();
 
 // src/path.js
 var NONE = /* @__PURE__ */ Symbol("NONE");
-var readKey = (value, key, dval = null) => {
-  if (value == null) return dval;
-  if (value instanceof Map) return value.has(key) ? value.get(key) : dval;
-  if (value instanceof Set) return value.has(key) ? key : dval;
-  return Object.hasOwn(value, key) ? value[key] : dval;
-};
 var writeKey = (value, key, next) => {
   if (value instanceof Map) value.set(key, next);
   else if (value instanceof Set) {
@@ -64,20 +58,15 @@ var writeKey = (value, key, next) => {
     value.add(next);
   } else value[key] = next;
 };
-var writeSeqKey = (value, key, next) => {
-  if (value instanceof Map || value instanceof Set || Array.isArray(value) || Object.hasOwn(value, key))
-    writeKey(value, key, next);
-  else if (typeof value?.set === "function") value.set(key, next);
-  else writeKey(value, key, next);
-};
+var writeSeqKey = (value, key, next) => !(value instanceof Map || value instanceof Set || Array.isArray(value)) && !Object.hasOwn(value, key) && typeof value?.set === "function" ? value.set(key, next) : writeKey(value, key, next);
 var Step = class {
-  lookup(_v, dval = null) {
-    return dval;
-  }
   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;
@@ -94,41 +83,29 @@ var Step = class {
     return null;
   }
 };
-var BindStep = class _BindStep extends Step {
+var BindStep = class extends Step {
   constructor(binds) {
     super();
     this.binds = binds;
   }
-  lookup(v, _dval) {
+  lookup(v) {
     return v;
   }
-  enterFrame(stack, next) {
-    return stack.enter(next, { ...this.binds }, false);
-  }
-  withIndex(i) {
-    return new _BindStep({ ...this.binds, key: i });
-  }
-  withKey(key) {
-    return new _BindStep({ ...this.binds, key });
+  enterFrame(stack, next, renderPath) {
+    return stack.enter(next, { ...this.binds }, false, renderPath);
   }
   toAbstractPathStep() {
     return null;
   }
 };
-var ScopeBindStep = class _ScopeBindStep extends BindStep {
+var ScopeBindStep = class extends BindStep {
   constructor(val, binds = {}) {
     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);
-  }
-  withIndex(i) {
-    return new _ScopeBindStep(this.val, { ...this.binds, key: i });
-  }
-  withKey(key) {
-    return new _ScopeBindStep(this.val, { ...this.binds, key });
+    return stack.enter(next, { ...this.binds, ...dyn }, false, renderPath);
   }
 };
 var FieldStep = class extends Step {
@@ -136,18 +113,12 @@ var FieldStep = class extends Step {
     super();
     this.field = field;
   }
-  lookup(v, dval = null) {
-    return readKey(v, this.field, dval);
+  lookup(v) {
+    return seqGet(v, this.field, NONE);
   }
   setDraftValue(root, v) {
     writeKey(root, this.field, v);
   }
-  withIndex(i) {
-    return new SeqStep(this.field, i);
-  }
-  withKey(k) {
-    return new SeqStep(this.field, k);
-  }
   toKey() {
     return { field: this.field };
   }
@@ -158,15 +129,15 @@ var SeqStep = class extends Step {
     this.field = field;
     this.key = key;
   }
-  lookup(v, dval = null) {
-    return seqGet(readKey(v, this.field, null), this.key, dval);
+  lookup(v) {
+    return seqGet(seqGet(v, this.field, null), this.key, NONE);
   }
   setDraftValue(root, v) {
-    const seq = readKey(root, this.field, null);
+    const seq = seqGet(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 };
@@ -178,20 +149,20 @@ var SeqAccessStep = class extends Step {
     this.seqField = seqField;
     this.keyField = keyField;
   }
-  lookup(v, dval = null) {
-    const seq = readKey(v, this.seqField, NONE);
-    const key = readKey(v, this.keyField, NONE);
-    return key !== NONE && seq !== NONE ? seqGet(seq, key, dval) : dval;
+  lookup(v) {
+    const seq = seqGet(v, this.seqField, NONE);
+    const key = seqGet(v, this.keyField, NONE);
+    return key !== NONE && seq !== NONE ? seqGet(seq, key, NONE) : NONE;
   }
   setDraftValue(root, v) {
-    const seq = readKey(root, this.seqField, NONE);
-    const key = readKey(root, this.keyField, NONE);
+    const seq = seqGet(root, this.seqField, NONE);
+    const key = seqGet(root, this.keyField, NONE);
     if (seq !== NONE && key !== NONE) writeSeqKey(seq, key, v);
   }
   // Resolve `keyField` against `v` now and freeze it as a literal-key `SeqStep`, so a
   // later lookup/setValue lands on this same item even if `keyField` changes meanwhile.
   pinKey(v) {
-    const key = readKey(v, this.keyField, NONE);
+    const key = seqGet(v, this.keyField, NONE);
     return key === NONE ? this : new SeqStep(this.seqField, key);
   }
   // The key is a *field reference* resolved live, so it is unknown without a value;
@@ -202,70 +173,62 @@ var SeqAccessStep = class extends Step {
   }
 };
 var EachBindStep = class extends Step {
-  constructor(iterInfo, key) {
+  constructor(eachNode, key) {
     super();
-    this.iterInfo = iterInfo;
+    this.eachNode = eachNode;
     this.key = key;
   }
-  lookup(v, _dval) {
+  lookup(v) {
     return v;
   }
   // 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.eachNode.enrichBinds(stack, this.key), false, renderPath);
   }
   toAbstractPathStep() {
     return null;
   }
 };
 var 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);
   }
 };
-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;
 }
-var 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;
-  }
-};
-var 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));
+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(path2) {
+  const out = [];
+  for (const step of path2.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);
+}
 var Path = class _Path {
   constructor(steps = []) {
     this.steps = steps;
@@ -273,43 +236,13 @@ var Path = class _Path {
   concat(steps) {
     return new _Path(this.steps.concat(steps));
   }
-  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);
   }
@@ -317,7 +250,6 @@ var Path = class _Path {
   // 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;
@@ -325,7 +257,7 @@ var Path = class _Path {
       const step = this.steps[i];
       const pinned = step.pinKey(curVal);
       if (pinned !== step) (out ??= this.steps.slice())[i] = pinned;
-      curVal = step.lookup(curVal, NONE);
+      curVal = step.lookup(curVal);
       if (curVal === NONE) break;
     }
     return out ? new _Path(out) : this;
@@ -333,20 +265,20 @@ var Path = class _Path {
   lookup(v, dval = null) {
     let curVal = v;
     for (const step of this.steps) {
-      curVal = step.lookup(curVal, NONE);
+      curVal = step.lookup(curVal);
       if (curVal === NONE) return dval;
     }
     return curVal;
   }
   // 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;
     for (const step of this.steps) {
-      curVal = step.lookup(curVal, NONE);
+      curVal = step.lookup(curVal);
       if (curVal === NONE) break;
       out.push(curVal);
     }
@@ -355,7 +287,7 @@ var Path = class _Path {
   // 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) {
@@ -369,69 +301,146 @@ var Path = class _Path {
     return (0, immer_exports.produce)(root, (draft) => {
       let parent = draft;
       for (let i = 0; i < this.steps.length - 1; i++) {
-        parent = this.steps[i].lookup(parent, NONE);
+        parent = this.steps[i].lookup(parent);
         if (parent === NONE) return;
       }
       this.steps.at(-1).setDraftValue(parent, v);
     });
   }
+};
+function walkItems(stack, items, renderPath, path2) {
+  let prev = stack.it;
+  for (const step of items) {
+    const next = step.lookup(prev);
+    if (next === NONE) {
+      console.warn("bad PathItem", { root: stack.it, step, path: path2 });
+      return null;
+    }
+    renderPath = renderPath.pushItem(step);
+    stack = step.enterFrame(stack, next, renderPath);
+    prev = next;
+  }
+  return [stack, renderPath];
+}
+var EMPTY_PATH = new Path([]);
+var 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) {
+    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. (A path always has at least one frame.)
+  canPop() {
+    return this.frames.length > 1 || this.frames[0].items.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 { top } = this;
+    if (top.items.length > 0) return this._withTopItems(top.items.slice(0, -1));
+    if (this.frames.length > 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 { base, items } = this.top;
+    return base.concat(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 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;
+    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 = [];
+  // Reconstruct the dispatch position of a DOM event from the `data-*` stamps and
+  // `§…§` meta comments the renderer left on the way down. `stopOnNoEvent` is off for
+  // drag events, whose path is needed even where no handler is registered.
+  static fromNodeAndEventName(node, eventName, rootNode, comps, stopOnNoEvent = true) {
+    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) {
+    while (node && node !== rootNode) {
       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;
@@ -439,21 +448,46 @@ var Path = class _Path {
           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 path2 = new _DispatchPath();
+    for (const part of parts)
+      path2 = part.base !== void 0 ? path2.pushFrame(part.base) : path2.pushItem(part.step);
+    return [path2, handlers];
+  }
+};
+function keyedPath(path2, key) {
+  const steps = path2.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(path2) {
+  return JSON.stringify(pathToJson(path2));
+}
+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 = [];
   while (n?.nodeType === 8 && n.textContent[0] === "§") {
@@ -498,28 +532,28 @@ var StepCtx = class _StepCtx {
   resolveNode() {
     return this.comp.getNodeForId(+this.meta.nid, this.vid);
   }
-  applyKey(pi) {
-    if (pi === null) return null;
-    const m = this.meta;
-    if (m.si !== void 0) return pi.withIndex(+m.si);
-    if (m.sk !== void 0) return pi.withKey(m.sk);
-    return pi;
-  }
 };
-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 NO_EVENT_INFO = [null, null];
 var BUBBLING_EVENTS = /* @__PURE__ */ new Set(["drop"]);
+var path = () => new PathBuilder();
 var PathBuilder = class {
   constructor() {
     this.pathChanges = [];
   }
+  toPath() {
+    return new Path(this.pathChanges);
+  }
   add(pathChange) {
     this.pathChanges.push(pathChange);
     return this;
@@ -535,10 +569,8 @@ var PathBuilder = class {
   }
 };
 
-// src/util/env.js
-var isMac = (globalThis.navigator?.userAgent ?? "").toLowerCase().includes("mac");
-
 // src/value.js
+var isMac = (globalThis.navigator?.userAgent ?? "").toLowerCase().includes("mac");
 var VALID_VAL_ID_RE = /^[a-zA-Z][a-zA-Z0-9_]*\??$/;
 var isValidValId = (name) => VALID_VAL_ID_RE.test(name);
 var VALID_FLOAT_RE = /^-?[0-9]+(\.[0-9]+)?$/;
@@ -720,22 +752,10 @@ function _parsePredicate(s, tokens, px) {
   }
   return new PredicateVal(pred, args);
 }
-function kindOf(val) {
-  if (val === null) return 0;
-  if (val instanceof ConstVal) return val.kind;
-  if (val instanceof StrTplVal) return val.kind;
-  if (val instanceof SeqAccessVal) return K_SEQ;
-  if (val instanceof FieldVal) return K_FIELD;
-  if (val instanceof MethodVal) return K_METHOD;
-  if (val instanceof BindVal) return K_BIND;
-  if (val instanceof DynVal) return K_DYN;
-  if (val instanceof NameVal) return K_NAME;
-  if (val instanceof EventMemberVal) return K_EVENT;
-  return 0;
-}
+var kindOf = (val) => val?.kind ?? 0;
 var BaseVal = class {
-  render(_stack, _rx) {
-  }
+  // No kind: never accepted by a group (PredicateVal, which only parseBool builds).
+  kind = 0;
   eval(_stack) {
   }
   toPathItem() {
@@ -755,9 +775,6 @@ var ConstVal = class extends BaseVal {
     this.val = val;
     this.kind = kind;
   }
-  render(_stack, _rx) {
-    return this.val;
-  }
   eval(_stack) {
     return this.val;
   }
@@ -783,9 +800,7 @@ var PredicateVal = class extends BaseVal {
     return `${this.pred.name} ${this.args.map(String).join(" ")}`;
   }
 };
-var VarVal = class extends BaseVal {
-};
-var StrTplVal = class _StrTplVal extends VarVal {
+var StrTplVal = class _StrTplVal extends BaseVal {
   constructor(vals) {
     super();
     this.vals = vals;
@@ -798,9 +813,6 @@ var StrTplVal = class _StrTplVal extends VarVal {
     for (const v of this.vals) if (!(v instanceof ConstVal) || v.fromMacroVar) return false;
     return true;
   }
-  render(stack, _rx) {
-    return this.eval(stack);
-  }
   eval(stack) {
     const strs = new Array(this.vals.length);
     for (let i = 0; i < this.vals.length; i++) strs[i] = this.vals[i]?.eval(stack, "");
@@ -837,7 +849,8 @@ var StrTplVal = class _StrTplVal extends VarVal {
     return new _StrTplVal(lo === 0 && hi === vals.length ? vals : vals.slice(lo, hi));
   }
 };
-var NameVal = class extends VarVal {
+var NameVal = class extends BaseVal {
+  kind = K_NAME;
   constructor(name) {
     super();
     this.name = name;
@@ -887,6 +900,7 @@ var EVENT_CONVENIENCES = {
   dragKey: nullSafe((info) => info.lookupBind("key"))
 };
 var EventMemberVal = class extends BaseVal {
+  kind = K_EVENT;
   constructor(members) {
     super();
     this.members = members;
@@ -909,24 +923,21 @@ var EventMemberVal = class extends BaseVal {
     return `e.${this.members.join(".")}`;
   }
 };
-var RenderVal = class extends BaseVal {
-  render(stack, _rx) {
-    return this.eval(stack);
-  }
-};
-var RenderNameVal = class extends RenderVal {
+var SigilNameVal = class extends BaseVal {
   constructor(name) {
     super();
     this.name = name;
   }
+  toString() {
+    return this.sigil + this.name;
+  }
 };
-var BindVal = class extends RenderNameVal {
+var BindVal = class extends SigilNameVal {
+  kind = K_BIND;
+  sigil = "@";
   eval(stack) {
     return stack.lookupBind(this.name);
   }
-  toString() {
-    return `@${this.name}`;
-  }
 };
 var BindMemberVal = class extends BindVal {
   constructor(name, member) {
@@ -941,37 +952,35 @@ var BindMemberVal = class extends BindVal {
     return `@${this.name}.${this.member}`;
   }
 };
-var DynVal = class extends RenderNameVal {
+var DynVal = class extends SigilNameVal {
+  kind = K_DYN;
+  sigil = "*";
   eval(stack) {
     return stack.lookupDynamic(this.name);
   }
-  toString() {
-    return `*${this.name}`;
-  }
 };
-var FieldVal = class extends RenderNameVal {
+var FieldVal = class extends SigilNameVal {
+  kind = K_FIELD;
+  sigil = ".";
   eval(stack) {
     return stack.lookupFieldRaw(this.name);
   }
   toPathItem() {
     return new FieldStep(this.name);
   }
-  toString() {
-    return `.${this.name}`;
-  }
 };
-var MethodVal = class extends RenderNameVal {
+var MethodVal = class extends SigilNameVal {
+  kind = K_METHOD;
+  sigil = "$";
   eval(stack) {
     return stack.lookupMethod(this.name);
   }
   evalAsHandler(stack) {
     return stack.lookupFieldRaw(this.name);
   }
-  toString() {
-    return `$${this.name}`;
-  }
 };
-var SeqAccessVal = class extends RenderVal {
+var SeqAccessVal = class extends BaseVal {
+  kind = K_SEQ;
   constructor(seqVal, keyVal) {
     super();
     this.seqVal = seqVal;
@@ -994,9 +1003,6 @@ var Attributes = class {
   constructor(items) {
     this.items = items;
   }
-  static parse(attributes, px, parseAll = false) {
-    return new AttrParser(px).parse(attributes, parseAll);
-  }
   isConstant() {
     return false;
   }
@@ -1014,10 +1020,16 @@ function parseDirectiveValue(px, directiveName, source, parser) {
   }
   return val;
 }
+var ITER_DIRECTIVES = {
+  when: "whenVal",
+  "loop-with": "loopWithVal",
+  "enrich-with": "enrichWithVal"
+};
+var parseIterDirective = (px, name, s) => parseDirectiveValue(px, name, s, parseAlterHandler);
 function parseIterationDirectives(attributes, px) {
   const parseNamed = (name) => {
     const attr = attributes.getNamedItem(`@${name}`);
-    return attr ? parseDirectiveValue(px, name, attr.value, parseAlterHandler) : null;
+    return attr ? parseIterDirective(px, name, attr.value) : null;
   };
   return { whenVal: parseNamed("when"), loopWithVal: parseNamed("loop-with") };
 }
@@ -1058,11 +1070,22 @@ var AttrParser = class {
       this.px.onParseIssue("bad-value", info);
     }
   }
-  parseThen(s) {
-    if (this.ifAttr) this.ifAttr.thenVal = parseText(s, this.px) ?? NOT_SET_VAL;
+  // `@then` / `@else` fill the branches of the `@if.<attr>` on the same element.
+  parseBranch(slot, name, s) {
+    if (this.ifAttr === null) return this._orphan(name, s, "if");
+    this.ifAttr[slot] = parseText(s, this.px) ?? NOT_SET_VAL;
+  }
+  // `@when` / `@loop-with` / `@enrich-with` amend the `@each` on the same element. A
+  // loop-less `@enrich-with` is a scope of its own; the other two need the loop.
+  parseIter(name, s) {
+    const val = parseIterDirective(this.px, name, s);
+    if (this.eachAttr !== null) this.eachAttr[ITER_DIRECTIVES[name]] = val;
+    else if (name === "enrich-with") this.pushWrapper("scope", s, val);
+    else this._orphan(name, s, "each");
   }
-  parseElse(value) {
-    if (this.ifAttr) this.ifAttr.elseVal = parseText(value, this.px) ?? NOT_SET_VAL;
+  // A directive that only means something next to another one, written alone.
+  _orphan(name, value, needs) {
+    this.px.onParseIssue("orphan-directive", { name, value, needs });
   }
   parseEvent(directiveName, value) {
     const [eventName, ...modifiers] = directiveName.slice(3).split("+");
@@ -1076,77 +1099,51 @@ var AttrParser = class {
       this.events.add(eventName, handler, modifiers);
     }
   }
-  _parseDirectiveValue(directiveName, s, parserFn) {
-    return parseDirectiveValue(this.px, directiveName, s, parserFn);
-  }
   parseDirective(s, directiveName) {
     switch (directiveName) {
       case "dangerouslysetinnerhtml":
         this.attrs ??= [];
-        this.attrs.push(new RawHtmlAttr(this._parseDirectiveValue(directiveName, s, parseText)));
+        this.attrs.push(new RawHtmlAttr(parseDirectiveValue(this.px, directiveName, s, parseText)));
         this.hasDynamic = true;
         return;
       case "push-view":
-        this.pushWrapper("push-view", s, this._parseDirectiveValue(directiveName, s, parseText));
+        this.pushWrapper("push-view", s, parseDirectiveValue(this.px, directiveName, s, parseText));
         return;
       case "text":
-        this.textChild = this._parseDirectiveValue(directiveName, s, parseText);
+        this.textChild = parseDirectiveValue(this.px, directiveName, s, parseText);
         return;
       case "show":
-        this.pushWrapper("show", s, this._parseDirectiveValue(directiveName, s, parseBool));
+        this.pushWrapper("show", s, parseDirectiveValue(this.px, directiveName, s, parseBool));
         return;
       case "hide":
-        this.pushWrapper("hide", s, this._parseDirectiveValue(directiveName, s, parseBool));
+        this.pushWrapper("hide", s, parseDirectiveValue(this.px, directiveName, s, parseBool));
         return;
       case "each": {
-        const val = this._parseDirectiveValue(directiveName, s, parseSequence);
+        const val = parseDirectiveValue(this.px, directiveName, s, parseSequence);
         this.eachAttr = this.pushWrapper("each", s, val);
         return;
       }
-      case "enrich-with":
-        if (this.eachAttr !== null)
-          this.eachAttr.enrichWithVal = this._parseDirectiveValue(
-            directiveName,
-            s,
-            parseAlterHandler
-          );
-        else
-          this.pushWrapper(
-            "scope",
-            s,
-            this._parseDirectiveValue(directiveName, s, parseAlterHandler)
-          );
-        return;
       case "when":
-        this._parseWhen(s);
-        return;
       case "loop-with":
-        this._parseLoopWith(s);
+      case "enrich-with":
+        this.parseIter(directiveName, s);
         return;
       case "then":
-        this.parseThen(s);
+        this.parseBranch("thenVal", directiveName, s);
         return;
       case "else":
-        this.parseElse(s);
+        this.parseBranch("elseVal", directiveName, s);
         return;
     }
     if (directiveName.startsWith("on.")) this.parseEvent(directiveName, s);
     else if (directiveName.startsWith("if.")) this.parseIf(directiveName, s);
-    else if (directiveName.startsWith("then.")) this.parseThen(s);
-    else if (directiveName.startsWith("else.")) this.parseElse(s);
+    else if (directiveName.startsWith("then.")) this.parseBranch("thenVal", directiveName, s);
+    else if (directiveName.startsWith("else.")) this.parseBranch("elseVal", directiveName, s);
     else {
       const info = { name: directiveName, value: s };
       this.px.onParseIssue("unknown-directive", info);
     }
   }
-  _parseWhen(s) {
-    if (this.eachAttr !== null)
-      this.eachAttr.whenVal = this._parseDirectiveValue("when", s, parseAlterHandler);
-  }
-  _parseLoopWith(s) {
-    if (this.eachAttr !== null)
-      this.eachAttr.loopWithVal = this._parseDirectiveValue("loop-with", s, parseAlterHandler);
-  }
   parse(attributes, parseAll = false) {
     for (const { name, value } of attributes) {
       const charCode = name.charCodeAt(0);
@@ -1499,19 +1496,21 @@ var VNode = class _VNode extends VBase {
     const createOpts = attrs.is != null ? { is: attrs.is } : void 0;
     const node = ns === null ? doc.createElement(tag, createOpts) : doc.createElementNS(ns, tag, createOpts);
     const cOpts = childOpts(this, ns, opts);
-    if ("value" in attrs || "checked" in attrs) {
-      const { value, checked, ...rest } = attrs;
-      applyProperties(node, rest);
-      appendChildNodes(node, this.childs, cOpts);
-      if (value !== void 0) applyValueLast(node, value);
-      if (checked !== void 0) setProp(node, "checked", checked, false);
-    } else {
-      applyProperties(node, attrs);
-      appendChildNodes(node, this.childs, cOpts);
-    }
+    applyAttrs(node, attrs, () => appendChildNodes(node, this.childs, cOpts));
     return node;
   }
 };
+function applyAttrs(node, attrs, placeChildren) {
+  const hasValue = "value" in attrs;
+  const hasChecked = "checked" in attrs;
+  if (hasValue || hasChecked) {
+    const { value: _v, checked: _c, ...rest } = attrs;
+    applyProperties(node, rest);
+  } else applyProperties(node, attrs);
+  placeChildren();
+  if (hasValue) applyValueLast(node, attrs.value);
+  if (hasChecked) setProp(node, "checked", attrs.checked, isNamespaced(node));
+}
 function diffProps(a, b) {
   if (a === b) return null;
   let diff = null;
@@ -1542,22 +1541,16 @@ function morphNode(domNode, source, target, opts) {
     }
     if (type === 1 && source.isSameKind(target)) {
       const propsDiff = diffProps(source.attrs, target.attrs);
-      const hasValue = propsDiff != null && "value" in propsDiff;
-      const hasChecked = propsDiff != null && "checked" in propsDiff;
-      if (propsDiff) {
-        if (hasValue || hasChecked) {
-          const { value: _v, checked: _c, ...rest } = propsDiff;
-          applyProperties(domNode, rest);
-        } else applyProperties(domNode, propsDiff);
-      }
-      if (!target.attrs.dangerouslySetInnerHTML) {
+      const placeChildren = () => {
+        if (target.attrs.dangerouslySetInnerHTML) return;
         const ns = effectiveNs(target, opts);
         morphChildren(domNode, source.childs, target.childs, childOpts(target, ns, opts));
+      };
+      if (propsDiff) applyAttrs(domNode, propsDiff, placeChildren);
+      else placeChildren();
+      if (!(propsDiff && "value" in propsDiff) && source.tag === "SELECT") {
+        if (target.attrs.value !== void 0) applyValueLast(domNode, target.attrs.value);
       }
-      if (hasValue) applyValueLast(domNode, propsDiff.value);
-      else if (source.tag === "SELECT" && target.attrs.value !== void 0)
-        applyValueLast(domNode, target.attrs.value);
-      if (hasChecked) setProp(domNode, "checked", propsDiff.checked, false);
       return domNode;
     }
     if (type === 11) {
@@ -1676,20 +1669,26 @@ function h(tagName, properties, children, namespace) {
 }
 
 // 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 path2 = stack.renderPath.pushItem(step);
+  return [val.eval(stack), path2, stack.pendingFrame ? path2.toTransactionPath() : null];
 }
 var BaseNode = class {
   render(_stack, _rx) {
     return null;
   }
-  setDataAttr(key, val) {
-    console.warn("setDataAttr not implemented for", this, { key, val });
+  // Stamp a `data-*` attribute on the element(s) this node renders. A no-op for
+  // nodes that produce no element of their own (text, `<x render*>`): a view whose
+  // root is one of those records its component boundary in the `§Comp§` meta
+  // comment instead (see Renderer._rValComp).
+  setDataAttr(_key, _val) {
   }
   isConstant() {
     return false;
@@ -1728,21 +1727,12 @@ var TextNode = class extends BaseNode {
   isConstant() {
     return true;
   }
-  setDataAttr(_key, _val) {
-  }
 };
 var CommentNode = class extends TextNode {
   render(_stack, rx) {
     return rx.renderComment(this.val);
   }
 };
-function optimizeChilds(childs) {
-  for (let i = 0; i < childs.length; i++) {
-    const child = childs[i];
-    if (child.isConstant()) childs[i] = new RenderOnceNode(child);
-    else child.optimize();
-  }
-}
 function optimizeNode(node) {
   if (node.isConstant()) return new RenderOnceNode(node);
   node.optimize();
@@ -1757,7 +1747,8 @@ var ChildsNode = class extends BaseNode {
     return this.childs.every((v) => v.isConstant());
   }
   optimize() {
-    optimizeChilds(this.childs);
+    const { childs } = this;
+    for (let i = 0; i < childs.length; i++) childs[i] = optimizeNode(childs[i]);
   }
 };
 var DomNode = class extends ChildsNode {
@@ -1769,8 +1760,7 @@ var DomNode = class extends ChildsNode {
   }
   render(stack, rx) {
     const childNodes = new Array(this.childs.length);
-    for (let i = 0; i < childNodes.length; i++)
-      childNodes[i] = this.childs[i]?.render?.(stack, rx) ?? null;
+    for (let i = 0; i < childNodes.length; i++) childNodes[i] = this.childs[i].render(stack, rx);
     return rx.renderTag(this.tagName, this.attrs.eval(stack), childNodes, this.namespace);
   }
   setDataAttr(key, val) {
@@ -1782,7 +1772,7 @@ var DomNode = class extends ChildsNode {
 };
 var FragmentNode = class extends ChildsNode {
   render(stack, rx) {
-    return rx.renderFragment(this.childs.map((c) => c?.render(stack, rx)));
+    return rx.renderFragment(this.childs.map((c) => c.render(stack, rx)));
   }
   setDataAttr(key, val) {
     for (const child of this.childs) child.setDataAttr(key, val);
@@ -1796,8 +1786,10 @@ var ANode = class _ANode extends BaseNode {
     this.nodeId = nodeId;
     this.val = val;
   }
-  toPathStep(ctx) {
-    return ctx.applyKey(this.val?.toPathItem?.() ?? null);
+  // The addressing step this node contributes to an event's dispatch path, given
+  // the `StepCtx` of the meta that named it; null when it addresses nothing.
+  toPathStep(_ctx) {
+    return this.val?.toPathItem?.() ?? null;
   }
   static parse(html2, px) {
     const nodes = px.parseHTML(html2);
@@ -1813,8 +1805,8 @@ var ANode = class _ANode extends BaseNode {
     return maybeFragment(trimmed);
   }
   static fromDOM(node, px) {
-    if (node instanceof px.Text) return new TextNode(node.textContent);
-    else if (node instanceof px.Comment) return new CommentNode(node.textContent);
+    if (node.nodeType === 3) return new TextNode(node.textContent);
+    if (node.nodeType === 8) return new CommentNode(node.textContent);
     const { childNodes, attributes: attrs, tagName: tag } = node;
     const childs = [];
     for (let i = 0; i < childNodes.length; i++) {
@@ -1832,11 +1824,11 @@ var ANode = class _ANode extends BaseNode {
           const slotName = attrs.getNamedItem("name")?.value ?? "_";
           return px.frame.macroSlots[slotName] ?? maybeFragment(childs);
         }
-        const [nAttrs, wrappers] = Attributes.parse(attrs, px, true);
+        const [nAttrs, wrappers] = new AttrParser(px).parse(attrs, true);
         px.onAttributes(nAttrs, wrappers, null, true, tag);
         return wrap(px.newMacroNode(macroName, nAttrs.toMacroVars(), childs), px, wrappers);
       } else if (VALID_NODE_RE.test(tag)) {
-        const [nAttrs, wrappers, textChild] = Attributes.parse(attrs, px);
+        const [nAttrs, wrappers, textChild] = new AttrParser(px).parse(attrs);
         px.onAttributes(nAttrs, wrappers, textChild, false, tag);
         if (textChild) childs.unshift(new RenderTextNode(null, textChild));
         const domChilds = tag !== "PRE" ? condenseChildsWhites(childs) : childs;
@@ -1998,39 +1990,32 @@ var RenderViewId = class extends ANode {
   evalViewName(stack) {
     return this.viewVal ? this.viewVal.eval(stack) : null;
   }
-  // A `<x render*>` produces no DOM element of its own to carry `data-cid`;
-  // when it is a view's root the component boundary is recorded in the `Comp`
-  // meta comment instead (see Renderer._rValComp), so this is a no-op.
-  setDataAttr(_key, _val) {
-  }
 };
-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);
-}
 var 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);
   }
 };
 var 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;
@@ -2052,9 +2037,6 @@ var RenderTextNode = class extends ANode {
   render(stack, _rx) {
     return this.val.eval(stack);
   }
-  // Renders to a text node, which can't carry `data-cid`.
-  setDataAttr(_key, _val) {
-  }
 };
 var RenderOnceNode = class extends BaseNode {
   constructor(node) {
@@ -2129,35 +2111,45 @@ var ScopeNode = class extends WrapperNode {
 var EachNode = class extends WrapperNode {
   constructor(nodeId, val) {
     super(nodeId, val);
-    this.iterInfo = new IterInfo(val, null, null, null);
+    this.iterInfo = new IterInfo();
   }
   render(stack, rx) {
-    return rx.renderEachWhen(stack, this.iterInfo, this.node, this.nodeId);
+    return rx.renderEachWhen(stack, this);
+  }
+  // The sequence and the three loop handlers, resolved against `stack`.
+  evalIter(stack) {
+    const { whenVal, loopWithVal, enrichWithVal } = this.iterInfo;
+    return {
+      seq: this.val.eval(stack) ?? [],
+      filter: whenVal?.evalAsHandler(stack) ?? filterAlwaysTrue,
+      loopWith: loopWithVal?.evalAsHandler(stack) ?? nullLoopWith,
+      enricher: enrichWithVal?.evalAsHandler(stack) ?? null
+    };
+  }
+  // Rebuild the per-item binds for `key` (see iteration.js bindsForKey).
+  enrichBinds(stack, key) {
+    const { seq, filter, loopWith, enricher } = this.evalIter(stack);
+    const ctx = makeLoopCtx(stack, filter);
+    return bindsForKey({ seq, it: stack.it, loopWith, enricher, ctx }, key);
   }
   toPathStep(ctx) {
-    return ctx.hasKey ? new EachBindStep(this.iterInfo, ctx.key) : null;
+    return ctx.hasKey ? new EachBindStep(this, 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;
 };
 var IterInfo = class {
-  constructor(val, whenVal, loopWithVal, enrichWithVal) {
-    this.val = val;
-    this.whenVal = whenVal;
-    this.loopWithVal = loopWithVal;
-    this.enrichWithVal = enrichWithVal;
-  }
-  eval(stack) {
-    const seq = this.val.eval(stack) ?? [];
-    const filter = this.whenVal?.evalAsHandler(stack) ?? filterAlwaysTrue;
-    const loopWith = this.loopWithVal?.evalAsHandler(stack) ?? nullLoopWith;
-    const enricher = this.enrichWithVal?.evalAsHandler(stack) ?? null;
-    return { seq, filter, loopWith, enricher };
-  }
-  // Rebuild the per-item binds for `key` (see iteration.js bindsForKey).
-  enrichBinds(stack, key) {
-    const { seq, filter, loopWith, enricher } = this.eval(stack);
-    const ctx = makeLoopCtx(stack, filter);
-    return bindsForKey({ seq, it: stack.it, loopWith, enricher, ctx }, key);
+  constructor() {
+    this.whenVal = null;
+    this.loopWithVal = null;
+    this.enrichWithVal = null;
   }
 };
 function xOp(consumed = [], { wrappable = false, wrapper = null, ignoresChildren = false } = {}) {
@@ -2185,26 +2177,31 @@ var WRAPPER_NODES = {
   scope: ScopeNode,
   "push-view": PushViewNameNode
 };
-var ParseContext = class _ParseContext {
-  constructor(document2, Text, Comment, nodes, events, macroNodes, frame, parent) {
-    this.nodes = nodes ?? [];
-    this.events = events ?? [];
-    this.macroNodes = macroNodes ?? [];
-    this.parent = parent ?? null;
-    this.frame = frame ?? {};
-    this.document = document2 ?? globalThis.document;
-    this.Text = Text ?? globalThis.Text;
-    this.Comment = Comment ?? globalThis.Comment;
-    this.cacheConstNodes = true;
+var ParseContext = class {
+  constructor(document2 = globalThis.document) {
+    this.document = document2;
+    this.nodes = [];
+    this.events = [];
+    this.macroNodes = [];
+    this.parent = null;
+    this.frame = {};
     this.currentTag = null;
   }
   isInsideMacro(name) {
     return this.frame.macroName === name || this.parent?.isInsideMacro(name);
   }
+  // A macro body parses in a child context that shares every accumulator with
+  // its parent (nodes, events, macroNodes, and whatever a subclass collects) and
+  // differs only in its frame. Cloned rather than constructed so a subclass
+  // keeps collecting inside macro bodies without re-implementing this — the
+  // lint and class-set contexts used to lose (or had to copy) exactly that.
   enterMacro(macroName, macroVars, macroSlots) {
-    const { document: document2, Text, Comment, nodes, events, macroNodes } = this;
-    const frame = { macroName, macroVars, macroSlots };
-    return new _ParseContext(document2, Text, Comment, nodes, events, macroNodes, frame, this);
+    const child = Object.create(Object.getPrototypeOf(this));
+    return Object.assign(child, this, {
+      frame: { macroName, macroVars, macroSlots },
+      parent: this,
+      currentTag: null
+    });
   }
   parseHTML(html2) {
     const t = this.document.createElement("template");
@@ -2269,10 +2266,10 @@ var isBlockDomNode = (n) => {
   return node instanceof DomNode && HTML_BLOCK_TAGS.has(node.tagName);
 };
 var isEmptyText = (c) => c instanceof TextNode && c.val === "";
-var isIgnorableXChild = (c) => c instanceof CommentNode || (c.isWhiteSpace?.() ?? false);
+var isIgnorableXChild = (c) => c instanceof CommentNode || c.isWhiteSpace();
 var hasMeaningfulChilds = (childs) => childs.some((c) => !isIgnorableXChild(c));
 function trimEdgeWhite(node) {
-  if (!node.isWhiteSpace?.()) return false;
+  if (!node.isWhiteSpace()) return false;
   node.condenseWhiteSpace();
   return true;
 }
@@ -2283,7 +2280,7 @@ function condenseChildsWhites(childs) {
   if (last > 0 && trimEdgeWhite(childs[last])) emptied = true;
   for (let i = 1; i < last; i++) {
     const cur = childs[i];
-    if (!(cur.isWhiteSpace?.() && cur.hasNewLine())) continue;
+    if (!(cur.isWhiteSpace() && cur.hasNewLine())) continue;
     const bothBlock = isBlockDomNode(childs[i - 1]) && isBlockDomNode(childs[i + 1]);
     cur.condenseWhiteSpace(bothBlock ? "" : " ");
     if (bothBlock) emptied = true;
@@ -2291,12 +2288,12 @@ function condenseChildsWhites(childs) {
   return emptied ? childs.filter((c) => !isEmptyText(c)) : childs;
 }
 var View = class {
-  constructor(name, rawView = "No View Defined", style = "", anode = null, ctx = null) {
+  constructor(name, rawView = "No View Defined", style = "") {
     this.name = name;
-    this.anode = anode;
-    this.style = style;
-    this.ctx = ctx;
     this.rawView = rawView;
+    this.style = style;
+    this.anode = null;
+    this.ctx = null;
   }
   compile(ctx, scope, cid) {
     this.ctx = ctx;
@@ -2304,7 +2301,7 @@ var View = class {
     this.anode.setDataAttr("data-cid", cid);
     this.anode.setDataAttr("data-vid", this.name);
     this.ctx.compile(scope);
-    if (ctx.cacheConstNodes) this.anode = optimizeNode(this.anode);
+    this.anode = optimizeNode(this.anode);
   }
   render(stack, rx) {
     if (this.anode === null) {
@@ -2329,7 +2326,7 @@ var NodeEvents = class {
   getHandlersFor(eventName) {
     let r = null;
     for (const handler of this.handlers)
-      if (handler.handlesEventName(eventName)) {
+      if (handler.name === eventName) {
         r ??= [];
         r.push(handler);
       }
@@ -2343,9 +2340,6 @@ var NodeEvent = class {
     this.modifierWrapper = compileModifiers(name, modifiers);
     this.modifiers = modifiers;
   }
-  handlesEventName(name) {
-    return this.name === name;
-  }
   getHandlerAndArgs(stack, event) {
     const r = this.handlerCall.getHandlerAndArgs(stack, event);
     r[0] = this.modifierWrapper(r[0], event);
@@ -2397,69 +2391,287 @@ function compileModifiers(eventName, names) {
   };
 }
 
-// src/components.js
-var COMPONENT = /* @__PURE__ */ Symbol.for("tutuca.component");
-var Components = class {
-  constructor() {
-    this.byId = /* @__PURE__ */ new Map();
-  }
-  registerComponent(Comp) {
-    this.byId.set(Comp[COMPONENT].id, Comp);
-  }
-  getComponentForId(id) {
-    return this.byId.get(id) ?? null;
+// src/stack.js
+var STOP = /* @__PURE__ */ Symbol("STOP");
+var NEXT = /* @__PURE__ */ Symbol("NEXT");
+var DEFAULT_ROUTE = ["dyn", "lex"];
+var isTypeName = (s) => {
+  const c = s.charCodeAt(0);
+  return c >= 65 && c <= 90;
+};
+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];
   }
-  getCompFor(v) {
-    const Comp = v?.constructor;
-    return Comp?.[COMPONENT] ? Comp : null;
+  return dv;
+}
+var BindFrame = class {
+  constructor(it, binds, isFrame) {
+    this.it = it;
+    this.binds = binds;
+    this.isFrame = isFrame;
   }
-  getHandlerFor(v, name, key) {
-    return this.getCompFor(v)?.[key][name] ?? null;
+  lookup(name) {
+    const v = this.binds[name];
+    return v === void 0 ? this.isFrame ? STOP : NEXT : v;
   }
-  // The `lex` leg of an intent's route: the handlers registered on the scope chain of
-  // the component that raised it, innermost first. A list, not a first match — see
-  // ComponentStack.lookupIntentChain.
-  getIntentChainFor(v, name) {
-    return this.getCompFor(v)?.scope.lookupIntentChain(name) ?? [];
+};
+var DynFrame = class {
+  constructor(binds, types) {
+    this.binds = binds;
+    this.types = types;
   }
-  compileStyles() {
-    const styles = [];
-    for (const Comp of this.byId.values()) styles.push(Comp[COMPONENT].compileStyle());
-    return styles.join("\n");
+  lookup(name) {
+    const v = (isTypeName(name) ? this.types : this.binds)[name];
+    return v === void 0 ? NEXT : v;
   }
 };
-var ComponentStack = class _ComponentStack {
-  constructor(comps = new Components(), parent = null) {
-    this.comps = comps;
-    this.parent = parent;
-    this.byName = {};
-    this.intentsByName = {};
-    this.macros = {};
+function computeViewsId(views) {
+  let s = "";
+  let n = views;
+  while (n !== null) {
+    s += n[0];
+    n = n[1];
   }
-  enter() {
-    return new _ComponentStack(this.comps, this);
+  return s === "main" ? "" : s;
+}
+var Stack = class _Stack {
+  constructor(fields) {
+    Object.assign(this, fields);
   }
-  registerComponents(comps, opts) {
-    const { aliases = {} } = opts ?? {};
-    for (let i = 0; i < comps.length; i++) {
-      const Comp = comps[i];
-      Comp[COMPONENT].scope = this.enter();
-      this.comps.registerComponent(Comp);
-      this.byName[Comp.name] = Comp;
+  _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 has = false;
+    const base = this._publishBase();
+    for (const k in provide) {
+      const step = provide[k].toPathItem?.() ?? null;
+      if (step === null) continue;
+      const value = provide[k].eval(this);
+      binds[k] = { value, path: base === null ? null : base.concat([step]) };
+      has = true;
     }
-    for (const alias in aliases) {
-      const comp = this.byName[aliases[alias]];
-      console.assert(this.byName[alias] === void 0, "alias overrides component", alias);
-      if (comp !== void 0) this.byName[alias] = comp;
-      else console.warn("alias", alias, "to inexistent component", aliases[alias]);
+    for (const k in provideType) {
+      types[k] = provideType[k];
+      has = true;
     }
+    if (!has) 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;
   }
-  registerMacros(macros) {
-    for (const key in macros) {
-      const lower = key.toLowerCase();
-      console.assert(this.macros[lower] === void 0, "macro key collision", lower);
-      this.macros[lower] = macros[key];
-    }
+  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 path2 = comp.scope?.lookupPath?.(name) ?? null;
+    if (path2 !== null) {
+      const value2 = path2.lookup(this.root, NOT_FOUND);
+      if (value2 !== NOT_FOUND) return { value: value2, path: path2 };
+    }
+    const dval = comp.lookup[name] ?? 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 (`ctx` is
+  // then a send/intent transaction, which carries no `e`).
+  lookupEvent() {
+    return this.ctx?.e ?? 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];
+  }
+};
+var NOT_FOUND = /* @__PURE__ */ Symbol("NOT_FOUND");
+
+// src/components.js
+var COMPONENT = /* @__PURE__ */ Symbol.for("tutuca.component");
+var Components = class {
+  constructor() {
+    this.byId = /* @__PURE__ */ new Map();
+  }
+  registerComponent(Comp) {
+    this.byId.set(Comp.id, Comp);
+  }
+  getComponentForId(id) {
+    return this.byId.get(id) ?? null;
+  }
+  getCompFor(v) {
+    const Comp = v?.constructor;
+    return Comp?.[COMPONENT] ? Comp : null;
+  }
+  getHandlerFor(v, name, key) {
+    return this.getCompFor(v)?.[key][name] ?? null;
+  }
+  // The `lex` leg of an intent's route: the handlers registered on the scope chain of
+  // the component that raised it, innermost first. A list, not a first match — see
+  // ComponentStack.lookupIntentChain.
+  getIntentChainFor(v, name) {
+    return this.getCompFor(v)?.scope.lookupIntentChain(name) ?? [];
+  }
+  compileStyles() {
+    const styles = [];
+    for (const Comp of this.byId.values()) styles.push(Comp.compileStyle());
+    return styles.join("\n");
+  }
+};
+var ComponentStack = class _ComponentStack {
+  constructor(comps = new Components(), parent = null) {
+    this.comps = comps;
+    this.parent = parent;
+    this.byName = {};
+    this.intentsByName = {};
+    this.macros = {};
+    this.paths = {};
+  }
+  enter() {
+    return new _ComponentStack(this.comps, this);
+  }
+  registerComponents(comps, opts) {
+    const { aliases = {}, paths } = opts ?? {};
+    if (paths) this.registerPaths(paths);
+    for (let i = 0; i < comps.length; i++) {
+      const Comp = comps[i];
+      Comp.scope = this.enter();
+      this.comps.registerComponent(Comp);
+      this.byName[Comp.name] = Comp;
+    }
+    for (const alias in aliases) {
+      const comp = this.byName[aliases[alias]];
+      console.assert(this.byName[alias] === void 0, "alias overrides component", alias);
+      if (comp !== void 0) this.byName[alias] = comp;
+      else console.warn("alias", alias, "to inexistent component", aliases[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();
+    }
+  }
+  lookupPath(name) {
+    return this.paths[name] ?? this.parent?.lookupPath(name) ?? null;
+  }
+  registerMacros(macros) {
+    for (const key in macros) {
+      const lower = key.toLowerCase();
+      console.assert(this.macros[lower] === void 0, "macro key collision", lower);
+      this.macros[lower] = macros[key];
+    }
   }
   getCompFor(v) {
     return this.comps.getCompFor(v);
@@ -2485,97 +2697,82 @@ var ComponentStack = class _ComponentStack {
   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;
   }
 };
-var ProvideInfo = class {
-  constructor(val) {
-    this.val = val;
-  }
-};
-var LookupInfo = class {
-  constructor(val) {
-    this.val = val;
-  }
-};
 var isString = (v) => typeof v === "string";
-var isTypeName = (s) => {
-  const c = s.charCodeAt(0);
-  return c >= 65 && c <= 90;
-};
 var _rawSpecKeys = "name view style commonStyle globalStyle receive intent alter views provide lookup fields methods statics";
 var KNOWN_SPEC_KEYS = new Set(_rawSpecKeys.split(" "));
 var _compId = 0;
-var Component = class {
-  constructor(Class, o) {
-    this.id = _compId++;
-    this.name = o.name ?? "UnkComp";
-    this.Class = Class;
-    this.views = { main: new View("main", o.view, o.style) };
-    this.commonStyle = o.commonStyle ?? "";
-    this.globalStyle = o.globalStyle ?? "";
-    this.receive = o.receive ?? {};
-    this.intent = o.intent ?? {};
-    this.alter = o.alter ?? {};
-    for (const name in o.views ?? {}) {
-      const v = o.views[name];
-      const { view, style } = isString(v) ? { view: v } : v;
-      this.views[name] = new View(name, view, style);
-    }
-    this._rawProvide = o.provide ?? {};
-    this._rawLookup = o.lookup ?? [];
-    this.provide = {};
-    this.provideType = {};
-    this.lookup = {};
-    this.scope = null;
-    this.spec = o;
-    this.extra = {};
-    for (const key of Object.keys(o)) if (!KNOWN_SPEC_KEYS.has(key)) this.extra[key] = o[key];
-  }
+function initComponent(Class, o) {
+  Class[COMPONENT] = Class;
+  Class.id = _compId++;
+  Class.views = { main: new View("main", o.view, o.style) };
+  Class.commonStyle = o.commonStyle ?? "";
+  Class.globalStyle = o.globalStyle ?? "";
+  Class.receive = o.receive ?? {};
+  Class.intent = o.intent ?? {};
+  Class.alter = o.alter ?? {};
+  for (const name in o.views ?? {}) {
+    const v = o.views[name];
+    const { view, style } = isString(v) ? { view: v } : v;
+    Class.views[name] = new View(name, view, style);
+  }
+  Class._rawProvide = o.provide ?? {};
+  Class._rawLookup = o.lookup ?? [];
+  Class.provide = {};
+  Class.provideType = {};
+  Class.lookup = {};
+  Class.scope = null;
+  Class.spec = o;
+  Class.extra = {};
+  for (const key of Object.keys(o)) if (!KNOWN_SPEC_KEYS.has(key)) Class.extra[key] = o[key];
+  return Object.assign(Class, COMPONENT_METHODS);
+}
+var COMPONENT_METHODS = {
   compile(ParseContext2) {
     for (const name in this.views)
       this.views[name].compile(new ParseContext2(), this.scope, this.id);
     const ctx = this.views.main.ctx;
     for (const key in this._rawProvide) {
       if (isTypeName(key)) {
-        if (this._rawProvide[key] === "self") this.provideType[key] = this.Class;
+        if (this._rawProvide[key] === "self") this.provideType[key] = this;
         continue;
       }
       const val = parseProvide(this._rawProvide[key], ctx);
-      if (val) this.provide[key] = new ProvideInfo(val);
+      if (val) this.provide[key] = val;
     }
     for (const entry of this._rawLookup) {
       const name = isString(entry) ? entry : isString(entry?.name) ? entry.name : null;
       if (name === null) continue;
       const defStr = isString(entry?.default) ? entry.default : null;
-      this.lookup[name] = new LookupInfo(defStr === null ? null : parseField(defStr, ctx));
+      this.lookup[name] = defStr === null ? null : parseField(defStr, ctx);
     }
     for (const key in this.lookup)
       if (this.provide[key] !== void 0)
         console.warn("name declared in both provide and lookup", this.name, key);
-  }
+  },
   getView(name) {
     return this.views[name] ?? this.views.main;
-  }
-  getEventForId(id, name = "main") {
-    return this.getView(name).ctx.getEventForId(id);
-  }
-  getNodeForId(id, name = "main") {
-    return this.getView(name).ctx.getNodeForId(id);
-  }
+  },
+  getEventForId(id, viewName) {
+    return this.getView(viewName).ctx.getEventForId(id);
+  },
+  getNodeForId(id, viewName) {
+    return this.getView(viewName).ctx.getNodeForId(id);
+  },
   compileStyle() {
     const { id, commonStyle, globalStyle, views } = this;
     const styles = commonStyle ? [`[data-cid="${id}"]{${commonStyle}}`] : [];
@@ -2588,170 +2785,38 @@ var Component = class {
   }
 };
 
-// src/stack.js
-var STOP = /* @__PURE__ */ Symbol("STOP");
-var NEXT = /* @__PURE__ */ Symbol("NEXT");
-var DEFAULT_ROUTE = ["dyn", "lex"];
-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"');
-    }
-  }
+// src/oo.js
+var BAD_VALUE = /* @__PURE__ */ Symbol("BadValue");
+var COERCE_NONE = (_v) => null;
+var COERCE_MAP = (v) => {
+  if (v instanceof Map) return new Map(v);
+  if (Array.isArray(v) || isPlainObject(v))
+    return new Map(Array.isArray(v) ? v : Object.entries(v));
   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;
-}
-var 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;
-  }
 };
-var ObjectFrame = class {
-  constructor(binds) {
-    this.binds = binds;
-  }
-  lookup(key) {
-    const v = this.binds[key];
-    return v === void 0 ? NEXT : v;
-  }
+var FIELD_TYPES = {
+  any: [(_v) => true, COERCE_NONE, () => null],
+  text: [(v) => typeof v === "string", (v) => v?.toString?.() ?? "", () => ""],
+  int: [Number.isInteger, (v) => Number.isFinite(v) ? Math.trunc(v) : null, () => 0],
+  float: [Number.isFinite, COERCE_NONE, () => 0],
+  bool: [(v) => typeof v === "boolean", (v) => !!v, () => false],
+  list: [Array.isArray, (v) => Array.isArray(v) ? [...v] : null, () => []],
+  object: [isPlainObject, (v) => isPlainObject(v) ? { ...v } : null, () => ({})],
+  map: [(v) => v instanceof Map, COERCE_MAP, () => /* @__PURE__ */ new Map()],
+  set: [
+    (v) => v instanceof Set,
+    (v) => v instanceof Set || Array.isArray(v) ? new Set(v) : null,
+    () => /* @__PURE__ */ new Set()
+  ]
 };
-function computeViewsId(views) {
-  let s = "";
-  let n = views;
-  while (n !== null) {
-    s += n[0];
-    n = n[1];
-  }
-  return s === "main" ? "" : s;
-}
-var 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 has = false;
-    for (const k in provide) {
-      dynObj[k] = provide[k].val.eval(this);
-      has = true;
-    }
-    for (const k in provideType) {
-      dynObj[k] = provideType[k];
-      has = true;
-    }
-    if (!has) 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
-var BAD_VALUE = /* @__PURE__ */ Symbol("BadValue");
-var nullCoercer = (v) => v;
 var Field = class {
-  constructor(type, name, typeCheck, coercer, defaultValue = null) {
+  // `type` names an entry of FIELD_TYPES; `defaultValue` falls back to the type's own.
+  constructor(type, name, defaultValue, [typeCheck, coercer, makeDefault] = FIELD_TYPES[type]) {
     this.type = type;
     this.name = name;
     this.typeCheck = typeCheck;
     this.coercer = coercer;
-    this.defaultValue = defaultValue;
+    this.defaultValue = defaultValue === void 0 ? makeDefault() : defaultValue;
   }
   isValid(v) {
     return this.typeCheck(v);
@@ -2765,81 +2830,14 @@ var Field = class {
     return this.coerceOr(v, this.defaultValue);
   }
 };
-var CHECK_TYPE_ANY = (_v) => true;
-var CHECK_TYPE_INT = Number.isInteger;
-var CHECK_TYPE_FLOAT = Number.isFinite;
-var CHECK_TYPE_BOOL = (v) => typeof v === "boolean";
-var CHECK_TYPE_STRING = (v) => typeof v === "string";
-var CHECK_TYPE_LIST = Array.isArray;
-var CHECK_TYPE_OBJECT = isPlainObject;
-var CHECK_TYPE_MAP = (v) => v instanceof Map;
-var CHECK_TYPE_SET = (v) => v instanceof Set;
-var COERCE_NONE = (_v) => null;
-var COERCE_BOOL = (v) => !!v;
-var COERCE_STRING = (v) => v?.toString?.() ?? "";
-var COERCE_INT = (v) => Number.isFinite(v) ? Math.trunc(v) : null;
-var COERCE_LIST = (v) => Array.isArray(v) ? [...v] : null;
-var COERCE_OBJECT = (v) => isPlainObject(v) ? { ...v } : null;
-var COERCE_MAP = (v) => {
-  if (v instanceof Map) return new Map(v);
-  if (Array.isArray(v) || isPlainObject(v))
-    return new Map(Array.isArray(v) ? v : Object.entries(v));
-  return null;
-};
-var COERCE_SET = (v) => v instanceof Set || Array.isArray(v) ? new Set(v) : null;
-var FieldBool = class extends Field {
-  constructor(name, defaultValue = false) {
-    super("bool", name, CHECK_TYPE_BOOL, COERCE_BOOL, defaultValue);
-  }
-};
-var FieldAny = class extends Field {
-  constructor(name, defaultValue = null) {
-    super("any", name, CHECK_TYPE_ANY, nullCoercer, defaultValue);
-  }
-};
-var FieldString = class extends Field {
-  constructor(name, defaultValue = "") {
-    super("text", name, CHECK_TYPE_STRING, COERCE_STRING, defaultValue);
-  }
-};
-var FieldInt = class extends Field {
-  constructor(name, defaultValue = 0) {
-    super("int", name, CHECK_TYPE_INT, COERCE_INT, defaultValue);
-  }
-};
-var FieldFloat = class extends Field {
-  constructor(name, defaultValue = 0) {
-    super("float", name, CHECK_TYPE_FLOAT, COERCE_NONE, defaultValue);
-  }
-};
-var metaOf = (v) => v?.constructor?.[COMPONENT] ?? v?.constructor?.getMetaClass?.();
+var metaOf = (v) => v?.constructor?.getMetaClass?.();
 var getTypeName = (v) => metaOf(v)?.name ?? null;
 var FieldComp = class extends Field {
   constructor(type, name, args) {
-    super(type, name, (v) => getTypeName(v) === type, nullCoercer, null);
+    super(type, name, null, [(v) => getTypeName(v) === type, COERCE_NONE, () => null]);
     this.args = args;
   }
 };
-var FieldList = class extends Field {
-  constructor(name, defaultValue = []) {
-    super("list", name, CHECK_TYPE_LIST, COERCE_LIST, defaultValue);
-  }
-};
-var FieldObject = class extends Field {
-  constructor(name, defaultValue = {}) {
-    super("object", name, CHECK_TYPE_OBJECT, COERCE_OBJECT, defaultValue);
-  }
-};
-var FieldMap = class extends Field {
-  constructor(name, defaultValue = /* @__PURE__ */ new Map()) {
-    super("map", name, CHECK_TYPE_MAP, COERCE_MAP, defaultValue);
-  }
-};
-var FieldSet = class extends Field {
-  constructor(name, defaultValue = /* @__PURE__ */ new Set()) {
-    super("set", name, CHECK_TYPE_SET, COERCE_SET, defaultValue);
-  }
-};
 function mkCompField(field, scope, args) {
   const Comp = scope?.lookupComponent(field.type) ?? null;
   if (Comp === null)
@@ -2848,112 +2846,66 @@ function mkCompField(field, scope, args) {
     );
   return Comp?.make({ ...field.args, ...args }, { scope }) ?? null;
 }
-var ClassBuilder = class {
-  constructor(name) {
-    this.name = name;
-    this.fields = {};
-    this.compFields = /* @__PURE__ */ new Set();
-    this._methods = {};
-    this._statics = {};
-  }
-  build() {
-    const { name, fields, compFields, _methods } = this;
-    const defaults = Object.fromEntries(
-      Object.entries(fields).map(([fieldName, field]) => [fieldName, field.defaultValue])
-    );
-    const Class = {
-      [name]: class {
-        constructor(values = {}) {
-          Object.assign(this, defaults, values);
-        }
-      }
-    }[name];
-    Class[immer_exports.immerable] = true;
-    Object.assign(Class.prototype, _methods);
-    const metaClass = { fields, name, methods: _methods };
-    Object.assign(
-      Class,
-      {
-        getMetaClass: () => metaClass,
-        make(inArgs = {}, opts = {}) {
-          const args = {};
-          const scope = opts.scope ?? this[COMPONENT]?.scope ?? this.scope;
-          for (const key in inArgs) {
-            const field = fields[key];
-            if (compFields.has(key)) args[key] = mkCompField(field, scope, inArgs[key]);
-            else if (field === void 0)
-              console.warn("extra argument to constructor:", name, key, inArgs);
-            else args[key] = field.coerceOrDefault(inArgs[key]);
-          }
-          for (const key of compFields)
-            if (args[key] === void 0) args[key] = mkCompField(fields[key], scope, inArgs[key]);
-          return (0, immer_exports.freeze)(new this(args), true);
-        }
-      },
-      this._statics
-    );
-    return Class;
-  }
-  methods(proto) {
-    for (const k in proto) this._methods[k] = proto[k];
-  }
-  statics(proto) {
-    for (const k in proto) this._statics[k] = proto[k];
-  }
-  addField(name, dval, FieldCls) {
-    const field = new FieldCls(name, dval);
-    this.fields[name] = field;
-    return field;
-  }
-  addCompField(name, type, args) {
-    const field = new FieldComp(type, name, args);
-    this.compFields.add(name);
-    this.fields[name] = field;
-    return field;
-  }
-};
-var FIELD_CLASS = /* @__PURE__ */ Symbol.for("tutuca.fieldClass");
-var fieldsByTypeName = {
-  text: FieldString,
-  int: FieldInt,
-  float: FieldFloat,
-  bool: FieldBool,
-  list: FieldList,
-  object: FieldObject,
-  map: FieldMap,
-  set: FieldSet,
-  any: FieldAny
-};
-function fieldFromDescriptor(name, value) {
-  const FieldCls = fieldsByTypeName[value.type] ?? FieldAny;
-  const probe = new FieldCls(name);
-  return [FieldCls, probe.coerceOr(value.defaultValue, probe.defaultValue)];
+function fieldFromSpec(name, value) {
+  const type = typeof value;
+  if (type === "string") return new Field("text", name, value);
+  if (type === "number") return new Field("float", name, value);
+  if (type === "boolean") return new Field("bool", name, value);
+  if (Array.isArray(value)) return new Field("list", name, [...value]);
+  if (value instanceof Set) return new Field("set", name, new Set(value));
+  if (value instanceof Map) return new Field("map", name, new Map(value));
+  if (value?.type && Object.hasOwn(value, "defaultValue")) {
+    const t = value.type in FIELD_TYPES ? value.type : "any";
+    const probe = new Field(t, name);
+    return new Field(t, name, probe.coerceOr(value.defaultValue, probe.defaultValue));
+  }
+  if (value?.component && value?.args !== void 0)
+    return new FieldComp(value.component, name, value.args);
+  if (isPlainObject(value)) return new Field("object", name, { ...value });
+  return new Field("any", name, value);
 }
-function classFromData(name, { fields = {}, methods, statics }) {
-  const b = new ClassBuilder(name);
-  for (const field in fields) {
-    const value = fields[field];
-    const type = typeof value;
-    if (type === "string") b.addField(field, value, FieldString);
-    else if (type === "number") b.addField(field, value, FieldFloat);
-    else if (type === "boolean") b.addField(field, value, FieldBool);
-    else if (Array.isArray(value)) b.addField(field, [...value], FieldList);
-    else if (value instanceof Set) b.addField(field, new Set(value), FieldSet);
-    else if (value instanceof Map) b.addField(field, new Map(value), FieldMap);
-    else if (value?.type && Object.hasOwn(value, "defaultValue")) {
-      const [FieldCls, dval] = fieldFromDescriptor(field, value);
-      b.addField(field, dval, FieldCls);
-    } else if (value?.component && value?.args !== void 0)
-      b.addCompField(field, value.component, value.args);
-    else if (isPlainObject(value)) b.addField(field, { ...value }, FieldObject);
-    else {
-      const FieldCls = value?.[FIELD_CLASS] ?? FieldAny;
-      b.addField(field, value, FieldCls);
+function classFromData(name, { fields: spec = {}, methods = {}, statics = {} }) {
+  const fields = {};
+  for (const key in spec) fields[key] = fieldFromSpec(key, spec[key]);
+  const defaults = Object.fromEntries(
+    Object.entries(fields).map(([key, field]) => [key, field.defaultValue])
+  );
+  const Class = {
+    [name]: class {
+      constructor(values = {}) {
+        Object.assign(this, defaults, values);
+      }
     }
-  }
-  if (methods) b.methods(methods);
-  if (statics) b.statics(statics);
-  return b.build();
+  }[name];
+  Class[immer_exports.immerable] = true;
+  Object.assign(Class.prototype, methods);
+  Object.assign(
+    Class,
+    {
+      fields,
+      methods,
+      // The documented way for instance code to reach its class's fields
+      // (`this.constructor.getMetaClass().fields.x.defaultValue`).
+      getMetaClass: () => Class,
+      make(inArgs = {}, opts = {}) {
+        const args = {};
+        const scope = opts.scope ?? this.scope;
+        for (const key in inArgs) {
+          const field = fields[key];
+          if (field === void 0)
+            console.warn("extra argument to constructor:", name, key, inArgs);
+          else if (field instanceof FieldComp) args[key] = mkCompField(field, scope, inArgs[key]);
+          else args[key] = field.coerceOrDefault(inArgs[key]);
+        }
+        for (const key in fields)
+          if (fields[key] instanceof FieldComp && args[key] === void 0)
+            args[key] = mkCompField(fields[key], scope, void 0);
+        return (0, immer_exports.freeze)(new this(args), true);
+      }
+    },
+    statics
+  );
+  return Class;
 }
 function validateDraftFields(current, draft) {
   const meta = metaOf(current);
@@ -2969,14 +2921,11 @@ function validateDraftFields(current, draft) {
     }
   }
 }
-var META_KEYS = "name id fields methods views receive intent alter provide provideType lookup spec extra commonStyle globalStyle scope _rawProvide _rawLookup".split(
-  " "
-);
 var RESERVED_COMPONENT_STATICS = /* @__PURE__ */ new Set([
-  ...META_KEYS,
-  "make",
-  "getMetaClass",
-  ...Object.getOwnPropertyNames(Component.prototype)
+  ..."name id fields methods views receive intent alter provide provideType lookup spec extra commonStyle globalStyle scope _rawProvide _rawLookup make getMetaClass".split(
+    " "
+  ),
+  ...Object.keys(COMPONENT_METHODS)
 ]);
 function assertNoReservedComponentStatics(statics = {}) {
   for (const name in statics) {
@@ -2985,32 +2934,10 @@ function assertNoReservedComponentStatics(statics = {}) {
     }
   }
 }
-Component.fromSpec = (opts) => {
+function component(opts) {
   assertNoReservedComponentStatics(opts.statics);
-  const Class = classFromData(opts.name, opts);
-  const comp = new Component(Class, opts);
-  const metaClass = Class.getMetaClass();
-  comp.fields = metaClass.fields;
-  comp.methods = metaClass.methods;
-  Class.getMetaClass = () => comp;
-  Class[COMPONENT] = comp;
-  for (const key of META_KEYS)
-    if (!Object.hasOwn(Class, key))
-      Object.defineProperty(Class, key, {
-        get() {
-          return comp[key];
-        },
-        set(v) {
-          comp[key] = v;
-        },
-        configurable: true
-      });
-  for (const key of Object.getOwnPropertyNames(Component.prototype))
-    if (key !== "constructor" && !Object.hasOwn(Class, key))
-      Class[key] = (...args) => comp[key](...args);
-  return Class;
-};
-var component = (opts) => Component.fromSpec(opts);
+  return initComponent(classFromData(opts.name ?? "UnkComp", opts), opts);
+}
 
 // src/transactor.js
 var State = class {
@@ -3051,14 +2978,7 @@ var Transactor = class {
   // carry: kind, name, args, path, pathKeys, targetPath, handler, handlerName,
   // matched, before, after, parent, timestamp. Purely observational.
   observe(cb) {
-    this._observers.push(cb);
-    return () => {
-      const i = this._observers.indexOf(cb);
-      if (i !== -1) this._observers.splice(i, 1);
-    };
-  }
-  _emit(record) {
-    for (const cb of this._observers) cb(record);
+    return subscribe(this._observers, cb);
   }
   // Record a refusal: a dispatch the runtime could not carry out. Kinds are
   // open strings; today the runtime raises NO_HANDLER (a receive name with no
@@ -3077,20 +2997,16 @@ var Transactor = class {
   // Subscribe to refusal records as they happen. Returns an unsubscribe fn,
   // like observe().
   observeRefusals(cb) {
-    this._refusalObservers.push(cb);
-    return () => {
-      const i = this._refusalObservers.indexOf(cb);
-      if (i !== -1) this._refusalObservers.splice(i, 1);
-    };
+    return subscribe(this._refusalObservers, cb);
   }
   // Build and dispatch one observer record. Pins field-resolved keys (e.g. a
   // `.a[.selId]` render target reconstructed from a DOM event) against the root the
   // handler read, so pathKeys carries concrete keys instead of dropping the dynamic
   // step. No-op when nobody is observing.
-  _emitRecord(root, { kind, name, args, path, targetPath, handler, handlerName, matched, before, after, parent }) {
+  _emitRecord(root, { kind, name, args, path: path2, targetPath, handler, handlerName, matched, before, after, parent }) {
     if (this._observers.length === 0) return;
-    const pinned = path.pinKeys(root);
-    this._emit({
+    const pinned = path2.pinKeys(root);
+    const record = {
       kind,
       name,
       args: args ?? null,
@@ -3104,14 +3020,14 @@ var Transactor = class {
       after,
       parent,
       timestamp: Date.now()
-    });
+    };
+    for (const cb of this._observers) cb(record);
   }
   // The observer record for a settled transaction. The resolved handler
   // (`_resolvedHandler`/`_matched`) and per-leaf before/after (`_before`/`_after`)
   // were captured while the handler ran (see callHandler / Transaction.run).
   _emitTransaction(transaction, root) {
     if (this._observers.length === 0) return;
-    if (transaction._resolvedHandler === void 0) return;
     this._emitRecord(root, {
       kind: transaction.observeKind,
       name: transaction.observeName,
@@ -3125,33 +3041,29 @@ var Transactor = class {
       parent: transaction.parentTransaction
     });
   }
-  // Make `child` a tracked unit of `parent`'s subtree: the parent's completion stays open
-  // until the child's *whole* subtree settles. Tracking happens at dispatch time — during
-  // the parent's handler or afterTransaction — while the parent's self-unit is still held,
-  // so the parent counter can't reach zero before the child is registered. Returns `child`.
-  _link(child, parent) {
-    if (parent) {
-      const release = parent.completion.track();
-      child.completion.whenSubtreeSettled().then(release);
-    }
-    return child;
-  }
   // `origin` is where the message came FROM, pinned now for the same reason an
   // 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) {
-    const t = new SendEvent(path, this, name, args, parent);
-    t.origin = origin === null ? null : origin.toTransactionPath().pinKeys(this.state.val);
+  //
+  // The parent's subtree stays open until this message's whole subtree settles. The
+  // unit is taken now, at dispatch — during the parent's handler or afterTransaction,
+  // while the parent's self-unit is still held — so its counter can't reach zero first.
+  pushSend(path2, name, args = [], parent = null, origin = null, txnPath = null) {
+    const t = new SendEvent(path2, this, name, args, parent);
+    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);
+    if (parent) t.completion.carry(parent.completion.track());
+    return t;
   }
   // Raise an intent: a job the sender did not address, walked along a route until
   // something answers. `opts.route` is a list of legs (see DEFAULT_ROUTE) and
   // `opts.livePath` opts out of pinning the answer's destination keys.
-  pushIntent(path, name, args = [], opts = {}, parent = null) {
+  pushIntent(path2, name, args = [], opts = {}, parent = null) {
     const release = parent ? parent.completion.track() : null;
-    const walk = new IntentWalk(this, path, name, args, opts, parent, release);
+    const walk = new IntentWalk(this, path2, name, args, opts, parent, release);
     walk.advance();
     return walk;
   }
@@ -3168,7 +3080,7 @@ var Transactor = class {
     return this.transactions.length > 0;
   }
   transactNext() {
-    if (this.hasPendingTransactions) this.transact(this.transactions.shift());
+    this.transact(this.transactions.shift());
   }
   transact(transaction) {
     try {
@@ -3181,20 +3093,31 @@ var Transactor = class {
       } else console.warn("undefined new state", { curState, transaction });
     } finally {
       transaction.ensureWalkAdvanced?.();
-      transaction._completion?.ensureSelfSettled();
-      transaction._completion?.releaseSelf();
+      transaction._completion?.finish();
     }
   }
-  transactInputNow(path, event, eventHandler, dragInfo) {
-    this.transact(new InputEvent(path, event, eventHandler, this, dragInfo));
+  transactInputNow(path2, event, eventHandler, dragInfo) {
+    this.transact(new InputEvent(path2, event, eventHandler, this, dragInfo));
   }
 };
 function nullHandler() {
   return this;
 }
+function subscribe(list, cb) {
+  list.push(cb);
+  return () => {
+    const i = list.indexOf(cb);
+    if (i !== -1) list.splice(i, 1);
+  };
+}
+function warnUnknownLeg(what, leg) {
+  console.warn(`unknown ${what} route leg`, leg, '- expected "dyn" or "lex"');
+  return null;
+}
 var Transaction = class {
-  constructor(path, transactor, parentTransaction = null) {
-    this.path = path;
+  constructor(path2, transactor, parentTransaction = null) {
+    this.path = path2;
+    this.txnPath = null;
     this.transactor = transactor;
     this.parentTransaction = parentTransaction;
     this._completion = null;
@@ -3214,39 +3137,41 @@ var Transaction = class {
   whenSubtreeSettled() {
     return this.completion.whenSubtreeSettled();
   }
-  afterTransaction() {
-  }
-  // Ending a walk and forwarding belong to the two dispatch buckets; the base warns
-  // rather than throwing, so a stray call from the wrong place is a message and not a
-  // crash. `walk` is undefined here, which is how ctx.reply/ctx.fail tell the two apart.
-  stop() {
-    warnNotIntent("stop");
-  }
-  forward(_opts) {
-    console.warn('ctx.forward() needs a "receive" or "intent" handler - ignored');
-  }
-  // The kind reported to observers (see Transactor.observe); null on the base.
-  get observeKind() {
-    return null;
-  }
-  // The name reported to observers; null on the base. Overridden by NameArgs (the
-  // dispatched message name) and InputEvent (the DOM event type). Kept separate from
-  // `name`/`ctx.name` so it can't change handler-visible behavior.
-  get observeName() {
-    return null;
-  }
+  // Every transaction kind defines `observeKind` / `observeName` (what observers see;
+  // kept apart from `name`/`ctx.name` so they can't change handler-visible behavior),
+  // `getHandlerAndArgs(root, instance, comps)`, and the three `_forward*` hooks below.
   callHandler(root, instance, draft, comps) {
     const [handler, args] = this.getHandlerAndArgs(root, instance, comps);
     this._resolvedHandler = handler;
     return handler.apply(instance, [draft, ...args]);
   }
-  getHandlerAndArgs(_root, _instance, _comps) {
-    return null;
+  // `forward` is where a name can LEAVE the component: the message being handled is
+  // raised again as an INTENT under the same name (`_forwardName()`) with the same
+  // arguments unless `opts.args` says otherwise, from the position `_forwardPath()`
+  // names. Deferred to afterTransaction so the state the handler produced is in place
+  // before the walk starts. (`IntentEvent` overrides both: in an intent body, forward
+  // amends the walk that is already running.)
+  forward(opts) {
+    this._forward = opts ?? {};
   }
-  // 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).
+  afterTransaction() {
+    const f = this._forward;
+    if (f === void 0) return;
+    this._forward = void 0;
+    const name = this._forwardName();
+    if (name === void 0) {
+      this.transactor.refuse("FORWARD_NO_NAME", {});
+      return;
+    }
+    const { args = this._forwardArgs(), ...rest } = f;
+    this.transactor.pushIntent(this._forwardPath(), name, args, rest, this);
+  }
+  // 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).
+  // `txnPath`, when pinned by the sender, wins.
   getTransactionPath() {
-    return this.path.toTransactionPath().compact();
+    return this.txnPath ?? this.path.toTransactionPath();
   }
   run(curRoot, comps) {
     const txnPath = this.getTransactionPath();
@@ -3263,19 +3188,27 @@ var Transaction = class {
   }
 };
 var InputEvent = class extends Transaction {
-  constructor(path, e, handler, transactor, dragInfo) {
-    super(path, transactor);
+  constructor(path2, e, handler, transactor, dragInfo) {
+    super(path2, transactor);
     this.e = e;
     this.handler = handler;
     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;
   }
+  // Only a DOM event's path carries frame-only bind steps (they replay the handler's
+  // arguments, but address no state); the compacted path is where the mutation lands,
+  // so a handler inside @each still updates the component that owns the view. Every
+  // other transaction is dispatched at an already-compacted position.
+  getTransactionPath() {
+    return this.dispatchPath.toTransactionPath();
+  }
   // A DOM event is an ADDRESSED message like any other — it reaches the component that
   // owns the view and stops. It keeps its own class only because it resolves its handler
   // from the compiled view and runs synchronously, not because it is a different channel.
@@ -3285,47 +3218,36 @@ var InputEvent = class extends Transaction {
   get observeName() {
     return this.e?.type ?? null;
   }
-  // A view's name is a message. `forward` is where that name can LEAVE the component:
-  // it becomes an intent with the same name and the same arguments, so a view that says
-  // `@on.click="saveDraft .text"` never has to change when an ancestor takes the job over.
-  // (A `$method` handler has a name too, so forwarding one raises an intent under it.)
-  forward(opts) {
-    this._forward = opts ?? {};
-  }
-  afterTransaction() {
-    const f = this._forward;
-    if (f === void 0) return;
-    this._forward = void 0;
-    const { args = this._handlerArgs ?? [], ...rest } = f;
+  // A view's name is a message, and forwarding it means a view that says
+  // `@on.click="saveDraft .text"` never has to change when an ancestor takes the job
+  // over. (A `$method` handler has a name too, so forwarding one raises an intent under
+  // it.) `handler` is a NodeEvent, whose own `name` is the DOM event type; the MESSAGE
+  // name is the one the view wrote, on the handler call it wraps.
+  _forwardName() {
     const hv = this.handler?.handlerCall?.handlerVal ?? this.handler?.handlerVal;
-    const name = hv?.name;
-    if (name === void 0) {
-      this.transactor.refuse("FORWARD_NO_NAME", {});
-      return;
-    }
-    this.transactor.pushIntent(this.dispatchPath, name, args, rest, this);
+    return hv?.name;
+  }
+  _forwardArgs() {
+    return this._handlerArgs ?? [];
+  }
+  _forwardPath() {
+    return this.dispatchPath;
   }
   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;
-    args.push(new EventContext(path, this.transactor, this));
+    const path2 = this.dispatchPath;
+    args.push(new EventContext(path2, this.transactor, this));
     return [handler, args];
   }
-  // The dispatched DOM event, read only through `e.<member>` handler args
-  // (src/value.js EventMemberVal via Stack.lookupEvent). There is no bare
-  // implicit-name vocabulary anymore: every arg carries a sigil.
-  get event() {
-    return this.e;
-  }
 };
 var NameArgsTransaction = class extends Transaction {
-  constructor(path, transactor, name, args, parentTransaction) {
-    super(path, transactor, parentTransaction);
+  constructor(path2, transactor, name, args, parentTransaction) {
+    super(path2, transactor, parentTransaction);
     this.name = name;
     this.args = args;
-    this.targetPath = path;
+    this.targetPath = path2;
   }
   handlerProp = null;
   // NameArgs verbs map their handler bucket straight to the observed kind:
@@ -3336,6 +3258,17 @@ var NameArgsTransaction = class extends Transaction {
   get observeName() {
     return this.name;
   }
+  // `forward` in a RECEIVE body starts a walk: the message that arrived becomes an
+  // intent, keeping its name and payload.
+  _forwardName() {
+    return this.name;
+  }
+  _forwardArgs() {
+    return this.args;
+  }
+  _forwardPath() {
+    return this.path;
+  }
   getHandlerForName(comp) {
     const handlers = comp?.[this.handlerProp];
     const exact = handlers?.[this.name];
@@ -3366,24 +3299,11 @@ var SendEvent = class extends NameArgsTransaction {
   get observeKind() {
     return this._isAnswer ? "answer" : "receive";
   }
-  // `forward` in a RECEIVE body starts a walk: the message that arrived becomes an
-  // intent, keeping its name and payload. This is what lets a view's name leave the
-  // component without the view changing.
-  forward(opts) {
-    this._forward = opts ?? {};
-  }
-  afterTransaction() {
-    const f = this._forward;
-    if (f === void 0) return;
-    this._forward = void 0;
-    const { args = this.args, ...rest } = f;
-    this.transactor.pushIntent(this.path, this.name, args, rest, this);
-  }
 };
 var IntentEvent = class extends NameArgsTransaction {
   handlerProp = "intent";
-  constructor(path, transactor, walk) {
-    super(path, transactor, walk.name, walk.args, walk.parent);
+  constructor(path2, transactor, walk) {
+    super(path2, transactor, walk.name, walk.args, walk.parent);
     this.walk = walk;
     this.targetPath = walk.origin;
   }
@@ -3392,9 +3312,6 @@ var IntentEvent = class extends NameArgsTransaction {
   forward(opts) {
     this.walk.amend(opts, this.path);
   }
-  stop() {
-    this.walk.finish(null, null);
-  }
   afterTransaction() {
     this.ensureWalkAdvanced();
   }
@@ -3410,17 +3327,17 @@ var PASS = /* @__PURE__ */ Symbol.for("tutuca.intent.pass");
 var REFUSAL_RING_CAP = 200;
 var INTENT_DEPTH = 64;
 var IntentWalk = class {
-  constructor(transactor, path, name, args, opts, parent, release) {
+  constructor(transactor, path2, name, args, opts, parent, release) {
     this.transactor = transactor;
     this.name = name;
     this.args = args;
     this.route = opts?.route ?? DEFAULT_ROUTE;
     this.parent = parent;
     this.release = release;
-    this.origin = path;
-    this.answerPath = opts?.livePath ? null : path.toTransactionPath().pinKeys(transactor.state.val);
+    this.origin = path2;
+    this.answerPath = opts?.livePath ? null : path2.toTransactionPath().pinKeys(transactor.state.val);
     this.legIndex = 0;
-    this.dynAt = path;
+    this.dynAt = path2;
     this.hops = 0;
     this.ended = false;
   }
@@ -3432,7 +3349,7 @@ var IntentWalk = class {
     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;
         }
@@ -3444,7 +3361,7 @@ var IntentWalk = class {
         this.legIndex++;
         return this._tryLex();
       }
-      console.warn("unknown intent route leg", leg, '- expected "dyn" or "lex"');
+      warnUnknownLeg("intent", leg);
       this.legIndex++;
     }
     this.exhaust("noHandler");
@@ -3529,11 +3446,11 @@ var IntentWalk = class {
     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);
+    if (this.release) t.completion.carry(this.release);
   }
 };
 var Completion = class {
@@ -3541,12 +3458,12 @@ var Completion = class {
     this.val = void 0;
     this.selfSettled = false;
     this.subtreeSettled = false;
-    this.pending = 1;
+    this.pending = 0;
     this._selfResolve = null;
     this._selfPromise = null;
     this._subtreeResolve = null;
     this._subtreePromise = null;
-    this._selfReleased = false;
+    this._releaseSelf = this.track();
   }
   whenSettled() {
     if (this.selfSettled) return Promise.resolve(this.val);
@@ -3569,38 +3486,38 @@ var Completion = class {
     this.val = val;
     this._selfResolve?.(val);
   }
-  // Settle self even when no handler produced a value (undefined-state / throw paths).
-  ensureSelfSettled() {
-    if (!this.selfSettled) this.markSelfSettled(this.val);
+  // The transaction is done processing: self is settled (with the value the handler
+  // produced, or none on the undefined-state / throw paths) and the self-unit goes.
+  finish() {
+    this.markSelfSettled(this.val);
+    this._releaseSelf();
   }
-  // Register an outstanding unit; returns a one-shot release.
+  // Register an outstanding unit; returns its one-shot release. The subtree settles
+  // when the last unit is released.
   track() {
     this.pending++;
     let done = false;
     return () => {
       if (done) return;
       done = true;
-      this._release();
+      if (--this.pending === 0) {
+        this.subtreeSettled = true;
+        this._subtreeResolve?.(this.val);
+      }
     };
   }
-  releaseSelf() {
-    if (this._selfReleased) return;
-    this._selfReleased = true;
-    this._release();
-  }
-  _release() {
-    if (--this.pending === 0) {
-      this.subtreeSettled = true;
-      this._subtreeResolve?.(this.val);
-    }
+  // Hand a unit held elsewhere to this subtree: `release` runs once this transaction
+  // and everything it spawned have settled.
+  carry(release) {
+    this.whenSubtreeSettled().then(release);
   }
 };
 var Dispatcher = class {
-  constructor(path, transactor, parentTransaction, root = transactor.state.val) {
-    this.path = path;
+  constructor(path2, transactor, parentTransaction) {
+    this.path = path2;
     this.transactor = transactor;
     this.parent = parentTransaction;
-    this.root = root;
+    this.root = transactor.state.val;
   }
   // Walk the component instances on this ctx's path, leaf→root, calling
   // callback(Component, instance). Return false from the callback to stop early.
@@ -3625,28 +3542,37 @@ var Dispatcher = class {
   // 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
   // the same spelling as `ctx.intent` — `["dyn"]` the render ancestry, `["lex"]` the
   // registration scope, default both.
+  // Legs are tried in route order, like the intent walker's; an unknown leg warns and
+  // is skipped, and an empty route resolves to null.
   lookup(name, opts) {
-    return routeLookup(
-      opts?.route ?? DEFAULT_ROUTE,
-      () => this._lookupLex(name),
-      () => this._stack()?.lookupDynamic(name) ?? null
-    );
+    for (const leg of opts?.route ?? DEFAULT_ROUTE) {
+      const v = leg === "dyn" ? this._stack()?.lookupDynamic(name) ?? null : leg === "lex" ? this._lookupLex(name) : warnUnknownLeg("lookup", leg);
+      if (v != null) return v;
+    }
+    return null;
   }
   // 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
@@ -3668,8 +3594,8 @@ var Dispatcher = class {
   send(name, args) {
     return this.sendAtPath(this.path, name, args);
   }
-  sendAtPath(path, name, args) {
-    return this.transactor.pushSend(path, name, args, this.parent, this.path);
+  sendAtPath(path2, name, args) {
+    return this.transactor.pushSend(path2, name, args, this.parent, this.path);
   }
   // An intent is ROUTED: it names a job and walks until something answers. The verb
   // does not decide which scope answers — `opts.route` does, written here at the call
@@ -3677,8 +3603,8 @@ var Dispatcher = class {
   intent(name, args, opts) {
     return this.intentAtPath(this.path, name, args, opts);
   }
-  intentAtPath(path, name, args, opts) {
-    return this.transactor.pushIntent(path, name, args, opts, this.parent);
+  intentAtPath(path2, name, args, opts) {
+    return this.transactor.pushIntent(path2, name, args, opts, this.parent);
   }
 };
 var EventContext = class extends Dispatcher {
@@ -3707,11 +3633,19 @@ var EventContext = class extends Dispatcher {
       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".
+  // End the walk answering nothing — "served, and no answer". Like reply/fail,
+  // legal only in an `intent` handler.
   stop() {
-    return this.parent.stop();
+    return this.parent.walk === void 0 ? warnNotIntent("stop") : this.parent.walk.finish(null, null);
   }
   // From an `intent` body: hand the intent to the next hop, optionally amending it.
   // From a `receive` body: turn the message that arrived into an intent. One word from
@@ -3739,7 +3673,7 @@ var PathChanges = class extends PathBuilder {
   }
 };
 function rootDispatcher(transactor) {
-  return new Dispatcher(new Path([]), transactor, null);
+  return new Dispatcher(new DispatchPath(), transactor, null);
 }
 
 // src/app.js
@@ -3752,7 +3686,6 @@ var App = class {
     this.transactor = new Transactor(comps, null);
     this.ParseContext = ParseContext2;
     this.renderer = renderer;
-    this.maxEventNodeDepth = Infinity;
     this._transactNextBatchId = this._evictCacheId = null;
     this._eventNames = new Set(_evs);
     this.dragInfo = this.curDragOver = null;
@@ -3779,18 +3712,17 @@ var App = class {
   _dispatchEvent(e) {
     const { type } = e;
     const isDrag = type === "dragover" || type === "dragstart" || type === "dragend" || type === "drop";
-    const { rootNode: root, maxEventNodeDepth: maxDepth, comps, transactor } = this;
-    const [path, handlers] = Path.fromNodeAndEventName(
+    const { rootNode, comps, transactor } = this;
+    const [path2, handlers] = DispatchPath.fromNodeAndEventName(
       e.target,
       type,
-      root,
-      maxDepth,
+      rootNode,
       comps,
       !isDrag
     );
-    if (isDrag) this._handleDragEvent(e, type, path);
-    if (path !== null && handlers !== null)
-      for (const handler of handlers) transactor.transactInputNow(path, e, handler, this.dragInfo);
+    if (isDrag) this._handleDragEvent(e, type, path2);
+    if (path2 !== null && handlers !== null)
+      for (const handler of handlers) transactor.transactInputNow(path2, e, handler, this.dragInfo);
   }
   _handleTouchEvent(e) {
     const { type } = e;
@@ -3833,7 +3765,7 @@ var App = class {
       this._touch = null;
     }
   }
-  _handleDragEvent(e, type, path) {
+  _handleDragEvent(e, type, path2) {
     if (type === "dragover") {
       const dropTarget = getClosestDropTarget(e.target, this.rootNode, Infinity);
       if (dropTarget !== null) {
@@ -3845,10 +3777,10 @@ var App = class {
     } else if (type === "dragstart") {
       e.target.dataset.dragging = 1;
       const rootValue = this.state.val;
-      const txnPath = path.compact().toTransactionPath();
+      const txnPath = path2.compact().toTransactionPath();
       const value = txnPath.lookup(rootValue);
       const dragType = e.target.dataset.dragtype ?? "?";
-      const stack = path.toTransactionPath().buildStack(this.makeStack(rootValue));
+      const stack = path2.buildStack(this.makeStack(rootValue));
       this.dragInfo = new DragInfo(stack, value, dragType, e.target);
     } else if (type === "drop") {
       e.preventDefault();
@@ -3893,10 +3825,9 @@ var App = class {
   }
   compile() {
     for (const Comp of this.comps.byId.values()) {
-      const meta = Comp[COMPONENT];
-      meta.compile(this.ParseContext);
-      for (const key in meta.views)
-        for (const name of meta.views[key].ctx.genEventNames()) this._eventNames.add(name);
+      Comp.compile(this.ParseContext);
+      for (const key in Comp.views)
+        for (const name of Comp.views[key].ctx.genEventNames()) this._eventNames.add(name);
     }
     this._compiled = true;
   }
@@ -3919,11 +3850,13 @@ var App = class {
   }
   stop() {
     this.stopCacheEvictionInterval();
+    clearTimeout(this._transactNextBatchId);
+    this._transactNextBatchId = null;
     for (const name of this._eventNames)
       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();
@@ -4005,28 +3938,21 @@ var NullDomCache = class {
   set(_keys, _cacheKey, _v) {
   }
   evict() {
-    return { hit: 0, miss: 0, badKey: 0 };
   }
 };
 var WeakMapDomCache = class {
   constructor() {
-    this.hit = this.miss = this.badKey = 0;
     this.keysByLen = /* @__PURE__ */ new Map();
   }
-  _returnValue(r) {
-    if (r === void 0) this.miss += 1;
-    else this.hit += 1;
-    return r;
-  }
   get(keys, cacheKey) {
     const len = keys.length;
     let cur = this.keysByLen.get(len);
-    if (!cur) return this._returnValue(void 0);
+    if (!cur) return void 0;
     for (let i = 0; i < len - 1; i++) {
       cur = cur.get(keys[i]);
-      if (!cur) return this._returnValue(void 0);
+      if (!cur) return void 0;
     }
-    return this._returnValue(cur.get(keys[len - 1])?.[cacheKey]);
+    return cur.get(keys[len - 1])?.[cacheKey];
   }
   set(keys, cacheKey, v) {
     const len = keys.length;
@@ -4039,10 +3965,7 @@ var WeakMapDomCache = class {
       const key = keys[i];
       let next = cur.get(key);
       if (!next) {
-        if (!isWeakKey(key)) {
-          this.badKey += 1;
-          return;
-        }
+        if (!isWeakKey(key)) return;
         next = /* @__PURE__ */ new WeakMap();
         cur.set(key, next);
       }
@@ -4052,23 +3975,38 @@ var WeakMapDomCache = class {
     const leaf = cur.get(lastKey);
     if (leaf) leaf[cacheKey] = v;
     else if (isWeakKey(lastKey)) cur.set(lastKey, { [cacheKey]: v });
-    else this.badKey += 1;
   }
   evict() {
-    const { hit, miss, badKey } = this;
-    this.hit = this.miss = this.badKey = 0;
     this.keysByLen = /* @__PURE__ */ new Map();
-    return { hit, miss, badKey };
   }
 };
 
 // src/renderer.js
-var DATASET_ATTRS = ["nid", "cid", "eid", "vid", "si", "sk"];
+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 Renderer = class {
   constructor(comps) {
     this.comps = comps;
     this.cache = new WeakMapDomCache();
-    this.renderTag = h;
+  }
+  // Parse nodes build their VDOM through the renderer, never by importing vdom.js
+  // themselves: a component may have been compiled by ANOTHER copy of the library
+  // (a docs example imports the dist bundle while the host app runs from src), and
+  // `render()` recognizes VNodes by `instanceof` against ITS copy's classes. Going
+  // through `rx` guarantees the rendering copy makes them.
+  renderTag(tag, attrs, childs, namespace) {
+    return h(tag, attrs, childs, namespace);
   }
   renderFragment(childs) {
     return new VFragment(childs);
@@ -4079,38 +4017,24 @@ var Renderer = class {
   setNullCache() {
     this.cache = new NullDomCache();
   }
-  // Library utilities for consumers embedding tutuca: render a value to a detached
-  // DOM node / an HTML string. Not called by the framework itself.
-  renderToDOM(stack, val) {
-    const rootNode = document.createElement("div");
-    const rOpts = { document };
-    render(h("DIV", null, [this.renderRoot(stack, val)]), rootNode, rOpts);
-    return rootNode.childNodes[0];
-  }
-  renderToString(stack, val, cleanAttrs = true) {
-    const dom = this.renderToDOM(stack, val);
-    if (cleanAttrs) {
-      const nodes = dom.querySelectorAll("[data-nid],[data-cid],[data-eid]");
-      for (const { dataset } of nodes) for (const name of DATASET_ATTRS) delete dataset[name];
-    }
-    return dom.innerHTML;
-  }
   renderRoot(stack, val, viewName = null) {
     const comp = this.comps.getCompFor(val);
     if (comp === null) return null;
     return this._rValComp(stack, val, comp, comp.getView(viewName).anode, "ROOT", viewName);
   }
-  renderIt(stack, node, key, viewName) {
+  // Render `stack.it` at a `<x render*>` site (`node`). `base` is the absolute
+  // path the site resumed at, when it rendered a `*name` (see _rValComp).
+  renderIt(stack, node, 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, "", 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);
@@ -4118,30 +4042,43 @@ var Renderer = class {
     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) {
-    const { seq, filter, loopWith, enricher } = iterInfo.eval(stack);
+  renderEachWhen(stack, each) {
+    const { val: seqVal, node: view, nodeId: nid } = each;
+    const { seq, filter, loopWith, enricher } = each.evalIter(stack);
+    const seqPath = seqVal instanceof DynVal ? stack.lookupDynamicLocated(seqVal.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 ? each.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);
       }
@@ -4205,17 +4142,18 @@ function dispatchPhase(dispatcher, targetPath, phase, self) {
 var css = String.raw;
 var html = String.raw;
 var macro = (defaults, rawView) => new Macro(defaults, rawView);
+var devOnly = (name, result) => {
+  console.warn(`${name} is a no-op in the core tutuca build; import tutuca/dev for the real one`);
+  return result;
+};
 function check(_app) {
-  return { error: 0, warn: 0, hint: 0, dummyCheck: true };
+  return devOnly("check", { error: 0, warn: 0, hint: 0 });
 }
 async function test(_opts) {
-  return null;
+  return devOnly("test", null);
 }
 function collectIterBindings() {
-  console.warn(
-    "collectIterBindings is a no-op in the core tutuca build; use the tutuca-dev build for a functional implementation"
-  );
-  return [];
+  return devOnly("collectIterBindings", []);
 }
 function tutuca(nodeOrSelector) {
   const rootNode = typeof nodeOrSelector === "string" ? document.querySelector(nodeOrSelector) : nodeOrSelector;
@@ -4225,7 +4163,6 @@ function tutuca(nodeOrSelector) {
 }
 export {
   COMPONENT,
-  FIELD_CLASS,
   PASS,
   ParseContext,
   SEQ_INFO,
@@ -4237,6 +4174,7 @@ export {
   html,
   injectCss,
   macro,
+  path,
   phaseOps,
   resolveArgs,
   rootDispatcher,