tutuca 0.13.1 → 0.13.3

package/dist/tutuca-dev.ext.js

@@ -222,11 +222,6 @@ var writeKey = (value, key, next) => {
     value.add(next);
   } else value[key] = next;
 };
-var readSeqKey = (value, key, dval = null) => {
-  const direct = readKey(value, key, NONE);
-  if (direct !== NONE) return direct;
-  return typeof value?.get === "function" ? value.get(key, dval) : dval;
-};
 var writeSeqKey = (value, key, next) => {
   if (value instanceof Map || value instanceof Set || Array.isArray(value) || Object.hasOwn(value, key))
     writeKey(value, key, next);
@@ -239,7 +234,7 @@ var Step = class {
   }
   setDraftValue(_root, _v) {
   }
-  enterFrame(stack, _prev, next) {
+  enterFrame(stack, next) {
     return stack.enter(next, {}, true);
   }
   toAbstractPathStep() {
@@ -265,7 +260,7 @@ var BindStep = class _BindStep extends Step {
   lookup(v, _dval) {
     return v;
   }
-  enterFrame(stack, _prev, next) {
+  enterFrame(stack, next) {
     return stack.enter(next, { ...this.binds }, false);
   }
   withIndex(i) {
@@ -283,7 +278,7 @@ var ScopeBindStep = class _ScopeBindStep extends BindStep {
     super(binds);
     this.val = val;
   }
-  enterFrame(stack, _prev, next) {
+  enterFrame(stack, next) {
     const dyn = this.val.evalAsHandler(stack)?.call(stack.it) ?? {};
     return stack.enter(next, { ...this.binds, ...dyn }, false);
   }
@@ -322,13 +317,13 @@ var SeqStep = class extends Step {
     this.key = key;
   }
   lookup(v, dval = null) {
-    return readSeqKey(readKey(v, this.field, null), this.key, dval);
+    return seqGet(readKey(v, this.field, null), this.key, dval);
   }
   setDraftValue(root, v) {
     const seq = readKey(root, this.field, null);
     if (seq != null) writeSeqKey(seq, this.key, v);
   }
-  enterFrame(stack, _prev, next) {
+  enterFrame(stack, next) {
     return stack.enter(next, { key: this.key }, true);
   }
   toKey() {
@@ -344,7 +339,7 @@ var SeqAccessStep = class extends Step {
   lookup(v, dval = null) {
     const seq = readKey(v, this.seqField, NONE);
     const key = readKey(v, this.keyField, NONE);
-    return key !== NONE && seq !== NONE ? readSeqKey(seq, key, dval) : dval;
+    return key !== NONE && seq !== NONE ? seqGet(seq, key, dval) : dval;
   }
   setDraftValue(root, v) {
     const seq = readKey(root, this.seqField, NONE);
@@ -375,7 +370,7 @@ var EachBindStep = class extends Step {
   }
   // Replay the renderer's per-item binds (key, value + any @enrich-with binds)
   // so a rebuilt stack matches the one @each rendered with.
-  enterFrame(stack, _prev, next) {
+  enterFrame(stack, next) {
     return stack.enter(next, this.iterInfo.enrichBinds(stack, this.key), false);
   }
   toAbstractPathStep() {
@@ -383,7 +378,7 @@ var EachBindStep = class extends Step {
   }
 };
 var EachRenderItStep = class extends SeqStep {
-  enterFrame(stack, _prev, next) {
+  enterFrame(stack, next) {
     return stack.enter(next, { key: this.key, value: next }, false).enter(next, {}, true);
   }
   toAbstractPathStep() {
@@ -408,7 +403,7 @@ var DynStep = class extends Step {
     warnRawDynStep("lookup", this);
     return dval;
   }
-  enterFrame(stack, _prev, _next) {
+  enterFrame(stack, _next) {
     warnRawDynStep("enterFrame", this);
     return stack;
   }
@@ -546,7 +541,7 @@ var Path = class _Path {
         console.warn("bad PathItem", { root: stack.it, step, path: this });
         return null;
       }
-      stack = step.enterFrame(stack, prev, next);
+      stack = step.enterFrame(stack, next);
       prev = next;
     }
     return stack;
@@ -616,10 +611,6 @@ var Path = class _Path {
       console.warn("event reconstruction: dynamic-var producer not found", pendingDyns);
     return [new _Path(pathSteps.reverse()), handlers];
   }
-  static fromEvent(e, rNode, maxDepth, comps, stopOnNoEvent = true) {
-    const { type, target } = e;
-    return _Path.fromNodeAndEventName(target, type, rNode, maxDepth, comps, stopOnNoEvent);
-  }
 };
 function metaChain(n) {
   const out = [];
@@ -823,31 +814,14 @@ function parseBool(s, px) {
   const val = parseToken(tokens[0], px);
   return val !== null && kindOf(val) & G_BOOL ? val : null;
 }
-function parseText(s, px) {
-  return _parseSingle(s, px, G_TEXT);
-}
-function parseComponent(s, px) {
-  return _parseSingle(s, px, G_COMPONENT);
-}
-function parseSequence(s, px) {
-  return _parseSingle(s, px, G_SEQUENCE);
-}
-function parseField(s, px) {
-  return _parseSingle(s, px, G_FIELD);
-}
-function parseProvide(s, px) {
-  return _parseSingle(s, px, G_PROVIDE);
-}
-function parseMacroAttr(s, px) {
-  return _parseSingle(s, px, G_ALL);
-}
-function parseReceiveHandler(s, px) {
-  return _parseHandler(s, px, "receive", true, true, false);
-}
-function parseAlterHandler(s, px) {
-  const r = _parseHandler(s, px, "alter", false, false, true);
-  return r === null ? null : r.handlerVal;
-}
+var parseText = (s, px) => _parseSingle(s, px, G_TEXT);
+var parseComponent = (s, px) => _parseSingle(s, px, G_COMPONENT);
+var parseSequence = (s, px) => _parseSingle(s, px, G_SEQUENCE);
+var parseField = (s, px) => _parseSingle(s, px, G_FIELD);
+var parseProvide = (s, px) => _parseSingle(s, px, G_PROVIDE);
+var parseMacroAttr = (s, px) => _parseSingle(s, px, G_ALL);
+var parseReceiveHandler = (s, px) => _parseHandler(s, px, "receive", true, true, false);
+var parseAlterHandler = (s, px) => _parseHandler(s, px, "alter", false, false, true)?.handlerVal ?? null;
 function _parseHandler(s, px, namespace, allowArgs, report, allowMethod) {
   const tokens = tokenizeValue(s.trim());
   const headTok = tokens[0] ?? "";
@@ -1179,7 +1153,7 @@ var Attributes = class {
     this.items = items;
   }
   static parse(attributes, px, parseAll = false) {
-    return getAttrParser(px).parse(attributes, parseAll);
+    return new AttrParser(px).parse(attributes, parseAll);
   }
   isConstant() {
     return false;
@@ -1425,9 +1399,6 @@ var IfAttr = class extends BaseAttr {
     return this.condVal.eval(stack) ? this.thenVal.eval(stack) : this.elseVal.eval(stack);
   }
 };
-function getAttrParser(px) {
-  return new AttrParser(px);
-}
 var EventHandler = class _EventHandler {
   constructor(handlerVal, args = []) {
     this.handlerVal = handlerVal;
@@ -1443,12 +1414,6 @@ var EventHandler = class _EventHandler {
     return r === null ? null : new _EventHandler(r.handlerVal, r.args);
   }
 };
-var IntentHandler = class {
-  constructor(name, fn) {
-    this.name = name;
-    this.fn = fn;
-  }
-};
 
 // src/iteration.js
 var SEQ_INFO = /* @__PURE__ */ Symbol.for("tutuca.seqInfo");
@@ -1499,6 +1464,15 @@ var callEnricher = (enricher, it, binds, key, value, iterData) => {
   binds.key = key;
   binds.value = value;
 };
+function bindsForKey({ seq, it, loopWith, enricher, ctx }, key) {
+  const value = seqGet(seq, key, null);
+  const binds = { key, value };
+  if (enricher) {
+    const { iterData } = unpackLoopResult(loopWith.call(it, seq, ctx), seq);
+    callEnricher(enricher, it, binds, key, value, iterData);
+  }
+  return binds;
+}
 var visitKeys = (seq, keys, visit) => {
   const attrName = isIndexedSeq(seq) ? "si" : "sk";
   for (const key of keys) visit(key, seqGet(seq, key), attrName);
@@ -1536,19 +1510,9 @@ function childOpts(vnode, ns, opts) {
   const target = ns === SVG_NS && isForeignObject(vnode.tag) ? null : ns;
   return target === (opts.namespace ?? null) ? opts : { ...opts, namespace: target };
 }
-var NEVER_ASSIGN = /* @__PURE__ */ new Set([
-  "width",
-  "height",
-  "href",
-  "list",
-  "form",
-  "tabIndex",
-  "download",
-  "rowSpan",
-  "colSpan",
-  "role",
-  "popover"
-]);
+var NEVER_ASSIGN = new Set(
+  "width height href list form tabIndex download rowSpan colSpan role popover".split(" ")
+);
 var PROP_ATTR_NAME = { className: "class", htmlFor: "for" };
 function applyProperties(node, props) {
   const namespaced = isNamespaced(node);
@@ -1827,6 +1791,10 @@ function morphChildren(parentDom, oldChilds, newChilds, opts) {
     if (!used[i] && domNodes[i].parentNode === parentDom) parentDom.removeChild(domNodes[i]);
 }
 function render(vnode, container, options, prev) {
+  if (vnode == null) {
+    container.replaceChildren();
+    return { vnode: null, dom: null };
+  }
   const isFragment = vnode instanceof VFragment;
   if (prev && prev.vnode instanceof VFragment === isFragment) {
     const oldDom = isFragment ? container : prev.dom;
@@ -2343,20 +2311,11 @@ var IterInfo = class {
     const enricher = this.enrichWithVal?.evalAsHandler(stack) ?? null;
     return { seq, filter, loopWith, enricher };
   }
-  // Rebuild the per-item binds for `key`, mirroring renderEachWhen: seed
-  // { key, value }, then run @enrich-with (with @loop-with's iterData) if any.
+  // Rebuild the per-item binds for `key` (see iteration.js bindsForKey).
   enrichBinds(stack, key) {
     const { seq, filter, loopWith, enricher } = this.eval(stack);
-    const value = seqGet(seq, key, null);
-    const binds = { key, value };
-    if (enricher) {
-      const { iterData } = unpackLoopResult(
-        loopWith.call(stack.it, seq, makeLoopCtx(stack, filter)),
-        seq
-      );
-      callEnricher(enricher, stack.it, binds, key, value, iterData);
-    }
-    return binds;
+    const ctx = makeLoopCtx(stack, filter);
+    return bindsForKey({ seq, it: stack.it, loopWith, enricher, ctx }, key);
   }
 };
 function xOp(consumed = [], { wrappable = false, wrapper = null, ignoresChildren = false } = {}) {
@@ -2552,10 +2511,11 @@ var NodeEvent = class {
   }
 };
 var fwdIfCtxPred = (pred) => (w) => (that, f, args, ctx) => pred(ctx) ? w(that, f, args, ctx) : that;
-var fwdIfKey = (keyName) => fwdIfCtxPred((ctx) => ctx.e.key === keyName);
-var fwdCtrl = fwdIfCtxPred(({ e }) => isMac && e.metaKey || e.ctrlKey);
-var fwdMeta = fwdIfCtxPred(({ e }) => e.metaKey);
-var fwdAlt = fwdIfCtxPred(({ e }) => e.altKey);
+var fwdIfEventPred = (pred) => fwdIfCtxPred(({ e }) => pred(e));
+var fwdIfKey = (keyName) => fwdIfEventPred(keyIs(keyName));
+var fwdCtrl = fwdIfEventPred(macCtrl);
+var fwdMeta = fwdIfEventPred((e) => e.metaKey);
+var fwdAlt = fwdIfEventPred((e) => e.altKey);
 var MOD_WRAPPERS_FOR_ANY_EVENT = {
   ctrl: fwdCtrl,
   cmd: fwdCtrl,
@@ -2740,13 +2700,15 @@ var ComponentStack = class _ComponentStack {
   getCompFor(v) {
     return this.comps.getCompFor(v);
   }
-  // Handlers that answer an intent's `lex` leg. A name maps to a LIST, because the leg
-  // walks: a handler that returns PASS declines and hands the intent to the next one.
-  // A bare function is accepted as a one-element list.
+  // Handlers that answer an intent's `lex` leg. A name maps to a LIST of plain
+  // functions, because the leg walks: a handler that returns PASS declines and hands
+  // the intent to the next one. Each runs with no `this` and takes a dispatcher
+  // context as its final argument; resolving answers, throwing fails. A bare function
+  // is accepted as a one-element list.
   registerIntentHandlers(handlers) {
     for (const name in handlers) {
-      const fns = Array.isArray(handlers[name]) ? handlers[name] : [handlers[name]];
-      this.intentsByName[name] = fns.map((fn) => new IntentHandler(name, fn));
+      const fns = handlers[name];
+      this.intentsByName[name] = Array.isArray(fns) ? fns : [fns];
     }
   }
   // Innermost scope first, then outward. Concatenated rather than first-match, so a
@@ -2776,14 +2738,12 @@ var ComponentStack = class _ComponentStack {
   }
 };
 var ProvideInfo = class {
-  constructor(name, val) {
-    this.name = name;
+  constructor(val) {
     this.val = val;
   }
 };
 var LookupInfo = class {
-  constructor(name, val) {
-    this.name = name;
+  constructor(val) {
     this.val = val;
   }
 };
@@ -2831,13 +2791,13 @@ var Component = class {
         continue;
       }
       const val = parseProvide(this._rawProvide[key], ctx);
-      if (val) this.provide[key] = new ProvideInfo(key, val);
+      if (val) this.provide[key] = new ProvideInfo(val);
     }
     for (const entry of this._rawLookup) {
       const name = isString(entry) ? entry : isString(entry?.name) ? entry.name : null;
       if (name === null) continue;
       const defStr = isString(entry?.default) ? entry.default : null;
-      this.lookup[name] = new LookupInfo(name, defStr === null ? null : parseField(defStr, ctx));
+      this.lookup[name] = new LookupInfo(defStr === null ? null : parseField(defStr, ctx));
     }
     for (const key in this.lookup)
       if (this.provide[key] !== void 0)
@@ -5660,10 +5620,10 @@ var ATTR_VAL_CHECKERS = {
   }
 };
 function checkConsistentAttrVal(lx, val, env, skipNameVal = false, errCtx = null, isRoot = true) {
-  const check3 = ATTR_VAL_CHECKERS[val?.constructor.name];
-  if (check3 === void 0) return;
+  const check2 = ATTR_VAL_CHECKERS[val?.constructor.name];
+  if (check2 === void 0) return;
   const recurse = (sub) => checkConsistentAttrVal(lx, sub, env, skipNameVal, errCtx, false);
-  check3({ lx, val, env, errCtx, skipNameVal, recurse, isRoot });
+  check2({ lx, val, env, errCtx, skipNameVal, recurse, isRoot });
 }
 var NODE_KIND_TO_CTX = {
   RenderTextNode: { originAttr: "<x text>" },
@@ -6109,34 +6069,16 @@ function dispatchPhase(dispatcher, targetPath, phase, self) {
 // src/oo.js
 var BAD_VALUE2 = /* @__PURE__ */ Symbol("BadValue");
 var nullCoercer = (v) => v;
-function defaultToData(v) {
-  if (v instanceof Map) return [...v.entries()];
-  if (v instanceof Set) return [...v.values()];
-  return v;
-}
 var Field = class {
   constructor(type, name, typeCheck, coercer, defaultValue = null) {
     this.type = type;
     this.name = name;
     this.typeCheck = typeCheck;
     this.coercer = coercer;
-    this.checks = [];
     this.defaultValue = defaultValue;
   }
-  toDataDef() {
-    return { type: this.type, defaultValue: defaultToData(this.defaultValue) };
-  }
-  getFirstFailingCheck(v) {
-    if (!this.typeCheck.isValid(v)) return this.typeCheck;
-    for (const check3 of this.checks) if (!check3.isValid(v)) return check3;
-    return null;
-  }
   isValid(v) {
-    return this.getFirstFailingCheck(v) === null;
-  }
-  addCheck(check3) {
-    this.checks.push(check3);
-    return this;
+    return this.typeCheck(v);
   }
   coerceOr(v, defaultValue = null) {
     if (this.isValid(v)) return v;
@@ -6147,135 +6089,79 @@ var Field = class {
     return this.coerceOr(v, this.defaultValue);
   }
 };
-var Check = class {
-  isValid(_v) {
-    return true;
-  }
-  getMessage(_v) {
-    return "Invalid";
-  }
-};
-var CheckTypeAny = class extends Check {
-};
-var CHECK_TYPE_ANY = new CheckTypeAny();
-var FnCheck = class extends Check {
-  constructor(isValidFn, getMessageFn) {
-    super();
-    this._isValid = isValidFn;
-    this._getMessage = getMessageFn;
-  }
-  isValid(v) {
-    return this._isValid(v);
-  }
-  getMessage(v) {
-    return this._getMessage(v);
-  }
+var CHECK_TYPE_ANY = (_v) => true;
+var CHECK_TYPE_INT = Number.isInteger;
+var CHECK_TYPE_FLOAT = Number.isFinite;
+var CHECK_TYPE_BOOL = (v) => typeof v === "boolean";
+var CHECK_TYPE_STRING = (v) => typeof v === "string";
+var CHECK_TYPE_LIST = Array.isArray;
+var CHECK_TYPE_OBJECT = isPlainObject;
+var CHECK_TYPE_MAP = (v) => v instanceof Map;
+var CHECK_TYPE_SET = (v) => v instanceof Set;
+var COERCE_NONE = (_v) => null;
+var COERCE_BOOL = (v) => !!v;
+var COERCE_STRING = (v) => v?.toString?.() ?? "";
+var COERCE_INT = (v) => Number.isFinite(v) ? Math.trunc(v) : null;
+var COERCE_LIST = (v) => Array.isArray(v) ? [...v] : null;
+var COERCE_OBJECT = (v) => isPlainObject(v) ? { ...v } : null;
+var COERCE_MAP = (v) => {
+  if (v instanceof Map) return new Map(v);
+  if (Array.isArray(v) || isPlainObject(v))
+    return new Map(Array.isArray(v) ? v : Object.entries(v));
+  return null;
 };
-var check = (fn, message) => new FnCheck(fn, () => message);
-var CHECK_TYPE_INT = check(Number.isInteger, "Integer expected");
-var CHECK_TYPE_FLOAT = check(Number.isFinite, "Float expected");
-var CHECK_TYPE_BOOL = check((v) => typeof v === "boolean", "Boolean expected");
-var CHECK_TYPE_STRING = check((v) => typeof v === "string", "String expected");
-var CHECK_TYPE_LIST = check(Array.isArray, "Array expected");
-var CHECK_TYPE_OBJECT = check(isPlainObject, "Plain object expected");
-var CHECK_TYPE_MAP = check((v) => v instanceof Map, "Map expected");
-var CHECK_TYPE_SET = check((v) => v instanceof Set, "Set expected");
+var COERCE_SET = (v) => v instanceof Set || Array.isArray(v) ? new Set(v) : null;
 var FieldBool = class extends Field {
   constructor(name, defaultValue = false) {
-    super("bool", name, CHECK_TYPE_BOOL, (v) => !!v, defaultValue);
+    super("bool", name, CHECK_TYPE_BOOL, COERCE_BOOL, defaultValue);
   }
 };
 var FieldAny = class extends Field {
   constructor(name, defaultValue = null) {
     super("any", name, CHECK_TYPE_ANY, nullCoercer, defaultValue);
   }
-  toDataDef() {
-    return { type: getTypeName(this.defaultValue) ?? "any", defaultValue: this.defaultValue };
-  }
 };
 var FieldString = class extends Field {
   constructor(name, defaultValue = "") {
-    super("text", name, CHECK_TYPE_STRING, (v) => v?.toString?.() ?? "", defaultValue);
+    super("text", name, CHECK_TYPE_STRING, COERCE_STRING, defaultValue);
   }
 };
 var FieldInt = class extends Field {
   constructor(name, defaultValue = 0) {
-    super(
-      "int",
-      name,
-      CHECK_TYPE_INT,
-      (v) => Number.isFinite(v) ? Math.trunc(v) : null,
-      defaultValue
-    );
+    super("int", name, CHECK_TYPE_INT, COERCE_INT, defaultValue);
   }
 };
 var FieldFloat = class extends Field {
   constructor(name, defaultValue = 0) {
-    super("float", name, CHECK_TYPE_FLOAT, (_) => null, defaultValue);
-  }
-};
-var getTypeName = (v) => v?.constructor?.[COMPONENT]?.name ?? v?.constructor?.getMetaClass?.()?.name ?? null;
-var CheckTypeName = class {
-  constructor(typeName) {
-    this.typeName = typeName;
-  }
-  isValid(v) {
-    return getTypeName(v) === this.typeName;
-  }
-  getMessage(v) {
-    return `Expected "${this.typeName}", got "${getTypeName(v)}"`;
+    super("float", name, CHECK_TYPE_FLOAT, COERCE_NONE, defaultValue);
   }
 };
+var metaOf = (v) => v?.constructor?.[COMPONENT] ?? v?.constructor?.getMetaClass?.();
+var getTypeName = (v) => metaOf(v)?.name ?? null;
 var FieldComp = class extends Field {
   constructor(type, name, args) {
-    super(type, name, new CheckTypeName(type), nullCoercer, null);
+    super(type, name, (v) => getTypeName(v) === type, nullCoercer, null);
     this.args = args;
   }
-  toDataDef() {
-    return { component: this.type, args: this.args };
-  }
 };
 var FieldList = class extends Field {
   constructor(name, defaultValue = []) {
-    super("list", name, CHECK_TYPE_LIST, (v) => Array.isArray(v) ? [...v] : null, defaultValue);
+    super("list", name, CHECK_TYPE_LIST, COERCE_LIST, defaultValue);
   }
 };
 var FieldObject = class extends Field {
   constructor(name, defaultValue = {}) {
-    super(
-      "object",
-      name,
-      CHECK_TYPE_OBJECT,
-      (v) => isPlainObject(v) ? { ...v } : null,
-      defaultValue
-    );
+    super("object", name, CHECK_TYPE_OBJECT, COERCE_OBJECT, defaultValue);
   }
 };
 var FieldMap = class extends Field {
   constructor(name, defaultValue = /* @__PURE__ */ new Map()) {
-    super(
-      "map",
-      name,
-      CHECK_TYPE_MAP,
-      (v) => {
-        if (v instanceof Map) return new Map(v);
-        if (Array.isArray(v) || isPlainObject(v))
-          return new Map(Array.isArray(v) ? v : Object.entries(v));
-        return null;
-      },
-      defaultValue
-    );
+    super("map", name, CHECK_TYPE_MAP, COERCE_MAP, defaultValue);
   }
 };
 var FieldSet = class extends Field {
   constructor(name, defaultValue = /* @__PURE__ */ new Set()) {
-    super(
-      "set",
-      name,
-      CHECK_TYPE_SET,
-      (v) => v instanceof Set || Array.isArray(v) ? new Set(v) : null,
-      defaultValue
-    );
+    super("set", name, CHECK_TYPE_SET, COERCE_SET, defaultValue);
   }
 };
 function mkCompField(field, scope, args) {
@@ -6373,8 +6259,7 @@ function classFromData(name, { fields = {}, methods, statics }) {
     const value = fields[field];
     const type = typeof value;
     if (type === "string") b.addField(field, value, FieldString);
-    else if (type === "number")
-      b.addField(field, value, Number.isInteger(value) ? FieldInt : FieldFloat);
+    else if (type === "number") b.addField(field, value, FieldFloat);
     else if (type === "boolean") b.addField(field, value, FieldBool);
     else if (Array.isArray(value)) b.addField(field, [...value], FieldList);
     else if (value instanceof Set) b.addField(field, new Set(value), FieldSet);
@@ -6395,7 +6280,7 @@ function classFromData(name, { fields = {}, methods, statics }) {
   return b.build();
 }
 function validateDraftFields(current, draft) {
-  const meta = current?.constructor?.[COMPONENT] ?? current?.constructor?.getMetaClass?.();
+  const meta = metaOf(current);
   if (!meta) return;
   for (const [name, field] of Object.entries(meta.fields)) {
     const value = draft[name];
@@ -6454,7 +6339,7 @@ var component = (opts) => Component.fromSpec(opts);
 // src/stack.js
 var STOP = /* @__PURE__ */ Symbol("STOP");
 var NEXT = /* @__PURE__ */ Symbol("NEXT");
-var DEFAULT_LOOKUP_ROUTE = ["dyn", "lex"];
+var DEFAULT_ROUTE = ["dyn", "lex"];
 function routeLookup(route, lex, dyn) {
   for (let i = 0; i < route.length; i++) {
     const leg = route[i];
@@ -6576,20 +6461,6 @@ var Stack = class _Stack {
   lookupBind(name) {
     return lookup(this.binds, name);
   }
-  // The `lex` leg: what a name means in the registration scope of the component being
-  // rendered. The scope chain holds components, so this leg only ever answers for a
-  // type name — for a value name it is a miss, which is why one default route serves
-  // both. Guarded: a non-component `it` has no scope to ask.
-  _lookupLex(name) {
-    return this.comps.getCompFor(this.it)?.scope.lookupComponent(name) ?? null;
-  }
-  lookupRouted(name, route = DEFAULT_LOOKUP_ROUTE) {
-    return routeLookup(
-      route,
-      () => this._lookupLex(name),
-      () => this.lookupDynamic(name)
-    );
-  }
   lookupFieldRaw(name) {
     return this.it[name] ?? null;
   }
@@ -6690,28 +6561,46 @@ var Transactor = class {
       if (i !== -1) this._refusalObservers.splice(i, 1);
     };
   }
-  // Build and dispatch the observer record for a settled transaction. The
-  // resolved handler (`_resolvedHandler`/`_matched`) and per-leaf before/after
-  // (`_before`/`_after`) were captured while the handler ran (see callHandler /
-  // Transaction.run). No-op when nobody is observing.
+  // Build and dispatch one observer record. Pins field-resolved keys (e.g. a
+  // `.a[.selId]` render target reconstructed from a DOM event) against the root the
+  // handler read, so pathKeys carries concrete keys instead of dropping the dynamic
+  // step. No-op when nobody is observing.
+  _emitRecord(root, { kind, name, args, path, targetPath, handler, handlerName, matched, before, after, parent }) {
+    if (this._observers.length === 0) return;
+    const pinned = path.pinKeys(root);
+    this._emit({
+      kind,
+      name,
+      args: args ?? null,
+      path: pinned,
+      pathKeys: pinned.toKeys(),
+      targetPath,
+      handler: handler ?? null,
+      handlerName: handlerName ?? (handler?.name || null),
+      matched: matched ?? null,
+      before,
+      after,
+      parent,
+      timestamp: Date.now()
+    });
+  }
+  // The observer record for a settled transaction. The resolved handler
+  // (`_resolvedHandler`/`_matched`) and per-leaf before/after (`_before`/`_after`)
+  // were captured while the handler ran (see callHandler / Transaction.run).
   _emitTransaction(transaction, root) {
     if (this._observers.length === 0) return;
     if (transaction._resolvedHandler === void 0) return;
-    const path = transaction.getTransactionPath().pinKeys(root);
-    this._emit({
+    this._emitRecord(root, {
       kind: transaction.observeKind,
       name: transaction.observeName,
-      args: transaction.args ?? null,
-      path,
-      pathKeys: path.toKeys(),
+      args: transaction.args,
+      path: transaction.getTransactionPath(),
       targetPath: transaction.targetPath ?? transaction.path,
-      handler: transaction._resolvedHandler ?? null,
-      handlerName: transaction._resolvedHandler?.name || null,
-      matched: transaction._matched ?? null,
+      handler: transaction._resolvedHandler,
+      matched: transaction._matched,
       before: transaction._before,
       after: transaction._after,
-      parent: transaction.parentTransaction,
-      timestamp: Date.now()
+      parent: transaction.parentTransaction
     });
   }
   // Make `child` a tracked unit of `parent`'s subtree: the parent's completion stays open
@@ -6809,7 +6698,7 @@ var Transaction = class {
   // rather than throwing, so a stray call from the wrong place is a message and not a
   // crash. `walk` is undefined here, which is how ctx.reply/ctx.fail tell the two apart.
   stop() {
-    console.warn('ctx.stop() is only meaningful in an "intent" handler - ignored');
+    warnNotIntent("stop");
   }
   forward(_opts) {
     console.warn('ctx.forward() needs a "receive" or "intent" handler - ignored');
@@ -6894,11 +6783,8 @@ var InputEvent = class extends Transaction {
     }
     this.transactor.pushIntent(this.dispatchPath, name, args, rest, this);
   }
-  buildStack(root, comps) {
-    return this.path.toTransactionPath().buildStack(Stack.root(comps, root, this));
-  }
   getHandlerAndArgs(root, _instance, comps) {
-    const stack = this.buildStack(root, comps);
+    const stack = this.path.toTransactionPath().buildStack(Stack.root(comps, root, this));
     const [handler, args] = this.handler.getHandlerAndArgs(stack, this);
     this._handlerArgs = [...args];
     const path = this.dispatchPath;
@@ -7000,7 +6886,6 @@ var IntentEvent = class extends NameArgsTransaction {
 };
 var PASS = /* @__PURE__ */ Symbol.for("tutuca.intent.pass");
 var REFUSAL_RING_CAP = 200;
-var DEFAULT_ROUTE = ["dyn", "lex"];
 var INTENT_DEPTH = 64;
 var IntentWalk = class {
   constructor(transactor, path, name, args, opts, parent, release) {
@@ -7049,24 +6934,19 @@ var IntentWalk = class {
     const txnPath = this.origin.toTransactionPath();
     const leaf = txnPath.lookup(root);
     const chain = this.transactor.comps.getIntentChainFor(leaf, this.name);
-    if (this.transactor._observers.length > 0) {
-      const path = txnPath.pinKeys(root);
-      this.transactor._emit({
-        kind: "intent",
-        name: this.name,
-        args: this.args,
-        path,
-        pathKeys: path.toKeys(),
-        targetPath: this.origin,
-        handler: chain[0]?.fn ?? null,
-        handlerName: chain[0]?.fn?.name || this.name,
-        matched: chain.length > 0 ? "exact" : "none",
-        before: leaf,
-        after: void 0,
-        parent: this.parent,
-        timestamp: Date.now()
-      });
-    }
+    this.transactor._emitRecord(root, {
+      kind: "intent",
+      name: this.name,
+      args: this.args,
+      path: txnPath,
+      targetPath: this.origin,
+      handler: chain[0],
+      handlerName: chain[0]?.name || this.name,
+      matched: chain.length > 0 ? "exact" : "none",
+      before: leaf,
+      after: void 0,
+      parent: this.parent
+    });
     if (chain.length === 0) return this.advance();
     const p = this._runLex(chain, 0);
     this.transactor._inflight.add(p);
@@ -7077,7 +6957,7 @@ var IntentWalk = class {
     if (i >= chain.length) return this.advance();
     const ctx = new Dispatcher(this.origin, this.transactor, this.parent);
     try {
-      const res = await chain[i].fn.apply(null, [...this.args, ctx]);
+      const res = await chain[i].apply(null, [...this.args, ctx]);
       if (res === PASS) return this._runLex(chain, i + 1);
       this.answer("Ok", res);
     } catch (error) {
@@ -7230,9 +7110,8 @@ var Dispatcher = class {
   // the same spelling as `ctx.intent` — `["dyn"]` the render ancestry, `["lex"]` the
   // registration scope, default both.
   lookup(name, opts) {
-    const route = opts?.route ?? DEFAULT_LOOKUP_ROUTE;
     return routeLookup(
-      route,
+      opts?.route ?? DEFAULT_ROUTE,
       () => this._lookupLex(name),
       () => this._stack()?.lookupDynamic(name) ?? null
     );
@@ -7251,12 +7130,10 @@ var Dispatcher = class {
   // can only ever answer with one; the `dyn` leg reads a binding an ancestor
   // published, so it is the leg that has to be checked.
   lookupType(name, opts) {
-    const v = this.lookup(name, opts);
+    const route = opts?.route ?? DEFAULT_ROUTE;
+    const v = this.lookup(name, { route });
     if (v == null) {
-      this.transactor.refuse("TYPE_NOT_FOUND", {
-        name,
-        route: opts?.route ?? DEFAULT_LOOKUP_ROUTE
-      });
+      this.transactor.refuse("TYPE_NOT_FOUND", { name, route });
       return null;
     }
     if (v?.[COMPONENT] == null) {
@@ -8058,7 +7935,14 @@ var App = class {
     const { type } = e;
     const isDrag = type === "dragover" || type === "dragstart" || type === "dragend" || type === "drop";
     const { rootNode: root, maxEventNodeDepth: maxDepth, comps, transactor } = this;
-    const [path, handlers] = Path.fromEvent(e, root, maxDepth, comps, !isDrag);
+    const [path, handlers] = Path.fromNodeAndEventName(
+      e.target,
+      type,
+      root,
+      maxDepth,
+      comps,
+      !isDrag
+    );
     if (isDrag) this._handleDragEvent(e, type, path);
     if (path !== null && handlers !== null)
       for (const handler of handlers) transactor.transactInputNow(path, e, handler, this.dragInfo);
@@ -8120,7 +8004,7 @@ var App = class {
       const value = txnPath.lookup(rootValue);
       const dragType = e.target.dataset.dragtype ?? "?";
       const stack = path.toTransactionPath().buildStack(this.makeStack(rootValue));
-      this.dragInfo = new DragInfo(txnPath, stack, e, value, dragType, e.target);
+      this.dragInfo = new DragInfo(stack, value, dragType, e.target);
     } else if (type === "drop") {
       e.preventDefault();
       this._cleanDragOverAttrs();
@@ -8257,10 +8141,8 @@ function getClosestDropTarget(target, rootNode, count) {
   return null;
 }
 var DragInfo = class {
-  constructor(path, stack, e, val, type, node) {
-    this.path = path;
+  constructor(stack, val, type, node) {
     this.stack = stack;
-    this.e = e;
     this.val = val;
     this.type = type;
     this.node = node;
@@ -8352,6 +8234,8 @@ var Renderer = class {
   setNullCache() {
     this.cache = new NullDomCache();
   }
+  // Library utilities for consumers embedding tutuca: render a value to a detached
+  // DOM node / an HTML string. Not called by the framework itself.
   renderToDOM(stack, val) {
     const rootNode = document.createElement("div");
     const rOpts = { document };
@@ -8569,7 +8453,7 @@ function shadowCheckComponent(Comp) {
   });
   return checkComponent(shadowComp).reports;
 }
-function check2(app) {
+function check(app) {
   const counts = { error: 0, warn: 0, hint: 0 };
   for (const Comp of app.comps.byId.values()) {
     const reports = shadowCheckComponent(Comp);
@@ -8694,7 +8578,7 @@ export {
   UNKNOWN_X_OP,
   UNSUPPORTED_EXPR_SYNTAX,
   X_OP_IGNORES_CHILDREN,
-  check2 as check,
+  check,
   checkComponent,
   collectIterBindings,
   compileClassesToStyle,