tutuca 0.13.1 → 0.13.3

package/dist/tutuca-cli.js

@@ -1069,9 +1069,10 @@ function resolvePathStep(comp, nodeIds, vid) {
   }
   return null;
 }
-var NONE, readKey, writeKey, readSeqKey, writeSeqKey, Step, BindStep, ScopeBindStep, FieldStep, SeqStep, SeqAccessStep, EachBindStep, EachRenderItStep, DynStep, DynEachStep, Path, StepCtx, NO_EVENT_INFO, BUBBLING_EVENTS, PathBuilder;
+var NONE, readKey, writeKey, writeSeqKey, Step, BindStep, ScopeBindStep, FieldStep, SeqStep, SeqAccessStep, EachBindStep, EachRenderItStep, DynStep, DynEachStep, Path, StepCtx, NO_EVENT_INFO, BUBBLING_EVENTS, PathBuilder;
 var init_path = __esm({
   "src/path.js"() {
+    init_collection();
     init_immer2();
     NONE = /* @__PURE__ */ Symbol("NONE");
     readKey = (value, key, dval = null) => {
@@ -1087,11 +1088,6 @@ var init_path = __esm({
         value.add(next);
       } else value[key] = next;
     };
-    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;
-    };
     writeSeqKey = (value, key, next) => {
       if (value instanceof Map || value instanceof Set || Array.isArray(value) || Object.hasOwn(value, key))
         writeKey(value, key, next);
@@ -1104,7 +1100,7 @@ var init_path = __esm({
       }
       setDraftValue(_root, _v) {
       }
-      enterFrame(stack, _prev, next) {
+      enterFrame(stack, next) {
         return stack.enter(next, {}, true);
       }
       toAbstractPathStep() {
@@ -1130,7 +1126,7 @@ var init_path = __esm({
       lookup(v, _dval) {
         return v;
       }
-      enterFrame(stack, _prev, next) {
+      enterFrame(stack, next) {
         return stack.enter(next, { ...this.binds }, false);
       }
       withIndex(i) {
@@ -1148,7 +1144,7 @@ var init_path = __esm({
         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);
       }
@@ -1187,13 +1183,13 @@ var init_path = __esm({
         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() {
@@ -1209,7 +1205,7 @@ var init_path = __esm({
       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);
@@ -1240,7 +1236,7 @@ var init_path = __esm({
       }
       // 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() {
@@ -1248,7 +1244,7 @@ var init_path = __esm({
       }
     };
     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() {
@@ -1270,7 +1266,7 @@ var init_path = __esm({
         warnRawDynStep("lookup", this);
         return dval;
       }
-      enterFrame(stack, _prev, _next) {
+      enterFrame(stack, _next) {
         warnRawDynStep("enterFrame", this);
         return stack;
       }
@@ -1408,7 +1404,7 @@ var init_path = __esm({
             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;
@@ -1478,10 +1474,6 @@ var init_path = __esm({
           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: type3, target } = e;
-        return _Path.fromNodeAndEventName(target, type3, rNode, maxDepth, comps, stopOnNoEvent);
-      }
     };
     StepCtx = class _StepCtx {
       constructor(comp, nodeIds, idx, vid) {
@@ -1627,31 +1619,6 @@ 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;
-}
 function _parseHandler(s, px, namespace, allowArgs, report, allowMethod) {
   const tokens = tokenizeValue(s.trim());
   const headTok = tokens[0] ?? "";
@@ -1721,7 +1688,7 @@ function kindOf(val) {
   if (val instanceof EventMemberVal) return K_EVENT;
   return 0;
 }
-var VALID_VAL_ID_RE, isValidValId, VALID_FLOAT_RE, STR_TPL_SPLIT_RE, mkVal, VAL_TOKEN_RE, tokenizeValue, unescapeStr, K_CONST, K_STRTPL, K_FIELD, K_BIND, K_DYN, K_NAME, K_SEQ, K_METHOD, K_EVENT, G_BOOL, G_TEXT, G_COMPONENT, G_SEQUENCE, G_PROVIDE, G_FIELD, G_VALUE, G_HANDLER_ARG, G_ALL, toNullIfNaN, predTruthy, PREDICATES, BaseVal, ConstVal, NULL_CONST_VAL, PredicateVal, VarVal, StrTplVal, NameVal, HandlerNameVal, mk404Handler, keyIs, macCtrl, nullSafe, EVENT_CONVENIENCES, EventMemberVal, RenderVal, RenderNameVal, BindVal, BindMemberVal, DynVal, FieldVal, MethodVal, SeqAccessVal;
+var VALID_VAL_ID_RE, isValidValId, VALID_FLOAT_RE, STR_TPL_SPLIT_RE, mkVal, VAL_TOKEN_RE, tokenizeValue, unescapeStr, K_CONST, K_STRTPL, K_FIELD, K_BIND, K_DYN, K_NAME, K_SEQ, K_METHOD, K_EVENT, G_BOOL, G_TEXT, G_COMPONENT, G_SEQUENCE, G_PROVIDE, G_FIELD, G_VALUE, G_HANDLER_ARG, G_ALL, toNullIfNaN, predTruthy, PREDICATES, parseText, parseComponent, parseSequence, parseField, parseProvide, parseMacroAttr, parseReceiveHandler, parseAlterHandler, BaseVal, ConstVal, NULL_CONST_VAL, PredicateVal, VarVal, StrTplVal, NameVal, HandlerNameVal, mk404Handler, keyIs, macCtrl, nullSafe, EVENT_CONVENIENCES, EventMemberVal, RenderVal, RenderNameVal, BindVal, BindMemberVal, DynVal, FieldVal, MethodVal, SeqAccessVal;
 var init_value = __esm({
   "src/value.js"() {
     init_collection();
@@ -1765,6 +1732,14 @@ var init_value = __esm({
       "null?": { name: "null?", arity: 1, fn: (v) => v == null },
       "equals?": { name: "equals?", arity: 2, fn: (a, b) => Object.is(a, b) }
     };
+    parseText = (s, px) => _parseSingle(s, px, G_TEXT);
+    parseComponent = (s, px) => _parseSingle(s, px, G_COMPONENT);
+    parseSequence = (s, px) => _parseSingle(s, px, G_SEQUENCE);
+    parseField = (s, px) => _parseSingle(s, px, G_FIELD);
+    parseProvide = (s, px) => _parseSingle(s, px, G_PROVIDE);
+    parseMacroAttr = (s, px) => _parseSingle(s, px, G_ALL);
+    parseReceiveHandler = (s, px) => _parseHandler(s, px, "receive", true, true, false);
+    parseAlterHandler = (s, px) => _parseHandler(s, px, "alter", false, false, true)?.handlerVal ?? null;
     BaseVal = class {
       render(_stack, _rx) {
       }
@@ -2042,10 +2017,7 @@ function parseIterationDirectives(attributes, px) {
   };
   return { whenVal: parseNamed("when"), loopWithVal: parseNamed("loop-with") };
 }
-function getAttrParser(px) {
-  return new AttrParser(px);
-}
-var Attributes, booleanAttrsRaw, booleanAttrs, AttrParser, ConstAttrs, DynAttrs, BaseAttr, Attr, ConstAttr, RawHtmlAttr, NOT_SET_VAL, IfAttr, EventHandler, IntentHandler;
+var Attributes, booleanAttrsRaw, booleanAttrs, AttrParser, ConstAttrs, DynAttrs, BaseAttr, Attr, ConstAttr, RawHtmlAttr, NOT_SET_VAL, IfAttr, EventHandler;
 var init_attribute = __esm({
   "src/attribute.js"() {
     init_value();
@@ -2054,7 +2026,7 @@ var init_attribute = __esm({
         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;
@@ -2297,16 +2269,19 @@ var init_attribute = __esm({
         return r === null ? null : new _EventHandler(r.handlerVal, r.args);
       }
     };
-    IntentHandler = class {
-      constructor(name, fn) {
-        this.name = name;
-        this.fn = fn;
-      }
-    };
   }
 });
 
 // src/iteration.js
+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;
+}
 function walkLoopBindings({ seq, it, filter, loopWith, enricher, ctx }, visit) {
   const { iterData, start, end, keys } = unpackLoopResult(loopWith.call(it, seq, ctx), seq);
   const visitOne = (key, value, attrName) => {
@@ -2566,6 +2541,10 @@ function morphChildren(parentDom, oldChilds, newChilds, opts) {
     if (!used2[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;
@@ -2615,19 +2594,9 @@ var init_vdom = __esm({
     };
     isForeignObject = (tag) => tag.length === 13 && tag.toLowerCase() === "foreignobject";
     effectiveNs = (vnode, opts) => vnode.namespace ?? opts.namespace ?? null;
-    NEVER_ASSIGN = /* @__PURE__ */ new Set([
-      "width",
-      "height",
-      "href",
-      "list",
-      "form",
-      "tabIndex",
-      "download",
-      "rowSpan",
-      "colSpan",
-      "role",
-      "popover"
-    ]);
+    NEVER_ASSIGN = new Set(
+      "width height href list form tabIndex download rowSpan colSpan role popover".split(" ")
+    );
     PROP_ATTR_NAME = { className: "class", htmlFor: "for" };
     VBase = class {
     };
@@ -2906,14 +2875,12 @@ function compileModifiers(eventName, names) {
     return w(this, f, args, ctx);
   };
 }
-var BaseNode, TextNode, CommentNode, ChildsNode, DomNode, FragmentNode, maybeFragment, VALID_NODE_RE, ANode, MacroNode, RenderViewId, RenderNode, RenderItNode, RenderTextNode, RenderOnceNode, WrapperNode, ShowNode, HideNode, PushViewNameNode, SlotNode, ScopeNode, EachNode, IterInfo, X_OPS, WRAPPER_NODES, ParseContext, _htmlBlockTags, HTML_BLOCK_TAGS, isBlockDomNode, isEmptyText, isIgnorableXChild, hasMeaningfulChilds, View, NodeEvents, NodeEvent, fwdIfCtxPred, fwdIfKey, fwdCtrl, fwdMeta, fwdAlt, MOD_WRAPPERS_FOR_ANY_EVENT, MOD_WRAPPERS_BY_EVENT, MOD_EFFECTS, NO_WRAPPERS, identityModifierWrapper;
+var BaseNode, TextNode, CommentNode, ChildsNode, DomNode, FragmentNode, maybeFragment, VALID_NODE_RE, ANode, MacroNode, RenderViewId, RenderNode, RenderItNode, RenderTextNode, RenderOnceNode, WrapperNode, ShowNode, HideNode, PushViewNameNode, SlotNode, ScopeNode, EachNode, IterInfo, X_OPS, WRAPPER_NODES, ParseContext, _htmlBlockTags, HTML_BLOCK_TAGS, isBlockDomNode, isEmptyText, isIgnorableXChild, hasMeaningfulChilds, View, NodeEvents, NodeEvent, fwdIfCtxPred, fwdIfEventPred, fwdIfKey, fwdCtrl, fwdMeta, fwdAlt, MOD_WRAPPERS_FOR_ANY_EVENT, MOD_WRAPPERS_BY_EVENT, MOD_EFFECTS, NO_WRAPPERS, identityModifierWrapper;
 var init_anode = __esm({
   "src/anode.js"() {
     init_attribute();
-    init_collection();
     init_iteration();
     init_path();
-    init_env();
     init_value();
     init_vdom();
     BaseNode = class {
@@ -3253,20 +3220,11 @@ var init_anode = __esm({
         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);
       }
     };
     X_OPS = {
@@ -3440,10 +3398,11 @@ var init_anode = __esm({
       }
     };
     fwdIfCtxPred = (pred) => (w) => (that, f, args, ctx) => pred(ctx) ? w(that, f, args, ctx) : that;
-    fwdIfKey = (keyName) => fwdIfCtxPred((ctx) => ctx.e.key === keyName);
-    fwdCtrl = fwdIfCtxPred(({ e }) => isMac && e.metaKey || e.ctrlKey);
-    fwdMeta = fwdIfCtxPred(({ e }) => e.metaKey);
-    fwdAlt = fwdIfCtxPred(({ e }) => e.altKey);
+    fwdIfEventPred = (pred) => fwdIfCtxPred(({ e }) => pred(e));
+    fwdIfKey = (keyName) => fwdIfEventPred(keyIs(keyName));
+    fwdCtrl = fwdIfEventPred(macCtrl);
+    fwdMeta = fwdIfEventPred((e) => e.metaKey);
+    fwdAlt = fwdIfEventPred((e) => e.altKey);
     MOD_WRAPPERS_FOR_ANY_EVENT = {
       ctrl: fwdCtrl,
       cmd: fwdCtrl,
@@ -3470,7 +3429,6 @@ var COMPONENT, Components, ComponentStack, ProvideInfo, LookupInfo, isString, is
 var init_components = __esm({
   "src/components.js"() {
     init_anode();
-    init_attribute();
     init_value();
     COMPONENT = /* @__PURE__ */ Symbol.for("tutuca.component");
     Components = class {
@@ -3538,13 +3496,15 @@ var init_components = __esm({
       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
@@ -3574,14 +3534,12 @@ var init_components = __esm({
       }
     };
     ProvideInfo = class {
-      constructor(name, val) {
-        this.name = name;
+      constructor(val) {
         this.val = val;
       }
     };
     LookupInfo = class {
-      constructor(name, val) {
-        this.name = name;
+      constructor(val) {
         this.val = val;
       }
     };
@@ -3629,13 +3587,13 @@ var init_components = __esm({
             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)
@@ -6288,10 +6246,10 @@ function reportUnknownName(lx, code, name, candidates, info) {
   lx.error(code, { ...info, name }, replaceNameSuggestion(name, candidates));
 }
 function checkConsistentAttrVal(lx, val, env, skipNameVal = false, errCtx = null, isRoot = true) {
-  const check2 = ATTR_VAL_CHECKERS[val?.constructor.name];
-  if (check2 === void 0) return;
+  const check = ATTR_VAL_CHECKERS[val?.constructor.name];
+  if (check === void 0) return;
   const recurse = (sub) => checkConsistentAttrVal(lx, sub, env, skipNameVal, errCtx, false);
-  check2({ lx, val, env, errCtx, skipNameVal, recurse, isRoot });
+  check({ lx, val, env, errCtx, skipNameVal, recurse, isRoot });
 }
 function nodeCtxForNode(nodeKind) {
   return NODE_KIND_TO_CTX[nodeKind] ?? null;
@@ -12836,12 +12794,12 @@ function computeViewsId(views) {
   }
   return s === "main" ? "" : s;
 }
-var STOP, NEXT, DEFAULT_LOOKUP_ROUTE, BindFrame, ObjectFrame, Stack;
+var STOP, NEXT, DEFAULT_ROUTE, BindFrame, ObjectFrame, Stack;
 var init_stack = __esm({
   "src/stack.js"() {
     STOP = /* @__PURE__ */ Symbol("STOP");
     NEXT = /* @__PURE__ */ Symbol("NEXT");
-    DEFAULT_LOOKUP_ROUTE = ["dyn", "lex"];
+    DEFAULT_ROUTE = ["dyn", "lex"];
     BindFrame = class {
       constructor(it, binds, isFrame) {
         this.it = it;
@@ -12929,20 +12887,6 @@ var init_stack = __esm({
       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;
       }
@@ -12975,11 +12919,6 @@ var init_stack = __esm({
 });
 
 // src/oo.js
-function defaultToData(v) {
-  if (v instanceof Map) return [...v.entries()];
-  if (v instanceof Set) return [...v.values()];
-  return v;
-}
 function mkCompField(field, scope, args) {
   const Comp = scope?.lookupComponent(field.type) ?? null;
   if (Comp === null)
@@ -12999,8 +12938,7 @@ function classFromData(name, { fields = {}, methods, statics }) {
     const value = fields[field];
     const type3 = typeof value;
     if (type3 === "string") b.addField(field, value, FieldString);
-    else if (type3 === "number")
-      b.addField(field, value, Number.isInteger(value) ? FieldInt : FieldFloat);
+    else if (type3 === "number") b.addField(field, value, FieldFloat);
     else if (type3 === "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);
@@ -13021,7 +12959,7 @@ function classFromData(name, { fields = {}, methods, statics }) {
   return b.build();
 }
 function validateDraftFields(current2, draft) {
-  const meta = current2?.constructor?.[COMPONENT] ?? current2?.constructor?.getMetaClass?.();
+  const meta = metaOf(current2);
   if (!meta) return;
   for (const [name, field] of Object.entries(meta.fields)) {
     const value = draft[name];
@@ -13041,7 +12979,7 @@ function assertNoReservedComponentStatics(statics = {}) {
     }
   }
 }
-var BAD_VALUE2, nullCoercer, Field, Check, CheckTypeAny, CHECK_TYPE_ANY, FnCheck, check, CHECK_TYPE_INT, CHECK_TYPE_FLOAT, CHECK_TYPE_BOOL, CHECK_TYPE_STRING, CHECK_TYPE_LIST, CHECK_TYPE_OBJECT, CHECK_TYPE_MAP, CHECK_TYPE_SET, FieldBool, FieldAny, FieldString, FieldInt, FieldFloat, getTypeName, CheckTypeName, FieldComp, FieldList, FieldObject, FieldMap, FieldSet, ClassBuilder, FIELD_CLASS, fieldsByTypeName, META_KEYS, RESERVED_COMPONENT_STATICS;
+var BAD_VALUE2, nullCoercer, Field, CHECK_TYPE_ANY, CHECK_TYPE_INT, CHECK_TYPE_FLOAT, CHECK_TYPE_BOOL, CHECK_TYPE_STRING, CHECK_TYPE_LIST, CHECK_TYPE_OBJECT, CHECK_TYPE_MAP, CHECK_TYPE_SET, COERCE_NONE, COERCE_BOOL, COERCE_STRING, COERCE_INT, COERCE_LIST, COERCE_OBJECT, COERCE_MAP, COERCE_SET, FieldBool, FieldAny, FieldString, FieldInt, FieldFloat, metaOf, getTypeName, FieldComp, FieldList, FieldObject, FieldMap, FieldSet, ClassBuilder, FIELD_CLASS, fieldsByTypeName, META_KEYS, RESERVED_COMPONENT_STATICS;
 var init_oo = __esm({
   "src/oo.js"() {
     init_collection();
@@ -13055,23 +12993,10 @@ var init_oo = __esm({
         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 check2 of this.checks) if (!check2.isValid(v)) return check2;
-        return null;
-      }
       isValid(v) {
-        return this.getFirstFailingCheck(v) === null;
-      }
-      addCheck(check2) {
-        this.checks.push(check2);
-        return this;
+        return this.typeCheck(v);
       }
       coerceOr(v, defaultValue = null) {
         if (this.isValid(v)) return v;
@@ -13082,135 +13007,79 @@ var init_oo = __esm({
         return this.coerceOr(v, this.defaultValue);
       }
     };
-    Check = class {
-      isValid(_v) {
-        return true;
-      }
-      getMessage(_v) {
-        return "Invalid";
-      }
-    };
-    CheckTypeAny = class extends Check {
-    };
-    CHECK_TYPE_ANY = new CheckTypeAny();
-    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);
-      }
+    CHECK_TYPE_ANY = (_v) => true;
+    CHECK_TYPE_INT = Number.isInteger;
+    CHECK_TYPE_FLOAT = Number.isFinite;
+    CHECK_TYPE_BOOL = (v) => typeof v === "boolean";
+    CHECK_TYPE_STRING = (v) => typeof v === "string";
+    CHECK_TYPE_LIST = Array.isArray;
+    CHECK_TYPE_OBJECT = isPlainObject;
+    CHECK_TYPE_MAP = (v) => v instanceof Map;
+    CHECK_TYPE_SET = (v) => v instanceof Set;
+    COERCE_NONE = (_v) => null;
+    COERCE_BOOL = (v) => !!v;
+    COERCE_STRING = (v) => v?.toString?.() ?? "";
+    COERCE_INT = (v) => Number.isFinite(v) ? Math.trunc(v) : null;
+    COERCE_LIST = (v) => Array.isArray(v) ? [...v] : null;
+    COERCE_OBJECT = (v) => isPlainObject(v) ? { ...v } : null;
+    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;
     };
-    check = (fn, message) => new FnCheck(fn, () => message);
-    CHECK_TYPE_INT = check(Number.isInteger, "Integer expected");
-    CHECK_TYPE_FLOAT = check(Number.isFinite, "Float expected");
-    CHECK_TYPE_BOOL = check((v) => typeof v === "boolean", "Boolean expected");
-    CHECK_TYPE_STRING = check((v) => typeof v === "string", "String expected");
-    CHECK_TYPE_LIST = check(Array.isArray, "Array expected");
-    CHECK_TYPE_OBJECT = check(isPlainObject, "Plain object expected");
-    CHECK_TYPE_MAP = check((v) => v instanceof Map, "Map expected");
-    CHECK_TYPE_SET = check((v) => v instanceof Set, "Set expected");
+    COERCE_SET = (v) => v instanceof Set || Array.isArray(v) ? new Set(v) : null;
     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);
       }
     };
     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 };
-      }
     };
     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);
       }
     };
     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);
       }
     };
     FieldFloat = class extends Field {
       constructor(name, defaultValue = 0) {
-        super("float", name, CHECK_TYPE_FLOAT, (_) => null, defaultValue);
-      }
-    };
-    getTypeName = (v) => v?.constructor?.[COMPONENT]?.name ?? v?.constructor?.getMetaClass?.()?.name ?? null;
-    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);
       }
     };
+    metaOf = (v) => v?.constructor?.[COMPONENT] ?? v?.constructor?.getMetaClass?.();
+    getTypeName = (v) => metaOf(v)?.name ?? null;
     FieldComp = class extends Field {
       constructor(type3, name, args) {
-        super(type3, name, new CheckTypeName(type3), nullCoercer, null);
+        super(type3, name, (v) => getTypeName(v) === type3, nullCoercer, null);
         this.args = args;
       }
-      toDataDef() {
-        return { component: this.type, args: this.args };
-      }
     };
     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);
       }
     };
     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);
       }
     };
     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);
       }
     };
     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);
       }
     };
     ClassBuilder = class {
@@ -13336,7 +13205,7 @@ function warnNotIntent(verb) {
 function rootDispatcher(transactor) {
   return new Dispatcher(new Path([]), transactor, null);
 }
-var State2, Transactor, Transaction, InputEvent, NameArgsTransaction, SendEvent, IntentEvent, PASS, REFUSAL_RING_CAP, DEFAULT_ROUTE, INTENT_DEPTH, IntentWalk, Completion, Dispatcher, EventContext, PathChanges;
+var State2, Transactor, Transaction, InputEvent, NameArgsTransaction, SendEvent, IntentEvent, PASS, REFUSAL_RING_CAP, INTENT_DEPTH, IntentWalk, Completion, Dispatcher, EventContext, PathChanges;
 var init_transactor = __esm({
   "src/transactor.js"() {
     init_components();
@@ -13414,28 +13283,46 @@ var init_transactor = __esm({
           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
@@ -13530,7 +13417,7 @@ var init_transactor = __esm({
       // 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');
@@ -13615,11 +13502,8 @@ var init_transactor = __esm({
         }
         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;
@@ -13721,7 +13605,6 @@ var init_transactor = __esm({
     };
     PASS = /* @__PURE__ */ Symbol.for("tutuca.intent.pass");
     REFUSAL_RING_CAP = 200;
-    DEFAULT_ROUTE = ["dyn", "lex"];
     INTENT_DEPTH = 64;
     IntentWalk = class {
       constructor(transactor, path, name, args, opts, parent, release) {
@@ -13770,24 +13653,19 @@ var init_transactor = __esm({
         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);
@@ -13798,7 +13676,7 @@ var init_transactor = __esm({
         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) {
@@ -13951,9 +13829,8 @@ var init_transactor = __esm({
       // 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
         );
@@ -13972,12 +13849,10 @@ var init_transactor = __esm({
       // 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) {
@@ -14140,7 +14015,14 @@ var init_app = __esm({
         const { type: type3 } = e;
         const isDrag = type3 === "dragover" || type3 === "dragstart" || type3 === "dragend" || type3 === "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,
+          type3,
+          root,
+          maxDepth,
+          comps,
+          !isDrag
+        );
         if (isDrag) this._handleDragEvent(e, type3, path);
         if (path !== null && handlers !== null)
           for (const handler of handlers) transactor.transactInputNow(path, e, handler, this.dragInfo);
@@ -14202,7 +14084,7 @@ var init_app = __esm({
           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 (type3 === "drop") {
           e.preventDefault();
           this._cleanDragOverAttrs();
@@ -14305,10 +14187,8 @@ var init_app = __esm({
     };
     listenerOpts = (name) => name === "touchmove" ? { passive: false } : void 0;
     DragInfo = class {
-      constructor(path, stack, e, val, type3, node) {
-        this.path = path;
+      constructor(stack, val, type3, node) {
         this.stack = stack;
-        this.e = e;
         this.val = val;
         this.type = type3;
         this.node = node;
@@ -14444,6 +14324,8 @@ var init_renderer = __esm({
       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 };
@@ -15786,7 +15668,7 @@ ${JSON.stringify({ imports }, null, 6)}
 </html>
 `;
 }
-function renderBootstrap(devModuleUrls, { margauiEnabled, margauiThemeUrl, check: check2, inspect: inspect3, noCache }) {
+function renderBootstrap(devModuleUrls, { margauiEnabled, margauiThemeUrl, check, inspect: inspect3, noCache }) {
   const lines = ['import { mountStorybook } from "tutuca/storybook";'];
   if (margauiEnabled) {
     lines.push('import { compileClassesToStyleText } from "tutuca/extra";');
@@ -15795,7 +15677,7 @@ function renderBootstrap(devModuleUrls, { margauiEnabled, margauiThemeUrl, check
   if (inspect3) {
     lines.push('import { shadowCheckComponent, runTests, expect } from "tutuca/dev";');
   }
-  if (check2) lines.push('import { check } from "tutuca/dev";');
+  if (check) lines.push('import { check } from "tutuca/dev";');
   devModuleUrls.forEach((url, i) => {
     lines.push(`import * as m${i} from ${JSON.stringify(url)};`);
   });
@@ -15810,7 +15692,7 @@ function renderBootstrap(devModuleUrls, { margauiEnabled, margauiThemeUrl, check
   const opts = optParts.length ? `{ ${optParts.join(", ")} }` : "{}";
   lines.push("");
   lines.push(`const app = await mountStorybook("#app", [${modules}], ${opts});`);
-  if (check2) lines.push("check(app);");
+  if (check) lines.push("check(app);");
   lines.push("");
   return lines.join("\n");
 }
@@ -15968,7 +15850,7 @@ async function run5(argv, opts = {}) {
   const margauiEnabled = !parsed.values["no-margaui"];
   const margauiOverride = parsed.values.margaui;
   const forceMargauiCdn = parsed.values["margaui-cdn"];
-  const check2 = !parsed.values["no-check"];
+  const check = !parsed.values["no-check"];
   const inspect3 = !parsed.values["no-inspect"];
   const noCache = parsed.values["no-cache"];
   const self = findSelf();
@@ -15992,7 +15874,7 @@ async function run5(argv, opts = {}) {
       renderBootstrap(devModuleUrls, {
         margauiEnabled,
         margauiThemeUrl: mg2.themeUrl,
-        check: check2,
+        check,
         inspect: inspect3,
         noCache
       })
@@ -16017,7 +15899,7 @@ async function run5(argv, opts = {}) {
       projectDir,
       tutuca: { source, base: base2, version: self.version },
       margaui: margauiEnabled ? { source: mg2.source, jsUrl: mg2.jsUrl, themeUrl: mg2.themeUrl } : null,
-      options: { margaui: margauiEnabled, check: check2, noCache, runTests: !parsed.values["no-tests"] },
+      options: { margaui: margauiEnabled, check, noCache, runTests: !parsed.values["no-tests"] },
       imports: imports2,
       modules,
       tests,
@@ -16032,7 +15914,7 @@ async function run5(argv, opts = {}) {
       `tutuca storybook dry run (no server started)
   project: ${projectDir}
   tutuca runtime: ${source} (${base2}, version ${self.version})
-  margaui: ${margauiEnabled ? `on (${mg2.source})` : "off"}, in-browser check: ${check2 ? "on" : "off"}, cache: ${noCache ? "off" : "on"}
+  margaui: ${margauiEnabled ? `on (${mg2.source})` : "off"}, in-browser check: ${check ? "on" : "off"}, cache: ${noCache ? "off" : "on"}
   ${modules.length} dev module(s):
 `
     );
@@ -16106,7 +15988,7 @@ async function run5(argv, opts = {}) {
   const bootstrapJs = renderBootstrap(devModuleUrls, {
     margauiEnabled,
     margauiThemeUrl: mg.themeUrl,
-    check: check2,
+    check,
     inspect: inspect3,
     noCache
   });