dev-cockpit 0.2.2 → 0.2.3

package/dist/index.js

@@ -290,8 +290,8 @@ var require_req = __commonJS({
       if (req.originalUrl) {
         _req.url = req.originalUrl;
       } else {
-        const path21 = req.path;
-        _req.url = typeof path21 === "string" ? path21 : req.url ? req.url.path || req.url : void 0;
+        const path22 = req.path;
+        _req.url = typeof path22 === "string" ? path22 : req.url ? req.url.path || req.url : void 0;
       }
       if (req.query) {
         _req.query = req.query;
@@ -456,14 +456,14 @@ var require_redact = __commonJS({
       }
       return obj;
     }
-    function parsePath(path21) {
+    function parsePath(path22) {
       const parts = [];
       let current = "";
       let inBrackets = false;
       let inQuotes = false;
       let quoteChar = "";
-      for (let i2 = 0; i2 < path21.length; i2++) {
-        const char = path21[i2];
+      for (let i2 = 0; i2 < path22.length; i2++) {
+        const char = path22[i2];
         if (!inBrackets && char === ".") {
           if (current) {
             parts.push(current);
@@ -594,10 +594,10 @@ var require_redact = __commonJS({
       return current;
     }
     function redactPaths(obj, paths, censor, remove = false) {
-      for (const path21 of paths) {
-        const parts = parsePath(path21);
+      for (const path22 of paths) {
+        const parts = parsePath(path22);
         if (parts.includes("*")) {
-          redactWildcardPath(obj, parts, censor, path21, remove);
+          redactWildcardPath(obj, parts, censor, path22, remove);
         } else {
           if (remove) {
             removeKey(obj, parts);
@@ -682,8 +682,8 @@ var require_redact = __commonJS({
           }
         } else {
           if (afterWildcard.includes("*")) {
-            const wrappedCensor = typeof censor === "function" ? (value, path21) => {
-              const fullPath = [...pathArray.slice(0, pathLength), ...path21];
+            const wrappedCensor = typeof censor === "function" ? (value, path22) => {
+              const fullPath = [...pathArray.slice(0, pathLength), ...path22];
               return censor(value, fullPath);
             } : censor;
             redactWildcardPath(current, afterWildcard, wrappedCensor, originalPath, remove);
@@ -718,8 +718,8 @@ var require_redact = __commonJS({
         return null;
       }
       const pathStructure = /* @__PURE__ */ new Map();
-      for (const path21 of pathsToClone) {
-        const parts = parsePath(path21);
+      for (const path22 of pathsToClone) {
+        const parts = parsePath(path22);
         let current = pathStructure;
         for (let i2 = 0; i2 < parts.length; i2++) {
           const part = parts[i2];
@@ -771,24 +771,24 @@ var require_redact = __commonJS({
       }
       return cloneSelectively(obj, pathStructure);
     }
-    function validatePath(path21) {
-      if (typeof path21 !== "string") {
+    function validatePath(path22) {
+      if (typeof path22 !== "string") {
         throw new Error("Paths must be (non-empty) strings");
       }
-      if (path21 === "") {
+      if (path22 === "") {
         throw new Error("Invalid redaction path ()");
       }
-      if (path21.includes("..")) {
-        throw new Error(`Invalid redaction path (${path21})`);
+      if (path22.includes("..")) {
+        throw new Error(`Invalid redaction path (${path22})`);
       }
-      if (path21.includes(",")) {
-        throw new Error(`Invalid redaction path (${path21})`);
+      if (path22.includes(",")) {
+        throw new Error(`Invalid redaction path (${path22})`);
       }
       let bracketCount = 0;
       let inQuotes = false;
       let quoteChar = "";
-      for (let i2 = 0; i2 < path21.length; i2++) {
-        const char = path21[i2];
+      for (let i2 = 0; i2 < path22.length; i2++) {
+        const char = path22[i2];
         if ((char === '"' || char === "'") && bracketCount > 0) {
           if (!inQuotes) {
             inQuotes = true;
@@ -802,20 +802,20 @@ var require_redact = __commonJS({
         } else if (char === "]" && !inQuotes) {
           bracketCount--;
           if (bracketCount < 0) {
-            throw new Error(`Invalid redaction path (${path21})`);
+            throw new Error(`Invalid redaction path (${path22})`);
           }
         }
       }
       if (bracketCount !== 0) {
-        throw new Error(`Invalid redaction path (${path21})`);
+        throw new Error(`Invalid redaction path (${path22})`);
       }
     }
     function validatePaths(paths) {
       if (!Array.isArray(paths)) {
         throw new TypeError("paths must be an array");
       }
-      for (const path21 of paths) {
-        validatePath(path21);
+      for (const path22 of paths) {
+        validatePath(path22);
       }
     }
     function slowRedact(options2 = {}) {
@@ -983,8 +983,8 @@ var require_redaction = __commonJS({
         if (shape[k] === null) {
           o2[k] = (value) => topCensor(value, [k]);
         } else {
-          const wrappedCensor = typeof censor === "function" ? (value, path21) => {
-            return censor(value, [k, ...path21]);
+          const wrappedCensor = typeof censor === "function" ? (value, path22) => {
+            return censor(value, [k, ...path22]);
           } : censor;
           o2[k] = Redact({
             paths: shape[k],
@@ -1205,7 +1205,7 @@ var require_sonic_boom = __commonJS({
     var fs18 = __require("fs");
     var EventEmitter3 = __require("events");
     var inherits = __require("util").inherits;
-    var path21 = __require("path");
+    var path22 = __require("path");
     var sleep = require_atomic_sleep();
     var assert = __require("assert");
     var BUSY_WRITE_TIMEOUT = 100;
@@ -1259,7 +1259,7 @@ var require_sonic_boom = __commonJS({
       const mode = sonic.mode;
       if (sonic.sync) {
         try {
-          if (sonic.mkdir) fs18.mkdirSync(path21.dirname(file), { recursive: true });
+          if (sonic.mkdir) fs18.mkdirSync(path22.dirname(file), { recursive: true });
           const fd = fs18.openSync(file, flags, mode);
           fileOpened(null, fd);
         } catch (err) {
@@ -1267,7 +1267,7 @@ var require_sonic_boom = __commonJS({
           throw err;
         }
       } else if (sonic.mkdir) {
-        fs18.mkdir(path21.dirname(file), { recursive: true }, (err) => {
+        fs18.mkdir(path22.dirname(file), { recursive: true }, (err) => {
           if (err) return fileOpened(err);
           fs18.open(file, flags, mode, fileOpened);
         });
@@ -4338,7 +4338,7 @@ var require_windows = __commonJS({
     module.exports = isexe;
     isexe.sync = sync;
     var fs18 = __require("fs");
-    function checkPathExt(path21, options2) {
+    function checkPathExt(path22, options2) {
       var pathext = options2.pathExt !== void 0 ? options2.pathExt : process.env.PATHEXT;
       if (!pathext) {
         return true;
@@ -4349,25 +4349,25 @@ var require_windows = __commonJS({
       }
       for (var i2 = 0; i2 < pathext.length; i2++) {
         var p = pathext[i2].toLowerCase();
-        if (p && path21.substr(-p.length).toLowerCase() === p) {
+        if (p && path22.substr(-p.length).toLowerCase() === p) {
           return true;
         }
       }
       return false;
     }
-    function checkStat(stat4, path21, options2) {
+    function checkStat(stat4, path22, options2) {
       if (!stat4.isSymbolicLink() && !stat4.isFile()) {
         return false;
       }
-      return checkPathExt(path21, options2);
+      return checkPathExt(path22, options2);
     }
-    function isexe(path21, options2, cb) {
-      fs18.stat(path21, function(er, stat4) {
-        cb(er, er ? false : checkStat(stat4, path21, options2));
+    function isexe(path22, options2, cb) {
+      fs18.stat(path22, function(er, stat4) {
+        cb(er, er ? false : checkStat(stat4, path22, options2));
       });
     }
-    function sync(path21, options2) {
-      return checkStat(fs18.statSync(path21), path21, options2);
+    function sync(path22, options2) {
+      return checkStat(fs18.statSync(path22), path22, options2);
     }
   }
 });
@@ -4378,13 +4378,13 @@ var require_mode = __commonJS({
     module.exports = isexe;
     isexe.sync = sync;
     var fs18 = __require("fs");
-    function isexe(path21, options2, cb) {
-      fs18.stat(path21, function(er, stat4) {
+    function isexe(path22, options2, cb) {
+      fs18.stat(path22, function(er, stat4) {
         cb(er, er ? false : checkStat(stat4, options2));
       });
     }
-    function sync(path21, options2) {
-      return checkStat(fs18.statSync(path21), options2);
+    function sync(path22, options2) {
+      return checkStat(fs18.statSync(path22), options2);
     }
     function checkStat(stat4, options2) {
       return stat4.isFile() && checkMode(stat4, options2);
@@ -4417,7 +4417,7 @@ var require_isexe = __commonJS({
     }
     module.exports = isexe;
     isexe.sync = sync;
-    function isexe(path21, options2, cb) {
+    function isexe(path22, options2, cb) {
       if (typeof options2 === "function") {
         cb = options2;
         options2 = {};
@@ -4427,7 +4427,7 @@ var require_isexe = __commonJS({
           throw new TypeError("callback not provided");
         }
         return new Promise(function(resolve3, reject) {
-          isexe(path21, options2 || {}, function(er, is) {
+          isexe(path22, options2 || {}, function(er, is) {
             if (er) {
               reject(er);
             } else {
@@ -4436,7 +4436,7 @@ var require_isexe = __commonJS({
           });
         });
       }
-      core(path21, options2 || {}, function(er, is) {
+      core(path22, options2 || {}, function(er, is) {
         if (er) {
           if (er.code === "EACCES" || options2 && options2.ignoreErrors) {
             er = null;
@@ -4446,9 +4446,9 @@ var require_isexe = __commonJS({
         cb(er, is);
       });
     }
-    function sync(path21, options2) {
+    function sync(path22, options2) {
       try {
-        return core.sync(path21, options2 || {});
+        return core.sync(path22, options2 || {});
       } catch (er) {
         if (options2 && options2.ignoreErrors || er.code === "EACCES") {
           return false;
@@ -4464,7 +4464,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 path21 = __require("path");
+    var path22 = __require("path");
     var COLON = isWindows2 ? ";" : ":";
     var isexe = require_isexe();
     var getNotFoundError = (cmd) => Object.assign(new Error(`not found: ${cmd}`), { code: "ENOENT" });
@@ -4502,7 +4502,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 = path21.join(pathPart, cmd);
+        const pCmd = path22.join(pathPart, cmd);
         const p = !pathPart && /^\.[\\\/]/.test(cmd) ? cmd.slice(0, 2) + pCmd : pCmd;
         resolve3(subStep(p, i2, 0));
       });
@@ -4529,7 +4529,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 = path21.join(pathPart, cmd);
+        const pCmd = path22.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];
@@ -4577,7 +4577,7 @@ var require_path_key = __commonJS({
 var require_resolveCommand = __commonJS({
   "node_modules/cross-spawn/lib/util/resolveCommand.js"(exports, module) {
     "use strict";
-    var path21 = __require("path");
+    var path22 = __require("path");
     var which = require_which();
     var getPathKey = require_path_key();
     function resolveCommandAttempt(parsed, withoutPathExt) {
@@ -4595,7 +4595,7 @@ var require_resolveCommand = __commonJS({
       try {
         resolved = which.sync(parsed.command, {
           path: env[getPathKey({ env })],
-          pathExt: withoutPathExt ? path21.delimiter : void 0
+          pathExt: withoutPathExt ? path22.delimiter : void 0
         });
       } catch (e) {
       } finally {
@@ -4604,7 +4604,7 @@ var require_resolveCommand = __commonJS({
         }
       }
       if (resolved) {
-        resolved = path21.resolve(hasCustomCwd ? parsed.options.cwd : "", resolved);
+        resolved = path22.resolve(hasCustomCwd ? parsed.options.cwd : "", resolved);
       }
       return resolved;
     }
@@ -4658,8 +4658,8 @@ var require_shebang_command = __commonJS({
       if (!match) {
         return null;
       }
-      const [path21, argument] = match[0].replace(/#! ?/, "").split(" ");
-      const binary = path21.split("/").pop();
+      const [path22, argument] = match[0].replace(/#! ?/, "").split(" ");
+      const binary = path22.split("/").pop();
       if (binary === "env") {
         return argument;
       }
@@ -4694,7 +4694,7 @@ var require_readShebang = __commonJS({
 var require_parse = __commonJS({
   "node_modules/cross-spawn/lib/parse.js"(exports, module) {
     "use strict";
-    var path21 = __require("path");
+    var path22 = __require("path");
     var resolveCommand = require_resolveCommand();
     var escape3 = require_escape();
     var readShebang = require_readShebang();
@@ -4719,7 +4719,7 @@ var require_parse = __commonJS({
       const needsShell = !isExecutableRegExp.test(commandFile);
       if (parsed.options.forceShell || needsShell) {
         const needsDoubleEscapeMetaChars = isCmdShimRegExp.test(commandFile);
-        parsed.command = path21.normalize(parsed.command);
+        parsed.command = path22.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(" ");
@@ -4906,17 +4906,17 @@ var require_visit = __commonJS({
     visit.BREAK = BREAK;
     visit.SKIP = SKIP;
     visit.REMOVE = REMOVE;
-    function visit_(key, node, visitor, path21) {
-      const ctrl = callVisitor(key, node, visitor, path21);
+    function visit_(key, node, visitor, path22) {
+      const ctrl = callVisitor(key, node, visitor, path22);
       if (identity4.isNode(ctrl) || identity4.isPair(ctrl)) {
-        replaceNode(key, path21, ctrl);
-        return visit_(key, ctrl, visitor, path21);
+        replaceNode(key, path22, ctrl);
+        return visit_(key, ctrl, visitor, path22);
       }
       if (typeof ctrl !== "symbol") {
         if (identity4.isCollection(node)) {
-          path21 = Object.freeze(path21.concat(node));
+          path22 = Object.freeze(path22.concat(node));
           for (let i2 = 0; i2 < node.items.length; ++i2) {
-            const ci = visit_(i2, node.items[i2], visitor, path21);
+            const ci = visit_(i2, node.items[i2], visitor, path22);
             if (typeof ci === "number")
               i2 = ci - 1;
             else if (ci === BREAK)
@@ -4927,13 +4927,13 @@ var require_visit = __commonJS({
             }
           }
         } else if (identity4.isPair(node)) {
-          path21 = Object.freeze(path21.concat(node));
-          const ck = visit_("key", node.key, visitor, path21);
+          path22 = Object.freeze(path22.concat(node));
+          const ck = visit_("key", node.key, visitor, path22);
           if (ck === BREAK)
             return BREAK;
           else if (ck === REMOVE)
             node.key = null;
-          const cv = visit_("value", node.value, visitor, path21);
+          const cv = visit_("value", node.value, visitor, path22);
           if (cv === BREAK)
             return BREAK;
           else if (cv === REMOVE)
@@ -4954,17 +4954,17 @@ var require_visit = __commonJS({
     visitAsync.BREAK = BREAK;
     visitAsync.SKIP = SKIP;
     visitAsync.REMOVE = REMOVE;
-    async function visitAsync_(key, node, visitor, path21) {
-      const ctrl = await callVisitor(key, node, visitor, path21);
+    async function visitAsync_(key, node, visitor, path22) {
+      const ctrl = await callVisitor(key, node, visitor, path22);
       if (identity4.isNode(ctrl) || identity4.isPair(ctrl)) {
-        replaceNode(key, path21, ctrl);
-        return visitAsync_(key, ctrl, visitor, path21);
+        replaceNode(key, path22, ctrl);
+        return visitAsync_(key, ctrl, visitor, path22);
       }
       if (typeof ctrl !== "symbol") {
         if (identity4.isCollection(node)) {
-          path21 = Object.freeze(path21.concat(node));
+          path22 = Object.freeze(path22.concat(node));
           for (let i2 = 0; i2 < node.items.length; ++i2) {
-            const ci = await visitAsync_(i2, node.items[i2], visitor, path21);
+            const ci = await visitAsync_(i2, node.items[i2], visitor, path22);
             if (typeof ci === "number")
               i2 = ci - 1;
             else if (ci === BREAK)
@@ -4975,13 +4975,13 @@ var require_visit = __commonJS({
             }
           }
         } else if (identity4.isPair(node)) {
-          path21 = Object.freeze(path21.concat(node));
-          const ck = await visitAsync_("key", node.key, visitor, path21);
+          path22 = Object.freeze(path22.concat(node));
+          const ck = await visitAsync_("key", node.key, visitor, path22);
           if (ck === BREAK)
             return BREAK;
           else if (ck === REMOVE)
             node.key = null;
-          const cv = await visitAsync_("value", node.value, visitor, path21);
+          const cv = await visitAsync_("value", node.value, visitor, path22);
           if (cv === BREAK)
             return BREAK;
           else if (cv === REMOVE)
@@ -5008,23 +5008,23 @@ var require_visit = __commonJS({
       }
       return visitor;
     }
-    function callVisitor(key, node, visitor, path21) {
+    function callVisitor(key, node, visitor, path22) {
       if (typeof visitor === "function")
-        return visitor(key, node, path21);
+        return visitor(key, node, path22);
       if (identity4.isMap(node))
-        return visitor.Map?.(key, node, path21);
+        return visitor.Map?.(key, node, path22);
       if (identity4.isSeq(node))
-        return visitor.Seq?.(key, node, path21);
+        return visitor.Seq?.(key, node, path22);
       if (identity4.isPair(node))
-        return visitor.Pair?.(key, node, path21);
+        return visitor.Pair?.(key, node, path22);
       if (identity4.isScalar(node))
-        return visitor.Scalar?.(key, node, path21);
+        return visitor.Scalar?.(key, node, path22);
       if (identity4.isAlias(node))
-        return visitor.Alias?.(key, node, path21);
+        return visitor.Alias?.(key, node, path22);
       return void 0;
     }
-    function replaceNode(key, path21, node) {
-      const parent = path21[path21.length - 1];
+    function replaceNode(key, path22, node) {
+      const parent = path22[path22.length - 1];
       if (identity4.isCollection(parent)) {
         parent.items[key] = node;
       } else if (identity4.isPair(parent)) {
@@ -5634,10 +5634,10 @@ var require_Collection = __commonJS({
     var createNode = require_createNode();
     var identity4 = require_identity();
     var Node = require_Node();
-    function collectionFromPath(schema, path21, value) {
+    function collectionFromPath(schema, path22, value) {
       let v = value;
-      for (let i2 = path21.length - 1; i2 >= 0; --i2) {
-        const k = path21[i2];
+      for (let i2 = path22.length - 1; i2 >= 0; --i2) {
+        const k = path22[i2];
         if (typeof k === "number" && Number.isInteger(k) && k >= 0) {
           const a2 = [];
           a2[k] = v;
@@ -5656,7 +5656,7 @@ var require_Collection = __commonJS({
         sourceObjects: /* @__PURE__ */ new Map()
       });
     }
-    var isEmptyPath = (path21) => path21 == null || typeof path21 === "object" && !!path21[Symbol.iterator]().next().done;
+    var isEmptyPath = (path22) => path22 == null || typeof path22 === "object" && !!path22[Symbol.iterator]().next().done;
     var Collection = class extends Node.NodeBase {
       constructor(type, schema) {
         super(type);
@@ -5686,11 +5686,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(path21, value) {
-        if (isEmptyPath(path21))
+      addIn(path22, value) {
+        if (isEmptyPath(path22))
           this.add(value);
         else {
-          const [key, ...rest] = path21;
+          const [key, ...rest] = path22;
           const node = this.get(key, true);
           if (identity4.isCollection(node))
             node.addIn(rest, value);
@@ -5704,8 +5704,8 @@ var require_Collection = __commonJS({
        * Removes a value from the collection.
        * @returns `true` if the item was found and removed.
        */
-      deleteIn(path21) {
-        const [key, ...rest] = path21;
+      deleteIn(path22) {
+        const [key, ...rest] = path22;
         if (rest.length === 0)
           return this.delete(key);
         const node = this.get(key, true);
@@ -5719,8 +5719,8 @@ var require_Collection = __commonJS({
        * scalar values from their surrounding node; to disable set `keepScalar` to
        * `true` (collections are always returned intact).
        */
-      getIn(path21, keepScalar) {
-        const [key, ...rest] = path21;
+      getIn(path22, keepScalar) {
+        const [key, ...rest] = path22;
         const node = this.get(key, true);
         if (rest.length === 0)
           return !keepScalar && identity4.isScalar(node) ? node.value : node;
@@ -5738,8 +5738,8 @@ var require_Collection = __commonJS({
       /**
        * Checks if the collection includes a value with the key `key`.
        */
-      hasIn(path21) {
-        const [key, ...rest] = path21;
+      hasIn(path22) {
+        const [key, ...rest] = path22;
         if (rest.length === 0)
           return this.has(key);
         const node = this.get(key, true);
@@ -5749,8 +5749,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(path21, value) {
-        const [key, ...rest] = path21;
+      setIn(path22, value) {
+        const [key, ...rest] = path22;
         if (rest.length === 0) {
           this.set(key, value);
         } else {
@@ -8265,9 +8265,9 @@ var require_Document = __commonJS({
           this.contents.add(value);
       }
       /** Adds a value to the document. */
-      addIn(path21, value) {
+      addIn(path22, value) {
         if (assertCollection(this.contents))
-          this.contents.addIn(path21, value);
+          this.contents.addIn(path22, value);
       }
       /**
        * Create a new `Alias` node, ensuring that the target `node` has the required anchor.
@@ -8342,14 +8342,14 @@ var require_Document = __commonJS({
        * Removes a value from the document.
        * @returns `true` if the item was found and removed.
        */
-      deleteIn(path21) {
-        if (Collection.isEmptyPath(path21)) {
+      deleteIn(path22) {
+        if (Collection.isEmptyPath(path22)) {
           if (this.contents == null)
             return false;
           this.contents = null;
           return true;
         }
-        return assertCollection(this.contents) ? this.contents.deleteIn(path21) : false;
+        return assertCollection(this.contents) ? this.contents.deleteIn(path22) : false;
       }
       /**
        * Returns item at `key`, or `undefined` if not found. By default unwraps
@@ -8364,10 +8364,10 @@ var require_Document = __commonJS({
        * scalar values from their surrounding node; to disable set `keepScalar` to
        * `true` (collections are always returned intact).
        */
-      getIn(path21, keepScalar) {
-        if (Collection.isEmptyPath(path21))
+      getIn(path22, keepScalar) {
+        if (Collection.isEmptyPath(path22))
           return !keepScalar && identity4.isScalar(this.contents) ? this.contents.value : this.contents;
-        return identity4.isCollection(this.contents) ? this.contents.getIn(path21, keepScalar) : void 0;
+        return identity4.isCollection(this.contents) ? this.contents.getIn(path22, keepScalar) : void 0;
       }
       /**
        * Checks if the document includes a value with the key `key`.
@@ -8378,10 +8378,10 @@ var require_Document = __commonJS({
       /**
        * Checks if the document includes a value at `path`.
        */
-      hasIn(path21) {
-        if (Collection.isEmptyPath(path21))
+      hasIn(path22) {
+        if (Collection.isEmptyPath(path22))
           return this.contents !== void 0;
-        return identity4.isCollection(this.contents) ? this.contents.hasIn(path21) : false;
+        return identity4.isCollection(this.contents) ? this.contents.hasIn(path22) : false;
       }
       /**
        * Sets a value in this document. For `!!set`, `value` needs to be a
@@ -8398,13 +8398,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(path21, value) {
-        if (Collection.isEmptyPath(path21)) {
+      setIn(path22, value) {
+        if (Collection.isEmptyPath(path22)) {
           this.contents = value;
         } else if (this.contents == null) {
-          this.contents = Collection.collectionFromPath(this.schema, Array.from(path21), value);
+          this.contents = Collection.collectionFromPath(this.schema, Array.from(path22), value);
         } else if (assertCollection(this.contents)) {
-          this.contents.setIn(path21, value);
+          this.contents.setIn(path22, value);
         }
       }
       /**
@@ -10362,9 +10362,9 @@ var require_cst_visit = __commonJS({
     visit.BREAK = BREAK;
     visit.SKIP = SKIP;
     visit.REMOVE = REMOVE;
-    visit.itemAtPath = (cst, path21) => {
+    visit.itemAtPath = (cst, path22) => {
       let item = cst;
-      for (const [field, index] of path21) {
+      for (const [field, index] of path22) {
         const tok = item?.[field];
         if (tok && "items" in tok) {
           item = tok.items[index];
@@ -10373,23 +10373,23 @@ var require_cst_visit = __commonJS({
       }
       return item;
     };
-    visit.parentCollection = (cst, path21) => {
-      const parent = visit.itemAtPath(cst, path21.slice(0, -1));
-      const field = path21[path21.length - 1][0];
+    visit.parentCollection = (cst, path22) => {
+      const parent = visit.itemAtPath(cst, path22.slice(0, -1));
+      const field = path22[path22.length - 1][0];
       const coll = parent?.[field];
       if (coll && "items" in coll)
         return coll;
       throw new Error("Parent collection not found");
     };
-    function _visit(path21, item, visitor) {
-      let ctrl = visitor(item, path21);
+    function _visit(path22, item, visitor) {
+      let ctrl = visitor(item, path22);
       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(path21.concat([[field, i2]])), token.items[i2], visitor);
+            const ci = _visit(Object.freeze(path22.concat([[field, i2]])), token.items[i2], visitor);
             if (typeof ci === "number")
               i2 = ci - 1;
             else if (ci === BREAK)
@@ -10400,10 +10400,10 @@ var require_cst_visit = __commonJS({
             }
           }
           if (typeof ctrl === "function" && field === "key")
-            ctrl = ctrl(item, path21);
+            ctrl = ctrl(item, path22);
         }
       }
-      return typeof ctrl === "function" ? ctrl(item, path21) : ctrl;
+      return typeof ctrl === "function" ? ctrl(item, path22) : ctrl;
     }
     exports.visit = visit;
   }
@@ -13070,7 +13070,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 path21 = __require("node:path");
+    var path22 = __require("node:path");
     var fs18 = __require("node:fs");
     var process10 = __require("node:process");
     var { Argument: Argument2, humanReadableArgName } = require_argument();
@@ -14003,9 +14003,9 @@ Expecting one of '${allowedValues.join("', '")}'`);
         let launchWithNode = false;
         const sourceExt = [".js", ".ts", ".tsx", ".mjs", ".cjs"];
         function findFile(baseDir, baseName) {
-          const localBin = path21.resolve(baseDir, baseName);
+          const localBin = path22.resolve(baseDir, baseName);
           if (fs18.existsSync(localBin)) return localBin;
-          if (sourceExt.includes(path21.extname(baseName))) return void 0;
+          if (sourceExt.includes(path22.extname(baseName))) return void 0;
           const foundExt = sourceExt.find(
             (ext) => fs18.existsSync(`${localBin}${ext}`)
           );
@@ -14023,17 +14023,17 @@ Expecting one of '${allowedValues.join("', '")}'`);
           } catch (err) {
             resolvedScriptPath = this._scriptPath;
           }
-          executableDir = path21.resolve(
-            path21.dirname(resolvedScriptPath),
+          executableDir = path22.resolve(
+            path22.dirname(resolvedScriptPath),
             executableDir
           );
         }
         if (executableDir) {
           let localFile = findFile(executableDir, executableFile);
           if (!localFile && !subcommand._executableFile && this._scriptPath) {
-            const legacyName = path21.basename(
+            const legacyName = path22.basename(
               this._scriptPath,
-              path21.extname(this._scriptPath)
+              path22.extname(this._scriptPath)
             );
             if (legacyName !== this._name) {
               localFile = findFile(
@@ -14044,7 +14044,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
           }
           executableFile = localFile || executableFile;
         }
-        launchWithNode = sourceExt.includes(path21.extname(executableFile));
+        launchWithNode = sourceExt.includes(path22.extname(executableFile));
         let proc;
         if (process10.platform !== "win32") {
           if (launchWithNode) {
@@ -14884,7 +14884,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
        * @return {Command}
        */
       nameFromFilename(filename) {
-        this._name = path21.basename(filename, path21.extname(filename));
+        this._name = path22.basename(filename, path22.extname(filename));
         return this;
       }
       /**
@@ -14898,9 +14898,9 @@ Expecting one of '${allowedValues.join("', '")}'`);
        * @param {string} [path]
        * @return {(string|null|Command)}
        */
-      executableDir(path22) {
-        if (path22 === void 0) return this._executableDir;
-        this._executableDir = path22;
+      executableDir(path23) {
+        if (path23 === void 0) return this._executableDir;
+        this._executableDir = path23;
         return this;
       }
       /**
@@ -60069,15 +60069,15 @@ var require_route = __commonJS({
       };
     }
     function wrapConversion(toModel, graph) {
-      const path21 = [graph[toModel].parent, toModel];
+      const path22 = [graph[toModel].parent, toModel];
       let fn = conversions[graph[toModel].parent][toModel];
       let cur = graph[toModel].parent;
       while (graph[cur].parent) {
-        path21.unshift(graph[cur].parent);
+        path22.unshift(graph[cur].parent);
         fn = link2(conversions[graph[cur].parent][cur], fn);
         cur = graph[cur].parent;
       }
-      fn.conversion = path21;
+      fn.conversion = path22;
       return fn;
     }
     module.exports = function(fromModel) {
@@ -77212,13 +77212,13 @@ var logOutputSync = ({ serializedResult, fdNumber, state, verboseInfo, encoding,
   }
 };
 var writeToFiles = (serializedResult, stdioItems, outputFiles) => {
-  for (const { path: path21, append } of stdioItems.filter(({ type }) => FILE_TYPES.has(type))) {
-    const pathString = typeof path21 === "string" ? path21 : path21.toString();
+  for (const { path: path22, append } of stdioItems.filter(({ type }) => FILE_TYPES.has(type))) {
+    const pathString = typeof path22 === "string" ? path22 : path22.toString();
     if (append || outputFiles.has(pathString)) {
-      appendFileSync(path21, serializedResult);
+      appendFileSync(path22, serializedResult);
     } else {
       outputFiles.add(pathString);
-      writeFileSync(path21, serializedResult);
+      writeFileSync(path22, serializedResult);
     }
   }
 };
@@ -80269,8 +80269,8 @@ function getErrorMap() {
 
 // node_modules/zod/v3/helpers/parseUtil.js
 var makeIssue = (params) => {
-  const { data, path: path21, errorMaps, issueData } = params;
-  const fullPath = [...path21, ...issueData.path || []];
+  const { data, path: path22, errorMaps, issueData } = params;
+  const fullPath = [...path22, ...issueData.path || []];
   const fullIssue = {
     ...issueData,
     path: fullPath
@@ -80386,11 +80386,11 @@ var errorUtil;
 
 // node_modules/zod/v3/types.js
 var ParseInputLazyPath = class {
-  constructor(parent, value, path21, key) {
+  constructor(parent, value, path22, key) {
     this._cachedPath = [];
     this.parent = parent;
     this.data = value;
-    this._path = path21;
+    this._path = path22;
     this._key = key;
   }
   get path() {
@@ -83951,8 +83951,14 @@ var ActionSchema = external_exports.object({
   key: external_exports.string().min(1).max(1).optional()
 });
 var MountSettingsSchema = external_exports.object({
-  /** Workspace-relative path for the generated docker-compose overlay. */
-  overlayPath: external_exports.string().optional().default("docker-compose.dev-cockpit.yml"),
+  /**
+   * Override path for the generated docker-compose overlay. When unset
+   * (the default), the overlay lands in the cockpit state dir alongside
+   * `mount.manifest.json` — keeps the wrapper repo clean of per-developer
+   * artefacts. When set, the value is workspace-relative; absolute paths
+   * are honoured verbatim.
+   */
+  overlayPath: external_exports.string().optional(),
   /** Basename inside stateDir for the manifest. */
   manifestFile: external_exports.string().optional().default("mount.manifest.json")
 });
@@ -83972,7 +83978,6 @@ var BaseCockpitConfigSchema = external_exports.object({
   }),
   mounts: external_exports.array(MountSchema).optional().default([]),
   mount: MountSettingsSchema.optional().default({
-    overlayPath: "docker-compose.dev-cockpit.yml",
     manifestFile: "mount.manifest.json"
   }),
   /** Which pane the cockpit lands on when it boots. Profile may override. */
@@ -88774,7 +88779,7 @@ var ReaddirpStream = class extends Readable4 {
     this._directoryFilter = normalizeFilter(opts.directoryFilter);
     const statMethod = opts.lstat ? lstat : stat;
     if (wantBigintFsStats) {
-      this._stat = (path21) => statMethod(path21, { bigint: true });
+      this._stat = (path22) => statMethod(path22, { bigint: true });
     } else {
       this._stat = statMethod;
     }
@@ -88799,8 +88804,8 @@ var ReaddirpStream = class extends Readable4 {
         const par = this.parent;
         const fil = par && par.files;
         if (fil && fil.length > 0) {
-          const { path: path21, depth } = par;
-          const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path21));
+          const { path: path22, depth } = par;
+          const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path22));
           const awaited = await Promise.all(slice);
           for (const entry of awaited) {
             if (!entry)
@@ -88840,20 +88845,20 @@ var ReaddirpStream = class extends Readable4 {
       this.reading = false;
     }
   }
-  async _exploreDir(path21, depth) {
+  async _exploreDir(path22, depth) {
     let files;
     try {
-      files = await readdir(path21, this._rdOptions);
+      files = await readdir(path22, this._rdOptions);
     } catch (error) {
       this._onError(error);
     }
-    return { files, depth, path: path21 };
+    return { files, depth, path: path22 };
   }
-  async _formatEntry(dirent, path21) {
+  async _formatEntry(dirent, path22) {
     let entry;
     const basename3 = this._isDirent ? dirent.name : dirent;
     try {
-      const fullPath = presolve(pjoin(path21, basename3));
+      const fullPath = presolve(pjoin(path22, basename3));
       entry = { path: prelative(this._root, fullPath), fullPath, basename: basename3 };
       entry[this._statsProp] = this._isDirent ? dirent : await this._stat(fullPath);
     } catch (err) {
@@ -89253,16 +89258,16 @@ var delFromSet = (main, prop, item) => {
 };
 var isEmptySet = (val) => val instanceof Set ? val.size === 0 : !val;
 var FsWatchInstances = /* @__PURE__ */ new Map();
-function createFsWatchInstance(path21, options2, listener, errHandler, emitRaw) {
+function createFsWatchInstance(path22, options2, listener, errHandler, emitRaw) {
   const handleEvent = (rawEvent, evPath) => {
-    listener(path21);
-    emitRaw(rawEvent, evPath, { watchedPath: path21 });
-    if (evPath && path21 !== evPath) {
-      fsWatchBroadcast(sp.resolve(path21, evPath), KEY_LISTENERS, sp.join(path21, evPath));
+    listener(path22);
+    emitRaw(rawEvent, evPath, { watchedPath: path22 });
+    if (evPath && path22 !== evPath) {
+      fsWatchBroadcast(sp.resolve(path22, evPath), KEY_LISTENERS, sp.join(path22, evPath));
     }
   };
   try {
-    return fs_watch(path21, {
+    return fs_watch(path22, {
       persistent: options2.persistent
     }, handleEvent);
   } catch (error) {
@@ -89278,12 +89283,12 @@ var fsWatchBroadcast = (fullPath, listenerType, val1, val2, val3) => {
     listener(val1, val2, val3);
   });
 };
-var setFsWatchListener = (path21, fullPath, options2, handlers) => {
+var setFsWatchListener = (path22, fullPath, options2, handlers) => {
   const { listener, errHandler, rawEmitter } = handlers;
   let cont = FsWatchInstances.get(fullPath);
   let watcher;
   if (!options2.persistent) {
-    watcher = createFsWatchInstance(path21, options2, listener, errHandler, rawEmitter);
+    watcher = createFsWatchInstance(path22, options2, listener, errHandler, rawEmitter);
     if (!watcher)
       return;
     return watcher.close.bind(watcher);
@@ -89294,7 +89299,7 @@ var setFsWatchListener = (path21, fullPath, options2, handlers) => {
     addAndConvert(cont, KEY_RAW, rawEmitter);
   } else {
     watcher = createFsWatchInstance(
-      path21,
+      path22,
       options2,
       fsWatchBroadcast.bind(null, fullPath, KEY_LISTENERS),
       errHandler,
@@ -89309,7 +89314,7 @@ var setFsWatchListener = (path21, fullPath, options2, handlers) => {
         cont.watcherUnusable = true;
       if (isWindows && error.code === "EPERM") {
         try {
-          const fd = await open(path21, "r");
+          const fd = await open(path22, "r");
           await fd.close();
           broadcastErr(error);
         } catch (err) {
@@ -89340,7 +89345,7 @@ var setFsWatchListener = (path21, fullPath, options2, handlers) => {
   };
 };
 var FsWatchFileInstances = /* @__PURE__ */ new Map();
-var setFsWatchFileListener = (path21, fullPath, options2, handlers) => {
+var setFsWatchFileListener = (path22, fullPath, options2, handlers) => {
   const { listener, rawEmitter } = handlers;
   let cont = FsWatchFileInstances.get(fullPath);
   const copts = cont && cont.options;
@@ -89362,7 +89367,7 @@ var setFsWatchFileListener = (path21, fullPath, options2, handlers) => {
         });
         const currmtime = curr.mtimeMs;
         if (curr.size !== prev.size || currmtime > prev.mtimeMs || currmtime === 0) {
-          foreach(cont.listeners, (listener2) => listener2(path21, curr));
+          foreach(cont.listeners, (listener2) => listener2(path22, curr));
         }
       })
     };
@@ -89392,13 +89397,13 @@ var NodeFsHandler = class {
    * @param listener on fs change
    * @returns closer for the watcher instance
    */
-  _watchWithNodeFs(path21, listener) {
+  _watchWithNodeFs(path22, listener) {
     const opts = this.fsw.options;
-    const directory = sp.dirname(path21);
-    const basename3 = sp.basename(path21);
+    const directory = sp.dirname(path22);
+    const basename3 = sp.basename(path22);
     const parent = this.fsw._getWatchedDir(directory);
     parent.add(basename3);
-    const absolutePath = sp.resolve(path21);
+    const absolutePath = sp.resolve(path22);
     const options2 = {
       persistent: opts.persistent
     };
@@ -89408,12 +89413,12 @@ var NodeFsHandler = class {
     if (opts.usePolling) {
       const enableBin = opts.interval !== opts.binaryInterval;
       options2.interval = enableBin && isBinaryPath(basename3) ? opts.binaryInterval : opts.interval;
-      closer = setFsWatchFileListener(path21, absolutePath, options2, {
+      closer = setFsWatchFileListener(path22, absolutePath, options2, {
         listener,
         rawEmitter: this.fsw._emitRaw
       });
     } else {
-      closer = setFsWatchListener(path21, absolutePath, options2, {
+      closer = setFsWatchListener(path22, absolutePath, options2, {
         listener,
         errHandler: this._boundHandleError,
         rawEmitter: this.fsw._emitRaw
@@ -89435,7 +89440,7 @@ var NodeFsHandler = class {
     let prevStats = stats;
     if (parent.has(basename3))
       return;
-    const listener = async (path21, newStats) => {
+    const listener = async (path22, newStats) => {
       if (!this.fsw._throttle(THROTTLE_MODE_WATCH, file, 5))
         return;
       if (!newStats || newStats.mtimeMs === 0) {
@@ -89449,11 +89454,11 @@ var NodeFsHandler = class {
             this.fsw._emit(EV.CHANGE, file, newStats2);
           }
           if ((isMacos || isLinux || isFreeBSD) && prevStats.ino !== newStats2.ino) {
-            this.fsw._closeFile(path21);
+            this.fsw._closeFile(path22);
             prevStats = newStats2;
             const closer2 = this._watchWithNodeFs(file, listener);
             if (closer2)
-              this.fsw._addPathCloser(path21, closer2);
+              this.fsw._addPathCloser(path22, closer2);
           } else {
             prevStats = newStats2;
           }
@@ -89485,7 +89490,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, path21, item) {
+  async _handleSymlink(entry, directory, path22, item) {
     if (this.fsw.closed) {
       return;
     }
@@ -89495,7 +89500,7 @@ var NodeFsHandler = class {
       this.fsw._incrReadyCount();
       let linkPath;
       try {
-        linkPath = await fsrealpath(path21);
+        linkPath = await fsrealpath(path22);
       } catch (e) {
         this.fsw._emitReady();
         return true;
@@ -89505,12 +89510,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, path21, entry.stats);
+          this.fsw._emit(EV.CHANGE, path22, entry.stats);
         }
       } else {
         dir.add(item);
         this.fsw._symlinkPaths.set(full, linkPath);
-        this.fsw._emit(EV.ADD, path21, entry.stats);
+        this.fsw._emit(EV.ADD, path22, entry.stats);
       }
       this.fsw._emitReady();
       return true;
@@ -89540,9 +89545,9 @@ var NodeFsHandler = class {
         return;
       }
       const item = entry.path;
-      let path21 = sp.join(directory, item);
+      let path22 = sp.join(directory, item);
       current.add(item);
-      if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path21, item)) {
+      if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path22, item)) {
         return;
       }
       if (this.fsw.closed) {
@@ -89551,8 +89556,8 @@ var NodeFsHandler = class {
       }
       if (item === target || !target && !previous.has(item)) {
         this.fsw._incrReadyCount();
-        path21 = sp.join(dir, sp.relative(dir, path21));
-        this._addToNodeFs(path21, initialAdd, wh, depth + 1);
+        path22 = sp.join(dir, sp.relative(dir, path22));
+        this._addToNodeFs(path22, initialAdd, wh, depth + 1);
       }
     }).on(EV.ERROR, this._boundHandleError);
     return new Promise((resolve3, reject) => {
@@ -89621,13 +89626,13 @@ var NodeFsHandler = class {
    * @param depth Child path actually targeted for watch
    * @param target Child path actually targeted for watch
    */
-  async _addToNodeFs(path21, initialAdd, priorWh, depth, target) {
+  async _addToNodeFs(path22, initialAdd, priorWh, depth, target) {
     const ready = this.fsw._emitReady;
-    if (this.fsw._isIgnored(path21) || this.fsw.closed) {
+    if (this.fsw._isIgnored(path22) || this.fsw.closed) {
       ready();
       return false;
     }
-    const wh = this.fsw._getWatchHelpers(path21);
+    const wh = this.fsw._getWatchHelpers(path22);
     if (priorWh) {
       wh.filterPath = (entry) => priorWh.filterPath(entry);
       wh.filterDir = (entry) => priorWh.filterDir(entry);
@@ -89643,8 +89648,8 @@ var NodeFsHandler = class {
       const follow = this.fsw.options.followSymlinks;
       let closer;
       if (stats.isDirectory()) {
-        const absPath = sp.resolve(path21);
-        const targetPath = follow ? await fsrealpath(path21) : path21;
+        const absPath = sp.resolve(path22);
+        const targetPath = follow ? await fsrealpath(path22) : path22;
         if (this.fsw.closed)
           return;
         closer = await this._handleDir(wh.watchPath, stats, initialAdd, depth, target, wh, targetPath);
@@ -89654,29 +89659,29 @@ var NodeFsHandler = class {
           this.fsw._symlinkPaths.set(absPath, targetPath);
         }
       } else if (stats.isSymbolicLink()) {
-        const targetPath = follow ? await fsrealpath(path21) : path21;
+        const targetPath = follow ? await fsrealpath(path22) : path22;
         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, path21, wh, targetPath);
+        closer = await this._handleDir(parent, stats, initialAdd, depth, path22, wh, targetPath);
         if (this.fsw.closed)
           return;
         if (targetPath !== void 0) {
-          this.fsw._symlinkPaths.set(sp.resolve(path21), targetPath);
+          this.fsw._symlinkPaths.set(sp.resolve(path22), targetPath);
         }
       } else {
         closer = this._handleFile(wh.watchPath, stats, initialAdd);
       }
       ready();
       if (closer)
-        this.fsw._addPathCloser(path21, closer);
+        this.fsw._addPathCloser(path22, closer);
       return false;
     } catch (error) {
       if (this.fsw._handleError(error)) {
         ready();
-        return path21;
+        return path22;
       }
     }
   }
@@ -89719,24 +89724,24 @@ function createPattern(matcher) {
   }
   return () => false;
 }
-function normalizePath(path21) {
-  if (typeof path21 !== "string")
+function normalizePath(path22) {
+  if (typeof path22 !== "string")
     throw new Error("string expected");
-  path21 = sp2.normalize(path21);
-  path21 = path21.replace(/\\/g, "/");
+  path22 = sp2.normalize(path22);
+  path22 = path22.replace(/\\/g, "/");
   let prepend = false;
-  if (path21.startsWith("//"))
+  if (path22.startsWith("//"))
     prepend = true;
-  path21 = path21.replace(DOUBLE_SLASH_RE, "/");
+  path22 = path22.replace(DOUBLE_SLASH_RE, "/");
   if (prepend)
-    path21 = "/" + path21;
-  return path21;
+    path22 = "/" + path22;
+  return path22;
 }
 function matchPatterns(patterns, testString, stats) {
-  const path21 = normalizePath(testString);
+  const path22 = normalizePath(testString);
   for (let index = 0; index < patterns.length; index++) {
     const pattern = patterns[index];
-    if (pattern(path21, stats)) {
+    if (pattern(path22, stats)) {
       return true;
     }
   }
@@ -89774,19 +89779,19 @@ var toUnix = (string) => {
   }
   return str;
 };
-var normalizePathToUnix = (path21) => toUnix(sp2.normalize(toUnix(path21)));
-var normalizeIgnored = (cwd = "") => (path21) => {
-  if (typeof path21 === "string") {
-    return normalizePathToUnix(sp2.isAbsolute(path21) ? path21 : sp2.join(cwd, path21));
+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));
   } else {
-    return path21;
+    return path22;
   }
 };
-var getAbsolutePath = (path21, cwd) => {
-  if (sp2.isAbsolute(path21)) {
-    return path21;
+var getAbsolutePath = (path22, cwd) => {
+  if (sp2.isAbsolute(path22)) {
+    return path22;
   }
-  return sp2.join(cwd, path21);
+  return sp2.join(cwd, path22);
 };
 var EMPTY_SET = Object.freeze(/* @__PURE__ */ new Set());
 var DirEntry = class {
@@ -89851,10 +89856,10 @@ var WatchHelper = class {
   dirParts;
   followSymlinks;
   statMethod;
-  constructor(path21, follow, fsw) {
+  constructor(path22, follow, fsw) {
     this.fsw = fsw;
-    const watchPath = path21;
-    this.path = path21 = path21.replace(REPLACER_RE, "");
+    const watchPath = path22;
+    this.path = path22 = path22.replace(REPLACER_RE, "");
     this.watchPath = watchPath;
     this.fullWatchPath = sp2.resolve(watchPath);
     this.dirParts = [];
@@ -89994,20 +89999,20 @@ var FSWatcher = class extends EventEmitter2 {
     this._closePromise = void 0;
     let paths = unifyPaths(paths_);
     if (cwd) {
-      paths = paths.map((path21) => {
-        const absPath = getAbsolutePath(path21, cwd);
+      paths = paths.map((path22) => {
+        const absPath = getAbsolutePath(path22, cwd);
         return absPath;
       });
     }
-    paths.forEach((path21) => {
-      this._removeIgnoredPath(path21);
+    paths.forEach((path22) => {
+      this._removeIgnoredPath(path22);
     });
     this._userIgnored = void 0;
     if (!this._readyCount)
       this._readyCount = 0;
     this._readyCount += paths.length;
-    Promise.all(paths.map(async (path21) => {
-      const res = await this._nodeFsHandler._addToNodeFs(path21, !_internal, void 0, 0, _origAdd);
+    Promise.all(paths.map(async (path22) => {
+      const res = await this._nodeFsHandler._addToNodeFs(path22, !_internal, void 0, 0, _origAdd);
       if (res)
         this._emitReady();
       return res;
@@ -90029,17 +90034,17 @@ var FSWatcher = class extends EventEmitter2 {
       return this;
     const paths = unifyPaths(paths_);
     const { cwd } = this.options;
-    paths.forEach((path21) => {
-      if (!sp2.isAbsolute(path21) && !this._closers.has(path21)) {
+    paths.forEach((path22) => {
+      if (!sp2.isAbsolute(path22) && !this._closers.has(path22)) {
         if (cwd)
-          path21 = sp2.join(cwd, path21);
-        path21 = sp2.resolve(path21);
+          path22 = sp2.join(cwd, path22);
+        path22 = sp2.resolve(path22);
       }
-      this._closePath(path21);
-      this._addIgnoredPath(path21);
-      if (this._watched.has(path21)) {
+      this._closePath(path22);
+      this._addIgnoredPath(path22);
+      if (this._watched.has(path22)) {
         this._addIgnoredPath({
-          path: path21,
+          path: path22,
           recursive: true
         });
       }
@@ -90103,38 +90108,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, path21, stats) {
+  async _emit(event, path22, stats) {
     if (this.closed)
       return;
     const opts = this.options;
     if (isWindows)
-      path21 = sp2.normalize(path21);
+      path22 = sp2.normalize(path22);
     if (opts.cwd)
-      path21 = sp2.relative(opts.cwd, path21);
-    const args = [path21];
+      path22 = sp2.relative(opts.cwd, path22);
+    const args = [path22];
     if (stats != null)
       args.push(stats);
     const awf = opts.awaitWriteFinish;
     let pw;
-    if (awf && (pw = this._pendingWrites.get(path21))) {
+    if (awf && (pw = this._pendingWrites.get(path22))) {
       pw.lastChange = /* @__PURE__ */ new Date();
       return this;
     }
     if (opts.atomic) {
       if (event === EVENTS.UNLINK) {
-        this._pendingUnlinks.set(path21, [event, ...args]);
+        this._pendingUnlinks.set(path22, [event, ...args]);
         setTimeout(() => {
-          this._pendingUnlinks.forEach((entry, path22) => {
+          this._pendingUnlinks.forEach((entry, path23) => {
             this.emit(...entry);
             this.emit(EVENTS.ALL, ...entry);
-            this._pendingUnlinks.delete(path22);
+            this._pendingUnlinks.delete(path23);
           });
         }, typeof opts.atomic === "number" ? opts.atomic : 100);
         return this;
       }
-      if (event === EVENTS.ADD && this._pendingUnlinks.has(path21)) {
+      if (event === EVENTS.ADD && this._pendingUnlinks.has(path22)) {
         event = EVENTS.CHANGE;
-        this._pendingUnlinks.delete(path21);
+        this._pendingUnlinks.delete(path22);
       }
     }
     if (awf && (event === EVENTS.ADD || event === EVENTS.CHANGE) && this._readyEmitted) {
@@ -90152,16 +90157,16 @@ var FSWatcher = class extends EventEmitter2 {
           this.emitWithAll(event, args);
         }
       };
-      this._awaitWriteFinish(path21, awf.stabilityThreshold, event, awfEmit);
+      this._awaitWriteFinish(path22, awf.stabilityThreshold, event, awfEmit);
       return this;
     }
     if (event === EVENTS.CHANGE) {
-      const isThrottled = !this._throttle(EVENTS.CHANGE, path21, 50);
+      const isThrottled = !this._throttle(EVENTS.CHANGE, path22, 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, path21) : path21;
+      const fullPath = opts.cwd ? sp2.join(opts.cwd, path22) : path22;
       let stats2;
       try {
         stats2 = await stat3(fullPath);
@@ -90192,23 +90197,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, path21, timeout) {
+  _throttle(actionType, path22, 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(path21);
+    const actionPath = action.get(path22);
     if (actionPath) {
       actionPath.count++;
       return false;
     }
     let timeoutObject;
     const clear = () => {
-      const item = action.get(path21);
+      const item = action.get(path22);
       const count2 = item ? item.count : 0;
-      action.delete(path21);
+      action.delete(path22);
       clearTimeout(timeoutObject);
       if (item)
         clearTimeout(item.timeoutObject);
@@ -90216,7 +90221,7 @@ var FSWatcher = class extends EventEmitter2 {
     };
     timeoutObject = setTimeout(clear, timeout);
     const thr = { timeoutObject, clear, count: 0 };
-    action.set(path21, thr);
+    action.set(path22, thr);
     return thr;
   }
   _incrReadyCount() {
@@ -90230,44 +90235,44 @@ var FSWatcher = class extends EventEmitter2 {
    * @param event
    * @param awfEmit Callback to be called when ready for event to be emitted.
    */
-  _awaitWriteFinish(path21, threshold, event, awfEmit) {
+  _awaitWriteFinish(path22, threshold, event, awfEmit) {
     const awf = this.options.awaitWriteFinish;
     if (typeof awf !== "object")
       return;
     const pollInterval = awf.pollInterval;
     let timeoutHandler;
-    let fullPath = path21;
-    if (this.options.cwd && !sp2.isAbsolute(path21)) {
-      fullPath = sp2.join(this.options.cwd, path21);
+    let fullPath = path22;
+    if (this.options.cwd && !sp2.isAbsolute(path22)) {
+      fullPath = sp2.join(this.options.cwd, path22);
     }
     const now = /* @__PURE__ */ new Date();
     const writes = this._pendingWrites;
     function awaitWriteFinishFn(prevStat) {
       statcb(fullPath, (err, curStat) => {
-        if (err || !writes.has(path21)) {
+        if (err || !writes.has(path22)) {
           if (err && err.code !== "ENOENT")
             awfEmit(err);
           return;
         }
         const now2 = Number(/* @__PURE__ */ new Date());
         if (prevStat && curStat.size !== prevStat.size) {
-          writes.get(path21).lastChange = now2;
+          writes.get(path22).lastChange = now2;
         }
-        const pw = writes.get(path21);
+        const pw = writes.get(path22);
         const df = now2 - pw.lastChange;
         if (df >= threshold) {
-          writes.delete(path21);
+          writes.delete(path22);
           awfEmit(void 0, curStat);
         } else {
           timeoutHandler = setTimeout(awaitWriteFinishFn, pollInterval, curStat);
         }
       });
     }
-    if (!writes.has(path21)) {
-      writes.set(path21, {
+    if (!writes.has(path22)) {
+      writes.set(path22, {
         lastChange: now,
         cancelWait: () => {
-          writes.delete(path21);
+          writes.delete(path22);
           clearTimeout(timeoutHandler);
           return event;
         }
@@ -90278,8 +90283,8 @@ var FSWatcher = class extends EventEmitter2 {
   /**
    * Determines whether user has asked to ignore this path.
    */
-  _isIgnored(path21, stats) {
-    if (this.options.atomic && DOT_RE.test(path21))
+  _isIgnored(path22, stats) {
+    if (this.options.atomic && DOT_RE.test(path22))
       return true;
     if (!this._userIgnored) {
       const { cwd } = this.options;
@@ -90289,17 +90294,17 @@ var FSWatcher = class extends EventEmitter2 {
       const list3 = [...ignoredPaths.map(normalizeIgnored(cwd)), ...ignored];
       this._userIgnored = anymatch(list3, void 0);
     }
-    return this._userIgnored(path21, stats);
+    return this._userIgnored(path22, stats);
   }
-  _isntIgnored(path21, stat4) {
-    return !this._isIgnored(path21, stat4);
+  _isntIgnored(path22, stat4) {
+    return !this._isIgnored(path22, stat4);
   }
   /**
    * Provides a set of common helpers and properties relating to symlink handling.
    * @param path file or directory pattern being watched
    */
-  _getWatchHelpers(path21) {
-    return new WatchHelper(path21, this.options.followSymlinks, this);
+  _getWatchHelpers(path22) {
+    return new WatchHelper(path22, this.options.followSymlinks, this);
   }
   // Directory helpers
   // -----------------
@@ -90331,63 +90336,63 @@ var FSWatcher = class extends EventEmitter2 {
    * @param item      base path of item/directory
    */
   _remove(directory, item, isDirectory) {
-    const path21 = sp2.join(directory, item);
-    const fullPath = sp2.resolve(path21);
-    isDirectory = isDirectory != null ? isDirectory : this._watched.has(path21) || this._watched.has(fullPath);
-    if (!this._throttle("remove", path21, 100))
+    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))
       return;
     if (!isDirectory && this._watched.size === 1) {
       this.add(directory, item, true);
     }
-    const wp = this._getWatchedDir(path21);
+    const wp = this._getWatchedDir(path22);
     const nestedDirectoryChildren = wp.getChildren();
-    nestedDirectoryChildren.forEach((nested) => this._remove(path21, nested));
+    nestedDirectoryChildren.forEach((nested) => this._remove(path22, 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 = path21;
+    let relPath = path22;
     if (this.options.cwd)
-      relPath = sp2.relative(this.options.cwd, path21);
+      relPath = sp2.relative(this.options.cwd, path22);
     if (this.options.awaitWriteFinish && this._pendingWrites.has(relPath)) {
       const event = this._pendingWrites.get(relPath).cancelWait();
       if (event === EVENTS.ADD)
         return;
     }
-    this._watched.delete(path21);
+    this._watched.delete(path22);
     this._watched.delete(fullPath);
     const eventName = isDirectory ? EVENTS.UNLINK_DIR : EVENTS.UNLINK;
-    if (wasTracked && !this._isIgnored(path21))
-      this._emit(eventName, path21);
-    this._closePath(path21);
+    if (wasTracked && !this._isIgnored(path22))
+      this._emit(eventName, path22);
+    this._closePath(path22);
   }
   /**
    * Closes all watchers for a path
    */
-  _closePath(path21) {
-    this._closeFile(path21);
-    const dir = sp2.dirname(path21);
-    this._getWatchedDir(dir).remove(sp2.basename(path21));
+  _closePath(path22) {
+    this._closeFile(path22);
+    const dir = sp2.dirname(path22);
+    this._getWatchedDir(dir).remove(sp2.basename(path22));
   }
   /**
    * Closes only file-specific watchers
    */
-  _closeFile(path21) {
-    const closers = this._closers.get(path21);
+  _closeFile(path22) {
+    const closers = this._closers.get(path22);
     if (!closers)
       return;
     closers.forEach((closer) => closer());
-    this._closers.delete(path21);
+    this._closers.delete(path22);
   }
-  _addPathCloser(path21, closer) {
+  _addPathCloser(path22, closer) {
     if (!closer)
       return;
-    let list3 = this._closers.get(path21);
+    let list3 = this._closers.get(path22);
     if (!list3) {
       list3 = [];
-      this._closers.set(path21, list3);
+      this._closers.set(path22, list3);
     }
     list3.push(closer);
   }
@@ -92221,7 +92226,7 @@ doctor failed: ${err instanceof Error ? err.message : String(err)}
 }
 
 // src/commands/mount.ts
-import path19 from "node:path";
+import path20 from "node:path";
 import fs15 from "node:fs";
 
 // src/mount/manifest.ts
@@ -92307,9 +92312,19 @@ function renderDockerOverlay(mounts, opts) {
 `;
 }
 
+// src/mount/overlay-path.ts
+import path18 from "node:path";
+function resolveOverlayPath(opts) {
+  if (!opts.configOverride) {
+    return path18.join(opts.stateDir, "dev-mount-overlay.yml");
+  }
+  if (path18.isAbsolute(opts.configOverride)) return opts.configOverride;
+  return path18.resolve(opts.workspaceRoot, opts.configOverride);
+}
+
 // src/mount/symlinks.ts
 import fs14 from "node:fs";
-import path18 from "node:path";
+import path19 from "node:path";
 function applyManagedSymlinks(workspaceRoot, mounts, strategy) {
   const report = { created: [], skipped: [] };
   for (const m of mounts) {
@@ -92332,7 +92347,7 @@ function applyManagedSymlinks(workspaceRoot, mounts, strategy) {
       }
     } catch {
     }
-    fs14.mkdirSync(path18.dirname(linkPath), { recursive: true });
+    fs14.mkdirSync(path19.dirname(linkPath), { recursive: true });
     fs14.symlinkSync(m.hostPath, linkPath);
     report.created.push(linkPath);
   }
@@ -92450,9 +92465,13 @@ async function resolveContext(opts) {
     process.exit(1);
   }
   const providerMounts = await profile?.mountCandidatesProvider?.() ?? [];
-  const overlayPath = path19.resolve(workspaceRoot, config.mount.overlayPath);
   const paths = getStatePaths(workspaceRoot, { appName: config.appName });
-  const manifestPath2 = path19.join(paths.stateDir, config.mount.manifestFile);
+  const overlayPath = resolveOverlayPath({
+    stateDir: paths.stateDir,
+    workspaceRoot,
+    configOverride: config.mount.overlayPath
+  });
+  const manifestPath2 = path20.join(paths.stateDir, config.mount.manifestFile);
   return {
     configPath,
     workspaceRoot,
@@ -92514,7 +92533,7 @@ async function mountCommand(opts = {}) {
       return;
     }
   }
-  fs15.mkdirSync(path19.dirname(overlayPath), { recursive: true });
+  fs15.mkdirSync(path20.dirname(overlayPath), { recursive: true });
   fs15.writeFileSync(overlayPath, renderDockerOverlay(selected, { service }), "utf8");
   process.stdout.write(`dev-cockpit mount: wrote ${overlayPath}
 `);
@@ -92546,7 +92565,7 @@ async function mountCommand(opts = {}) {
     await profile.onMountApply(hookCtx);
   } else {
     process.stdout.write(
-      `  Apply with: docker compose -f <your-compose>.yml -f ${path19.basename(overlayPath)} up -d
+      `  Apply with: docker compose -f <your-compose>.yml -f ${path20.basename(overlayPath)} up -d
 `
     );
   }
@@ -92656,9 +92675,9 @@ async function mountClearCommand(opts = {}) {
 // src/commands/migrate-config.ts
 var import_yaml2 = __toESM(require_dist(), 1);
 import fs16 from "node:fs";
-import path20 from "node:path";
+import path21 from "node:path";
 async function migrateConfigCommand(opts = {}) {
-  const configPath = path20.resolve(opts.config ?? "cockpit.yaml");
+  const configPath = path21.resolve(opts.config ?? "cockpit.yaml");
   if (!fs16.existsSync(configPath)) {
     process.stderr.write(`dev-cockpit migrate-config: no file at ${configPath}.
 `);
@@ -92898,6 +92917,7 @@ export {
   renderWizardYaml,
   resolveDocsRoot,
   resolveNotify,
+  resolveOverlayPath,
   restartDockerService,
   runAllLints,
   runChecks,