@lousy-agents/mcp 5.22.16 → 5.22.17

package/dist/mcp-server.js

@@ -90330,8 +90330,12 @@ function encodeCharacterReference(code) {
 
 ;// CONCATENATED MODULE: ../../node_modules/unist-util-visit-parents/lib/color.node.js
 /**
+ * Color a string.
+ *
  * @param {string} d
+ *   Value.
  * @returns {string}
+ *   Colored value.
  */
 function color_node_color(d) {
   return '\u001B[33m' + d + '\u001B[39m'
@@ -90507,44 +90511,96 @@ function color_node_color(d) {
  *   List with one or two values, the first an action, the second an index.
  *
  * @typedef {Action | ActionTuple | Index | null | undefined | void} VisitorResult
- *   Any value that can be returned from a visitor.
+ *   Any value that can be returned from an enter visitor.
+ *
+ *   Like `VisitorResultExit`,
+ *   but `SKIP` can also be returned,
+ *   to not walk the children of the node,
+ *   and `ActionTuple` can be used to combine an action with an index.
+ *
+ * @typedef {Index | boolean | null | undefined | void} VisitorResultExit
+ *   Any value that can be returned from an exit visitor.
  */
 
 /**
  * @callback Visitor
- *   Handle a node (matching `test`, if given).
- *
- *   Visitors are free to transform `node`.
- *   They can also transform the parent of node (the last of `ancestors`).
- *
- *   Replacing `node` itself, if `SKIP` is not returned, still causes its
- *   descendants to be walked (which is a bug).
- *
- *   When adding or removing previous siblings of `node` (or next siblings, in
- *   case of reverse), the `Visitor` should return a new `Index` to specify the
- *   sibling to traverse after `node` is traversed.
- *   Adding or removing next siblings of `node` (or previous siblings, in case
- *   of reverse) is handled as expected without needing to return a new `Index`.
- *
- *   Removing the children property of an ancestor still results in them being
- *   traversed.
+ *   Handle a node (matching `test`, if given) before its children.
+ *
+ *   Changes inside `node` are walked next.
+ *   Replacing or removing it is easier in `exit`.
+ *   When replacing or removing it here,
+ *   return `SKIP` (as otherwise its old children are walked),
+ *   or `[SKIP, index]` to continue with the node now at `index`.
+ *   Changing next siblings (in walk order) is fine;
+ *   changing previous siblings needs a new `Index`.
+ *   Removing an ancestor or changing its previous siblings is not supported.
  * @param {Visited} node
  *   Found node.
  * @param {Array<VisitedParents>} ancestors
  *   Ancestors of `node`.
+ * @param {number | undefined} index
+ *   Index of `node` in its parent (the last of `ancestors`),
+ *   or `undefined` for the tree itself.
  * @returns {VisitorResult}
  *   What to do next.
  *
- *   An `Index` is treated as a tuple of `[CONTINUE, Index]`.
- *   An `Action` is treated as a tuple of `[Action]`.
+ *   Like `VisitorExit`,
+ *   but `SKIP` can also be returned,
+ *   to not walk the children of `node`.
+ *   Passing a tuple back (`ActionTuple`) only makes sense as `[SKIP, Index]`.
+ * @template {UnistNode} [Visited=UnistNode]
+ *   Visited node type.
+ * @template {UnistParent} [VisitedParents=UnistParent]
+ *   Ancestor type.
+ */
+
+/**
+ * @callback VisitorExit
+ *   Handle a node (matching `test`, if given) after its children.
+ *
+ *   Changes inside `node` are not walked,
+ *   which makes this a good place to change `node` based on its children,
+ *   or to replace or remove it.
+ *   When removing `node` or changing previous siblings (in walk order),
+ *   return a new `Index`.
+ *   Removing an ancestor or changing its previous siblings is not supported.
+ * @param {Visited} node
+ *   Found node.
+ * @param {Array<VisitedParents>} ancestors
+ *   Ancestors of `node`.
+ * @param {number | undefined} index
+ *   Index of `node` in its parent (the last of `ancestors`),
+ *   or `undefined` for the tree itself.
+ * @returns {VisitorResultExit}
+ *   What to do next.
  *
- *   Passing a tuple back only makes sense if the `Action` is `SKIP`.
- *   When the `Action` is `EXIT`, that action can be returned.
- *   When the `Action` is `CONTINUE`, `Index` can be returned.
+ *   `CONTINUE` (`true`, nothing) continues as normal,
+ *   `EXIT` (`false`) stops traversing,
+ *   and `Index` continues at that sibling.
+ * @template {UnistNode} [Visited=UnistNode]
+ *   Visited node type.
+ * @template {UnistParent} [VisitedParents=UnistParent]
+ *   Ancestor type.
+ */
+
+/**
  * @template {UnistNode} [Visited=UnistNode]
  *   Visited node type.
  * @template {UnistParent} [VisitedParents=UnistParent]
  *   Ancestor type.
+ * @typedef Visitors
+ *   Handle nodes when entering and exiting them.
+ *   The `enter` visitor is optional while `exit` is required.
+ *
+ *   Pass an `enter` visitor directly to only handle nodes when entering them.
+ *
+ *   `enter` is called before children (if any) are walked and `exit` after that.
+ *   `exit` is still called when `enter` returns `SKIP`.
+ *   Both `enter` and `exit` are only called for nodes that match an optional `test`.
+ * @property {Visitor<Visited, VisitedParents> | null | undefined} [enter]
+ *   Handle a node before its children (optional).
+ * @property {VisitorExit<Visited, VisitedParents>} exit
+ *   Handle a node after its children.
  */
 
 /**
@@ -90558,6 +90614,17 @@ function color_node_color(d) {
  *   Test type.
  */
 
+/**
+ * @typedef {Visitors<Matches<InclusiveDescendant<Tree>, Check>, Ancestor<Tree, Matches<InclusiveDescendant<Tree>, Check>>>} BuildVisitors
+ *   Build typed `Visitors` from a tree and a test.
+ *
+ *   It will infer which values are passed as `node` and which as `parents`.
+ * @template {UnistNode} [Tree=UnistNode]
+ *   Tree type.
+ * @template {Test} [Check=Test]
+ *   Test type.
+ */
+
 
 
 
@@ -90576,6 +90643,7 @@ const EXIT = false
 
 /**
  * Do not traverse this node’s children.
+ * Only works when entering a node.
  */
 const SKIP = 'skip'
 
@@ -90583,10 +90651,13 @@ const SKIP = 'skip'
  * Visit nodes, with ancestral information.
  *
  * This algorithm performs *depth-first* *tree traversal* in *preorder*
- * (**NLR**) or if `reverse` is given, in *reverse preorder* (**NRL**).
+ * (**NLR**) or if `reverse` is given,
+ * in *reverse preorder* (**NRL**).
+ * An `exit` visitor is called in *postorder* (**LRN**)
+ * or if `reverse` is given, in *reverse postorder* (**RLN**).
  *
- * You can choose for which nodes `visitor` is called by passing a `test`.
- * For complex tests, you should test yourself in `visitor`, as it will be
+ * You can choose which nodes are visited by passing a `test`.
+ * For complex tests, you should test yourself in a visitor, as it will be
  * faster and will have improved type information.
  *
  * Walking the tree is an intensive task.
@@ -90595,29 +90666,72 @@ const SKIP = 'skip'
  * to check if a node matches, and then perform different operations.
  *
  * You can change the tree.
- * See `Visitor` for more info.
+ * Changes inside a node made when entering it are walked,
+ * changes made when exiting it are not.
+ * See `Visitor` and `VisitorExit` for more info.
+ *
+ * @overload
+ * @param {Tree} tree
+ *   Tree to traverse.
+ * @param {Check} check
+ *   `unist-util-is`-compatible test.
+ * @param {BuildVisitor<Tree, Check>} enter
+ *   Handle each node when entering it.
+ * @param {boolean | null | undefined} [reverse]
+ *   Walk children from last to first;
+ *   for `enter`, reverse preorder (NRL) instead of preorder (NLR);
+ *   for `exit`, reverse postorder (RLN) instead of postorder (LRN).
+ * @returns {undefined}
+ *   Nothing.
  *
  * @overload
  * @param {Tree} tree
+ *   Tree to traverse.
  * @param {Check} check
- * @param {BuildVisitor<Tree, Check>} visitor
+ *   `unist-util-is`-compatible test.
+ * @param {BuildVisitors<Tree, Check>} visitors
+ *   Handle each node when exiting it, and optionally when entering it.
+ * @param {boolean | null | undefined} [reverse]
+ *   Walk children from last to first;
+ *   for `enter`, reverse preorder (NRL) instead of preorder (NLR);
+ *   for `exit`, reverse postorder (RLN) instead of postorder (LRN).
+ * @returns {undefined}
+ *   Nothing.
+ *
+ * @overload
+ * @param {Tree} tree
+ *   Tree to traverse.
+ * @param {BuildVisitor<Tree>} enter
+ *   Handle each node when entering it.
  * @param {boolean | null | undefined} [reverse]
+ *   Walk children from last to first;
+ *   for `enter`, reverse preorder (NRL) instead of preorder (NLR);
+ *   for `exit`, reverse postorder (RLN) instead of postorder (LRN).
  * @returns {undefined}
+ *   Nothing.
  *
  * @overload
  * @param {Tree} tree
- * @param {BuildVisitor<Tree>} visitor
+ *   Tree to traverse.
+ * @param {BuildVisitors<Tree>} visitors
+ *   Handle each node when exiting it, and optionally when entering it.
  * @param {boolean | null | undefined} [reverse]
+ *   Walk children from last to first;
+ *   for `enter`, reverse preorder (NRL) instead of preorder (NLR);
+ *   for `exit`, reverse postorder (RLN) instead of postorder (LRN).
  * @returns {undefined}
+ *   Nothing.
  *
  * @param {UnistNode} tree
  *   Tree to traverse.
- * @param {Visitor | Test} test
- *   `unist-util-is`-compatible test
- * @param {Visitor | boolean | null | undefined} [visitor]
- *   Handle each node.
+ * @param {Visitor | Visitors | Test} testOrEnterOrVisitors
+ *   `unist-util-is`-compatible test, `enter`, or `visitors`.
+ * @param {Visitor | Visitors | boolean | null | undefined} [enterOrVisitorsOrReverse]
+ *   `enter`, `visitors`, or `reverse` after a test.
  * @param {boolean | null | undefined} [reverse]
- *   Traverse in reverse preorder (NRL) instead of the default preorder (NLR).
+ *   Walk children from last to first;
+ *   for `enter`, reverse preorder (NRL) instead of preorder (NLR);
+ *   for `exit`, reverse postorder (RLN) instead of postorder (LRN).
  * @returns {undefined}
  *   Nothing.
  *
@@ -90626,28 +90740,89 @@ const SKIP = 'skip'
  * @template {Test} Check
  *   `unist-util-is`-compatible test.
  */
-function visitParents(tree, test, visitor, reverse) {
+function visitParents(
+  tree,
+  testOrEnterOrVisitors,
+  enterOrVisitorsOrReverse,
+  reverse
+) {
+  if (!tree || typeof tree !== 'object') {
+    throw new Error('Unexpected value `' + tree + '` for `tree`, expected node')
+  }
+
+  let preorder = true
   /** @type {Test} */
   let check
+  /** @type {Visitors | Visitor} */
+  let visitors
+  /** @type {Visitor | null | undefined} */
+  let enter
+  /** @type {VisitorExit | null | undefined} */
+  let exit
+
+  // Third parameter is an enter visitor or a visitors object, so expect a `test` too.
+  if (
+    typeof enterOrVisitorsOrReverse === 'function' ||
+    (enterOrVisitorsOrReverse && typeof enterOrVisitorsOrReverse === 'object')
+  ) {
+    check = /** @type {Test} */ (testOrEnterOrVisitors)
+    visitors = enterOrVisitorsOrReverse
+    if (reverse) preorder = false
+  }
+  // Assume no test.
+  else {
+    visitors = /** @type {Visitors | Visitor} */ (testOrEnterOrVisitors)
+    if (enterOrVisitorsOrReverse) preorder = false
+  }
+
+  if (typeof visitors === 'function') {
+    enter = visitors
+  } else if (visitors && typeof visitors === 'object') {
+    if (visitors.enter === null || visitors.enter === undefined) {
+      // Empty.
+    } else if (typeof visitors.enter === 'function') {
+      enter = visitors.enter
+    } else {
+      throw new Error(
+        'Unexpected value `' +
+          visitors.enter +
+          '` for `visitors.enter`, expected optional visitor'
+      )
+    }
 
-  if (typeof test === 'function' && typeof visitor !== 'function') {
-    reverse = visitor
-    // @ts-expect-error no visitor given, so `visitor` is test.
-    visitor = test
+    if (typeof visitors.exit === 'function') {
+      exit = visitors.exit
+    } else {
+      throw new Error(
+        'Unexpected value `' +
+          visitors.exit +
+          '` for `visitors.exit`, expected visitor (pass a visitor directly if you only want an enter visitor)'
+      )
+    }
   } else {
-    // @ts-expect-error visitor given, so `test` isn’t a visitor.
-    check = test
+    throw new Error(
+      'Unexpected value `' +
+        visitors +
+        '` for `enter` or `visitors`, expected visitor or object with visitors'
+    )
   }
 
   const is = convert(check)
-  const step = reverse ? -1 : 1
+  const step = preorder ? 1 : -1
 
   factory(tree, undefined, [])()
 
   /**
+   * Create a function to visit a node.
+   *
    * @param {UnistNode} node
+   *   Node to visit.
    * @param {number | undefined} index
+   *   Index of `node` in its parent.
    * @param {Array<UnistParent>} parents
+   *   Ancestors of `node`.
+   * @returns {() => Readonly<ActionTuple>}
+   *   Visit `node`.
    */
   function factory(node, index, parents) {
     const value = /** @type {Record<string, unknown>} */ (
@@ -90673,18 +90848,13 @@ function visitParents(tree, test, visitor, reverse) {
     return visit
 
     function visit() {
+      const matches =
+        !check || is(node, index, parents[parents.length - 1] || undefined)
       /** @type {Readonly<ActionTuple>} */
       let result = lib_empty
-      /** @type {Readonly<ActionTuple>} */
-      let subresult
-      /** @type {number} */
-      let offset
-      /** @type {Array<UnistParent>} */
-      let grandparents
 
-      if (!test || is(node, index, parents[parents.length - 1] || undefined)) {
-        // @ts-expect-error: `visitor` is now a visitor.
-        result = toResult(visitor(node, parents))
+      if (enter && matches) {
+        result = toResult(enter(node, parents, index))
 
         if (result[0] === EXIT) {
           return result
@@ -90695,13 +90865,13 @@ function visitParents(tree, test, visitor, reverse) {
         const nodeAsParent = /** @type {UnistParent} */ (node)
 
         if (nodeAsParent.children && result[0] !== SKIP) {
-          offset = (reverse ? nodeAsParent.children.length : -1) + step
-          grandparents = parents.concat(nodeAsParent)
+          let offset = (preorder ? -1 : nodeAsParent.children.length) + step
+          const grandparents = [...parents, nodeAsParent]
 
           while (offset > -1 && offset < nodeAsParent.children.length) {
             const child = nodeAsParent.children[offset]
 
-            subresult = factory(child, offset, grandparents)()
+            const subresult = factory(child, offset, grandparents)()
 
             if (subresult[0] === EXIT) {
               return subresult
@@ -90713,6 +90883,23 @@ function visitParents(tree, test, visitor, reverse) {
         }
       }
 
+      if (exit && matches) {
+        const exitResult = toResult(exit(node, parents, index))
+
+        if (exitResult[0] === SKIP) {
+          throw new Error(
+            'Unexpected value `' +
+              exitResult[0] +
+              '` from `exit`, expected `CONTINUE`, `EXIT`, index, or nothing'
+          )
+        }
+
+        // Prefer a result from `exit` over `enter`.
+        if (exitResult[0] === EXIT || typeof exitResult[1] === 'number') {
+          return exitResult
+        }
+      }
+
       return result
     }
   }
@@ -90741,7 +90928,13 @@ function toResult(value) {
 ;// CONCATENATED MODULE: ../../node_modules/unist-util-visit/lib/index.js
 /**
  * @import {Node as UnistNode, Parent as UnistParent} from 'unist'
- * @import {VisitorResult} from 'unist-util-visit-parents'
+ * @import {
+ *   InclusiveDescendant,
+ *   Matches,
+ *   Visitors as ParentsVisitors,
+ *   VisitorResult,
+ *   VisitorResultExit
+ * } from 'unist-util-visit-parents'
  */
 
 /**
@@ -90753,67 +90946,6 @@ function toResult(value) {
  *   which doesn’t work when publishing on npm.
  */
 
-// To do: use types from `unist-util-visit-parents` when it’s released.
-
-/**
- * @typedef {(
- *   Fn extends (value: any) => value is infer Thing
- *   ? Thing
- *   : Fallback
- * )} Predicate
- *   Get the value of a type guard `Fn`.
- * @template Fn
- *   Value; typically function that is a type guard (such as `(x): x is Y`).
- * @template Fallback
- *   Value to yield if `Fn` is not a type guard.
- */
-
-/**
- * @typedef {(
- *   Check extends null | undefined // No test.
- *   ? Value
- *   : Value extends {type: Check} // String (type) test.
- *   ? Value
- *   : Value extends Check // Partial test.
- *   ? Value
- *   : Check extends Function // Function test.
- *   ? Predicate<Check, Value> extends Value
- *     ? Predicate<Check, Value>
- *     : never
- *   : never // Some other test?
- * )} MatchesOne
- *   Check whether a node matches a primitive check in the type system.
- * @template Value
- *   Value; typically unist `Node`.
- * @template Check
- *   Value; typically `unist-util-is`-compatible test, but not arrays.
- */
-
-/**
- * @typedef {(
- *   Check extends ReadonlyArray<any>
- *   ? MatchesOne<Value, Check[number]>
- *   : MatchesOne<Value, Check>
- * )} Matches
- *   Check whether a node matches a check in the type system.
- * @template Value
- *   Value; typically unist `Node`.
- * @template Check
- *   Value; typically `unist-util-is`-compatible test.
- */
-
-/**
- * @typedef {0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10} Uint
- *   Number; capped reasonably.
- */
-
-/**
- * @typedef {I extends 0 ? 1 : I extends 1 ? 2 : I extends 2 ? 3 : I extends 3 ? 4 : I extends 4 ? 5 : I extends 5 ? 6 : I extends 6 ? 7 : I extends 7 ? 8 : I extends 8 ? 9 : 10} Increment
- *   Increment a number in the type system.
- * @template {Uint} [I=0]
- *   Index.
- */
-
 /**
  * @typedef {(
  *   Node extends UnistParent
@@ -90839,89 +90971,64 @@ function toResult(value) {
  */
 
 /**
- * @typedef {(
- *   Depth extends Max
- *   ? never
- *   :
- *     | InternalParent<Node, Child>
- *     | InternalAncestor<Node, InternalParent<Node, Child>, Max, Increment<Depth>>
- * )} InternalAncestor
- *   Collect nodes in `Tree` that can be ancestors of `Child`.
- * @template {UnistNode} Node
- *   All node types in a tree.
- * @template {UnistNode} Child
- *   Node to search for.
- * @template {Uint} [Max=10]
- *   Max; searches up to this depth.
- * @template {Uint} [Depth=0]
- *   Current depth.
- */
-
-/**
- * @typedef {(
- *   Tree extends UnistParent
- *     ? Depth extends Max
- *       ? Tree
- *       : Tree | InclusiveDescendant<Tree['children'][number], Max, Increment<Depth>>
- *     : Tree
- * )} InclusiveDescendant
- *   Collect all (inclusive) descendants of `Tree`.
+ * @callback Visitor
+ *   Handle a node (matching `test`, if given) before its children.
  *
- *   > 👉 **Note**: for performance reasons, this seems to be the fastest way to
- *   > recurse without actually running into an infinite loop, which the
- *   > previous version did.
- *   >
- *   > Practically, a max of `2` is typically enough assuming a `Root` is
- *   > passed, but it doesn’t improve performance.
- *   > It gets higher with `List > ListItem > Table > TableRow > TableCell`.
- *   > Using up to `10` doesn’t hurt or help either.
- * @template {UnistNode} Tree
- *   Tree type.
- * @template {Uint} [Max=10]
- *   Max; searches up to this depth.
- * @template {Uint} [Depth=0]
- *   Current depth.
+ *   Like `Visitor` in `unist-util-visit-parents`,
+ *   but with `index` and `parent` instead of `parents`.
+ * @param {Visited} node
+ *   Found node.
+ * @param {Visited extends UnistNode ? number | undefined : never} index
+ *   Index of `node` in `parent`,
+ *   or `undefined` for the tree itself.
+ * @param {Ancestor extends UnistParent ? Ancestor | undefined : never} parent
+ *   Parent of `node`,
+ *   or `undefined` for the tree itself.
+ * @returns {VisitorResult}
+ *   What to do next.
+ * @template {UnistNode} [Visited=UnistNode]
+ *   Visited node type.
+ * @template {UnistParent} [Ancestor=UnistParent]
+ *   Ancestor type.
  */
 
 /**
- * @callback Visitor
- *   Handle a node (matching `test`, if given).
- *
- *   Visitors are free to transform `node`.
- *   They can also transform `parent`.
- *
- *   Replacing `node` itself, if `SKIP` is not returned, still causes its
- *   descendants to be walked (which is a bug).
+ * @callback VisitorExit
+ *   Handle a node (matching `test`, if given) after its children.
  *
- *   When adding or removing previous siblings of `node` (or next siblings, in
- *   case of reverse), the `Visitor` should return a new `Index` to specify the
- *   sibling to traverse after `node` is traversed.
- *   Adding or removing next siblings of `node` (or previous siblings, in case
- *   of reverse) is handled as expected without needing to return a new `Index`.
- *
- *   Removing the children property of `parent` still results in them being
- *   traversed.
+ *   Like `VisitorExit` in `unist-util-visit-parents`,
+ *   but with `index` and `parent` instead of `parents`.
  * @param {Visited} node
  *   Found node.
  * @param {Visited extends UnistNode ? number | undefined : never} index
- *   Index of `node` in `parent`.
+ *   Index of `node` in `parent`,
+ *   or `undefined` for the tree itself.
  * @param {Ancestor extends UnistParent ? Ancestor | undefined : never} parent
- *   Parent of `node`.
- * @returns {VisitorResult}
+ *   Parent of `node`,
+ *   or `undefined` for the tree itself.
+ * @returns {VisitorResultExit}
  *   What to do next.
- *
- *   An `Index` is treated as a tuple of `[CONTINUE, Index]`.
- *   An `Action` is treated as a tuple of `[Action]`.
- *
- *   Passing a tuple back only makes sense if the `Action` is `SKIP`.
- *   When the `Action` is `EXIT`, that action can be returned.
- *   When the `Action` is `CONTINUE`, `Index` can be returned.
  * @template {UnistNode} [Visited=UnistNode]
  *   Visited node type.
  * @template {UnistParent} [Ancestor=UnistParent]
  *   Ancestor type.
  */
 
+/**
+ * @template {UnistNode} [Visited=UnistNode]
+ *   Visited node type.
+ * @template {UnistParent} [Ancestor=UnistParent]
+ *   Ancestor type.
+ * @typedef Visitors
+ *   Handle nodes when entering and exiting them.
+ *
+ *   Like `Visitors` in `unist-util-visit-parents`.
+ * @property {Visitor<Visited, Ancestor> | null | undefined} [enter]
+ *   Handle a node before its children (optional).
+ * @property {VisitorExit<Visited, Ancestor>} exit
+ *   Handle a node after its children.
+ */
+
 /**
  * @typedef {Visitor<Visited, Parent<Ancestor, Visited>>} BuildVisitorFromMatch
  *   Build a typed `Visitor` function from a node and all possible parents.
@@ -90965,6 +91072,25 @@ function toResult(value) {
  *   Test type.
  */
 
+/**
+ * @typedef {(
+ *   Visitors<
+ *     Matches<InclusiveDescendant<Tree>, Check>,
+ *     Parent<
+ *       Extract<InclusiveDescendant<Tree>, UnistParent>,
+ *       Matches<InclusiveDescendant<Tree>, Check>
+ *     >
+ *   >
+ * )} BuildVisitors
+ *   Build typed `Visitors` from a tree and a test.
+ *
+ *   It will infer which values are passed as `node` and which as `parent`.
+ * @template {UnistNode} [Tree=UnistNode]
+ *   Node type.
+ * @template {Test} [Check=Test]
+ *   Test type.
+ */
+
 
 
 
@@ -90973,10 +91099,13 @@ function toResult(value) {
  * Visit nodes.
  *
  * This algorithm performs *depth-first* *tree traversal* in *preorder*
- * (**NLR**) or if `reverse` is given, in *reverse preorder* (**NRL**).
+ * (**NLR**) or if `reverse` is given,
+ * in *reverse preorder* (**NRL**).
+ * An `exit` visitor is called in *postorder* (**LRN**)
+ * or if `reverse` is given, in *reverse postorder* (**RLN**).
  *
- * You can choose for which nodes `visitor` is called by passing a `test`.
- * For complex tests, you should test yourself in `visitor`, as it will be
+ * You can choose which nodes are visited by passing a `test`.
+ * For complex tests, you should test yourself in a visitor, as it will be
  * faster and will have improved type information.
  *
  * Walking the tree is an intensive task.
@@ -90985,29 +91114,48 @@ function toResult(value) {
  * to check if a node matches, and then perform different operations.
  *
  * You can change the tree.
- * See `Visitor` for more info.
+ * Changes inside a node made when entering it are walked,
+ * changes made when exiting it are not.
+ * See `Visitor` and `VisitorExit` for more info.
  *
  * @overload
  * @param {Tree} tree
+ *   Tree to traverse.
  * @param {Check} check
- * @param {BuildVisitor<Tree, Check>} visitor
+ *   `unist-util-is`-compatible test.
+ * @param {BuildVisitor<Tree, Check> | BuildVisitors<Tree, Check>} visitors
+ *   Handle each node when entering it,
+ *   or `{enter, exit}` to also handle it when exiting it.
  * @param {boolean | null | undefined} [reverse]
+ *   Walk children from last to first;
+ *   for `enter`, reverse preorder (NRL) instead of preorder (NLR);
+ *   for `exit`, reverse postorder (RLN) instead of postorder (LRN).
  * @returns {undefined}
+ *   Nothing.
  *
  * @overload
  * @param {Tree} tree
- * @param {BuildVisitor<Tree>} visitor
+ *   Tree to traverse.
+ * @param {BuildVisitor<Tree> | BuildVisitors<Tree>} visitors
+ *   Handle each node when entering it,
+ *   or `{enter, exit}` to also handle it when exiting it.
  * @param {boolean | null | undefined} [reverse]
+ *   Walk children from last to first;
+ *   for `enter`, reverse preorder (NRL) instead of preorder (NLR);
+ *   for `exit`, reverse postorder (RLN) instead of postorder (LRN).
  * @returns {undefined}
+ *   Nothing.
  *
  * @param {UnistNode} tree
  *   Tree to traverse.
- * @param {Visitor | Test} testOrVisitor
- *   `unist-util-is`-compatible test (optional, omit to pass a visitor).
- * @param {Visitor | boolean | null | undefined} [visitorOrReverse]
- *   Handle each node (when test is omitted, pass `reverse`).
- * @param {boolean | null | undefined} [maybeReverse=false]
- *   Traverse in reverse preorder (NRL) instead of the default preorder (NLR).
+ * @param {Visitor | Visitors | Test} testOrEnterOrVisitors
+ *   `unist-util-is`-compatible test, `enter`, or `visitors`.
+ * @param {Visitor | Visitors | boolean | null | undefined} [enterOrVisitorsOrReverse]
+ *   `enter`, `visitors`, or `reverse` after a test.
+ * @param {boolean | null | undefined} [maybeReverse]
+ *   Walk children from last to first;
+ *   for `enter`, reverse preorder (NRL) instead of preorder (NLR);
+ *   for `exit`, reverse postorder (RLN) instead of postorder (LRN).
  * @returns {undefined}
  *   Nothing.
  *
@@ -91016,39 +91164,90 @@ function toResult(value) {
  * @template {Test} Check
  *   `unist-util-is`-compatible test.
  */
-function lib_visit(tree, testOrVisitor, visitorOrReverse, maybeReverse) {
+function lib_visit(
+  tree,
+  testOrEnterOrVisitors,
+  enterOrVisitorsOrReverse,
+  maybeReverse
+) {
+  /** @type {Test} */
+  let check
+  /** @type {Visitor | Visitors} */
+  let visitors
   /** @type {boolean | null | undefined} */
   let reverse
-  /** @type {Test} */
-  let test
-  /** @type {Visitor} */
-  let visitor
 
+  // Third parameter is an enter visitor or a visitors object, so expect a `test` too.
   if (
-    typeof testOrVisitor === 'function' &&
-    typeof visitorOrReverse !== 'function'
+    typeof enterOrVisitorsOrReverse === 'function' ||
+    (enterOrVisitorsOrReverse && typeof enterOrVisitorsOrReverse === 'object')
   ) {
-    test = undefined
-    visitor = testOrVisitor
-    reverse = visitorOrReverse
-  } else {
-    // @ts-expect-error: assume the overload with test was given.
-    test = testOrVisitor
-    // @ts-expect-error: assume the overload with test was given.
-    visitor = visitorOrReverse
+    check = /** @type {Test} */ (testOrEnterOrVisitors)
+    visitors = enterOrVisitorsOrReverse
     reverse = maybeReverse
   }
+  // Assume no test.
+  else {
+    visitors = /** @type {Visitor | Visitors} */ (testOrEnterOrVisitors)
+    reverse = enterOrVisitorsOrReverse
+  }
 
-  visitParents(tree, test, overload, reverse)
+  if (typeof visitors === 'function') {
+    visitParents(tree, check, lib_wrap(visitors), reverse)
+  } else {
+    visitParents(tree, check, wrapVisitors(visitors), reverse)
+  }
+}
+
+/**
+ * Turn `visit` visitors into `visitParents` visitors.
+ *
+ * @param {Visitors} visitors
+ *   Visitors for `visit`.
+ * @returns {ParentsVisitors}
+ *   Visitors for `visitParents`.
+ */
+function wrapVisitors(visitors) {
+  // Pass anything else straight to `visitParents` to get its errors.
+  if (!visitors || typeof visitors !== 'object') return visitors
+
+  return {
+    enter:
+      typeof visitors.enter === 'function'
+        ? lib_wrap(visitors.enter)
+        : visitors.enter,
+    exit:
+      typeof visitors.exit === 'function' ? lib_wrap(visitors.exit) : visitors.exit
+  }
+}
+
+/**
+ * Turn a `visit` visitor into a `visitParents` one.
+ *
+ * @template {VisitorResult} Result
+ *   Result type.
+ * @param {(node: UnistNode, index: number | undefined, parent: UnistParent | undefined) => Result} visitor
+ *   Visitor for `visit`.
+ * @returns {(node: UnistNode, parents: Array<UnistParent>, index: number | undefined) => Result}
+ *   Visitor for `visitParents`.
+ */
+function lib_wrap(visitor) {
+  return overload
 
   /**
+   * Call `visitor` with `index` and `parent` instead of `parents`.
+   *
    * @param {UnistNode} node
+   *   Visited node.
    * @param {Array<UnistParent>} parents
+   *   Ancestors of `node`.
+   * @param {number | undefined} index
+   *   Index of `node` in its parent.
+   * @returns {Result}
+   *   What to do next.
    */
-  function overload(node, parents) {
-    const parent = parents[parents.length - 1]
-    const index = parent ? parent.children.indexOf(node) : undefined
-    return visitor(node, index, parent)
+  function overload(node, parents, index) {
+    return visitor(node, index, parents[parents.length - 1])
   }
 }
 
@@ -94371,7 +94570,7 @@ function trough() {
 
       // Next or done.
       if (fn) {
-        lib_wrap(fn, next)(...output)
+        trough_lib_wrap(fn, next)(...output)
       } else {
         callback(null, ...output)
       }
@@ -94423,7 +94622,7 @@ function trough() {
  * @returns {Run}
  *   Wrapped middleware.
  */
-function lib_wrap(middleware, callback) {
+function trough_lib_wrap(middleware, callback) {
   /** @type {boolean} */
   let called
 

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@lousy-agents/mcp",
-    "version": "5.22.16",
+    "version": "5.22.17",
     "description": "MCP server for lousy-agents - provides AI coding assistant tools via the Model Context Protocol",
     "type": "module",
     "repository": {