tutuca 0.12.0 → 0.13.0

package/dist/tutuca-extra.js

@@ -782,9 +782,6 @@ var Step = class {
   lookup(_v, dval = null) {
     return dval;
   }
-  setValue(root, _v) {
-    return root;
-  }
   setDraftValue(_root, _v) {
   }
   enterFrame(stack, _prev, next) {
@@ -813,9 +810,6 @@ var BindStep = class _BindStep extends Step {
   lookup(v, _dval) {
     return v;
   }
-  setValue(_root, v) {
-    return v;
-  }
   enterFrame(stack, _prev, next) {
     return stack.enter(next, { ...this.binds }, false);
   }
@@ -853,9 +847,6 @@ var FieldStep = class extends Step {
   lookup(v, dval = null) {
     return readKey(v, this.field, dval);
   }
-  setValue(root, v) {
-    return produce(root, (draft) => this.setDraftValue(draft, v));
-  }
   setDraftValue(root, v) {
     writeKey(root, this.field, v);
   }
@@ -878,9 +869,6 @@ var SeqStep = class extends Step {
   lookup(v, dval = null) {
     return readSeqKey(readKey(v, this.field, null), this.key, dval);
   }
-  setValue(root, v) {
-    return produce(root, (draft) => this.setDraftValue(draft, v));
-  }
   setDraftValue(root, v) {
     const seq = readKey(root, this.field, null);
     if (seq != null) writeSeqKey(seq, this.key, v);
@@ -903,9 +891,6 @@ var SeqAccessStep = class extends Step {
     const key = readKey(v, this.keyField, NONE);
     return key !== NONE && seq !== NONE ? readSeqKey(seq, key, dval) : dval;
   }
-  setValue(root, v) {
-    return produce(root, (draft) => this.setDraftValue(draft, v));
-  }
   setDraftValue(root, v) {
     const seq = readKey(root, this.seqField, NONE);
     const key = readKey(root, this.keyField, NONE);
@@ -933,9 +918,6 @@ var EachBindStep = class extends Step {
   lookup(v, _dval) {
     return v;
   }
-  setValue(_root, 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, _prev, next) {
@@ -971,10 +953,6 @@ var DynStep = class extends Step {
     warnRawDynStep("lookup", this);
     return dval;
   }
-  setValue(root, _v) {
-    warnRawDynStep("setValue", this);
-    return root;
-  }
   enterFrame(stack, _prev, _next) {
     warnRawDynStep("enterFrame", this);
     return stack;
@@ -1045,7 +1023,7 @@ var Path = class _Path {
   }
   // Resolve every field-keyed step (e.g. `SeqAccessStep`) against `root`, freezing the
   // 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 a request was in
+  // 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) {
@@ -1287,7 +1265,6 @@ var K_FIELD = 4;
 var K_BIND = 8;
 var K_DYN = 16;
 var K_NAME = 32;
-var K_TYPE = 64;
 var K_SEQ = 256;
 var K_METHOD = 1024;
 var K_EVENT = 2048;
@@ -1297,7 +1274,7 @@ var G_COMPONENT = K_FIELD | K_SEQ | K_DYN;
 var G_SEQUENCE = K_FIELD | K_DYN;
 var G_PROVIDE = K_FIELD | K_SEQ;
 var G_FIELD = K_FIELD | K_METHOD | K_CONST | K_SEQ;
-var G_VALUE = K_FIELD | K_METHOD | K_BIND | K_DYN | K_NAME | K_TYPE | K_CONST;
+var G_VALUE = K_FIELD | K_METHOD | K_BIND | K_DYN | K_NAME | K_CONST;
 var G_HANDLER_ARG = G_VALUE & ~K_NAME | K_EVENT;
 var G_ALL = G_VALUE | K_STRTPL | K_SEQ;
 function sizeOf(v) {
@@ -1367,7 +1344,6 @@ function parseToken(s, px) {
     if (m !== null) return new EventMemberVal(s.split(".").slice(1));
   }
   if (c0 >= 97 && c0 <= 122) return mkVal(s, NameVal);
-  if (c0 >= 65 && c0 <= 90) return mkVal(s, TypeVal);
   return null;
 }
 function _parseSeqAccess(s, px) {
@@ -1482,7 +1458,6 @@ function kindOf(val) {
   if (val instanceof MethodVal) return K_METHOD;
   if (val instanceof BindVal) return K_BIND;
   if (val instanceof DynVal) return K_DYN;
-  if (val instanceof TypeVal) return K_TYPE;
   if (val instanceof NameVal) return K_NAME;
   if (val instanceof EventMemberVal) return K_EVENT;
   return 0;
@@ -1596,9 +1571,6 @@ var NameVal = class extends VarVal {
     super();
     this.name = name;
   }
-  eval(stack) {
-    return stack.lookupName(this.name);
-  }
   toString() {
     return this.name;
   }
@@ -1619,11 +1591,6 @@ var mk404Handler = (stack, type, name) => function(...args) {
   else console.warn("handler not found", { type, name });
   return this;
 };
-var TypeVal = class extends NameVal {
-  eval(stack) {
-    return stack.lookupType(this.name);
-  }
-};
 var keyIs = (k) => (e) => e.key === k;
 var macCtrl = (e) => isMac && e.metaKey || e.ctrlKey;
 var nullSafe = (fn) => (e, stack) => {
@@ -1756,9 +1723,6 @@ var Attributes = class {
   constructor(items) {
     this.items = items;
   }
-  eval(_stack) {
-    return {};
-  }
   static parse(attributes, px, parseAll = false) {
     return getAttrParser(px).parse(attributes, parseAll);
   }
@@ -1768,11 +1732,26 @@ var Attributes = class {
 };
 var booleanAttrsRaw = "itemscope,allowfullscreen,formnovalidate,ismap,nomodule,novalidate,readonly,async,autofocus,autoplay,controls,default,defer,disabled,hidden,inert,loop,open,required,reversed,scoped,seamless,checked,muted,multiple,selected";
 var booleanAttrs = new Set(booleanAttrsRaw.split(","));
+function parseDirectiveValue(px, directiveName, source, parser) {
+  const val = parser(source, px);
+  if (val === null) {
+    px.onParseIssue("bad-value", {
+      role: "directive",
+      directive: directiveName,
+      value: source
+    });
+  }
+  return val;
+}
+function parseIterationDirectives(attributes, px) {
+  const parseNamed = (name) => {
+    const attr = attributes.getNamedItem(`@${name}`);
+    return attr ? parseDirectiveValue(px, name, attr.value, parseAlterHandler) : null;
+  };
+  return { whenVal: parseNamed("when"), loopWithVal: parseNamed("loop-with") };
+}
 var AttrParser = class {
   constructor(px) {
-    this.clear(px);
-  }
-  clear(px) {
     this.px = px;
     this.attrs = null;
     this.hasDynamic = false;
@@ -1827,12 +1806,7 @@ var AttrParser = class {
     }
   }
   _parseDirectiveValue(directiveName, s, parserFn) {
-    const val = parserFn(s, this.px);
-    if (val === null) {
-      const info = { role: "directive", directive: directiveName, value: s };
-      this.px.onParseIssue("bad-value", info);
-    }
-    return val;
+    return parseDirectiveValue(this.px, directiveName, s, parserFn);
   }
   parseDirective(s, directiveName) {
     switch (directiveName) {
@@ -1996,11 +1970,8 @@ var IfAttr = class extends BaseAttr {
     return this.condVal.eval(stack) ? this.thenVal.eval(stack) : this.elseVal.eval(stack);
   }
 };
-var _attrParser = null;
 function getAttrParser(px) {
-  _attrParser ??= new AttrParser(px);
-  _attrParser.clear(px);
-  return _attrParser;
+  return new AttrParser(px);
 }
 var EventHandler = class _EventHandler {
   constructor(handlerVal, args = []) {
@@ -2024,70 +1995,77 @@ var IntentHandler = class {
   }
 };
 
-// src/cache.js
-var isWeakKey = (k) => k !== null && (typeof k === "object" || typeof k === "function");
-var NullDomCache = class {
-  get(_keys, _cacheKey) {
-  }
-  set(_keys, _cacheKey, _v) {
-  }
-  evict() {
-    return { hit: 0, miss: 0, badKey: 0 };
-  }
+// src/iteration.js
+var SEQ_INFO = /* @__PURE__ */ Symbol.for("tutuca.seqInfo");
+var normalizeRange = (start, end, size) => {
+  let s = start == null ? 0 : start < 0 ? size + start : start;
+  let e = end == null ? size : end < 0 ? size + end : end;
+  s = s < 0 ? 0 : s > size ? size : s;
+  e = e < 0 ? 0 : e > size ? size : e;
+  return [s, e < s ? s : e];
 };
-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);
-    for (let i = 0; i < len - 1; i++) {
-      cur = cur.get(keys[i]);
-      if (!cur) return this._returnValue(void 0);
-    }
-    return this._returnValue(cur.get(keys[len - 1])?.[cacheKey]);
-  }
-  set(keys, cacheKey, v) {
-    const len = keys.length;
-    let cur = this.keysByLen.get(len);
-    if (!cur) {
-      cur = /* @__PURE__ */ new WeakMap();
-      this.keysByLen.set(len, cur);
-    }
-    for (let i = 0; i < len - 1; i++) {
-      const key = keys[i];
-      let next = cur.get(key);
-      if (!next) {
-        if (!isWeakKey(key)) {
-          this.badKey += 1;
-          return;
-        }
-        next = /* @__PURE__ */ new WeakMap();
-        cur.set(key, next);
-      }
-      cur = next;
-    }
-    const lastKey = keys[len - 1];
-    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 };
+var nativeIndexedIter = (seq, visit, start, end) => {
+  const [s, e] = normalizeRange(start, end, seqSize(seq));
+  for (let i = s; i < e; i++) visit(i, seq[i], "si");
+};
+var nativeKeyedIter = (seq, visit, start, end) => {
+  const [s, e] = normalizeRange(start, end, seqSize(seq));
+  let i = 0;
+  for (const [key, value] of seqEntries(seq)) {
+    if (i >= e) break;
+    if (i >= s) visit(key, value, "sk");
+    i++;
   }
 };
+var unknownIter = () => {
+};
+var getSeqInfo = (seq) => isIndexedSeq(seq) ? nativeIndexedIter : isKeyedSeq(seq) || isSetSeq(seq) ? nativeKeyedIter : seq?.[SEQ_INFO] ?? unknownIter;
+var filterAlwaysTrue = (_key, _value, _iterData) => true;
+var nullLoopWith = (seq) => ({ iterData: { seq } });
+var unpackLoopResult = (result, seq) => {
+  const value = result ?? {};
+  return {
+    iterData: value.iterData ?? { seq },
+    start: value.start,
+    end: value.end,
+    keys: value.keys
+  };
+};
+var makeLoopCtx = (stack, filter) => ({
+  lookup: (name) => stack.lookupBind(name),
+  filter: (key, value, iterData) => filter.call(stack.it, key, value, iterData)
+});
+var callEnricher = (enricher, it, binds, key, value, iterData) => {
+  enricher.call(it, binds, key, value, iterData);
+  console.assert(
+    binds.key === key && binds.value === value,
+    "@enrich-with handlers must not overwrite binds.key or binds.value"
+  );
+  binds.key = key;
+  binds.value = value;
+};
+var visitKeys = (seq, keys, visit) => {
+  const attrName = isIndexedSeq(seq) ? "si" : "sk";
+  for (const key of keys) visit(key, seqGet(seq, key), attrName);
+};
+function walkLoopBindings({ seq, it, filter, loopWith, enricher, ctx }, visit) {
+  const { iterData, start, end, keys } = unpackLoopResult(loopWith.call(it, seq, ctx), seq);
+  const visitOne = (key, value, attrName) => {
+    const binds = { key, value };
+    if (enricher) callEnricher(enricher, it, binds, key, value, iterData);
+    visit(key, value, attrName, binds);
+  };
+  if (keys) visitKeys(seq, keys, visitOne);
+  else
+    getSeqInfo(seq)(
+      seq,
+      (key, value, attrName) => {
+        if (filter.call(it, key, value, iterData)) visitOne(key, value, attrName);
+      },
+      start,
+      end
+    );
+}
 
 // src/vdom.js
 var HTML_NS = "http://www.w3.org/1999/xhtml";
@@ -2432,189 +2410,11 @@ function h(tagName, properties, children, namespace) {
   return new VNode(tag, props, normalizedChildren, key, namespace);
 }
 
-// src/renderer.js
-var DATASET_ATTRS = ["nid", "cid", "eid", "vid", "si", "sk"];
-var Renderer = class {
-  constructor(comps) {
-    this.comps = comps;
-    this.cache = new WeakMapDomCache();
-    this.renderTag = h;
-  }
-  renderFragment(childs) {
-    return new VFragment(childs);
-  }
-  renderComment(text) {
-    return new VComment(text);
-  }
-  setNullCache() {
-    this.cache = new NullDomCache();
-  }
-  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) {
-    const comp = this.comps.getCompFor(stack.it);
-    return comp ? this._rValComp(stack, stack.it, comp, node, key, viewName) : 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}`;
-    const cachePath = [node, val];
-    stack._pushDynBindValuesToArray(cachePath, comp);
-    const cachedNode = this.cache.get(cachePath, cacheKey);
-    if (cachedNode) return cachedNode;
-    const view = viewName ? comp.getView(viewName) : stack.lookupBestView(comp.views, "main");
-    const body = this.renderView(view, stack);
-    if (body == null) return null;
-    const meta = this._renderMetadata({
-      $: "Comp",
-      nid: node?.nodeId ?? null,
-      cid: comp.id,
-      vid: view.name
-    });
-    const dom = new VFragment([meta, body]);
-    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);
-    const r = [];
-    const it = stack.it;
-    const { iterData, start, end, keys } = unpackLoopResult(
-      loopWith.call(it, seq, makeLoopCtx(stack, filter)),
-      seq
-    );
-    const renderOne = (key, value, attrName) => {
-      const cachePath = enricher ? [view, it, value] : [view, value];
-      const binds = { key, value };
-      const cacheKey = `${stack.viewsId ?? ""}${nid}${key}`;
-      if (enricher) callEnricher(enricher, it, binds, key, value, iterData);
-      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));
-        if (dom != null) this.pushEachEntry(r, nid, attrName, key, dom);
-        this.cache.set(cachePath, cacheKey, dom);
-      }
-    };
-    if (keys) keysIter(seq, renderOne, keys);
-    else
-      getSeqInfo(seq)(
-        seq,
-        (key, value, attrName) => {
-          if (filter.call(it, key, value, iterData)) renderOne(key, value, attrName);
-        },
-        start,
-        end
-      );
-    return r;
-  }
-  renderView(view, stack) {
-    let n = stack.binds[1];
-    while (n !== null) {
-      const b = n[0];
-      if (b.isFrame) {
-        if (stack.it !== b.it) break;
-        console.error("recursion detected", stack.it, b.it);
-        return new VComment("RECURSION AVOIDED");
-      }
-      n = n[1];
-    }
-    return view.render(stack, this);
-  }
-  _renderMetadata(info) {
-    return new VComment(`§${JSON.stringify(info)}§`);
-  }
-  // Prefix a loop-less @enrich-with subtree with a boundary meta so event-path
-  // reconstruction replays its binds (mirrors the §Each§ / §Comp§ metas).
-  renderScopeMeta(nid, dom) {
-    return new VFragment([this._renderMetadata({ $: "Scope", nid }), dom]);
-  }
-};
-var getSeqInfo = (seq) => isIndexedSeq(seq) ? nativeIndexedIter : isKeyedSeq(seq) || isSetSeq(seq) ? nativeKeyedIter : seq?.[SEQ_INFO] ?? unkIter;
-var normalizeRange = (start, end, size) => {
-  let s = start == null ? 0 : start < 0 ? size + start : start;
-  let e = end == null ? size : end < 0 ? size + end : end;
-  s = s < 0 ? 0 : s > size ? size : s;
-  e = e < 0 ? 0 : e > size ? size : e;
-  return [s, e < s ? s : e];
-};
-var callEnricher = (enricher, it, binds, key, value, iterData) => {
-  enricher.call(it, binds, key, value, iterData);
-  console.assert(
-    binds.key === key && binds.value === value,
-    "@enrich-with handlers must not overwrite binds.key or binds.value"
-  );
-  binds.key = key;
-  binds.value = value;
-};
-var filterAlwaysTrue = (_v, _k, _seq) => true;
-var nullLoopWith = (seq) => ({ iterData: { seq } });
-var unpackLoopResult = (result, seq) => {
-  const r = result ?? {};
-  return { iterData: r.iterData ?? { seq }, start: r.start, end: r.end, keys: r.keys };
-};
-var keysIter = (seq, visit, keys) => {
-  const attrName = isIndexedSeq(seq) ? "si" : "sk";
-  for (const key of keys) visit(key, seqGet(seq, key), attrName);
-};
-var makeLoopCtx = (stack, filter) => ({
-  lookup: (name) => stack.lookupBind(name),
-  filter: (key, value, iterData) => filter.call(stack.it, key, value, iterData)
-});
-var nativeIndexedIter = (seq, visit, start, end) => {
-  const [s, e] = normalizeRange(start, end, seqSize(seq));
-  for (let i = s; i < e; i++) visit(i, seq[i], "si");
-};
-var nativeKeyedIter = (seq, visit, start, end) => {
-  const [s, e] = normalizeRange(start, end, seqSize(seq));
-  let i = 0;
-  for (const [k, v] of seqEntries(seq)) {
-    if (i >= e) break;
-    if (i >= s) visit(k, v, "sk");
-    i++;
-  }
-};
-var unkIter = () => {
-};
-var SEQ_INFO = /* @__PURE__ */ Symbol.for("tutuca.seqInfo");
-
 // src/anode.js
 function resolveDynProducer(comp, name) {
-  let producerComp, producerProvide;
-  const lk = comp?.lookup?.[name];
-  if (lk != null) {
-    producerComp = comp.scope?.lookupComponent(lk.compName);
-    producerProvide = producerComp?.provide?.[lk.provideName];
-  } else {
-    const p = comp?.provide?.[name];
-    if (p == null) return null;
-    producerComp = comp;
-    producerProvide = p;
-  }
+  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] : [] };
@@ -2975,16 +2775,10 @@ function parseRenderEach(px, value, as, attrs) {
   const seqVal = parseXOpVal("render-each", value, px, parseSequence);
   if (seqVal === null) return null;
   const renderIt = px.addNode(RenderItNode, as);
-  const attrParser = getAttrParser(px);
-  const eachAttr = attrParser.pushWrapper("each", value, seqVal);
-  attrParser.eachAttr = eachAttr;
-  const when = attrs.getNamedItem("@when");
-  if (when) attrParser._parseWhen(when.value);
-  const lWith = attrs.getNamedItem("@loop-with");
-  if (lWith) attrParser._parseLoopWith(lWith.value);
+  const { whenVal, loopWithVal } = parseIterationDirectives(attrs, px);
   const each2 = px.addNodeIf(EachNode, seqVal);
-  each2.iterInfo.whenVal = eachAttr.whenVal ?? null;
-  each2.iterInfo.loopWithVal = eachAttr.loopWithVal ?? null;
+  each2.iterInfo.whenVal = whenVal;
+  each2.iterInfo.loopWithVal = loopWithVal;
   each2.fromRenderEach = true;
   each2.wrapNode(renderIt);
   return each2;
@@ -3373,7 +3167,7 @@ var Components = class {
   }
   compileStyles() {
     const styles = [];
-    for (const comp of this.byId.values()) styles.push(comp.compileStyle());
+    for (const Comp of this.byId.values()) styles.push(Comp[COMPONENT].compileStyle());
     return styles.join("\n");
   }
 };
@@ -3432,32 +3226,39 @@ 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) {
+    for (const compName in this.byName) {
+      const Comp = this.byName[compName];
+      if (Comp.provide?.[name] !== void 0) return Comp;
+    }
+    return this.parent?.lookupProvider(name) ?? null;
+  }
   lookupMacro(name) {
     return this.macros[name] ?? this.parent?.lookupMacro(name) ?? null;
   }
 };
 var ProvideInfo = class {
-  constructor(name, val, symbol) {
+  constructor(name, val) {
     this.name = name;
     this.val = val;
-    this.symbol = symbol;
   }
 };
 var LookupInfo = class {
-  constructor(name, compName, provideName, val) {
+  constructor(name, val) {
     this.name = name;
-    this.compName = compName;
-    this.provideName = provideName;
     this.val = val;
-    this._sym = void 0;
-  }
-  getProducerSymbol(stack) {
-    if (this._sym === void 0)
-      this._sym = stack.lookupType(this.compName)?.provide?.[this.provideName]?.symbol ?? null;
-    return this._sym;
   }
 };
 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;
@@ -3478,8 +3279,9 @@ var Component = class {
       this.views[name] = new View(name, view, style);
     }
     this._rawProvide = o.provide ?? {};
-    this._rawLookup = o.lookup ?? {};
+    this._rawLookup = o.lookup ?? [];
     this.provide = {};
+    this.provideType = {};
     this.lookup = {};
     this.scope = null;
     this.spec = o;
@@ -3491,25 +3293,23 @@ var Component = class {
       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;
+        continue;
+      }
       const val = parseProvide(this._rawProvide[key], ctx);
-      if (val) this.provide[key] = new ProvideInfo(key, val, Symbol(key));
+      if (val) this.provide[key] = new ProvideInfo(key, val);
     }
-    for (const key in this._rawLookup) {
-      const linfo = this._rawLookup[key];
-      const forStr = isString(linfo) ? linfo : isString(linfo?.for) ? linfo.for : null;
-      const [compName, provideName] = forStr === null ? [] : forStr.split(".");
-      if (!isString(compName) || !isString(provideName)) continue;
-      const defStr = isString(linfo?.default) ? linfo.default : null;
-      const val = defStr === null ? null : parseField(defStr, ctx);
-      this.lookup[key] = new LookupInfo(key, compName, provideName, 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(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);
   }
-  make(args, opts) {
-    return this.Class.make(args, opts ?? { scope: this.scope });
-  }
   getView(name) {
     return this.views[name] ?? this.views.main;
   }
@@ -3534,6 +3334,22 @@ var Component = class {
 // src/stack.js
 var STOP = /* @__PURE__ */ Symbol("STOP");
 var NEXT = /* @__PURE__ */ Symbol("NEXT");
+var DEFAULT_LOOKUP_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"');
+    }
+  }
+  return null;
+}
 function lookup(chain, name, dv = null) {
   let n = chain;
   while (n !== null) {
@@ -3584,14 +3400,21 @@ var Stack = class _Stack {
     this.ctx = ctx;
   }
   // Evaluate every provide the entered component publishes and push them as one
-  // dynBinds frame (keyed by each provide's symbol). No-op when there are no provides.
+  // 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 provide = this.comps.getCompFor(this.it)?.provide;
-    if (provide == null) return this;
+    const comp = this.comps.getCompFor(this.it);
+    if (comp == null) return this;
+    const { provide, provideType } = comp;
     const dynObj = {};
     let has2 = false;
     for (const k in provide) {
-      dynObj[provide[k].symbol] = provide[k].val.eval(this);
+      dynObj[k] = provide[k].val.eval(this);
+      has2 = true;
+    }
+    for (const k in provideType) {
+      dynObj[k] = provideType[k];
       has2 = true;
     }
     if (!has2) return this;
@@ -3616,30 +3439,36 @@ var Stack = class _Stack {
     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._lookupProvide(comp.provide[k]));
-    for (const k in comp.lookup) arr.push(this._lookupAlias(comp.lookup[k]));
-  }
-  _lookupProvide(p) {
-    return lookup(this.dynBinds, p.symbol) ?? p.val.eval(this) ?? null;
-  }
-  _lookupAlias(lk) {
-    const sym = lk.getProducerSymbol(this);
-    return (sym != null ? lookup(this.dynBinds, sym) : null) ?? lk.val?.eval(this) ?? null;
+    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);
-    if (comp == null) return null;
-    const lk = comp.lookup[name];
-    if (lk !== void 0) return this._lookupAlias(lk);
-    const p = comp.provide[name];
-    return p !== void 0 ? this._lookupProvide(p) : null;
+    return comp?.lookup[name]?.val?.eval(this) ?? null;
   }
   lookupBind(name) {
     return lookup(this.binds, name);
   }
-  lookupType(name) {
-    return this.comps.getCompFor(this.it).scope.lookupComponent(name);
+  // The `lex` leg: what a name means in the registration scope of the component being
+  // rendered. The scope chain holds components, so this leg only ever answers for a
+  // type name — for a value name it is a miss, which is why one default route serves
+  // both. Guarded: a non-component `it` has no scope to ask.
+  _lookupLex(name) {
+    return this.comps.getCompFor(this.it)?.scope.lookupComponent(name) ?? null;
+  }
+  lookupRouted(name, route = DEFAULT_LOOKUP_ROUTE) {
+    return routeLookup(
+      route,
+      () => this._lookupLex(name),
+      () => this.lookupDynamic(name)
+    );
   }
   lookupFieldRaw(name) {
     return this.it[name] ?? null;
@@ -3648,12 +3477,6 @@ var Stack = class _Stack {
     const fn = this.it[name];
     return fn instanceof Function ? fn.call(this.it) : null;
   }
-  // Bare implicit event names are gone: a sigil-less word cannot reach a
-  // handler-arg slot anymore, so this only ever serves stale NameVals parsed
-  // before the removal (e.g. macro-attr pass-throughs). Always null.
-  lookupName(_name) {
-    return null;
-  }
   // The dispatched DOM event / drag info, read only by EventMemberVal's
   // `e.<member>` handler args. Null outside a live event transaction.
   lookupEvent() {
@@ -3679,11 +3502,6 @@ var Stack = class _Stack {
 // src/oo.js
 var BAD_VALUE = /* @__PURE__ */ Symbol("BadValue");
 var nullCoercer = (v) => v;
-var isPlainObject3 = (v) => {
-  if (v === null || typeof v !== "object") return false;
-  const proto = Object.getPrototypeOf(v);
-  return proto === Object.prototype || proto === null;
-};
 function defaultToData(v) {
   if (v instanceof Map) return [...v.entries()];
   if (v instanceof Set) return [...v.values()];
@@ -3752,7 +3570,7 @@ var CHECK_TYPE_FLOAT = check(Number.isFinite, "Float expected");
 var CHECK_TYPE_BOOL = check((v) => typeof v === "boolean", "Boolean expected");
 var CHECK_TYPE_STRING = check((v) => typeof v === "string", "String expected");
 var CHECK_TYPE_LIST = check(Array.isArray, "Array expected");
-var CHECK_TYPE_OBJECT = check(isPlainObject3, "Plain object expected");
+var CHECK_TYPE_OBJECT = check(isPlainObject, "Plain object expected");
 var CHECK_TYPE_MAP = check((v) => v instanceof Map, "Map expected");
 var CHECK_TYPE_SET = check((v) => v instanceof Set, "Set expected");
 var FieldBool = class extends Field {
@@ -3821,7 +3639,7 @@ var FieldObject = class extends Field {
       "object",
       name,
       CHECK_TYPE_OBJECT,
-      (v) => isPlainObject3(v) ? { ...v } : null,
+      (v) => isPlainObject(v) ? { ...v } : null,
       defaultValue
     );
   }
@@ -3834,7 +3652,7 @@ var FieldMap = class extends Field {
       CHECK_TYPE_MAP,
       (v) => {
         if (v instanceof Map) return new Map(v);
-        if (Array.isArray(v) || isPlainObject3(v))
+        if (Array.isArray(v) || isPlainObject(v))
           return new Map(Array.isArray(v) ? v : Object.entries(v));
         return null;
       },
@@ -3959,7 +3777,7 @@ function classFromData(name, { fields = {}, methods, statics }) {
       b.addField(field, dval, FieldCls);
     } else if (value?.component && value?.args !== void 0)
       b.addCompField(field, value.component, value.args);
-    else if (isPlainObject3(value)) b.addField(field, { ...value }, FieldObject);
+    else if (isPlainObject(value)) b.addField(field, { ...value }, FieldObject);
     else {
       const FieldCls = value?.[FIELD_CLASS] ?? FieldAny;
       b.addField(field, value, FieldCls);
@@ -3983,10 +3801,24 @@ function validateDraftFields(current2, draft) {
     }
   }
 }
-var META_KEYS = "name id fields methods views receive intent alter provide lookup spec extra commonStyle globalStyle scope _rawProvide _rawLookup".split(
+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)
+]);
+function assertNoReservedComponentStatics(statics = {}) {
+  for (const name in statics) {
+    if (RESERVED_COMPONENT_STATICS.has(name)) {
+      throw new TypeError(`component static "${name}" is reserved by the framework`);
+    }
+  }
+}
 Component.fromSpec = (opts) => {
+  assertNoReservedComponentStatics(opts.statics);
   const Class = classFromData(opts.name, opts);
   const comp = new Component(Class, opts);
   const metaClass = Class.getMetaClass();
@@ -4006,7 +3838,7 @@ Component.fromSpec = (opts) => {
         configurable: true
       });
   for (const key of Object.getOwnPropertyNames(Component.prototype))
-    if (key !== "constructor" && key !== "make" && !Object.hasOwn(Class, key))
+    if (key !== "constructor" && !Object.hasOwn(Class, key))
       Class[key] = (...args) => comp[key](...args);
   return Class;
 };
@@ -4026,9 +3858,6 @@ var State = class {
     this.val = val;
     for (const sub of this.changeSubs) sub({ val, old, info, timestamp: Date.now() });
   }
-  update(fn, info) {
-    return this.set(fn(this.val), info);
-  }
 };
 var Transactor = class {
   constructor(comps, rootValue) {
@@ -4089,7 +3918,7 @@ var Transactor = class {
   // Build and dispatch 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 /
-  // updateRootValue). No-op when nobody is observing.
+  // Transaction.run). No-op when nobody is observing.
   _emitTransaction(transaction, root) {
     if (this._observers.length === 0) return;
     if (transaction._resolvedHandler === void 0) return;
@@ -4121,8 +3950,13 @@ var Transactor = class {
     }
     return child;
   }
-  pushSend(path, name, args = [], opts = {}, parent = null) {
-    const t = new SendEvent(path, this, name, args, parent, opts);
+  // `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);
     this.pushTransaction(t);
     return this._link(t, parent);
   }
@@ -4135,9 +3969,9 @@ var Transactor = class {
     walk.advance();
     return walk;
   }
-  // Drain queued transactions and await in-flight requests until quiescent. Each
-  // awaited request enqueues a ResponseEvent, which may dispatch more work, so we
-  // loop. `maxTurns` backstops a pathological non-terminating cascade.
+  // Drain queued transactions and await async intent handlers until quiescent. A
+  // completed handler may enqueue an answer, which may dispatch more work, so we loop.
+  // `maxTurns` backstops a pathological non-terminating cascade.
   async settle(maxTurns = 1e4) {
     while ((this.hasPendingTransactions || this._inflight.size) && maxTurns-- > 0) {
       while (this.hasPendingTransactions) this.transactNext();
@@ -4194,9 +4028,6 @@ var Transaction = class {
   whenSubtreeSettled() {
     return this.completion.whenSubtreeSettled();
   }
-  run(rootValue, comps) {
-    return this.updateRootValue(rootValue, comps);
-  }
   afterTransaction() {
   }
   // Ending a walk and forwarding belong to the two dispatch buckets; the base warns
@@ -4208,12 +4039,6 @@ var Transaction = class {
   forward(_opts) {
     console.warn('ctx.forward() needs a "receive" or "intent" handler - ignored');
   }
-  buildRootStack(root, comps) {
-    return Stack.root(comps, root);
-  }
-  buildStack(root, comps) {
-    return this.path.toTransactionPath().buildStack(this.buildRootStack(root, comps));
-  }
   // The kind reported to observers (see Transactor.observe); null on the base.
   get observeKind() {
     return null;
@@ -4233,12 +4058,11 @@ var Transaction = class {
     return null;
   }
   // The path used to apply the mutation. Teleports dynamic-var renders so it lands on
-  // the data's real location (the dispatch `this.path` keeps intermediates). A subclass
-  // may override to supply a pre-resolved path (see ResponseEvent's pinned keys).
+  // the data's real location (the dispatch `this.path` keeps intermediates).
   getTransactionPath() {
     return this.path.toTransactionPath().compact();
   }
-  updateRootValue(curRoot, comps) {
+  run(curRoot, comps) {
     const txnPath = this.getTransactionPath();
     const curLeaf = txnPath.lookup(curRoot);
     const newLeaf = produce(curLeaf, (draft) => {
@@ -4295,8 +4119,8 @@ var InputEvent = class extends Transaction {
     }
     this.transactor.pushIntent(this.dispatchPath, name, args, rest, this);
   }
-  buildRootStack(root, comps) {
-    return Stack.root(comps, root, this);
+  buildStack(root, comps) {
+    return this.path.toTransactionPath().buildStack(Stack.root(comps, root, this));
   }
   getHandlerAndArgs(root, _instance, comps) {
     const stack = this.buildStack(root, comps);
@@ -4314,11 +4138,10 @@ var InputEvent = class extends Transaction {
   }
 };
 var NameArgsTransaction = class extends Transaction {
-  constructor(path, transactor, name, args, parentTransaction, opts = {}) {
+  constructor(path, transactor, name, args, parentTransaction) {
     super(path, transactor, parentTransaction);
     this.name = name;
     this.args = args;
-    this.opts = opts;
     this.targetPath = path;
   }
   handlerProp = null;
@@ -4377,7 +4200,7 @@ var SendEvent = class extends NameArgsTransaction {
 var IntentEvent = class extends NameArgsTransaction {
   handlerProp = "intent";
   constructor(path, transactor, walk) {
-    super(path, transactor, walk.name, walk.args, walk.parent, {});
+    super(path, transactor, walk.name, walk.args, walk.parent);
     this.walk = walk;
     this.targetPath = walk.origin;
   }
@@ -4477,7 +4300,7 @@ var IntentWalk = class {
   async _runLex(chain, i) {
     if (this.ended) return;
     if (i >= chain.length) return this.advance();
-    const ctx = new IntentContext(this.origin, this.transactor, this.parent);
+    const ctx = new Dispatcher(this.origin, this.transactor, this.parent);
     try {
       const res = await chain[i].fn.apply(null, [...this.args, ctx]);
       if (res === PASS) return this._runLex(chain, i + 1);
@@ -4530,7 +4353,7 @@ var IntentWalk = class {
     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(path, this.transactor, name, args, this.parent);
     t._isAnswer = true;
     this.transactor.pushTransaction(t);
     if (this.release) t.completion.whenSubtreeSettled().then(this.release);
@@ -4569,7 +4392,7 @@ var Completion = class {
     this.val = val;
     this._selfResolve?.(val);
   }
-  // Settle self even when no handler produced a value (skipSelf / undefined / throw paths).
+  // Settle self even when no handler produced a value (undefined-state / throw paths).
   ensureSelfSettled() {
     if (!this.selfSettled) this.markSelfSettled(this.val);
   }
@@ -4615,12 +4438,64 @@ var Dispatcher = class {
   get at() {
     return new PathChanges(this);
   }
+  // The render-time Stack, rebuilt on demand. A handler does not get one: the stack
+  // that evaluated its arguments is a local in getHandlerAndArgs and is gone by the
+  // time the body runs, and send/intent transactions never build one at all. Both
+  // halves it needs are pinned on this ctx, so the `dyn` leg reconstructs it — and
+  // only the `dyn` leg does, which is why this is lazy rather than eager.
+  //
+  // The path is compacted, so per-item binds (`@each`, `@enrich-with`) are not
+  // 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));
+    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.
+  lookup(name, opts) {
+    const route = opts?.route ?? DEFAULT_LOOKUP_ROUTE;
+    return routeLookup(
+      route,
+      () => this._lookupLex(name),
+      () => this._stack()?.lookupDynamic(name) ?? 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.
+  _lookupLex(name) {
+    let Comp = null;
+    this.walkPath((c) => {
+      Comp = c;
+      return false;
+    });
+    return Comp?.scope?.lookupComponent(name) ?? 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
+  // published, so it is the leg that has to be checked.
+  lookupType(name, opts) {
+    const v = this.lookup(name, opts);
+    if (v == null) {
+      this.transactor.refuse("TYPE_NOT_FOUND", {
+        name,
+        route: opts?.route ?? DEFAULT_LOOKUP_ROUTE
+      });
+      return null;
+    }
+    if (v?.[COMPONENT] == null) {
+      this.transactor.refuse("TYPE_NOT_COMPONENT", { name, got: typeof v });
+      return null;
+    }
+    return v;
+  }
   // A message is ADDRESSED: it names one component and stops there.
-  send(name, args, opts) {
-    return this.sendAtPath(this.path, name, args, opts);
+  send(name, args) {
+    return this.sendAtPath(this.path, name, args);
   }
-  sendAtPath(path, name, args, opts) {
-    return this.transactor.pushSend(path, name, args, opts, this.parent);
+  sendAtPath(path, name, args) {
+    return this.transactor.pushSend(path, 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
@@ -4631,9 +4506,6 @@ var Dispatcher = class {
   intentAtPath(path, name, args, opts) {
     return this.transactor.pushIntent(path, name, args, opts, this.parent);
   }
-  lookupTypeFor(name, inst) {
-    return this.transactor.comps.getCompFor(inst).scope.lookupComponent(name);
-  }
 };
 var EventContext = class extends Dispatcher {
   get name() {
@@ -4650,6 +4522,19 @@ var EventContext = class extends Dispatcher {
   fail(error) {
     return this.parent.walk === void 0 ? warnNotIntent("fail") : this.parent.walk.answer("Error", error);
   }
+  // Reply to the sender of the MESSAGE being handled. An intent answers under a name
+  // the runtime derives (`<name>Ok`), because the raiser asked a question and declared
+  // arms for it; a message did not, so the replier names the reply itself and the
+  // sender handles it like any other message. Refuses when nobody sent this — a view's
+  // own `@on.*`, or a host sendAtRoot.
+  sendReply(name, args) {
+    const origin = this.parent?.origin ?? null;
+    if (origin == null) {
+      this.transactor.refuse("NO_SENDER", { name });
+      return null;
+    }
+    return this.sendAtPath(origin, name, args);
+  }
   // End the walk answering nothing — "served, and no answer".
   stop() {
     return this.parent.stop();
@@ -4661,8 +4546,6 @@ var EventContext = class extends Dispatcher {
     return this.parent.forward(opts);
   }
 };
-var IntentContext = class extends Dispatcher {
-};
 function warnNotIntent(verb) {
   console.warn(`ctx.${verb}() is only meaningful in an "intent" handler - ignored`);
 }
@@ -4671,8 +4554,8 @@ var PathChanges = class extends PathBuilder {
     super();
     this.dispatcher = dispatcher;
   }
-  send(name, args, opts) {
-    return this.dispatcher.sendAtPath(this.buildPath(), name, args, opts);
+  send(name, args) {
+    return this.dispatcher.sendAtPath(this.buildPath(), name, args);
   }
   intent(name, args, opts) {
     return this.dispatcher.intentAtPath(this.buildPath(), name, args, opts);
@@ -4829,9 +4712,10 @@ var App = class {
   }
   compile() {
     for (const Comp of this.comps.byId.values()) {
-      Comp.compile(this.ParseContext);
-      for (const key in Comp.views)
-        for (const name of Comp.views[key].ctx.genEventNames()) this._eventNames.add(name);
+      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);
     }
     this._compiled = true;
   }
@@ -4857,8 +4741,8 @@ var App = class {
     for (const name of this._eventNames)
       this.rootNode.removeEventListener(name, this, listenerOpts(name));
   }
-  sendAtRoot(name, args, opts) {
-    this.transactor.pushSend(new Path([]), name, args, opts);
+  sendAtRoot(name, args) {
+    this.transactor.pushSend(new Path([]), name, args);
   }
   registerComponents(comps, opts) {
     const scope = this.compStack.enter();
@@ -5012,6 +4896,182 @@ function collectAppClassesInSet(app) {
   return classes;
 }
 
+// src/cache.js
+var isWeakKey = (k) => k !== null && (typeof k === "object" || typeof k === "function");
+var NullDomCache = class {
+  get(_keys, _cacheKey) {
+  }
+  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);
+    for (let i = 0; i < len - 1; i++) {
+      cur = cur.get(keys[i]);
+      if (!cur) return this._returnValue(void 0);
+    }
+    return this._returnValue(cur.get(keys[len - 1])?.[cacheKey]);
+  }
+  set(keys, cacheKey, v) {
+    const len = keys.length;
+    let cur = this.keysByLen.get(len);
+    if (!cur) {
+      cur = /* @__PURE__ */ new WeakMap();
+      this.keysByLen.set(len, cur);
+    }
+    for (let i = 0; i < len - 1; i++) {
+      const key = keys[i];
+      let next = cur.get(key);
+      if (!next) {
+        if (!isWeakKey(key)) {
+          this.badKey += 1;
+          return;
+        }
+        next = /* @__PURE__ */ new WeakMap();
+        cur.set(key, next);
+      }
+      cur = next;
+    }
+    const lastKey = keys[len - 1];
+    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"];
+var Renderer = class {
+  constructor(comps) {
+    this.comps = comps;
+    this.cache = new WeakMapDomCache();
+    this.renderTag = h;
+  }
+  renderFragment(childs) {
+    return new VFragment(childs);
+  }
+  renderComment(text) {
+    return new VComment(text);
+  }
+  setNullCache() {
+    this.cache = new NullDomCache();
+  }
+  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) {
+    const comp = this.comps.getCompFor(stack.it);
+    return comp ? this._rValComp(stack, stack.it, comp, node, key, viewName) : 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}`;
+    const cachePath = [node, val];
+    stack._pushDynBindValuesToArray(cachePath, comp);
+    const cachedNode = this.cache.get(cachePath, cacheKey);
+    if (cachedNode) return cachedNode;
+    const view = viewName ? comp.getView(viewName) : stack.lookupBestView(comp.views, "main");
+    const body = this.renderView(view, stack);
+    if (body == null) return null;
+    const meta = this._renderMetadata({
+      $: "Comp",
+      nid: node?.nodeId ?? null,
+      cid: comp.id,
+      vid: view.name
+    });
+    const dom = new VFragment([meta, body]);
+    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);
+    const r = [];
+    const it = stack.it;
+    const renderOne = (key, value, attrName, binds) => {
+      const cachePath = enricher ? [view, it, value] : [view, value];
+      const cacheKey = `${stack.viewsId ?? ""}${nid}${key}`;
+      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));
+        if (dom != null) this.pushEachEntry(r, nid, attrName, key, dom);
+        this.cache.set(cachePath, cacheKey, dom);
+      }
+    };
+    walkLoopBindings(
+      { seq, it, filter, loopWith, enricher, ctx: makeLoopCtx(stack, filter) },
+      renderOne
+    );
+    return r;
+  }
+  renderView(view, stack) {
+    let n = stack.binds[1];
+    while (n !== null) {
+      const b = n[0];
+      if (b.isFrame) {
+        if (stack.it !== b.it) break;
+        console.error("recursion detected", stack.it, b.it);
+        return new VComment("RECURSION AVOIDED");
+      }
+      n = n[1];
+    }
+    return view.render(stack, this);
+  }
+  _renderMetadata(info) {
+    return new VComment(`§${JSON.stringify(info)}§`);
+  }
+  // Prefix a loop-less @enrich-with subtree with a boundary meta so event-path
+  // reconstruction replays its binds (mirrors the §Each§ / §Comp§ metas).
+  renderScopeMeta(nid, dom) {
+    return new VFragment([this._renderMetadata({ $: "Scope", nid }), dom]);
+  }
+};
+
 // src/on.js
 var OP_KINDS = ["send", "intent"];
 function phaseOps(phase) {
@@ -5029,7 +5089,7 @@ function dispatchPhase(dispatcher, targetPath, phase, self) {
     const args = resolveArgs(op.args, self);
     switch (op.type) {
       case "send":
-        dispatcher.sendAtPath(targetPath, op.name, args, op.opts);
+        dispatcher.sendAtPath(targetPath, op.name, args);
         break;
       case "intent":
         dispatcher.intentAtPath(targetPath, op.name, args, op.opts);