tutuca 0.9.32 → 0.9.34

package/dist/tutuca-cli.js

@@ -734,9 +734,11 @@ class ValParser {
     const charCode = s.charCodeAt(0);
     switch (charCode) {
       case 94: {
-        const newS = px.frame.macroVars?.[s.slice(1)];
+        const name = s.slice(1);
+        const newS = px.frame.macroVars?.[name];
         if (newS !== undefined)
           return this.parse(newS, px);
+        px.onParseIssue("bad-value", { role: "macro-var", name, value: s });
         return null;
       }
       case 39:
@@ -1057,6 +1059,8 @@ class AttrParser {
       this.attrs ??= [];
       this.attrs.push(new Attr(name, val));
       this.hasDynamic ||= !(val instanceof ConstVal);
+    } else {
+      this.px.onParseIssue("bad-value", { role: "attr", attr: name, value });
     }
   }
   pushWrapper(name, raw, val) {
@@ -1072,6 +1076,9 @@ class AttrParser {
       this.attrs ??= [];
       this.attrs.push(this.ifAttr);
       this.hasDynamic = true;
+    } else {
+      const info = { role: "if", attr: directiveName.slice(3), value };
+      this.px.onParseIssue("bad-value", info);
     }
   }
   parseThen(s) {
@@ -1094,36 +1101,44 @@ class AttrParser {
       this.events.add(eventName, handler, modifiers);
     }
   }
+  _parseDirectiveValue(directiveName, s, parserFn) {
+    const val = parserFn.call(vp, s, this.px);
+    if (val === null) {
+      const info = { role: "directive", directive: directiveName, value: s };
+      this.px.onParseIssue("bad-value", info);
+    }
+    return val;
+  }
   parseDirective(s, directiveName) {
     switch (directiveName) {
       case "dangerouslysetinnerhtml":
         this.attrs ??= [];
-        this.attrs.push(new RawHtmlAttr(vp.parseText(s, this.px)));
+        this.attrs.push(new RawHtmlAttr(this._parseDirectiveValue(directiveName, s, vp.parseText)));
         this.hasDynamic = true;
         return;
       case "slot":
         this.pushWrapper("slot", s, vp.const(s));
         return;
       case "push-view":
-        this.pushWrapper("push-view", s, vp.parseText(s, this.px));
+        this.pushWrapper("push-view", s, this._parseDirectiveValue(directiveName, s, vp.parseText));
         return;
       case "text":
-        this.textChild = vp.parseText(s, this.px);
+        this.textChild = this._parseDirectiveValue(directiveName, s, vp.parseText);
         return;
       case "show":
-        this.pushWrapper("show", s, vp.parseCondValue(s, this.px));
+        this.pushWrapper("show", s, this._parseDirectiveValue(directiveName, s, vp.parseCondValue));
         return;
       case "hide":
-        this.pushWrapper("hide", s, vp.parseCondValue(s, this.px));
+        this.pushWrapper("hide", s, this._parseDirectiveValue(directiveName, s, vp.parseCondValue));
         return;
       case "each":
-        this.eachAttr = this.pushWrapper("each", s, vp.parseEach(s, this.px));
+        this.eachAttr = this.pushWrapper("each", s, this._parseDirectiveValue(directiveName, s, vp.parseEach));
         return;
       case "enrich-with":
         if (this.eachAttr !== null) {
-          this.eachAttr.enrichWithVal = vp.parseAlter(s, this.px);
+          this.eachAttr.enrichWithVal = this._parseDirectiveValue(directiveName, s, vp.parseAlter);
         } else {
-          this.pushWrapper("scope", s, vp.parseAlter(s, this.px));
+          this.pushWrapper("scope", s, this._parseDirectiveValue(directiveName, s, vp.parseAlter));
         }
         return;
       case "when":
@@ -1147,16 +1162,18 @@ class AttrParser {
       this.parseThen(s);
     else if (directiveName.startsWith("else."))
       this.parseElse(s);
-    else
-      this.px.onParseIssue("unknown-directive", { name: directiveName, value: s });
+    else {
+      const info = { name: directiveName, value: s };
+      this.px.onParseIssue("unknown-directive", info);
+    }
   }
   _parseWhen(s) {
     if (this.eachAttr !== null)
-      this.eachAttr.whenVal = vp.parseAlter(s, this.px);
+      this.eachAttr.whenVal = this._parseDirectiveValue("when", s, vp.parseAlter);
   }
   _parseLoopWith(s) {
     if (this.eachAttr !== null)
-      this.eachAttr.loopWithVal = vp.parseAlter(s, this.px);
+      this.eachAttr.loopWithVal = this._parseDirectiveValue("loop-with", s, vp.parseAlter);
   }
   parse(attributes, parseAll = false) {
     for (const { name, value } of attributes) {
@@ -1202,13 +1219,22 @@ class EventHandler {
   static parse(s, px) {
     const [handlerName, ...rawArgs] = s.trim().split(/\s+/);
     const handlerVal = vp.parseHandlerName(handlerName, px);
-    if (handlerVal === null)
+    if (handlerVal === null) {
+      const info = { role: "handler-name", value: handlerName };
+      px.onParseIssue("bad-value", info);
       return null;
+    }
     const args = new Array(rawArgs.length);
     vp.allowHandlerArg();
     for (let i = 0;i < rawArgs.length; i++) {
       const val = vp.parse(rawArgs[i], px);
-      args[i] = val !== null ? val : vp.nullConstVal;
+      if (val !== null) {
+        args[i] = val;
+      } else {
+        const info = { role: "handler-arg", value: rawArgs[i] };
+        px.onParseIssue("bad-value", info);
+        args[i] = vp.nullConstVal;
+      }
     }
     return new EventHandler(handlerVal, args);
   }
@@ -1334,6 +1360,50 @@ function optimizeNode(node) {
   node.optimize();
   return node;
 }
+function parseXOp(attrs, childs, opIdx, px) {
+  if (attrs.length === 0)
+    return maybeFragment(childs);
+  const { name, value } = attrs[opIdx];
+  const as = attrs.getNamedItem("as")?.value ?? null;
+  let node;
+  switch (name) {
+    case "slot":
+      node = new SlotNode(null, vp.const(value), maybeFragment(childs));
+      break;
+    case "text":
+      node = px.addNodeIf(RenderTextNode, parseXOpVal(name, value, px, vp.parseText));
+      break;
+    case "render":
+      node = px.addNodeIf(RenderNode, parseXOpVal(name, value, px, vp.parseRender), as);
+      break;
+    case "render-it":
+      node = px.addNodeIf(RenderItNode, vp.bindValIt, as);
+      break;
+    case "render-each":
+      node = RenderEachNode.parse(px, vp, value, as, attrs);
+      break;
+    case "show": {
+      const val = parseXOpVal(name, value, px, vp.parseCondValue);
+      node = px.addNodeIf(ShowNode, val, maybeFragment(childs));
+      break;
+    }
+    case "hide": {
+      const val = parseXOpVal(name, value, px, vp.parseCondValue);
+      node = px.addNodeIf(HideNode, val, maybeFragment(childs));
+      break;
+    }
+    default:
+      px.onParseIssue("unknown-x-op", { name, value });
+      return new CommentNode(`Error: InvalidSpecialTagOp ${name}=${value}`);
+  }
+  return processXExtras(node, attrs, name, opIdx + 1, px);
+}
+function parseXOpVal(opName, value, px, parserFn) {
+  const val = parserFn.call(vp, value, px);
+  if (val === null)
+    px.onParseIssue("bad-value", { role: "x-op", op: opName, value });
+  return val;
+}
 function processXExtras(node, attrs, opName, startIdx, px) {
   const consumed = X_OP_CONSUMED[opName];
   const wrappable = X_OP_WRAPPABLE.has(opName);
@@ -1408,6 +1478,7 @@ class ParseContext {
     this.Text = Text ?? globalThis.Text;
     this.Comment = Comment ?? globalThis.Comment;
     this.cacheConstNodes = true;
+    this.currentTag = null;
   }
   isInsideMacro(name) {
     return this.frame.macroName === name || this.parent?.isInsideMacro(name);
@@ -1463,7 +1534,7 @@ class ParseContext {
   getNodeForId(id) {
     return this.nodes[id] ?? null;
   }
-  onAttributes(_attrs, _wrapperAttrs, _textChild, _isMacroCall) {}
+  onAttributes(_attrs, _wrapperAttrs, _textChild, _isMacroCall, _tag) {}
   onParseIssue(kind, info) {
     console.warn(`tutuca parse issue [${kind}]`, info);
   }
@@ -1665,62 +1736,39 @@ var init_anode = __esm(() => {
       else if (node instanceof px.Comment)
         return new CommentNode(node.textContent);
       const { childNodes, attributes: attrs, tagName: tag } = node;
-      const childs = new Array(childNodes.length);
-      for (let i = 0;i < childNodes.length; i++)
-        childs[i] = ANode.fromDOM(childNodes[i], px);
-      const isPseudoX = attrs[0]?.name === "@x";
-      if (tag === "X" || isPseudoX) {
-        if (attrs.length === 0)
-          return maybeFragment(childs);
-        const opIdx = isPseudoX ? 1 : 0;
-        const { name, value } = attrs[opIdx];
-        const as = attrs.getNamedItem("as")?.value ?? null;
-        let node2;
-        switch (name) {
-          case "slot":
-            node2 = new SlotNode(null, vp.const(value), maybeFragment(childs));
-            break;
-          case "text":
-            node2 = px.addNodeIf(RenderTextNode, vp.parseText(value, px));
-            break;
-          case "render":
-            node2 = px.addNodeIf(RenderNode, vp.parseRender(value, px), as);
-            break;
-          case "render-it":
-            node2 = px.addNodeIf(RenderItNode, vp.bindValIt, as);
-            break;
-          case "render-each":
-            node2 = RenderEachNode.parse(px, vp, value, as, attrs);
-            break;
-          case "show":
-            node2 = px.addNodeIf(ShowNode, vp.parseCondValue(value, px), maybeFragment(childs));
-            break;
-          case "hide":
-            node2 = px.addNodeIf(HideNode, vp.parseCondValue(value, px), maybeFragment(childs));
-            break;
-          default:
-            px.onParseIssue("unknown-x-op", { name, value });
-            return new CommentNode(`Error: InvalidSpecialTagOp ${name}=${value}`);
-        }
-        return processXExtras(node2, attrs, name, (isPseudoX ? 1 : 0) + 1, px);
-      } else if (tag.charCodeAt(1) === 58 && tag.charCodeAt(0) === 88) {
-        const macroName = tag.slice(2).toLowerCase();
-        if (macroName === "slot") {
-          const slotName = attrs.getNamedItem("name")?.value ?? "_";
-          return px.frame.macroSlots[slotName] ?? maybeFragment(childs);
+      const childs = [];
+      for (let i = 0;i < childNodes.length; i++) {
+        const child = ANode.fromDOM(childNodes[i], px);
+        if (child !== null)
+          childs.push(child);
+      }
+      const prevTag = px.currentTag;
+      px.currentTag = tag;
+      try {
+        const isPseudoX = attrs[0]?.name === "@x";
+        if (tag === "X" || isPseudoX) {
+          return parseXOp(attrs, childs, isPseudoX ? 1 : 0, px);
+        } else if (tag.charCodeAt(1) === 58 && tag.charCodeAt(0) === 88) {
+          const macroName = tag.slice(2).toLowerCase();
+          if (macroName === "slot") {
+            const slotName = attrs.getNamedItem("name")?.value ?? "_";
+            return px.frame.macroSlots[slotName] ?? maybeFragment(childs);
+          }
+          const [nAttrs, wrappers] = Attributes.parse(attrs, px, true);
+          px.onAttributes(nAttrs, wrappers, null, true, tag);
+          return wrap(px.newMacroNode(macroName, nAttrs.toMacroVars(), childs), px, wrappers);
+        } else if (VALID_NODE_RE.test(tag)) {
+          const [nAttrs, wrappers, textChild] = Attributes.parse(attrs, px);
+          px.onAttributes(nAttrs, wrappers, textChild, false, tag);
+          if (textChild)
+            childs.unshift(new RenderTextNode(null, textChild));
+          const domChilds = tag !== "PRE" ? condenseChildsWhites(childs) : childs;
+          return wrap(new DomNode(tag, nAttrs, domChilds), px, wrappers);
         }
-        const [nAttrs, wrappers] = Attributes.parse(attrs, px, true);
-        px.onAttributes(nAttrs, wrappers, null, true);
-        return wrap(px.newMacroNode(macroName, nAttrs.toMacroVars(), childs), px, wrappers);
-      } else if (VALID_NODE_RE.test(tag)) {
-        const [nAttrs, wrappers, textChild] = Attributes.parse(attrs, px);
-        px.onAttributes(nAttrs, wrappers, textChild);
-        if (textChild)
-          childs.unshift(new RenderTextNode(null, textChild));
-        const domChilds = tag !== "PRE" ? condenseChildsWhites(childs) : childs;
-        return wrap(new DomNode(tag, nAttrs, domChilds), px, wrappers);
+        return new CommentNode(`Error: InvalidTagName ${tag}`);
+      } finally {
+        px.currentTag = prevTag;
       }
-      return new CommentNode(`Error: InvalidTagName ${tag}`);
     }
   };
   MacroNode = class MacroNode extends BaseNode {
@@ -1788,7 +1836,7 @@ var init_anode = __esm(() => {
       return rx.renderEach(stack, this.iterInfo, this.nodeId, this.viewId);
     }
     static parse(px, vp2, s, as, attrs) {
-      const node = px.addNodeIf(RenderEachNode, vp2.parseEach(s, px), as);
+      const node = px.addNodeIf(RenderEachNode, parseXOpVal("render-each", s, px, vp2.parseEach), as);
       if (node !== null) {
         const attrParser = getAttrParser(px);
         attrParser.eachAttr = attrParser.pushWrapper("each", s, node.val);
@@ -2171,7 +2219,8 @@ function checkMacroCallArgs(lx, view, Comp) {
       if (!(argName in defaults)) {
         lx.error(UNKNOWN_MACRO_ARG, {
           name: argName,
-          macroName: macroNode.name
+          macroName: macroNode.name,
+          tag: `x:${macroNode.name}`
         });
       }
     }
@@ -2225,7 +2274,13 @@ function checkEventModifiers(lx, view) {
       const modWrappers = MOD_WRAPPERS_BY_EVENT[name] ?? NO_WRAPPERS;
       for (const modifier of modifiers) {
         if (modWrappers[modifier] === undefined) {
-          lx.error(UNKNOWN_EVENT_MODIFIER, { name, modifier, handler, event });
+          lx.error(UNKNOWN_EVENT_MODIFIER, {
+            name,
+            modifier,
+            handler,
+            event,
+            originAttr: `@on.${name}+${modifiers.join("+")}`
+          });
         }
       }
     }
@@ -2240,10 +2295,16 @@ function checkKnownHandlerNames(lx, view, Comp, referencedAlters, referencedComp
   const { fields } = Class.getMetaClass();
   for (const event of view.ctx.events) {
     for (const handler of event.handlers) {
-      const { args } = handler.handlerCall;
+      const { args, handlerVal } = handler.handlerCall;
+      const handlerName = handlerVal?.name;
+      const eventName = handler.name;
+      const errCtx = {
+        eventName,
+        handlerName,
+        originAttr: `@on.${eventName}`
+      };
       for (let i = 0;i < args.length; i++) {
-        const arg = args[i];
-        checkConsistentAttrVal(lx, arg, fields, proto, computed, scope, alter, referencedAlters, referencedComputed);
+        checkConsistentAttrVal(lx, args[i], fields, proto, computed, scope, alter, referencedAlters, referencedComputed, false, { ...errCtx, argIndex: i });
       }
     }
   }
@@ -2258,19 +2319,25 @@ function checkEventHandlersHaveImpls(lx, Comp, referencedInputs) {
         for (const handler of event.handlers) {
           const { handlerVal } = handler.handlerCall;
           const hvName = handlerVal?.constructor.name;
+          const eventName = handler.name;
+          const originAttr = `@on.${eventName}`;
           if (hvName === "InputHandlerNameVal") {
             referencedInputs?.add(handlerVal.name);
             if (input[handlerVal.name] === undefined) {
               lx.error(INPUT_HANDLER_NOT_IMPLEMENTED, {
                 name: handlerVal.name,
                 handler,
-                event
+                event,
+                eventName,
+                originAttr
               });
               if (proto[handlerVal.name] !== undefined) {
                 lx.hint(INPUT_HANDLER_METHOD_FOR_INPUT_HANDLER, {
                   name: handlerVal.name,
                   handler,
-                  event
+                  event,
+                  eventName,
+                  originAttr
                 });
               }
             }
@@ -2280,13 +2347,17 @@ function checkEventHandlersHaveImpls(lx, Comp, referencedInputs) {
               lx.error(INPUT_HANDLER_METHOD_NOT_IMPLEMENTED, {
                 name: handlerVal.name,
                 handler,
-                event
+                event,
+                eventName,
+                originAttr
               });
               if (input[handlerVal.name] !== undefined) {
                 lx.hint(INPUT_HANDLER_FOR_INPUT_HANDLER_METHOD, {
                   name: handlerVal.name,
                   handler,
-                  event
+                  event,
+                  eventName,
+                  originAttr
                 });
               }
             }
@@ -2296,47 +2367,68 @@ function checkEventHandlersHaveImpls(lx, Comp, referencedInputs) {
     });
   }
 }
-function checkConsistentAttrVal(lx, val, fields, proto, computed, scope, alter, referencedAlters, referencedComputed, skipNameVal = false) {
+function checkConsistentAttrVal(lx, val, fields, proto, computed, scope, alter, referencedAlters, referencedComputed, skipNameVal = false, errCtx = null) {
   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 });
+      lx.error(FIELD_VAL_NOT_DEFINED, { ...errCtx, val, name });
     }
   } else if (valName === "ComputedVal") {
     const { name } = val;
     referencedComputed?.add(name);
     if (computed[name] === undefined) {
-      lx.error(COMPUTED_VAL_NOT_DEFINED, { val, name });
+      lx.error(COMPUTED_VAL_NOT_DEFINED, { ...errCtx, val, name });
     }
   } else if (valName === "SeqAccessVal") {
-    checkConsistentAttrVal(lx, val.seqVal, fields, proto, computed, scope, alter, referencedAlters, referencedComputed, skipNameVal);
-    checkConsistentAttrVal(lx, val.keyVal, fields, proto, computed, scope, alter, referencedAlters, referencedComputed, skipNameVal);
+    checkConsistentAttrVal(lx, val.seqVal, fields, proto, computed, scope, alter, referencedAlters, referencedComputed, skipNameVal, errCtx);
+    checkConsistentAttrVal(lx, val.keyVal, fields, proto, computed, scope, alter, referencedAlters, referencedComputed, skipNameVal, errCtx);
   } else if (valName === "RequestVal") {
     if (scope.lookupRequest(val.name) === null) {
-      lx.error(UNKNOWN_REQUEST_NAME, { name: val.name });
+      lx.error(UNKNOWN_REQUEST_NAME, { ...errCtx, name: val.name });
     }
   } else if (valName === "TypeVal") {
     if (scope.lookupComponent(val.name) === null) {
-      lx.error(UNKNOWN_COMPONENT_NAME, { name: val.name });
+      lx.error(UNKNOWN_COMPONENT_NAME, { ...errCtx, name: val.name });
     }
   } else if (valName === "NameVal") {
     if (!skipNameVal && !isKnownHandlerName(val.name)) {
-      lx.error(UNKNOWN_HANDLER_ARG_NAME, { name: val.name });
+      lx.error(UNKNOWN_HANDLER_ARG_NAME, { ...errCtx, name: val.name });
     }
   } else if (valName === "StrTplVal") {
     for (const subVal of val.vals) {
-      checkConsistentAttrVal(lx, subVal, fields, proto, computed, scope, alter, referencedAlters, referencedComputed, skipNameVal);
+      checkConsistentAttrVal(lx, subVal, fields, proto, computed, scope, alter, referencedAlters, referencedComputed, skipNameVal, errCtx);
     }
   } else if (valName === "AlterHandlerNameVal") {
     referencedAlters?.add(val.name);
     if (alter[val.name] === undefined) {
-      lx.error(ALT_HANDLER_NOT_DEFINED, { name: val.name });
+      lx.error(ALT_HANDLER_NOT_DEFINED, { ...errCtx, name: val.name });
     }
   } else if (valName !== "ConstVal" && valName !== "BindVal" && valName !== "DynVal") {
     console.log(val);
   }
 }
+function nodeCtxForNode(nodeKind) {
+  return NODE_KIND_TO_CTX[nodeKind] ?? null;
+}
+function attrSourceLabel(attr) {
+  const cn = attr.constructor.name;
+  if (cn === "ConstAttr")
+    return "literal";
+  if (cn === "IfAttr")
+    return `@if.${attr.name}`;
+  if (cn === "RawHtmlAttr")
+    return "@dangerouslysetinnerhtml";
+  return `:${attr.name}`;
+}
+function attrOriginAttr(attr) {
+  const cn = attr.constructor.name;
+  if (cn === "IfAttr")
+    return `@if.${attr.name}`;
+  if (cn === "RawHtmlAttr")
+    return "@dangerouslysetinnerhtml";
+  return `:${attr.name}`;
+}
 function checkConsistentAttrs(lx, Comp, referencedAlters, referencedComputed) {
   const { computed, scope, views, alter, Class } = Comp;
   const { prototype: proto } = Class;
@@ -2344,25 +2436,39 @@ function checkConsistentAttrs(lx, Comp, referencedAlters, referencedComputed) {
   for (const viewName in views) {
     lx.push({ viewName }, () => {
       const view = views[viewName];
-      for (const attr of view.ctx.attrs) {
-        const { attrs, wrapperAttrs, textChild, isMacroCall } = attr;
+      for (const entry of view.ctx.attrs) {
+        const { attrs, wrapperAttrs, textChild, isMacroCall, tag } = entry;
         if (attrs?.constructor.name === "DynAttrs") {
-          const seenNames = new Set;
-          for (const attr2 of attrs.items) {
-            const name = attr2?.name;
+          const sourcesByName = new Map;
+          for (const attr of attrs.items) {
+            const name = attr?.name;
             if (name !== undefined && name !== "data-eid") {
-              if (seenNames.has(name)) {
-                lx.error(DUPLICATE_ATTR_DEFINITION, { name });
-              } else {
-                seenNames.add(name);
-              }
+              const sources = sourcesByName.get(name);
+              const label = attrSourceLabel(attr);
+              if (sources)
+                sources.push(label);
+              else
+                sourcesByName.set(name, [label]);
             }
-            if (attr2?.constructor.name === "IfAttr") {
-              for (const subVal of [attr2.condVal, attr2.thenVal, attr2.elseVal]) {
-                checkConsistentAttrVal(lx, subVal, fields, proto, computed, scope, alter, referencedAlters, referencedComputed, isMacroCall);
+            if (attr?.constructor.name === "IfAttr") {
+              if (!attr.anyBranchIsSet) {
+                lx.error(IF_NO_BRANCH_SET, { attr: attr.name, tag });
               }
-            } else if (attr2?.val !== undefined) {
-              checkConsistentAttrVal(lx, attr2.val, fields, proto, computed, scope, alter, referencedAlters, referencedComputed, isMacroCall);
+              const branches = [
+                ["@if", attr.condVal],
+                ["@then", attr.thenVal],
+                ["@else", attr.elseVal]
+              ];
+              for (const [branch, subVal] of branches) {
+                checkConsistentAttrVal(lx, subVal, fields, proto, computed, scope, alter, referencedAlters, referencedComputed, isMacroCall, { tag, originAttr: `@if.${attr.name}`, branch });
+              }
+            } else if (attr?.val !== undefined) {
+              checkConsistentAttrVal(lx, attr.val, fields, proto, computed, scope, alter, referencedAlters, referencedComputed, isMacroCall, { tag, originAttr: attrOriginAttr(attr) });
+            }
+          }
+          for (const [name, sources] of sourcesByName) {
+            if (sources.length > 1) {
+              lx.error(DUPLICATE_ATTR_DEFINITION, { name, sources, tag });
             }
           }
         }
@@ -2370,30 +2476,35 @@ function checkConsistentAttrs(lx, Comp, referencedAlters, referencedComputed) {
           for (const w of wrapperAttrs) {
             if (w.name === "each") {
               if (w.whenVal)
-                checkConsistentAttrVal(lx, w.whenVal, fields, proto, computed, scope, alter, referencedAlters, referencedComputed);
+                checkConsistentAttrVal(lx, w.whenVal, fields, proto, computed, scope, alter, referencedAlters, referencedComputed, false, { tag, originAttr: "@when" });
               if (w.enrichWithVal)
-                checkConsistentAttrVal(lx, w.enrichWithVal, fields, proto, computed, scope, alter, referencedAlters, referencedComputed);
+                checkConsistentAttrVal(lx, w.enrichWithVal, fields, proto, computed, scope, alter, referencedAlters, referencedComputed, false, { tag, originAttr: "@enrich-with" });
               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);
+                checkConsistentAttrVal(lx, w.loopWithVal, fields, proto, computed, scope, alter, referencedAlters, referencedComputed, false, { tag, originAttr: "@loop-with" });
+            } else {
+              const originAttr = w.name === "scope" ? "@enrich-with" : `@${w.name}`;
+              checkConsistentAttrVal(lx, w.val, fields, proto, computed, scope, alter, referencedAlters, referencedComputed, false, { tag, originAttr });
             }
           }
         }
         if (textChild) {
-          checkConsistentAttrVal(lx, textChild, fields, proto, computed, scope, alter, referencedAlters, referencedComputed);
+          checkConsistentAttrVal(lx, textChild, fields, proto, computed, scope, alter, referencedAlters, referencedComputed, false, { tag, originAttr: "@text" });
         }
       }
       for (const node of view.ctx.nodes) {
+        const nodeKind = node.constructor.name;
+        if (nodeKind === "ScopeNode")
+          continue;
+        const baseCtx = nodeCtxForNode(nodeKind);
         if (node.val) {
-          checkConsistentAttrVal(lx, node.val, fields, proto, computed, scope, alter, referencedAlters, referencedComputed);
+          checkConsistentAttrVal(lx, node.val, fields, proto, computed, scope, alter, referencedAlters, referencedComputed, false, baseCtx);
         }
-        if (node.constructor.name === "RenderEachNode") {
+        if (nodeKind === "RenderEachNode") {
           const iter = node.iterInfo;
           if (iter.whenVal)
-            checkConsistentAttrVal(lx, iter.whenVal, fields, proto, computed, scope, alter, referencedAlters, referencedComputed);
+            checkConsistentAttrVal(lx, iter.whenVal, fields, proto, computed, scope, alter, referencedAlters, referencedComputed, false, { originAttr: "<x render-each when>" });
           if (iter.loopWithVal)
-            checkConsistentAttrVal(lx, iter.loopWithVal, fields, proto, computed, scope, alter, referencedAlters, referencedComputed);
+            checkConsistentAttrVal(lx, iter.loopWithVal, fields, proto, computed, scope, alter, referencedAlters, referencedComputed, false, { originAttr: "<x render-each loop-with>" });
         }
       }
     });
@@ -2448,13 +2559,14 @@ class LintContext {
     this.reports.push({ id, info, level, context: { ...this.frame } });
   }
 }
-var ALT_HANDLER_NOT_DEFINED = "ALT_HANDLER_NOT_DEFINED", ALT_HANDLER_NOT_REFERENCED = "ALT_HANDLER_NOT_REFERENCED", RENDER_IT_OUTSIDE_OF_LOOP = "RENDER_IT_OUTSIDE_OF_LOOP", UNKNOWN_EVENT_MODIFIER = "UNKNOWN_EVENT_MODIFIER", UNKNOWN_HANDLER_ARG_NAME = "UNKNOWN_HANDLER_ARG_NAME", INPUT_HANDLER_NOT_IMPLEMENTED = "INPUT_HANDLER_NOT_IMPLEMENTED", INPUT_HANDLER_NOT_REFERENCED = "INPUT_HANDLER_NOT_REFERENCED", INPUT_HANDLER_METHOD_NOT_IMPLEMENTED = "INPUT_HANDLER_METHOD_NOT_IMPLEMENTED", INPUT_HANDLER_FOR_INPUT_HANDLER_METHOD = "INPUT_HANDLER_FOR_INPUT_HANDLER_METHOD", INPUT_HANDLER_METHOD_FOR_INPUT_HANDLER = "INPUT_HANDLER_METHOD_FOR_INPUT_HANDLER", FIELD_VAL_NOT_DEFINED = "FIELD_VAL_NOT_DEFINED", COMPUTED_VAL_NOT_DEFINED = "COMPUTED_VAL_NOT_DEFINED", COMPUTED_NOT_REFERENCED = "COMPUTED_NOT_REFERENCED", DUPLICATE_ATTR_DEFINITION = "DUPLICATE_ATTR_DEFINITION", UNKNOWN_REQUEST_NAME = "UNKNOWN_REQUEST_NAME", UNKNOWN_COMPONENT_NAME = "UNKNOWN_COMPONENT_NAME", UNKNOWN_MACRO_ARG = "UNKNOWN_MACRO_ARG", UNKNOWN_DIRECTIVE = "UNKNOWN_DIRECTIVE", UNKNOWN_X_OP = "UNKNOWN_X_OP", UNKNOWN_X_ATTR = "UNKNOWN_X_ATTR", MAYBE_DROP_AT_PREFIX = "MAYBE_DROP_AT_PREFIX", PARSE_ISSUE_KIND_TO_LINT_ID, X_KNOWN_OP_NAMES, X_KNOWN_ATTR_NAMES, AT_PREFIX_HINT_KNOWN_BY_KIND, LEVEL_WARN = "warn", LEVEL_ERROR = "error", LEVEL_HINT = "hint", NO_WRAPPERS, KNOWN_HANDLER_NAMES, LintParseContext;
+var ALT_HANDLER_NOT_DEFINED = "ALT_HANDLER_NOT_DEFINED", ALT_HANDLER_NOT_REFERENCED = "ALT_HANDLER_NOT_REFERENCED", RENDER_IT_OUTSIDE_OF_LOOP = "RENDER_IT_OUTSIDE_OF_LOOP", UNKNOWN_EVENT_MODIFIER = "UNKNOWN_EVENT_MODIFIER", UNKNOWN_HANDLER_ARG_NAME = "UNKNOWN_HANDLER_ARG_NAME", INPUT_HANDLER_NOT_IMPLEMENTED = "INPUT_HANDLER_NOT_IMPLEMENTED", INPUT_HANDLER_NOT_REFERENCED = "INPUT_HANDLER_NOT_REFERENCED", INPUT_HANDLER_METHOD_NOT_IMPLEMENTED = "INPUT_HANDLER_METHOD_NOT_IMPLEMENTED", INPUT_HANDLER_FOR_INPUT_HANDLER_METHOD = "INPUT_HANDLER_FOR_INPUT_HANDLER_METHOD", INPUT_HANDLER_METHOD_FOR_INPUT_HANDLER = "INPUT_HANDLER_METHOD_FOR_INPUT_HANDLER", FIELD_VAL_NOT_DEFINED = "FIELD_VAL_NOT_DEFINED", COMPUTED_VAL_NOT_DEFINED = "COMPUTED_VAL_NOT_DEFINED", COMPUTED_NOT_REFERENCED = "COMPUTED_NOT_REFERENCED", DUPLICATE_ATTR_DEFINITION = "DUPLICATE_ATTR_DEFINITION", IF_NO_BRANCH_SET = "IF_NO_BRANCH_SET", UNKNOWN_REQUEST_NAME = "UNKNOWN_REQUEST_NAME", UNKNOWN_COMPONENT_NAME = "UNKNOWN_COMPONENT_NAME", UNKNOWN_MACRO_ARG = "UNKNOWN_MACRO_ARG", UNKNOWN_DIRECTIVE = "UNKNOWN_DIRECTIVE", UNKNOWN_X_OP = "UNKNOWN_X_OP", UNKNOWN_X_ATTR = "UNKNOWN_X_ATTR", MAYBE_DROP_AT_PREFIX = "MAYBE_DROP_AT_PREFIX", BAD_VALUE = "BAD_VALUE", PARSE_ISSUE_KIND_TO_LINT_ID, X_KNOWN_OP_NAMES, X_KNOWN_ATTR_NAMES, AT_PREFIX_HINT_KNOWN_BY_KIND, LEVEL_WARN = "warn", LEVEL_ERROR = "error", LEVEL_HINT = "hint", NO_WRAPPERS, KNOWN_HANDLER_NAMES, NODE_KIND_TO_CTX, LintParseContext;
 var init_lint_check = __esm(() => {
   init_anode();
   PARSE_ISSUE_KIND_TO_LINT_ID = {
     "unknown-directive": UNKNOWN_DIRECTIVE,
     "unknown-x-op": UNKNOWN_X_OP,
-    "unknown-x-attr": UNKNOWN_X_ATTR
+    "unknown-x-attr": UNKNOWN_X_ATTR,
+    "bad-value": BAD_VALUE
   };
   X_KNOWN_OP_NAMES = new Set([
     "slot",
@@ -2491,17 +2603,27 @@ var init_lint_check = __esm(() => {
     "ctx",
     "dragInfo"
   ]);
+  NODE_KIND_TO_CTX = {
+    RenderTextNode: { originAttr: "<x text>" },
+    RenderNode: { originAttr: "<x render>" },
+    RenderItNode: { originAttr: "<x render-it>" },
+    RenderEachNode: { originAttr: "<x render-each>" },
+    ShowNode: { originAttr: "<x show>" },
+    HideNode: { originAttr: "<x hide>" },
+    PushViewNameNode: { originAttr: "<x push-view>" }
+  };
   LintParseContext = class LintParseContext extends ParseContext {
     constructor(document2, Text, Comment) {
       super(document2, Text, Comment);
       this.attrs = [];
       this.parseIssues = [];
     }
-    onAttributes(attrs, wrapperAttrs, textChild, isMacroCall = false) {
-      this.attrs.push({ attrs, wrapperAttrs, textChild, isMacroCall });
+    onAttributes(attrs, wrapperAttrs, textChild, isMacroCall = false, tag = null) {
+      this.attrs.push({ attrs, wrapperAttrs, textChild, isMacroCall, tag });
     }
     onParseIssue(kind, info) {
-      this.parseIssues.push({ kind, info });
+      const tag = this.currentTag;
+      this.parseIssues.push({ kind, info: tag && info.tag === undefined ? { ...info, tag } : info });
     }
   };
 });
@@ -8467,6 +8589,121 @@ function makeFormatter(name, table) {
   };
 }
 
+// tools/format/lint.js
+function badValueMessage(info) {
+  const v = JSON.stringify(info.value);
+  switch (info.role) {
+    case "attr":
+      return `Cannot parse value ${v} for attribute ':${info.attr}'`;
+    case "directive":
+      return `Cannot parse value ${v} for directive '@${info.directive}'`;
+    case "if":
+      return `Cannot parse condition ${v} for '@if.${info.attr}'`;
+    case "x-op":
+      return `Cannot parse value ${v} for <x ${info.op}>`;
+    case "handler-name":
+      return `Cannot parse handler name ${v}`;
+    case "handler-arg":
+      return `Cannot parse handler argument ${v}`;
+    case "macro-var":
+      return `Macro variable '^${info.name}' is not defined`;
+    default:
+      return `Cannot parse value ${v}`;
+  }
+}
+function tagDisplay(tag) {
+  return tag ? String(tag).toLowerCase() : null;
+}
+function fmtTagSuffix(info) {
+  const t = tagDisplay(info?.tag);
+  return t && t !== "x" ? ` on <${t}>` : "";
+}
+function fmtOriginSuffix(info) {
+  if (!info)
+    return "";
+  const parts = [];
+  if (info.originAttr) {
+    const branch = info.branch ? `[${info.branch}]` : "";
+    parts.push(`in ${info.originAttr}${branch}`);
+  }
+  if (info.handlerName) {
+    parts.push(`handler '${info.handlerName}'${info.argIndex !== undefined ? ` arg ${info.argIndex}` : ""}`);
+  }
+  const t = tagDisplay(info.tag);
+  if (t && t !== "x")
+    parts.push(`on <${t}>`);
+  return parts.length ? ` (${parts.join(", ")})` : "";
+}
+function fmtEventSuffix(info) {
+  if (info?.originAttr)
+    return ` in ${info.originAttr}`;
+  if (info?.eventName)
+    return ` in @on.${info.eventName}`;
+  return "";
+}
+function lintIdToMessage(id, info) {
+  switch (id) {
+    case "RENDER_IT_OUTSIDE_OF_LOOP":
+      return "render-it used outside of a loop";
+    case "UNKNOWN_EVENT_MODIFIER": {
+      const mods = info.handler?.modifiers ?? [info.modifier];
+      const written = `@on.${info.name}+${mods.join("+")}`;
+      return `Unknown modifier '+${info.modifier}' in '${written}'`;
+    }
+    case "UNKNOWN_HANDLER_ARG_NAME":
+      return `Unknown handler argument '${info.name}'${fmtOriginSuffix(info)}`;
+    case "INPUT_HANDLER_NOT_IMPLEMENTED":
+      return `Input handler '${info.name}' is not implemented${fmtEventSuffix(info)}`;
+    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${fmtEventSuffix(info)}`;
+    case "INPUT_HANDLER_FOR_INPUT_HANDLER_METHOD":
+      return `'${info.name}' exists as input handler — use without '.' prefix${fmtEventSuffix(info)}`;
+    case "INPUT_HANDLER_METHOD_FOR_INPUT_HANDLER":
+      return `'${info.name}' exists as method — use with '.' prefix${fmtEventSuffix(info)}`;
+    case "FIELD_VAL_NOT_DEFINED":
+      return `Field '.${info.name}' is not defined${fmtOriginSuffix(info)}`;
+    case "COMPUTED_VAL_NOT_DEFINED":
+      return `Computed property '$${info.name}' is not defined${fmtOriginSuffix(info)}`;
+    case "COMPUTED_NOT_REFERENCED":
+      return `Computed property '$${info.name}' is defined but not referenced`;
+    case "DUPLICATE_ATTR_DEFINITION": {
+      const sources = info.sources?.length ? ` (${info.sources.join(", ")})` : "";
+      const tag = info.tag ? ` on <${String(info.tag).toLowerCase()}>` : "";
+      return `Attribute '${info.name}' is set ${info.sources?.length ?? "multiple"} times${sources}${tag}`;
+    }
+    case "IF_NO_BRANCH_SET":
+      return `'@if.${info.attr}' has no '@then' or '@else' branch — at least one must be set${fmtTagSuffix(info)}`;
+    case "UNKNOWN_REQUEST_NAME":
+      return `Unknown request '!${info.name}'${fmtOriginSuffix(info)}`;
+    case "UNKNOWN_COMPONENT_NAME":
+      return `Unknown component '${info.name}'${fmtOriginSuffix(info)}`;
+    case "ALT_HANDLER_NOT_DEFINED":
+      return `Alter handler '${info.name}' is not defined${fmtOriginSuffix(info)}`;
+    case "ALT_HANDLER_NOT_REFERENCED":
+      return `Alter handler '${info.name}' is defined but not referenced`;
+    case "UNKNOWN_MACRO_ARG":
+      return `Argument '${info.name}' is not declared in macro '${info.macroName}'`;
+    case "UNKNOWN_DIRECTIVE":
+      return `Unknown directive '@${info.name}=${JSON.stringify(info.value)}'${fmtTagSuffix(info)}`;
+    case "UNKNOWN_X_OP":
+      return `Unknown <x> op '${info.name}=${JSON.stringify(info.value)}'${fmtTagSuffix(info)}`;
+    case "UNKNOWN_X_ATTR":
+      return `Unknown attribute '${info.name}=${JSON.stringify(info.value)}' on <x ${info.op}>${fmtTagSuffix(info)}`;
+    case "MAYBE_DROP_AT_PREFIX": {
+      const written = info.value !== undefined ? `${info.name}=${JSON.stringify(info.value)}` : info.name;
+      return `Did you mean '${info.suggestion}'? Drop the '@' from '${written}' on <x>.`;
+    }
+    case "BAD_VALUE":
+      return `${badValueMessage(info)}${fmtTagSuffix(info)}`;
+    case "LINT_ERROR":
+      return info.message;
+    default:
+      return id;
+  }
+}
+
 // tools/format/cli.js
 function fmtModuleInfo(info) {
   const lines = [];
@@ -8536,15 +8773,6 @@ function fmtComponentDocs(docs) {
   return lines.join(`
 `);
 }
-function fmtFindingInfo(info) {
-  const keys = ["name", "modifier", "id"];
-  const parts = [];
-  for (const k of keys) {
-    if (info?.[k] !== undefined)
-      parts.push(`${k}=${info[k]}`);
-  }
-  return parts.join(" ");
-}
 function fmtLintReport(rep) {
   if (rep.components.length === 0)
     return "(no components)";
@@ -8557,9 +8785,8 @@ function fmtLintReport(rep) {
     lines.push(`${c.componentName}:`);
     for (const f of c.findings) {
       const tag = f.level.toUpperCase();
-      const view = f.context?.viewName ? ` view=${f.context.viewName}` : "";
-      const extra = fmtFindingInfo(f.info);
-      lines.push(`  [${tag}] ${f.id}${view}${extra ? ` (${extra})` : ""}`);
+      const view = f.context?.viewName ? ` [view=${f.context.viewName}]` : "";
+      lines.push(`  [${tag}]${view} ${lintIdToMessage(f.id, f.info)}`);
     }
   }
   lines.push("");
@@ -8706,8 +8933,8 @@ function fmtLintReport2(rep) {
       continue;
     }
     for (const f of c.findings) {
-      const view = f.context?.viewName ? ` — view: \`${f.context.viewName}\`` : "";
-      lines.push(`- **${f.level.toUpperCase()}** \`${f.id}\`${view}`);
+      const view = f.context?.viewName ? ` _(view: \`${f.context.viewName}\`)_` : "";
+      lines.push(`- **${f.level.toUpperCase()}** ${lintIdToMessage(f.id, f.info)}${view}`);
     }
     lines.push("");
   }