tutuca 0.12.1 → 0.13.1

package/dist/tutuca-cli.js

@@ -1102,9 +1102,6 @@ var init_path = __esm({
       lookup(_v, dval = null) {
         return dval;
       }
-      setValue(root, _v) {
-        return root;
-      }
       setDraftValue(_root, _v) {
       }
       enterFrame(stack, _prev, next) {
@@ -1133,9 +1130,6 @@ var init_path = __esm({
       lookup(v, _dval) {
         return v;
       }
-      setValue(_root, v) {
-        return v;
-      }
       enterFrame(stack, _prev, next) {
         return stack.enter(next, { ...this.binds }, false);
       }
@@ -1173,9 +1167,6 @@ var init_path = __esm({
       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);
       }
@@ -1198,9 +1189,6 @@ var init_path = __esm({
       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);
@@ -1223,9 +1211,6 @@ var init_path = __esm({
         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);
@@ -1253,9 +1238,6 @@ var init_path = __esm({
       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) {
@@ -1288,10 +1270,6 @@ var init_path = __esm({
         warnRawDynStep("lookup", this);
         return dval;
       }
-      setValue(root, _v) {
-        warnRawDynStep("setValue", this);
-        return root;
-      }
       enterFrame(stack, _prev, _next) {
         warnRawDynStep("enterFrame", this);
         return stack;
@@ -1362,7 +1340,7 @@ var init_path = __esm({
       }
       // 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) {
@@ -1625,7 +1603,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) {
@@ -1740,12 +1717,11 @@ 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;
 }
-var VALID_VAL_ID_RE, isValidValId, VALID_FLOAT_RE, STR_TPL_SPLIT_RE, mkVal, VAL_TOKEN_RE, tokenizeValue, unescapeStr, K_CONST, K_STRTPL, K_FIELD, K_BIND, K_DYN, K_NAME, K_TYPE, K_SEQ, K_METHOD, K_EVENT, G_BOOL, G_TEXT, G_COMPONENT, G_SEQUENCE, G_PROVIDE, G_FIELD, G_VALUE, G_HANDLER_ARG, G_ALL, toNullIfNaN, predTruthy, PREDICATES, BaseVal, ConstVal, NULL_CONST_VAL, PredicateVal, VarVal, StrTplVal, NameVal, HandlerNameVal, mk404Handler, TypeVal, keyIs, macCtrl, nullSafe, EVENT_CONVENIENCES, EventMemberVal, RenderVal, RenderNameVal, BindVal, BindMemberVal, DynVal, FieldVal, MethodVal, SeqAccessVal;
+var VALID_VAL_ID_RE, isValidValId, VALID_FLOAT_RE, STR_TPL_SPLIT_RE, mkVal, VAL_TOKEN_RE, tokenizeValue, unescapeStr, K_CONST, K_STRTPL, K_FIELD, K_BIND, K_DYN, K_NAME, K_SEQ, K_METHOD, K_EVENT, G_BOOL, G_TEXT, G_COMPONENT, G_SEQUENCE, G_PROVIDE, G_FIELD, G_VALUE, G_HANDLER_ARG, G_ALL, toNullIfNaN, predTruthy, PREDICATES, BaseVal, ConstVal, NULL_CONST_VAL, PredicateVal, VarVal, StrTplVal, NameVal, HandlerNameVal, mk404Handler, keyIs, macCtrl, nullSafe, EVENT_CONVENIENCES, EventMemberVal, RenderVal, RenderNameVal, BindVal, BindMemberVal, DynVal, FieldVal, MethodVal, SeqAccessVal;
 var init_value = __esm({
   "src/value.js"() {
     init_collection();
@@ -1765,7 +1741,6 @@ var init_value = __esm({
     K_BIND = 8;
     K_DYN = 16;
     K_NAME = 32;
-    K_TYPE = 64;
     K_SEQ = 256;
     K_METHOD = 1024;
     K_EVENT = 2048;
@@ -1775,7 +1750,7 @@ var init_value = __esm({
     G_SEQUENCE = K_FIELD | K_DYN;
     G_PROVIDE = K_FIELD | K_SEQ;
     G_FIELD = K_FIELD | K_METHOD | K_CONST | K_SEQ;
-    G_VALUE = K_FIELD | K_METHOD | K_BIND | K_DYN | K_NAME | K_TYPE | K_CONST;
+    G_VALUE = K_FIELD | K_METHOD | K_BIND | K_DYN | K_NAME | K_CONST;
     G_HANDLER_ARG = G_VALUE & ~K_NAME | K_EVENT;
     G_ALL = G_VALUE | K_STRTPL | K_SEQ;
     toNullIfNaN = (v) => Number.isNaN(v) ? null : v;
@@ -1899,9 +1874,6 @@ var init_value = __esm({
         super();
         this.name = name;
       }
-      eval(stack) {
-        return stack.lookupName(this.name);
-      }
       toString() {
         return this.name;
       }
@@ -1922,11 +1894,6 @@ var init_value = __esm({
       else console.warn("handler not found", { type: type3, name });
       return this;
     };
-    TypeVal = class extends NameVal {
-      eval(stack) {
-        return stack.lookupType(this.name);
-      }
-    };
     keyIs = (k) => (e) => e.key === k;
     macCtrl = (e) => isMac && e.metaKey || e.ctrlKey;
     nullSafe = (fn) => (e, stack) => {
@@ -2057,12 +2024,28 @@ var init_value = __esm({
 });
 
 // src/attribute.js
+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") };
+}
 function getAttrParser(px) {
-  _attrParser ??= new AttrParser(px);
-  _attrParser.clear(px);
-  return _attrParser;
+  return new AttrParser(px);
 }
-var Attributes, booleanAttrsRaw, booleanAttrs, AttrParser, ConstAttrs, DynAttrs, BaseAttr, Attr, ConstAttr, RawHtmlAttr, NOT_SET_VAL, IfAttr, _attrParser, EventHandler, IntentHandler;
+var Attributes, booleanAttrsRaw, booleanAttrs, AttrParser, ConstAttrs, DynAttrs, BaseAttr, Attr, ConstAttr, RawHtmlAttr, NOT_SET_VAL, IfAttr, EventHandler, IntentHandler;
 var init_attribute = __esm({
   "src/attribute.js"() {
     init_value();
@@ -2070,9 +2053,6 @@ var init_attribute = __esm({
       constructor(items) {
         this.items = items;
       }
-      eval(_stack) {
-        return {};
-      }
       static parse(attributes, px, parseAll = false) {
         return getAttrParser(px).parse(attributes, parseAll);
       }
@@ -2084,9 +2064,6 @@ var init_attribute = __esm({
     booleanAttrs = new Set(booleanAttrsRaw.split(","));
     AttrParser = class {
       constructor(px) {
-        this.clear(px);
-      }
-      clear(px) {
         this.px = px;
         this.attrs = null;
         this.hasDynamic = false;
@@ -2141,12 +2118,7 @@ var init_attribute = __esm({
         }
       }
       _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) {
@@ -2310,7 +2282,6 @@ var init_attribute = __esm({
         return this.condVal.eval(stack) ? this.thenVal.eval(stack) : this.elseVal.eval(stack);
       }
     };
-    _attrParser = null;
     EventHandler = class _EventHandler {
       constructor(handlerVal, args = []) {
         this.handlerVal = handlerVal;
@@ -2335,73 +2306,81 @@ var init_attribute = __esm({
   }
 });
 
-// src/cache.js
-var isWeakKey, NullDomCache, WeakMapDomCache;
-var init_cache = __esm({
-  "src/cache.js"() {
-    isWeakKey = (k) => k !== null && (typeof k === "object" || typeof k === "function");
-    NullDomCache = class {
-      get(_keys, _cacheKey) {
-      }
-      set(_keys, _cacheKey, _v) {
-      }
-      evict() {
-        return { hit: 0, miss: 0, badKey: 0 };
-      }
+// src/iteration.js
+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
+    );
+}
+var SEQ_INFO, normalizeRange, nativeIndexedIter, nativeKeyedIter, unknownIter, getSeqInfo, filterAlwaysTrue, nullLoopWith, unpackLoopResult, makeLoopCtx, callEnricher, visitKeys;
+var init_iteration = __esm({
+  "src/iteration.js"() {
+    init_collection();
+    SEQ_INFO = /* @__PURE__ */ Symbol.for("tutuca.seqInfo");
+    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];
     };
-    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 };
+    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");
+    };
+    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++;
       }
     };
+    unknownIter = () => {
+    };
+    getSeqInfo = (seq) => isIndexedSeq(seq) ? nativeIndexedIter : isKeyedSeq(seq) || isSetSeq(seq) ? nativeKeyedIter : seq?.[SEQ_INFO] ?? unknownIter;
+    filterAlwaysTrue = (_key, _value, _iterData) => true;
+    nullLoopWith = (seq) => ({ iterData: { seq } });
+    unpackLoopResult = (result, seq) => {
+      const value = result ?? {};
+      return {
+        iterData: value.iterData ?? { seq },
+        start: value.start,
+        end: value.end,
+        keys: value.keys
+      };
+    };
+    makeLoopCtx = (stack, filter) => ({
+      lookup: (name) => stack.lookupBind(name),
+      filter: (key, value, iterData) => filter.call(stack.it, key, value, iterData)
+    });
+    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;
+    };
+    visitKeys = (seq, keys, visit) => {
+      const attrName = isIndexedSeq(seq) ? "si" : "sk";
+      for (const key of keys) visit(key, seqGet(seq, key), attrName);
+    };
   }
 });
 
@@ -2753,197 +2732,11 @@ var init_vdom = __esm({
   }
 });
 
-// src/renderer.js
-var DATASET_ATTRS, Renderer, getSeqInfo, normalizeRange, callEnricher, filterAlwaysTrue, nullLoopWith, unpackLoopResult, keysIter, makeLoopCtx, nativeIndexedIter, nativeKeyedIter, unkIter, SEQ_INFO;
-var init_renderer = __esm({
-  "src/renderer.js"() {
-    init_cache();
-    init_collection();
-    init_vdom();
-    DATASET_ATTRS = ["nid", "cid", "eid", "vid", "si", "sk"];
-    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]);
-      }
-    };
-    getSeqInfo = (seq) => isIndexedSeq(seq) ? nativeIndexedIter : isKeyedSeq(seq) || isSetSeq(seq) ? nativeKeyedIter : seq?.[SEQ_INFO] ?? unkIter;
-    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];
-    };
-    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;
-    };
-    filterAlwaysTrue = (_v, _k, _seq) => true;
-    nullLoopWith = (seq) => ({ iterData: { seq } });
-    unpackLoopResult = (result, seq) => {
-      const r = result ?? {};
-      return { iterData: r.iterData ?? { seq }, start: r.start, end: r.end, keys: r.keys };
-    };
-    keysIter = (seq, visit, keys) => {
-      const attrName = isIndexedSeq(seq) ? "si" : "sk";
-      for (const key of keys) visit(key, seqGet(seq, key), attrName);
-    };
-    makeLoopCtx = (stack, filter) => ({
-      lookup: (name) => stack.lookupBind(name),
-      filter: (key, value, iterData) => filter.call(stack.it, key, value, iterData)
-    });
-    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");
-    };
-    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++;
-      }
-    };
-    unkIter = () => {
-    };
-    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] : [] };
@@ -3063,16 +2856,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;
@@ -3124,8 +2911,8 @@ var init_anode = __esm({
   "src/anode.js"() {
     init_attribute();
     init_collection();
+    init_iteration();
     init_path();
-    init_renderer();
     init_env();
     init_value();
     init_vdom();
@@ -3679,7 +3466,7 @@ var init_anode = __esm({
 });
 
 // src/components.js
-var COMPONENT, Components, ComponentStack, ProvideInfo, LookupInfo, isString, _rawSpecKeys, KNOWN_SPEC_KEYS, _compId, Component;
+var COMPONENT, Components, ComponentStack, ProvideInfo, LookupInfo, isString, isTypeName, _rawSpecKeys, KNOWN_SPEC_KEYS, _compId, Component;
 var init_components = __esm({
   "src/components.js"() {
     init_anode();
@@ -3711,7 +3498,7 @@ var init_components = __esm({
       }
       compileStyles() {
         const styles2 = [];
-        for (const comp of this.byId.values()) styles2.push(comp.compileStyle());
+        for (const Comp of this.byId.values()) styles2.push(Comp[COMPONENT].compileStyle());
         return styles2.join("\n");
       }
     };
@@ -3770,32 +3557,39 @@ var init_components = __esm({
       lookupComponent(name) {
         return this.byName[name] ?? this.parent?.lookupComponent(name) ?? null;
       }
+      // The component in this scope chain that provides `name`, innermost first. A lookup
+      // names a value without naming its producer, so the render-target teleport
+      // (resolveDynProducer) recovers the producer here instead. Sound because
+      // PROVIDE_NAME_COLLISION keeps a provide name to one producer per chain; with two,
+      // this returns the innermost and the linter has already reported the ambiguity.
+      lookupProvider(name) {
+        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;
       }
     };
     ProvideInfo = class {
-      constructor(name, val, symbol) {
+      constructor(name, val) {
         this.name = name;
         this.val = val;
-        this.symbol = symbol;
       }
     };
     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;
       }
     };
     isString = (v) => typeof v === "string";
+    isTypeName = (s) => {
+      const c = s.charCodeAt(0);
+      return c >= 65 && c <= 90;
+    };
     _rawSpecKeys = "name view style commonStyle globalStyle receive intent alter views provide lookup fields methods statics";
     KNOWN_SPEC_KEYS = new Set(_rawSpecKeys.split(" "));
     _compId = 0;
@@ -3816,8 +3610,9 @@ var init_components = __esm({
           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;
@@ -3829,25 +3624,23 @@ var init_components = __esm({
           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;
       }
@@ -6206,7 +5999,11 @@ function checkComponent(Comp, lx = new LintContext(), { wellKnownExtras = EMPTY_
     checkFieldDeclarations(lx, Comp);
     checkFieldMethodNameCollisions(lx, Comp);
     checkProvidesAreAddressable(lx, Comp);
+    checkProvidedTypes(lx, Comp);
+    checkProvideNameCollisions(lx, Comp);
     checkLookupShapes(lx, Comp);
+    checkLookupTypesResolve(lx, Comp);
+    checkLookupsHaveProviders(lx, Comp);
     checkHandlersNotAsync(lx, Comp);
     checkHandlerNameCollisions(lx, Comp);
     checkScopedStyleTopLevel(lx, Comp);
@@ -6765,53 +6562,95 @@ function checkScopedStyleTopLevel(lx, Comp) {
 }
 function checkProvidesAreAddressable(lx, Comp) {
   for (const name in Comp._rawProvide) {
+    if (isTypeName2(name)) continue;
     if (Comp.provide[name] === void 0) {
       lx.error(PROVIDE_NOT_ADDRESSABLE, { name, value: Comp._rawProvide[name] });
     }
-  }
-}
-function checkLookupShapes(lx, Comp) {
-  for (const name in Comp._rawLookup) {
-    const raw = Comp._rawLookup[name];
-    let target;
-    if (typeof raw === "string") {
-      target = raw;
-    } else if (raw === null || typeof raw !== "object" || Array.isArray(raw)) {
+  }
+}
+function checkProvidedTypes(lx, Comp) {
+  for (const name in Comp._rawProvide) {
+    if (!isTypeName2(name)) continue;
+    const raw = Comp._rawProvide[name];
+    if (raw !== "self") lx.error(PROVIDE_TYPE_BAD_SHAPE, { name, value: raw });
+  }
+}
+function checkProvideNameCollisions(lx, Comp) {
+  const scope = Comp.scope;
+  if (!scope) return;
+  for (const name in Comp.provide) {
+    for (let s = scope; s; s = s.parent) {
+      for (const otherName in s.byName) {
+        const Other = s.byName[otherName];
+        if (Other !== Comp && Other.provide?.[name] !== void 0)
+          lx.error(PROVIDE_NAME_COLLISION, { name, other: Other.name });
+      }
+    }
+  }
+}
+function checkLookupShapes(lx, Comp) {
+  const raw = Comp._rawLookup;
+  if (!Array.isArray(raw)) {
+    if (raw !== void 0 && Object.keys(raw).length > 0)
+      lx.error(LOOKUP_BAD_SHAPE, { name: "lookup", problem: "must be a list of names" });
+    return;
+  }
+  for (const entry of raw) {
+    if (typeof entry === "string") continue;
+    if (entry === null || typeof entry !== "object" || Array.isArray(entry)) {
+      lx.error(LOOKUP_BAD_SHAPE, {
+        name: String(entry),
+        problem: 'must be a "name" string or a { name, default } object'
+      });
+      continue;
+    }
+    const extra = Object.keys(entry).filter((k) => !KNOWN_LOOKUP_KEYS.has(k));
+    if (extra.length > 0) {
       lx.error(LOOKUP_BAD_SHAPE, {
-        name,
-        problem: 'must be a "Producer.provideName" string or a { for, default } object'
+        name: String(entry.name),
+        problem: `unknown key(s): ${extra.join(", ")}`
       });
       continue;
-    } else {
-      const extra = Object.keys(raw).filter((k) => !KNOWN_LOOKUP_KEYS.has(k));
-      if (extra.length > 0) {
-        lx.error(LOOKUP_BAD_SHAPE, { name, problem: `unknown key(s): ${extra.join(", ")}` });
-        continue;
-      }
-      if (typeof raw.for !== "string") {
-        lx.error(LOOKUP_BAD_SHAPE, { name, problem: "'for' is required and must be a string" });
-        continue;
-      }
-      if (raw.default !== void 0 && typeof raw.default !== "string") {
-        lx.error(LOOKUP_BAD_SHAPE, { name, problem: "'default' must be a string" });
-        continue;
-      }
-      target = raw.for;
     }
-    const parts = target.split(".");
-    if (parts.length !== 2 || !parts[0] || !parts[1]) {
-      lx.error(LOOKUP_TARGET_MALFORMED, { name, target });
+    if (typeof entry.name !== "string" || entry.name === "") {
+      lx.error(LOOKUP_BAD_SHAPE, {
+        name: String(entry.name),
+        problem: "'name' is required and must be a string"
+      });
+      continue;
     }
+    if (entry.default !== void 0 && typeof entry.default !== "string")
+      lx.error(LOOKUP_BAD_SHAPE, { name: entry.name, problem: "'default' must be a string" });
+  }
+}
+function checkLookupsHaveProviders(lx, Comp) {
+  const scope = Comp.scope;
+  if (!scope) return;
+  for (const name in Comp.lookup) {
+    if (isTypeName2(name)) continue;
+    if (scope.lookupProvider?.(name)) continue;
+    const info = { name, hasDefault: Comp.lookup[name].val != null };
+    if (info.hasDefault) lx.hint(LOOKUP_NO_PROVIDER, info);
+    else lx.error(LOOKUP_NO_PROVIDER, info);
+  }
+}
+function checkLookupTypesResolve(lx, Comp) {
+  if (!Comp.scope) return;
+  for (const name in Comp.lookup) {
+    if (!isTypeName2(name)) continue;
+    if (Comp.scope.lookupComponent(name) === null)
+      reportUnknownName(lx, UNKNOWN_COMPONENT_NAME, name, scopeKeysAlong(Comp.scope, "byName"), {});
   }
 }
 function checkUnreferencedDynamics(lx, Comp, referencedDynamics) {
   for (const name in Comp.lookup) {
+    if (isTypeName2(name)) continue;
     if (!referencedDynamics.has(name)) {
       lx.hint(DYN_ALIAS_NOT_REFERENCED, { name });
     }
   }
 }
-var KNOWN_COMPONENT_SPEC_KEYS, EMPTY_SET, FRAMEWORK_WELL_KNOWN_EXTRAS, KNOWN_DIRECTIVE_NAMES, ALT_HANDLER_NOT_DEFINED, ALT_HANDLER_NOT_REFERENCED, DYN_VAL_NOT_DEFINED, DYN_ALIAS_NOT_REFERENCED, PROVIDE_NOT_ADDRESSABLE, LOOKUP_BAD_SHAPE, LOOKUP_TARGET_MALFORMED, RENDER_IT_OUTSIDE_OF_LOOP, UNKNOWN_EVENT_MODIFIER, RECEIVE_HANDLER_NOT_IMPLEMENTED, EVENT_HANDLER_METHOD_NOT_ALLOWED, HANDLER_NAME_COLLISION, FIELD_VAL_NOT_DEFINED, FIELD_VAL_IS_METHOD, METHOD_VAL_NOT_DEFINED, METHOD_VAL_IS_FIELD, DUPLICATE_ATTR_DEFINITION, IF_NO_BRANCH_SET, UNKNOWN_COMPONENT_NAME, UNKNOWN_MACRO_ARG, UNKNOWN_DIRECTIVE, UNKNOWN_X_OP, UNKNOWN_X_ATTR, X_OP_IGNORES_CHILDREN, MAYBE_DROP_AT_PREFIX, MAYBE_ADD_AT_PREFIX, BAD_VALUE, UNSUPPORTED_EXPR_SYNTAX, BINDING_MEMBER_TOO_DEEP, SUGGEST_BINDING_MEMBER, REDUNDANT_TEMPLATE_STRING, PLACEHOLDERLESS_TEMPLATE_STRING, CONSTANT_CONDITION, UNKNOWN_COMPONENT_SPEC_KEY, COMP_FIELD_BAD_SHAPE, ASYNC_HANDLER, TOP_LEVEL_AT_RULE_IN_SCOPED_STYLE, GLOBAL_SELECTOR_IN_SCOPED_STYLE, FIELD_METHOD_NAME_COLLISION, X_KNOWN_OP_NAMES, X_KNOWN_ATTR_NAMES, HOST_DIRECTIVE_ONLY_NAMES, LEVEL_WARN2, LEVEL_ERROR2, LEVEL_HINT, PARSE_ISSUES, BINDING_MEMBER_TOO_DEEP_RE, UNSUPPORTED_EXPR_GUIDANCE, HTML_LINT_OPTS, NO_WRAPPERS2, ANY_EVENT_MODIFIERS, fixTo, BOOL_CONDITION_ORIGINS, isBoolConditionCtx, ATTR_VAL_CHECKERS, NODE_KIND_TO_CTX, HANDLER_CHANNELS, ASYNC_HANDLER_HELP, NON_NESTABLE_AT_RULE, GLOBAL_LEADING_SELECTOR, IGNORE_DIRECTIVE, blankRun, STYLE_TO_GLOBAL_HELP, KNOWN_LOOKUP_KEYS, LintContext, LintParseContext;
+var KNOWN_COMPONENT_SPEC_KEYS, EMPTY_SET, FRAMEWORK_WELL_KNOWN_EXTRAS, KNOWN_DIRECTIVE_NAMES, isTypeName2, ALT_HANDLER_NOT_DEFINED, ALT_HANDLER_NOT_REFERENCED, DYN_VAL_NOT_DEFINED, DYN_ALIAS_NOT_REFERENCED, PROVIDE_NOT_ADDRESSABLE, PROVIDE_TYPE_BAD_SHAPE, PROVIDE_NAME_COLLISION, LOOKUP_BAD_SHAPE, LOOKUP_NO_PROVIDER, RENDER_IT_OUTSIDE_OF_LOOP, UNKNOWN_EVENT_MODIFIER, RECEIVE_HANDLER_NOT_IMPLEMENTED, EVENT_HANDLER_METHOD_NOT_ALLOWED, HANDLER_NAME_COLLISION, FIELD_VAL_NOT_DEFINED, FIELD_VAL_IS_METHOD, METHOD_VAL_NOT_DEFINED, METHOD_VAL_IS_FIELD, DUPLICATE_ATTR_DEFINITION, IF_NO_BRANCH_SET, UNKNOWN_COMPONENT_NAME, UNKNOWN_MACRO_ARG, UNKNOWN_DIRECTIVE, UNKNOWN_X_OP, UNKNOWN_X_ATTR, X_OP_IGNORES_CHILDREN, MAYBE_DROP_AT_PREFIX, MAYBE_ADD_AT_PREFIX, BAD_VALUE, UNSUPPORTED_EXPR_SYNTAX, BINDING_MEMBER_TOO_DEEP, SUGGEST_BINDING_MEMBER, REDUNDANT_TEMPLATE_STRING, PLACEHOLDERLESS_TEMPLATE_STRING, CONSTANT_CONDITION, UNKNOWN_COMPONENT_SPEC_KEY, COMP_FIELD_BAD_SHAPE, ASYNC_HANDLER, TOP_LEVEL_AT_RULE_IN_SCOPED_STYLE, GLOBAL_SELECTOR_IN_SCOPED_STYLE, FIELD_METHOD_NAME_COLLISION, X_KNOWN_OP_NAMES, X_KNOWN_ATTR_NAMES, HOST_DIRECTIVE_ONLY_NAMES, LEVEL_WARN2, LEVEL_ERROR2, LEVEL_HINT, PARSE_ISSUES, BINDING_MEMBER_TOO_DEEP_RE, UNSUPPORTED_EXPR_GUIDANCE, HTML_LINT_OPTS, NO_WRAPPERS2, ANY_EVENT_MODIFIERS, fixTo, BOOL_CONDITION_ORIGINS, isBoolConditionCtx, ATTR_VAL_CHECKERS, NODE_KIND_TO_CTX, HANDLER_CHANNELS, ASYNC_HANDLER_HELP, NON_NESTABLE_AT_RULE, GLOBAL_LEADING_SELECTOR, IGNORE_DIRECTIVE, blankRun, STYLE_TO_GLOBAL_HELP, KNOWN_LOOKUP_KEYS, LintContext, LintParseContext;
 var init_lint_check = __esm({
   "tools/core/lint-check.js"() {
     init_anode();
@@ -6839,13 +6678,19 @@ var init_lint_check = __esm({
       "then",
       "else"
     ]);
+    isTypeName2 = (s) => {
+      const c = s.charCodeAt(0);
+      return c >= 65 && c <= 90;
+    };
     ALT_HANDLER_NOT_DEFINED = "ALT_HANDLER_NOT_DEFINED";
     ALT_HANDLER_NOT_REFERENCED = "ALT_HANDLER_NOT_REFERENCED";
     DYN_VAL_NOT_DEFINED = "DYN_VAL_NOT_DEFINED";
     DYN_ALIAS_NOT_REFERENCED = "DYN_ALIAS_NOT_REFERENCED";
     PROVIDE_NOT_ADDRESSABLE = "PROVIDE_NOT_ADDRESSABLE";
+    PROVIDE_TYPE_BAD_SHAPE = "PROVIDE_TYPE_BAD_SHAPE";
+    PROVIDE_NAME_COLLISION = "PROVIDE_NAME_COLLISION";
     LOOKUP_BAD_SHAPE = "LOOKUP_BAD_SHAPE";
-    LOOKUP_TARGET_MALFORMED = "LOOKUP_TARGET_MALFORMED";
+    LOOKUP_NO_PROVIDER = "LOOKUP_NO_PROVIDER";
     RENDER_IT_OUTSIDE_OF_LOOP = "RENDER_IT_OUTSIDE_OF_LOOP";
     UNKNOWN_EVENT_MODIFIER = "UNKNOWN_EVENT_MODIFIER";
     RECEIVE_HANDLER_NOT_IMPLEMENTED = "RECEIVE_HANDLER_NOT_IMPLEMENTED";
@@ -6962,16 +6807,6 @@ var init_lint_check = __esm({
         recurse(val.seqVal);
         recurse(val.keyVal);
       },
-      TypeVal({ lx, val, env, errCtx }) {
-        if (env.scope.lookupComponent(val.name) === null)
-          reportUnknownName(
-            lx,
-            UNKNOWN_COMPONENT_NAME,
-            val.name,
-            scopeKeysAlong(env.scope, "byName"),
-            errCtx
-          );
-      },
       // NameVals on a macro call-site attribute are macro-param bindings, not
       // handler args — their role is determined inside the macro body after
       // ^-substitution, where re-parsing handles validation. No checker: a NameVal
@@ -7030,7 +6865,7 @@ var init_lint_check = __esm({
     IGNORE_DIRECTIVE = /\/\*\s*tutuca-lint-ignore\s*\*\//g;
     blankRun = (m) => m.replace(/[^\n]/g, " ");
     STYLE_TO_GLOBAL_HELP = "Move it to the component's 'globalStyle' key, which is injected without the component-scoping wrapper. To suppress a false positive, put a /* tutuca-lint-ignore */ comment on the same line.";
-    KNOWN_LOOKUP_KEYS = /* @__PURE__ */ new Set(["for", "default"]);
+    KNOWN_LOOKUP_KEYS = /* @__PURE__ */ new Set(["name", "default"]);
     LintContext = class {
       constructor() {
         this.reports = [];
@@ -7175,13 +7010,25 @@ var init_lint_rules = __esm({
         code: LOOKUP_BAD_SHAPE,
         level: "error",
         group: "Dynamic bindings",
-        summary: "`lookup` entry must be a string or `{ for, default }` (known keys, string values)."
+        summary: "`lookup` entry must be a name string or `{ name, default }`."
+      },
+      {
+        code: LOOKUP_NO_PROVIDER,
+        level: "error",
+        group: "Dynamic bindings",
+        summary: "`lookup` name is provided by no component in scope."
+      },
+      {
+        code: PROVIDE_TYPE_BAD_SHAPE,
+        level: "error",
+        group: "Dynamic bindings",
+        summary: 'A PascalCase `provide` publishes a component type; its value must be `"self"`.'
       },
       {
-        code: LOOKUP_TARGET_MALFORMED,
+        code: PROVIDE_NAME_COLLISION,
         level: "error",
         group: "Dynamic bindings",
-        summary: '`lookup` target must be `"Producer.provideName"` (string or `for`).'
+        summary: "Two components in one scope chain `provide` the same name."
       },
       // Templates / events
       {
@@ -7474,8 +7321,12 @@ function lintIdToMessage(id, info) {
       return `Provide '${info.name}' value '${info.value}' must be a field ('.f') or seq-access ('.s[.k]') — a method/constant can't be a render target`;
     case "LOOKUP_BAD_SHAPE":
       return `Lookup '${info.name}' has an invalid shape: ${info.problem}`;
-    case "LOOKUP_TARGET_MALFORMED":
-      return `Lookup '${info.name}' target '${info.target}' must be 'Producer.provideName' (a string, or the 'for' of { for, default })`;
+    case "LOOKUP_NO_PROVIDER":
+      return info.hasDefault ? `Lookup '${info.name}' is provided by no component in scope, so it always resolves to its default` : `Lookup '${info.name}' is provided by no component in scope — add a 'provide' for it, or give this lookup a default`;
+    case "PROVIDE_TYPE_BAD_SHAPE":
+      return `Provide '${info.name}' starts uppercase, so it publishes a component type — its value must be 'self', not '${info.value}'`;
+    case "PROVIDE_NAME_COLLISION":
+      return `Provide '${info.name}' is also provided by '${info.other}' in the same scope — one name, one provider, so a lookup can find it`;
     case "UNKNOWN_MACRO_ARG":
       return `Argument '${info.name}' is not declared in macro '${info.macroName}'`;
     case "UNKNOWN_DIRECTIVE":
@@ -12951,6 +12802,21 @@ var init_list = __esm({
 });
 
 // src/stack.js
+function routeLookup(route, lex, dyn) {
+  for (let i = 0; i < route.length; i++) {
+    const leg = route[i];
+    if (leg === "dyn") {
+      const v = dyn();
+      if (v != null) return v;
+    } else if (leg === "lex") {
+      const v = lex();
+      if (v != null) return v;
+    } else {
+      console.warn("unknown lookup route leg", leg, '- expected "dyn" or "lex"');
+    }
+  }
+  return null;
+}
 function lookup(chain, name, dv = null) {
   let n = chain;
   while (n !== null) {
@@ -12970,11 +12836,12 @@ function computeViewsId(views) {
   }
   return s === "main" ? "" : s;
 }
-var STOP, NEXT, BindFrame, ObjectFrame, Stack;
+var STOP, NEXT, DEFAULT_LOOKUP_ROUTE, BindFrame, ObjectFrame, Stack;
 var init_stack = __esm({
   "src/stack.js"() {
     STOP = /* @__PURE__ */ Symbol("STOP");
     NEXT = /* @__PURE__ */ Symbol("NEXT");
+    DEFAULT_LOOKUP_ROUTE = ["dyn", "lex"];
     BindFrame = class {
       constructor(it, binds, isFrame) {
         this.it = it;
@@ -13006,14 +12873,21 @@ var init_stack = __esm({
         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;
@@ -13038,30 +12912,36 @@ var init_stack = __esm({
         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;
@@ -13070,12 +12950,6 @@ var init_stack = __esm({
         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() {
@@ -13136,7 +13010,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 (isPlainObject4(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);
@@ -13160,18 +13034,21 @@ function validateDraftFields(current2, draft) {
     }
   }
 }
-var BAD_VALUE2, nullCoercer, isPlainObject4, Field, Check, CheckTypeAny, CHECK_TYPE_ANY, FnCheck, check, CHECK_TYPE_INT, CHECK_TYPE_FLOAT, CHECK_TYPE_BOOL, CHECK_TYPE_STRING, CHECK_TYPE_LIST, CHECK_TYPE_OBJECT, CHECK_TYPE_MAP, CHECK_TYPE_SET, FieldBool, FieldAny, FieldString, FieldInt, FieldFloat, getTypeName, CheckTypeName, FieldComp, FieldList, FieldObject, FieldMap, FieldSet, ClassBuilder, FIELD_CLASS, fieldsByTypeName, META_KEYS;
+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`);
+    }
+  }
+}
+var BAD_VALUE2, nullCoercer, Field, Check, CheckTypeAny, CHECK_TYPE_ANY, FnCheck, check, CHECK_TYPE_INT, CHECK_TYPE_FLOAT, CHECK_TYPE_BOOL, CHECK_TYPE_STRING, CHECK_TYPE_LIST, CHECK_TYPE_OBJECT, CHECK_TYPE_MAP, CHECK_TYPE_SET, FieldBool, FieldAny, FieldString, FieldInt, FieldFloat, getTypeName, CheckTypeName, FieldComp, FieldList, FieldObject, FieldMap, FieldSet, ClassBuilder, FIELD_CLASS, fieldsByTypeName, META_KEYS, RESERVED_COMPONENT_STATICS;
 var init_oo = __esm({
   "src/oo.js"() {
+    init_collection();
     init_components();
     init_immer2();
     BAD_VALUE2 = /* @__PURE__ */ Symbol("BadValue");
     nullCoercer = (v) => v;
-    isPlainObject4 = (v) => {
-      if (v === null || typeof v !== "object") return false;
-      const proto = Object.getPrototypeOf(v);
-      return proto === Object.prototype || proto === null;
-    };
     Field = class {
       constructor(type3, name, typeCheck, coercer, defaultValue = null) {
         this.type = type3;
@@ -13235,7 +13112,7 @@ var init_oo = __esm({
     CHECK_TYPE_BOOL = check((v) => typeof v === "boolean", "Boolean expected");
     CHECK_TYPE_STRING = check((v) => typeof v === "string", "String expected");
     CHECK_TYPE_LIST = check(Array.isArray, "Array expected");
-    CHECK_TYPE_OBJECT = check(isPlainObject4, "Plain object expected");
+    CHECK_TYPE_OBJECT = check(isPlainObject, "Plain object expected");
     CHECK_TYPE_MAP = check((v) => v instanceof Map, "Map expected");
     CHECK_TYPE_SET = check((v) => v instanceof Set, "Set expected");
     FieldBool = class extends Field {
@@ -13304,7 +13181,7 @@ var init_oo = __esm({
           "object",
           name,
           CHECK_TYPE_OBJECT,
-          (v) => isPlainObject4(v) ? { ...v } : null,
+          (v) => isPlainObject(v) ? { ...v } : null,
           defaultValue
         );
       }
@@ -13317,7 +13194,7 @@ var init_oo = __esm({
           CHECK_TYPE_MAP,
           (v) => {
             if (v instanceof Map) return new Map(v);
-            if (Array.isArray(v) || isPlainObject4(v))
+            if (Array.isArray(v) || isPlainObject(v))
               return new Map(Array.isArray(v) ? v : Object.entries(v));
             return null;
           },
@@ -13412,10 +13289,17 @@ var init_oo = __esm({
       set: FieldSet,
       any: FieldAny
     };
-    META_KEYS = "name id fields methods views receive intent alter provide lookup spec extra commonStyle globalStyle scope _rawProvide _rawLookup".split(
+    META_KEYS = "name id fields methods views receive intent alter provide provideType lookup spec extra commonStyle globalStyle scope _rawProvide _rawLookup".split(
       " "
     );
+    RESERVED_COMPONENT_STATICS = /* @__PURE__ */ new Set([
+      ...META_KEYS,
+      "make",
+      "getMetaClass",
+      ...Object.getOwnPropertyNames(Component.prototype)
+    ]);
     Component.fromSpec = (opts) => {
+      assertNoReservedComponentStatics(opts.statics);
       const Class = classFromData(opts.name, opts);
       const comp = new Component(Class, opts);
       const metaClass = Class.getMetaClass();
@@ -13435,7 +13319,7 @@ var init_oo = __esm({
             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;
     };
@@ -13452,9 +13336,10 @@ function warnNotIntent(verb) {
 function rootDispatcher(transactor) {
   return new Dispatcher(new Path([]), transactor, null);
 }
-var State2, Transactor, Transaction, InputEvent, NameArgsTransaction, SendEvent, IntentEvent, PASS, REFUSAL_RING_CAP, DEFAULT_ROUTE, INTENT_DEPTH, IntentWalk, Completion, Dispatcher, EventContext, IntentContext, PathChanges;
+var State2, Transactor, Transaction, InputEvent, NameArgsTransaction, SendEvent, IntentEvent, PASS, REFUSAL_RING_CAP, DEFAULT_ROUTE, INTENT_DEPTH, IntentWalk, Completion, Dispatcher, EventContext, PathChanges;
 var init_transactor = __esm({
   "src/transactor.js"() {
+    init_components();
     init_immer2();
     init_oo();
     init_path();
@@ -13472,9 +13357,6 @@ var init_transactor = __esm({
         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);
-      }
     };
     Transactor = class {
       constructor(comps, rootValue) {
@@ -13535,7 +13417,7 @@ var init_transactor = __esm({
       // 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;
@@ -13567,8 +13449,13 @@ var init_transactor = __esm({
         }
         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);
       }
@@ -13581,9 +13468,9 @@ var init_transactor = __esm({
         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();
@@ -13637,9 +13524,6 @@ var init_transactor = __esm({
       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
@@ -13651,12 +13535,6 @@ var init_transactor = __esm({
       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;
@@ -13676,12 +13554,11 @@ var init_transactor = __esm({
         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) => {
@@ -13738,8 +13615,8 @@ var init_transactor = __esm({
         }
         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);
@@ -13757,11 +13634,10 @@ var init_transactor = __esm({
       }
     };
     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;
@@ -13820,7 +13696,7 @@ var init_transactor = __esm({
     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;
       }
@@ -13920,7 +13796,7 @@ var init_transactor = __esm({
       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);
@@ -13973,7 +13849,7 @@ var init_transactor = __esm({
         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);
@@ -14012,7 +13888,7 @@ var init_transactor = __esm({
         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);
       }
@@ -14058,12 +13934,64 @@ var init_transactor = __esm({
       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
@@ -14074,9 +14002,6 @@ var init_transactor = __esm({
       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);
-      }
     };
     EventContext = class extends Dispatcher {
       get name() {
@@ -14093,6 +14018,19 @@ var init_transactor = __esm({
       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();
@@ -14104,15 +14042,13 @@ var init_transactor = __esm({
         return this.parent.forward(opts);
       }
     };
-    IntentContext = class extends Dispatcher {
-    };
     PathChanges = class extends PathBuilder {
       constructor(dispatcher) {
         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);
@@ -14310,9 +14246,10 @@ var init_app = __esm({
       }
       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;
       }
@@ -14338,8 +14275,8 @@ var init_app = __esm({
         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();
@@ -14399,7 +14336,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);
@@ -14414,6 +14351,195 @@ var init_on = __esm({
   }
 });
 
+// src/cache.js
+var isWeakKey, NullDomCache, WeakMapDomCache;
+var init_cache = __esm({
+  "src/cache.js"() {
+    isWeakKey = (k) => k !== null && (typeof k === "object" || typeof k === "function");
+    NullDomCache = class {
+      get(_keys, _cacheKey) {
+      }
+      set(_keys, _cacheKey, _v) {
+      }
+      evict() {
+        return { hit: 0, miss: 0, badKey: 0 };
+      }
+    };
+    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, Renderer;
+var init_renderer = __esm({
+  "src/renderer.js"() {
+    init_cache();
+    init_iteration();
+    init_vdom();
+    DATASET_ATTRS = ["nid", "cid", "eid", "vid", "si", "sk"];
+    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/util/render.js
 function reindexComponents(comps) {
   for (let i = 0; i < comps.length; i++) {