tutuca 0.11.2 → 0.12.0

package/dist/tutuca-cli.js

@@ -1561,6 +1561,14 @@ var init_path = __esm({
   }
 });
 
+// src/util/env.js
+var isMac;
+var init_env = __esm({
+  "src/util/env.js"() {
+    isMac = (globalThis.navigator?.userAgent ?? "").toLowerCase().includes("mac");
+  }
+});
+
 // src/value.js
 function sizeOf(v) {
   if (v == null) return null;
@@ -1570,6 +1578,9 @@ function sizeOf(v) {
   if (typeof l === "number") return l;
   return isPlainObject(v) ? Object.keys(v).length : null;
 }
+function getValue(e) {
+  return e.target.type === "checkbox" ? e.target.checked : (e instanceof CustomEvent ? e.detail : e.target.value) ?? null;
+}
 function parseToken(s, px) {
   const c0 = s.charCodeAt(0);
   if (c0 === 39)
@@ -1609,6 +1620,10 @@ function parseToken(s, px) {
   const num = VALID_FLOAT_RE.test(s) ? parseFloat(s) : null;
   if (Number.isFinite(num)) return new ConstVal(num);
   if (s === "true" || s === "false") return new ConstVal(s === "true");
+  if (c0 === 101) {
+    const m = /^e(\.[a-zA-Z][a-zA-Z0-9_]*)+$/.exec(s);
+    if (m !== null) return new EventMemberVal(s.split(".").slice(1));
+  }
   if (c0 >= 97 && c0 <= 122) return mkVal(s, NameVal);
   if (c0 >= 65 && c0 <= 90) return mkVal(s, TypeVal);
   return null;
@@ -1684,7 +1699,7 @@ function _parseHandler(s, px, namespace, allowArgs, report, allowMethod) {
   const args = new Array(tokens.length - 1);
   for (let i = 1; i < tokens.length; i++) {
     const val = parseToken(tokens[i], px);
-    if (val !== null && kindOf(val) & G_VALUE) args[i - 1] = val;
+    if (val !== null && kindOf(val) & G_HANDLER_ARG) args[i - 1] = val;
     else {
       if (report) px.onParseIssue("bad-value", { role: "handler-arg", value: tokens[i] });
       args[i - 1] = NULL_CONST_VAL;
@@ -1727,13 +1742,15 @@ function kindOf(val) {
   if (val instanceof DynVal) return K_DYN;
   if (val instanceof TypeVal) return K_TYPE;
   if (val instanceof NameVal) return K_NAME;
+  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_TYPE, K_SEQ, K_METHOD, G_BOOL, G_TEXT, G_COMPONENT, G_SEQUENCE, G_PROVIDE, G_FIELD, G_VALUE, G_ALL, predTruthy, PREDICATES, BaseVal, ConstVal, NULL_CONST_VAL, PredicateVal, VarVal, StrTplVal, NameVal, HandlerNameVal, mk404Handler, TypeVal, 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_TYPE, 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, TypeVal, keyIs, macCtrl, nullSafe, EVENT_CONVENIENCES, EventMemberVal, RenderVal, RenderNameVal, BindVal, BindMemberVal, DynVal, FieldVal, MethodVal, SeqAccessVal;
 var init_value = __esm({
   "src/value.js"() {
     init_collection();
     init_path();
+    init_env();
     VALID_VAL_ID_RE = /^[a-zA-Z][a-zA-Z0-9_]*\??$/;
     isValidValId = (name) => VALID_VAL_ID_RE.test(name);
     VALID_FLOAT_RE = /^-?[0-9]+(\.[0-9]+)?$/;
@@ -1751,6 +1768,7 @@ var init_value = __esm({
     K_TYPE = 64;
     K_SEQ = 256;
     K_METHOD = 1024;
+    K_EVENT = 2048;
     G_BOOL = K_FIELD | K_METHOD | K_BIND | K_DYN | K_CONST;
     G_TEXT = G_BOOL | K_STRTPL;
     G_COMPONENT = K_FIELD | K_SEQ | K_DYN;
@@ -1758,7 +1776,9 @@ var init_value = __esm({
     G_PROVIDE = K_FIELD | K_SEQ;
     G_FIELD = K_FIELD | K_METHOD | K_CONST | K_SEQ;
     G_VALUE = K_FIELD | K_METHOD | K_BIND | K_DYN | K_NAME | K_TYPE | K_CONST;
+    G_HANDLER_ARG = G_VALUE & ~K_NAME | K_EVENT;
     G_ALL = G_VALUE | K_STRTPL | K_SEQ;
+    toNullIfNaN = (v) => Number.isNaN(v) ? null : v;
     predTruthy = (v) => {
       const n = sizeOf(v);
       return n === null ? !!v : n > 0;
@@ -1892,11 +1912,14 @@ var init_value = __esm({
         this.namespace = namespace;
       }
       eval(stack) {
-        return stack.getHandlerFor(this.name, this.namespace) ?? mk404Handler(this.namespace, this.name);
+        return stack.getHandlerFor(this.name, this.namespace) ?? mk404Handler(stack, this.namespace, this.name);
       }
     };
-    mk404Handler = (type3, name) => function(...args) {
-      console.warn("handler not found", { type: type3, name, args }, this);
+    mk404Handler = (stack, type3, name) => function(...args) {
+      const transactor = stack?.ctx?.transactor;
+      if (transactor)
+        transactor.refuse("NO_HANDLER", { namespace: type3, name, argCount: args.length });
+      else console.warn("handler not found", { type: type3, name });
       return this;
     };
     TypeVal = class extends NameVal {
@@ -1904,6 +1927,53 @@ var init_value = __esm({
         return stack.lookupType(this.name);
       }
     };
+    keyIs = (k) => (e) => e.key === k;
+    macCtrl = (e) => isMac && e.metaKey || e.ctrlKey;
+    nullSafe = (fn) => (e, stack) => {
+      const info = stack.lookupDragInfo();
+      return info == null ? null : fn(info);
+    };
+    EVENT_CONVENIENCES = {
+      value: (e) => getValue(e),
+      valueAsInt: (e) => toNullIfNaN(parseInt(getValue(e), 10)),
+      valueAsFloat: (e) => toNullIfNaN(parseFloat(getValue(e))),
+      isAlt: (e) => e.altKey,
+      isShift: (e) => e.shiftKey,
+      isCtrl: macCtrl,
+      isCmd: macCtrl,
+      isUpKey: keyIs("ArrowUp"),
+      isDownKey: keyIs("ArrowDown"),
+      isSend: keyIs("Enter"),
+      isCancel: keyIs("Escape"),
+      isTabKey: keyIs("Tab"),
+      dragInfo: (_e, stack) => stack.lookupDragInfo(),
+      dragType: nullSafe((info) => info.type),
+      dragValue: nullSafe((info) => info.val),
+      dragKey: nullSafe((info) => info.lookupBind("key"))
+    };
+    EventMemberVal = class extends BaseVal {
+      constructor(members) {
+        super();
+        this.members = members;
+      }
+      eval(stack) {
+        const e = stack.lookupEvent();
+        if (e == null) return null;
+        if (this.members.length === 1) {
+          const convenience = EVENT_CONVENIENCES[this.members[0]];
+          if (convenience !== void 0) return convenience(e, stack);
+        }
+        let v = e;
+        for (const member of this.members) {
+          if (v == null) return null;
+          v = v[member];
+        }
+        return v ?? null;
+      }
+      toString() {
+        return `e.${this.members.join(".")}`;
+      }
+    };
     RenderVal = class extends BaseVal {
       render(stack, _rx) {
         return this.eval(stack);
@@ -2861,14 +2931,6 @@ var init_renderer = __esm({
   }
 });
 
-// src/util/env.js
-var isMac;
-var init_env = __esm({
-  "src/util/env.js"() {
-    isMac = (globalThis.navigator?.userAgent ?? "").toLowerCase().includes("mac");
-  }
-});
-
 // src/anode.js
 function resolveDynProducer(comp, name) {
   let producerComp, producerProvide;
@@ -6369,9 +6431,6 @@ function checkEventModifiers(lx, view) {
     }
   }
 }
-function isKnownHandlerName(name) {
-  return KNOWN_HANDLER_NAMES.has(name);
-}
 function checkKnownHandlerNames(lx, view, Comp, referencedAlters, referencedDynamics) {
   const env = mkAttrValEnv(Comp, referencedAlters, referencedDynamics);
   for (const event of view.ctx.events) {
@@ -6752,7 +6811,7 @@ function checkUnreferencedDynamics(lx, Comp, referencedDynamics) {
     }
   }
 }
-var KNOWN_COMPONENT_SPEC_KEYS, EMPTY_SET, FRAMEWORK_WELL_KNOWN_EXTRAS, KNOWN_DIRECTIVE_NAMES, ALT_HANDLER_NOT_DEFINED, ALT_HANDLER_NOT_REFERENCED, DYN_VAL_NOT_DEFINED, DYN_ALIAS_NOT_REFERENCED, PROVIDE_NOT_ADDRESSABLE, LOOKUP_BAD_SHAPE, LOOKUP_TARGET_MALFORMED, RENDER_IT_OUTSIDE_OF_LOOP, UNKNOWN_EVENT_MODIFIER, UNKNOWN_HANDLER_ARG_NAME, RECEIVE_HANDLER_NOT_IMPLEMENTED, EVENT_HANDLER_METHOD_NOT_ALLOWED, HANDLER_NAME_COLLISION, FIELD_VAL_NOT_DEFINED, FIELD_VAL_IS_METHOD, METHOD_VAL_NOT_DEFINED, METHOD_VAL_IS_FIELD, DUPLICATE_ATTR_DEFINITION, IF_NO_BRANCH_SET, UNKNOWN_COMPONENT_NAME, UNKNOWN_MACRO_ARG, UNKNOWN_DIRECTIVE, UNKNOWN_X_OP, UNKNOWN_X_ATTR, X_OP_IGNORES_CHILDREN, MAYBE_DROP_AT_PREFIX, MAYBE_ADD_AT_PREFIX, BAD_VALUE, UNSUPPORTED_EXPR_SYNTAX, BINDING_MEMBER_TOO_DEEP, SUGGEST_BINDING_MEMBER, REDUNDANT_TEMPLATE_STRING, PLACEHOLDERLESS_TEMPLATE_STRING, CONSTANT_CONDITION, UNKNOWN_COMPONENT_SPEC_KEY, COMP_FIELD_BAD_SHAPE, ASYNC_HANDLER, TOP_LEVEL_AT_RULE_IN_SCOPED_STYLE, GLOBAL_SELECTOR_IN_SCOPED_STYLE, FIELD_METHOD_NAME_COLLISION, X_KNOWN_OP_NAMES, X_KNOWN_ATTR_NAMES, HOST_DIRECTIVE_ONLY_NAMES, LEVEL_WARN2, LEVEL_ERROR2, LEVEL_HINT, PARSE_ISSUES, BINDING_MEMBER_TOO_DEEP_RE, UNSUPPORTED_EXPR_GUIDANCE, HTML_LINT_OPTS, NO_WRAPPERS2, ANY_EVENT_MODIFIERS, KNOWN_HANDLER_NAMES, fixTo, BOOL_CONDITION_ORIGINS, isBoolConditionCtx, ATTR_VAL_CHECKERS, NODE_KIND_TO_CTX, HANDLER_CHANNELS, ASYNC_HANDLER_HELP, NON_NESTABLE_AT_RULE, GLOBAL_LEADING_SELECTOR, IGNORE_DIRECTIVE, blankRun, STYLE_TO_GLOBAL_HELP, KNOWN_LOOKUP_KEYS, LintContext, LintParseContext;
+var KNOWN_COMPONENT_SPEC_KEYS, EMPTY_SET, FRAMEWORK_WELL_KNOWN_EXTRAS, KNOWN_DIRECTIVE_NAMES, ALT_HANDLER_NOT_DEFINED, ALT_HANDLER_NOT_REFERENCED, DYN_VAL_NOT_DEFINED, DYN_ALIAS_NOT_REFERENCED, PROVIDE_NOT_ADDRESSABLE, LOOKUP_BAD_SHAPE, LOOKUP_TARGET_MALFORMED, RENDER_IT_OUTSIDE_OF_LOOP, UNKNOWN_EVENT_MODIFIER, RECEIVE_HANDLER_NOT_IMPLEMENTED, EVENT_HANDLER_METHOD_NOT_ALLOWED, HANDLER_NAME_COLLISION, FIELD_VAL_NOT_DEFINED, FIELD_VAL_IS_METHOD, METHOD_VAL_NOT_DEFINED, METHOD_VAL_IS_FIELD, DUPLICATE_ATTR_DEFINITION, IF_NO_BRANCH_SET, UNKNOWN_COMPONENT_NAME, UNKNOWN_MACRO_ARG, UNKNOWN_DIRECTIVE, UNKNOWN_X_OP, UNKNOWN_X_ATTR, X_OP_IGNORES_CHILDREN, MAYBE_DROP_AT_PREFIX, MAYBE_ADD_AT_PREFIX, BAD_VALUE, UNSUPPORTED_EXPR_SYNTAX, BINDING_MEMBER_TOO_DEEP, SUGGEST_BINDING_MEMBER, REDUNDANT_TEMPLATE_STRING, PLACEHOLDERLESS_TEMPLATE_STRING, CONSTANT_CONDITION, UNKNOWN_COMPONENT_SPEC_KEY, COMP_FIELD_BAD_SHAPE, ASYNC_HANDLER, TOP_LEVEL_AT_RULE_IN_SCOPED_STYLE, GLOBAL_SELECTOR_IN_SCOPED_STYLE, FIELD_METHOD_NAME_COLLISION, X_KNOWN_OP_NAMES, X_KNOWN_ATTR_NAMES, HOST_DIRECTIVE_ONLY_NAMES, LEVEL_WARN2, LEVEL_ERROR2, LEVEL_HINT, PARSE_ISSUES, BINDING_MEMBER_TOO_DEEP_RE, UNSUPPORTED_EXPR_GUIDANCE, HTML_LINT_OPTS, NO_WRAPPERS2, ANY_EVENT_MODIFIERS, fixTo, BOOL_CONDITION_ORIGINS, isBoolConditionCtx, ATTR_VAL_CHECKERS, NODE_KIND_TO_CTX, HANDLER_CHANNELS, ASYNC_HANDLER_HELP, NON_NESTABLE_AT_RULE, GLOBAL_LEADING_SELECTOR, IGNORE_DIRECTIVE, blankRun, STYLE_TO_GLOBAL_HELP, KNOWN_LOOKUP_KEYS, LintContext, LintParseContext;
 var init_lint_check = __esm({
   "tools/core/lint-check.js"() {
     init_anode();
@@ -6789,7 +6848,6 @@ var init_lint_check = __esm({
     LOOKUP_TARGET_MALFORMED = "LOOKUP_TARGET_MALFORMED";
     RENDER_IT_OUTSIDE_OF_LOOP = "RENDER_IT_OUTSIDE_OF_LOOP";
     UNKNOWN_EVENT_MODIFIER = "UNKNOWN_EVENT_MODIFIER";
-    UNKNOWN_HANDLER_ARG_NAME = "UNKNOWN_HANDLER_ARG_NAME";
     RECEIVE_HANDLER_NOT_IMPLEMENTED = "RECEIVE_HANDLER_NOT_IMPLEMENTED";
     EVENT_HANDLER_METHOD_NOT_ALLOWED = "EVENT_HANDLER_METHOD_NOT_ALLOWED";
     HANDLER_NAME_COLLISION = "HANDLER_NAME_COLLISION";
@@ -6864,26 +6922,6 @@ var init_lint_check = __esm({
       ...Object.keys(MOD_WRAPPERS_FOR_ANY_EVENT),
       ...Object.keys(MOD_EFFECTS)
     ];
-    KNOWN_HANDLER_NAMES = /* @__PURE__ */ new Set([
-      "value",
-      "valueAsInt",
-      "valueAsFloat",
-      "target",
-      "event",
-      "isAlt",
-      "isShift",
-      "isCtrl",
-      "isCmd",
-      "key",
-      "keyCode",
-      "isUpKey",
-      "isDownKey",
-      "isSend",
-      "isCancel",
-      "isTabKey",
-      "ctx",
-      "dragInfo"
-    ]);
     fixTo = (from, to) => ({ kind: "rewrite", from, to });
     BOOL_CONDITION_ORIGINS = /* @__PURE__ */ new Set(["@show", "@hide", "<x show>", "<x hide>"]);
     isBoolConditionCtx = (errCtx) => errCtx != null && (BOOL_CONDITION_ORIGINS.has(errCtx.originAttr) || errCtx.branch === "@if");
@@ -6934,10 +6972,11 @@ var init_lint_check = __esm({
             errCtx
           );
       },
-      NameVal({ lx, val, errCtx, skipNameVal }) {
-        if (!skipNameVal && !isKnownHandlerName(val.name))
-          reportUnknownName(lx, UNKNOWN_HANDLER_ARG_NAME, val.name, KNOWN_HANDLER_NAMES, errCtx);
-      },
+      // NameVals on a macro call-site attribute are macro-param bindings, not
+      // handler args — their role is determined inside the macro body after
+      // ^-substitution, where re-parsing handles validation. No checker: a NameVal
+      // can no longer reach a handler-arg slot (sigil-less words fail to parse),
+      // and macro-attr pass-throughs are skipped via skipNameVal.
       StrTplVal({ lx, val, errCtx, recurse, isRoot }) {
         const vs = val.vals;
         const literal = val.toLiteralSource();
@@ -7157,12 +7196,6 @@ var init_lint_rules = __esm({
         group: "Templates / events",
         summary: "`@on.<event>+<mod>` uses a modifier not in the recognized set."
       },
-      {
-        code: UNKNOWN_HANDLER_ARG_NAME,
-        level: "error",
-        group: "Templates / events",
-        summary: "Handler argument name is not a built-in or a declared component."
-      },
       {
         code: DUPLICATE_ATTR_DEFINITION,
         level: "error",
@@ -7404,8 +7437,6 @@ function lintIdToMessage(id, info) {
       const written = `@on.${info.name}+${mods.join("+")}`;
       return `Unknown modifier '+${info.modifier}' in '${written}'`;
     }
-    case "UNKNOWN_HANDLER_ARG_NAME":
-      return `Unknown handler argument '${info.name}'${fmtOriginSuffix(info)}`;
     case "HANDLER_NAME_COLLISION":
       return `${info.problem} — ${info.fix}`;
     case "RECEIVE_HANDLER_NOT_IMPLEMENTED":
@@ -13039,8 +13070,19 @@ var init_stack = __esm({
         const fn = this.it[name];
         return fn instanceof Function ? fn.call(this.it) : null;
       }
-      lookupName(name) {
-        return this.ctx.lookupName(name);
+      // Bare implicit event names are gone: a sigil-less word cannot reach a
+      // handler-arg slot anymore, so this only ever serves stale NameVals parsed
+      // before the removal (e.g. macro-attr pass-throughs). Always null.
+      lookupName(_name) {
+        return null;
+      }
+      // The dispatched DOM event / drag info, read only by EventMemberVal's
+      // `e.<member>` handler args. Null outside a live event transaction.
+      lookupEvent() {
+        return this.ctx?.event ?? null;
+      }
+      lookupDragInfo() {
+        return this.ctx?.dragInfo ?? null;
       }
       getHandlerFor(name, key) {
         return this.comps.getHandlerFor(this.it, name, key);
@@ -13404,23 +13446,19 @@ var init_oo = __esm({
 function nullHandler() {
   return this;
 }
-function getValue(e) {
-  return e.target.type === "checkbox" ? e.target.checked : (e instanceof CustomEvent ? e.detail : e.target.value) ?? null;
-}
 function warnNotIntent(verb) {
   console.warn(`ctx.${verb}() is only meaningful in an "intent" handler - ignored`);
 }
 function rootDispatcher(transactor) {
   return new Dispatcher(new Path([]), transactor, null);
 }
-var State2, Transactor, Transaction, toNullIfNaN, InputEvent, NameArgsTransaction, SendEvent, IntentEvent, PASS, DEFAULT_ROUTE, INTENT_DEPTH, IntentWalk, Completion, Dispatcher, EventContext, IntentContext, PathChanges;
+var State2, Transactor, Transaction, InputEvent, NameArgsTransaction, SendEvent, IntentEvent, PASS, REFUSAL_RING_CAP, DEFAULT_ROUTE, INTENT_DEPTH, IntentWalk, Completion, Dispatcher, EventContext, IntentContext, PathChanges;
 var init_transactor = __esm({
   "src/transactor.js"() {
     init_immer2();
     init_oo();
     init_path();
     init_stack();
-    init_env();
     State2 = class {
       constructor(val) {
         this.val = val;
@@ -13446,6 +13484,8 @@ var init_transactor = __esm({
         this.onTransactionPushed = () => {
         };
         this._observers = [];
+        this.refusals = [];
+        this._refusalObservers = [];
         this._inflight = /* @__PURE__ */ new Set();
       }
       pushTransaction(t) {
@@ -13469,6 +13509,29 @@ var init_transactor = __esm({
       _emit(record) {
         for (const cb of this._observers) cb(record);
       }
+      // Record a refusal: a dispatch the runtime could not carry out. Kinds are
+      // open strings; today the runtime raises NO_HANDLER (a receive name with no
+      // implementation, including the auto-generated fallback firing at dispatch
+      // time) and FORWARD_NO_NAME (ctx.forward() from a handler whose view wrote
+      // no name). Records carry { kind, info, timestamp } and are observational —
+      // the dispatch itself has already failed gracefully.
+      refuse(kind, info = {}) {
+        const record = { kind, info, timestamp: Date.now() };
+        this.refusals.push(record);
+        if (this.refusals.length > REFUSAL_RING_CAP) this.refusals.shift();
+        console.warn(`tutuca refusal [${kind}]`, info);
+        for (const cb of this._refusalObservers) cb(record);
+        return record;
+      }
+      // Subscribe to refusal records as they happen. Returns an unsubscribe fn,
+      // like observe().
+      observeRefusals(cb) {
+        this._refusalObservers.push(cb);
+        return () => {
+          const i = this._refusalObservers.indexOf(cb);
+          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 /
@@ -13631,11 +13694,7 @@ var init_transactor = __esm({
         this._completion?.markSelfSettled({ value: newLeaf, old: curLeaf });
         return curLeaf !== newLeaf ? txnPath.setValue(curRoot, newLeaf) : curRoot;
       }
-      lookupName(_name) {
-        return null;
-      }
     };
-    toNullIfNaN = (v) => Number.isNaN(v) ? null : v;
     InputEvent = class extends Transaction {
       constructor(path, e, handler, transactor, dragInfo) {
         super(path, transactor);
@@ -13673,8 +13732,10 @@ var init_transactor = __esm({
         const { args = this._handlerArgs ?? [], ...rest } = f;
         const hv = this.handler?.handlerCall?.handlerVal ?? this.handler?.handlerVal;
         const name = hv?.name;
-        if (name === void 0)
-          return console.warn("ctx.forward() from a handler with no name - ignored");
+        if (name === void 0) {
+          this.transactor.refuse("FORWARD_NO_NAME", {});
+          return;
+        }
         this.transactor.pushIntent(this.dispatchPath, name, args, rest, this);
       }
       buildRootStack(root, comps) {
@@ -13688,47 +13749,11 @@ var init_transactor = __esm({
         args.push(new EventContext(path, this.transactor, this));
         return [handler, args];
       }
-      lookupName(name) {
-        const { e } = this;
-        switch (name) {
-          case "value":
-            return getValue(e);
-          case "valueAsInt":
-            return toNullIfNaN(parseInt(getValue(e), 10));
-          case "valueAsFloat":
-            return toNullIfNaN(parseFloat(getValue(e)));
-          case "target":
-            return e.target;
-          case "event":
-            return e;
-          case "isAlt":
-            return e.altKey;
-          case "isShift":
-            return e.shiftKey;
-          case "isCtrl":
-          /* falls through */
-          case "isCmd":
-            return isMac && e.metaKey || e.ctrlKey;
-          case "key":
-            return e.key;
-          case "keyCode":
-            return e.keyCode;
-          case "isUpKey":
-            return e.key === "ArrowUp";
-          case "isDownKey":
-            return e.key === "ArrowDown";
-          case "isSend":
-            return e.key === "Enter";
-          case "isCancel":
-            return e.key === "Escape";
-          case "isTabKey":
-            return e.key === "Tab";
-          case "ctx":
-            return new EventContext(this.dispatchPath, this.transactor, this);
-          case "dragInfo":
-            return this.dragInfo;
-        }
-        return null;
+      // The dispatched DOM event, read only through `e.<member>` handler args
+      // (src/value.js EventMemberVal via Stack.lookupEvent). There is no bare
+      // implicit-name vocabulary anymore: every arg carries a sigil.
+      get event() {
+        return this.e;
       }
     };
     NameArgsTransaction = class extends Transaction {
@@ -13819,6 +13844,7 @@ var init_transactor = __esm({
       }
     };
     PASS = /* @__PURE__ */ Symbol.for("tutuca.intent.pass");
+    REFUSAL_RING_CAP = 200;
     DEFAULT_ROUTE = ["dyn", "lex"];
     INTENT_DEPTH = 64;
     IntentWalk = class {