tutuca 0.9.106 → 0.9.108

package/dist/tutuca-cli.js

@@ -4248,6 +4248,9 @@ class Step {
   pinKey(_v) {
     return this;
   }
+  toKey() {
+    return null;
+  }
 }
 function warnRawDynStep(op, step) {
   console.warn(`Path.${op} reached a DynStep: call toTransactionPath() first`, step);
@@ -4332,6 +4335,15 @@ class Path {
     }
     return out;
   }
+  toKeys() {
+    const out = [];
+    for (const step of this.steps) {
+      const k = step.toKey();
+      if (k !== null)
+        out.push(k);
+    }
+    return out;
+  }
   setValue(root, v) {
     const intermediates = new Array(this.steps.length);
     let curVal = root;
@@ -4412,19 +4424,12 @@ class Path {
           eventIds.push(eid);
         const metas = metaChain(node.previousSibling);
         let sawComp = false;
-        for (let i = 0;i < metas.length; i++) {
-          const m = metas[i];
+        for (const m of metas) {
           if (m.$ === "Comp") {
             sawComp = true;
             if (!crossComponent(m.cid, m.vid))
               return NO_EVENT_INFO;
-            const outer = metas[i + 1];
-            if (outer?.$ === "Each" && outer.nid === m.nid) {
-              nodeIds.push({ nid: outer.nid, si: outer.si, sk: outer.sk });
-              i += 1;
-            } else {
-              nodeIds.push({ nid: m.nid });
-            }
+            nodeIds.push({ nid: m.nid });
           } else {
             nodeIds.push({ nid: m.nid, si: m.si, sk: m.sk });
           }
@@ -4589,6 +4594,9 @@ var init_path = __esm(() => {
     withKey(k) {
       return new SeqStep(this.field, k);
     }
+    toKey() {
+      return { field: this.field };
+    }
   };
   SeqStep = class SeqStep extends Step {
     constructor(field, key) {
@@ -4607,6 +4615,9 @@ var init_path = __esm(() => {
     enterFrame(stack, _prev, next) {
       return stack.enter(next, { key: this.key }, true);
     }
+    toKey() {
+      return { field: this.field, key: this.key };
+    }
   };
   SeqAccessStep = class SeqAccessStep extends Step {
     constructor(seqField, keyField) {
@@ -4628,6 +4639,9 @@ var init_path = __esm(() => {
       const key = v?.get(this.keyField, NONE);
       return key === NONE ? this : new SeqStep(this.seqField, key);
     }
+    toKey() {
+      return { field: this.seqField };
+    }
   };
   EachBindStep = class EachBindStep extends Step {
     constructor(iterInfo, key) {
@@ -4722,7 +4736,7 @@ class ValParser {
   parseToken(s, px) {
     const c0 = s.charCodeAt(0);
     if (c0 === 39)
-      return s.length >= 2 && s.charCodeAt(s.length - 1) === 39 ? new ConstVal(unescapeStr(s.slice(1, -1)), K_STR | K_STRTPL) : null;
+      return s.length >= 2 && s.charCodeAt(s.length - 1) === 39 ? new ConstVal(unescapeStr(s.slice(1, -1))) : null;
     if (c0 === 36 && s.charCodeAt(1) === 39)
       return s.length >= 3 && s.charCodeAt(s.length - 1) === 39 ? StrTplVal.parse(s.slice(2, -1), px) : null;
     if (s.indexOf("[") !== -1 || s.indexOf("]") !== -1)
@@ -4747,14 +4761,18 @@ class ValParser {
       }
       case 36:
         return mkVal(s.slice(1), MethodVal);
-      case 64:
-        return mkVal(s.slice(1), BindVal);
+      case 64: {
+        const dot = s.indexOf(".", 1);
+        if (dot === -1)
+          return mkVal(s.slice(1), BindVal);
+        const name = s.slice(1, dot);
+        const member = s.slice(dot + 1);
+        return isValidValId(name) && isValidValId(member) ? new BindMemberVal(name, member) : null;
+      }
       case 42:
         return mkVal(s.slice(1), DynVal);
       case 46:
         return mkVal(s.slice(1), FieldVal);
-      case 33:
-        return mkVal(s.slice(1), RequestVal);
     }
     const num = VALID_FLOAT_RE.test(s) ? parseFloat(s) : null;
     if (Number.isFinite(num))
@@ -4807,7 +4825,7 @@ class ValParser {
     return this._parseSingle(s, px, G_PROVIDE);
   }
   parseHandlerArg(s, px) {
-    return this._parseSingle(s, px, G_HANDLER_ARG);
+    return this._parseSingle(s, px, G_VALUE);
   }
   parseMacroAttr(s, px) {
     return this._parseSingle(s, px, G_ALL);
@@ -4839,7 +4857,7 @@ class ValParser {
     const args = new Array(tokens.length - 1);
     for (let i = 1;i < tokens.length; i++) {
       const val = this.parseToken(tokens[i], px);
-      if (val !== null && kindOf(val) & G_HANDLER_ARG)
+      if (val !== null && kindOf(val) & G_VALUE)
         args[i - 1] = val;
       else {
         if (report)
@@ -4865,7 +4883,7 @@ class ValParser {
     for (let i = 0;i < arity; i++) {
       const tok = tokens[i + 1];
       const val = this.parseToken(tok, px);
-      if (val === null || !(kindOf(val) & G_PRED_ARG)) {
+      if (val === null || !(kindOf(val) & G_BOOL)) {
         px.onParseIssue("bad-value", { role: "predicate-arg", value: tok });
         return null;
       }
@@ -4880,7 +4898,7 @@ function kindOf(val) {
   if (val instanceof ConstVal)
     return val.kind;
   if (val instanceof StrTplVal)
-    return K_STRTPL;
+    return val.kind;
   if (val instanceof SeqAccessVal)
     return K_SEQ;
   if (val instanceof FieldVal)
@@ -4891,8 +4909,6 @@ function kindOf(val) {
     return K_BIND;
   if (val instanceof DynVal)
     return K_DYN;
-  if (val instanceof RequestVal)
-    return K_REQUEST;
   if (val instanceof TypeVal)
     return K_TYPE;
   if (val instanceof NameVal)
@@ -4910,13 +4926,13 @@ class BaseVal {
     return this.eval(stack);
   }
 }
-var VALID_VAL_ID_RE, isValidValId = (name) => VALID_VAL_ID_RE.test(name), VALID_FLOAT_RE, STR_TPL_SPLIT_RE, mkVal = (name, Cls) => isValidValId(name) ? new Cls(name) : null, VAL_TOKEN_RE, tokenizeValue = (s) => s.match(VAL_TOKEN_RE) ?? [], unescapeStr = (s) => s.replace(/\\(['\\])/g, "$1"), K_CONST = 1, K_STRTPL = 2, K_FIELD = 4, K_BIND = 8, K_DYN = 16, K_NAME = 32, K_TYPE = 64, K_REQUEST = 128, K_SEQ = 256, K_STR = 512, K_METHOD = 1024, G_BOOL, G_TEXT, G_COMPONENT, G_SEQUENCE, G_PROVIDE, G_FIELD, G_VALUE, G_PRED_ARG, G_HANDLER_ARG, G_ALL, predTruthy = (v) => {
+var VALID_VAL_ID_RE, isValidValId = (name) => VALID_VAL_ID_RE.test(name), VALID_FLOAT_RE, STR_TPL_SPLIT_RE, mkVal = (name, Cls) => isValidValId(name) ? new Cls(name) : null, VAL_TOKEN_RE, tokenizeValue = (s) => s.match(VAL_TOKEN_RE) ?? [], unescapeStr = (s) => s.replace(/\\(['\\])/g, "$1"), K_CONST = 1, K_STRTPL = 2, K_FIELD = 4, K_BIND = 8, K_DYN = 16, K_NAME = 32, K_TYPE = 64, K_SEQ = 256, K_METHOD = 1024, G_BOOL, G_TEXT, G_COMPONENT, G_SEQUENCE, G_PROVIDE, G_FIELD, G_VALUE, G_ALL, predTruthy = (v) => {
   const n = sizeOf(v);
   return n === null ? !!v : n > 0;
 }, PREDICATES, ConstVal, PredicateVal, VarVal, StrTplVal, NameVal, HandlerNameVal, mk404Handler = (type, name) => function(...args) {
   console.warn("handler not found", { type, name, args }, this);
   return this;
-}, TypeVal, RequestVal, RenderVal, RenderNameVal, BindVal, DynVal, FieldVal, MethodVal, SeqAccessVal, vp;
+}, TypeVal, RenderVal, RenderNameVal, BindVal, BindMemberVal, DynVal, FieldVal, MethodVal, SeqAccessVal, vp;
 var init_value = __esm(() => {
   init_immutable();
   init_path();
@@ -4929,10 +4945,8 @@ var init_value = __esm(() => {
   G_COMPONENT = K_FIELD | K_SEQ | K_DYN;
   G_SEQUENCE = K_FIELD | K_DYN;
   G_PROVIDE = K_FIELD | K_SEQ;
-  G_FIELD = K_FIELD | K_METHOD | K_CONST | K_STR | K_SEQ;
-  G_VALUE = K_FIELD | K_METHOD | K_BIND | K_DYN | K_NAME | K_TYPE | K_REQUEST | K_CONST;
-  G_PRED_ARG = G_BOOL | K_STR;
-  G_HANDLER_ARG = G_VALUE | K_STR;
+  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_ALL = G_VALUE | K_STRTPL | K_SEQ;
   PREDICATES = {
     "empty?": { name: "empty?", arity: 1, fn: (v) => v == null || sizeOf(v) === 0 },
@@ -4981,6 +4995,13 @@ var init_value = __esm(() => {
     constructor(vals) {
       super();
       this.vals = vals;
+      this.kind = this.isLiteral() ? K_CONST : K_STRTPL;
+    }
+    isLiteral() {
+      for (const v of this.vals)
+        if (!(v instanceof ConstVal) || v.fromMacroVar)
+          return false;
+      return true;
     }
     render(stack, _rx) {
       return this.eval(stack);
@@ -4992,12 +5013,11 @@ var init_value = __esm(() => {
       return strs.join("");
     }
     toLiteralSource() {
+      if (!this.isLiteral())
+        return null;
       let out = "";
-      for (const v of this.vals) {
-        if (!(v instanceof ConstVal) || v.fromMacroVar)
-          return null;
+      for (const v of this.vals)
         out += v.val;
-      }
       return new ConstVal(out).toString();
     }
     static parse(s, px) {
@@ -5044,14 +5064,6 @@ var init_value = __esm(() => {
       return stack.lookupType(this.name);
     }
   };
-  RequestVal = class RequestVal extends NameVal {
-    eval(stack) {
-      return stack.lookupRequest(this.name);
-    }
-    toString() {
-      return `!${this.name}`;
-    }
-  };
   RenderVal = class RenderVal extends BaseVal {
     render(stack, _rx) {
       return this.eval(stack);
@@ -5071,6 +5083,19 @@ var init_value = __esm(() => {
       return `@${this.name}`;
     }
   };
+  BindMemberVal = class BindMemberVal extends BindVal {
+    constructor(name, member) {
+      super(name);
+      this.member = member;
+    }
+    eval(stack) {
+      const v = stack.lookupBind(this.name);
+      return typeof v?.get === "function" ? v.get(this.member, null) : v?.[this.member] ?? null;
+    }
+    toString() {
+      return `@${this.name}.${this.member}`;
+    }
+  };
   DynVal = class DynVal extends RenderNameVal {
     eval(stack) {
       return stack.lookupDynamic(this.name);
@@ -5213,9 +5238,6 @@ class AttrParser {
         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, this._parseDirectiveValue(directiveName, s, vp.parseText));
         return;
@@ -5325,11 +5347,6 @@ class RequestHandler {
     this.name = name;
     this.fn = fn;
   }
-  toHandlerArg(disp) {
-    const f = (...args) => disp.request(this.name, args);
-    f.withOpts = (...args) => disp.request(this.name, args.slice(0, -1), args.at(-1));
-    return f;
-  }
 }
 var booleanAttrsRaw = "itemscope,allowfullscreen,formnovalidate,ismap,nomodule,novalidate,readonly,async,autofocus,autoplay,controls,default,defer,disabled,hidden,inert,loop,open,required,reversed,scoped,seamless,checked,muted,multiple,selected", booleanAttrs, ConstAttrs, DynAttrs, Attr, ConstAttr, RawHtmlAttr, NOT_SET_VAL, IfAttr, _attrParser = null;
 var init_attribute = __esm(() => {
@@ -5921,24 +5938,6 @@ class Renderer {
   pushEachEntry(r, nid, attrName, key, dom) {
     r.push(this._renderMetadata({ $: "Each", nid, [attrName]: key }), dom);
   }
-  renderEach(stack, iterInfo, node, viewName) {
-    const { seq, filter, loopWith } = iterInfo.eval(stack);
-    const r = [];
-    const { iterData, start, end, keys } = unpackLoopResult(loopWith.call(stack.it, seq, makeLoopCtx(stack, filter)), seq);
-    const renderOne = (key, value, attrName) => {
-      const dom = this.renderIt(stack.enter(value, { key }, true), node, key, viewName);
-      if (dom != null)
-        this.pushEachEntry(r, node.nodeId, attrName, key, dom);
-    };
-    if (keys)
-      imKeysIter(seq, renderOne, keys);
-    else
-      getSeqInfo(seq)(seq, (key, value, attrName) => {
-        if (filter.call(stack.it, key, value, iterData))
-          renderOne(key, value, attrName);
-      }, start, end);
-    return r;
-  }
   renderEachWhen(stack, iterInfo, view, nid) {
     const { seq, filter, loopWith, enricher } = iterInfo.eval(stack);
     const r = [];
@@ -5949,7 +5948,7 @@ class Renderer {
       const binds = { key, value };
       const cacheKey = `${stack.viewsId ?? ""}\x1F${nid}\x1F${key}`;
       if (enricher)
-        enricher.call(it, binds, key, value, iterData);
+        callEnricher(enricher, it, binds, key, value, iterData);
       const cachedNode = this.cache.get(cachePath, cacheKey);
       if (cachedNode)
         this.pushEachEntry(r, nid, attrName, key, cachedNode);
@@ -5996,6 +5995,11 @@ var DATASET_ATTRS, getSeqInfo = (seq) => isIndexed(seq) ? imIndexedIter : isKeye
   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 };
@@ -6064,6 +6068,9 @@ class BaseNode {
   isConstant() {
     return false;
   }
+  isWhiteSpace() {
+    return false;
+  }
   optimize() {}
 }
 function optimizeChilds(childs) {
@@ -6085,6 +6092,8 @@ function parseXOp(attrs, childs, opIdx, px) {
   if (attrs.length <= opIdx)
     return maybeFragment(childs);
   const { name, value } = attrs[opIdx];
+  if (X_OPS[name]?.ignoresChildren && hasMeaningfulChilds(childs))
+    px.onParseIssue("x-op-ignores-children", { op: name });
   const asAttr = attrs.getNamedItem("as")?.value ?? null;
   const as = asAttr === null ? null : parseViewName(asAttr, px);
   let node;
@@ -6102,7 +6111,7 @@ function parseXOp(attrs, childs, opIdx, px) {
       node = px.addNodeIf(RenderItNode, vp.bindValIt, as);
       break;
     case "render-each":
-      node = RenderEachNode.parse(px, vp, value, as, attrs);
+      node = parseRenderEach(px, value, as, attrs);
       break;
     case "show": {
       const val = parseXOpVal(name, value, px, vp.parseBool);
@@ -6137,8 +6146,12 @@ function processXExtras(node, attrs, opName, startIdx, px) {
     const aName = a.name;
     if (consumed.has(aName))
       continue;
-    const wrapper = wrappable ? X_OPS[aName]?.wrapper : null;
+    const atPrefixed = aName.charCodeAt(0) === 64;
+    const baseName = atPrefixed ? aName.slice(1) : aName;
+    const wrapper = wrappable ? X_OPS[baseName]?.wrapper : null;
     if (wrapper) {
+      if (!atPrefixed)
+        maybeDeprecateBareXDirective(px, opName, baseName);
       wrappers.push([wrapper, vp.parseBool(a.value, px)]);
       continue;
     }
@@ -6153,6 +6166,9 @@ function processXExtras(node, attrs, opName, startIdx, px) {
   }
   return node;
 }
+function maybeDeprecateBareXDirective(px, opName, name) {
+  px.onDeprecatedSyntax("bare-x-directive", { op: opName, name });
+}
 function wrap(node, px, wrappers) {
   if (wrappers) {
     for (let i = wrappers.length - 1;i >= 0; i--) {
@@ -6181,6 +6197,29 @@ function dynRenderStep(comp, name, key) {
     return null;
   return key === undefined ? new DynStep(p.producerCompId, p.producerSteps) : new DynEachStep(p.producerCompId, p.producerSteps, key);
 }
+function parseRenderEach(px, value, as, attrs) {
+  const seqVal = parseXOpVal("render-each", value, px, vp.parseSequence);
+  if (seqVal === null)
+    return null;
+  const renderIt = px.addNodeIf(RenderItNode, vp.bindValIt, as);
+  const attrParser = getAttrParser(px);
+  const eachAttr = attrParser.eachAttr = attrParser.pushWrapper("each", value, seqVal);
+  const when = attrs.getNamedItem("@when") ?? attrs.getNamedItem("when");
+  if (when) {
+    if (when.name.charCodeAt(0) !== 64)
+      maybeDeprecateBareXDirective(px, "render-each", "when");
+    attrParser._parseWhen(when.value);
+  }
+  const lWith = attrs.getNamedItem("loop-with");
+  if (lWith)
+    attrParser._parseLoopWith(lWith.value);
+  const each = px.addNodeIf(EachNode, seqVal);
+  each.iterInfo.whenVal = eachAttr.whenVal ?? null;
+  each.iterInfo.loopWithVal = eachAttr.loopWithVal ?? null;
+  each.fromRenderEach = true;
+  each.wrapNode(renderIt);
+  return each;
+}
 
 class IterInfo {
   constructor(val, whenVal, loopWithVal, enrichWithVal) {
@@ -6202,13 +6241,13 @@ class IterInfo {
     const binds = { key, value };
     if (enricher) {
       const { iterData } = unpackLoopResult(loopWith.call(stack.it, seq, makeLoopCtx(stack, filter)), seq);
-      enricher.call(stack.it, binds, key, value, iterData);
+      callEnricher(enricher, stack.it, binds, key, value, iterData);
     }
     return binds;
   }
 }
-function xOp(consumed = [], { wrappable = false, wrapper = null } = {}) {
-  return { consumed: new Set(consumed), wrappable, wrapper };
+function xOp(consumed = [], { wrappable = false, wrapper = null, ignoresChildren = false } = {}) {
+  return { consumed: new Set(consumed), wrappable, wrapper, ignoresChildren };
 }
 
 class ParseContext {
@@ -6256,9 +6295,9 @@ class ParseContext {
     const anySlot = [];
     const slots = { _: new FragmentNode(anySlot) };
     for (const child of childs)
-      if (child instanceof SlotNode)
+      if (child.isSlotNode)
         slots[child.val.val] = child.node;
-      else if (!(child instanceof TextNode) || !child.isWhiteSpace())
+      else if (!child.isWhiteSpace())
         anySlot.push(child);
     const node = new MacroNode(macroName, mAttrs, slots, this);
     this.macroNodes.push(node);
@@ -6282,6 +6321,7 @@ class ParseContext {
   onParseIssue(kind, info) {
     console.warn(`tutuca parse issue [${kind}]`, info);
   }
+  onDeprecatedSyntax(_kind, _info) {}
 }
 function trimEdgeWhite(node) {
   if (!node.isWhiteSpace?.())
@@ -6361,10 +6401,10 @@ function compileModifiers(eventName, names) {
     return w(this, f, args, ctx);
   };
 }
-var TextNode, CommentNode, ChildsNode, DomNode, FragmentNode, maybeFragment = (xs) => xs.length === 1 ? xs[0] : new FragmentNode(xs), VALID_NODE_RE, ANode, MacroNode, RenderViewId, RenderNode, RenderItNode, RenderEachNode, RenderTextNode, RenderOnceNode, WrapperNode, ShowNode, HideNode, PushViewNameNode, SlotNode, ScopeNode, EachNode, X_OPS, WRAPPER_NODES, _htmlBlockTags = "ADDRESS,ARTICLE,ASIDE,BLOCKQUOTE,CAPTION,COL,COLGROUP,DETAILS,DIALOG,DIV,DD,DL,DT,FIELDSET,FIGCAPTION,FIGURE,FOOTER,FORM,H1,H2,H3,H4,H5,H6,HEADER,HGROUP,HR,LEGEND,LI,MAIN,MENU,NAV,OL,P,PRE,SECTION,SUMMARY,TABLE,TBODY,TD,TFOOT,TH,THEAD,TR,UL", HTML_BLOCK_TAGS, isBlockDomNode = (n) => {
+var TextNode, CommentNode, ChildsNode, DomNode, FragmentNode, maybeFragment = (xs) => xs.length === 1 ? xs[0] : new FragmentNode(xs), VALID_NODE_RE, ANode, MacroNode, RenderViewId, RenderNode, RenderItNode, RenderTextNode, RenderOnceNode, WrapperNode, ShowNode, HideNode, PushViewNameNode, SlotNode, ScopeNode, EachNode, X_OPS, WRAPPER_NODES, _htmlBlockTags = "ADDRESS,ARTICLE,ASIDE,BLOCKQUOTE,CAPTION,COL,COLGROUP,DETAILS,DIALOG,DIV,DD,DL,DT,FIELDSET,FIGCAPTION,FIGURE,FOOTER,FORM,H1,H2,H3,H4,H5,H6,HEADER,HGROUP,HR,LEGEND,LI,MAIN,MENU,NAV,OL,P,PRE,SECTION,SUMMARY,TABLE,TBODY,TD,TFOOT,TH,THEAD,TR,UL", HTML_BLOCK_TAGS, isBlockDomNode = (n) => {
   const node = n instanceof FragmentNode ? n.childs[0] : n;
   return node instanceof DomNode && HTML_BLOCK_TAGS.has(node.tagName);
-}, isEmptyText = (c) => c instanceof TextNode && c.val === "", fwdIfCtxPred = (pred) => (w) => (that, f, args, ctx) => pred(ctx) ? w(that, f, args, ctx) : that, fwdIfKey = (keyName) => fwdIfCtxPred((ctx) => ctx.e.key === keyName), fwdCtrl, fwdMeta, fwdAlt, metaWraps, MOD_WRAPPERS_BY_EVENT, identityModifierWrapper = (f, _ctx) => f;
+}, isEmptyText = (c) => c instanceof TextNode && c.val === "", isIgnorableXChild = (c) => c instanceof CommentNode || (c.isWhiteSpace?.() ?? false), hasMeaningfulChilds = (childs) => childs.some((c) => !isIgnorableXChild(c)), fwdIfCtxPred = (pred) => (w) => (that, f, args, ctx) => pred(ctx) ? w(that, f, args, ctx) : that, fwdIfKey = (keyName) => fwdIfCtxPred((ctx) => ctx.e.key === keyName), fwdCtrl, fwdMeta, fwdAlt, metaWraps, MOD_WRAPPERS_BY_EVENT, identityModifierWrapper = (f, _ctx) => f;
 var init_anode = __esm(() => {
   init_attribute();
   init_path();
@@ -6596,36 +6636,6 @@ var init_anode = __esm(() => {
       return null;
     }
   };
-  RenderEachNode = class RenderEachNode extends RenderViewId {
-    constructor(nodeId, val, viewVal) {
-      super(nodeId, val, viewVal);
-      this.iterInfo = new IterInfo(val, null, null, null);
-    }
-    render(stack, rx) {
-      return rx.renderEach(stack, this.iterInfo, this, this.evalViewName(stack));
-    }
-    toPathStep(ctx) {
-      if (this.val instanceof DynVal)
-        return ctx.hasKey ? dynRenderStep(ctx.comp, this.val.name, ctx.key) : null;
-      return super.toPathStep(ctx);
-    }
-    static parse(px, vp2, s, as, attrs) {
-      const node = px.addNodeIf(RenderEachNode, parseXOpVal("render-each", s, px, vp2.parseSequence), as);
-      if (node !== null) {
-        const attrParser = getAttrParser(px);
-        attrParser.eachAttr = attrParser.pushWrapper("each", s, node.val);
-        const when = attrs.getNamedItem("when");
-        if (when)
-          attrParser._parseWhen(when.value);
-        const lWith = attrs.getNamedItem("loop-with");
-        if (lWith)
-          attrParser._parseLoopWith(lWith.value);
-        node.iterInfo.whenVal = attrParser.eachAttr.whenVal ?? null;
-        node.iterInfo.loopWithVal = attrParser.eachAttr.loopWithVal ?? null;
-      }
-      return node;
-    }
-  };
   RenderTextNode = class RenderTextNode extends ANode {
     render(stack, _rx) {
       return this.val.eval(stack);
@@ -6678,6 +6688,7 @@ var init_anode = __esm(() => {
     }
   };
   SlotNode = class SlotNode extends WrapperNode {
+    isSlotNode = true;
     optimize() {
       this.node.optimize();
     }
@@ -6712,15 +6723,17 @@ var init_anode = __esm(() => {
   };
   X_OPS = {
     slot: xOp(),
-    text: xOp([], { wrappable: true }),
-    render: xOp(["as"], { wrappable: true }),
-    "render-it": xOp(["as"], { wrappable: true }),
-    "render-each": xOp(["as", "when", "loop-with"], { wrappable: true }),
+    text: xOp([], { wrappable: true, ignoresChildren: true }),
+    render: xOp(["as"], { wrappable: true, ignoresChildren: true }),
+    "render-it": xOp(["as"], { wrappable: true, ignoresChildren: true }),
+    "render-each": xOp(["as", "when", "loop-with", "@when"], {
+      wrappable: true,
+      ignoresChildren: true
+    }),
     show: xOp([], { wrapper: ShowNode }),
     hide: xOp([], { wrapper: HideNode })
   };
   WRAPPER_NODES = {
-    slot: SlotNode,
     show: ShowNode,
     hide: HideNode,
     each: EachNode,
@@ -8990,14 +9003,17 @@ function closestName(name, candidates, maxDistance = 2) {
 
 // tools/core/lint-check.js
 function protoHasMethod(proto, name) {
+  return protoMethodValue(proto, name) !== null;
+}
+function protoMethodValue(proto, name) {
   let cursor = proto;
   while (cursor && cursor !== Object.prototype) {
     const desc = Object.getOwnPropertyDescriptor(cursor, name);
     if (desc !== undefined)
-      return typeof desc.value === "function";
+      return typeof desc.value === "function" ? desc.value : null;
     cursor = Object.getPrototypeOf(cursor);
   }
-  return false;
+  return null;
 }
 function collectProtoMethodNames(proto) {
   const out = [];
@@ -9041,6 +9057,8 @@ function classifyBadValue(value) {
     return "logical";
   if (/^[.$][A-Za-z_]\w*\s+\S/.test(s))
     return "call-with-args";
+  if (/^\.[A-Za-z_]\w*\??(\.[A-Za-z_]\w*\??)+$/.test(s))
+    return "field-path";
   return null;
 }
 function checkComponent(Comp, lx = new LintContext, { wellKnownExtras = EMPTY_SET2 } = {}) {
@@ -9069,6 +9087,7 @@ function checkComponent(Comp, lx = new LintContext, { wellKnownExtras = EMPTY_SE
 function checkView(lx, view, Comp, referencedAlters, referencedDynamics) {
   checkParseIssues(lx, view);
   checkRenderItInLoop(lx, view);
+  checkEnrichProjection(lx, view, Comp);
   checkEventModifiers(lx, view);
   checkKnownHandlerNames(lx, view, Comp, referencedAlters, referencedDynamics);
   checkMacroCallArgs(lx, view, Comp);
@@ -9084,11 +9103,31 @@ function checkParseIssues(lx, view) {
   if (!issues)
     return;
   for (const { kind, info } of issues) {
+    if (kind === "deprecated:bare-x-directive") {
+      lx.warn(DEPRECATED_BARE_X_DIRECTIVE, info, {
+        kind: "add-prefix",
+        from: info.name,
+        to: `@${info.name}`
+      });
+      continue;
+    }
+    if (kind === "x-op-ignores-children") {
+      lx.warn(X_OP_IGNORES_CHILDREN, info, { kind: "remove", what: "the ignored children" });
+      continue;
+    }
     const rule = PARSE_ISSUES[kind];
     if (!rule)
       continue;
     const id = rule.id;
     if (kind === "bad-value") {
+      if (typeof info.value === "string" && BINDING_MEMBER_TOO_DEEP_RE.test(info.value.trim())) {
+        lx.error(BINDING_MEMBER_TOO_DEEP, info, {
+          kind: "rephrase",
+          from: info.value,
+          text: "Read one level off the binding and compute the rest in a method or an '@enrich-with' handler."
+        });
+        continue;
+      }
       const detected = classifyBadValue(info.value);
       if (detected) {
         lx.error(UNSUPPORTED_EXPR_SYNTAX, { ...info, detected }, { kind: "rephrase", from: info.value, text: UNSUPPORTED_EXPR_GUIDANCE[detected] });
@@ -9135,6 +9174,54 @@ function checkRenderItInLoop(lx, view) {
     return;
   walkForRenderIt(lx, view.anode, 0);
 }
+function pureProjectionBinds(fn) {
+  const src = Function.prototype.toString.call(fn);
+  const head = src.match(/^[^(]*\(([^)]*)\)\s*(?:=>)?\s*/);
+  if (!head)
+    return null;
+  const params = head[1].split(",").map((p) => p.trim());
+  const [bindsName, , valueName] = params;
+  if (!/^\w+$/.test(bindsName ?? "") || !/^\w+$/.test(valueName ?? ""))
+    return null;
+  let body = src.slice(head[0].length).trim();
+  if (body.startsWith("{")) {
+    if (!body.endsWith("}"))
+      return null;
+    body = body.slice(1, -1);
+  }
+  const statements = body.split(/[;\n]/).map((s) => s.trim()).filter((s) => s !== "" && !s.startsWith("//"));
+  if (statements.length === 0)
+    return null;
+  const projectionRe = new RegExp(`^${bindsName}\\.(\\w+)\\s*=\\s*${valueName}(?:\\.(\\w+)|\\.get\\((['"])(\\w+)\\3\\))$`);
+  const members = [];
+  for (const statement of statements) {
+    const m = statement.match(projectionRe);
+    if (!m)
+      return null;
+    members.push({ bind: m[1], member: m[2] ?? m[4] });
+  }
+  return members;
+}
+function checkEnrichProjection(lx, view, Comp) {
+  for (const node of view.ctx.nodes) {
+    if (node.constructor.name !== "EachNode")
+      continue;
+    const enrich = node.iterInfo?.enrichWithVal;
+    if (!enrich?.name)
+      continue;
+    const fn = enrich.constructor.name === "MethodVal" ? protoMethodValue(Comp.Class?.prototype, enrich.name) : Comp.alter?.[enrich.name];
+    if (typeof fn !== "function")
+      continue;
+    const members = pureProjectionBinds(fn);
+    if (members === null)
+      continue;
+    const rewrites = members.map(({ bind, member }) => `'@${bind}' -> '@value.${member}'`);
+    lx.hint(SUGGEST_BINDING_MEMBER, { name: enrich.name, members }, {
+      kind: "rephrase",
+      text: `Replace ${rewrites.join(", ")} in the view, then remove the '@enrich-with' and the '${enrich.name}' alter handler.`
+    });
+  }
+}
 function walkForRenderIt(lx, node, loopDepth) {
   if (node === null || node === undefined)
     return;
@@ -9382,7 +9469,7 @@ function checkConsistentAttrs(lx, Comp, referencedAlters, referencedDynamics) {
         if (node.val) {
           checkConsistentAttrVal(lx, node.val, env, false, baseCtx);
         }
-        if (nodeKind === "RenderEachNode") {
+        if (nodeKind === "EachNode" && node.fromRenderEach) {
           const iter = node.iterInfo;
           if (iter.whenVal)
             checkConsistentAttrVal(lx, iter.whenVal, env, false, {
@@ -9609,7 +9696,7 @@ class LintContext {
     this.reports.push({ id, info, level, context: { ...this.frame }, suggestion });
   }
 }
-var KNOWN_COMPONENT_SPEC_KEYS, EMPTY_SET2, FRAMEWORK_WELL_KNOWN_EXTRAS, KNOWN_DIRECTIVE_NAMES, 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", LOOKUP_BAD_SHAPE = "LOOKUP_BAD_SHAPE", LOOKUP_TARGET_MALFORMED = "LOOKUP_TARGET_MALFORMED", 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", FIELD_VAL_IS_METHOD = "FIELD_VAL_IS_METHOD", METHOD_VAL_NOT_DEFINED = "METHOD_VAL_NOT_DEFINED", METHOD_VAL_IS_FIELD = "METHOD_VAL_IS_FIELD", 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", MAYBE_ADD_AT_PREFIX = "MAYBE_ADD_AT_PREFIX", BAD_VALUE = "BAD_VALUE", UNSUPPORTED_EXPR_SYNTAX = "UNSUPPORTED_EXPR_SYNTAX", REDUNDANT_TEMPLATE_STRING = "REDUNDANT_TEMPLATE_STRING", PLACEHOLDERLESS_TEMPLATE_STRING = "PLACEHOLDERLESS_TEMPLATE_STRING", UNKNOWN_COMPONENT_SPEC_KEY = "UNKNOWN_COMPONENT_SPEC_KEY", COMP_FIELD_BAD_SHAPE = "COMP_FIELD_BAD_SHAPE", ASYNC_HANDLER = "ASYNC_HANDLER", TOP_LEVEL_AT_RULE_IN_SCOPED_STYLE = "TOP_LEVEL_AT_RULE_IN_SCOPED_STYLE", GLOBAL_SELECTOR_IN_SCOPED_STYLE = "GLOBAL_SELECTOR_IN_SCOPED_STYLE", FIELD_NAME_RESERVED_BY_RECORD = "FIELD_NAME_RESERVED_BY_RECORD", RECORD_FIELD_NAME_COLLISIONS, X_KNOWN_OP_NAMES, X_KNOWN_ATTR_NAMES, HOST_DIRECTIVE_ONLY_NAMES, LEVEL_WARN2 = "warn", LEVEL_ERROR2 = "error", LEVEL_HINT = "hint", PARSE_ISSUES, UNSUPPORTED_EXPR_GUIDANCE, HTML_LINT_OPTS, NO_WRAPPERS, KNOWN_HANDLER_NAMES, fixTo = (from, to) => ({ kind: "rewrite", from, to }), ATTR_VAL_CHECKERS, NODE_KIND_TO_CTX, HANDLER_CHANNELS, ASYNC_HANDLER_HELP, NON_NESTABLE_AT_RULE, GLOBAL_LEADING_SELECTOR, IGNORE_DIRECTIVE, blankRun = (m) => m.replace(/[^\n]/g, " "), STYLE_TO_GLOBAL_HELP, KNOWN_LOOKUP_KEYS, LintParseContext;
+var KNOWN_COMPONENT_SPEC_KEYS, EMPTY_SET2, FRAMEWORK_WELL_KNOWN_EXTRAS, KNOWN_DIRECTIVE_NAMES, 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", LOOKUP_BAD_SHAPE = "LOOKUP_BAD_SHAPE", LOOKUP_TARGET_MALFORMED = "LOOKUP_TARGET_MALFORMED", 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", FIELD_VAL_IS_METHOD = "FIELD_VAL_IS_METHOD", METHOD_VAL_NOT_DEFINED = "METHOD_VAL_NOT_DEFINED", METHOD_VAL_IS_FIELD = "METHOD_VAL_IS_FIELD", DUPLICATE_ATTR_DEFINITION = "DUPLICATE_ATTR_DEFINITION", IF_NO_BRANCH_SET = "IF_NO_BRANCH_SET", 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", X_OP_IGNORES_CHILDREN = "X_OP_IGNORES_CHILDREN", MAYBE_DROP_AT_PREFIX = "MAYBE_DROP_AT_PREFIX", MAYBE_ADD_AT_PREFIX = "MAYBE_ADD_AT_PREFIX", DEPRECATED_BARE_X_DIRECTIVE = "DEPRECATED_BARE_X_DIRECTIVE", BAD_VALUE = "BAD_VALUE", UNSUPPORTED_EXPR_SYNTAX = "UNSUPPORTED_EXPR_SYNTAX", BINDING_MEMBER_TOO_DEEP = "BINDING_MEMBER_TOO_DEEP", SUGGEST_BINDING_MEMBER = "SUGGEST_BINDING_MEMBER", REDUNDANT_TEMPLATE_STRING = "REDUNDANT_TEMPLATE_STRING", PLACEHOLDERLESS_TEMPLATE_STRING = "PLACEHOLDERLESS_TEMPLATE_STRING", CONSTANT_CONDITION = "CONSTANT_CONDITION", UNKNOWN_COMPONENT_SPEC_KEY = "UNKNOWN_COMPONENT_SPEC_KEY", COMP_FIELD_BAD_SHAPE = "COMP_FIELD_BAD_SHAPE", ASYNC_HANDLER = "ASYNC_HANDLER", TOP_LEVEL_AT_RULE_IN_SCOPED_STYLE = "TOP_LEVEL_AT_RULE_IN_SCOPED_STYLE", GLOBAL_SELECTOR_IN_SCOPED_STYLE = "GLOBAL_SELECTOR_IN_SCOPED_STYLE", FIELD_NAME_RESERVED_BY_RECORD = "FIELD_NAME_RESERVED_BY_RECORD", RECORD_FIELD_NAME_COLLISIONS, X_KNOWN_OP_NAMES, X_KNOWN_ATTR_NAMES, HOST_DIRECTIVE_ONLY_NAMES, LEVEL_WARN2 = "warn", LEVEL_ERROR2 = "error", LEVEL_HINT = "hint", PARSE_ISSUES, BINDING_MEMBER_TOO_DEEP_RE, UNSUPPORTED_EXPR_GUIDANCE, HTML_LINT_OPTS, NO_WRAPPERS, KNOWN_HANDLER_NAMES, fixTo = (from, to) => ({ kind: "rewrite", from, to }), BOOL_CONDITION_ORIGINS, isBoolConditionCtx = (errCtx) => errCtx != null && (BOOL_CONDITION_ORIGINS.has(errCtx.originAttr) || errCtx.branch === "@if"), ATTR_VAL_CHECKERS, NODE_KIND_TO_CTX, HANDLER_CHANNELS, ASYNC_HANDLER_HELP, NON_NESTABLE_AT_RULE, GLOBAL_LEADING_SELECTOR, IGNORE_DIRECTIVE, blankRun = (m) => m.replace(/[^\n]/g, " "), STYLE_TO_GLOBAL_HELP, KNOWN_LOOKUP_KEYS, LintParseContext;
 var init_lint_check = __esm(() => {
   init_anode();
   init_htmllinter();
@@ -9652,11 +9739,13 @@ var init_lint_check = __esm(() => {
     },
     "bad-value": { id: BAD_VALUE }
   };
+  BINDING_MEMBER_TOO_DEEP_RE = /^@[a-zA-Z]\w*\??(\.[a-zA-Z]\w*\??){2,}$/;
   UNSUPPORTED_EXPR_GUIDANCE = {
     ternary: "Ternary expressions aren't supported in dynamic attributes. Define a method or computed field on the component that returns the value, then reference it as '$methodName'.",
     comparison: "Comparisons aren't supported in dynamic attributes. Define a method like 'isFooSelected' that returns the boolean, then reference it as '$isFooSelected'.",
     logical: "Logical operators aren't supported in dynamic attributes. Combine the conditions in a method on the component and reference it as '$methodName'.",
-    "call-with-args": "Method calls with arguments aren't supported here. Reference a no-arg method ('$methodName') and read what you need from component state, or split into per-case methods."
+    "call-with-args": "Method calls with arguments aren't supported here. Reference a no-arg method ('$methodName') and read what you need from component state, or split into per-case methods.",
+    "field-path": "Fields can't be read through a dotted path. Define a method that returns the value, render a child component for the nested data, or — inside a loop — read one member off a binding ('@value.member')."
   };
   HTML_LINT_OPTS = {
     fragmentContext: "template",
@@ -9683,7 +9772,12 @@ var init_lint_check = __esm(() => {
     "ctx",
     "dragInfo"
   ]);
+  BOOL_CONDITION_ORIGINS = new Set(["@show", "@hide", "<x show>", "<x hide>"]);
   ATTR_VAL_CHECKERS = {
+    ConstVal({ lx, val, errCtx }) {
+      if (isBoolConditionCtx(errCtx) && typeof val.val !== "boolean")
+        lx.warn(CONSTANT_CONDITION, { ...errCtx, literal: String(val) });
+    },
     FieldVal({ lx, val, env, errCtx }) {
       const { fields, proto } = env;
       const { name } = val;
@@ -9711,10 +9805,6 @@ var init_lint_check = __esm(() => {
       recurse(val.seqVal);
       recurse(val.keyVal);
     },
-    RequestVal({ lx, val, env, errCtx }) {
-      if (env.scope.lookupRequest(val.name) === null)
-        reportUnknownName(lx, UNKNOWN_REQUEST_NAME, val.name, scopeKeysAlong(env.scope, "reqsByName"), errCtx);
-    },
     TypeVal({ lx, val, env, errCtx }) {
       if (env.scope.lookupComponent(val.name) === null)
         reportUnknownName(lx, UNKNOWN_COMPONENT_NAME, val.name, scopeKeysAlong(env.scope, "byName"), errCtx);
@@ -9727,7 +9817,11 @@ var init_lint_check = __esm(() => {
       const vs = val.vals;
       const literal = val.toLiteralSource();
       if (literal !== null) {
-        lx.hint(PLACEHOLDERLESS_TEMPLATE_STRING, { ...errCtx, literal }, fixTo(`$${literal}`, literal));
+        if (isBoolConditionCtx(errCtx))
+          lx.warn(CONSTANT_CONDITION, { ...errCtx, literal });
+        else
+          lx.hint(PLACEHOLDERLESS_TEMPLATE_STRING, { ...errCtx, literal }, fixTo(`$${literal}`, literal));
+        return;
       } else if (vs.length === 1) {
         const simpler = String(vs[0]);
         lx.warn(REDUNDANT_TEMPLATE_STRING, { ...errCtx, simpler }, fixTo(`$'{${simpler}}'`, simpler));
@@ -9754,7 +9848,6 @@ var init_lint_check = __esm(() => {
     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>" }
@@ -9779,6 +9872,13 @@ var init_lint_check = __esm(() => {
       const tag = this.currentTag;
       this.parseIssues.push({ kind, info: tag && info.tag === undefined ? { ...info, tag } : info });
     }
+    onDeprecatedSyntax(kind, info) {
+      const tag = this.currentTag;
+      this.parseIssues.push({
+        kind: `deprecated:${kind}`,
+        info: tag && info.tag === undefined ? { ...info, tag } : info
+      });
+    }
   };
 });
 
@@ -9867,6 +9967,12 @@ var init_lint_rules = __esm(() => {
       group: "Iteration helpers (`alter`)",
       summary: "`alter` entry is defined but never used."
     },
+    {
+      code: SUGGEST_BINDING_MEMBER,
+      level: "hint",
+      group: "Iteration helpers (`alter`)",
+      summary: "`@enrich-with` handler only copies members of the loop value — read them directly as `@value.member` and drop the enrich."
+    },
     {
       code: DYN_VAL_NOT_DEFINED,
       level: "error",
@@ -9945,6 +10051,12 @@ var init_lint_rules = __esm(() => {
       group: "Templates / events",
       summary: "Extra attribute on `<x op>` not consumed by the op and not a known wrapper."
     },
+    {
+      code: X_OP_IGNORES_CHILDREN,
+      level: "warn",
+      group: "Templates / events",
+      summary: "`<x text/render/render-it/render-each>` has child content the op silently drops."
+    },
     {
       code: MAYBE_DROP_AT_PREFIX,
       level: "hint",
@@ -9957,6 +10069,12 @@ var init_lint_rules = __esm(() => {
       group: "Templates / events",
       summary: "A directive name (`when`/`enrich-with`/`loop-with`/`show`/`hide`) was written as a plain attribute on a host element — add the `@` prefix."
     },
+    {
+      code: DEPRECATED_BARE_X_DIRECTIVE,
+      level: "warn",
+      group: "Templates / events",
+      summary: "Bare `show`/`hide`/`when` on an `<x>` op is deprecated — use the `@`-prefixed directive (`@show`/`@hide`/`@when`)."
+    },
     {
       code: BAD_VALUE,
       level: "error",
@@ -9967,7 +10085,13 @@ var init_lint_rules = __esm(() => {
       code: UNSUPPORTED_EXPR_SYNTAX,
       level: "error",
       group: "Value expressions",
-      summary: "Value uses JS-style syntax (ternary, comparison, logical, call-with-args) tutuca does not support — move the logic into a method."
+      summary: "Value uses JS-style syntax (ternary, comparison, logical, call-with-args, dotted field path) tutuca does not support — move the logic into a method."
+    },
+    {
+      code: BINDING_MEMBER_TOO_DEEP,
+      level: "error",
+      group: "Value expressions",
+      summary: "A binding member read goes more than one level deep (`@x.a.b`) — only one member is allowed."
     },
     {
       code: REDUNDANT_TEMPLATE_STRING,
@@ -9982,10 +10106,10 @@ var init_lint_rules = __esm(() => {
       summary: "`$'…'` template has no `{}` placeholder — use a plain string literal."
     },
     {
-      code: UNKNOWN_REQUEST_NAME,
-      level: "error",
-      group: "Names registered with the app",
-      summary: "`!name` references a request handler not registered with the app."
+      code: CONSTANT_CONDITION,
+      level: "warn",
+      group: "Value expressions",
+      summary: "A non-boolean literal in a boolean condition (`@show`, `@hide`, `@if`) never changes — reference a field or method instead."
     },
     {
       code: UNKNOWN_COMPONENT_NAME,
@@ -10158,8 +10282,6 @@ function lintIdToMessage(id, info) {
     }
     case "IF_NO_BRANCH_SET":
       return `'@if.${info.attr}' has no '@then' or '@else' branch — add '@then="…"' or '@else="…"' (or both)${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":
@@ -10184,20 +10306,32 @@ function lintIdToMessage(id, info) {
       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 "X_OP_IGNORES_CHILDREN":
+      return `<x ${info.op}> has child content, but the '${info.op}' op ignores its children — they are silently dropped when the template is parsed; remove them${fmtTagSuffix(info)}`;
     case "MAYBE_DROP_AT_PREFIX": {
       const written = info.value !== undefined ? `${info.name}=${JSON.stringify(info.value)}` : info.name;
       return `'${written}' on <x> looks like a directive but is actually an x op/attr written with a leading '@'`;
     }
     case "MAYBE_ADD_AT_PREFIX":
       return `'${info.name}' on <${(info.tag ?? "").toLowerCase()}> is a plain attribute, but '@${info.name}' is a directive — add the leading '@'`;
+    case "DEPRECATED_BARE_X_DIRECTIVE":
+      return `'${info.name}' on <x ${info.op}> is deprecated — write '@${info.name}' instead${fmtTagSuffix(info)}`;
     case "BAD_VALUE":
       return `${badValueMessage(info)}${fmtTagSuffix(info)}`;
     case "UNSUPPORTED_EXPR_SYNTAX":
       return `${unsupportedExprMessage(info)}${fmtTagSuffix(info)}`;
+    case "BINDING_MEMBER_TOO_DEEP":
+      return `Binding member read ${JSON.stringify(info.value)} goes more than one level deep — only one member is allowed (like '@value.title')${fmtTagSuffix(info)}`;
+    case "SUGGEST_BINDING_MEMBER": {
+      const reads = (info.members ?? []).map(({ member }) => `'@value.${member}'`).join(", ");
+      return `Enrich handler '${info.name}' only copies members of the loop value — read them directly${reads ? ` (${reads})` : ""} and remove the '@enrich-with'`;
+    }
     case "REDUNDANT_TEMPLATE_STRING":
       return `Redundant template string — '{${info.simpler}}' should be just '${info.simpler}'${fmtOriginSuffix(info)}`;
     case "PLACEHOLDERLESS_TEMPLATE_STRING":
       return `Template string has no dynamic parts — use the string literal ${info.literal} instead${fmtOriginSuffix(info)}`;
+    case "CONSTANT_CONDITION":
+      return `Condition is the constant literal ${info.literal} — it never changes; reference a field ('.name') or a method ('$name') instead${fmtOriginSuffix(info)}`;
     case "UNKNOWN_COMPONENT_SPEC_KEY":
       return `Unknown component spec key '${info.key}' — value will be ignored at runtime`;
     case "COMP_FIELD_BAD_SHAPE":
@@ -10300,7 +10434,8 @@ var init_lint = __esm(() => {
     ternary: "ternary expression",
     comparison: "comparison",
     logical: "logical expression",
-    "call-with-args": "method call with arguments"
+    "call-with-args": "method call with arguments",
+    "field-path": "dotted field path"
   };
 });
 
@@ -15108,9 +15243,6 @@ class Stack2 {
   getHandlerFor(name, key) {
     return this.comps.getHandlerFor(this.it, name, key);
   }
-  lookupRequest(name) {
-    return this.comps.getRequestFor(this.it, name);
-  }
   lookupBestView(views, defaultViewName) {
     let n = this.views;
     while (n !== null) {
@@ -15154,12 +15286,47 @@ class Transactor {
     this.transactions = [];
     this.state = new State2(rootValue);
     this.onTransactionPushed = () => {};
+    this._observers = [];
     this._inflight = new Set;
   }
   pushTransaction(t) {
     this.transactions.push(t);
     this.onTransactionPushed(t);
   }
+  observe(cb) {
+    this._observers.push(cb);
+    return () => {
+      const i = this._observers.indexOf(cb);
+      if (i !== -1)
+        this._observers.splice(i, 1);
+    };
+  }
+  _emit(record) {
+    for (const cb of this._observers)
+      cb(record);
+  }
+  _emitTransaction(transaction, root) {
+    if (this._observers.length === 0)
+      return;
+    if (transaction._resolvedHandler === undefined)
+      return;
+    const path = transaction.getTransactionPath().pinKeys(root);
+    this._emit({
+      kind: transaction.observeKind,
+      name: transaction.observeName,
+      args: transaction.args ?? null,
+      path,
+      pathKeys: path.toKeys(),
+      targetPath: transaction.targetPath ?? transaction.path,
+      handler: transaction._resolvedHandler ?? null,
+      handlerName: transaction._resolvedHandler?.name || null,
+      matched: transaction._matched ?? null,
+      before: transaction._before,
+      after: transaction._after,
+      parent: transaction.parentTransaction,
+      timestamp: Date.now()
+    });
+  }
   _link(child, parent) {
     if (parent) {
       const release = parent.completion.track();
@@ -15210,7 +15377,26 @@ class Transactor {
       const curRoot = this.state.val;
       const txnPath = path.toTransactionPath();
       const curLeaf = txnPath.lookup(curRoot);
-      const handler = this.comps.getRequestFor(curLeaf, name) ?? mkReq404(name);
+      const found = this.comps.getRequestFor(curLeaf, name);
+      const handler = found ?? mkReq404(name);
+      if (this._observers.length > 0) {
+        const reqPath = txnPath.pinKeys(curRoot);
+        this._emit({
+          kind: "request",
+          name,
+          args,
+          path: reqPath,
+          pathKeys: reqPath.toKeys(),
+          targetPath: path,
+          handler: found?.fn ?? null,
+          handlerName: found?.fn?.name || name,
+          matched: found ? "exact" : "none",
+          before: curLeaf,
+          after: undefined,
+          parent,
+          timestamp: Date.now()
+        });
+      }
       const reqCtx = new RequestContext(path, this, parent, curRoot);
       const resHandlerName = opts?.onResName ?? name;
       const resPath = opts?.livePath ? null : txnPath.pinKeys(curRoot);
@@ -15245,6 +15431,7 @@ class Transactor {
       if (newState !== undefined) {
         this.state.set(newState, { transaction });
         transaction.afterTransaction();
+        this._emitTransaction(transaction, curState);
       } else
         console.warn("undefined new state", { curState, transaction });
     } finally {
@@ -15293,8 +15480,15 @@ class Transaction {
   buildStack(root, comps) {
     return this.path.toTransactionPath().buildStack(this.buildRootStack(root, comps));
   }
+  get observeKind() {
+    return null;
+  }
+  get observeName() {
+    return null;
+  }
   callHandler(root, instance, comps) {
     const [handler, args] = this.getHandlerAndArgs(root, instance, comps);
+    this._resolvedHandler = handler;
     return handler.apply(instance, args);
   }
   getHandlerAndArgs(_root, _instance, _comps) {
@@ -15307,6 +15501,8 @@ class Transaction {
     const txnPath = this.getTransactionPath();
     const curLeaf = txnPath.lookup(curRoot);
     const newLeaf = this.callHandler(curRoot, curLeaf, comps);
+    this._before = curLeaf;
+    this._after = newLeaf;
     this._completion?.markSelfSettled({ value: newLeaf, old: curLeaf });
     return curLeaf !== newLeaf ? txnPath.setValue(curRoot, newLeaf) : curRoot;
   }
@@ -15442,6 +15638,12 @@ var init_transactor = __esm(() => {
       this._dispatchPath ??= this.path.compact();
       return this._dispatchPath;
     }
+    get observeKind() {
+      return "input";
+    }
+    get observeName() {
+      return this.e?.type ?? null;
+    }
     buildRootStack(root, comps) {
       return Stack2.root(comps, root, this);
     }
@@ -15449,13 +15651,6 @@ var init_transactor = __esm(() => {
       const stack = this.buildStack(root, comps);
       const [handler, args] = this.handler.getHandlerAndArgs(stack, this);
       const path = this.dispatchPath;
-      let dispatcher;
-      for (let i = 0;i < args.length; i++) {
-        if (args[i]?.toHandlerArg) {
-          dispatcher ??= new Dispatcher(path, this.transactor, this);
-          args[i] = args[i].toHandlerArg(dispatcher);
-        }
-      }
       args.push(new EventContext(path, this.transactor, this));
       return [handler, args];
     }
@@ -15510,9 +15705,26 @@ var init_transactor = __esm(() => {
       this.targetPath = path;
     }
     handlerProp = null;
+    get observeKind() {
+      return this.handlerProp;
+    }
+    get observeName() {
+      return this.name;
+    }
     getHandlerForName(comp) {
       const handlers = comp?.[this.handlerProp];
-      return handlers?.[this.name] ?? handlers?.$unknown ?? nullHandler;
+      const exact = handlers?.[this.name];
+      if (exact) {
+        this._matched = "exact";
+        return exact;
+      }
+      const unknown = handlers?.$unknown;
+      if (unknown) {
+        this._matched = "unknown";
+        return unknown;
+      }
+      this._matched = "none";
+      return nullHandler;
     }
     getHandlerAndArgs(_root, instance, comps) {
       const handler = this.getHandlerForName(comps.getCompFor(instance));
@@ -15722,6 +15934,9 @@ class App {
   onChange(callback) {
     this.transactor.state.onChange(callback);
   }
+  observe(callback) {
+    return this.transactor.observe(callback);
+  }
   compile() {
     for (const Comp of this.comps.byId.values()) {
       Comp.compile(this.ParseContext);