tutuca 0.13.0 → 0.13.2

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 = [];
@@ -1179,7 +1170,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 +1416,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 +1431,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 +1481,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);
@@ -2343,20 +2334,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 +2534,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 +2723,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 +2761,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 +2814,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 +5643,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 +6092,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,39 +6112,15 @@ 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 = (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 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 FieldBool = class extends Field {
   constructor(name, defaultValue = false) {
     super("bool", name, CHECK_TYPE_BOOL, (v) => !!v, defaultValue);
@@ -6189,9 +6130,6 @@ 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 = "") {
@@ -6214,26 +6152,13 @@ var FieldFloat = class extends Field {
     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)}"`;
-  }
-};
+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 = []) {
@@ -6395,7 +6320,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 +6379,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 +6501,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 +6601,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 +6738,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 +6823,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 +6926,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 +6974,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 +6997,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 +7150,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 +7170,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 +7975,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 +8044,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 +8181,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 +8274,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 +8493,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 +8618,7 @@ export {
   UNKNOWN_X_OP,
   UNSUPPORTED_EXPR_SYNTAX,
   X_OP_IGNORES_CHILDREN,
-  check2 as check,
+  check,
   checkComponent,
   collectIterBindings,
   compileClassesToStyle,