tutuca 0.9.115 → 0.11.0

package/dist/tutuca-dev.ext.js

@@ -170,11 +170,69 @@ __reExport(chai_exports, chai_star);
 import * as chai_star from "chai";
 chai.use(jestMatchers);
 
-// src/value.js
-import { is } from "immutable";
+// src/collection.js
+var isPlainObject = (value) => {
+  if (value === null || typeof value !== "object") return false;
+  const proto = Object.getPrototypeOf(value);
+  return proto === Object.prototype || proto === null;
+};
+var seqSize = (seq) => {
+  if (seq == null) return 0;
+  if (typeof seq.length === "number") return seq.length;
+  if (typeof seq.size === "number") return seq.size;
+  return isPlainObject(seq) ? Object.keys(seq).length : 0;
+};
+var seqGet = (seq, key, dval = null) => {
+  if (seq == null) return dval;
+  if (seq instanceof Map) return seq.has(key) ? seq.get(key) : dval;
+  if (seq instanceof Set) return seq.has(key) ? key : dval;
+  if (Object.hasOwn(seq, key)) return seq[key];
+  if (typeof seq.get === "function") return seq.get(key, dval);
+  return dval;
+};
+var isIndexedSeq = (seq) => Array.isArray(seq);
+var isKeyedSeq = (seq) => seq instanceof Map || isPlainObject(seq);
+var isSetSeq = (seq) => seq instanceof Set;
+function* seqEntries(seq) {
+  if (seq instanceof Map) yield* seq.entries();
+  else if (seq instanceof Set) for (const value of seq) yield [value, value];
+  else if (isPlainObject(seq)) yield* Object.entries(seq);
+  else if (Array.isArray(seq)) for (let i = 0; i < seq.length; i++) yield [i, seq[i]];
+}
+
+// src/immer.js
+var immer_exports = {};
+__reExport(immer_exports, immer_star);
+import { enableMapSet } from "immer";
+import * as immer_star from "immer";
+enableMapSet();
 
 // src/path.js
 var NONE = /* @__PURE__ */ Symbol("NONE");
+var readKey = (value, key, dval = null) => {
+  if (value == null) return dval;
+  if (value instanceof Map) return value.has(key) ? value.get(key) : dval;
+  if (value instanceof Set) return value.has(key) ? key : dval;
+  return Object.hasOwn(value, key) ? value[key] : dval;
+};
+var writeKey = (value, key, next) => {
+  if (value instanceof Map) value.set(key, next);
+  else if (value instanceof Set) {
+    value.delete(key);
+    value.add(next);
+  } else value[key] = next;
+};
+var readSeqKey = (value, key, dval = null) => {
+  const direct = readKey(value, key, NONE);
+  if (direct !== NONE) return direct;
+  return typeof value?.get === "function" ? value.get(key, dval) : dval;
+};
+var writeSeqKey = (value, key, next) => {
+  if (value instanceof Map || value instanceof Set || Array.isArray(value) || Object.hasOwn(value, key))
+    writeKey(value, key, next);
+  else if (typeof value?.set === "function") value.set(key, next);
+  else writeKey(value, key, next);
+};
 var Step = class {
   lookup(_v, dval = null) {
     return dval;
@@ -182,6 +240,8 @@ var Step = class {
   setValue(root, _v) {
     return root;
   }
+  setDraftValue(_root, _v) {
+  }
   enterFrame(stack, _prev, next) {
     return stack.enter(next, {}, true);
   }
@@ -246,10 +306,13 @@ var FieldStep = class extends Step {
     this.field = field;
   }
   lookup(v, dval = null) {
-    return v?.get ? v.get(this.field, dval) : dval;
+    return readKey(v, this.field, dval);
   }
   setValue(root, v) {
-    return root.set(this.field, v);
+    return (0, immer_exports.produce)(root, (draft) => this.setDraftValue(draft, v));
+  }
+  setDraftValue(root, v) {
+    writeKey(root, this.field, v);
   }
   withIndex(i) {
     return new SeqStep(this.field, i);
@@ -268,12 +331,14 @@ var SeqStep = class extends Step {
     this.key = key;
   }
   lookup(v, dval = null) {
-    const o = v?.get(this.field, null);
-    return o?.get ? o.get(this.key, dval) : dval;
+    return readSeqKey(readKey(v, this.field, null), this.key, dval);
   }
   setValue(root, v) {
-    const seq = root?.get(this.field, null);
-    return seq ? root.set(this.field, seq.set(this.key, v)) : root;
+    return (0, immer_exports.produce)(root, (draft) => this.setDraftValue(draft, v));
+  }
+  setDraftValue(root, v) {
+    const seq = readKey(root, this.field, null);
+    if (seq != null) writeSeqKey(seq, this.key, v);
   }
   enterFrame(stack, _prev, next) {
     return stack.enter(next, { key: this.key }, true);
@@ -289,19 +354,22 @@ var SeqAccessStep = class extends Step {
     this.keyField = keyField;
   }
   lookup(v, dval = null) {
-    const seq = v?.get(this.seqField, NONE);
-    const key = v?.get(this.keyField, NONE);
-    return key !== NONE && seq?.get ? seq.get(key, dval) : dval;
+    const seq = readKey(v, this.seqField, NONE);
+    const key = readKey(v, this.keyField, NONE);
+    return key !== NONE && seq !== NONE ? readSeqKey(seq, key, dval) : dval;
   }
   setValue(root, v) {
-    const seq = root?.get(this.seqField, NONE);
-    const key = root?.get(this.keyField, NONE);
-    return seq === NONE || key === NONE ? root : root.set(this.seqField, seq.set(key, v));
+    return (0, immer_exports.produce)(root, (draft) => this.setDraftValue(draft, v));
+  }
+  setDraftValue(root, v) {
+    const seq = readKey(root, this.seqField, NONE);
+    const key = readKey(root, this.keyField, NONE);
+    if (seq !== NONE && key !== NONE) writeSeqKey(seq, key, v);
   }
   // Resolve `keyField` against `v` now and freeze it as a literal-key `SeqStep`, so a
   // later lookup/setValue lands on this same item even if `keyField` changes meanwhile.
   pinKey(v) {
-    const key = v?.get(this.keyField, NONE);
+    const key = readKey(v, this.keyField, NONE);
     return key === NONE ? this : new SeqStep(this.seqField, key);
   }
   // The key is a *field reference* resolved live, so it is unknown without a value;
@@ -482,19 +550,15 @@ var Path = class _Path {
     return out;
   }
   setValue(root, v) {
-    const intermediates = new Array(this.steps.length);
-    let curVal = root;
-    for (let i = 0; i < this.steps.length; i++) {
-      intermediates[i] = curVal;
-      curVal = this.steps[i].lookup(curVal, NONE);
-      if (curVal === NONE) return root;
-    }
-    let newVal = v;
-    for (let i = this.steps.length - 1; i >= 0; i--) {
-      newVal = this.steps[i].setValue(intermediates[i], newVal);
-      intermediates[i] = newVal;
-    }
-    return newVal;
+    if (this.steps.length === 0) return v;
+    return (0, immer_exports.produce)(root, (draft) => {
+      let parent = draft;
+      for (let i = 0; i < this.steps.length - 1; i++) {
+        parent = this.steps[i].lookup(parent, NONE);
+        if (parent === NONE) return;
+      }
+      this.steps.at(-1).setDraftValue(parent, v);
+    });
   }
   buildStack(stack) {
     let prev = stack.it;
@@ -691,7 +755,8 @@ function sizeOf(v) {
   const s = v.size;
   if (typeof s === "number") return s;
   const l = v.length;
-  return typeof l === "number" ? l : null;
+  if (typeof l === "number") return l;
+  return isPlainObject(v) ? Object.keys(v).length : null;
 }
 var predTruthy = (v) => {
   const n = sizeOf(v);
@@ -702,7 +767,7 @@ var PREDICATES = {
   "truthy?": { name: "truthy?", arity: 1, fn: predTruthy },
   "falsy?": { name: "falsy?", arity: 1, fn: (v) => !predTruthy(v) },
   "null?": { name: "null?", arity: 1, fn: (v) => v == null },
-  "equals?": { name: "equals?", arity: 2, fn: (a, b) => is(a, b) }
+  "equals?": { name: "equals?", arity: 2, fn: (a, b) => Object.is(a, b) }
 };
 function parseToken(s, px) {
   const c0 = s.charCodeAt(0);
@@ -787,21 +852,29 @@ function parseProvide(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, false);
 }
 function parseAlterHandler(s, px) {
-  const r = _parseHandler(s, px, "alter", false, false);
+  const r = _parseHandler(s, px, "alter", false, false, true);
   return r === null ? null : r.handlerVal;
 }
-function _parseHandler(s, px, namespace, allowArgs, report) {
+function _parseHandler(s, px, namespace, allowArgs, report, allowMethod) {
   const tokens = tokenizeValue(s.trim());
   const headTok = tokens[0] ?? "";
   const head = headTok === "" ? null : parseToken(headTok, px);
   const hk = kindOf(head);
   let handlerVal;
-  if (hk & K_METHOD) handlerVal = head;
-  else if (hk & K_NAME) handlerVal = new HandlerNameVal(head.name, namespace);
+  if (hk & K_METHOD && allowMethod) handlerVal = head;
+  else if (hk & K_METHOD) {
+    if (report)
+      px.onParseIssue("event-method-handler", {
+        name: head.name,
+        role: "handler-name",
+        value: headTok
+      });
+    return null;
+  } else if (hk & K_NAME) handlerVal = new HandlerNameVal(head.name, namespace);
   else {
     if (report) px.onParseIssue("bad-value", { role: "handler-name", value: headTok });
     return null;
@@ -1015,7 +1088,7 @@ var BindMemberVal = class extends BindVal {
   }
   eval(stack) {
     const v = stack.lookupBind(this.name);
-    return typeof v?.get === "function" ? v.get(this.member, null) : v?.[this.member] ?? null;
+    return seqGet(v, this.member, null);
   }
   toString() {
     return `@${this.name}.${this.member}`;
@@ -1062,7 +1135,7 @@ var SeqAccessVal = class extends RenderVal {
   }
   eval(stack) {
     const key = this.keyVal.eval(stack);
-    return this.seqVal.eval(stack)?.get(key, null);
+    return seqGet(this.seqVal.eval(stack), key, null);
   }
   toString() {
     return `${this.seqVal}[${this.keyVal}]`;
@@ -1331,20 +1404,17 @@ var EventHandler = class _EventHandler {
     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);
   }
 };
-var RequestHandler = class {
+var IntentHandler = class {
   constructor(name, fn) {
     this.name = name;
     this.fn = fn;
   }
 };
 
-// src/renderer.js
-import { isIndexed, isKeyed } from "immutable";
-
 // src/cache.js
 var isWeakKey = (k) => k !== null && (typeof k === "object" || typeof k === "function");
 var NullDomCache = class {
@@ -1841,7 +1911,7 @@ var Renderer = class {
         this.cache.set(cachePath, cacheKey, dom);
       }
     };
-    if (keys) imKeysIter(seq, renderOne, keys);
+    if (keys) keysIter(seq, renderOne, keys);
     else
       getSeqInfo(seq)(
         seq,
@@ -1875,7 +1945,7 @@ var Renderer = class {
     return new VFragment([this._renderMetadata({ $: "Scope", nid }), dom]);
   }
 };
-var getSeqInfo = (seq) => isIndexed(seq) ? imIndexedIter : isKeyed(seq) ? imKeyedIter : seq?.[SEQ_INFO] ?? unkIter;
+var getSeqInfo = (seq) => isIndexedSeq(seq) ? nativeIndexedIter : isKeyedSeq(seq) || isSetSeq(seq) ? nativeKeyedIter : seq?.[SEQ_INFO] ?? unkIter;
 var normalizeRange = (start, end, size) => {
   let s = start == null ? 0 : start < 0 ? size + start : start;
   let e = end == null ? size : end < 0 ? size + end : end;
@@ -1898,22 +1968,22 @@ var unpackLoopResult = (result, seq) => {
   const r = result ?? {};
   return { iterData: r.iterData ?? { seq }, start: r.start, end: r.end, keys: r.keys };
 };
-var imKeysIter = (seq, visit, keys) => {
-  const attrName = isIndexed(seq) ? "si" : "sk";
-  for (const key of keys) visit(key, seq.get(key), attrName);
+var keysIter = (seq, visit, keys) => {
+  const attrName = isIndexedSeq(seq) ? "si" : "sk";
+  for (const key of keys) visit(key, seqGet(seq, key), attrName);
 };
 var makeLoopCtx = (stack, filter) => ({
   lookup: (name) => stack.lookupBind(name),
   filter: (key, value, iterData) => filter.call(stack.it, key, value, iterData)
 });
-var imIndexedIter = (seq, visit, start, end) => {
-  const [s, e] = normalizeRange(start, end, seq.size);
-  for (let i = s; i < e; i++) visit(i, seq.get(i), "si");
+var nativeIndexedIter = (seq, visit, start, end) => {
+  const [s, e] = normalizeRange(start, end, seqSize(seq));
+  for (let i = s; i < e; i++) visit(i, seq[i], "si");
 };
-var imKeyedIter = (seq, visit, start, end) => {
-  const [s, e] = normalizeRange(start, end, seq.size);
+var nativeKeyedIter = (seq, visit, start, end) => {
+  const [s, e] = normalizeRange(start, end, seqSize(seq));
   let i = 0;
-  for (const [k, v] of seq.toSeq().entries()) {
+  for (const [k, v] of seqEntries(seq)) {
     if (i >= e) break;
     if (i >= s) visit(k, v, "sk");
     i++;
@@ -2433,7 +2503,7 @@ var IterInfo = class {
   // { key, value }, then run @enrich-with (with @loop-with's iterData) if any.
   enrichBinds(stack, key) {
     const { seq, filter, loopWith, enricher } = this.eval(stack);
-    const value = seq?.get ? seq.get(key, null) : null;
+    const value = seqGet(seq, key, null);
     const binds = { key, value };
     if (enricher) {
       const { iterData } = unpackLoopResult(
@@ -5031,7 +5101,7 @@ var KNOWN_COMPONENT_SPEC_KEYS = new Set(
   )
 );
 var EMPTY_SET = /* @__PURE__ */ new Set();
-var FRAMEWORK_WELL_KNOWN_EXTRAS = /* @__PURE__ */ new Set(["requestOverridesField"]);
+var FRAMEWORK_WELL_KNOWN_EXTRAS = /* @__PURE__ */ new Set(["intentOverridesField"]);
 var KNOWN_DIRECTIVE_NAMES = /* @__PURE__ */ new Set([
   "dangerouslysetinnerhtml",
   "slot",
@@ -5056,11 +5126,11 @@ var LOOKUP_TARGET_MALFORMED = "LOOKUP_TARGET_MALFORMED";
 var RENDER_IT_OUTSIDE_OF_LOOP = "RENDER_IT_OUTSIDE_OF_LOOP";
 var UNKNOWN_EVENT_MODIFIER = "UNKNOWN_EVENT_MODIFIER";
 var UNKNOWN_HANDLER_ARG_NAME = "UNKNOWN_HANDLER_ARG_NAME";
-var INPUT_HANDLER_NOT_IMPLEMENTED = "INPUT_HANDLER_NOT_IMPLEMENTED";
-var INPUT_HANDLER_NOT_REFERENCED = "INPUT_HANDLER_NOT_REFERENCED";
-var INPUT_HANDLER_METHOD_NOT_IMPLEMENTED = "INPUT_HANDLER_METHOD_NOT_IMPLEMENTED";
-var INPUT_HANDLER_FOR_INPUT_HANDLER_METHOD = "INPUT_HANDLER_FOR_INPUT_HANDLER_METHOD";
-var INPUT_HANDLER_METHOD_FOR_INPUT_HANDLER = "INPUT_HANDLER_METHOD_FOR_INPUT_HANDLER";
+var RECEIVE_HANDLER_NOT_IMPLEMENTED = "RECEIVE_HANDLER_NOT_IMPLEMENTED";
+var EVENT_HANDLER_METHOD_NOT_ALLOWED = "EVENT_HANDLER_METHOD_NOT_ALLOWED";
+var RETIRED_HANDLER_BUCKET = "RETIRED_HANDLER_BUCKET";
+var RETIRED_CTX_VERB = "RETIRED_CTX_VERB";
+var HANDLER_NAME_COLLISION = "HANDLER_NAME_COLLISION";
 var FIELD_VAL_NOT_DEFINED = "FIELD_VAL_NOT_DEFINED";
 var FIELD_VAL_IS_METHOD = "FIELD_VAL_IS_METHOD";
 var METHOD_VAL_NOT_DEFINED = "METHOD_VAL_NOT_DEFINED";
@@ -5088,8 +5158,7 @@ var COMP_FIELD_BAD_SHAPE = "COMP_FIELD_BAD_SHAPE";
 var ASYNC_HANDLER = "ASYNC_HANDLER";
 var TOP_LEVEL_AT_RULE_IN_SCOPED_STYLE = "TOP_LEVEL_AT_RULE_IN_SCOPED_STYLE";
 var GLOBAL_SELECTOR_IN_SCOPED_STYLE = "GLOBAL_SELECTOR_IN_SCOPED_STYLE";
-var FIELD_NAME_RESERVED_BY_RECORD = "FIELD_NAME_RESERVED_BY_RECORD";
-var RECORD_FIELD_NAME_COLLISIONS = /* @__PURE__ */ new Set(["entries", "hashCode"]);
+var FIELD_METHOD_NAME_COLLISION = "FIELD_METHOD_NAME_COLLISION";
 var X_KNOWN_OP_NAMES = /* @__PURE__ */ new Set([
   "slot",
   "text",
@@ -5112,7 +5181,8 @@ var PARSE_ISSUES = {
     candidates: X_KNOWN_ATTR_NAMES,
     atPrefix: X_KNOWN_ATTR_NAMES
   },
-  "bad-value": { id: BAD_VALUE }
+  "bad-value": { id: BAD_VALUE },
+  "event-method-handler": { id: EVENT_HANDLER_METHOD_NOT_ALLOWED }
 };
 function protoHasMethod(proto, name) {
   return protoMethodValue(proto, name) !== null;
@@ -5174,10 +5244,13 @@ function checkComponent(Comp, lx = new LintContext(), { wellKnownExtras = EMPTY_
   return lx.push({ componentName: Comp.name }, () => {
     checkUnknownSpecKeys(lx, Comp, wellKnownExtras);
     checkFieldDeclarations(lx, Comp);
-    checkRecordFieldNameCollisions(lx, Comp);
+    checkFieldMethodNameCollisions(lx, Comp);
     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();
@@ -5191,7 +5264,6 @@ function checkComponent(Comp, lx = new LintContext(), { wellKnownExtras = EMPTY_
       );
     }
     checkUnreferencedAlterHandlers(lx, Comp, referencedAlters);
-    checkUnreferencedInputHandlers(lx, Comp, referencedInputs);
     checkUnreferencedDynamics(lx, Comp, referencedDynamics);
     return lx;
   });
@@ -5235,6 +5307,14 @@ function checkParseIssues(lx, view) {
       lx.warn(X_OP_IGNORES_CHILDREN, info, { kind: "remove", what: "the ignored children" });
       continue;
     }
+    if (kind === "event-method-handler") {
+      lx.error(EVENT_HANDLER_METHOD_NOT_ALLOWED, info, {
+        kind: "rephrase",
+        from: info.value,
+        text: `Move '${info.name}' to receive and reference it as '${info.name}'.`
+      });
+      continue;
+    }
     const rule = PARSE_ISSUES[kind];
     if (!rule) continue;
     const id = rule.id;
@@ -5461,7 +5541,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 }, () => {
@@ -5469,44 +5549,22 @@ function checkEventHandlersHaveImpls(lx, Comp, referencedInputs) {
       for (const event of view.ctx.events) {
         for (const handler of event.handlers) {
           const { handlerVal } = handler.handlerCall;
-          const hvName = handlerVal?.constructor.name;
           const eventName = handler.name;
           const originAttr = `@on.${eventName}`;
-          if (hvName === "HandlerNameVal") {
+          if (handlerVal?.constructor.name === "HandlerNameVal") {
             referencedInputs?.add(handlerVal.name);
             const { name } = handlerVal;
             if (input[name] === void 0) {
-              const isMethodFix = protoHasMethod(proto, name);
+              const suggestion = protoHasMethod(proto, name) ? {
+                kind: "rephrase",
+                from: name,
+                text: `Move '${name}' from methods to receive; event handlers are receive handlers.`
+              } : replaceNameSuggestion(name, Object.keys(input));
               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))
+                suggestion
               );
-              if (isMethodFix) {
-                lx.hint(
-                  INPUT_HANDLER_METHOD_FOR_INPUT_HANDLER,
-                  { name, handler, event, eventName, originAttr },
-                  { kind: "add-prefix", from: name, to: `$${name}` }
-                );
-              }
-            }
-          } else if (hvName === "MethodVal") {
-            referencedInputs?.add(handlerVal.name);
-            const { name } = handlerVal;
-            if (!protoHasMethod(proto, name)) {
-              const isInputFix = input[name] !== void 0;
-              lx.error(
-                INPUT_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,
-                  { name, handler, event, eventName, originAttr },
-                  { kind: "drop-prefix", from: `$${name}`, to: name }
-                );
-              }
             }
           }
         }
@@ -5610,10 +5668,10 @@ var ATTR_VAL_CHECKERS = {
   }
 };
 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 check3 = ATTR_VAL_CHECKERS[val?.constructor.name];
+  if (check3 === void 0) return;
   const recurse = (sub) => checkConsistentAttrVal(lx, sub, env, skipNameVal, errCtx, false);
-  check2({ lx, val, env, errCtx, skipNameVal, recurse, isRoot });
+  check3({ lx, val, env, errCtx, skipNameVal, recurse, isRoot });
 }
 var NODE_KIND_TO_CTX = {
   RenderTextNode: { originAttr: "<x text>" },
@@ -5751,12 +5809,83 @@ function checkConsistentAttrs(lx, Comp, referencedAlters, referencedDynamics) {
     });
   }
 }
+var isPlainObj = (v) => v !== null && typeof v === "object" && !Array.isArray(v);
+var 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"
+  }
+};
+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 });
+  }
+}
+var 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"] })'
+};
+var RETIRED_CTX_RE = new RegExp(
+  `\\bctx\\.(${Object.keys(RETIRED_CTX_VERBS).join("|")})\\s*\\(`,
+  "g"
+);
+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,
@@ -5788,14 +5917,11 @@ function checkFieldDeclarations(lx, Comp) {
     }
   }
 }
-function checkRecordFieldNameCollisions(lx, Comp) {
-  const fields = Comp.Class?.getMetaClass?.().fields;
-  if (!fields) return;
-  for (const name in fields) {
-    if (RECORD_FIELD_NAME_COLLISIONS.has(name)) {
-      lx.error(FIELD_NAME_RESERVED_BY_RECORD, { name });
-    }
-  }
+function checkFieldMethodNameCollisions(lx, Comp) {
+  const meta = Comp.Class?.getMetaClass?.();
+  if (!meta) return;
+  for (const name in meta.fields)
+    if (Object.hasOwn(meta.methods, name)) lx.error(FIELD_METHOD_NAME_COLLISION, { name });
 }
 function checkUnreferencedAlterHandlers(lx, Comp, referencedAlters) {
   for (const name in Comp.alter) {
@@ -5804,15 +5930,8 @@ 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 });
-    }
-  }
-}
-var HANDLER_CHANNELS = ["input", "receive", "bubble", "response", "alter"];
-var 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.";
+var HANDLER_CHANNELS = ["receive", "intent", "alter"];
+var 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.`;
 function checkHandlersNotAsync(lx, Comp) {
   for (const channel of HANDLER_CHANNELS) {
     const block = Comp[channel];
@@ -6008,8 +6127,11 @@ var Components = class {
   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 styles = [];
@@ -6022,7 +6144,7 @@ var ComponentStack = class _ComponentStack {
     this.comps = comps;
     this.parent = parent;
     this.byName = {};
-    this.reqsByName = {};
+    this.intentsByName = {};
     this.macros = {};
   }
   enter() {
@@ -6054,11 +6176,21 @@ var ComponentStack = class _ComponentStack {
   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;
@@ -6089,7 +6221,7 @@ var LookupInfo = class {
   }
 };
 var isString = (v) => typeof v === "string";
-var _rawSpecKeys = "name view style commonStyle globalStyle input receive bubble response alter views provide lookup fields methods statics";
+var _rawSpecKeys = "name view style commonStyle globalStyle receive intent alter views provide lookup fields methods statics";
 var KNOWN_SPEC_KEYS = new Set(_rawSpecKeys.split(" "));
 var _compId = 0;
 var Component = class {
@@ -6100,10 +6232,8 @@ var Component = class {
     this.views = { main: new View("main", o.view, o.style) };
     this.commonStyle = o.commonStyle ?? "";
     this.globalStyle = o.globalStyle ?? "";
-    this.input = o.input ?? {};
     this.receive = o.receive ?? {};
-    this.bubble = o.bubble ?? {};
-    this.response = o.response ?? {};
+    this.intent = o.intent ?? {};
     this.alter = o.alter ?? {};
     for (const name in o.views ?? {}) {
       const v = o.views[name];
@@ -6165,7 +6295,7 @@ var Component = class {
 };
 
 // src/on.js
-var OP_KINDS = ["send", "bubble", "request", "input"];
+var OP_KINDS = ["send", "intent"];
 function phaseOps(phase) {
   const ops = [];
   for (const type of OP_KINDS) for (const a of phase[type] ?? []) ops.push({ type, ...a });
@@ -6175,11 +6305,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)) {
@@ -6188,23 +6313,323 @@ 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;
     }
   }
 }
 
+// src/oo.js
+var BAD_VALUE2 = /* @__PURE__ */ Symbol("BadValue");
+var nullCoercer = (v) => v;
+var isPlainObject2 = (v) => {
+  if (v === null || typeof v !== "object") return false;
+  const proto = Object.getPrototypeOf(v);
+  return proto === Object.prototype || proto === null;
+};
+function defaultToData(v) {
+  if (v instanceof Map) return [...v.entries()];
+  if (v instanceof Set) return [...v.values()];
+  return v;
+}
+var Field = class {
+  constructor(type, name, typeCheck, coercer, defaultValue = null) {
+    this.type = type;
+    this.name = name;
+    this.typeCheck = typeCheck;
+    this.coercer = coercer;
+    this.checks = [];
+    this.defaultValue = defaultValue;
+  }
+  toDataDef() {
+    return { type: this.type, defaultValue: defaultToData(this.defaultValue) };
+  }
+  getFirstFailingCheck(v) {
+    if (!this.typeCheck.isValid(v)) return this.typeCheck;
+    for (const check3 of this.checks) if (!check3.isValid(v)) return check3;
+    return null;
+  }
+  isValid(v) {
+    return this.getFirstFailingCheck(v) === null;
+  }
+  addCheck(check3) {
+    this.checks.push(check3);
+    return this;
+  }
+  coerceOr(v, defaultValue = null) {
+    if (this.isValid(v)) return v;
+    const v1 = this.coercer(v);
+    return this.isValid(v1) ? v1 : defaultValue;
+  }
+  coerceOrDefault(v) {
+    return this.coerceOr(v, this.defaultValue);
+  }
+};
+var Check = class {
+  isValid(_v) {
+    return true;
+  }
+  getMessage(_v) {
+    return "Invalid";
+  }
+};
+var CheckTypeAny = class extends Check {
+};
+var CHECK_TYPE_ANY = new CheckTypeAny();
+var FnCheck = class extends Check {
+  constructor(isValidFn, getMessageFn) {
+    super();
+    this._isValid = isValidFn;
+    this._getMessage = getMessageFn;
+  }
+  isValid(v) {
+    return this._isValid(v);
+  }
+  getMessage(v) {
+    return this._getMessage(v);
+  }
+};
+var check = (fn, message) => new FnCheck(fn, () => message);
+var CHECK_TYPE_INT = check(Number.isInteger, "Integer expected");
+var CHECK_TYPE_FLOAT = check(Number.isFinite, "Float expected");
+var CHECK_TYPE_BOOL = check((v) => typeof v === "boolean", "Boolean expected");
+var CHECK_TYPE_STRING = check((v) => typeof v === "string", "String expected");
+var CHECK_TYPE_LIST = check(Array.isArray, "Array expected");
+var CHECK_TYPE_OBJECT = check(isPlainObject2, "Plain object expected");
+var CHECK_TYPE_MAP = check((v) => v instanceof Map, "Map expected");
+var CHECK_TYPE_SET = check((v) => v instanceof Set, "Set expected");
+var FieldBool = class extends Field {
+  constructor(name, defaultValue = false) {
+    super("bool", name, CHECK_TYPE_BOOL, (v) => !!v, defaultValue);
+  }
+};
+var FieldAny = class extends Field {
+  constructor(name, defaultValue = null) {
+    super("any", name, CHECK_TYPE_ANY, nullCoercer, defaultValue);
+  }
+  toDataDef() {
+    return { type: getTypeName(this.defaultValue) ?? "any", defaultValue: this.defaultValue };
+  }
+};
+var FieldString = class extends Field {
+  constructor(name, defaultValue = "") {
+    super("text", name, CHECK_TYPE_STRING, (v) => v?.toString?.() ?? "", defaultValue);
+  }
+};
+var FieldInt = class extends Field {
+  constructor(name, defaultValue = 0) {
+    super(
+      "int",
+      name,
+      CHECK_TYPE_INT,
+      (v) => Number.isFinite(v) ? Math.trunc(v) : null,
+      defaultValue
+    );
+  }
+};
+var FieldFloat = class extends Field {
+  constructor(name, defaultValue = 0) {
+    super("float", name, CHECK_TYPE_FLOAT, (_) => null, defaultValue);
+  }
+};
+var getTypeName = (v) => v?.constructor?.getMetaClass?.()?.name;
+var CheckTypeName = class {
+  constructor(typeName) {
+    this.typeName = typeName;
+  }
+  isValid(v) {
+    return getTypeName(v) === this.typeName;
+  }
+  getMessage(v) {
+    return `Expected "${this.typeName}", got "${getTypeName(v)}"`;
+  }
+};
+var FieldComp = class extends Field {
+  constructor(type, name, args) {
+    super(type, name, new CheckTypeName(type), nullCoercer, null);
+    this.args = args;
+  }
+  toDataDef() {
+    return { component: this.type, args: this.args };
+  }
+};
+var FieldList = class extends Field {
+  constructor(name, defaultValue = []) {
+    super("list", name, CHECK_TYPE_LIST, (v) => Array.isArray(v) ? [...v] : null, defaultValue);
+  }
+};
+var FieldObject = class extends Field {
+  constructor(name, defaultValue = {}) {
+    super(
+      "object",
+      name,
+      CHECK_TYPE_OBJECT,
+      (v) => isPlainObject2(v) ? { ...v } : null,
+      defaultValue
+    );
+  }
+};
+var FieldMap = class extends Field {
+  constructor(name, defaultValue = /* @__PURE__ */ new Map()) {
+    super(
+      "map",
+      name,
+      CHECK_TYPE_MAP,
+      (v) => {
+        if (v instanceof Map) return new Map(v);
+        if (Array.isArray(v) || isPlainObject2(v))
+          return new Map(Array.isArray(v) ? v : Object.entries(v));
+        return null;
+      },
+      defaultValue
+    );
+  }
+};
+var FieldSet = class extends Field {
+  constructor(name, defaultValue = /* @__PURE__ */ new Set()) {
+    super(
+      "set",
+      name,
+      CHECK_TYPE_SET,
+      (v) => v instanceof Set || Array.isArray(v) ? new Set(v) : null,
+      defaultValue
+    );
+  }
+};
+function mkCompField(field, scope, args) {
+  const Comp = scope?.lookupComponent(field.type) ?? null;
+  if (Comp === null)
+    console.warn(
+      scope ? `component field "${field.name}": component "${field.type}" not found in scope` : `component field "${field.name}": cannot resolve component "${field.type}" — built without a registered scope (use ${field.type}.make({}) as the default, or build via a registered component)`
+    );
+  return Comp?.make({ ...field.args, ...args }, { scope }) ?? null;
+}
+var ClassBuilder = class {
+  constructor(name) {
+    this.name = name;
+    this.fields = {};
+    this.compFields = /* @__PURE__ */ new Set();
+    this._methods = {};
+    this._statics = {};
+  }
+  build() {
+    const { name, fields, compFields, _methods } = this;
+    const defaults = Object.fromEntries(
+      Object.entries(fields).map(([fieldName, field]) => [fieldName, field.defaultValue])
+    );
+    const Class = {
+      [name]: class {
+        constructor(values = {}) {
+          Object.assign(this, defaults, values);
+        }
+      }
+    }[name];
+    Class[immer_exports.immerable] = true;
+    Object.assign(Class.prototype, _methods);
+    const metaClass = { fields, name, methods: _methods };
+    Object.assign(
+      Class,
+      {
+        getMetaClass: () => metaClass,
+        make(inArgs = {}, opts = {}) {
+          const args = {};
+          const scope = opts.scope ?? this.scope;
+          for (const key in inArgs) {
+            const field = fields[key];
+            if (compFields.has(key)) args[key] = mkCompField(field, scope, inArgs[key]);
+            else if (field === void 0)
+              console.warn("extra argument to constructor:", name, key, inArgs);
+            else args[key] = field.coerceOrDefault(inArgs[key]);
+          }
+          for (const key of compFields)
+            if (args[key] === void 0) args[key] = mkCompField(fields[key], scope, inArgs[key]);
+          return (0, immer_exports.freeze)(new this(args), true);
+        }
+      },
+      this._statics
+    );
+    return Class;
+  }
+  methods(proto) {
+    for (const k in proto) this._methods[k] = proto[k];
+  }
+  statics(proto) {
+    for (const k in proto) this._statics[k] = proto[k];
+  }
+  addField(name, dval, FieldCls) {
+    const field = new FieldCls(name, dval);
+    this.fields[name] = field;
+    return field;
+  }
+  addCompField(name, type, args) {
+    const field = new FieldComp(type, name, args);
+    this.compFields.add(name);
+    this.fields[name] = field;
+    return field;
+  }
+};
+var FIELD_CLASS = /* @__PURE__ */ Symbol.for("tutuca.fieldClass");
+var fieldsByTypeName = {
+  text: FieldString,
+  int: FieldInt,
+  float: FieldFloat,
+  bool: FieldBool,
+  list: FieldList,
+  object: FieldObject,
+  map: FieldMap,
+  set: FieldSet,
+  any: FieldAny
+};
+function fieldFromDescriptor(name, value) {
+  const FieldCls = fieldsByTypeName[value.type] ?? FieldAny;
+  const probe = new FieldCls(name);
+  return [FieldCls, probe.coerceOr(value.defaultValue, probe.defaultValue)];
+}
+function classFromData(name, { fields = {}, methods, statics }) {
+  const b = new ClassBuilder(name);
+  for (const field in fields) {
+    const value = fields[field];
+    const type = typeof value;
+    if (type === "string") b.addField(field, value, FieldString);
+    else if (type === "number")
+      b.addField(field, value, Number.isInteger(value) ? FieldInt : FieldFloat);
+    else if (type === "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);
+    else if (value instanceof Map) b.addField(field, new Map(value), FieldMap);
+    else if (value?.type && Object.hasOwn(value, "defaultValue")) {
+      const [FieldCls, dval] = fieldFromDescriptor(field, value);
+      b.addField(field, dval, FieldCls);
+    } else if (value?.component && value?.args !== void 0)
+      b.addCompField(field, value.component, value.args);
+    else if (isPlainObject2(value)) b.addField(field, { ...value }, FieldObject);
+    else {
+      const FieldCls = value?.[FIELD_CLASS] ?? FieldAny;
+      b.addField(field, value, FieldCls);
+    }
+  }
+  if (methods) b.methods(methods);
+  if (statics) b.statics(statics);
+  return b.build();
+}
+function validateDraftFields(current, draft) {
+  const meta = current?.constructor?.getMetaClass?.();
+  if (!meta) return;
+  for (const [name, field] of Object.entries(meta.fields)) {
+    const value = draft[name];
+    if (field.isValid(value)) continue;
+    const coerced = field.coerceOr(value, BAD_VALUE2);
+    if (coerced !== BAD_VALUE2) draft[name] = coerced;
+    else {
+      console.warn(`invalid value for ${meta.name}.${name}`, value);
+      draft[name] = current[name];
+    }
+  }
+}
+Component.fromSpec = (opts) => new Component(classFromData(opts.name, opts), opts);
+var component = (opts) => Component.fromSpec(opts);
+
 // src/stack.js
 var STOP = /* @__PURE__ */ Symbol("STOP");
 var NEXT = /* @__PURE__ */ Symbol("NEXT");
@@ -6263,12 +6688,12 @@ var Stack = class _Stack {
     const provide = this.comps.getCompFor(this.it)?.provide;
     if (provide == null) return this;
     const dynObj = {};
-    let has2 = false;
+    let has = false;
     for (const k in provide) {
       dynObj[provide[k].symbol] = provide[k].val.eval(this);
-      has2 = true;
+      has = true;
     }
-    if (!has2) return this;
+    if (!has) return this;
     const newDynBinds = [new ObjectFrame(dynObj), this.dynBinds];
     const { comps, it, binds, views, viewsId, ctx } = this;
     return new _Stack(comps, it, binds, newDynBinds, views, viewsId, ctx);
@@ -6371,8 +6796,11 @@ var Transactor = class {
     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) {
@@ -6425,23 +6853,14 @@ var Transactor = class {
     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
@@ -6452,57 +6871,6 @@ var Transactor = class {
       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;
   }
@@ -6519,6 +6887,7 @@ var Transactor = class {
         this._emitTransaction(transaction, curState);
       } else console.warn("undefined new state", { curState, transaction });
     } finally {
+      transaction.ensureWalkAdvanced?.();
       transaction._completion?.ensureSelfSettled();
       transaction._completion?.releaseSelf();
     }
@@ -6527,12 +6896,6 @@ var Transactor = class {
     this.transact(new InputEvent(path, event, eventHandler, this, dragInfo));
   }
 };
-function mkReq404(name) {
-  const fn = () => {
-    throw new Error(`Request not found: ${name}`);
-  };
-  return { fn };
-}
 function nullHandler() {
   return this;
 }
@@ -6563,6 +6926,15 @@ var Transaction = class {
   }
   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 Stack.root(comps, root);
   }
@@ -6579,10 +6951,10 @@ var Transaction = class {
   get observeName() {
     return null;
   }
-  callHandler(root, instance, comps) {
+  callHandler(root, instance, draft, comps) {
     const [handler, args] = this.getHandlerAndArgs(root, instance, comps);
     this._resolvedHandler = handler;
-    return handler.apply(instance, args);
+    return handler.apply(instance, [draft, ...args]);
   }
   getHandlerAndArgs(_root, _instance, _comps) {
     return null;
@@ -6591,12 +6963,16 @@ var Transaction = class {
   // the data's real location (the dispatch `this.path` keeps intermediates). A subclass
   // may override to supply a pre-resolved path (see ResponseEvent's pinned keys).
   getTransactionPath() {
-    return this.path.toTransactionPath();
+    return this.path.toTransactionPath().compact();
   }
   updateRootValue(curRoot, comps) {
     const txnPath = this.getTransactionPath();
     const curLeaf = txnPath.lookup(curRoot);
-    const newLeaf = this.callHandler(curRoot, curLeaf, comps);
+    const newLeaf = (0, immer_exports.produce)(curLeaf, (draft) => {
+      const result = this.callHandler(curRoot, curLeaf, draft, comps);
+      if (result === void 0 || result === draft) validateDraftFields(curLeaf, draft);
+      return result;
+    });
     this._before = curLeaf;
     this._after = newLeaf;
     this._completion?.markSelfSettled({ value: newLeaf, old: curLeaf });
@@ -6624,18 +7000,40 @@ var InputEvent = class extends Transaction {
     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 Stack.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];
@@ -6720,39 +7118,190 @@ var NameArgsTransaction = class extends Transaction {
     return [handler, [...this.args, new EventContext(this.path, this.transactor, this)]];
   }
 };
-var 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();
-  }
-};
 var 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);
   }
 };
-var 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;
+var 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);
+  }
+  stop() {
+    this.walk.finish(null, null);
+  }
+  afterTransaction() {
+    this.ensureWalkAdvanced();
   }
-  stopPropagation() {
-    this.opts.bubbles = false;
+  // 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();
   }
 };
-var InputDispatchEvent = class extends NameArgsTransaction {
-  handlerProp = "input";
+var PASS = /* @__PURE__ */ Symbol.for("tutuca.intent.pass");
+var DEFAULT_ROUTE = ["dyn", "lex"];
+var INTENT_DEPTH = 64;
+var 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);
+  }
 };
 var Completion = class {
   constructor() {
@@ -6833,23 +7382,21 @@ var Dispatcher = class {
   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);
-  }
-  requestAtPath(path, name, args, opts) {
-    return this.transactor.pushRequest(path, name, args, opts, this.parent);
+  // 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);
   }
-  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);
@@ -6862,12 +7409,30 @@ var EventContext = class extends Dispatcher {
   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);
   }
 };
-var RequestContext = class extends Dispatcher {
+var IntentContext = class extends Dispatcher {
 };
+function warnNotIntent(verb) {
+  console.warn(`ctx.${verb}() is only meaningful in an "intent" handler - ignored`);
+}
 var PathChanges = class extends PathBuilder {
   constructor(dispatcher) {
     super();
@@ -6876,8 +7441,8 @@ var PathChanges = class extends PathBuilder {
   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);
@@ -7149,29 +7714,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;
@@ -7187,7 +7747,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 };
@@ -7201,7 +7761,7 @@ async function runTests({
   }
   const { describe, 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, test: test2, expect: expect3, drive: driveLocal });
   let bailed = false;
@@ -7267,7 +7827,7 @@ async function runTests({
 }
 
 // tools/format/console.js
-var PASS = "color: #0a0; font-weight: bold";
+var PASS2 = "color: #0a0; font-weight: bold";
 var FAIL = "color: #c00; font-weight: bold";
 var SKIP = "color: #888";
 var DIM = "color: #888";
@@ -7282,7 +7842,7 @@ function reportTestNode(node) {
   }
   const dur = node.status === "skip" ? "" : ` (${Math.round(node.durationMs)}ms)`;
   if (node.status === "pass") {
-    console.log(`%c✓%c ${node.title}%c${dur}`, PASS, RESET, DIM);
+    console.log(`%c✓%c ${node.title}%c${dur}`, PASS2, RESET, DIM);
   } else if (node.status === "skip") {
     console.log(`%c○ ${node.title}%c (skipped)`, SKIP, RESET);
   } else {
@@ -7309,7 +7869,7 @@ function reportTestReportToConsole(report) {
     const summary = `${c.pass} passed, ${c.fail} failed, ${c.skip} skipped (${c.total} total)`;
     if (c.fail > 0) console.error(`%c${summary}`, FAIL);
     else if (c.total === 0) console.log(`%c${summary}`, DIM);
-    else console.log(`%c${summary}`, PASS);
+    else console.log(`%c${summary}`, PASS2);
     console.groupEnd();
   }
   return report;
@@ -7399,18 +7959,20 @@ 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":
-      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 "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 "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 "EVENT_HANDLER_METHOD_NOT_ALLOWED":
+      return `Event handler '$${info.name}' is a method reference — move it to receive and use '${info.name}'`;
+    case "FIELD_METHOD_NAME_COLLISION":
+      return `Field '${info.name}' shadows a method with the same name — rename either the field or method`;
     case "FIELD_VAL_NOT_DEFINED":
       return `Field '.${info.name}' is not defined${fmtOriginSuffix(info)}`;
     case "FIELD_VAL_IS_METHOD":
@@ -7821,440 +8383,6 @@ var DragInfo = class {
   }
 };
 
-// index.js
-import {
-  Collection,
-  fromJS,
-  get,
-  getIn,
-  has,
-  hash,
-  hasIn,
-  is as is2,
-  isAssociative,
-  isCollection,
-  isImmutable,
-  isIndexed as isIndexed2,
-  isKeyed as isKeyed2,
-  isList,
-  isMap,
-  isMap as isMap2,
-  isOrdered,
-  isOrderedMap,
-  isOrderedMap as isOrderedMap2,
-  isOrderedSet,
-  isPlainObject,
-  isRecord,
-  isSeq,
-  isSet,
-  isStack,
-  isValueObject,
-  List as List2,
-  Map as Map2,
-  Map as Map3,
-  merge,
-  mergeDeep,
-  mergeDeepWith,
-  mergeWith,
-  OrderedMap as OrderedMap2,
-  OrderedMap as OrderedMap3,
-  OrderedSet,
-  PairSorting,
-  Range,
-  Record as Record2,
-  Repeat,
-  remove,
-  removeIn,
-  Seq,
-  Set as Set2,
-  Set as Set3,
-  Stack as Stack2,
-  set,
-  setIn,
-  update,
-  updateIn,
-  version
-} from "immutable";
-
-// src/oo.js
-import { Map as IMap, Set as ISet, List, OrderedMap, Record } from "immutable";
-var BAD_VALUE2 = /* @__PURE__ */ Symbol("BadValue");
-var nullCoercer = (v) => v;
-var Field = class {
-  constructor(type, name, typeCheck, coercer, defaultValue = null) {
-    this.type = type;
-    this.name = name;
-    this.typeCheck = typeCheck;
-    this.coercer = coercer;
-    this.checks = [];
-    this.defaultValue = defaultValue;
-  }
-  toDataDef() {
-    const { type, defaultValue: dv } = this;
-    return { type, defaultValue: dv?.toJS ? dv.toJS() : dv };
-  }
-  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;
-  }
-  coerceOr(v, defaultValue = null) {
-    if (this.isValid(v)) return v;
-    const v1 = this.coercer(v);
-    return this.isValid(v1) ? v1 : defaultValue;
-  }
-  coerceOrDefault(v) {
-    return this.coerceOr(v, this.defaultValue);
-  }
-  extendProtoForType(_proto, _uname) {
-  }
-  extendProto(proto) {
-    const { name } = this;
-    const uname = name[0].toUpperCase() + name.slice(1);
-    const setName = `set${uname}`;
-    const that = this;
-    proto[setName] = function(v) {
-      const v1 = that.coerceOr(v, BAD_VALUE2);
-      if (v1 === BAD_VALUE2) {
-        console.warn("invalid value", v);
-        return this;
-      }
-      return this.set(name, v1);
-    };
-    proto[`update${uname}`] = function(fn) {
-      return this[setName](fn(this.get(name)));
-    };
-    proto[`reset${uname}`] = function() {
-      return this.set(name, that.defaultValue);
-    };
-    this.extendProtoForType(proto, uname);
-  }
-};
-var Check = class {
-  isValid(_v) {
-    return true;
-  }
-  getMessage(_v) {
-    return "Invalid";
-  }
-};
-var CheckTypeAny = class extends Check {
-};
-var CHECK_TYPE_ANY = new CheckTypeAny();
-var FnCheck = class extends Check {
-  constructor(isValidFn, getMessageFn) {
-    super();
-    this._isValid = isValidFn;
-    this._getMessage = getMessageFn;
-  }
-  isValid(v) {
-    return this._isValid(v);
-  }
-  getMessage(v) {
-    return this._getMessage(v);
-  }
-};
-var CHECK_TYPE_INT = new FnCheck(
-  (v) => Number.isInteger(v),
-  () => "Integer expected"
-);
-var CHECK_TYPE_FLOAT = new FnCheck(
-  (v) => Number.isFinite(v),
-  () => "Float expected"
-);
-var CHECK_TYPE_BOOL = new FnCheck(
-  (v) => typeof v === "boolean",
-  () => "Boolean expected"
-);
-var CHECK_TYPE_STRING = new FnCheck(
-  (v) => typeof v === "string",
-  () => "String expected"
-);
-var CHECK_TYPE_LIST = new FnCheck(
-  (v) => List.isList(v),
-  () => "List expected"
-);
-var CHECK_TYPE_MAP = new FnCheck(
-  (v) => IMap.isMap(v),
-  () => "Map expected"
-);
-var CHECK_TYPE_OMAP = new FnCheck(
-  (v) => OrderedMap.isOrderedMap(v),
-  () => "OrderedMap expected"
-);
-var CHECK_TYPE_SET = new FnCheck(
-  (v) => ISet.isSet(v),
-  () => "Set expected"
-);
-var boolCoercer = (v) => !!v;
-var FieldBool = class extends Field {
-  constructor(name, defaultValue = false) {
-    super("bool", name, CHECK_TYPE_BOOL, boolCoercer, defaultValue);
-  }
-  extendProtoForType(proto, uname) {
-    const { name } = this;
-    proto[`toggle${uname}`] = function() {
-      return this.set(name, !this.get(name, false));
-    };
-    proto[`set${uname}`] = function(v) {
-      return this.set(name, !!v);
-    };
-  }
-};
-var FieldAny = class extends Field {
-  constructor(name, defaultValue = null) {
-    super("any", name, CHECK_TYPE_ANY, nullCoercer, defaultValue);
-  }
-  toDataDef() {
-    const { defaultValue: dv } = this;
-    const type = getTypeName(dv) ?? "any";
-    return { type, defaultValue: dv?.toJS ? dv.toJS() : dv };
-  }
-};
-var stringCoercer = (v) => v?.toString?.() ?? "";
-var FieldString = class extends Field {
-  constructor(name, defaultValue = "") {
-    super("text", name, CHECK_TYPE_STRING, stringCoercer, defaultValue);
-  }
-  extendProtoForType(proto, _uname) {
-    extendProtoSized(proto, this.name, "", "length");
-  }
-};
-var intCoercer = (v) => Number.isFinite(v) ? Math.trunc(v) : null;
-var FieldInt = class extends Field {
-  constructor(name, defaultValue = 0) {
-    super("int", name, CHECK_TYPE_INT, intCoercer, defaultValue);
-  }
-};
-var floatCoercer = (_) => null;
-var FieldFloat = class extends Field {
-  constructor(name, defaultValue = 0) {
-    super("float", name, CHECK_TYPE_FLOAT, floatCoercer, defaultValue);
-  }
-};
-var getTypeName = (v) => v?.constructor?.getMetaClass?.()?.name;
-var CheckTypeName = class {
-  constructor(typeName) {
-    this.typeName = typeName;
-  }
-  isValid(v) {
-    return getTypeName(v) === this.typeName;
-  }
-  getMessage(v) {
-    const got = getTypeName(v);
-    return `Expected "${this.typeName}", got "${got}"`;
-  }
-};
-var FieldComp = class extends Field {
-  constructor(type, name, args) {
-    super(type, name, new CheckTypeName(type), nullCoercer, null);
-    this.args = args;
-  }
-  toDataDef() {
-    return { component: this.typeName, args: this.args };
-  }
-};
-var NONE2 = /* @__PURE__ */ Symbol("NONE");
-function extendProtoForKeyed(proto, name, uname) {
-  extendProtoSized(proto, name, EMPTY_LIST);
-  proto[`setIn${uname}At`] = function(i, v) {
-    return this.set(name, this.get(name).set(i, v));
-  };
-  proto[`getIn${uname}At`] = function(i, dval) {
-    return this.get(name).get(i, dval);
-  };
-  proto[`updateIn${uname}At`] = function(i, fn) {
-    const col = this.get(name);
-    const v = col.get(i, NONE2);
-    if (v !== NONE2) return this.set(name, col.set(i, fn(v)));
-    console.warn("key", i, "not found in", name, col);
-    return this;
-  };
-  extendDeleteInAt(proto, name, `${uname}At`);
-}
-function extendDeleteInAt(proto, name, uname) {
-  proto[`deleteIn${uname}`] = function(v) {
-    return this.set(name, this.get(name).delete(v));
-  };
-  proto[`removeIn${uname}`] = proto[`deleteIn${uname}`];
-}
-var EMPTY_LIST = List();
-var listCoercer = (v) => Array.isArray(v) ? List(v) : null;
-var FieldList = class extends Field {
-  constructor(name, defaultValue = EMPTY_LIST) {
-    super("list", name, CHECK_TYPE_LIST, listCoercer, defaultValue);
-  }
-  extendProtoForType(proto, uname) {
-    const { name } = this;
-    extendProtoForKeyed(proto, name, uname);
-    proto[`pushIn${uname}`] = function(v) {
-      return this.set(name, this.get(name).push(v));
-    };
-    proto[`insertIn${uname}At`] = function(i, v) {
-      return this.set(name, this.get(name).insert(i, v));
-    };
-  }
-};
-var imapCoercer = (v) => IMap(v);
-var FieldMap = class extends Field {
-  constructor(name, defaultValue = IMap()) {
-    super("map", name, CHECK_TYPE_MAP, imapCoercer, defaultValue);
-  }
-  extendProtoForType(proto, uname) {
-    extendProtoForKeyed(proto, this.name, uname);
-  }
-};
-var omapCoercer = (v) => OrderedMap(v);
-var FieldOMap = class extends Field {
-  constructor(name, defaultValue = OrderedMap()) {
-    super("omap", name, CHECK_TYPE_OMAP, omapCoercer, defaultValue);
-  }
-  extendProtoForType(proto, uname) {
-    extendProtoForKeyed(proto, this.name, uname);
-  }
-};
-function extendProtoSized(proto, name, defaultEmpty, propName = "size") {
-  proto[`${name}Len`] = function() {
-    return this.get(name, defaultEmpty)[propName];
-  };
-}
-var EMPTY_SET2 = ISet();
-var isetCoercer = (v) => Array.isArray(v) ? ISet(v) : v instanceof Set ? ISet(v) : null;
-var FieldSet = class extends Field {
-  constructor(name, defaultValue = EMPTY_SET2) {
-    super("set", name, CHECK_TYPE_SET, isetCoercer, defaultValue);
-  }
-  extendProtoForType(proto, uname) {
-    const { name } = this;
-    extendProtoSized(proto, name, EMPTY_SET2);
-    proto[`addIn${uname}`] = function(v) {
-      return this.set(name, this.get(name).add(v));
-    };
-    extendDeleteInAt(proto, name, uname);
-    proto[`hasIn${uname}`] = function(v) {
-      return this.get(name).has(v);
-    };
-    proto[`toggleIn${uname}`] = function(v) {
-      const current = this.get(name);
-      return this.set(name, current.has(v) ? current.delete(v) : current.add(v));
-    };
-  }
-};
-function mkCompField(field, scope, args) {
-  const Comp = scope?.lookupComponent(field.type) ?? null;
-  if (Comp === null)
-    console.warn(
-      scope ? `component field "${field.name}": component "${field.type}" not found in scope` : `component field "${field.name}": cannot resolve component "${field.type}" — built without a registered scope (use ${field.type}.make({}) as the default, or build via a registered component)`
-    );
-  return Comp?.make({ ...field.args, ...args }, { scope }) ?? null;
-}
-var ClassBuilder = class {
-  constructor(name) {
-    const fields = {};
-    const compFields = /* @__PURE__ */ new Set();
-    this.name = name;
-    this.fields = fields;
-    this.compFields = compFields;
-    this._methods = {};
-    this._statics = {
-      make: function(inArgs = {}, opts = {}) {
-        const args = {};
-        const scope = opts.scope ?? this.scope;
-        for (const key in inArgs) {
-          const field = fields[key];
-          if (compFields.has(key)) args[key] = mkCompField(field, scope, inArgs[key]);
-          else if (field === void 0)
-            console.warn("extra argument to constructor:", name, key, inArgs);
-          else args[key] = field.coerceOrDefault(inArgs[key]);
-        }
-        for (const key of compFields)
-          if (args[key] === void 0) args[key] = mkCompField(fields[key], scope, inArgs[key]);
-        return this(args);
-      }
-    };
-  }
-  build() {
-    const fieldVals = {};
-    const proto = {};
-    const { name, _methods, fields } = this;
-    for (const fieldName in fields) {
-      const field = fields[fieldName];
-      fieldVals[fieldName] = field.defaultValue;
-      field.extendProto(proto);
-    }
-    const Class = { [name]: Record(fieldVals, name) }[name];
-    Object.assign(Class.prototype, proto, _methods);
-    const metaClass = { fields, name, methods: _methods };
-    Object.assign(Class, this._statics, { getMetaClass: () => metaClass });
-    return Class;
-  }
-  methods(proto) {
-    for (const k in proto) this._methods[k] = proto[k];
-  }
-  statics(proto) {
-    for (const k in proto) this._statics[k] = proto[k];
-  }
-  addField(name, dval, FieldCls) {
-    const field = new FieldCls(name, dval);
-    this.fields[name] = field;
-    return field;
-  }
-  addCompField(name, type, args) {
-    const field = new FieldComp(type, name, args);
-    this.compFields.add(name);
-    this.fields[name] = field;
-    return field;
-  }
-};
-var FIELD_CLASS = /* @__PURE__ */ Symbol.for("tutuca.fieldClass");
-var fieldsByTypeName = {
-  text: FieldString,
-  int: FieldInt,
-  float: FieldFloat,
-  bool: FieldBool,
-  list: FieldList,
-  map: FieldMap,
-  omap: FieldOMap,
-  set: FieldSet,
-  any: FieldAny
-};
-function classFromData(name, { fields = {}, methods, statics }) {
-  const b = new ClassBuilder(name);
-  for (const field in fields) {
-    const value = fields[field];
-    const type = typeof value;
-    if (type === "string") b.addField(field, value, FieldString);
-    else if (type === "number") b.addField(field, value, FieldFloat);
-    else if (type === "boolean") b.addField(field, value, FieldBool);
-    else if (List.isList(value) || Array.isArray(value)) b.addField(field, List(value), FieldList);
-    else if (ISet.isSet(value) || value instanceof Set) b.addField(field, ISet(value), FieldSet);
-    else if (OrderedMap.isOrderedMap(value)) b.addField(field, value, FieldOMap);
-    else if (value?.type && value?.defaultValue !== void 0) {
-      const Field2 = fieldsByTypeName[value.type] ?? FieldAny;
-      b.addField(field, new Field2().coerceOr(value.defaultValue), Field2);
-    } else if (value?.component && value?.args !== void 0)
-      b.addCompField(field, value.component, value.args);
-    else if (IMap.isMap(value) || value?.constructor === Object)
-      b.addField(field, IMap(value), FieldMap);
-    else {
-      const Field2 = value?.[FIELD_CLASS] ?? FieldAny;
-      b.addField(field, value, Field2);
-    }
-  }
-  if (methods) b.methods(methods);
-  if (statics) b.statics(statics);
-  return b.build();
-}
-Component.fromSpec = (opts) => new Component(classFromData(opts.name, opts), opts);
-var component = (opts) => Component.fromSpec(opts);
-
 // index.js
 var css = String.raw;
 var html = String.raw;
@@ -8307,7 +8435,6 @@ function resolveAlter(Comp, name) {
   }
   return fn;
 }
-var seqGet = (seq, key) => Array.isArray(seq) ? seq[key] : seq.get ? seq.get(key) : seq[key];
 function collectIterBindings(Comp, compInstance, seq, opts = {}) {
   const whenFn = resolveAlter(Comp, opts.when) ?? filterAlwaysTrue;
   const loopWithFn = resolveAlter(Comp, opts.loopWith) ?? nullLoopWith;
@@ -8352,157 +8479,10 @@ function getSignature(name, fn) {
   const params = m ? m[1].trim() : "";
   return `${name}(${params})`;
 }
-function getFieldMethods(field) {
-  const { name, type } = field;
-  const uname = name[0].toUpperCase() + name.slice(1);
-  const methods = [
-    { name: `set${uname}`, sig: `set${uname}(v)`, desc: "Set value" },
-    {
-      name: `update${uname}`,
-      sig: `update${uname}(fn)`,
-      desc: "Update value with function"
-    },
-    {
-      name: `reset${uname}`,
-      sig: `reset${uname}()`,
-      desc: "Reset to default value"
-    }
-  ];
-  switch (type) {
-    case "bool":
-      methods[0].desc = "Set value (coerces to boolean)";
-      methods.push({
-        name: `toggle${uname}`,
-        sig: `toggle${uname}()`,
-        desc: "Toggle boolean value"
-      });
-      break;
-    case "int":
-    case "float":
-    case "any":
-      break;
-    case "text":
-      methods.push({
-        name: `${name}Len`,
-        sig: `${name}Len()`,
-        desc: "Get string length"
-      });
-      break;
-    case "list":
-      methods.push(
-        { name: `${name}Len`, sig: `${name}Len()`, desc: "Get list size" },
-        {
-          name: `setIn${uname}At`,
-          sig: `setIn${uname}At(i, v)`,
-          desc: "Set item at index"
-        },
-        {
-          name: `getIn${uname}At`,
-          sig: `getIn${uname}At(i, defaultValue)`,
-          desc: "Get item at index"
-        },
-        {
-          name: `updateIn${uname}At`,
-          sig: `updateIn${uname}At(i, fn)`,
-          desc: "Update item at index with function"
-        },
-        {
-          name: `deleteIn${uname}At`,
-          sig: `deleteIn${uname}At(i)`,
-          desc: "Delete item at index"
-        },
-        {
-          name: `removeIn${uname}At`,
-          sig: `removeIn${uname}At(i)`,
-          desc: "Delete item at index (alias)"
-        },
-        {
-          name: `pushIn${uname}`,
-          sig: `pushIn${uname}(v)`,
-          desc: "Push item to end"
-        },
-        {
-          name: `insertIn${uname}At`,
-          sig: `insertIn${uname}At(i, v)`,
-          desc: "Insert item at index"
-        }
-      );
-      break;
-    case "map":
-    case "omap": {
-      const label = type === "omap" ? "ordered map" : "map";
-      methods.push(
-        {
-          name: `${name}Len`,
-          sig: `${name}Len()`,
-          desc: `Get ${label} size`
-        },
-        {
-          name: `setIn${uname}At`,
-          sig: `setIn${uname}At(key, v)`,
-          desc: "Set value at key"
-        },
-        {
-          name: `getIn${uname}At`,
-          sig: `getIn${uname}At(key, defaultValue)`,
-          desc: "Get value at key"
-        },
-        {
-          name: `updateIn${uname}At`,
-          sig: `updateIn${uname}At(key, fn)`,
-          desc: "Update value at key with function"
-        },
-        {
-          name: `deleteIn${uname}At`,
-          sig: `deleteIn${uname}At(key)`,
-          desc: "Delete entry at key"
-        },
-        {
-          name: `removeIn${uname}At`,
-          sig: `removeIn${uname}At(key)`,
-          desc: "Delete entry at key (alias)"
-        }
-      );
-      break;
-    }
-    case "set":
-      methods.push(
-        { name: `${name}Len`, sig: `${name}Len()`, desc: "Get set size" },
-        {
-          name: `addIn${uname}`,
-          sig: `addIn${uname}(v)`,
-          desc: "Add value to set"
-        },
-        {
-          name: `deleteIn${uname}`,
-          sig: `deleteIn${uname}(v)`,
-          desc: "Remove value from set"
-        },
-        {
-          name: `removeIn${uname}`,
-          sig: `removeIn${uname}(v)`,
-          desc: "Remove value from set (alias)"
-        },
-        {
-          name: `hasIn${uname}`,
-          sig: `hasIn${uname}(v)`,
-          desc: "Check if value is in set"
-        },
-        {
-          name: `toggleIn${uname}`,
-          sig: `toggleIn${uname}(v)`,
-          desc: "Toggle value in set"
-        }
-      );
-      break;
-    default:
-      break;
-  }
-  return methods;
-}
 function serializeDefault(v) {
   if (v === null || v === void 0) return v;
-  if (v?.toJS) return v.toJS();
+  if (v instanceof Map) return Object.fromEntries(v);
+  if (v instanceof Set) return [...v];
   return v;
 }
 function getComponentDoc(comp) {
@@ -8512,10 +8492,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];
@@ -8523,10 +8502,16 @@ function getComponentDoc(comp) {
       name: fieldName,
       type: field.type,
       default: serializeDefault(field.defaultValue),
-      methods: getFieldMethods(field)
+      methods: []
     });
   }
-  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;
@@ -8553,7 +8538,7 @@ function shadowCheckComponent(Comp) {
   shadowComp.views = shadowViews;
   return checkComponent(shadowComp).reports;
 }
-function check(app) {
+function check2(app) {
   const counts = { error: 0, warn: 0, hint: 0 };
   for (const Comp of app.comps.byId.values()) {
     const reports = shadowCheckComponent(Comp);
@@ -8618,7 +8603,6 @@ export {
   BINDING_MEMBER_TOO_DEEP,
   COMP_FIELD_BAD_SHAPE,
   CONSTANT_CONDITION,
-  Collection,
   ComponentDocs,
   ComponentList,
   ComponentSummary,
@@ -8628,20 +8612,15 @@ export {
   DYN_VAL_NOT_DEFINED,
   Describe,
   DescribeResult,
+  EVENT_HANDLER_METHOD_NOT_ALLOWED,
   ExampleIndex,
   FIELD_CLASS,
-  FIELD_NAME_RESERVED_BY_RECORD,
+  FIELD_METHOD_NAME_COLLISION,
   FIELD_VAL_IS_METHOD,
   FIELD_VAL_NOT_DEFINED,
   GLOBAL_SELECTOR_IN_SCOPED_STYLE,
+  HANDLER_NAME_COLLISION,
   IF_NO_BRANCH_SET,
-  Map3 as IMap,
-  INPUT_HANDLER_FOR_INPUT_HANDLER_METHOD,
-  INPUT_HANDLER_METHOD_FOR_INPUT_HANDLER,
-  INPUT_HANDLER_METHOD_NOT_IMPLEMENTED,
-  INPUT_HANDLER_NOT_IMPLEMENTED,
-  INPUT_HANDLER_NOT_REFERENCED,
-  Set3 as ISet,
   LOOKUP_BAD_SHAPE,
   LOOKUP_TARGET_MALFORMED,
   LintClassCollectorCtx,
@@ -8650,35 +8629,27 @@ export {
   LintFinding,
   LintParseContext,
   LintReport,
-  List2 as List,
   MAYBE_ADD_AT_PREFIX,
   MAYBE_DROP_AT_PREFIX,
   METHOD_VAL_IS_FIELD,
   METHOD_VAL_NOT_DEFINED,
-  Map2 as Map,
   ModuleInfo,
   ModuleTestReport,
   ModuleTests,
-  OrderedMap3 as OMap,
-  OrderedMap2 as OrderedMap,
-  OrderedSet,
+  PASS,
   PLACEHOLDERLESS_TEMPLATE_STRING,
   PROVIDE_NOT_ADDRESSABLE,
-  PairSorting,
   ParseContext,
+  RECEIVE_HANDLER_NOT_IMPLEMENTED,
   REDUNDANT_TEMPLATE_STRING,
   RENDER_IT_OUTSIDE_OF_LOOP,
-  Range,
-  Record2 as Record,
+  RETIRED_CTX_VERB,
+  RETIRED_HANDLER_BUCKET,
   RenderBatch,
   RenderedExample,
   RenderedSection,
-  Repeat,
   SEQ_INFO,
   SUGGEST_BINDING_MEMBER,
-  Seq,
-  Set2 as Set,
-  Stack2 as Stack,
   TOP_LEVEL_AT_RULE_IN_SCOPED_STYLE,
   Test,
   TestReport,
@@ -8693,7 +8664,7 @@ export {
   UNKNOWN_X_OP,
   UNSUPPORTED_EXPR_SYNTAX,
   X_OP_IGNORES_CHILDREN,
-  check,
+  check2 as check,
   checkComponent,
   collectIterBindings,
   compileClassesToStyle,
@@ -8704,55 +8675,18 @@ export {
   docComponents,
   drive,
   export_expect as expect,
-  fromJS,
-  get,
-  getIn,
-  has,
-  hasIn,
-  hash,
   html,
   injectCss,
-  is2 as is,
-  isAssociative,
-  isCollection,
-  isMap2 as isIMap,
-  isImmutable,
-  isIndexed2 as isIndexed,
-  isKeyed2 as isKeyed,
-  isList,
-  isMap,
-  isOrderedMap2 as isOMap,
-  isOrdered,
-  isOrderedMap,
-  isOrderedSet,
-  isPlainObject,
-  isRecord,
-  isSeq,
-  isSet,
-  isStack,
-  isValueObject,
   lintIdToMessage,
   macro,
   makeCollector,
-  merge,
-  mergeDeep,
-  mergeDeepWith,
-  mergeWith,
-  phaseHasBubble,
   phaseOps,
-  remove,
-  removeIn,
   reportTestReportToConsole,
   resolveArgs,
   rootDispatcher,
   runTests,
-  set,
-  setIn,
   shadowCheckComponent,
   suggestionToMessage,
   test,
-  tutuca,
-  update,
-  updateIn,
-  version
+  tutuca
 };