tutuca 0.9.21 → 0.9.23

package/dist/tutuca-dev.js

@@ -1552,100 +1552,463 @@ class ParseCtxClassSetCollector extends ParseContext {
   }
 }
 
-// src/cache.js
-class NullDomCache {
-  get(_k, _cacheKey) {}
-  set(_k, _cacheKey, _v) {}
-  get2(_k1, _k2, _cacheKey) {}
-  set2(_k1, _k2, _cacheKey, _v) {}
-  evict() {
-    return { hit: 0, miss: 0, badKey: 0 };
-  }
+// tools/core/lint-check.js
+var ALT_HANDLER_NOT_DEFINED = "ALT_HANDLER_NOT_DEFINED";
+var ALT_HANDLER_NOT_REFERENCED = "ALT_HANDLER_NOT_REFERENCED";
+var RENDER_IT_OUTSIDE_OF_LOOP = "RENDER_IT_OUTSIDE_OF_LOOP";
+var UNKNOWN_EVENT_MODIFIER = "UNKNOWN_EVENT_MODIFIER";
+var UNKNOWN_HANDLER_ARG_NAME = "UNKNOWN_HANDLER_ARG_NAME";
+var INPUT_HANDLER_NOT_IMPLEMENTED = "INPUT_HANDLER_NOT_IMPLEMENTED";
+var INPUT_HANDLER_NOT_REFERENCED = "INPUT_HANDLER_NOT_REFERENCED";
+var INPUT_HANDLER_METHOD_NOT_IMPLEMENTED = "INPUT_HANDLER_METHOD_NOT_IMPLEMENTED";
+var INPUT_HANDLER_FOR_INPUT_HANDLER_METHOD = "INPUT_HANDLER_FOR_INPUT_HANDLER_METHOD";
+var INPUT_HANDLER_METHOD_FOR_INPUT_HANDLER = "INPUT_HANDLER_METHOD_FOR_INPUT_HANDLER";
+var FIELD_VAL_NOT_DEFINED = "FIELD_VAL_NOT_DEFINED";
+var COMPUTED_VAL_NOT_DEFINED = "COMPUTED_VAL_NOT_DEFINED";
+var COMPUTED_NOT_REFERENCED = "COMPUTED_NOT_REFERENCED";
+var UNKNOWN_REQUEST_NAME = "UNKNOWN_REQUEST_NAME";
+var UNKNOWN_COMPONENT_NAME = "UNKNOWN_COMPONENT_NAME";
+var LEVEL_WARN = "warn";
+var LEVEL_ERROR = "error";
+var LEVEL_HINT = "hint";
+function checkComponent(Comp, lx = new LintContext) {
+  return lx.push({ componentName: Comp.name }, () => {
+    const referencedAlters = new Set;
+    const referencedInputs = new Set;
+    const referencedComputed = new Set;
+    checkEventHandlersHaveImpls(lx, Comp, referencedInputs);
+    checkConsistentAttrs(lx, Comp, referencedAlters, referencedComputed);
+    for (const name in Comp.views) {
+      lx.push({ viewName: name }, () => checkView(lx, Comp.views[name], Comp, referencedAlters, referencedComputed));
+    }
+    checkUnreferencedAlterHandlers(lx, Comp, referencedAlters);
+    checkUnreferencedInputHandlers(lx, Comp, referencedInputs);
+    checkUnreferencedComputed(lx, Comp, referencedComputed);
+    return lx;
+  });
 }
-
-class WeakMapDomCache {
-  constructor() {
-    this.hit = this.miss = this.badKey = 0;
-    this.map = new WeakMap;
+function checkView(lx, view, Comp, referencedAlters, referencedComputed) {
+  checkRenderItInLoop(lx, view);
+  checkEventModifiers(lx, view);
+  checkKnownHandlerNames(lx, view, Comp, referencedAlters, referencedComputed);
+}
+function checkRenderItInLoop(lx, view) {
+  let hasRenderIt = false;
+  for (const node of view.ctx.nodes) {
+    if (node.constructor.name === "RenderItNode") {
+      hasRenderIt = true;
+      break;
+    }
   }
-  _returnValue(r) {
-    if (r === undefined)
-      this.miss += 1;
-    else
-      this.hit += 1;
-    return r;
+  if (!hasRenderIt)
+    return;
+  walkForRenderIt(lx, view.anode, 0);
+}
+function walkForRenderIt(lx, node, loopDepth) {
+  if (node === null || node === undefined)
+    return;
+  switch (node.constructor.name) {
+    case "RenderItNode":
+      if (loopDepth === 0)
+        lx.error(RENDER_IT_OUTSIDE_OF_LOOP, { node });
+      return;
+    case "EachNode":
+      walkForRenderIt(lx, node.node, loopDepth + 1);
+      return;
+    case "ShowNode":
+    case "HideNode":
+    case "ScopeNode":
+    case "SlotNode":
+    case "PushViewNameNode":
+    case "MacroNode":
+    case "RenderOnceNode":
+      walkForRenderIt(lx, node.node, loopDepth);
+      return;
+    case "DomNode":
+    case "FragmentNode":
+      for (const child of node.childs)
+        walkForRenderIt(lx, child, loopDepth);
+      return;
+    default:
+      return;
   }
-  get(k, cacheKey) {
-    return this._returnValue(this.map.get(k)?.[cacheKey]);
+}
+var NO_WRAPPERS = {};
+function checkEventModifiers(lx, view) {
+  for (const event of view.ctx.events) {
+    for (const handler of event.handlers) {
+      const { name, modifiers } = handler;
+      const modWrappers = MOD_WRAPPERS_BY_EVENT[name] ?? NO_WRAPPERS;
+      for (const modifier of modifiers) {
+        if (modWrappers[modifier] === undefined) {
+          lx.warn(UNKNOWN_EVENT_MODIFIER, { name, modifier, handler, event });
+        }
+      }
+    }
   }
-  set(k, cacheKey, v) {
-    const cur = this.map.get(k);
-    if (cur)
-      cur[cacheKey] = v;
-    else if (typeof k === "object")
-      this.map.set(k, { [cacheKey]: v });
-    else
-      this.badKey += 1;
+}
+var KNOWN_HANDLER_NAMES = new Set([
+  "value",
+  "valueAsInt",
+  "valueAsFloat",
+  "target",
+  "event",
+  "isAlt",
+  "isShift",
+  "isCtrl",
+  "isCmd",
+  "key",
+  "keyCode",
+  "isUpKey",
+  "isDownKey",
+  "isSend",
+  "isCancel",
+  "isTabKey",
+  "ctx",
+  "dragInfo"
+]);
+function isKnownHandlerName(name) {
+  return KNOWN_HANDLER_NAMES.has(name);
+}
+function checkKnownHandlerNames(lx, view, Comp, referencedAlters, referencedComputed) {
+  const { computed, scope, alter, Class } = Comp;
+  const { prototype: proto } = Class;
+  const { fields } = Class.getMetaClass();
+  for (const event of view.ctx.events) {
+    for (const handler of event.handlers) {
+      const { args } = handler.handlerCall;
+      for (let i = 0;i < args.length; i++) {
+        const arg = args[i];
+        checkConsistentAttrVal(lx, arg, fields, proto, computed, scope, alter, referencedAlters, referencedComputed);
+      }
+    }
   }
-  get2(k1, k2, cacheKey) {
-    return this._returnValue(this.map.get(k1)?.get?.(k2)?.[cacheKey]);
+}
+function checkEventHandlersHaveImpls(lx, Comp, referencedInputs) {
+  const { input, views, Class } = Comp;
+  const { prototype: proto } = Class;
+  for (const viewName in views) {
+    lx.push({ viewName }, () => {
+      const view = views[viewName];
+      for (const event of view.ctx.events) {
+        for (const handler of event.handlers) {
+          const { handlerVal } = handler.handlerCall;
+          const hvName = handlerVal?.constructor.name;
+          if (hvName === "InputHandlerNameVal") {
+            referencedInputs?.add(handlerVal.name);
+            if (input[handlerVal.name] === undefined) {
+              lx.warn(INPUT_HANDLER_NOT_IMPLEMENTED, {
+                name: handlerVal.name,
+                handler,
+                event
+              });
+              if (proto[handlerVal.name] !== undefined) {
+                lx.hint(INPUT_HANDLER_METHOD_FOR_INPUT_HANDLER, {
+                  name: handlerVal.name,
+                  handler,
+                  event
+                });
+              }
+            }
+          } else if (hvName === "RawFieldVal") {
+            referencedInputs?.add(handlerVal.name);
+            if (proto[handlerVal.name] === undefined) {
+              lx.warn(INPUT_HANDLER_METHOD_NOT_IMPLEMENTED, {
+                name: handlerVal.name,
+                handler,
+                event
+              });
+              if (input[handlerVal.name] !== undefined) {
+                lx.hint(INPUT_HANDLER_FOR_INPUT_HANDLER_METHOD, {
+                  name: handlerVal.name,
+                  handler,
+                  event
+                });
+              }
+            }
+          }
+        }
+      }
+    });
   }
-  set2(k1, k2, cacheKey, v) {
-    const cur1 = this.map.get(k1);
-    if (cur1) {
-      const cur = cur1.get(k2);
-      if (cur)
-        cur[cacheKey] = v;
-      else
-        cur1.set(k2, { [cacheKey]: v });
-    } else if (typeof k1 === "object" && typeof k2 === "object") {
-      const cur = new WeakMap;
-      cur.set(k2, { [cacheKey]: v });
-      this.map.set(k1, cur);
-    } else {
-      this.badKey += 1;
+}
+function checkConsistentAttrVal(lx, val, fields, proto, computed, scope, alter, referencedAlters, referencedComputed) {
+  const valName = val?.constructor.name;
+  if (valName === "FieldVal" || valName === "RawFieldVal") {
+    const { name } = val;
+    if (fields[name] === undefined && proto[name] === undefined) {
+      lx.error(FIELD_VAL_NOT_DEFINED, { val, name });
+    }
+  } else if (valName === "ComputedVal") {
+    const { name } = val;
+    referencedComputed?.add(name);
+    if (computed[name] === undefined) {
+      lx.error(COMPUTED_VAL_NOT_DEFINED, { val, name });
+    }
+  } else if (valName === "SeqAccessVal") {
+    checkConsistentAttrVal(lx, val.seqVal, fields, proto, computed, scope, alter, referencedAlters, referencedComputed);
+    checkConsistentAttrVal(lx, val.keyVal, fields, proto, computed, scope, alter, referencedAlters, referencedComputed);
+  } else if (valName === "RequestVal") {
+    if (scope.lookupRequest(val.name) === null) {
+      lx.warn(UNKNOWN_REQUEST_NAME, { name: val.name });
+    }
+  } else if (valName === "TypeVal") {
+    if (scope.lookupComponent(val.name) === null) {
+      lx.warn(UNKNOWN_COMPONENT_NAME, { name: val.name });
+    }
+  } else if (valName === "NameVal") {
+    if (!isKnownHandlerName(val.name)) {
+      lx.warn(UNKNOWN_HANDLER_ARG_NAME, { name: val.name });
+    }
+  } else if (valName === "StrTplVal") {
+    for (const subVal of val.vals) {
+      checkConsistentAttrVal(lx, subVal, fields, proto, computed, scope, alter, referencedAlters, referencedComputed);
+    }
+  } else if (valName === "AlterHandlerNameVal") {
+    referencedAlters?.add(val.name);
+    if (alter[val.name] === undefined) {
+      lx.warn(ALT_HANDLER_NOT_DEFINED, { name: val.name });
     }
+  } else if (valName !== "ConstVal" && valName !== "BindVal") {
+    console.log(val);
   }
-  evict() {
-    const { hit, miss, badKey } = this;
-    this.hit = this.miss = this.badKey = 0;
-    this.map = new WeakMap;
-    return { hit, miss, badKey };
+}
+function checkConsistentAttrs(lx, Comp, referencedAlters, referencedComputed) {
+  const { computed, scope, views, alter, Class } = Comp;
+  const { prototype: proto } = Class;
+  const { fields } = Class.getMetaClass();
+  for (const viewName in views) {
+    lx.push({ viewName }, () => {
+      const view = views[viewName];
+      for (const attr of view.ctx.attrs) {
+        const { attrs, wrapperAttrs, textChild } = attr;
+        if (attrs?.constructor.name === "DynAttrs") {
+          for (const attr2 of attrs.items) {
+            if (attr2?.constructor.name === "Attr") {
+              checkConsistentAttrVal(lx, attr2.val, fields, proto, computed, scope, alter, referencedAlters, referencedComputed);
+            }
+          }
+        }
+        if (wrapperAttrs !== null) {
+          for (const w of wrapperAttrs) {
+            if (w.name === "each") {
+              if (w.whenVal)
+                checkConsistentAttrVal(lx, w.whenVal, fields, proto, computed, scope, alter, referencedAlters, referencedComputed);
+              if (w.enrichWithVal)
+                checkConsistentAttrVal(lx, w.enrichWithVal, fields, proto, computed, scope, alter, referencedAlters, referencedComputed);
+              if (w.loopWithVal)
+                checkConsistentAttrVal(lx, w.loopWithVal, fields, proto, computed, scope, alter, referencedAlters, referencedComputed);
+            } else if (w.name !== "scope") {
+              checkConsistentAttrVal(lx, w.val, fields, proto, computed, scope, alter, referencedAlters, referencedComputed);
+            }
+          }
+        }
+        if (textChild) {
+          checkConsistentAttrVal(lx, textChild, fields, proto, computed, scope, alter, referencedAlters, referencedComputed);
+        }
+      }
+      for (const node of view.ctx.nodes) {
+        if (node.val) {
+          checkConsistentAttrVal(lx, node.val, fields, proto, computed, scope, alter, referencedAlters, referencedComputed);
+        }
+      }
+    });
   }
 }
-
-class NullComputedCache {
-  getKey(v, _key, fn) {
-    return fn.call(v);
+function checkUnreferencedAlterHandlers(lx, Comp, referencedAlters) {
+  for (const name in Comp.alter) {
+    if (!referencedAlters.has(name)) {
+      lx.hint(ALT_HANDLER_NOT_REFERENCED, { name });
+    }
   }
 }
-
-class WeakMapComputedCache {
-  constructor() {
-    this.map = new WeakMap;
+function checkUnreferencedInputHandlers(lx, Comp, referencedInputs) {
+  for (const name in Comp.input) {
+    if (!referencedInputs.has(name)) {
+      lx.hint(INPUT_HANDLER_NOT_REFERENCED, { name });
+    }
   }
-  getKey(v, key, fn) {
-    const cur = this.map.get(v);
-    if (cur) {
-      const curValue = cur[key];
-      if (curValue !== undefined)
-        return curValue;
-      const newValue2 = fn.call(v) ?? null;
-      cur[key] = newValue2;
-      return newValue2;
+}
+function checkUnreferencedComputed(lx, Comp, referencedComputed) {
+  for (const name in Comp.computed) {
+    if (!referencedComputed.has(name)) {
+      lx.hint(COMPUTED_NOT_REFERENCED, { name });
     }
-    const newValue = fn.call(v) ?? null;
-    this.map.set(v, { [key]: newValue });
-    return newValue;
   }
 }
 
-// src/components.js
-class Components {
+class LintContext {
   constructor() {
-    this.getComponentSymbol = Symbol("getComponent");
-    this.byId = new Map;
-    this.computedCache = new WeakMapComputedCache;
+    this.reports = [];
+    this.frame = {};
+  }
+  push(patch, fn) {
+    const prev = this.frame;
+    this.frame = { ...prev, ...patch };
+    try {
+      return fn();
+    } finally {
+      this.frame = prev;
+    }
+  }
+  error(id, info) {
+    this.report(id, info, LEVEL_ERROR);
+  }
+  warn(id, info) {
+    this.report(id, info, LEVEL_WARN);
+  }
+  hint(id, info) {
+    this.report(id, info, LEVEL_HINT);
+  }
+  report(id, info = {}, level = LEVEL_ERROR) {
+    this.reports.push({ id, info, level, context: { ...this.frame } });
+  }
+}
+
+class LintParseContext extends ParseContext {
+  constructor(DOMParser, Text, Comment) {
+    super(DOMParser, Text, Comment);
+    this.attrs = [];
+  }
+  onAttributes(attrs, wrapperAttrs, textChild) {
+    this.attrs.push({ attrs, wrapperAttrs, textChild });
+  }
+}
+
+// tools/format/lint.js
+function lintIdToMessage(id, info) {
+  switch (id) {
+    case "RENDER_IT_OUTSIDE_OF_LOOP":
+      return "render-it used outside of a loop";
+    case "UNKNOWN_EVENT_MODIFIER":
+      return `Unknown modifier '${info.modifier}' on '${info.name}' event`;
+    case "UNKNOWN_HANDLER_ARG_NAME":
+      return `Unknown handler argument '${info.name}'`;
+    case "INPUT_HANDLER_NOT_IMPLEMENTED":
+      return `Input handler '${info.name}' is not implemented`;
+    case "INPUT_HANDLER_NOT_REFERENCED":
+      return `Input handler '${info.name}' is defined but not referenced`;
+    case "INPUT_HANDLER_METHOD_NOT_IMPLEMENTED":
+      return `Method '.${info.name}' is not implemented`;
+    case "INPUT_HANDLER_FOR_INPUT_HANDLER_METHOD":
+      return `'${info.name}' exists as input handler — use without '.' prefix`;
+    case "INPUT_HANDLER_METHOD_FOR_INPUT_HANDLER":
+      return `'${info.name}' exists as method — use with '.' prefix`;
+    case "FIELD_VAL_NOT_DEFINED":
+      return `Field '.${info.name}' is not defined`;
+    case "COMPUTED_VAL_NOT_DEFINED":
+      return `Computed property '$${info.name}' is not defined`;
+    case "COMPUTED_NOT_REFERENCED":
+      return `Computed property '$${info.name}' is defined but not referenced`;
+    case "UNKNOWN_REQUEST_NAME":
+      return `Unknown request '!${info.name}'`;
+    case "UNKNOWN_COMPONENT_NAME":
+      return `Unknown component '${info.name}'`;
+    case "ALT_HANDLER_NOT_DEFINED":
+      return `Alter handler '${info.name}' is not defined`;
+    case "ALT_HANDLER_NOT_REFERENCED":
+      return `Alter handler '${info.name}' is defined but not referenced`;
+    case "LINT_ERROR":
+      return info.message;
+    default:
+      return id;
+  }
+}
+
+// src/cache.js
+class NullDomCache {
+  get(_k, _cacheKey) {}
+  set(_k, _cacheKey, _v) {}
+  get2(_k1, _k2, _cacheKey) {}
+  set2(_k1, _k2, _cacheKey, _v) {}
+  evict() {
+    return { hit: 0, miss: 0, badKey: 0 };
+  }
+}
+
+class WeakMapDomCache {
+  constructor() {
+    this.hit = this.miss = this.badKey = 0;
+    this.map = new WeakMap;
+  }
+  _returnValue(r) {
+    if (r === undefined)
+      this.miss += 1;
+    else
+      this.hit += 1;
+    return r;
+  }
+  get(k, cacheKey) {
+    return this._returnValue(this.map.get(k)?.[cacheKey]);
+  }
+  set(k, cacheKey, v) {
+    const cur = this.map.get(k);
+    if (cur)
+      cur[cacheKey] = v;
+    else if (typeof k === "object")
+      this.map.set(k, { [cacheKey]: v });
+    else
+      this.badKey += 1;
+  }
+  get2(k1, k2, cacheKey) {
+    return this._returnValue(this.map.get(k1)?.get?.(k2)?.[cacheKey]);
+  }
+  set2(k1, k2, cacheKey, v) {
+    const cur1 = this.map.get(k1);
+    if (cur1) {
+      const cur = cur1.get(k2);
+      if (cur)
+        cur[cacheKey] = v;
+      else
+        cur1.set(k2, { [cacheKey]: v });
+    } else if (typeof k1 === "object" && typeof k2 === "object") {
+      const cur = new WeakMap;
+      cur.set(k2, { [cacheKey]: v });
+      this.map.set(k1, cur);
+    } else {
+      this.badKey += 1;
+    }
+  }
+  evict() {
+    const { hit, miss, badKey } = this;
+    this.hit = this.miss = this.badKey = 0;
+    this.map = new WeakMap;
+    return { hit, miss, badKey };
+  }
+}
+
+class NullComputedCache {
+  getKey(v, _key, fn) {
+    return fn.call(v);
+  }
+}
+
+class WeakMapComputedCache {
+  constructor() {
+    this.map = new WeakMap;
+  }
+  getKey(v, key, fn) {
+    const cur = this.map.get(v);
+    if (cur) {
+      const curValue = cur[key];
+      if (curValue !== undefined)
+        return curValue;
+      const newValue2 = fn.call(v) ?? null;
+      cur[key] = newValue2;
+      return newValue2;
+    }
+    const newValue = fn.call(v) ?? null;
+    this.map.set(v, { [key]: newValue });
+    return newValue;
+  }
+}
+
+// src/components.js
+class Components {
+  constructor() {
+    this.getComponentSymbol = Symbol("getComponent");
+    this.byId = new Map;
+    this.computedCache = new WeakMapComputedCache;
   }
   setNullComputedCache() {
     this.computedCache = new NullComputedCache;
@@ -7736,483 +8099,205 @@ class Renderer {
   pushEachEntry(r, nid, attrName, key, dom) {
     r.push(this._renderMetadata({ $: "Each", nid, [attrName]: key }), dom);
   }
-  renderEach(stack, iterInfo, nodeId, viewName) {
-    const { seq, filter, loopWith } = iterInfo.eval(stack);
-    const r = [];
-    const iterData = loopWith.call(stack.it, seq);
-    this.getSeqInfo(seq)(seq, (key, value, attrName) => {
-      if (filter.call(stack.it, key, value, iterData)) {
-        const newStack = stack.enter(value, { key }, true);
-        const dom = this.renderIt(newStack, nodeId, key, viewName);
-        this.pushEachEntry(r, nodeId, attrName, key, dom);
-      }
-    });
-    return r;
-  }
-  renderEachWhen(stack, iterInfo, view, nid) {
-    const { seq, filter, loopWith, enricher } = iterInfo.eval(stack);
-    const r = [];
-    const iterData = loopWith.call(stack.it, seq);
-    const it = stack.it;
-    this.getSeqInfo(seq)(seq, (key, value, attrName) => {
-      if (filter.call(it, key, value, iterData)) {
-        const bindings = { key, value };
-        const cacheKey = `${nid}-${key}`;
-        let cachedNode;
-        if (enricher) {
-          enricher.call(it, bindings, key, value, iterData);
-          cachedNode = this.cache.get2(it, value, cacheKey);
-        } else
-          cachedNode = this.cache.get(value, cacheKey);
-        if (cachedNode) {
-          this.pushEachEntry(r, nid, attrName, key, cachedNode);
-          return;
-        }
-        const newStack = stack.enter(value, bindings, false);
-        const dom = this.renderView(view, newStack);
-        this.pushEachEntry(r, nid, attrName, key, dom);
-        if (enricher)
-          this.cache.set2(it, value, cacheKey, dom);
-        else
-          this.cache.set(value, cacheKey, dom);
-      }
-    });
-    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)}§`);
-  }
-}
-var imIndexedIter = (seq, visit) => {
-  let i = 0;
-  for (const v of seq)
-    visit(i++, v, "si");
-};
-var imKeyedIter = (seq, visit) => {
-  for (const [k, v] of seq.toSeq().entries())
-    visit(k, v, "sk");
-};
-var unkIter = () => {};
-var seqInfoByClass = new Map;
-
-// extra/klist.js
-class KList {
-  constructor(items = Map2(), order = List()) {
-    this.items = items;
-    this.order = order;
-    this.$ = 0;
-  }
-  _clonish(items, order) {
-    return new KList(items, order, this.$);
-  }
-  toJS() {
-    return this.order.toArray().map((k) => this.items.get(k));
-  }
-  set(k, v) {
-    const newOrder = this.items.has(k) ? this.order : this.order.push(k);
-    return this._clonish(this.items.set(k, v), newOrder, this.$);
-  }
-  get(k, dval = null) {
-    return this.items.get(k, dval);
-  }
-  _nextFreeKey() {
-    let cur = this.$;
-    while (true) {
-      const key = `§${cur}§`;
-      if (!this.items.has(key)) {
-        return [key, cur];
-      }
-      cur += 1;
-    }
-  }
-  push(v) {
-    const [key, next$] = this._nextFreeKey();
-    const newKList = this.set(key, v);
-    newKList.$ = next$;
-    return newKList;
-  }
-  get size() {
-    return this.items.size;
-  }
-  delete(k) {
-    if (this.items.has(k)) {
-      const newOrder = this.order.delete(this.order.indexOf(k));
-      return this._clonish(this.items.delete(k), newOrder);
-    }
-    return this;
-  }
-  moveKeyBeforeKey(k1, k2) {
-    const { order } = this;
-    return this.moveKeyIndexToIndex(order.indexOf(k1), order.indexOf(k2), 0);
-  }
-  moveKeyAfterKey(k1, k2) {
-    const { order } = this;
-    return this.moveKeyIndexToIndex(order.indexOf(k1), order.indexOf(k2), 1);
-  }
-  moveKeyIndexToIndex(source, target, offset) {
-    if (source === -1 || target === -1 || source === target) {
-      return this;
-    }
-    const { order } = this;
-    const newPos = target + offset;
-    const oldPos = newPos < source ? source + 1 : source;
-    const newOrder = order.insert(newPos, order.get(source)).delete(oldPos);
-    return this._clonish(this.items, newOrder);
-  }
-}
-var klistCoercer = (_) => null;
-
-class CheckTypeKList {
-  isValid(v) {
-    return v instanceof KList;
-  }
-  getMessage(_v) {
-    return "KList expected";
-  }
-}
-var CHECK_TYPE_KLIST = new CheckTypeKList;
-
-class FieldKList extends Field {
-  constructor(name, defaultValue = new KList) {
-    super("KList", name, CHECK_TYPE_KLIST, klistCoercer, defaultValue);
-  }
-  extendProtoForType(proto, uname) {
-    extendProtoForKeyed(proto, this.name, uname);
-    const { name } = this;
-    extendProtoForKeyed(proto, name, uname);
-    proto[`pushIn${uname}`] = function(v) {
-      return this.set(name, this.get(name).push(v));
-    };
-  }
-}
-fieldsByClass.set(KList, FieldKList);
-seqInfoByClass.set(KList, (seq, visit) => {
-  for (const k of seq.order)
-    visit(k, seq.items.get(k), "data-sk");
-});
-// index.js
-var css = String.raw;
-var html = String.raw;
-var macro = (defaults, rawView) => new Macro(defaults, rawView);
-function tutuca(nodeOrSelector) {
-  const rootNode = typeof nodeOrSelector === "string" ? document.querySelector(nodeOrSelector) : nodeOrSelector;
-  const comps = new Components;
-  const renderer = new Renderer(comps);
-  return new App(rootNode, comps, renderer, ParseContext);
-}
-
-// extra.js
-async function compileClassesToStyle(app, compileClasses, styleId = "margaui-css") {
-  const t1 = performance.now();
-  const css2 = await compileClassesToStyleText(app, compileClasses);
-  const t2 = performance.now();
-  injectCss(styleId, css2);
-  return t2 - t1;
-}
-async function compileClassesToStyleText(app, compileClasses, extraCSSClasses, Ctx = ParseCtxClassSetCollector) {
-  app.ParseContext = Ctx;
-  app.compile();
-  const classes = new Set(extraCSSClasses ?? []);
-  for (const Comp of app.comps.byId.values()) {
-    for (const key in Comp.views) {
-      const view = Comp.views[key];
-      for (const name of view.ctx.classes)
-        classes.add(name);
-    }
-  }
-  return await compileClasses(Array.from(classes));
-}
-// tools/core/lint-check.js
-var ALT_HANDLER_NOT_DEFINED = "ALT_HANDLER_NOT_DEFINED";
-var ALT_HANDLER_NOT_REFERENCED = "ALT_HANDLER_NOT_REFERENCED";
-var RENDER_IT_OUTSIDE_OF_LOOP = "RENDER_IT_OUTSIDE_OF_LOOP";
-var UNKNOWN_EVENT_MODIFIER = "UNKNOWN_EVENT_MODIFIER";
-var UNKNOWN_HANDLER_ARG_NAME = "UNKNOWN_HANDLER_ARG_NAME";
-var INPUT_HANDLER_NOT_IMPLEMENTED = "INPUT_HANDLER_NOT_IMPLEMENTED";
-var INPUT_HANDLER_NOT_REFERENCED = "INPUT_HANDLER_NOT_REFERENCED";
-var INPUT_HANDLER_METHOD_NOT_IMPLEMENTED = "INPUT_HANDLER_METHOD_NOT_IMPLEMENTED";
-var INPUT_HANDLER_FOR_INPUT_HANDLER_METHOD = "INPUT_HANDLER_FOR_INPUT_HANDLER_METHOD";
-var INPUT_HANDLER_METHOD_FOR_INPUT_HANDLER = "INPUT_HANDLER_METHOD_FOR_INPUT_HANDLER";
-var FIELD_VAL_NOT_DEFINED = "FIELD_VAL_NOT_DEFINED";
-var COMPUTED_VAL_NOT_DEFINED = "COMPUTED_VAL_NOT_DEFINED";
-var COMPUTED_NOT_REFERENCED = "COMPUTED_NOT_REFERENCED";
-var UNKNOWN_REQUEST_NAME = "UNKNOWN_REQUEST_NAME";
-var UNKNOWN_COMPONENT_NAME = "UNKNOWN_COMPONENT_NAME";
-var LEVEL_WARN = "warn";
-var LEVEL_ERROR = "error";
-var LEVEL_HINT = "hint";
-function checkComponent(Comp, lx = new LintContext) {
-  const referencedAlters = new Set;
-  const referencedInputs = new Set;
-  const referencedComputed = new Set;
-  checkEventHandlersHaveImpls(lx, Comp, referencedInputs);
-  checkConsistentAttrs(lx, Comp, referencedAlters, referencedComputed);
-  for (const name in Comp.views) {
-    checkView(lx, Comp.views[name], Comp, referencedAlters, referencedComputed);
-  }
-  checkUnreferencedAlterHandlers(lx, Comp, referencedAlters);
-  checkUnreferencedInputHandlers(lx, Comp, referencedInputs);
-  checkUnreferencedComputed(lx, Comp, referencedComputed);
-  return lx;
-}
-function checkView(lx, view, Comp, referencedAlters, referencedComputed) {
-  checkRenderItInLoop(lx, view);
-  checkEventModifiers(lx, view);
-  checkKnownHandlerNames(lx, view, Comp, referencedAlters, referencedComputed);
-}
-function checkRenderItInLoop(lx, view) {
-  const { nodes } = view.ctx;
-  for (let i = 0;i < nodes.length; i++) {
-    const node = nodes[i];
-    if (node.constructor.name === "RenderItNode") {
-      const next = nodes[i + 1];
-      const nextName = next?.constructor.name;
-      if (nextName !== "EachNode" && nextName !== "RenderEachNode") {
-        lx.error(RENDER_IT_OUTSIDE_OF_LOOP, { node });
-      }
-    }
-  }
-}
-var NO_WRAPPERS = {};
-function checkEventModifiers(lx, view) {
-  for (const event of view.ctx.events) {
-    for (const handler of event.handlers) {
-      const { name, modifiers } = handler;
-      const modWrappers = MOD_WRAPPERS_BY_EVENT[name] ?? NO_WRAPPERS;
-      for (const modifier of modifiers) {
-        if (modWrappers[modifier] === undefined) {
-          lx.warn(UNKNOWN_EVENT_MODIFIER, { name, modifier, handler, event });
-        }
-      }
-    }
-  }
-}
-var KNOWN_HANDLER_NAMES = new Set([
-  "value",
-  "valueAsInt",
-  "valueAsFloat",
-  "target",
-  "event",
-  "isAlt",
-  "isShift",
-  "isCtrl",
-  "isCmd",
-  "key",
-  "keyCode",
-  "isUpKey",
-  "isDownKey",
-  "isSend",
-  "isCancel",
-  "isTabKey",
-  "ctx",
-  "dragInfo"
-]);
-function isKnownHandlerName(name) {
-  return KNOWN_HANDLER_NAMES.has(name);
-}
-function checkKnownHandlerNames(lx, view, Comp, referencedAlters, referencedComputed) {
-  const { computed, scope, alter, Class } = Comp;
-  const { prototype: proto } = Class;
-  const { fields } = Class.getMetaClass();
-  for (const event of view.ctx.events) {
-    for (const handler of event.handlers) {
-      const { args } = handler.handlerCall;
-      for (let i = 0;i < args.length; i++) {
-        const arg = args[i];
-        checkConsistentAttrVal(lx, arg, fields, proto, computed, scope, alter, referencedAlters, referencedComputed);
-      }
-    }
-  }
-}
-function checkEventHandlersHaveImpls(lx, Comp, referencedInputs) {
-  const { input, views, Class } = Comp;
-  const { prototype: proto } = Class;
-  for (const viewName in views) {
-    const view = views[viewName];
-    for (const event of view.ctx.events) {
-      for (const handler of event.handlers) {
-        const { handlerVal } = handler.handlerCall;
-        const hvName = handlerVal?.constructor.name;
-        if (hvName === "InputHandlerNameVal") {
-          referencedInputs?.add(handlerVal.name);
-          if (input[handlerVal.name] === undefined) {
-            lx.warn(INPUT_HANDLER_NOT_IMPLEMENTED, {
-              name: handlerVal.name,
-              handler,
-              event
-            });
-            if (proto[handlerVal.name] !== undefined) {
-              lx.hint(INPUT_HANDLER_METHOD_FOR_INPUT_HANDLER, {
-                name: handlerVal.name,
-                handler,
-                event
-              });
-            }
-          }
-        } else if (hvName === "RawFieldVal") {
-          referencedInputs?.add(handlerVal.name);
-          if (proto[handlerVal.name] === undefined) {
-            lx.warn(INPUT_HANDLER_METHOD_NOT_IMPLEMENTED, {
-              name: handlerVal.name,
-              handler,
-              event
-            });
-            if (input[handlerVal.name] !== undefined) {
-              lx.hint(INPUT_HANDLER_FOR_INPUT_HANDLER_METHOD, {
-                name: handlerVal.name,
-                handler,
-                event
-              });
-            }
-          }
-        }
-      }
-    }
-  }
-}
-function checkConsistentAttrVal(lx, val, fields, proto, computed, scope, alter, referencedAlters, referencedComputed) {
-  const valName = val?.constructor.name;
-  if (valName === "FieldVal" || valName === "RawFieldVal") {
-    const { name } = val;
-    if (fields[name] === undefined && proto[name] === undefined) {
-      lx.error(FIELD_VAL_NOT_DEFINED, { val, name });
-    }
-  } else if (valName === "ComputedVal") {
-    const { name } = val;
-    referencedComputed?.add(name);
-    if (computed[name] === undefined) {
-      lx.error(COMPUTED_VAL_NOT_DEFINED, { val, name });
-    }
-  } else if (valName === "SeqAccessVal") {
-    checkConsistentAttrVal(lx, val.seqVal, fields, proto, computed, scope, alter, referencedAlters, referencedComputed);
-    checkConsistentAttrVal(lx, val.keyVal, fields, proto, computed, scope, alter, referencedAlters, referencedComputed);
-  } else if (valName === "RequestVal") {
-    if (scope.lookupRequest(val.name) === null) {
-      lx.warn(UNKNOWN_REQUEST_NAME, { name: val.name });
-    }
-  } else if (valName === "TypeVal") {
-    if (scope.lookupComponent(val.name) === null) {
-      lx.warn(UNKNOWN_COMPONENT_NAME, { name: val.name });
-    }
-  } else if (valName === "NameVal") {
-    if (!isKnownHandlerName(val.name)) {
-      lx.warn(UNKNOWN_HANDLER_ARG_NAME, { name: val.name });
-    }
-  } else if (valName === "StrTplVal") {
-    for (const subVal of val.vals) {
-      checkConsistentAttrVal(lx, subVal, fields, proto, computed, scope, alter, referencedAlters, referencedComputed);
-    }
-  } else if (valName === "AlterHandlerNameVal") {
-    referencedAlters?.add(val.name);
-    if (alter[val.name] === undefined) {
-      lx.warn(ALT_HANDLER_NOT_DEFINED, { name: val.name });
-    }
-  } else if (valName !== "ConstVal" && valName !== "BindVal") {
-    console.log(val);
-  }
-}
-function checkConsistentAttrs(lx, Comp, referencedAlters, referencedComputed) {
-  const { computed, scope, views, alter, Class } = Comp;
-  const { prototype: proto } = Class;
-  const { fields } = Class.getMetaClass();
-  for (const viewName in views) {
-    const view = views[viewName];
-    for (const attr of view.ctx.attrs) {
-      const { attrs, wrapperAttrs, textChild } = attr;
-      if (attrs?.constructor.name === "DynAttrs") {
-        for (const attr2 of attrs.items) {
-          if (attr2?.constructor.name === "Attr") {
-            checkConsistentAttrVal(lx, attr2.val, fields, proto, computed, scope, alter, referencedAlters, referencedComputed);
-          }
-        }
+  renderEach(stack, iterInfo, nodeId, viewName) {
+    const { seq, filter, loopWith } = iterInfo.eval(stack);
+    const r = [];
+    const iterData = loopWith.call(stack.it, seq);
+    this.getSeqInfo(seq)(seq, (key, value, attrName) => {
+      if (filter.call(stack.it, key, value, iterData)) {
+        const newStack = stack.enter(value, { key }, true);
+        const dom = this.renderIt(newStack, nodeId, key, viewName);
+        this.pushEachEntry(r, nodeId, attrName, key, dom);
       }
-      if (wrapperAttrs !== null) {
-        for (const w of wrapperAttrs) {
-          if (w.name === "each") {
-            if (w.whenVal)
-              checkConsistentAttrVal(lx, w.whenVal, fields, proto, computed, scope, alter, referencedAlters, referencedComputed);
-            if (w.enrichWithVal)
-              checkConsistentAttrVal(lx, w.enrichWithVal, fields, proto, computed, scope, alter, referencedAlters, referencedComputed);
-            if (w.loopWithVal)
-              checkConsistentAttrVal(lx, w.loopWithVal, fields, proto, computed, scope, alter, referencedAlters, referencedComputed);
-          } else if (w.name !== "scope") {
-            checkConsistentAttrVal(lx, w.val, fields, proto, computed, scope, alter, referencedAlters, referencedComputed);
-          }
+    });
+    return r;
+  }
+  renderEachWhen(stack, iterInfo, view, nid) {
+    const { seq, filter, loopWith, enricher } = iterInfo.eval(stack);
+    const r = [];
+    const iterData = loopWith.call(stack.it, seq);
+    const it = stack.it;
+    this.getSeqInfo(seq)(seq, (key, value, attrName) => {
+      if (filter.call(it, key, value, iterData)) {
+        const bindings = { key, value };
+        const cacheKey = `${nid}-${key}`;
+        let cachedNode;
+        if (enricher) {
+          enricher.call(it, bindings, key, value, iterData);
+          cachedNode = this.cache.get2(it, value, cacheKey);
+        } else
+          cachedNode = this.cache.get(value, cacheKey);
+        if (cachedNode) {
+          this.pushEachEntry(r, nid, attrName, key, cachedNode);
+          return;
         }
+        const newStack = stack.enter(value, bindings, false);
+        const dom = this.renderView(view, newStack);
+        this.pushEachEntry(r, nid, attrName, key, dom);
+        if (enricher)
+          this.cache.set2(it, value, cacheKey, dom);
+        else
+          this.cache.set(value, cacheKey, dom);
       }
-      if (textChild) {
-        checkConsistentAttrVal(lx, textChild, fields, proto, computed, scope, alter, referencedAlters, referencedComputed);
-      }
-    }
-    for (const node of view.ctx.nodes) {
-      if (node.val) {
-        checkConsistentAttrVal(lx, node.val, fields, proto, computed, scope, alter, referencedAlters, referencedComputed);
+    });
+    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)}§`);
   }
 }
-function checkUnreferencedAlterHandlers(lx, Comp, referencedAlters) {
-  for (const name in Comp.alter) {
-    if (!referencedAlters.has(name)) {
-      lx.hint(ALT_HANDLER_NOT_REFERENCED, { name });
+var imIndexedIter = (seq, visit) => {
+  let i = 0;
+  for (const v of seq)
+    visit(i++, v, "si");
+};
+var imKeyedIter = (seq, visit) => {
+  for (const [k, v] of seq.toSeq().entries())
+    visit(k, v, "sk");
+};
+var unkIter = () => {};
+var seqInfoByClass = new Map;
+
+// extra/klist.js
+class KList {
+  constructor(items = Map2(), order = List()) {
+    this.items = items;
+    this.order = order;
+    this.$ = 0;
+  }
+  _clonish(items, order) {
+    return new KList(items, order, this.$);
+  }
+  toJS() {
+    return this.order.toArray().map((k) => this.items.get(k));
+  }
+  set(k, v) {
+    const newOrder = this.items.has(k) ? this.order : this.order.push(k);
+    return this._clonish(this.items.set(k, v), newOrder, this.$);
+  }
+  get(k, dval = null) {
+    return this.items.get(k, dval);
+  }
+  _nextFreeKey() {
+    let cur = this.$;
+    while (true) {
+      const key = `§${cur}§`;
+      if (!this.items.has(key)) {
+        return [key, cur];
+      }
+      cur += 1;
     }
   }
-}
-function checkUnreferencedInputHandlers(lx, Comp, referencedInputs) {
-  for (const name in Comp.input) {
-    if (!referencedInputs.has(name)) {
-      lx.hint(INPUT_HANDLER_NOT_REFERENCED, { name });
+  push(v) {
+    const [key, next$] = this._nextFreeKey();
+    const newKList = this.set(key, v);
+    newKList.$ = next$;
+    return newKList;
+  }
+  get size() {
+    return this.items.size;
+  }
+  delete(k) {
+    if (this.items.has(k)) {
+      const newOrder = this.order.delete(this.order.indexOf(k));
+      return this._clonish(this.items.delete(k), newOrder);
     }
+    return this;
   }
-}
-function checkUnreferencedComputed(lx, Comp, referencedComputed) {
-  for (const name in Comp.computed) {
-    if (!referencedComputed.has(name)) {
-      lx.hint(COMPUTED_NOT_REFERENCED, { name });
+  moveKeyBeforeKey(k1, k2) {
+    const { order } = this;
+    return this.moveKeyIndexToIndex(order.indexOf(k1), order.indexOf(k2), 0);
+  }
+  moveKeyAfterKey(k1, k2) {
+    const { order } = this;
+    return this.moveKeyIndexToIndex(order.indexOf(k1), order.indexOf(k2), 1);
+  }
+  moveKeyIndexToIndex(source, target, offset) {
+    if (source === -1 || target === -1 || source === target) {
+      return this;
     }
+    const { order } = this;
+    const newPos = target + offset;
+    const oldPos = newPos < source ? source + 1 : source;
+    const newOrder = order.insert(newPos, order.get(source)).delete(oldPos);
+    return this._clonish(this.items, newOrder);
   }
 }
+var klistCoercer = (_) => null;
 
-class LintContext {
-  constructor() {
-    this.reports = [];
-  }
-  error(id, info) {
-    this.report(id, info, LEVEL_ERROR);
+class CheckTypeKList {
+  isValid(v) {
+    return v instanceof KList;
   }
-  warn(id, info) {
-    this.report(id, info, LEVEL_WARN);
+  getMessage(_v) {
+    return "KList expected";
   }
-  hint(id, info) {
-    this.report(id, info, LEVEL_HINT);
+}
+var CHECK_TYPE_KLIST = new CheckTypeKList;
+
+class FieldKList extends Field {
+  constructor(name, defaultValue = new KList) {
+    super("KList", name, CHECK_TYPE_KLIST, klistCoercer, defaultValue);
   }
-  report(id, info = {}, level = LEVEL_ERROR) {
-    this.reports.push({ id, info, level });
+  extendProtoForType(proto, uname) {
+    extendProtoForKeyed(proto, this.name, uname);
+    const { name } = this;
+    extendProtoForKeyed(proto, name, uname);
+    proto[`pushIn${uname}`] = function(v) {
+      return this.set(name, this.get(name).push(v));
+    };
   }
 }
+fieldsByClass.set(KList, FieldKList);
+seqInfoByClass.set(KList, (seq, visit) => {
+  for (const k of seq.order)
+    visit(k, seq.items.get(k), "data-sk");
+});
+// index.js
+var css = String.raw;
+var html = String.raw;
+var macro = (defaults, rawView) => new Macro(defaults, rawView);
+function tutuca(nodeOrSelector) {
+  const rootNode = typeof nodeOrSelector === "string" ? document.querySelector(nodeOrSelector) : nodeOrSelector;
+  const comps = new Components;
+  const renderer = new Renderer(comps);
+  return new App(rootNode, comps, renderer, ParseContext);
+}
 
-class LintParseContext extends ParseContext {
-  constructor(DOMParser, Text, Comment) {
-    super(DOMParser, Text, Comment);
-    this.attrs = [];
-  }
-  onAttributes(attrs, wrapperAttrs, textChild) {
-    this.attrs.push({ attrs, wrapperAttrs, textChild });
+// extra.js
+async function compileClassesToStyle(app, compileClasses, styleId = "margaui-css") {
+  const t1 = performance.now();
+  const css2 = await compileClassesToStyleText(app, compileClasses);
+  const t2 = performance.now();
+  injectCss(styleId, css2);
+  return t2 - t1;
+}
+async function compileClassesToStyleText(app, compileClasses, extraCSSClasses, Ctx = ParseCtxClassSetCollector) {
+  app.ParseContext = Ctx;
+  app.compile();
+  const classes = new Set(extraCSSClasses ?? []);
+  for (const Comp of app.comps.byId.values()) {
+    for (const key in Comp.views) {
+      const view = Comp.views[key];
+      for (const name of view.ctx.classes)
+        classes.add(name);
+    }
   }
+  return await compileClasses(Array.from(classes));
 }
 // tools/core/results.js
 class ComponentDocs {
@@ -8407,47 +8492,41 @@ function docComponents(normalized, { name = null } = {}) {
   const picked = name === null ? comps : comps.filter((c) => c.name === name);
   return new ComponentDocs({ items: getComponentsDocs(picked) });
 }
-// tools/format/lint.js
-function lintIdToMessage(id, info) {
-  switch (id) {
-    case "RENDER_IT_OUTSIDE_OF_LOOP":
-      return "render-it used outside of a loop";
-    case "UNKNOWN_EVENT_MODIFIER":
-      return `Unknown modifier '${info.modifier}' on '${info.name}' event`;
-    case "UNKNOWN_HANDLER_ARG_NAME":
-      return `Unknown handler argument '${info.name}'`;
-    case "INPUT_HANDLER_NOT_IMPLEMENTED":
-      return `Input handler '${info.name}' is not implemented`;
-    case "INPUT_HANDLER_NOT_REFERENCED":
-      return `Input handler '${info.name}' is defined but not referenced`;
-    case "INPUT_HANDLER_METHOD_NOT_IMPLEMENTED":
-      return `Method '.${info.name}' is not implemented`;
-    case "INPUT_HANDLER_FOR_INPUT_HANDLER_METHOD":
-      return `'${info.name}' exists as input handler — use without '.' prefix`;
-    case "INPUT_HANDLER_METHOD_FOR_INPUT_HANDLER":
-      return `'${info.name}' exists as method — use with '.' prefix`;
-    case "FIELD_VAL_NOT_DEFINED":
-      return `Field '.${info.name}' is not defined`;
-    case "COMPUTED_VAL_NOT_DEFINED":
-      return `Computed property '$${info.name}' is not defined`;
-    case "COMPUTED_NOT_REFERENCED":
-      return `Computed property '$${info.name}' is defined but not referenced`;
-    case "UNKNOWN_REQUEST_NAME":
-      return `Unknown request '!${info.name}'`;
-    case "UNKNOWN_COMPONENT_NAME":
-      return `Unknown component '${info.name}'`;
-    case "ALT_HANDLER_NOT_DEFINED":
-      return `Alter handler '${info.name}' is not defined`;
-    case "ALT_HANDLER_NOT_REFERENCED":
-      return `Alter handler '${info.name}' is defined but not referenced`;
-    case "LINT_ERROR":
-      return info.message;
-    default:
-      return id;
+
+// dev.js
+function check(app) {
+  const counts = { error: 0, warn: 0, hint: 0 };
+  for (const Comp of app.comps.byId.values()) {
+    const shadowViews = {};
+    for (const name in Comp.views) {
+      const ctx = new LintParseContext;
+      ANode.parse(Comp.views[name].rawView, ctx);
+      ctx.compile(Comp.scope);
+      shadowViews[name] = { name, ctx };
+    }
+    const shadowComp = Object.create(Comp);
+    shadowComp.views = shadowViews;
+    const { reports } = checkComponent(shadowComp);
+    if (reports.length === 0)
+      continue;
+    console.group(Comp.name);
+    for (const r of reports) {
+      counts[r.level]++;
+      const line = `[${r.level}] ${lintIdToMessage(r.id, r.info)}`;
+      if (r.level === "error")
+        console.error(line);
+      else if (r.level === "warn")
+        console.warn(line);
+      else
+        console.log(line);
+    }
+    console.groupEnd();
   }
+  const total = counts.error + counts.warn + counts.hint;
+  console.log(total === 0 ? "check: no issues" : `check: ${counts.error} error, ${counts.warn} warn, ${counts.hint} hint`);
+  return counts;
 }
 
-// dev.js
 class LintClassCollectorCtx extends ParseCtxClassSetCollector {
   constructor(...args) {
     super(...args);
@@ -8518,6 +8597,7 @@ export {
   compileClassesToStyle,
   checkView,
   checkComponent,
+  check,
   UNKNOWN_REQUEST_NAME,
   UNKNOWN_HANDLER_ARG_NAME,
   UNKNOWN_EVENT_MODIFIER,