dev-cockpit 0.2.9 → 0.3.0

package/dist/index.js

@@ -294,8 +294,8 @@ var require_req = __commonJS({
       if (req.originalUrl) {
         _req.url = req.originalUrl;
       } else {
-        const path22 = req.path;
-        _req.url = typeof path22 === "string" ? path22 : req.url ? req.url.path || req.url : void 0;
+        const path23 = req.path;
+        _req.url = typeof path23 === "string" ? path23 : req.url ? req.url.path || req.url : void 0;
       }
       if (req.query) {
         _req.query = req.query;
@@ -460,14 +460,14 @@ var require_redact = __commonJS({
       }
       return obj;
     }
-    function parsePath(path22) {
+    function parsePath(path23) {
       const parts = [];
       let current = "";
       let inBrackets = false;
       let inQuotes = false;
       let quoteChar = "";
-      for (let i2 = 0; i2 < path22.length; i2++) {
-        const char = path22[i2];
+      for (let i2 = 0; i2 < path23.length; i2++) {
+        const char = path23[i2];
         if (!inBrackets && char === ".") {
           if (current) {
             parts.push(current);
@@ -598,10 +598,10 @@ var require_redact = __commonJS({
       return current;
     }
     function redactPaths(obj, paths, censor, remove = false) {
-      for (const path22 of paths) {
-        const parts = parsePath(path22);
+      for (const path23 of paths) {
+        const parts = parsePath(path23);
         if (parts.includes("*")) {
-          redactWildcardPath(obj, parts, censor, path22, remove);
+          redactWildcardPath(obj, parts, censor, path23, remove);
         } else {
           if (remove) {
             removeKey(obj, parts);
@@ -686,8 +686,8 @@ var require_redact = __commonJS({
           }
         } else {
           if (afterWildcard.includes("*")) {
-            const wrappedCensor = typeof censor === "function" ? (value, path22) => {
-              const fullPath = [...pathArray.slice(0, pathLength), ...path22];
+            const wrappedCensor = typeof censor === "function" ? (value, path23) => {
+              const fullPath = [...pathArray.slice(0, pathLength), ...path23];
               return censor(value, fullPath);
             } : censor;
             redactWildcardPath(current, afterWildcard, wrappedCensor, originalPath, remove);
@@ -722,8 +722,8 @@ var require_redact = __commonJS({
         return null;
       }
       const pathStructure = /* @__PURE__ */ new Map();
-      for (const path22 of pathsToClone) {
-        const parts = parsePath(path22);
+      for (const path23 of pathsToClone) {
+        const parts = parsePath(path23);
         let current = pathStructure;
         for (let i2 = 0; i2 < parts.length; i2++) {
           const part = parts[i2];
@@ -775,24 +775,24 @@ var require_redact = __commonJS({
       }
       return cloneSelectively(obj, pathStructure);
     }
-    function validatePath(path22) {
-      if (typeof path22 !== "string") {
+    function validatePath(path23) {
+      if (typeof path23 !== "string") {
         throw new Error("Paths must be (non-empty) strings");
       }
-      if (path22 === "") {
+      if (path23 === "") {
         throw new Error("Invalid redaction path ()");
       }
-      if (path22.includes("..")) {
-        throw new Error(`Invalid redaction path (${path22})`);
+      if (path23.includes("..")) {
+        throw new Error(`Invalid redaction path (${path23})`);
       }
-      if (path22.includes(",")) {
-        throw new Error(`Invalid redaction path (${path22})`);
+      if (path23.includes(",")) {
+        throw new Error(`Invalid redaction path (${path23})`);
       }
       let bracketCount = 0;
       let inQuotes = false;
       let quoteChar = "";
-      for (let i2 = 0; i2 < path22.length; i2++) {
-        const char = path22[i2];
+      for (let i2 = 0; i2 < path23.length; i2++) {
+        const char = path23[i2];
         if ((char === '"' || char === "'") && bracketCount > 0) {
           if (!inQuotes) {
             inQuotes = true;
@@ -806,20 +806,20 @@ var require_redact = __commonJS({
         } else if (char === "]" && !inQuotes) {
           bracketCount--;
           if (bracketCount < 0) {
-            throw new Error(`Invalid redaction path (${path22})`);
+            throw new Error(`Invalid redaction path (${path23})`);
           }
         }
       }
       if (bracketCount !== 0) {
-        throw new Error(`Invalid redaction path (${path22})`);
+        throw new Error(`Invalid redaction path (${path23})`);
       }
     }
     function validatePaths(paths) {
       if (!Array.isArray(paths)) {
         throw new TypeError("paths must be an array");
       }
-      for (const path22 of paths) {
-        validatePath(path22);
+      for (const path23 of paths) {
+        validatePath(path23);
       }
     }
     function slowRedact(options2 = {}) {
@@ -987,8 +987,8 @@ var require_redaction = __commonJS({
         if (shape[k] === null) {
           o2[k] = (value) => topCensor(value, [k]);
         } else {
-          const wrappedCensor = typeof censor === "function" ? (value, path22) => {
-            return censor(value, [k, ...path22]);
+          const wrappedCensor = typeof censor === "function" ? (value, path23) => {
+            return censor(value, [k, ...path23]);
           } : censor;
           o2[k] = Redact({
             paths: shape[k],
@@ -1209,7 +1209,7 @@ var require_sonic_boom = __commonJS({
     var fs18 = __require("fs");
     var EventEmitter3 = __require("events");
     var inherits = __require("util").inherits;
-    var path22 = __require("path");
+    var path23 = __require("path");
     var sleep = require_atomic_sleep();
     var assert = __require("assert");
     var BUSY_WRITE_TIMEOUT = 100;
@@ -1263,7 +1263,7 @@ var require_sonic_boom = __commonJS({
       const mode = sonic.mode;
       if (sonic.sync) {
         try {
-          if (sonic.mkdir) fs18.mkdirSync(path22.dirname(file), { recursive: true });
+          if (sonic.mkdir) fs18.mkdirSync(path23.dirname(file), { recursive: true });
           const fd = fs18.openSync(file, flags, mode);
           fileOpened(null, fd);
         } catch (err) {
@@ -1271,7 +1271,7 @@ var require_sonic_boom = __commonJS({
           throw err;
         }
       } else if (sonic.mkdir) {
-        fs18.mkdir(path22.dirname(file), { recursive: true }, (err) => {
+        fs18.mkdir(path23.dirname(file), { recursive: true }, (err) => {
           if (err) return fileOpened(err);
           fs18.open(file, flags, mode, fileOpened);
         });
@@ -4342,7 +4342,7 @@ var require_windows = __commonJS({
     module.exports = isexe;
     isexe.sync = sync;
     var fs18 = __require("fs");
-    function checkPathExt(path22, options2) {
+    function checkPathExt(path23, options2) {
       var pathext = options2.pathExt !== void 0 ? options2.pathExt : process.env.PATHEXT;
       if (!pathext) {
         return true;
@@ -4353,25 +4353,25 @@ var require_windows = __commonJS({
       }
       for (var i2 = 0; i2 < pathext.length; i2++) {
         var p = pathext[i2].toLowerCase();
-        if (p && path22.substr(-p.length).toLowerCase() === p) {
+        if (p && path23.substr(-p.length).toLowerCase() === p) {
           return true;
         }
       }
       return false;
     }
-    function checkStat(stat4, path22, options2) {
+    function checkStat(stat4, path23, options2) {
       if (!stat4.isSymbolicLink() && !stat4.isFile()) {
         return false;
       }
-      return checkPathExt(path22, options2);
+      return checkPathExt(path23, options2);
     }
-    function isexe(path22, options2, cb) {
-      fs18.stat(path22, function(er, stat4) {
-        cb(er, er ? false : checkStat(stat4, path22, options2));
+    function isexe(path23, options2, cb) {
+      fs18.stat(path23, function(er, stat4) {
+        cb(er, er ? false : checkStat(stat4, path23, options2));
       });
     }
-    function sync(path22, options2) {
-      return checkStat(fs18.statSync(path22), path22, options2);
+    function sync(path23, options2) {
+      return checkStat(fs18.statSync(path23), path23, options2);
     }
   }
 });
@@ -4382,13 +4382,13 @@ var require_mode = __commonJS({
     module.exports = isexe;
     isexe.sync = sync;
     var fs18 = __require("fs");
-    function isexe(path22, options2, cb) {
-      fs18.stat(path22, function(er, stat4) {
+    function isexe(path23, options2, cb) {
+      fs18.stat(path23, function(er, stat4) {
         cb(er, er ? false : checkStat(stat4, options2));
       });
     }
-    function sync(path22, options2) {
-      return checkStat(fs18.statSync(path22), options2);
+    function sync(path23, options2) {
+      return checkStat(fs18.statSync(path23), options2);
     }
     function checkStat(stat4, options2) {
       return stat4.isFile() && checkMode(stat4, options2);
@@ -4421,7 +4421,7 @@ var require_isexe = __commonJS({
     }
     module.exports = isexe;
     isexe.sync = sync;
-    function isexe(path22, options2, cb) {
+    function isexe(path23, options2, cb) {
       if (typeof options2 === "function") {
         cb = options2;
         options2 = {};
@@ -4431,7 +4431,7 @@ var require_isexe = __commonJS({
           throw new TypeError("callback not provided");
         }
         return new Promise(function(resolve3, reject) {
-          isexe(path22, options2 || {}, function(er, is) {
+          isexe(path23, options2 || {}, function(er, is) {
             if (er) {
               reject(er);
             } else {
@@ -4440,7 +4440,7 @@ var require_isexe = __commonJS({
           });
         });
       }
-      core(path22, options2 || {}, function(er, is) {
+      core(path23, options2 || {}, function(er, is) {
         if (er) {
           if (er.code === "EACCES" || options2 && options2.ignoreErrors) {
             er = null;
@@ -4450,9 +4450,9 @@ var require_isexe = __commonJS({
         cb(er, is);
       });
     }
-    function sync(path22, options2) {
+    function sync(path23, options2) {
       try {
-        return core.sync(path22, options2 || {});
+        return core.sync(path23, options2 || {});
       } catch (er) {
         if (options2 && options2.ignoreErrors || er.code === "EACCES") {
           return false;
@@ -4468,7 +4468,7 @@ var require_isexe = __commonJS({
 var require_which = __commonJS({
   "node_modules/which/which.js"(exports, module) {
     var isWindows2 = process.platform === "win32" || process.env.OSTYPE === "cygwin" || process.env.OSTYPE === "msys";
-    var path22 = __require("path");
+    var path23 = __require("path");
     var COLON = isWindows2 ? ";" : ":";
     var isexe = require_isexe();
     var getNotFoundError = (cmd) => Object.assign(new Error(`not found: ${cmd}`), { code: "ENOENT" });
@@ -4506,7 +4506,7 @@ var require_which = __commonJS({
           return opt.all && found.length ? resolve3(found) : reject(getNotFoundError(cmd));
         const ppRaw = pathEnv[i2];
         const pathPart = /^".*"$/.test(ppRaw) ? ppRaw.slice(1, -1) : ppRaw;
-        const pCmd = path22.join(pathPart, cmd);
+        const pCmd = path23.join(pathPart, cmd);
         const p = !pathPart && /^\.[\\\/]/.test(cmd) ? cmd.slice(0, 2) + pCmd : pCmd;
         resolve3(subStep(p, i2, 0));
       });
@@ -4533,7 +4533,7 @@ var require_which = __commonJS({
       for (let i2 = 0; i2 < pathEnv.length; i2++) {
         const ppRaw = pathEnv[i2];
         const pathPart = /^".*"$/.test(ppRaw) ? ppRaw.slice(1, -1) : ppRaw;
-        const pCmd = path22.join(pathPart, cmd);
+        const pCmd = path23.join(pathPart, cmd);
         const p = !pathPart && /^\.[\\\/]/.test(cmd) ? cmd.slice(0, 2) + pCmd : pCmd;
         for (let j = 0; j < pathExt.length; j++) {
           const cur = p + pathExt[j];
@@ -4581,7 +4581,7 @@ var require_path_key = __commonJS({
 var require_resolveCommand = __commonJS({
   "node_modules/cross-spawn/lib/util/resolveCommand.js"(exports, module) {
     "use strict";
-    var path22 = __require("path");
+    var path23 = __require("path");
     var which = require_which();
     var getPathKey = require_path_key();
     function resolveCommandAttempt(parsed, withoutPathExt) {
@@ -4599,7 +4599,7 @@ var require_resolveCommand = __commonJS({
       try {
         resolved = which.sync(parsed.command, {
           path: env[getPathKey({ env })],
-          pathExt: withoutPathExt ? path22.delimiter : void 0
+          pathExt: withoutPathExt ? path23.delimiter : void 0
         });
       } catch (e) {
       } finally {
@@ -4608,7 +4608,7 @@ var require_resolveCommand = __commonJS({
         }
       }
       if (resolved) {
-        resolved = path22.resolve(hasCustomCwd ? parsed.options.cwd : "", resolved);
+        resolved = path23.resolve(hasCustomCwd ? parsed.options.cwd : "", resolved);
       }
       return resolved;
     }
@@ -4662,8 +4662,8 @@ var require_shebang_command = __commonJS({
       if (!match) {
         return null;
       }
-      const [path22, argument] = match[0].replace(/#! ?/, "").split(" ");
-      const binary = path22.split("/").pop();
+      const [path23, argument] = match[0].replace(/#! ?/, "").split(" ");
+      const binary = path23.split("/").pop();
       if (binary === "env") {
         return argument;
       }
@@ -4698,7 +4698,7 @@ var require_readShebang = __commonJS({
 var require_parse = __commonJS({
   "node_modules/cross-spawn/lib/parse.js"(exports, module) {
     "use strict";
-    var path22 = __require("path");
+    var path23 = __require("path");
     var resolveCommand = require_resolveCommand();
     var escape3 = require_escape();
     var readShebang = require_readShebang();
@@ -4723,7 +4723,7 @@ var require_parse = __commonJS({
       const needsShell = !isExecutableRegExp.test(commandFile);
       if (parsed.options.forceShell || needsShell) {
         const needsDoubleEscapeMetaChars = isCmdShimRegExp.test(commandFile);
-        parsed.command = path22.normalize(parsed.command);
+        parsed.command = path23.normalize(parsed.command);
         parsed.command = escape3.command(parsed.command);
         parsed.args = parsed.args.map((arg) => escape3.argument(arg, needsDoubleEscapeMetaChars));
         const shellCommand = [parsed.command].concat(parsed.args).join(" ");
@@ -4910,17 +4910,17 @@ var require_visit = __commonJS({
     visit.BREAK = BREAK;
     visit.SKIP = SKIP;
     visit.REMOVE = REMOVE;
-    function visit_(key, node, visitor, path22) {
-      const ctrl = callVisitor(key, node, visitor, path22);
+    function visit_(key, node, visitor, path23) {
+      const ctrl = callVisitor(key, node, visitor, path23);
       if (identity4.isNode(ctrl) || identity4.isPair(ctrl)) {
-        replaceNode(key, path22, ctrl);
-        return visit_(key, ctrl, visitor, path22);
+        replaceNode(key, path23, ctrl);
+        return visit_(key, ctrl, visitor, path23);
       }
       if (typeof ctrl !== "symbol") {
         if (identity4.isCollection(node)) {
-          path22 = Object.freeze(path22.concat(node));
+          path23 = Object.freeze(path23.concat(node));
           for (let i2 = 0; i2 < node.items.length; ++i2) {
-            const ci = visit_(i2, node.items[i2], visitor, path22);
+            const ci = visit_(i2, node.items[i2], visitor, path23);
             if (typeof ci === "number")
               i2 = ci - 1;
             else if (ci === BREAK)
@@ -4931,13 +4931,13 @@ var require_visit = __commonJS({
             }
           }
         } else if (identity4.isPair(node)) {
-          path22 = Object.freeze(path22.concat(node));
-          const ck = visit_("key", node.key, visitor, path22);
+          path23 = Object.freeze(path23.concat(node));
+          const ck = visit_("key", node.key, visitor, path23);
           if (ck === BREAK)
             return BREAK;
           else if (ck === REMOVE)
             node.key = null;
-          const cv = visit_("value", node.value, visitor, path22);
+          const cv = visit_("value", node.value, visitor, path23);
           if (cv === BREAK)
             return BREAK;
           else if (cv === REMOVE)
@@ -4958,17 +4958,17 @@ var require_visit = __commonJS({
     visitAsync.BREAK = BREAK;
     visitAsync.SKIP = SKIP;
     visitAsync.REMOVE = REMOVE;
-    async function visitAsync_(key, node, visitor, path22) {
-      const ctrl = await callVisitor(key, node, visitor, path22);
+    async function visitAsync_(key, node, visitor, path23) {
+      const ctrl = await callVisitor(key, node, visitor, path23);
       if (identity4.isNode(ctrl) || identity4.isPair(ctrl)) {
-        replaceNode(key, path22, ctrl);
-        return visitAsync_(key, ctrl, visitor, path22);
+        replaceNode(key, path23, ctrl);
+        return visitAsync_(key, ctrl, visitor, path23);
       }
       if (typeof ctrl !== "symbol") {
         if (identity4.isCollection(node)) {
-          path22 = Object.freeze(path22.concat(node));
+          path23 = Object.freeze(path23.concat(node));
           for (let i2 = 0; i2 < node.items.length; ++i2) {
-            const ci = await visitAsync_(i2, node.items[i2], visitor, path22);
+            const ci = await visitAsync_(i2, node.items[i2], visitor, path23);
             if (typeof ci === "number")
               i2 = ci - 1;
             else if (ci === BREAK)
@@ -4979,13 +4979,13 @@ var require_visit = __commonJS({
             }
           }
         } else if (identity4.isPair(node)) {
-          path22 = Object.freeze(path22.concat(node));
-          const ck = await visitAsync_("key", node.key, visitor, path22);
+          path23 = Object.freeze(path23.concat(node));
+          const ck = await visitAsync_("key", node.key, visitor, path23);
           if (ck === BREAK)
             return BREAK;
           else if (ck === REMOVE)
             node.key = null;
-          const cv = await visitAsync_("value", node.value, visitor, path22);
+          const cv = await visitAsync_("value", node.value, visitor, path23);
           if (cv === BREAK)
             return BREAK;
           else if (cv === REMOVE)
@@ -5012,23 +5012,23 @@ var require_visit = __commonJS({
       }
       return visitor;
     }
-    function callVisitor(key, node, visitor, path22) {
+    function callVisitor(key, node, visitor, path23) {
       if (typeof visitor === "function")
-        return visitor(key, node, path22);
+        return visitor(key, node, path23);
       if (identity4.isMap(node))
-        return visitor.Map?.(key, node, path22);
+        return visitor.Map?.(key, node, path23);
       if (identity4.isSeq(node))
-        return visitor.Seq?.(key, node, path22);
+        return visitor.Seq?.(key, node, path23);
       if (identity4.isPair(node))
-        return visitor.Pair?.(key, node, path22);
+        return visitor.Pair?.(key, node, path23);
       if (identity4.isScalar(node))
-        return visitor.Scalar?.(key, node, path22);
+        return visitor.Scalar?.(key, node, path23);
       if (identity4.isAlias(node))
-        return visitor.Alias?.(key, node, path22);
+        return visitor.Alias?.(key, node, path23);
       return void 0;
     }
-    function replaceNode(key, path22, node) {
-      const parent = path22[path22.length - 1];
+    function replaceNode(key, path23, node) {
+      const parent = path23[path23.length - 1];
       if (identity4.isCollection(parent)) {
         parent.items[key] = node;
       } else if (identity4.isPair(parent)) {
@@ -5638,10 +5638,10 @@ var require_Collection = __commonJS({
     var createNode = require_createNode();
     var identity4 = require_identity();
     var Node = require_Node();
-    function collectionFromPath(schema, path22, value) {
+    function collectionFromPath(schema, path23, value) {
       let v = value;
-      for (let i2 = path22.length - 1; i2 >= 0; --i2) {
-        const k = path22[i2];
+      for (let i2 = path23.length - 1; i2 >= 0; --i2) {
+        const k = path23[i2];
         if (typeof k === "number" && Number.isInteger(k) && k >= 0) {
           const a2 = [];
           a2[k] = v;
@@ -5660,7 +5660,7 @@ var require_Collection = __commonJS({
         sourceObjects: /* @__PURE__ */ new Map()
       });
     }
-    var isEmptyPath = (path22) => path22 == null || typeof path22 === "object" && !!path22[Symbol.iterator]().next().done;
+    var isEmptyPath = (path23) => path23 == null || typeof path23 === "object" && !!path23[Symbol.iterator]().next().done;
     var Collection = class extends Node.NodeBase {
       constructor(type, schema) {
         super(type);
@@ -5690,11 +5690,11 @@ var require_Collection = __commonJS({
        * be a Pair instance or a `{ key, value }` object, which may not have a key
        * that already exists in the map.
        */
-      addIn(path22, value) {
-        if (isEmptyPath(path22))
+      addIn(path23, value) {
+        if (isEmptyPath(path23))
           this.add(value);
         else {
-          const [key, ...rest] = path22;
+          const [key, ...rest] = path23;
           const node = this.get(key, true);
           if (identity4.isCollection(node))
             node.addIn(rest, value);
@@ -5708,8 +5708,8 @@ var require_Collection = __commonJS({
        * Removes a value from the collection.
        * @returns `true` if the item was found and removed.
        */
-      deleteIn(path22) {
-        const [key, ...rest] = path22;
+      deleteIn(path23) {
+        const [key, ...rest] = path23;
         if (rest.length === 0)
           return this.delete(key);
         const node = this.get(key, true);
@@ -5723,8 +5723,8 @@ var require_Collection = __commonJS({
        * scalar values from their surrounding node; to disable set `keepScalar` to
        * `true` (collections are always returned intact).
        */
-      getIn(path22, keepScalar) {
-        const [key, ...rest] = path22;
+      getIn(path23, keepScalar) {
+        const [key, ...rest] = path23;
         const node = this.get(key, true);
         if (rest.length === 0)
           return !keepScalar && identity4.isScalar(node) ? node.value : node;
@@ -5742,8 +5742,8 @@ var require_Collection = __commonJS({
       /**
        * Checks if the collection includes a value with the key `key`.
        */
-      hasIn(path22) {
-        const [key, ...rest] = path22;
+      hasIn(path23) {
+        const [key, ...rest] = path23;
         if (rest.length === 0)
           return this.has(key);
         const node = this.get(key, true);
@@ -5753,8 +5753,8 @@ var require_Collection = __commonJS({
        * Sets a value in this collection. For `!!set`, `value` needs to be a
        * boolean to add/remove the item from the set.
        */
-      setIn(path22, value) {
-        const [key, ...rest] = path22;
+      setIn(path23, value) {
+        const [key, ...rest] = path23;
         if (rest.length === 0) {
           this.set(key, value);
         } else {
@@ -8269,9 +8269,9 @@ var require_Document = __commonJS({
           this.contents.add(value);
       }
       /** Adds a value to the document. */
-      addIn(path22, value) {
+      addIn(path23, value) {
         if (assertCollection(this.contents))
-          this.contents.addIn(path22, value);
+          this.contents.addIn(path23, value);
       }
       /**
        * Create a new `Alias` node, ensuring that the target `node` has the required anchor.
@@ -8346,14 +8346,14 @@ var require_Document = __commonJS({
        * Removes a value from the document.
        * @returns `true` if the item was found and removed.
        */
-      deleteIn(path22) {
-        if (Collection.isEmptyPath(path22)) {
+      deleteIn(path23) {
+        if (Collection.isEmptyPath(path23)) {
           if (this.contents == null)
             return false;
           this.contents = null;
           return true;
         }
-        return assertCollection(this.contents) ? this.contents.deleteIn(path22) : false;
+        return assertCollection(this.contents) ? this.contents.deleteIn(path23) : false;
       }
       /**
        * Returns item at `key`, or `undefined` if not found. By default unwraps
@@ -8368,10 +8368,10 @@ var require_Document = __commonJS({
        * scalar values from their surrounding node; to disable set `keepScalar` to
        * `true` (collections are always returned intact).
        */
-      getIn(path22, keepScalar) {
-        if (Collection.isEmptyPath(path22))
+      getIn(path23, keepScalar) {
+        if (Collection.isEmptyPath(path23))
           return !keepScalar && identity4.isScalar(this.contents) ? this.contents.value : this.contents;
-        return identity4.isCollection(this.contents) ? this.contents.getIn(path22, keepScalar) : void 0;
+        return identity4.isCollection(this.contents) ? this.contents.getIn(path23, keepScalar) : void 0;
       }
       /**
        * Checks if the document includes a value with the key `key`.
@@ -8382,10 +8382,10 @@ var require_Document = __commonJS({
       /**
        * Checks if the document includes a value at `path`.
        */
-      hasIn(path22) {
-        if (Collection.isEmptyPath(path22))
+      hasIn(path23) {
+        if (Collection.isEmptyPath(path23))
           return this.contents !== void 0;
-        return identity4.isCollection(this.contents) ? this.contents.hasIn(path22) : false;
+        return identity4.isCollection(this.contents) ? this.contents.hasIn(path23) : false;
       }
       /**
        * Sets a value in this document. For `!!set`, `value` needs to be a
@@ -8402,13 +8402,13 @@ var require_Document = __commonJS({
        * Sets a value in this document. For `!!set`, `value` needs to be a
        * boolean to add/remove the item from the set.
        */
-      setIn(path22, value) {
-        if (Collection.isEmptyPath(path22)) {
+      setIn(path23, value) {
+        if (Collection.isEmptyPath(path23)) {
           this.contents = value;
         } else if (this.contents == null) {
-          this.contents = Collection.collectionFromPath(this.schema, Array.from(path22), value);
+          this.contents = Collection.collectionFromPath(this.schema, Array.from(path23), value);
         } else if (assertCollection(this.contents)) {
-          this.contents.setIn(path22, value);
+          this.contents.setIn(path23, value);
         }
       }
       /**
@@ -10366,9 +10366,9 @@ var require_cst_visit = __commonJS({
     visit.BREAK = BREAK;
     visit.SKIP = SKIP;
     visit.REMOVE = REMOVE;
-    visit.itemAtPath = (cst, path22) => {
+    visit.itemAtPath = (cst, path23) => {
       let item = cst;
-      for (const [field, index] of path22) {
+      for (const [field, index] of path23) {
         const tok = item?.[field];
         if (tok && "items" in tok) {
           item = tok.items[index];
@@ -10377,23 +10377,23 @@ var require_cst_visit = __commonJS({
       }
       return item;
     };
-    visit.parentCollection = (cst, path22) => {
-      const parent = visit.itemAtPath(cst, path22.slice(0, -1));
-      const field = path22[path22.length - 1][0];
+    visit.parentCollection = (cst, path23) => {
+      const parent = visit.itemAtPath(cst, path23.slice(0, -1));
+      const field = path23[path23.length - 1][0];
       const coll = parent?.[field];
       if (coll && "items" in coll)
         return coll;
       throw new Error("Parent collection not found");
     };
-    function _visit(path22, item, visitor) {
-      let ctrl = visitor(item, path22);
+    function _visit(path23, item, visitor) {
+      let ctrl = visitor(item, path23);
       if (typeof ctrl === "symbol")
         return ctrl;
       for (const field of ["key", "value"]) {
         const token = item[field];
         if (token && "items" in token) {
           for (let i2 = 0; i2 < token.items.length; ++i2) {
-            const ci = _visit(Object.freeze(path22.concat([[field, i2]])), token.items[i2], visitor);
+            const ci = _visit(Object.freeze(path23.concat([[field, i2]])), token.items[i2], visitor);
             if (typeof ci === "number")
               i2 = ci - 1;
             else if (ci === BREAK)
@@ -10404,10 +10404,10 @@ var require_cst_visit = __commonJS({
             }
           }
           if (typeof ctrl === "function" && field === "key")
-            ctrl = ctrl(item, path22);
+            ctrl = ctrl(item, path23);
         }
       }
-      return typeof ctrl === "function" ? ctrl(item, path22) : ctrl;
+      return typeof ctrl === "function" ? ctrl(item, path23) : ctrl;
     }
     exports.visit = visit;
   }
@@ -13074,7 +13074,7 @@ var require_command = __commonJS({
   "node_modules/commander/lib/command.js"(exports) {
     var EventEmitter3 = __require("node:events").EventEmitter;
     var childProcess = __require("node:child_process");
-    var path22 = __require("node:path");
+    var path23 = __require("node:path");
     var fs18 = __require("node:fs");
     var process10 = __require("node:process");
     var { Argument: Argument2, humanReadableArgName } = require_argument();
@@ -14007,9 +14007,9 @@ Expecting one of '${allowedValues.join("', '")}'`);
         let launchWithNode = false;
         const sourceExt = [".js", ".ts", ".tsx", ".mjs", ".cjs"];
         function findFile(baseDir, baseName) {
-          const localBin = path22.resolve(baseDir, baseName);
+          const localBin = path23.resolve(baseDir, baseName);
           if (fs18.existsSync(localBin)) return localBin;
-          if (sourceExt.includes(path22.extname(baseName))) return void 0;
+          if (sourceExt.includes(path23.extname(baseName))) return void 0;
           const foundExt = sourceExt.find(
             (ext) => fs18.existsSync(`${localBin}${ext}`)
           );
@@ -14027,17 +14027,17 @@ Expecting one of '${allowedValues.join("', '")}'`);
           } catch (err) {
             resolvedScriptPath = this._scriptPath;
           }
-          executableDir = path22.resolve(
-            path22.dirname(resolvedScriptPath),
+          executableDir = path23.resolve(
+            path23.dirname(resolvedScriptPath),
             executableDir
           );
         }
         if (executableDir) {
           let localFile = findFile(executableDir, executableFile);
           if (!localFile && !subcommand._executableFile && this._scriptPath) {
-            const legacyName = path22.basename(
+            const legacyName = path23.basename(
               this._scriptPath,
-              path22.extname(this._scriptPath)
+              path23.extname(this._scriptPath)
             );
             if (legacyName !== this._name) {
               localFile = findFile(
@@ -14048,7 +14048,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
           }
           executableFile = localFile || executableFile;
         }
-        launchWithNode = sourceExt.includes(path22.extname(executableFile));
+        launchWithNode = sourceExt.includes(path23.extname(executableFile));
         let proc;
         if (process10.platform !== "win32") {
           if (launchWithNode) {
@@ -14888,7 +14888,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
        * @return {Command}
        */
       nameFromFilename(filename) {
-        this._name = path22.basename(filename, path22.extname(filename));
+        this._name = path23.basename(filename, path23.extname(filename));
         return this;
       }
       /**
@@ -14902,9 +14902,9 @@ Expecting one of '${allowedValues.join("', '")}'`);
        * @param {string} [path]
        * @return {(string|null|Command)}
        */
-      executableDir(path23) {
-        if (path23 === void 0) return this._executableDir;
-        this._executableDir = path23;
+      executableDir(path24) {
+        if (path24 === void 0) return this._executableDir;
+        this._executableDir = path24;
         return this;
       }
       /**
@@ -60073,15 +60073,15 @@ var require_route = __commonJS({
       };
     }
     function wrapConversion(toModel, graph) {
-      const path22 = [graph[toModel].parent, toModel];
+      const path23 = [graph[toModel].parent, toModel];
       let fn = conversions[graph[toModel].parent][toModel];
       let cur = graph[toModel].parent;
       while (graph[cur].parent) {
-        path22.unshift(graph[cur].parent);
+        path23.unshift(graph[cur].parent);
         fn = link2(conversions[graph[cur].parent][cur], fn);
         cur = graph[cur].parent;
       }
-      fn.conversion = path22;
+      fn.conversion = path23;
       return fn;
     }
     module.exports = function(fromModel) {
@@ -77216,13 +77216,13 @@ var logOutputSync = ({ serializedResult, fdNumber, state, verboseInfo, encoding,
   }
 };
 var writeToFiles = (serializedResult, stdioItems, outputFiles) => {
-  for (const { path: path22, append } of stdioItems.filter(({ type }) => FILE_TYPES.has(type))) {
-    const pathString = typeof path22 === "string" ? path22 : path22.toString();
+  for (const { path: path23, append } of stdioItems.filter(({ type }) => FILE_TYPES.has(type))) {
+    const pathString = typeof path23 === "string" ? path23 : path23.toString();
     if (append || outputFiles.has(pathString)) {
-      appendFileSync(path22, serializedResult);
+      appendFileSync(path23, serializedResult);
     } else {
       outputFiles.add(pathString);
-      writeFileSync(path22, serializedResult);
+      writeFileSync(path23, serializedResult);
     }
   }
 };
@@ -80300,8 +80300,8 @@ function getErrorMap() {
 
 // node_modules/zod/v3/helpers/parseUtil.js
 var makeIssue = (params) => {
-  const { data, path: path22, errorMaps, issueData } = params;
-  const fullPath = [...path22, ...issueData.path || []];
+  const { data, path: path23, errorMaps, issueData } = params;
+  const fullPath = [...path23, ...issueData.path || []];
   const fullIssue = {
     ...issueData,
     path: fullPath
@@ -80417,11 +80417,11 @@ var errorUtil;
 
 // node_modules/zod/v3/types.js
 var ParseInputLazyPath = class {
-  constructor(parent, value, path22, key) {
+  constructor(parent, value, path23, key) {
     this._cachedPath = [];
     this.parent = parent;
     this.data = value;
-    this._path = path22;
+    this._path = path23;
     this._key = key;
   }
   get path() {
@@ -88837,7 +88837,7 @@ var ReaddirpStream = class extends Readable4 {
     this._directoryFilter = normalizeFilter(opts.directoryFilter);
     const statMethod = opts.lstat ? lstat : stat;
     if (wantBigintFsStats) {
-      this._stat = (path22) => statMethod(path22, { bigint: true });
+      this._stat = (path23) => statMethod(path23, { bigint: true });
     } else {
       this._stat = statMethod;
     }
@@ -88862,8 +88862,8 @@ var ReaddirpStream = class extends Readable4 {
         const par = this.parent;
         const fil = par && par.files;
         if (fil && fil.length > 0) {
-          const { path: path22, depth } = par;
-          const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path22));
+          const { path: path23, depth } = par;
+          const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path23));
           const awaited = await Promise.all(slice);
           for (const entry of awaited) {
             if (!entry)
@@ -88903,20 +88903,20 @@ var ReaddirpStream = class extends Readable4 {
       this.reading = false;
     }
   }
-  async _exploreDir(path22, depth) {
+  async _exploreDir(path23, depth) {
     let files;
     try {
-      files = await readdir(path22, this._rdOptions);
+      files = await readdir(path23, this._rdOptions);
     } catch (error) {
       this._onError(error);
     }
-    return { files, depth, path: path22 };
+    return { files, depth, path: path23 };
   }
-  async _formatEntry(dirent, path22) {
+  async _formatEntry(dirent, path23) {
     let entry;
     const basename3 = this._isDirent ? dirent.name : dirent;
     try {
-      const fullPath = presolve(pjoin(path22, basename3));
+      const fullPath = presolve(pjoin(path23, basename3));
       entry = { path: prelative(this._root, fullPath), fullPath, basename: basename3 };
       entry[this._statsProp] = this._isDirent ? dirent : await this._stat(fullPath);
     } catch (err) {
@@ -89316,16 +89316,16 @@ var delFromSet = (main, prop, item) => {
 };
 var isEmptySet = (val) => val instanceof Set ? val.size === 0 : !val;
 var FsWatchInstances = /* @__PURE__ */ new Map();
-function createFsWatchInstance(path22, options2, listener, errHandler, emitRaw) {
+function createFsWatchInstance(path23, options2, listener, errHandler, emitRaw) {
   const handleEvent = (rawEvent, evPath) => {
-    listener(path22);
-    emitRaw(rawEvent, evPath, { watchedPath: path22 });
-    if (evPath && path22 !== evPath) {
-      fsWatchBroadcast(sp.resolve(path22, evPath), KEY_LISTENERS, sp.join(path22, evPath));
+    listener(path23);
+    emitRaw(rawEvent, evPath, { watchedPath: path23 });
+    if (evPath && path23 !== evPath) {
+      fsWatchBroadcast(sp.resolve(path23, evPath), KEY_LISTENERS, sp.join(path23, evPath));
     }
   };
   try {
-    return fs_watch(path22, {
+    return fs_watch(path23, {
       persistent: options2.persistent
     }, handleEvent);
   } catch (error) {
@@ -89341,12 +89341,12 @@ var fsWatchBroadcast = (fullPath, listenerType, val1, val2, val3) => {
     listener(val1, val2, val3);
   });
 };
-var setFsWatchListener = (path22, fullPath, options2, handlers) => {
+var setFsWatchListener = (path23, fullPath, options2, handlers) => {
   const { listener, errHandler, rawEmitter } = handlers;
   let cont = FsWatchInstances.get(fullPath);
   let watcher;
   if (!options2.persistent) {
-    watcher = createFsWatchInstance(path22, options2, listener, errHandler, rawEmitter);
+    watcher = createFsWatchInstance(path23, options2, listener, errHandler, rawEmitter);
     if (!watcher)
       return;
     return watcher.close.bind(watcher);
@@ -89357,7 +89357,7 @@ var setFsWatchListener = (path22, fullPath, options2, handlers) => {
     addAndConvert(cont, KEY_RAW, rawEmitter);
   } else {
     watcher = createFsWatchInstance(
-      path22,
+      path23,
       options2,
       fsWatchBroadcast.bind(null, fullPath, KEY_LISTENERS),
       errHandler,
@@ -89372,7 +89372,7 @@ var setFsWatchListener = (path22, fullPath, options2, handlers) => {
         cont.watcherUnusable = true;
       if (isWindows && error.code === "EPERM") {
         try {
-          const fd = await open(path22, "r");
+          const fd = await open(path23, "r");
           await fd.close();
           broadcastErr(error);
         } catch (err) {
@@ -89403,7 +89403,7 @@ var setFsWatchListener = (path22, fullPath, options2, handlers) => {
   };
 };
 var FsWatchFileInstances = /* @__PURE__ */ new Map();
-var setFsWatchFileListener = (path22, fullPath, options2, handlers) => {
+var setFsWatchFileListener = (path23, fullPath, options2, handlers) => {
   const { listener, rawEmitter } = handlers;
   let cont = FsWatchFileInstances.get(fullPath);
   const copts = cont && cont.options;
@@ -89425,7 +89425,7 @@ var setFsWatchFileListener = (path22, fullPath, options2, handlers) => {
         });
         const currmtime = curr.mtimeMs;
         if (curr.size !== prev.size || currmtime > prev.mtimeMs || currmtime === 0) {
-          foreach(cont.listeners, (listener2) => listener2(path22, curr));
+          foreach(cont.listeners, (listener2) => listener2(path23, curr));
         }
       })
     };
@@ -89455,13 +89455,13 @@ var NodeFsHandler = class {
    * @param listener on fs change
    * @returns closer for the watcher instance
    */
-  _watchWithNodeFs(path22, listener) {
+  _watchWithNodeFs(path23, listener) {
     const opts = this.fsw.options;
-    const directory = sp.dirname(path22);
-    const basename3 = sp.basename(path22);
+    const directory = sp.dirname(path23);
+    const basename3 = sp.basename(path23);
     const parent = this.fsw._getWatchedDir(directory);
     parent.add(basename3);
-    const absolutePath = sp.resolve(path22);
+    const absolutePath = sp.resolve(path23);
     const options2 = {
       persistent: opts.persistent
     };
@@ -89471,12 +89471,12 @@ var NodeFsHandler = class {
     if (opts.usePolling) {
       const enableBin = opts.interval !== opts.binaryInterval;
       options2.interval = enableBin && isBinaryPath(basename3) ? opts.binaryInterval : opts.interval;
-      closer = setFsWatchFileListener(path22, absolutePath, options2, {
+      closer = setFsWatchFileListener(path23, absolutePath, options2, {
         listener,
         rawEmitter: this.fsw._emitRaw
       });
     } else {
-      closer = setFsWatchListener(path22, absolutePath, options2, {
+      closer = setFsWatchListener(path23, absolutePath, options2, {
         listener,
         errHandler: this._boundHandleError,
         rawEmitter: this.fsw._emitRaw
@@ -89498,7 +89498,7 @@ var NodeFsHandler = class {
     let prevStats = stats;
     if (parent.has(basename3))
       return;
-    const listener = async (path22, newStats) => {
+    const listener = async (path23, newStats) => {
       if (!this.fsw._throttle(THROTTLE_MODE_WATCH, file, 5))
         return;
       if (!newStats || newStats.mtimeMs === 0) {
@@ -89512,11 +89512,11 @@ var NodeFsHandler = class {
             this.fsw._emit(EV.CHANGE, file, newStats2);
           }
           if ((isMacos || isLinux || isFreeBSD) && prevStats.ino !== newStats2.ino) {
-            this.fsw._closeFile(path22);
+            this.fsw._closeFile(path23);
             prevStats = newStats2;
             const closer2 = this._watchWithNodeFs(file, listener);
             if (closer2)
-              this.fsw._addPathCloser(path22, closer2);
+              this.fsw._addPathCloser(path23, closer2);
           } else {
             prevStats = newStats2;
           }
@@ -89548,7 +89548,7 @@ var NodeFsHandler = class {
    * @param item basename of this item
    * @returns true if no more processing is needed for this entry.
    */
-  async _handleSymlink(entry, directory, path22, item) {
+  async _handleSymlink(entry, directory, path23, item) {
     if (this.fsw.closed) {
       return;
     }
@@ -89558,7 +89558,7 @@ var NodeFsHandler = class {
       this.fsw._incrReadyCount();
       let linkPath;
       try {
-        linkPath = await fsrealpath(path22);
+        linkPath = await fsrealpath(path23);
       } catch (e) {
         this.fsw._emitReady();
         return true;
@@ -89568,12 +89568,12 @@ var NodeFsHandler = class {
       if (dir.has(item)) {
         if (this.fsw._symlinkPaths.get(full) !== linkPath) {
           this.fsw._symlinkPaths.set(full, linkPath);
-          this.fsw._emit(EV.CHANGE, path22, entry.stats);
+          this.fsw._emit(EV.CHANGE, path23, entry.stats);
         }
       } else {
         dir.add(item);
         this.fsw._symlinkPaths.set(full, linkPath);
-        this.fsw._emit(EV.ADD, path22, entry.stats);
+        this.fsw._emit(EV.ADD, path23, entry.stats);
       }
       this.fsw._emitReady();
       return true;
@@ -89603,9 +89603,9 @@ var NodeFsHandler = class {
         return;
       }
       const item = entry.path;
-      let path22 = sp.join(directory, item);
+      let path23 = sp.join(directory, item);
       current.add(item);
-      if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path22, item)) {
+      if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path23, item)) {
         return;
       }
       if (this.fsw.closed) {
@@ -89614,8 +89614,8 @@ var NodeFsHandler = class {
       }
       if (item === target || !target && !previous.has(item)) {
         this.fsw._incrReadyCount();
-        path22 = sp.join(dir, sp.relative(dir, path22));
-        this._addToNodeFs(path22, initialAdd, wh, depth + 1);
+        path23 = sp.join(dir, sp.relative(dir, path23));
+        this._addToNodeFs(path23, initialAdd, wh, depth + 1);
       }
     }).on(EV.ERROR, this._boundHandleError);
     return new Promise((resolve3, reject) => {
@@ -89684,13 +89684,13 @@ var NodeFsHandler = class {
    * @param depth Child path actually targeted for watch
    * @param target Child path actually targeted for watch
    */
-  async _addToNodeFs(path22, initialAdd, priorWh, depth, target) {
+  async _addToNodeFs(path23, initialAdd, priorWh, depth, target) {
     const ready = this.fsw._emitReady;
-    if (this.fsw._isIgnored(path22) || this.fsw.closed) {
+    if (this.fsw._isIgnored(path23) || this.fsw.closed) {
       ready();
       return false;
     }
-    const wh = this.fsw._getWatchHelpers(path22);
+    const wh = this.fsw._getWatchHelpers(path23);
     if (priorWh) {
       wh.filterPath = (entry) => priorWh.filterPath(entry);
       wh.filterDir = (entry) => priorWh.filterDir(entry);
@@ -89706,8 +89706,8 @@ var NodeFsHandler = class {
       const follow = this.fsw.options.followSymlinks;
       let closer;
       if (stats.isDirectory()) {
-        const absPath = sp.resolve(path22);
-        const targetPath = follow ? await fsrealpath(path22) : path22;
+        const absPath = sp.resolve(path23);
+        const targetPath = follow ? await fsrealpath(path23) : path23;
         if (this.fsw.closed)
           return;
         closer = await this._handleDir(wh.watchPath, stats, initialAdd, depth, target, wh, targetPath);
@@ -89717,29 +89717,29 @@ var NodeFsHandler = class {
           this.fsw._symlinkPaths.set(absPath, targetPath);
         }
       } else if (stats.isSymbolicLink()) {
-        const targetPath = follow ? await fsrealpath(path22) : path22;
+        const targetPath = follow ? await fsrealpath(path23) : path23;
         if (this.fsw.closed)
           return;
         const parent = sp.dirname(wh.watchPath);
         this.fsw._getWatchedDir(parent).add(wh.watchPath);
         this.fsw._emit(EV.ADD, wh.watchPath, stats);
-        closer = await this._handleDir(parent, stats, initialAdd, depth, path22, wh, targetPath);
+        closer = await this._handleDir(parent, stats, initialAdd, depth, path23, wh, targetPath);
         if (this.fsw.closed)
           return;
         if (targetPath !== void 0) {
-          this.fsw._symlinkPaths.set(sp.resolve(path22), targetPath);
+          this.fsw._symlinkPaths.set(sp.resolve(path23), targetPath);
         }
       } else {
         closer = this._handleFile(wh.watchPath, stats, initialAdd);
       }
       ready();
       if (closer)
-        this.fsw._addPathCloser(path22, closer);
+        this.fsw._addPathCloser(path23, closer);
       return false;
     } catch (error) {
       if (this.fsw._handleError(error)) {
         ready();
-        return path22;
+        return path23;
       }
     }
   }
@@ -89782,24 +89782,24 @@ function createPattern(matcher) {
   }
   return () => false;
 }
-function normalizePath(path22) {
-  if (typeof path22 !== "string")
+function normalizePath(path23) {
+  if (typeof path23 !== "string")
     throw new Error("string expected");
-  path22 = sp2.normalize(path22);
-  path22 = path22.replace(/\\/g, "/");
+  path23 = sp2.normalize(path23);
+  path23 = path23.replace(/\\/g, "/");
   let prepend = false;
-  if (path22.startsWith("//"))
+  if (path23.startsWith("//"))
     prepend = true;
-  path22 = path22.replace(DOUBLE_SLASH_RE, "/");
+  path23 = path23.replace(DOUBLE_SLASH_RE, "/");
   if (prepend)
-    path22 = "/" + path22;
-  return path22;
+    path23 = "/" + path23;
+  return path23;
 }
 function matchPatterns(patterns, testString, stats) {
-  const path22 = normalizePath(testString);
+  const path23 = normalizePath(testString);
   for (let index = 0; index < patterns.length; index++) {
     const pattern = patterns[index];
-    if (pattern(path22, stats)) {
+    if (pattern(path23, stats)) {
       return true;
     }
   }
@@ -89837,19 +89837,19 @@ var toUnix = (string) => {
   }
   return str;
 };
-var normalizePathToUnix = (path22) => toUnix(sp2.normalize(toUnix(path22)));
-var normalizeIgnored = (cwd = "") => (path22) => {
-  if (typeof path22 === "string") {
-    return normalizePathToUnix(sp2.isAbsolute(path22) ? path22 : sp2.join(cwd, path22));
+var normalizePathToUnix = (path23) => toUnix(sp2.normalize(toUnix(path23)));
+var normalizeIgnored = (cwd = "") => (path23) => {
+  if (typeof path23 === "string") {
+    return normalizePathToUnix(sp2.isAbsolute(path23) ? path23 : sp2.join(cwd, path23));
   } else {
-    return path22;
+    return path23;
   }
 };
-var getAbsolutePath = (path22, cwd) => {
-  if (sp2.isAbsolute(path22)) {
-    return path22;
+var getAbsolutePath = (path23, cwd) => {
+  if (sp2.isAbsolute(path23)) {
+    return path23;
   }
-  return sp2.join(cwd, path22);
+  return sp2.join(cwd, path23);
 };
 var EMPTY_SET = Object.freeze(/* @__PURE__ */ new Set());
 var DirEntry = class {
@@ -89914,10 +89914,10 @@ var WatchHelper = class {
   dirParts;
   followSymlinks;
   statMethod;
-  constructor(path22, follow, fsw) {
+  constructor(path23, follow, fsw) {
     this.fsw = fsw;
-    const watchPath = path22;
-    this.path = path22 = path22.replace(REPLACER_RE, "");
+    const watchPath = path23;
+    this.path = path23 = path23.replace(REPLACER_RE, "");
     this.watchPath = watchPath;
     this.fullWatchPath = sp2.resolve(watchPath);
     this.dirParts = [];
@@ -90057,20 +90057,20 @@ var FSWatcher = class extends EventEmitter2 {
     this._closePromise = void 0;
     let paths = unifyPaths(paths_);
     if (cwd) {
-      paths = paths.map((path22) => {
-        const absPath = getAbsolutePath(path22, cwd);
+      paths = paths.map((path23) => {
+        const absPath = getAbsolutePath(path23, cwd);
         return absPath;
       });
     }
-    paths.forEach((path22) => {
-      this._removeIgnoredPath(path22);
+    paths.forEach((path23) => {
+      this._removeIgnoredPath(path23);
     });
     this._userIgnored = void 0;
     if (!this._readyCount)
       this._readyCount = 0;
     this._readyCount += paths.length;
-    Promise.all(paths.map(async (path22) => {
-      const res = await this._nodeFsHandler._addToNodeFs(path22, !_internal, void 0, 0, _origAdd);
+    Promise.all(paths.map(async (path23) => {
+      const res = await this._nodeFsHandler._addToNodeFs(path23, !_internal, void 0, 0, _origAdd);
       if (res)
         this._emitReady();
       return res;
@@ -90092,17 +90092,17 @@ var FSWatcher = class extends EventEmitter2 {
       return this;
     const paths = unifyPaths(paths_);
     const { cwd } = this.options;
-    paths.forEach((path22) => {
-      if (!sp2.isAbsolute(path22) && !this._closers.has(path22)) {
+    paths.forEach((path23) => {
+      if (!sp2.isAbsolute(path23) && !this._closers.has(path23)) {
         if (cwd)
-          path22 = sp2.join(cwd, path22);
-        path22 = sp2.resolve(path22);
+          path23 = sp2.join(cwd, path23);
+        path23 = sp2.resolve(path23);
       }
-      this._closePath(path22);
-      this._addIgnoredPath(path22);
-      if (this._watched.has(path22)) {
+      this._closePath(path23);
+      this._addIgnoredPath(path23);
+      if (this._watched.has(path23)) {
         this._addIgnoredPath({
-          path: path22,
+          path: path23,
           recursive: true
         });
       }
@@ -90166,38 +90166,38 @@ var FSWatcher = class extends EventEmitter2 {
    * @param stats arguments to be passed with event
    * @returns the error if defined, otherwise the value of the FSWatcher instance's `closed` flag
    */
-  async _emit(event, path22, stats) {
+  async _emit(event, path23, stats) {
     if (this.closed)
       return;
     const opts = this.options;
     if (isWindows)
-      path22 = sp2.normalize(path22);
+      path23 = sp2.normalize(path23);
     if (opts.cwd)
-      path22 = sp2.relative(opts.cwd, path22);
-    const args = [path22];
+      path23 = sp2.relative(opts.cwd, path23);
+    const args = [path23];
     if (stats != null)
       args.push(stats);
     const awf = opts.awaitWriteFinish;
     let pw;
-    if (awf && (pw = this._pendingWrites.get(path22))) {
+    if (awf && (pw = this._pendingWrites.get(path23))) {
       pw.lastChange = /* @__PURE__ */ new Date();
       return this;
     }
     if (opts.atomic) {
       if (event === EVENTS.UNLINK) {
-        this._pendingUnlinks.set(path22, [event, ...args]);
+        this._pendingUnlinks.set(path23, [event, ...args]);
         setTimeout(() => {
-          this._pendingUnlinks.forEach((entry, path23) => {
+          this._pendingUnlinks.forEach((entry, path24) => {
             this.emit(...entry);
             this.emit(EVENTS.ALL, ...entry);
-            this._pendingUnlinks.delete(path23);
+            this._pendingUnlinks.delete(path24);
           });
         }, typeof opts.atomic === "number" ? opts.atomic : 100);
         return this;
       }
-      if (event === EVENTS.ADD && this._pendingUnlinks.has(path22)) {
+      if (event === EVENTS.ADD && this._pendingUnlinks.has(path23)) {
         event = EVENTS.CHANGE;
-        this._pendingUnlinks.delete(path22);
+        this._pendingUnlinks.delete(path23);
       }
     }
     if (awf && (event === EVENTS.ADD || event === EVENTS.CHANGE) && this._readyEmitted) {
@@ -90215,16 +90215,16 @@ var FSWatcher = class extends EventEmitter2 {
           this.emitWithAll(event, args);
         }
       };
-      this._awaitWriteFinish(path22, awf.stabilityThreshold, event, awfEmit);
+      this._awaitWriteFinish(path23, awf.stabilityThreshold, event, awfEmit);
       return this;
     }
     if (event === EVENTS.CHANGE) {
-      const isThrottled = !this._throttle(EVENTS.CHANGE, path22, 50);
+      const isThrottled = !this._throttle(EVENTS.CHANGE, path23, 50);
       if (isThrottled)
         return this;
     }
     if (opts.alwaysStat && stats === void 0 && (event === EVENTS.ADD || event === EVENTS.ADD_DIR || event === EVENTS.CHANGE)) {
-      const fullPath = opts.cwd ? sp2.join(opts.cwd, path22) : path22;
+      const fullPath = opts.cwd ? sp2.join(opts.cwd, path23) : path23;
       let stats2;
       try {
         stats2 = await stat3(fullPath);
@@ -90255,23 +90255,23 @@ var FSWatcher = class extends EventEmitter2 {
    * @param timeout duration of time to suppress duplicate actions
    * @returns tracking object or false if action should be suppressed
    */
-  _throttle(actionType, path22, timeout) {
+  _throttle(actionType, path23, timeout) {
     if (!this._throttled.has(actionType)) {
       this._throttled.set(actionType, /* @__PURE__ */ new Map());
     }
     const action = this._throttled.get(actionType);
     if (!action)
       throw new Error("invalid throttle");
-    const actionPath = action.get(path22);
+    const actionPath = action.get(path23);
     if (actionPath) {
       actionPath.count++;
       return false;
     }
     let timeoutObject;
     const clear = () => {
-      const item = action.get(path22);
+      const item = action.get(path23);
       const count2 = item ? item.count : 0;
-      action.delete(path22);
+      action.delete(path23);
       clearTimeout(timeoutObject);
       if (item)
         clearTimeout(item.timeoutObject);
@@ -90279,7 +90279,7 @@ var FSWatcher = class extends EventEmitter2 {
     };
     timeoutObject = setTimeout(clear, timeout);
     const thr = { timeoutObject, clear, count: 0 };
-    action.set(path22, thr);
+    action.set(path23, thr);
     return thr;
   }
   _incrReadyCount() {
@@ -90293,44 +90293,44 @@ var FSWatcher = class extends EventEmitter2 {
    * @param event
    * @param awfEmit Callback to be called when ready for event to be emitted.
    */
-  _awaitWriteFinish(path22, threshold, event, awfEmit) {
+  _awaitWriteFinish(path23, threshold, event, awfEmit) {
     const awf = this.options.awaitWriteFinish;
     if (typeof awf !== "object")
       return;
     const pollInterval = awf.pollInterval;
     let timeoutHandler;
-    let fullPath = path22;
-    if (this.options.cwd && !sp2.isAbsolute(path22)) {
-      fullPath = sp2.join(this.options.cwd, path22);
+    let fullPath = path23;
+    if (this.options.cwd && !sp2.isAbsolute(path23)) {
+      fullPath = sp2.join(this.options.cwd, path23);
     }
     const now = /* @__PURE__ */ new Date();
     const writes = this._pendingWrites;
     function awaitWriteFinishFn(prevStat) {
       statcb(fullPath, (err, curStat) => {
-        if (err || !writes.has(path22)) {
+        if (err || !writes.has(path23)) {
           if (err && err.code !== "ENOENT")
             awfEmit(err);
           return;
         }
         const now2 = Number(/* @__PURE__ */ new Date());
         if (prevStat && curStat.size !== prevStat.size) {
-          writes.get(path22).lastChange = now2;
+          writes.get(path23).lastChange = now2;
         }
-        const pw = writes.get(path22);
+        const pw = writes.get(path23);
         const df = now2 - pw.lastChange;
         if (df >= threshold) {
-          writes.delete(path22);
+          writes.delete(path23);
           awfEmit(void 0, curStat);
         } else {
           timeoutHandler = setTimeout(awaitWriteFinishFn, pollInterval, curStat);
         }
       });
     }
-    if (!writes.has(path22)) {
-      writes.set(path22, {
+    if (!writes.has(path23)) {
+      writes.set(path23, {
         lastChange: now,
         cancelWait: () => {
-          writes.delete(path22);
+          writes.delete(path23);
           clearTimeout(timeoutHandler);
           return event;
         }
@@ -90341,8 +90341,8 @@ var FSWatcher = class extends EventEmitter2 {
   /**
    * Determines whether user has asked to ignore this path.
    */
-  _isIgnored(path22, stats) {
-    if (this.options.atomic && DOT_RE.test(path22))
+  _isIgnored(path23, stats) {
+    if (this.options.atomic && DOT_RE.test(path23))
       return true;
     if (!this._userIgnored) {
       const { cwd } = this.options;
@@ -90352,17 +90352,17 @@ var FSWatcher = class extends EventEmitter2 {
       const list3 = [...ignoredPaths.map(normalizeIgnored(cwd)), ...ignored];
       this._userIgnored = anymatch(list3, void 0);
     }
-    return this._userIgnored(path22, stats);
+    return this._userIgnored(path23, stats);
   }
-  _isntIgnored(path22, stat4) {
-    return !this._isIgnored(path22, stat4);
+  _isntIgnored(path23, stat4) {
+    return !this._isIgnored(path23, stat4);
   }
   /**
    * Provides a set of common helpers and properties relating to symlink handling.
    * @param path file or directory pattern being watched
    */
-  _getWatchHelpers(path22) {
-    return new WatchHelper(path22, this.options.followSymlinks, this);
+  _getWatchHelpers(path23) {
+    return new WatchHelper(path23, this.options.followSymlinks, this);
   }
   // Directory helpers
   // -----------------
@@ -90394,63 +90394,63 @@ var FSWatcher = class extends EventEmitter2 {
    * @param item      base path of item/directory
    */
   _remove(directory, item, isDirectory) {
-    const path22 = sp2.join(directory, item);
-    const fullPath = sp2.resolve(path22);
-    isDirectory = isDirectory != null ? isDirectory : this._watched.has(path22) || this._watched.has(fullPath);
-    if (!this._throttle("remove", path22, 100))
+    const path23 = sp2.join(directory, item);
+    const fullPath = sp2.resolve(path23);
+    isDirectory = isDirectory != null ? isDirectory : this._watched.has(path23) || this._watched.has(fullPath);
+    if (!this._throttle("remove", path23, 100))
       return;
     if (!isDirectory && this._watched.size === 1) {
       this.add(directory, item, true);
     }
-    const wp = this._getWatchedDir(path22);
+    const wp = this._getWatchedDir(path23);
     const nestedDirectoryChildren = wp.getChildren();
-    nestedDirectoryChildren.forEach((nested) => this._remove(path22, nested));
+    nestedDirectoryChildren.forEach((nested) => this._remove(path23, nested));
     const parent = this._getWatchedDir(directory);
     const wasTracked = parent.has(item);
     parent.remove(item);
     if (this._symlinkPaths.has(fullPath)) {
       this._symlinkPaths.delete(fullPath);
     }
-    let relPath = path22;
+    let relPath = path23;
     if (this.options.cwd)
-      relPath = sp2.relative(this.options.cwd, path22);
+      relPath = sp2.relative(this.options.cwd, path23);
     if (this.options.awaitWriteFinish && this._pendingWrites.has(relPath)) {
       const event = this._pendingWrites.get(relPath).cancelWait();
       if (event === EVENTS.ADD)
         return;
     }
-    this._watched.delete(path22);
+    this._watched.delete(path23);
     this._watched.delete(fullPath);
     const eventName = isDirectory ? EVENTS.UNLINK_DIR : EVENTS.UNLINK;
-    if (wasTracked && !this._isIgnored(path22))
-      this._emit(eventName, path22);
-    this._closePath(path22);
+    if (wasTracked && !this._isIgnored(path23))
+      this._emit(eventName, path23);
+    this._closePath(path23);
   }
   /**
    * Closes all watchers for a path
    */
-  _closePath(path22) {
-    this._closeFile(path22);
-    const dir = sp2.dirname(path22);
-    this._getWatchedDir(dir).remove(sp2.basename(path22));
+  _closePath(path23) {
+    this._closeFile(path23);
+    const dir = sp2.dirname(path23);
+    this._getWatchedDir(dir).remove(sp2.basename(path23));
   }
   /**
    * Closes only file-specific watchers
    */
-  _closeFile(path22) {
-    const closers = this._closers.get(path22);
+  _closeFile(path23) {
+    const closers = this._closers.get(path23);
     if (!closers)
       return;
     closers.forEach((closer) => closer());
-    this._closers.delete(path22);
+    this._closers.delete(path23);
   }
-  _addPathCloser(path22, closer) {
+  _addPathCloser(path23, closer) {
     if (!closer)
       return;
-    let list3 = this._closers.get(path22);
+    let list3 = this._closers.get(path23);
     if (!list3) {
       list3 = [];
-      this._closers.set(path22, list3);
+      this._closers.set(path23, list3);
     }
     list3.push(closer);
   }
@@ -92385,7 +92385,9 @@ function validateMountManifest(filePath, raw) {
     if (typeof m["hostPath"] !== "string") {
       throw new MountManifestError(filePath, `mounts[${i2}].hostPath must be a string`);
     }
-    if (typeof m["containerPath"] !== "string") {
+    const kind = m["kind"];
+    const isSymlinkOnly = kind === "symlink-only";
+    if (!isSymlinkOnly && typeof m["containerPath"] !== "string") {
       throw new MountManifestError(filePath, `mounts[${i2}].containerPath must be a string`);
     }
   }
@@ -92711,9 +92713,7 @@ async function pickMounts(candidates) {
       candidates.map((c3) => c3.containerPath).filter((p) => typeof p === "string" && p.length > 0)
     )
   );
-  const knownHostPaths = Array.from(
-    new Set(candidates.flatMap((c3) => c3.alternativeSources ?? []))
-  );
+  const knownHostPaths = Array.from(new Set(candidates.flatMap((c3) => c3.alternativeSources ?? [])));
   while (await confirm({
     message: candidates.length === 0 ? "Add a custom mount?" : "Add another (custom) mount?",
     default: false
@@ -93147,6 +93147,75 @@ function findHostClones(opts) {
   }
   return found;
 }
+
+// src/mount/health-check.ts
+import path22 from "node:path";
+var DEFAULT_REMEDIATION = {
+  key: "F",
+  label: "mount apply",
+  command: "dev-cockpit mount"
+};
+function createMountBrokenSymlinkCheck(opts) {
+  const id = opts.id ?? "mount-broken-symlink";
+  const label = opts.label ?? "Mount symlinks";
+  const severity = opts.severity ?? "error";
+  const triggers = opts.triggers ?? ["startup", "fsevent"];
+  const remediation = opts.remediation ?? DEFAULT_REMEDIATION;
+  const remediationKey = remediation.key;
+  const predicate = async (ctx) => {
+    const { workspaceRoot } = ctx;
+    let manifestPath2;
+    try {
+      const { configPath } = discoverConfig({
+        workspaceDiscoverer: () => ({ root: workspaceRoot })
+      });
+      const config = loadConfig(configPath);
+      const paths = getStatePaths(workspaceRoot, { appName: config.appName });
+      manifestPath2 = path22.join(paths.stateDir, config.mount.manifestFile);
+    } catch (err) {
+      if (err instanceof DiscoveryError) {
+        return { id, label, severity: "ok", detail: "no cockpit.yaml found", remediationKey };
+      }
+      throw err;
+    }
+    let mounts;
+    try {
+      const manifest = readMountManifest(manifestPath2);
+      mounts = manifest?.mounts ?? [];
+    } catch {
+      return {
+        id,
+        label,
+        severity: "warn",
+        detail: "mount manifest could not be read",
+        remediationKey
+      };
+    }
+    if (mounts.length === 0) {
+      return { id, label, severity: "ok", detail: "no active mounts", remediationKey };
+    }
+    const broken = detectBrokenSymlinks(workspaceRoot, mounts, opts.symlinks);
+    if (broken.length === 0) {
+      return {
+        id,
+        label,
+        severity: "ok",
+        detail: `${mounts.length} symlink(s) healthy`,
+        remediationKey
+      };
+    }
+    const namesFor = (reason) => broken.filter((b) => b.reason === reason).map(
+      (b) => b.mount.meta?.["name"] ?? b.mount.containerPath ?? b.mount.hostPath
+    ).join(", ");
+    const parts = [];
+    const brokenNames = namesFor("broken");
+    const missingNames = namesFor("missing");
+    if (brokenNames) parts.push(`broken (target missing): ${brokenNames}`);
+    if (missingNames) parts.push(`not applied (no symlink): ${missingNames}`);
+    return { id, label, severity, detail: parts.join("; "), remediationKey };
+  };
+  return { id, label, severity, triggers, predicate, remediation };
+}
 export {
   BUILTIN_CHECK_FACTORIES,
   BUILTIN_DEFAULT_SEVERITY,
@@ -93188,6 +93257,7 @@ export {
   cockpitStore,
   compileHighlights,
   createLogger,
+  createMountBrokenSymlinkCheck,
   deleteMountManifest,
   detectBrokenSymlinks,
   detectTransitions,