tutuca 0.9.115 → 0.10.0

package/dist/tutuca-cli.js

@@ -4891,8 +4891,8 @@ function parseSequence(s, px) {
 function parseMacroAttr(s, px) {
   return _parseSingle(s, px, G_ALL);
 }
-function parseInputHandler(s, px) {
-  return _parseHandler(s, px, "input", true, true);
+function parseReceiveHandler(s, px) {
+  return _parseHandler(s, px, "receive", true, true);
 }
 function parseAlterHandler(s, px) {
   const r = _parseHandler(s, px, "alter", false, false);
@@ -5222,7 +5222,7 @@ function getAttrParser(px) {
   _attrParser.clear(px);
   return _attrParser;
 }
-var Attributes, booleanAttrsRaw, booleanAttrs, AttrParser, ConstAttrs, DynAttrs, BaseAttr, Attr, ConstAttr, RawHtmlAttr, NOT_SET_VAL, IfAttr, _attrParser, EventHandler, RequestHandler;
+var Attributes, booleanAttrsRaw, booleanAttrs, AttrParser, ConstAttrs, DynAttrs, BaseAttr, Attr, ConstAttr, RawHtmlAttr, NOT_SET_VAL, IfAttr, _attrParser, EventHandler, IntentHandler;
 var init_attribute = __esm({
   "src/attribute.js"() {
     init_value();
@@ -5482,11 +5482,11 @@ var init_attribute = __esm({
         return [this.handlerVal.evalAsHandler(stack), argValues];
       }
       static parse(s, px) {
-        const r = parseInputHandler(s, px);
+        const r = parseReceiveHandler(s, px);
         return r === null ? null : new _EventHandler(r.handlerVal, r.args);
       }
     };
-    RequestHandler = class {
+    IntentHandler = class {
       constructor(name, fn) {
         this.name = name;
         this.fn = fn;
@@ -9174,6 +9174,9 @@ function checkComponent(Comp, lx = new LintContext(), { wellKnownExtras = EMPTY_
     checkProvidesAreAddressable(lx, Comp);
     checkLookupShapes(lx, Comp);
     checkHandlersNotAsync(lx, Comp);
+    checkRetiredBuckets(lx, Comp);
+    checkRetiredCtxVerbs(lx, Comp);
+    checkHandlerNameCollisions(lx, Comp);
     checkScopedStyleTopLevel(lx, Comp);
     const referencedAlters = /* @__PURE__ */ new Set();
     const referencedInputs = /* @__PURE__ */ new Set();
@@ -9187,7 +9190,6 @@ function checkComponent(Comp, lx = new LintContext(), { wellKnownExtras = EMPTY_
       );
     }
     checkUnreferencedAlterHandlers(lx, Comp, referencedAlters);
-    checkUnreferencedInputHandlers(lx, Comp, referencedInputs);
     checkUnreferencedDynamics(lx, Comp, referencedDynamics);
     return lx;
   });
@@ -9426,7 +9428,7 @@ function mkAttrValEnv(Comp, referencedAlters, referencedDynamics) {
   return { fields, proto, scope, alter, referencedAlters, dynamicMap, referencedDynamics };
 }
 function checkEventHandlersHaveImpls(lx, Comp, referencedInputs) {
-  const { input, views, Class } = Comp;
+  const { receive: input, views, Class } = Comp;
   const { prototype: proto } = Class;
   for (const viewName in views) {
     lx.push({ viewName }, () => {
@@ -9443,13 +9445,13 @@ function checkEventHandlersHaveImpls(lx, Comp, referencedInputs) {
             if (input[name] === void 0) {
               const isMethodFix = protoHasMethod(proto, name);
               lx.error(
-                INPUT_HANDLER_NOT_IMPLEMENTED,
+                RECEIVE_HANDLER_NOT_IMPLEMENTED,
                 { name, handler, event, eventName, originAttr },
                 isMethodFix ? { kind: "add-prefix", from: name, to: `$${name}` } : replaceNameSuggestion(name, Object.keys(input))
               );
               if (isMethodFix) {
                 lx.hint(
-                  INPUT_HANDLER_METHOD_FOR_INPUT_HANDLER,
+                  METHOD_FOR_RECEIVE_HANDLER,
                   { name, handler, event, eventName, originAttr },
                   { kind: "add-prefix", from: name, to: `$${name}` }
                 );
@@ -9461,13 +9463,13 @@ function checkEventHandlersHaveImpls(lx, Comp, referencedInputs) {
             if (!protoHasMethod(proto, name)) {
               const isInputFix = input[name] !== void 0;
               lx.error(
-                INPUT_HANDLER_METHOD_NOT_IMPLEMENTED,
+                RECEIVE_HANDLER_METHOD_NOT_IMPLEMENTED,
                 { name, handler, event, eventName, originAttr },
                 isInputFix ? { kind: "drop-prefix", from: `$${name}`, to: name } : replaceNameSuggestion(name, collectProtoMethodNames(proto))
               );
               if (isInputFix) {
                 lx.hint(
-                  INPUT_HANDLER_FOR_INPUT_HANDLER_METHOD,
+                  RECEIVE_HANDLER_FOR_METHOD,
                   { name, handler, event, eventName, originAttr },
                   { kind: "drop-prefix", from: `$${name}`, to: name }
                 );
@@ -9616,12 +9618,57 @@ function checkConsistentAttrs(lx, Comp, referencedAlters, referencedDynamics) {
     });
   }
 }
+function checkRetiredBuckets(lx, Comp) {
+  const extra = Comp.extra;
+  if (!extra) return;
+  for (const key of Object.keys(extra)) {
+    if (!Object.hasOwn(RETIRED_BUCKETS, key)) continue;
+    const retired = RETIRED_BUCKETS[key];
+    const names = isPlainObj(extra[key]) ? Object.keys(extra[key]) : [];
+    lx.error(RETIRED_HANDLER_BUCKET, { key, to: retired.to, how: retired.how, names });
+  }
+}
+function checkRetiredCtxVerbs(lx, Comp) {
+  for (const bucket of ["receive", "intent", "alter", "methods", "statics"]) {
+    const block = bucket === "methods" || bucket === "statics" ? Comp.spec?.[bucket] : Comp[bucket];
+    if (!isPlainObj(block)) continue;
+    for (const name in block) {
+      const fn = block[name];
+      if (typeof fn !== "function") continue;
+      const src = String(fn);
+      for (const m of src.matchAll(RETIRED_CTX_RE)) {
+        const verb = m[1];
+        lx.error(RETIRED_CTX_VERB, { verb, to: RETIRED_CTX_VERBS[verb], bucket, name });
+      }
+    }
+  }
+}
+function checkHandlerNameCollisions(lx, Comp) {
+  const receive = Comp.receive ?? {};
+  const intent = Comp.intent ?? {};
+  for (const name in intent)
+    if (receive[name] !== void 0)
+      lx.error(HANDLER_NAME_COLLISION, {
+        name,
+        problem: `"${name}" is declared in both \`receive\` and \`intent\``,
+        fix: "one is addressed and one is routed; give them different names so a reader can tell which a call site meant"
+      });
+  for (const name in receive)
+    for (const suffix of ["Ok", "Error", "Unhandled"])
+      if (receive[name + suffix] !== void 0 && intent[name] === void 0)
+        lx.warn(HANDLER_NAME_COLLISION, {
+          name,
+          problem: `\`receive\` declares both "${name}" and its answer name "${name + suffix}"`,
+          fix: `an intent named "${name}" would dispatch its answer to "${name + suffix}" - rename one unless that is what you meant`
+        });
+}
 function checkUnknownSpecKeys(lx, Comp, wellKnownExtras) {
   const extra = Comp.extra;
   if (!extra) return;
   let candidates = null;
   for (const key of Object.keys(extra)) {
     if (FRAMEWORK_WELL_KNOWN_EXTRAS.has(key) || wellKnownExtras.has(key)) continue;
+    if (Object.hasOwn(RETIRED_BUCKETS, key)) continue;
     candidates ??= [
       ...KNOWN_COMPONENT_SPEC_KEYS,
       ...FRAMEWORK_WELL_KNOWN_EXTRAS,
@@ -9669,13 +9716,6 @@ function checkUnreferencedAlterHandlers(lx, Comp, referencedAlters) {
     }
   }
 }
-function checkUnreferencedInputHandlers(lx, Comp, referencedInputs) {
-  for (const name in Comp.input) {
-    if (!referencedInputs.has(name)) {
-      lx.hint(INPUT_HANDLER_NOT_REFERENCED, { name });
-    }
-  }
-}
 function checkHandlersNotAsync(lx, Comp) {
   for (const channel of HANDLER_CHANNELS) {
     const block = Comp[channel];
@@ -9794,7 +9834,7 @@ function checkUnreferencedDynamics(lx, Comp, referencedDynamics) {
     }
   }
 }
-var KNOWN_COMPONENT_SPEC_KEYS, EMPTY_SET2, 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, INPUT_HANDLER_NOT_IMPLEMENTED, INPUT_HANDLER_NOT_REFERENCED, INPUT_HANDLER_METHOD_NOT_IMPLEMENTED, INPUT_HANDLER_FOR_INPUT_HANDLER_METHOD, INPUT_HANDLER_METHOD_FOR_INPUT_HANDLER, 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, DEPRECATED_BARE_X_DIRECTIVE, 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_NAME_RESERVED_BY_RECORD, RECORD_FIELD_NAME_COLLISIONS, 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_SET2, 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, RETIRED_HANDLER_BUCKET, RETIRED_CTX_VERB, HANDLER_NAME_COLLISION, RECEIVE_HANDLER_METHOD_NOT_IMPLEMENTED, RECEIVE_HANDLER_FOR_METHOD, METHOD_FOR_RECEIVE_HANDLER, 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, DEPRECATED_BARE_X_DIRECTIVE, 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_NAME_RESERVED_BY_RECORD, RECORD_FIELD_NAME_COLLISIONS, 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, isPlainObj, RETIRED_BUCKETS, RETIRED_CTX_VERBS, RETIRED_CTX_RE, 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();
@@ -9806,7 +9846,7 @@ var init_lint_check = __esm({
       )
     );
     EMPTY_SET2 = /* @__PURE__ */ new Set();
-    FRAMEWORK_WELL_KNOWN_EXTRAS = /* @__PURE__ */ new Set(["requestOverridesField"]);
+    FRAMEWORK_WELL_KNOWN_EXTRAS = /* @__PURE__ */ new Set(["intentOverridesField"]);
     KNOWN_DIRECTIVE_NAMES = /* @__PURE__ */ new Set([
       "dangerouslysetinnerhtml",
       "slot",
@@ -9831,11 +9871,13 @@ var init_lint_check = __esm({
     RENDER_IT_OUTSIDE_OF_LOOP = "RENDER_IT_OUTSIDE_OF_LOOP";
     UNKNOWN_EVENT_MODIFIER = "UNKNOWN_EVENT_MODIFIER";
     UNKNOWN_HANDLER_ARG_NAME = "UNKNOWN_HANDLER_ARG_NAME";
-    INPUT_HANDLER_NOT_IMPLEMENTED = "INPUT_HANDLER_NOT_IMPLEMENTED";
-    INPUT_HANDLER_NOT_REFERENCED = "INPUT_HANDLER_NOT_REFERENCED";
-    INPUT_HANDLER_METHOD_NOT_IMPLEMENTED = "INPUT_HANDLER_METHOD_NOT_IMPLEMENTED";
-    INPUT_HANDLER_FOR_INPUT_HANDLER_METHOD = "INPUT_HANDLER_FOR_INPUT_HANDLER_METHOD";
-    INPUT_HANDLER_METHOD_FOR_INPUT_HANDLER = "INPUT_HANDLER_METHOD_FOR_INPUT_HANDLER";
+    RECEIVE_HANDLER_NOT_IMPLEMENTED = "RECEIVE_HANDLER_NOT_IMPLEMENTED";
+    RETIRED_HANDLER_BUCKET = "RETIRED_HANDLER_BUCKET";
+    RETIRED_CTX_VERB = "RETIRED_CTX_VERB";
+    HANDLER_NAME_COLLISION = "HANDLER_NAME_COLLISION";
+    RECEIVE_HANDLER_METHOD_NOT_IMPLEMENTED = "RECEIVE_HANDLER_METHOD_NOT_IMPLEMENTED";
+    RECEIVE_HANDLER_FOR_METHOD = "RECEIVE_HANDLER_FOR_METHOD";
+    METHOD_FOR_RECEIVE_HANDLER = "METHOD_FOR_RECEIVE_HANDLER";
     FIELD_VAL_NOT_DEFINED = "FIELD_VAL_NOT_DEFINED";
     FIELD_VAL_IS_METHOD = "FIELD_VAL_IS_METHOD";
     METHOD_VAL_NOT_DEFINED = "METHOD_VAL_NOT_DEFINED";
@@ -10028,8 +10070,34 @@ var init_lint_check = __esm({
       HideNode: { originAttr: "<x hide>" },
       PushViewNameNode: { originAttr: "<x push-view>" }
     };
-    HANDLER_CHANNELS = ["input", "receive", "bubble", "response", "alter"];
-    ASYNC_HANDLER_HELP = "Move the async work into a request handler and trigger it with ctx.request('name', args), then handle the result in a synchronous response handler. To coordinate other components, keep the handler synchronous and use ctx.send to deliver a message or ctx.bubble to raise an event.";
+    isPlainObj = (v) => v !== null && typeof v === "object" && !Array.isArray(v);
+    RETIRED_BUCKETS = {
+      input: {
+        to: "receive",
+        how: "rename the bucket to `receive` - a view's own @on.* name and a parent's ctx.send are the same message now, and nothing can tell them apart"
+      },
+      bubble: {
+        to: "intent",
+        how: "rename the bucket to `intent` - and note the walk changed: a handler that calls ctx.reply() ENDS it, where ctx.stopPropagation() used to be the only way to stop"
+      },
+      response: {
+        to: "receive",
+        how: "split each arm into `receive` arms named after the intent: <name>Ok takes the result alone, <name>Error takes the error alone, and the optional <name>Unhandled means nothing claimed it"
+      }
+    };
+    RETIRED_CTX_VERBS = {
+      bubble: 'ctx.intent(name, args, { route: ["dyn"] }) - the route says it walks the ancestors, where the verb used to',
+      request: 'ctx.intent(name, args, { route: ["lex"] }) - and the outcome comes back as a `receive` arm named <name>Ok / <name>Error / <name>Unhandled, so onOkName and onErrorName are gone',
+      stopPropagation: "ctx.stop()",
+      inputAtPath: "ctx.sendAtPath(path, name, args)",
+      requestAtPath: 'ctx.intentAtPath(path, name, args, { route: ["lex"] })'
+    };
+    RETIRED_CTX_RE = new RegExp(
+      `\\bctx\\.(${Object.keys(RETIRED_CTX_VERBS).join("|")})\\s*\\(`,
+      "g"
+    );
+    HANDLER_CHANNELS = ["receive", "intent", "alter"];
+    ASYNC_HANDLER_HELP = `Move the async work into a scope-registered intent handler and trigger it with ctx.intent("name", args, { route: ["lex"] }), then read the outcome in the synchronous \`receive\` arms named after it: <name>Ok, <name>Error and <name>Unhandled. To coordinate other components, keep the handler synchronous and use ctx.send to address one, or ctx.intent to let a route find one.`;
     NON_NESTABLE_AT_RULE = /(?:^|[\s;{}])@(?:-[a-z]+-)?(charset|import|namespace|font-face|keyframes|page|property|counter-style|font-feature-values|font-palette-values|view-transition)\b/gi;
     GLOBAL_LEADING_SELECTOR = /(?:^|[{}])\s*(html|body|:root)\b[^{};]*\{/gi;
     IGNORE_DIRECTIVE = /\/\*\s*tutuca-lint-ignore\s*\*\//g;
@@ -10135,36 +10203,30 @@ var init_lint_rules = __esm({
         group: "Field / method references",
         summary: "`$name` calls a method, but `name` is a field — use `.name`."
       },
-      // Input-handler / method confusion
+      // Receive-handler / method confusion
       {
-        code: INPUT_HANDLER_NOT_IMPLEMENTED,
+        code: RECEIVE_HANDLER_NOT_IMPLEMENTED,
         level: "error",
-        group: "Input-handler / method confusion",
-        summary: "Bare handler name has no entry in `input`."
+        group: "Receive-handler / method confusion",
+        summary: "Bare handler name has no entry in `receive`."
       },
       {
-        code: INPUT_HANDLER_METHOD_NOT_IMPLEMENTED,
+        code: RECEIVE_HANDLER_METHOD_NOT_IMPLEMENTED,
         level: "error",
-        group: "Input-handler / method confusion",
+        group: "Receive-handler / method confusion",
         summary: "`$handler` has no entry in `methods`."
       },
       {
-        code: INPUT_HANDLER_FOR_INPUT_HANDLER_METHOD,
+        code: RECEIVE_HANDLER_FOR_METHOD,
         level: "hint",
-        group: "Input-handler / method confusion",
-        summary: "`$name` is a method reference, but `name` is an input handler — drop the `$`."
+        group: "Receive-handler / method confusion",
+        summary: "`$name` is a method reference, but `name` is a receive handler — drop the `$`."
       },
       {
-        code: INPUT_HANDLER_METHOD_FOR_INPUT_HANDLER,
+        code: METHOD_FOR_RECEIVE_HANDLER,
         level: "hint",
-        group: "Input-handler / method confusion",
-        summary: "Bare `name` is an input-handler reference, but `name` is a method — add `$`."
-      },
-      {
-        code: INPUT_HANDLER_NOT_REFERENCED,
-        level: "hint",
-        group: "Input-handler / method confusion",
-        summary: "`input` entry is defined but never wired to an `@on.*` event."
+        group: "Receive-handler / method confusion",
+        summary: "Bare `name` is a receive-handler reference, but `name` is a method — add `$`."
       },
       // Iteration helpers (`alter`)
       {
@@ -10348,12 +10410,33 @@ var init_lint_rules = __esm({
         group: "Component spec",
         summary: "`component({...})` has an unrecognized key; its value is ignored at runtime."
       },
+      // Retired four-channel vocabulary (TEMPORARY — remove a couple of releases after
+      // the two-channel change). These exist to drive the migration: the linter reports
+      // every site and says what replaces it, and a clean run IS the finished migration.
+      {
+        code: "RETIRED_HANDLER_BUCKET",
+        level: "error",
+        group: "Retired dispatch vocabulary",
+        summary: "`input`, `bubble` and `response` are no longer handler buckets — four dispatch channels became two, `receive` (addressed) and `intent` (routed)."
+      },
+      {
+        code: "RETIRED_CTX_VERB",
+        level: "error",
+        group: "Retired dispatch vocabulary",
+        summary: "`ctx.bubble`, `ctx.request` and `ctx.stopPropagation` are gone — one `ctx.intent` carries a route, and `ctx.stop()` ends a walk."
+      },
+      {
+        code: "HANDLER_NAME_COLLISION",
+        level: "error",
+        group: "Retired dispatch vocabulary",
+        summary: "Two handlers collapse onto one name, or a `receive` arm collides with an intent's derived answer name."
+      },
       // Handler effects
       {
         code: ASYNC_HANDLER,
         level: "error",
         group: "Handler effects",
-        summary: "A handler in `input`/`receive`/`bubble`/`response`/`alter` is an async function — handlers must be synchronous; use a request handler, `ctx.send`, or `ctx.bubble` instead."
+        summary: "A handler in `receive`/`intent`/`alter` is an async function — handlers must be synchronous. Put the async work in a scope-registered intent handler and reach it with `ctx.intent`, or coordinate with `ctx.send`."
       },
       // Component styles
       {
@@ -10480,16 +10563,22 @@ function lintIdToMessage(id, info) {
     }
     case "UNKNOWN_HANDLER_ARG_NAME":
       return `Unknown handler argument '${info.name}'${fmtOriginSuffix(info)}`;
-    case "INPUT_HANDLER_NOT_IMPLEMENTED":
-      return `Input handler '${info.name}' is not implemented${fmtEventSuffix(info)}`;
-    case "INPUT_HANDLER_NOT_REFERENCED":
-      return `Input handler '${info.name}' is defined but never used — remove it or wire it to an @on.* event`;
-    case "INPUT_HANDLER_METHOD_NOT_IMPLEMENTED":
+    case "RETIRED_HANDLER_BUCKET": {
+      const which = info.names?.length ? ` (${info.names.join(", ")})` : "";
+      return `\`${info.key}\` is no longer a handler bucket${which} — ${info.how}`;
+    }
+    case "RETIRED_CTX_VERB":
+      return `ctx.${info.verb}() no longer exists — use ${info.to} (in \`${info.bucket}.${info.name}\`)`;
+    case "HANDLER_NAME_COLLISION":
+      return `${info.problem} — ${info.fix}`;
+    case "RECEIVE_HANDLER_NOT_IMPLEMENTED":
+      return `Receive handler '${info.name}' is not implemented${fmtEventSuffix(info)}`;
+    case "RECEIVE_HANDLER_METHOD_NOT_IMPLEMENTED":
       return `Method '$${info.name}' is not implemented${fmtEventSuffix(info)}`;
-    case "INPUT_HANDLER_FOR_INPUT_HANDLER_METHOD":
-      return `'$${info.name}' is a method reference, but '${info.name}' is defined as an input handler${fmtEventSuffix(info)}`;
-    case "INPUT_HANDLER_METHOD_FOR_INPUT_HANDLER":
-      return `'${info.name}' is an input handler reference, but '${info.name}' is defined as a method${fmtEventSuffix(info)}`;
+    case "RECEIVE_HANDLER_FOR_METHOD":
+      return `'$${info.name}' is a method reference, but '${info.name}' is defined as a receive handler${fmtEventSuffix(info)}`;
+    case "METHOD_FOR_RECEIVE_HANDLER":
+      return `'${info.name}' is a receive handler reference, but '${info.name}' is defined as a method${fmtEventSuffix(info)}`;
     case "FIELD_NAME_RESERVED_BY_RECORD":
       return `Field '${info.name}' collides with the Immutable Record API: '.${info.name}' reads the Record member, not your value — rename the field (its value is only reachable via .get('${info.name}'))`;
     case "FIELD_VAL_NOT_DEFINED":
@@ -10677,7 +10766,7 @@ function fmtModuleInfo(info) {
   lines.push(`Exports: ${[...info.present].join(", ") || "(none)"}`);
   lines.push(`Components: ${info.counts.components}`);
   lines.push(`Macros: ${info.counts.macros}`);
-  lines.push(`Request handlers: ${info.counts.requestHandlers}`);
+  lines.push(`Request handlers: ${info.counts.intentHandlers}`);
   lines.push(`Examples: ${info.counts.examples} (sections: ${info.counts.sections})`);
   if (info.warnings.length) {
     lines.push("");
@@ -10730,9 +10819,13 @@ function fmtComponentDocs(docs) {
       lines.push("  methods:");
       for (const m of c.methods) lines.push(`    ${m.sig}`);
     }
-    if (c.input.length) {
-      lines.push("  input:");
-      for (const m of c.input) lines.push(`    ${m.sig}`);
+    for (const [label, bucket] of [
+      ["receive", c.receive],
+      ["intent", c.intent]
+    ]) {
+      if (!bucket?.length) continue;
+      lines.push(`  ${label}:`);
+      for (const m of bucket) lines.push(`    ${m.sig}`);
     }
     if (c.fields.length) {
       lines.push("  fields:");
@@ -10928,9 +11021,14 @@ function fmtComponentDocs2(docs) {
       }
       lines.push("");
     }
-    if (comp.input.length > 0) {
-      lines.push("## Input Handlers\n");
-      for (const m of comp.input) {
+    for (const [title, bucket] of [
+      ["Receive Handlers", comp.receive],
+      ["Intent Handlers", comp.intent]
+    ]) {
+      if (!bucket?.length) continue;
+      lines.push(`## ${title}
+`);
+      for (const m of bucket) {
         lines.push(`- \`${m.sig}\``);
       }
       lines.push("");
@@ -11016,7 +11114,7 @@ function fmtModuleInfo2(info) {
   lines.push(`- Exports: ${[...info.present].map((k) => `\`${k}\``).join(", ") || "(none)"}`);
   lines.push(`- Components: ${info.counts.components}`);
   lines.push(`- Macros: ${info.counts.macros}`);
-  lines.push(`- Request handlers: ${info.counts.requestHandlers}`);
+  lines.push(`- Request handlers: ${info.counts.intentHandlers}`);
   lines.push(`- Examples: ${info.counts.examples} (sections: ${info.counts.sections})`);
   if (info.warnings.length) {
     lines.push("", "## Warnings", "");
@@ -15513,9 +15611,9 @@ function parseExample(raw, index, components, parentPath) {
   if (raw.value === void 0) {
     throw shapeError(`example at ${where} missing "value"`, where);
   }
-  const rh = raw.requestHandlers;
+  const rh = raw.intentHandlers;
   if (rh != null && (typeof rh !== "object" || Array.isArray(rh))) {
-    throw shapeError(`example at ${where} "requestHandlers" must be an object of functions`, where);
+    throw shapeError(`example at ${where} "intentHandlers" must be an object of functions`, where);
   }
   const on = raw.on;
   if (on != null) {
@@ -15534,7 +15632,7 @@ function parseExample(raw, index, components, parentPath) {
       }
       if (!isPlainObject2(on[key])) {
         throw shapeError(
-          `example at ${where} "on.${key}" must be an object of actions (send, bubble, request, input, do)`,
+          `example at ${where} "on.${key}" must be an object of actions (send, intent, do)`,
           where
         );
       }
@@ -15546,7 +15644,7 @@ function parseExample(raw, index, components, parentPath) {
     value: raw.value,
     view: raw.view ?? "main",
     componentName: resolveComponentName(raw.value, components),
-    requestHandlers: rh ?? null,
+    intentHandlers: rh ?? null,
     requestHandlerNames: rh ? Object.keys(rh) : [],
     on: on ?? null
   });
@@ -15590,7 +15688,7 @@ function normalizeModule(mod, { path = null } = {}) {
   for (const key of [
     "getComponents",
     "getMacros",
-    "getRequestHandlers",
+    "getIntentHandlers",
     "getExamples",
     "getTests",
     "getRoot"
@@ -15599,7 +15697,7 @@ function normalizeModule(mod, { path = null } = {}) {
   }
   const components = present.has("getComponents") ? mod.getComponents() : [];
   const macros = present.has("getMacros") ? mod.getMacros() : null;
-  const requestHandlers = present.has("getRequestHandlers") ? mod.getRequestHandlers() : null;
+  const intentHandlers = present.has("getIntentHandlers") ? mod.getIntentHandlers() : null;
   const root = present.has("getRoot") ? mod.getRoot() : null;
   const sections = present.has("getExamples") ? parseSections(mod.getExamples(), components) : [];
   return {
@@ -15608,7 +15706,7 @@ function normalizeModule(mod, { path = null } = {}) {
       path,
       components,
       macros,
-      requestHandlers,
+      intentHandlers,
       sections,
       root
     }),
@@ -15653,7 +15751,7 @@ var init_module = __esm({
         value,
         view = "main",
         componentName = null,
-        requestHandlers = null,
+        intentHandlers = null,
         requestHandlerNames = [],
         on = null
       }) {
@@ -15662,7 +15760,7 @@ var init_module = __esm({
         this.value = value;
         this.view = view;
         this.componentName = componentName;
-        this.requestHandlers = requestHandlers;
+        this.intentHandlers = intentHandlers;
         this.requestHandlerNames = requestHandlerNames;
         this.on = on;
       }
@@ -15677,12 +15775,12 @@ var init_module = __esm({
       }
     };
     NormalizedModule = class {
-      constructor({ mod, path = null, components, macros, requestHandlers, sections, root }) {
+      constructor({ mod, path = null, components, macros, intentHandlers, sections, root }) {
         this.mod = mod;
         this.path = path;
         this.components = components;
         this.macros = macros;
-        this.requestHandlers = requestHandlers;
+        this.intentHandlers = intentHandlers;
         this.sections = sections;
         this.root = root;
       }
@@ -15840,7 +15938,7 @@ function describeModule(mod, { path = null } = {}) {
   const counts = {
     components: normalized.components.length,
     macros: normalized.macros ? Object.keys(normalized.macros).length : 0,
-    requestHandlers: normalized.requestHandlers ? Object.keys(normalized.requestHandlers).length : 0,
+    intentHandlers: normalized.intentHandlers ? Object.keys(normalized.intentHandlers).length : 0,
     examples: normalized.sections.reduce((n, s) => n + s.items.length, 0),
     sections: normalized.sections.length
   };
@@ -16027,10 +16125,9 @@ function getComponentDoc(comp) {
     name: k,
     sig: getSignature(k, methods[k])
   }));
-  const inputHandlers = Object.keys(comp.input).map((k) => ({
-    name: k,
-    sig: getSignature(k, comp.input[k])
-  }));
+  const sigs = (bucket) => Object.keys(bucket ?? {}).map((k) => ({ name: k, sig: getSignature(k, bucket[k]) }));
+  const receiveHandlers = sigs(comp.receive);
+  const intentHandlers = sigs(comp.intent);
   const fieldDocs = [];
   for (const fieldName in fields) {
     const field = fields[fieldName];
@@ -16041,7 +16138,13 @@ function getComponentDoc(comp) {
       methods: getFieldMethods(field)
     });
   }
-  return { name, methods: userMethods, input: inputHandlers, fields: fieldDocs };
+  return {
+    name,
+    methods: userMethods,
+    receive: receiveHandlers,
+    intent: intentHandlers,
+    fields: fieldDocs
+  };
 }
 function docComponents(normalized, { name = null } = {}) {
   const comps = normalized.components;
@@ -16077,8 +16180,11 @@ var init_components = __esm({
       getHandlerFor(v, name, key) {
         return this.getCompFor(v)?.[key][name] ?? null;
       }
-      getRequestFor(v, name) {
-        return this.getCompFor(v)?.scope.lookupRequest(name) ?? null;
+      // The `lex` leg of an intent's route: the handlers registered on the scope chain of
+      // the component that raised it, innermost first. A list, not a first match — see
+      // ComponentStack.lookupIntentChain.
+      getIntentChainFor(v, name) {
+        return this.getCompFor(v)?.scope.lookupIntentChain(name) ?? [];
       }
       compileStyles() {
         const styles2 = [];
@@ -16091,7 +16197,7 @@ var init_components = __esm({
         this.comps = comps;
         this.parent = parent;
         this.byName = {};
-        this.reqsByName = {};
+        this.intentsByName = {};
         this.macros = {};
       }
       enter() {
@@ -16123,11 +16229,21 @@ var init_components = __esm({
       getCompFor(v) {
         return this.comps.getCompFor(v);
       }
-      registerRequestHandlers(handlers) {
-        for (const name in handlers) this.reqsByName[name] = new RequestHandler(name, handlers[name]);
+      // 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.
+      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));
+        }
       }
-      lookupRequest(name) {
-        return this.reqsByName[name] ?? this.parent?.lookupRequest(name) ?? null;
+      // Innermost scope first, then outward. Concatenated rather than first-match, so a
+      // declining handler can hand the intent to one further up.
+      lookupIntentChain(name) {
+        const here = this.intentsByName[name] ?? [];
+        const up = this.parent?.lookupIntentChain(name) ?? [];
+        return up.length === 0 ? here : here.concat(up);
       }
       lookupComponent(name) {
         return this.byName[name] ?? this.parent?.lookupComponent(name) ?? null;
@@ -16136,7 +16252,7 @@ var init_components = __esm({
         return this.macros[name] ?? this.parent?.lookupMacro(name) ?? null;
       }
     };
-    _rawSpecKeys = "name view style commonStyle globalStyle input receive bubble response alter views provide lookup fields methods statics";
+    _rawSpecKeys = "name view style commonStyle globalStyle receive intent alter views provide lookup fields methods statics";
     KNOWN_SPEC_KEYS = new Set(_rawSpecKeys.split(" "));
   }
 });
@@ -16148,7 +16264,7 @@ function lintComponents(normalized, { name = null, LintParseContextClass, wellKn
   const stack = new ComponentStack();
   stack.registerComponents(comps);
   if (normalized.macros) stack.registerMacros(normalized.macros);
-  if (normalized.requestHandlers) stack.registerRequestHandlers(normalized.requestHandlers);
+  if (normalized.intentHandlers) stack.registerIntentHandlers(normalized.intentHandlers);
   const results = [];
   for (const comp of picked) {
     comp.compile(LintParseContextClass);
@@ -16361,22 +16477,19 @@ var init_stack = __esm({
 });
 
 // src/transactor.js
-function mkReq404(name) {
-  const fn = () => {
-    throw new Error(`Request not found: ${name}`);
-  };
-  return { fn };
-}
 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, ResponseEvent, SendEvent, BubbleEvent, InputDispatchEvent, Completion, Dispatcher, EventContext, RequestContext, PathChanges;
+var State2, Transactor, Transaction, toNullIfNaN, InputEvent, NameArgsTransaction, SendEvent, IntentEvent, PASS, DEFAULT_ROUTE, INTENT_DEPTH, IntentWalk, Completion, Dispatcher, EventContext, IntentContext, PathChanges;
 var init_transactor = __esm({
   "src/transactor.js"() {
     init_path();
@@ -16413,8 +16526,11 @@ var init_transactor = __esm({
         this.transactions.push(t);
         this.onTransactionPushed(t);
       }
-      // Subscribe to a normalized record for every handler invocation (send/receive,
-      // bubble, request/response, input). Returns an unsubscribe function. Records
+      // Subscribe to a normalized record for every handler invocation. `kind` is the
+      // handler bucket (`receive` / `intent`), plus `answer` — an observation-only kind for
+      // a message the runtime wrote to answer an intent. The BUCKET does not know about
+      // that distinction, and must not: a handler cannot tell an answer from a message its
+      // parent sent. Returns an unsubscribe function. Records
       // carry: kind, name, args, path, pathKeys, targetPath, handler, handlerName,
       // matched, before, after, parent, timestamp. Purely observational.
       observe(cb) {
@@ -16467,23 +16583,14 @@ var init_transactor = __esm({
         this.pushTransaction(t);
         return this._link(t, parent);
       }
-      pushInput(path, name, args = [], opts = {}, parent = null) {
-        const t = new InputDispatchEvent(path, this, name, args, parent, opts);
-        this.pushTransaction(t);
-        return this._link(t, parent);
-      }
-      pushBubble(path, name, args = [], opts = {}, parent = null, targetPath = null) {
-        const newOpts = opts.skipSelf ? { ...opts, skipSelf: false } : opts;
-        const t = new BubbleEvent(path, this, name, args, parent, newOpts, targetPath);
-        this.pushTransaction(t);
-        return this._link(t, parent);
-      }
-      pushRequest(path, name, args = [], opts = {}, parent = null) {
+      // Raise an intent: a job the sender did not address, walked along a route until
+      // something answers. `opts.route` is a list of legs (see DEFAULT_ROUTE) and
+      // `opts.livePath` opts out of pinning the answer's destination keys.
+      pushIntent(path, name, args = [], opts = {}, parent = null) {
         const release = parent ? parent.completion.track() : null;
-        const p = this._runRequest(path, name, args, opts, parent, release);
-        this._inflight.add(p);
-        p.finally(() => this._inflight.delete(p));
-        return p;
+        const walk = new IntentWalk(this, path, name, args, opts, parent, release);
+        walk.advance();
+        return walk;
       }
       // Drain queued transactions and await in-flight requests until quiescent. Each
       // awaited request enqueues a ResponseEvent, which may dispatch more work, so we
@@ -16494,57 +16601,6 @@ var init_transactor = __esm({
           if (this._inflight.size) await Promise.allSettled([...this._inflight]);
         }
       }
-      async _runRequest(path, name, args = [], opts = {}, parent = null, release = null) {
-        let released = false;
-        const transfer = (t) => {
-          if (release) {
-            released = true;
-            t.completion.whenSubtreeSettled().then(release);
-          }
-        };
-        try {
-          const curRoot = this.state.val;
-          const txnPath = path.toTransactionPath();
-          const curLeaf = txnPath.lookup(curRoot);
-          const found = this.comps.getRequestFor(curLeaf, name);
-          const handler = found ?? mkReq404(name);
-          if (this._observers.length > 0) {
-            const reqPath = txnPath.pinKeys(curRoot);
-            this._emit({
-              kind: "request",
-              name,
-              args,
-              path: reqPath,
-              pathKeys: reqPath.toKeys(),
-              targetPath: path,
-              handler: found?.fn ?? null,
-              handlerName: found?.fn?.name || name,
-              matched: found ? "exact" : "none",
-              before: curLeaf,
-              after: void 0,
-              parent,
-              timestamp: Date.now()
-            });
-          }
-          const reqCtx = new RequestContext(path, this, parent, curRoot);
-          const resHandlerName = opts?.onResName ?? name;
-          const resPath = opts?.livePath ? null : txnPath.pinKeys(curRoot);
-          const push = (specificName, baseName, singleArg, result, error) => {
-            const resArgs = specificName ? [singleArg] : [result, error];
-            const t = new ResponseEvent(path, this, specificName ?? baseName, resArgs, parent, resPath);
-            transfer(t);
-            this.pushTransaction(t);
-          };
-          try {
-            const result = await handler.fn.apply(null, [...args, reqCtx]);
-            push(opts?.onOkName, resHandlerName, result, result, null);
-          } catch (error) {
-            push(opts?.onErrorName, resHandlerName, error, null, error);
-          }
-        } finally {
-          if (release && !released) release();
-        }
-      }
       get hasPendingTransactions() {
         return this.transactions.length > 0;
       }
@@ -16561,6 +16617,7 @@ var init_transactor = __esm({
             this._emitTransaction(transaction, curState);
           } else console.warn("undefined new state", { curState, transaction });
         } finally {
+          transaction.ensureWalkAdvanced?.();
           transaction._completion?.ensureSelfSettled();
           transaction._completion?.releaseSelf();
         }
@@ -16596,6 +16653,15 @@ var init_transactor = __esm({
       }
       afterTransaction() {
       }
+      // Ending a walk and forwarding belong to the two dispatch buckets; the base warns
+      // 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');
+      }
+      forward(_opts) {
+        console.warn('ctx.forward() needs a "receive" or "intent" handler - ignored');
+      }
       buildRootStack(root, comps) {
         return Stack2.root(comps, root);
       }
@@ -16654,18 +16720,40 @@ var init_transactor = __esm({
         this._dispatchPath ??= this.path.compact();
         return this._dispatchPath;
       }
+      // A DOM event is an ADDRESSED message like any other — it reaches the component that
+      // owns the view and stops. It keeps its own class only because it resolves its handler
+      // from the compiled view and runs synchronously, not because it is a different channel.
       get observeKind() {
-        return "input";
+        return "receive";
       }
       get observeName() {
         return this.e?.type ?? null;
       }
+      // A view's name is a message. `forward` is where that name can LEAVE the component:
+      // it becomes an intent with the same name and the same arguments, so a view that says
+      // `@on.click="saveDraft .text"` never has to change when an ancestor takes the job over.
+      // (A `$method` handler has a name too, so forwarding one raises an intent under it.)
+      forward(opts) {
+        this._forward = opts ?? {};
+      }
+      afterTransaction() {
+        const f = this._forward;
+        if (f === void 0) return;
+        this._forward = void 0;
+        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");
+        this.transactor.pushIntent(this.dispatchPath, name, args, rest, this);
+      }
       buildRootStack(root, comps) {
         return Stack2.root(comps, root, this);
       }
       getHandlerAndArgs(root, _instance, comps) {
         const stack = this.buildStack(root, comps);
         const [handler, args] = this.handler.getHandlerAndArgs(stack, this);
+        this._handlerArgs = [...args];
         const path = this.dispatchPath;
         args.push(new EventContext(path, this.transactor, this));
         return [handler, args];
@@ -16750,39 +16838,190 @@ var init_transactor = __esm({
         return [handler, [...this.args, new EventContext(this.path, this.transactor, this)]];
       }
     };
-    ResponseEvent = class extends NameArgsTransaction {
-      handlerProp = "response";
-      constructor(path, transactor, name, args, parent, txnPath = null) {
-        super(path, transactor, name, args, parent);
-        this._txnPath = txnPath;
-      }
-      getTransactionPath() {
-        return this._txnPath ?? super.getTransactionPath();
-      }
-    };
     SendEvent = class extends NameArgsTransaction {
       handlerProp = "receive";
-      run(rootVal, comps) {
-        return this.opts.skipSelf ? rootVal : this.updateRootValue(rootVal, comps);
+      // `receive` is the ADDRESSED bucket, and it is the only one: a view's `@on.click`,
+      // a parent's ctx.send, the host's sendAtRoot and an answer to an intent all arrive
+      // here, and a handler cannot tell them apart. Splitting on where a message came from
+      // would let the view's name through and turn the parent's away, though the two say
+      // the same thing — and neither a test nor a parent could drive the component.
+      get observeKind() {
+        return this._isAnswer ? "answer" : "receive";
+      }
+      // `forward` in a RECEIVE body starts a walk: the message that arrived becomes an
+      // intent, keeping its name and payload. This is what lets a view's name leave the
+      // component without the view changing.
+      forward(opts) {
+        this._forward = opts ?? {};
       }
       afterTransaction() {
-        const { path, name, args, opts, targetPath } = this;
-        if (opts.bubbles && path.steps.length > 0)
-          this.transactor.pushBubble(path.popStep(), name, args, opts, this, targetPath);
+        const f = this._forward;
+        if (f === void 0) return;
+        this._forward = void 0;
+        const { args = this.args, ...rest } = f;
+        this.transactor.pushIntent(this.path, this.name, args, rest, this);
       }
     };
-    BubbleEvent = class extends SendEvent {
-      handlerProp = "bubble";
-      constructor(path, transactor, name, args, parent, opts, targetPath) {
-        super(path, transactor, name, args, parent, opts);
-        this.targetPath = targetPath ?? path;
+    IntentEvent = class extends NameArgsTransaction {
+      handlerProp = "intent";
+      constructor(path, transactor, walk) {
+        super(path, transactor, walk.name, walk.args, walk.parent, {});
+        this.walk = walk;
+        this.targetPath = walk.origin;
+      }
+      // `forward` in an INTENT body amends the hop about to be pushed — it does not push
+      // one itself, because a walk advances on its own.
+      forward(opts) {
+        this.walk.amend(opts, this.path);
       }
-      stopPropagation() {
-        this.opts.bubbles = false;
+      stop() {
+        this.walk.finish(null, null);
+      }
+      afterTransaction() {
+        this.ensureWalkAdvanced();
+      }
+      // Idempotent, because both afterTransaction and the transactor's `finally` call it —
+      // whichever gets there first advances the walk exactly once.
+      ensureWalkAdvanced() {
+        if (this._advanced) return;
+        this._advanced = true;
+        this.walk.advance();
       }
     };
-    InputDispatchEvent = class extends NameArgsTransaction {
-      handlerProp = "input";
+    PASS = /* @__PURE__ */ Symbol.for("tutuca.intent.pass");
+    DEFAULT_ROUTE = ["dyn", "lex"];
+    INTENT_DEPTH = 64;
+    IntentWalk = class {
+      constructor(transactor, path, name, args, opts, parent, release) {
+        this.transactor = transactor;
+        this.name = name;
+        this.args = args;
+        this.route = opts?.route ?? DEFAULT_ROUTE;
+        this.parent = parent;
+        this.release = release;
+        this.origin = path;
+        this.answerPath = opts?.livePath ? null : path.toTransactionPath().pinKeys(transactor.state.val);
+        this.legIndex = 0;
+        this.dynAt = path;
+        this.hops = 0;
+        this.ended = false;
+      }
+      // Offer the intent to the next hop. Called once at dispatch, and again by every hop
+      // that ran without answering.
+      advance() {
+        if (this.ended) return;
+        if (this.hops++ >= INTENT_DEPTH) return this.exhaust("intentDepth");
+        while (this.legIndex < this.route.length) {
+          const leg = this.route[this.legIndex];
+          if (leg === "dyn") {
+            if (this.dynAt.steps.length === 0) {
+              this.legIndex++;
+              continue;
+            }
+            this.dynAt = this.dynAt.popStep();
+            this.transactor.pushTransaction(new IntentEvent(this.dynAt, this.transactor, this));
+            return;
+          }
+          if (leg === "lex") {
+            this.legIndex++;
+            return this._tryLex();
+          }
+          console.warn("unknown intent route leg", leg, '- expected "dyn" or "lex"');
+          this.legIndex++;
+        }
+        this.exhaust("noHandler");
+      }
+      // The `lex` leg: the handlers registered on the scope chain of the component that
+      // raised the intent, in order.
+      _tryLex() {
+        const root = this.transactor.state.val;
+        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()
+          });
+        }
+        if (chain.length === 0) return this.advance();
+        const p = this._runLex(chain, 0);
+        this.transactor._inflight.add(p);
+        p.finally(() => this.transactor._inflight.delete(p));
+      }
+      async _runLex(chain, i) {
+        if (this.ended) return;
+        if (i >= chain.length) return this.advance();
+        const ctx = new IntentContext(this.origin, this.transactor, this.parent);
+        try {
+          const res = await chain[i].fn.apply(null, [...this.args, ctx]);
+          if (res === PASS) return this._runLex(chain, i + 1);
+          this.answer("Ok", res);
+        } catch (error) {
+          this.answer("Error", error);
+        }
+      }
+      // A hop answered. Ends the walk.
+      answer(suffix, value) {
+        this.finish(`${this.name}${suffix}`, [value]);
+      }
+      // `forward` from an intent body: keep walking, optionally with new arguments or a
+      // narrowed route.
+      amend(opts, from) {
+        if (opts?.args !== void 0) this.args = opts.args;
+        if (opts?.route !== void 0) {
+          this.route = opts.route;
+          this.legIndex = 0;
+          this.dynAt = from ?? this.dynAt;
+        }
+      }
+      // The route ran out. What the sender hears depends only on what it DECLARES, which is
+      // how "a sender expects an answer if and only if it declares an answer arm" becomes
+      // code — nobody writes it down twice, and there is no schema to keep in step.
+      exhaust(reason) {
+        if (this.ended) return;
+        const { name, args } = this;
+        const comp = this.transactor.comps.getCompFor(
+          this.origin.toTransactionPath().lookup(this.transactor.state.val)
+        );
+        const declares = (n) => comp?.receive?.[n] !== void 0;
+        if (declares(`${name}Unhandled`)) {
+          this.finish(`${name}Unhandled`, args);
+        } else if (declares(`${name}Error`)) {
+          this.finish(`${name}Error`, [reason]);
+        } else {
+          if (declares(`${name}Ok`))
+            console.warn(
+              `intent "${name}" was not answered (${reason}) and this component declares only "${name}Ok" - add "${name}Unhandled" or "${name}Error" to handle it`
+            );
+          this.finish(null, null);
+        }
+      }
+      // End the walk. `name === null` means no answer goes out, which is what `stop` and a
+      // fire-and-forget notification both are — the tracked unit is released here instead
+      // of following an answer's subtree.
+      finish(name, args) {
+        if (this.ended) return;
+        this.ended = true;
+        if (name === null) return this.release?.();
+        const path = this.answerPath ?? this.origin;
+        const t = new SendEvent(path, this.transactor, name, args, this.parent, {});
+        t._isAnswer = true;
+        this.transactor.pushTransaction(t);
+        if (this.release) t.completion.whenSubtreeSettled().then(this.release);
+      }
     };
     Completion = class {
       constructor() {
@@ -16863,23 +17102,21 @@ var init_transactor = __esm({
       get at() {
         return new PathChanges(this);
       }
+      // A message is ADDRESSED: it names one component and stops there.
       send(name, args, opts) {
         return this.sendAtPath(this.path, name, args, opts);
       }
-      bubble(name, args, opts) {
-        return this.send(name, args, { skipSelf: true, bubbles: true, ...opts });
-      }
       sendAtPath(path, name, args, opts) {
         return this.transactor.pushSend(path, name, args, opts, this.parent);
       }
-      request(name, args, opts) {
-        return this.requestAtPath(this.path, name, args, opts);
+      // An intent is ROUTED: it names a job and walks until something answers. The verb
+      // does not decide which scope answers — `opts.route` does, written here at the call
+      // site, which is where the decision actually is.
+      intent(name, args, opts) {
+        return this.intentAtPath(this.path, name, args, opts);
       }
-      requestAtPath(path, name, args, opts) {
-        return this.transactor.pushRequest(path, name, args, opts, this.parent);
-      }
-      inputAtPath(path, name, args, opts) {
-        return this.transactor.pushInput(path, name, args, opts, this.parent);
+      intentAtPath(path, name, args, opts) {
+        return this.transactor.pushIntent(path, name, args, opts, this.parent);
       }
       lookupTypeFor(name, inst) {
         return this.transactor.comps.getCompFor(inst).scope.lookupComponent(name);
@@ -16892,11 +17129,26 @@ var init_transactor = __esm({
       get targetPath() {
         return this.parent.targetPath;
       }
-      stopPropagation() {
-        return this.parent.stopPropagation();
+      // Answer the intent being handled, with a result or with an error. Either ENDS the
+      // walk. Legal only in an `intent` handler: a message has no sender waiting on it.
+      reply(value) {
+        return this.parent.walk === void 0 ? warnNotIntent("reply") : this.parent.walk.answer("Ok", value);
+      }
+      fail(error) {
+        return this.parent.walk === void 0 ? warnNotIntent("fail") : this.parent.walk.answer("Error", error);
+      }
+      // End the walk answering nothing — "served, and no answer".
+      stop() {
+        return this.parent.stop();
+      }
+      // From an `intent` body: hand the intent to the next hop, optionally amending it.
+      // From a `receive` body: turn the message that arrived into an intent. One word from
+      // both ends of a walk; which one you get depends on which bucket you are in.
+      forward(opts) {
+        return this.parent.forward(opts);
       }
     };
-    RequestContext = class extends Dispatcher {
+    IntentContext = class extends Dispatcher {
     };
     PathChanges = class extends PathBuilder {
       constructor(dispatcher) {
@@ -16906,8 +17158,8 @@ var init_transactor = __esm({
       send(name, args, opts) {
         return this.dispatcher.sendAtPath(this.buildPath(), name, args, opts);
       }
-      bubble(name, args, opts) {
-        return this.send(name, args, { skipSelf: true, bubbles: true, ...opts });
+      intent(name, args, opts) {
+        return this.dispatcher.intentAtPath(this.buildPath(), name, args, opts);
       }
       buildPath() {
         return this.dispatcher.path.concat(this.pathChanges);
@@ -17185,11 +17437,6 @@ function phaseOps(phase) {
 function resolveArgs(args, self) {
   return typeof args === "function" ? args(self) ?? [] : args ?? [];
 }
-function phaseHasBubble(phase) {
-  if (!phase) return false;
-  if (phase.bubble?.length) return true;
-  return (phase.do ?? []).some((op) => op.type === "bubble");
-}
 function dispatchPhase(dispatcher, targetPath, phase, self) {
   if (!phase) return;
   for (const op of phaseOps(phase)) {
@@ -17198,18 +17445,8 @@ function dispatchPhase(dispatcher, targetPath, phase, self) {
       case "send":
         dispatcher.sendAtPath(targetPath, op.name, args, op.opts);
         break;
-      case "bubble":
-        dispatcher.sendAtPath(targetPath, op.name, args, {
-          skipSelf: true,
-          bubbles: true,
-          ...op.opts
-        });
-        break;
-      case "request":
-        dispatcher.requestAtPath(targetPath, op.name, args, op.opts);
-        break;
-      case "input":
-        dispatcher.inputAtPath(targetPath, op.name, args, op.opts);
+      case "intent":
+        dispatcher.intentAtPath(targetPath, op.name, args, op.opts);
         break;
     }
   }
@@ -17217,7 +17454,7 @@ function dispatchPhase(dispatcher, targetPath, phase, self) {
 var OP_KINDS;
 var init_on = __esm({
   "src/on.js"() {
-    OP_KINDS = ["send", "bubble", "request", "input"];
+    OP_KINDS = ["send", "intent"];
   }
 });
 
@@ -17243,7 +17480,7 @@ function renderToHTMLNode(document2, components, macros, rootState, ParseContext
   const app = new App(container, comps, renderer, ParseContext2);
   const scope = app.registerComponents(components);
   if (macros) scope.registerMacros(macros);
-  if (opts.requestHandlers) scope.registerRequestHandlers(opts.requestHandlers);
+  if (opts.intentHandlers) scope.registerIntentHandlers(opts.intentHandlers);
   app.rootViewName = opts.view ?? null;
   app.transactor.state.set(rootState);
   app.start(opts);
@@ -17256,21 +17493,17 @@ function renderToHTMLNode(document2, components, macros, rootState, ParseContext
     }
   };
 }
-async function renderToHTMLDriven(document2, components, macros, rootState, ParseContext2, { phase = null, requestHandlers = null, view = null, warn = console.warn } = {}) {
+async function renderToHTMLDriven(document2, components, macros, rootState, ParseContext2, { phase = null, intentHandlers = null, view = null } = {}) {
   const { container, app, cleanup } = renderToHTMLNode(
     document2,
     components,
     macros,
     rootState,
     ParseContext2,
-    { noCache: true, requestHandlers, view }
+    { noCache: true, intentHandlers, view }
   );
   try {
     if (phase) {
-      if (phaseHasBubble(phase))
-        warn(
-          "render: a `bubble` action is a no-op here — the example's value is the render root, so there is no ancestor to receive it. Use send/request/input to drive a preset state."
-        );
       dispatchPhase(rootDispatcher(app.transactor), new Path([]), phase, app.state.val);
       await app.transactor.settle();
     }
@@ -17299,7 +17532,7 @@ function checkView2(value, components, viewName) {
   return new Error(`view "${viewName}" is not defined on ${comp.name} (has: ${known})`);
 }
 function handlersFor(normalized, example) {
-  const merged = { ...normalized.requestHandlers ?? {}, ...example.requestHandlers ?? {} };
+  const merged = { ...normalized.intentHandlers ?? {}, ...example.intentHandlers ?? {} };
   return Object.keys(merged).length > 0 ? merged : null;
 }
 async function renderExamples(normalized, env, { name = null, title = null, view = null } = {}) {
@@ -17324,7 +17557,7 @@ async function renderExamples(normalized, env, { name = null, title = null, view
           env.ParseContext,
           {
             phase: example.on?.init ?? null,
-            requestHandlers: handlersFor(normalized, example),
+            intentHandlers: handlersFor(normalized, example),
             view: viewName
           }
         );
@@ -17488,29 +17721,24 @@ function captureError(e) {
   if ("actual" in e) out.actual = e.actual;
   return out;
 }
-function buildStack({ components = [], macros = null, requestHandlers = null } = {}) {
+function buildStack({ components = [], macros = null, intentHandlers = null } = {}) {
   const stack = new ComponentStack();
   stack.registerComponents(components);
   if (macros) stack.registerMacros(macros);
-  if (requestHandlers) stack.registerRequestHandlers(requestHandlers);
+  if (intentHandlers) stack.registerIntentHandlers(intentHandlers);
   return stack;
 }
 async function driveStack(stack, value, phase, opts = {}) {
-  const warn = opts.warn ?? console.warn;
   const transactor = new Transactor(stack.comps, value);
   if (opts.onMessage)
     transactor.state.onChange(({ val, old, info }) => {
       const t = info?.transaction;
       opts.onMessage(
-        { kind: t?.handlerProp ?? "input", name: t?.name, args: t?.args, path: t?.path },
+        { kind: t?.handlerProp ?? "receive", name: t?.name, args: t?.args, path: t?.path },
         old,
         val
       );
     });
-  if (phaseHasBubble(phase))
-    warn(
-      "drive(): a `bubble` action is a no-op here — drive originates at the root and bubbles travel child→parent, so there is no ancestor to receive it (and the root's own bubble handler is skipped). To exercise a bubble handler, call it directly."
-    );
   dispatchPhase(rootDispatcher(transactor), new Path([]), phase, value);
   await transactor.settle();
   return transactor.state.val;
@@ -17523,7 +17751,7 @@ async function runTests({
   name = null,
   grep = null,
   bail = false,
-  requestHandlers = null,
+  intentHandlers = null,
   macros = null
 } = {}) {
   const counts = { pass: 0, fail: 0, skip: 0, total: 0 };
@@ -17537,7 +17765,7 @@ async function runTests({
   }
   const { describe: describe6, test: test2, moduleTests } = makeCollector({ path, components });
   let _stack = null;
-  const getStack = () => _stack ??= buildStack({ components, macros, requestHandlers });
+  const getStack = () => _stack ??= buildStack({ components, macros, intentHandlers });
   const driveLocal = (value, phase, opts = {}) => driveStack(getStack(), value, phase, opts);
   await getTests({ describe: describe6, test: test2, expect: expect2, drive: driveLocal });
   let bailed = false;
@@ -17706,7 +17934,7 @@ var init_registry = __esm({
           name: positionals[0] ?? null,
           grep: values.grep ?? null,
           bail: values.bail ?? false,
-          requestHandlers: normalized.requestHandlers,
+          intentHandlers: normalized.intentHandlers,
           macros: normalized.macros
         }),
         exitOn: (result) => result.hasFailures ? 4 : 0
@@ -18008,7 +18236,7 @@ MODULE CONVENTION
     export function getMacros()           // optional
       -> Record<string, Macro>            // from tutuca's macro()
 
-    export function getRequestHandlers()  // optional
+    export function getIntentHandlers()  // optional
       -> Record<string, Function>
 
     export function getTests({ describe, test, expect })   // required for test
@@ -18530,7 +18758,7 @@ async function runDevTests(projectDir, devModuleUrls) {
       components: normalized.components,
       path: abs,
       expect,
-      requestHandlers: normalized.requestHandlers,
+      intentHandlers: normalized.intentHandlers,
       macros: normalized.macros
     });
     const m = report.modules[0];
@@ -18577,11 +18805,11 @@ async function discoverModules(projectDir, devModuleUrls) {
             title: it.title,
             view: it.view,
             componentName: it.componentName,
-            requestHandlers: it.requestHandlerNames
+            intentHandlers: it.requestHandlerNames
           }))
         })),
         macros: normalized.macros ? Object.keys(normalized.macros) : [],
-        requestHandlers: normalized.requestHandlers ? Object.keys(normalized.requestHandlers) : [],
+        intentHandlers: normalized.intentHandlers ? Object.keys(normalized.intentHandlers) : [],
         error: null
       });
     } catch (e) {