tutuca 0.9.115 → 0.10.0

package/dist/tutuca-extra.js

@@ -4944,8 +4944,8 @@ 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);
 }
 function parseAlterHandler(s, px) {
   const r = _parseHandler(s, px, "alter", false, false);
@@ -5488,11 +5488,11 @@ 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;
@@ -6860,8 +6860,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 = [];
@@ -6874,7 +6877,7 @@ var ComponentStack = class _ComponentStack {
     this.comps = comps;
     this.parent = parent;
     this.byName = {};
-    this.reqsByName = {};
+    this.intentsByName = {};
     this.macros = {};
   }
   enter() {
@@ -6906,11 +6909,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;
@@ -6941,7 +6954,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 {
@@ -6952,10 +6965,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];
@@ -7182,8 +7193,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) {
@@ -7236,23 +7250,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
@@ -7263,57 +7268,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;
   }
@@ -7330,6 +7284,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();
     }
@@ -7338,12 +7293,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;
 }
@@ -7374,6 +7323,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 Stack2.root(comps, root);
   }
@@ -7435,18 +7393,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 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];
@@ -7531,39 +7511,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;
   }
-  stopPropagation() {
-    this.opts.bubbles = false;
+  // `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();
+  }
+  // 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() {
@@ -7644,23 +7775,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);
+  // 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);
@@ -7673,12 +7802,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();
@@ -7687,8 +7834,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);
@@ -8026,7 +8173,7 @@ function collectAppClassesInSet(app) {
 }
 
 // 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 });
@@ -8036,11 +8183,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)) {
@@ -8049,18 +8191,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;
     }
   }
@@ -8490,6 +8622,7 @@ export {
   OrderedMap as OMap,
   OrderedMap,
   OrderedSet,
+  PASS,
   PairSorting,
   ParseContext,
   Range,
@@ -8538,7 +8671,6 @@ export {
   mergeDeep$1 as mergeDeep,
   mergeDeepWith$1 as mergeDeepWith,
   mergeWith$1 as mergeWith,
-  phaseHasBubble,
   phaseOps,
   remove,
   removeIn,