@adhdev/daemon-standalone 0.7.9 → 0.7.10

package/dist/index.js

@@ -283,10 +283,10 @@ function mergeDefs(...defs) {
 function cloneDef(schema) {
   return mergeDefs(schema._zod.def);
 }
-function getElementAtPath(obj, path17) {
-  if (!path17)
+function getElementAtPath(obj, path18) {
+  if (!path18)
     return obj;
-  return path17.reduce((acc, key) => acc?.[key], obj);
+  return path18.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -598,11 +598,11 @@ function aborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path17, issues) {
+function prefixIssues(path18, issues) {
   return issues.map((iss) => {
     var _a2;
     (_a2 = iss).path ?? (_a2.path = []);
-    iss.path.unshift(path17);
+    iss.path.unshift(path18);
     return iss;
   });
 }
@@ -845,7 +845,7 @@ function formatError(error48, mapper = (issue2) => issue2.message) {
 }
 function treeifyError(error48, mapper = (issue2) => issue2.message) {
   const result = { errors: [] };
-  const processError = (error49, path17 = []) => {
+  const processError = (error49, path18 = []) => {
     var _a2, _b;
     for (const issue2 of error49.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
@@ -855,7 +855,7 @@ function treeifyError(error48, mapper = (issue2) => issue2.message) {
       } else if (issue2.code === "invalid_element") {
         processError({ issues: issue2.issues }, issue2.path);
       } else {
-        const fullpath = [...path17, ...issue2.path];
+        const fullpath = [...path18, ...issue2.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue2));
           continue;
@@ -887,8 +887,8 @@ function treeifyError(error48, mapper = (issue2) => issue2.message) {
 }
 function toDotPath(_path) {
   const segs = [];
-  const path17 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
-  for (const seg of path17) {
+  const path18 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
+  for (const seg of path18) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -13652,13 +13652,13 @@ function resolveRef(ref, ctx) {
   if (!ref.startsWith("#")) {
     throw new Error("External $ref is not supported, only local refs (#/...) are allowed");
   }
-  const path17 = ref.slice(1).split("/").filter(Boolean);
-  if (path17.length === 0) {
+  const path18 = ref.slice(1).split("/").filter(Boolean);
+  if (path18.length === 0) {
     return ctx.rootSchema;
   }
   const defsKey = ctx.version === "draft-2020-12" ? "$defs" : "definitions";
-  if (path17[0] === defsKey) {
-    const key = path17[1];
+  if (path18[0] === defsKey) {
+    const key = path18[1];
     if (!key || !ctx.defs[key]) {
       throw new Error(`Reference not found: ${ref}`);
     }
@@ -16085,8 +16085,8 @@ var init_acp = __esm({
         this.#requestHandler = requestHandler;
         this.#notificationHandler = notificationHandler;
         this.#stream = stream;
-        this.#closedPromise = new Promise((resolve11) => {
-          this.#abortController.signal.addEventListener("abort", () => resolve11());
+        this.#closedPromise = new Promise((resolve12) => {
+          this.#abortController.signal.addEventListener("abort", () => resolve12());
         });
         this.#receive();
       }
@@ -16235,8 +16235,8 @@ var init_acp = __esm({
       }
       async sendRequest(method, params) {
         const id = this.#nextRequestId++;
-        const responsePromise = new Promise((resolve11, reject) => {
-          this.#pendingResponses.set(id, { resolve: resolve11, reject });
+        const responsePromise = new Promise((resolve12, reject) => {
+          this.#pendingResponses.set(id, { resolve: resolve12, reject });
         });
         await this.#sendMessage({ jsonrpc: "2.0", id, method, params });
         return responsePromise;
@@ -16334,21 +16334,21 @@ var init_acp = __esm({
 // src/index.ts
 var import_http = require("http");
 var import_ws2 = require("ws");
-var path16 = __toESM(require("path"));
+var path17 = __toESM(require("path"));
 var fs12 = __toESM(require("fs"));
 var os17 = __toESM(require("os"));
 
 // ../daemon-core/dist/index.mjs
 var fs = __toESM(require("fs"), 1);
 var os2 = __toESM(require("os"), 1);
-var path3 = __toESM(require("path"), 1);
+var path = __toESM(require("path"), 1);
 var import_crypto2 = require("crypto");
 var import_os = require("os");
 var import_path = require("path");
 var import_fs = require("fs");
 var import_crypto3 = require("crypto");
 var fs2 = __toESM(require("fs"), 1);
-var path32 = __toESM(require("path"), 1);
+var path3 = __toESM(require("path"), 1);
 var os4 = __toESM(require("os"), 1);
 var os11 = __toESM(require("os"), 1);
 var os12 = __toESM(require("os"), 1);
@@ -16469,7 +16469,7 @@ var ReaddirpStream = class extends import_node_stream.Readable {
     this._directoryFilter = normalizeFilter(opts.directoryFilter);
     const statMethod = opts.lstat ? import_promises.lstat : import_promises.stat;
     if (wantBigintFsStats) {
-      this._stat = (path17) => statMethod(path17, { bigint: true });
+      this._stat = (path18) => statMethod(path18, { bigint: true });
     } else {
       this._stat = statMethod;
     }
@@ -16494,8 +16494,8 @@ var ReaddirpStream = class extends import_node_stream.Readable {
         const par = this.parent;
         const fil = par && par.files;
         if (fil && fil.length > 0) {
-          const { path: path17, depth } = par;
-          const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path17));
+          const { path: path18, depth } = par;
+          const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path18));
           const awaited = await Promise.all(slice);
           for (const entry of awaited) {
             if (!entry)
@@ -16535,20 +16535,20 @@ var ReaddirpStream = class extends import_node_stream.Readable {
       this.reading = false;
     }
   }
-  async _exploreDir(path17, depth) {
+  async _exploreDir(path18, depth) {
     let files;
     try {
-      files = await (0, import_promises.readdir)(path17, this._rdOptions);
+      files = await (0, import_promises.readdir)(path18, this._rdOptions);
     } catch (error48) {
       this._onError(error48);
     }
-    return { files, depth, path: path17 };
+    return { files, depth, path: path18 };
   }
-  async _formatEntry(dirent, path17) {
+  async _formatEntry(dirent, path18) {
     let entry;
     const basename7 = this._isDirent ? dirent.name : dirent;
     try {
-      const fullPath = (0, import_node_path.resolve)((0, import_node_path.join)(path17, basename7));
+      const fullPath = (0, import_node_path.resolve)((0, import_node_path.join)(path18, basename7));
       entry = { path: (0, import_node_path.relative)(this._root, fullPath), fullPath, basename: basename7 };
       entry[this._statsProp] = this._isDirent ? dirent : await this._stat(fullPath);
     } catch (err) {
@@ -16948,16 +16948,16 @@ var delFromSet = (main2, prop, item) => {
 };
 var isEmptySet = (val) => val instanceof Set ? val.size === 0 : !val;
 var FsWatchInstances = /* @__PURE__ */ new Map();
-function createFsWatchInstance(path17, options, listener, errHandler, emitRaw) {
+function createFsWatchInstance(path18, options, listener, errHandler, emitRaw) {
   const handleEvent = (rawEvent, evPath) => {
-    listener(path17);
-    emitRaw(rawEvent, evPath, { watchedPath: path17 });
-    if (evPath && path17 !== evPath) {
-      fsWatchBroadcast(sp.resolve(path17, evPath), KEY_LISTENERS, sp.join(path17, evPath));
+    listener(path18);
+    emitRaw(rawEvent, evPath, { watchedPath: path18 });
+    if (evPath && path18 !== evPath) {
+      fsWatchBroadcast(sp.resolve(path18, evPath), KEY_LISTENERS, sp.join(path18, evPath));
     }
   };
   try {
-    return (0, import_node_fs.watch)(path17, {
+    return (0, import_node_fs.watch)(path18, {
       persistent: options.persistent
     }, handleEvent);
   } catch (error48) {
@@ -16973,12 +16973,12 @@ var fsWatchBroadcast = (fullPath, listenerType, val1, val2, val3) => {
     listener(val1, val2, val3);
   });
 };
-var setFsWatchListener = (path17, fullPath, options, handlers) => {
+var setFsWatchListener = (path18, fullPath, options, handlers) => {
   const { listener, errHandler, rawEmitter } = handlers;
   let cont = FsWatchInstances.get(fullPath);
   let watcher;
   if (!options.persistent) {
-    watcher = createFsWatchInstance(path17, options, listener, errHandler, rawEmitter);
+    watcher = createFsWatchInstance(path18, options, listener, errHandler, rawEmitter);
     if (!watcher)
       return;
     return watcher.close.bind(watcher);
@@ -16989,7 +16989,7 @@ var setFsWatchListener = (path17, fullPath, options, handlers) => {
     addAndConvert(cont, KEY_RAW, rawEmitter);
   } else {
     watcher = createFsWatchInstance(
-      path17,
+      path18,
       options,
       fsWatchBroadcast.bind(null, fullPath, KEY_LISTENERS),
       errHandler,
@@ -17004,7 +17004,7 @@ var setFsWatchListener = (path17, fullPath, options, handlers) => {
         cont.watcherUnusable = true;
       if (isWindows && error48.code === "EPERM") {
         try {
-          const fd = await (0, import_promises2.open)(path17, "r");
+          const fd = await (0, import_promises2.open)(path18, "r");
           await fd.close();
           broadcastErr(error48);
         } catch (err) {
@@ -17035,7 +17035,7 @@ var setFsWatchListener = (path17, fullPath, options, handlers) => {
   };
 };
 var FsWatchFileInstances = /* @__PURE__ */ new Map();
-var setFsWatchFileListener = (path17, fullPath, options, handlers) => {
+var setFsWatchFileListener = (path18, fullPath, options, handlers) => {
   const { listener, rawEmitter } = handlers;
   let cont = FsWatchFileInstances.get(fullPath);
   const copts = cont && cont.options;
@@ -17057,7 +17057,7 @@ var setFsWatchFileListener = (path17, fullPath, options, handlers) => {
         });
         const currmtime = curr.mtimeMs;
         if (curr.size !== prev.size || currmtime > prev.mtimeMs || currmtime === 0) {
-          foreach(cont.listeners, (listener2) => listener2(path17, curr));
+          foreach(cont.listeners, (listener2) => listener2(path18, curr));
         }
       })
     };
@@ -17087,13 +17087,13 @@ var NodeFsHandler = class {
    * @param listener on fs change
    * @returns closer for the watcher instance
    */
-  _watchWithNodeFs(path17, listener) {
+  _watchWithNodeFs(path18, listener) {
     const opts = this.fsw.options;
-    const directory = sp.dirname(path17);
-    const basename7 = sp.basename(path17);
+    const directory = sp.dirname(path18);
+    const basename7 = sp.basename(path18);
     const parent = this.fsw._getWatchedDir(directory);
     parent.add(basename7);
-    const absolutePath = sp.resolve(path17);
+    const absolutePath = sp.resolve(path18);
     const options = {
       persistent: opts.persistent
     };
@@ -17103,12 +17103,12 @@ var NodeFsHandler = class {
     if (opts.usePolling) {
       const enableBin = opts.interval !== opts.binaryInterval;
       options.interval = enableBin && isBinaryPath(basename7) ? opts.binaryInterval : opts.interval;
-      closer = setFsWatchFileListener(path17, absolutePath, options, {
+      closer = setFsWatchFileListener(path18, absolutePath, options, {
         listener,
         rawEmitter: this.fsw._emitRaw
       });
     } else {
-      closer = setFsWatchListener(path17, absolutePath, options, {
+      closer = setFsWatchListener(path18, absolutePath, options, {
         listener,
         errHandler: this._boundHandleError,
         rawEmitter: this.fsw._emitRaw
@@ -17130,7 +17130,7 @@ var NodeFsHandler = class {
     let prevStats = stats;
     if (parent.has(basename7))
       return;
-    const listener = async (path17, newStats) => {
+    const listener = async (path18, newStats) => {
       if (!this.fsw._throttle(THROTTLE_MODE_WATCH, file2, 5))
         return;
       if (!newStats || newStats.mtimeMs === 0) {
@@ -17144,11 +17144,11 @@ var NodeFsHandler = class {
             this.fsw._emit(EV.CHANGE, file2, newStats2);
           }
           if ((isMacos || isLinux || isFreeBSD) && prevStats.ino !== newStats2.ino) {
-            this.fsw._closeFile(path17);
+            this.fsw._closeFile(path18);
             prevStats = newStats2;
             const closer2 = this._watchWithNodeFs(file2, listener);
             if (closer2)
-              this.fsw._addPathCloser(path17, closer2);
+              this.fsw._addPathCloser(path18, closer2);
           } else {
             prevStats = newStats2;
           }
@@ -17180,7 +17180,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, path17, item) {
+  async _handleSymlink(entry, directory, path18, item) {
     if (this.fsw.closed) {
       return;
     }
@@ -17190,7 +17190,7 @@ var NodeFsHandler = class {
       this.fsw._incrReadyCount();
       let linkPath;
       try {
-        linkPath = await (0, import_promises2.realpath)(path17);
+        linkPath = await (0, import_promises2.realpath)(path18);
       } catch (e) {
         this.fsw._emitReady();
         return true;
@@ -17200,12 +17200,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, path17, entry.stats);
+          this.fsw._emit(EV.CHANGE, path18, entry.stats);
         }
       } else {
         dir.add(item);
         this.fsw._symlinkPaths.set(full, linkPath);
-        this.fsw._emit(EV.ADD, path17, entry.stats);
+        this.fsw._emit(EV.ADD, path18, entry.stats);
       }
       this.fsw._emitReady();
       return true;
@@ -17235,9 +17235,9 @@ var NodeFsHandler = class {
         return;
       }
       const item = entry.path;
-      let path17 = sp.join(directory, item);
+      let path18 = sp.join(directory, item);
       current.add(item);
-      if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path17, item)) {
+      if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path18, item)) {
         return;
       }
       if (this.fsw.closed) {
@@ -17246,11 +17246,11 @@ var NodeFsHandler = class {
       }
       if (item === target || !target && !previous.has(item)) {
         this.fsw._incrReadyCount();
-        path17 = sp.join(dir, sp.relative(dir, path17));
-        this._addToNodeFs(path17, initialAdd, wh, depth + 1);
+        path18 = sp.join(dir, sp.relative(dir, path18));
+        this._addToNodeFs(path18, initialAdd, wh, depth + 1);
       }
     }).on(EV.ERROR, this._boundHandleError);
-    return new Promise((resolve11, reject) => {
+    return new Promise((resolve12, reject) => {
       if (!stream)
         return reject();
       stream.once(STR_END, () => {
@@ -17259,7 +17259,7 @@ var NodeFsHandler = class {
           return;
         }
         const wasThrottled = throttler ? throttler.clear() : false;
-        resolve11(void 0);
+        resolve12(void 0);
         previous.getChildren().filter((item) => {
           return item !== directory && !current.has(item);
         }).forEach((item) => {
@@ -17316,13 +17316,13 @@ var NodeFsHandler = class {
    * @param depth Child path actually targeted for watch
    * @param target Child path actually targeted for watch
    */
-  async _addToNodeFs(path17, initialAdd, priorWh, depth, target) {
+  async _addToNodeFs(path18, initialAdd, priorWh, depth, target) {
     const ready = this.fsw._emitReady;
-    if (this.fsw._isIgnored(path17) || this.fsw.closed) {
+    if (this.fsw._isIgnored(path18) || this.fsw.closed) {
       ready();
       return false;
     }
-    const wh = this.fsw._getWatchHelpers(path17);
+    const wh = this.fsw._getWatchHelpers(path18);
     if (priorWh) {
       wh.filterPath = (entry) => priorWh.filterPath(entry);
       wh.filterDir = (entry) => priorWh.filterDir(entry);
@@ -17338,8 +17338,8 @@ var NodeFsHandler = class {
       const follow = this.fsw.options.followSymlinks;
       let closer;
       if (stats.isDirectory()) {
-        const absPath = sp.resolve(path17);
-        const targetPath = follow ? await (0, import_promises2.realpath)(path17) : path17;
+        const absPath = sp.resolve(path18);
+        const targetPath = follow ? await (0, import_promises2.realpath)(path18) : path18;
         if (this.fsw.closed)
           return;
         closer = await this._handleDir(wh.watchPath, stats, initialAdd, depth, target, wh, targetPath);
@@ -17349,29 +17349,29 @@ var NodeFsHandler = class {
           this.fsw._symlinkPaths.set(absPath, targetPath);
         }
       } else if (stats.isSymbolicLink()) {
-        const targetPath = follow ? await (0, import_promises2.realpath)(path17) : path17;
+        const targetPath = follow ? await (0, import_promises2.realpath)(path18) : path18;
         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, path17, wh, targetPath);
+        closer = await this._handleDir(parent, stats, initialAdd, depth, path18, wh, targetPath);
         if (this.fsw.closed)
           return;
         if (targetPath !== void 0) {
-          this.fsw._symlinkPaths.set(sp.resolve(path17), targetPath);
+          this.fsw._symlinkPaths.set(sp.resolve(path18), targetPath);
         }
       } else {
         closer = this._handleFile(wh.watchPath, stats, initialAdd);
       }
       ready();
       if (closer)
-        this.fsw._addPathCloser(path17, closer);
+        this.fsw._addPathCloser(path18, closer);
       return false;
     } catch (error48) {
       if (this.fsw._handleError(error48)) {
         ready();
-        return path17;
+        return path18;
       }
     }
   }
@@ -17414,24 +17414,24 @@ function createPattern(matcher) {
   }
   return () => false;
 }
-function normalizePath(path17) {
-  if (typeof path17 !== "string")
+function normalizePath(path18) {
+  if (typeof path18 !== "string")
     throw new Error("string expected");
-  path17 = sp2.normalize(path17);
-  path17 = path17.replace(/\\/g, "/");
+  path18 = sp2.normalize(path18);
+  path18 = path18.replace(/\\/g, "/");
   let prepend = false;
-  if (path17.startsWith("//"))
+  if (path18.startsWith("//"))
     prepend = true;
-  path17 = path17.replace(DOUBLE_SLASH_RE, "/");
+  path18 = path18.replace(DOUBLE_SLASH_RE, "/");
   if (prepend)
-    path17 = "/" + path17;
-  return path17;
+    path18 = "/" + path18;
+  return path18;
 }
 function matchPatterns(patterns, testString, stats) {
-  const path17 = normalizePath(testString);
+  const path18 = normalizePath(testString);
   for (let index = 0; index < patterns.length; index++) {
     const pattern = patterns[index];
-    if (pattern(path17, stats)) {
+    if (pattern(path18, stats)) {
       return true;
     }
   }
@@ -17469,19 +17469,19 @@ var toUnix = (string4) => {
   }
   return str;
 };
-var normalizePathToUnix = (path17) => toUnix(sp2.normalize(toUnix(path17)));
-var normalizeIgnored = (cwd = "") => (path17) => {
-  if (typeof path17 === "string") {
-    return normalizePathToUnix(sp2.isAbsolute(path17) ? path17 : sp2.join(cwd, path17));
+var normalizePathToUnix = (path18) => toUnix(sp2.normalize(toUnix(path18)));
+var normalizeIgnored = (cwd = "") => (path18) => {
+  if (typeof path18 === "string") {
+    return normalizePathToUnix(sp2.isAbsolute(path18) ? path18 : sp2.join(cwd, path18));
   } else {
-    return path17;
+    return path18;
   }
 };
-var getAbsolutePath = (path17, cwd) => {
-  if (sp2.isAbsolute(path17)) {
-    return path17;
+var getAbsolutePath = (path18, cwd) => {
+  if (sp2.isAbsolute(path18)) {
+    return path18;
   }
-  return sp2.join(cwd, path17);
+  return sp2.join(cwd, path18);
 };
 var EMPTY_SET = Object.freeze(/* @__PURE__ */ new Set());
 var DirEntry = class {
@@ -17546,10 +17546,10 @@ var WatchHelper = class {
   dirParts;
   followSymlinks;
   statMethod;
-  constructor(path17, follow, fsw) {
+  constructor(path18, follow, fsw) {
     this.fsw = fsw;
-    const watchPath = path17;
-    this.path = path17 = path17.replace(REPLACER_RE, "");
+    const watchPath = path18;
+    this.path = path18 = path18.replace(REPLACER_RE, "");
     this.watchPath = watchPath;
     this.fullWatchPath = sp2.resolve(watchPath);
     this.dirParts = [];
@@ -17689,20 +17689,20 @@ var FSWatcher = class extends import_node_events.EventEmitter {
     this._closePromise = void 0;
     let paths = unifyPaths(paths_);
     if (cwd) {
-      paths = paths.map((path17) => {
-        const absPath = getAbsolutePath(path17, cwd);
+      paths = paths.map((path18) => {
+        const absPath = getAbsolutePath(path18, cwd);
         return absPath;
       });
     }
-    paths.forEach((path17) => {
-      this._removeIgnoredPath(path17);
+    paths.forEach((path18) => {
+      this._removeIgnoredPath(path18);
     });
     this._userIgnored = void 0;
     if (!this._readyCount)
       this._readyCount = 0;
     this._readyCount += paths.length;
-    Promise.all(paths.map(async (path17) => {
-      const res = await this._nodeFsHandler._addToNodeFs(path17, !_internal, void 0, 0, _origAdd);
+    Promise.all(paths.map(async (path18) => {
+      const res = await this._nodeFsHandler._addToNodeFs(path18, !_internal, void 0, 0, _origAdd);
       if (res)
         this._emitReady();
       return res;
@@ -17724,17 +17724,17 @@ var FSWatcher = class extends import_node_events.EventEmitter {
       return this;
     const paths = unifyPaths(paths_);
     const { cwd } = this.options;
-    paths.forEach((path17) => {
-      if (!sp2.isAbsolute(path17) && !this._closers.has(path17)) {
+    paths.forEach((path18) => {
+      if (!sp2.isAbsolute(path18) && !this._closers.has(path18)) {
         if (cwd)
-          path17 = sp2.join(cwd, path17);
-        path17 = sp2.resolve(path17);
+          path18 = sp2.join(cwd, path18);
+        path18 = sp2.resolve(path18);
       }
-      this._closePath(path17);
-      this._addIgnoredPath(path17);
-      if (this._watched.has(path17)) {
+      this._closePath(path18);
+      this._addIgnoredPath(path18);
+      if (this._watched.has(path18)) {
         this._addIgnoredPath({
-          path: path17,
+          path: path18,
           recursive: true
         });
       }
@@ -17798,38 +17798,38 @@ var FSWatcher = class extends import_node_events.EventEmitter {
    * @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, path17, stats) {
+  async _emit(event, path18, stats) {
     if (this.closed)
       return;
     const opts = this.options;
     if (isWindows)
-      path17 = sp2.normalize(path17);
+      path18 = sp2.normalize(path18);
     if (opts.cwd)
-      path17 = sp2.relative(opts.cwd, path17);
-    const args = [path17];
+      path18 = sp2.relative(opts.cwd, path18);
+    const args = [path18];
     if (stats != null)
       args.push(stats);
     const awf = opts.awaitWriteFinish;
     let pw;
-    if (awf && (pw = this._pendingWrites.get(path17))) {
+    if (awf && (pw = this._pendingWrites.get(path18))) {
       pw.lastChange = /* @__PURE__ */ new Date();
       return this;
     }
     if (opts.atomic) {
       if (event === EVENTS.UNLINK) {
-        this._pendingUnlinks.set(path17, [event, ...args]);
+        this._pendingUnlinks.set(path18, [event, ...args]);
         setTimeout(() => {
-          this._pendingUnlinks.forEach((entry, path18) => {
+          this._pendingUnlinks.forEach((entry, path19) => {
             this.emit(...entry);
             this.emit(EVENTS.ALL, ...entry);
-            this._pendingUnlinks.delete(path18);
+            this._pendingUnlinks.delete(path19);
           });
         }, typeof opts.atomic === "number" ? opts.atomic : 100);
         return this;
       }
-      if (event === EVENTS.ADD && this._pendingUnlinks.has(path17)) {
+      if (event === EVENTS.ADD && this._pendingUnlinks.has(path18)) {
         event = EVENTS.CHANGE;
-        this._pendingUnlinks.delete(path17);
+        this._pendingUnlinks.delete(path18);
       }
     }
     if (awf && (event === EVENTS.ADD || event === EVENTS.CHANGE) && this._readyEmitted) {
@@ -17847,16 +17847,16 @@ var FSWatcher = class extends import_node_events.EventEmitter {
           this.emitWithAll(event, args);
         }
       };
-      this._awaitWriteFinish(path17, awf.stabilityThreshold, event, awfEmit);
+      this._awaitWriteFinish(path18, awf.stabilityThreshold, event, awfEmit);
       return this;
     }
     if (event === EVENTS.CHANGE) {
-      const isThrottled = !this._throttle(EVENTS.CHANGE, path17, 50);
+      const isThrottled = !this._throttle(EVENTS.CHANGE, path18, 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, path17) : path17;
+      const fullPath = opts.cwd ? sp2.join(opts.cwd, path18) : path18;
       let stats2;
       try {
         stats2 = await (0, import_promises3.stat)(fullPath);
@@ -17887,23 +17887,23 @@ var FSWatcher = class extends import_node_events.EventEmitter {
    * @param timeout duration of time to suppress duplicate actions
    * @returns tracking object or false if action should be suppressed
    */
-  _throttle(actionType, path17, timeout) {
+  _throttle(actionType, path18, 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(path17);
+    const actionPath = action.get(path18);
     if (actionPath) {
       actionPath.count++;
       return false;
     }
     let timeoutObject;
     const clear = () => {
-      const item = action.get(path17);
+      const item = action.get(path18);
       const count = item ? item.count : 0;
-      action.delete(path17);
+      action.delete(path18);
       clearTimeout(timeoutObject);
       if (item)
         clearTimeout(item.timeoutObject);
@@ -17911,7 +17911,7 @@ var FSWatcher = class extends import_node_events.EventEmitter {
     };
     timeoutObject = setTimeout(clear, timeout);
     const thr = { timeoutObject, clear, count: 0 };
-    action.set(path17, thr);
+    action.set(path18, thr);
     return thr;
   }
   _incrReadyCount() {
@@ -17925,44 +17925,44 @@ var FSWatcher = class extends import_node_events.EventEmitter {
    * @param event
    * @param awfEmit Callback to be called when ready for event to be emitted.
    */
-  _awaitWriteFinish(path17, threshold, event, awfEmit) {
+  _awaitWriteFinish(path18, threshold, event, awfEmit) {
     const awf = this.options.awaitWriteFinish;
     if (typeof awf !== "object")
       return;
     const pollInterval = awf.pollInterval;
     let timeoutHandler;
-    let fullPath = path17;
-    if (this.options.cwd && !sp2.isAbsolute(path17)) {
-      fullPath = sp2.join(this.options.cwd, path17);
+    let fullPath = path18;
+    if (this.options.cwd && !sp2.isAbsolute(path18)) {
+      fullPath = sp2.join(this.options.cwd, path18);
     }
     const now = /* @__PURE__ */ new Date();
     const writes = this._pendingWrites;
     function awaitWriteFinishFn(prevStat) {
       (0, import_node_fs2.stat)(fullPath, (err, curStat) => {
-        if (err || !writes.has(path17)) {
+        if (err || !writes.has(path18)) {
           if (err && err.code !== "ENOENT")
             awfEmit(err);
           return;
         }
         const now2 = Number(/* @__PURE__ */ new Date());
         if (prevStat && curStat.size !== prevStat.size) {
-          writes.get(path17).lastChange = now2;
+          writes.get(path18).lastChange = now2;
         }
-        const pw = writes.get(path17);
+        const pw = writes.get(path18);
         const df = now2 - pw.lastChange;
         if (df >= threshold) {
-          writes.delete(path17);
+          writes.delete(path18);
           awfEmit(void 0, curStat);
         } else {
           timeoutHandler = setTimeout(awaitWriteFinishFn, pollInterval, curStat);
         }
       });
     }
-    if (!writes.has(path17)) {
-      writes.set(path17, {
+    if (!writes.has(path18)) {
+      writes.set(path18, {
         lastChange: now,
         cancelWait: () => {
-          writes.delete(path17);
+          writes.delete(path18);
           clearTimeout(timeoutHandler);
           return event;
         }
@@ -17973,8 +17973,8 @@ var FSWatcher = class extends import_node_events.EventEmitter {
   /**
    * Determines whether user has asked to ignore this path.
    */
-  _isIgnored(path17, stats) {
-    if (this.options.atomic && DOT_RE.test(path17))
+  _isIgnored(path18, stats) {
+    if (this.options.atomic && DOT_RE.test(path18))
       return true;
     if (!this._userIgnored) {
       const { cwd } = this.options;
@@ -17984,17 +17984,17 @@ var FSWatcher = class extends import_node_events.EventEmitter {
       const list = [...ignoredPaths.map(normalizeIgnored(cwd)), ...ignored];
       this._userIgnored = anymatch(list, void 0);
     }
-    return this._userIgnored(path17, stats);
+    return this._userIgnored(path18, stats);
   }
-  _isntIgnored(path17, stat4) {
-    return !this._isIgnored(path17, stat4);
+  _isntIgnored(path18, stat4) {
+    return !this._isIgnored(path18, stat4);
   }
   /**
    * Provides a set of common helpers and properties relating to symlink handling.
    * @param path file or directory pattern being watched
    */
-  _getWatchHelpers(path17) {
-    return new WatchHelper(path17, this.options.followSymlinks, this);
+  _getWatchHelpers(path18) {
+    return new WatchHelper(path18, this.options.followSymlinks, this);
   }
   // Directory helpers
   // -----------------
@@ -18026,63 +18026,63 @@ var FSWatcher = class extends import_node_events.EventEmitter {
    * @param item      base path of item/directory
    */
   _remove(directory, item, isDirectory) {
-    const path17 = sp2.join(directory, item);
-    const fullPath = sp2.resolve(path17);
-    isDirectory = isDirectory != null ? isDirectory : this._watched.has(path17) || this._watched.has(fullPath);
-    if (!this._throttle("remove", path17, 100))
+    const path18 = sp2.join(directory, item);
+    const fullPath = sp2.resolve(path18);
+    isDirectory = isDirectory != null ? isDirectory : this._watched.has(path18) || this._watched.has(fullPath);
+    if (!this._throttle("remove", path18, 100))
       return;
     if (!isDirectory && this._watched.size === 1) {
       this.add(directory, item, true);
     }
-    const wp = this._getWatchedDir(path17);
+    const wp = this._getWatchedDir(path18);
     const nestedDirectoryChildren = wp.getChildren();
-    nestedDirectoryChildren.forEach((nested) => this._remove(path17, nested));
+    nestedDirectoryChildren.forEach((nested) => this._remove(path18, 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 = path17;
+    let relPath = path18;
     if (this.options.cwd)
-      relPath = sp2.relative(this.options.cwd, path17);
+      relPath = sp2.relative(this.options.cwd, path18);
     if (this.options.awaitWriteFinish && this._pendingWrites.has(relPath)) {
       const event = this._pendingWrites.get(relPath).cancelWait();
       if (event === EVENTS.ADD)
         return;
     }
-    this._watched.delete(path17);
+    this._watched.delete(path18);
     this._watched.delete(fullPath);
     const eventName = isDirectory ? EVENTS.UNLINK_DIR : EVENTS.UNLINK;
-    if (wasTracked && !this._isIgnored(path17))
-      this._emit(eventName, path17);
-    this._closePath(path17);
+    if (wasTracked && !this._isIgnored(path18))
+      this._emit(eventName, path18);
+    this._closePath(path18);
   }
   /**
    * Closes all watchers for a path
    */
-  _closePath(path17) {
-    this._closeFile(path17);
-    const dir = sp2.dirname(path17);
-    this._getWatchedDir(dir).remove(sp2.basename(path17));
+  _closePath(path18) {
+    this._closeFile(path18);
+    const dir = sp2.dirname(path18);
+    this._getWatchedDir(dir).remove(sp2.basename(path18));
   }
   /**
    * Closes only file-specific watchers
    */
-  _closeFile(path17) {
-    const closers = this._closers.get(path17);
+  _closeFile(path18) {
+    const closers = this._closers.get(path18);
     if (!closers)
       return;
     closers.forEach((closer) => closer());
-    this._closers.delete(path17);
+    this._closers.delete(path18);
   }
-  _addPathCloser(path17, closer) {
+  _addPathCloser(path18, closer) {
     if (!closer)
       return;
-    let list = this._closers.get(path17);
+    let list = this._closers.get(path18);
     if (!list) {
       list = [];
-      this._closers.set(path17, list);
+      this._closers.set(path18, list);
     }
     list.push(closer);
   }
@@ -18205,8 +18205,8 @@ var SessionHostClient = class {
       }
       this.requestWaiters.clear();
     });
-    await new Promise((resolve11, reject) => {
-      socket.once("connect", () => resolve11());
+    await new Promise((resolve12, reject) => {
+      socket.once("connect", () => resolve12());
       socket.once("error", reject);
     });
   }
@@ -18225,8 +18225,8 @@ var SessionHostClient = class {
       requestId,
       request
     };
-    const response = await new Promise((resolve11, reject) => {
-      this.requestWaiters.set(requestId, { resolve: resolve11, reject });
+    const response = await new Promise((resolve12, reject) => {
+      this.requestWaiters.set(requestId, { resolve: resolve12, reject });
       this.socket?.write(serializeEnvelope(envelope));
     });
     return response;
@@ -18239,12 +18239,12 @@ var SessionHostClient = class {
       waiter.reject(new Error("Session host client closed"));
     }
     this.requestWaiters.clear();
-    await new Promise((resolve11) => {
+    await new Promise((resolve12) => {
       let settled = false;
       const done = () => {
         if (settled) return;
         settled = true;
-        resolve11();
+        resolve12();
       };
       socket.once("close", done);
       socket.end();
@@ -18284,8 +18284,8 @@ var __toCommonJS = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: t
 function expandPath(p) {
   const t = (p || "").trim();
   if (!t) return "";
-  if (t.startsWith("~")) return path3.join(os2.homedir(), t.slice(1).replace(/^\//, ""));
-  return path3.resolve(t);
+  if (t.startsWith("~")) return path.join(os2.homedir(), t.slice(1).replace(/^\//, ""));
+  return path.resolve(t);
 }
 function validateWorkspacePath(absPath) {
   try {
@@ -18299,7 +18299,7 @@ function validateWorkspacePath(absPath) {
   }
 }
 function defaultWorkspaceLabel(absPath) {
-  const base = path3.basename(absPath) || absPath;
+  const base = path.basename(absPath) || absPath;
   return base;
 }
 function migrateWorkspacesFromRecent(config2) {
@@ -18310,7 +18310,7 @@ function migrateWorkspacesFromRecent(config2) {
   for (const raw of recent) {
     const abs = expandPath(raw);
     if (!abs || validateWorkspacePath(abs).ok !== true) continue;
-    if (config2.workspaces.some((w) => path3.resolve(w.path) === abs)) continue;
+    if (config2.workspaces.some((w) => path.resolve(w.path) === abs)) continue;
     config2.workspaces.push({
       id: (0, import_crypto2.randomUUID)(),
       path: abs,
@@ -18409,16 +18409,16 @@ function resolveIdeLaunchWorkspace(args, config2) {
   return getDefaultWorkspacePath(config2) || void 0;
 }
 function findWorkspaceByPath(config2, rawPath) {
-  const abs = path3.resolve(expandPath(rawPath));
+  const abs = path.resolve(expandPath(rawPath));
   if (!abs) return void 0;
-  return (config2.workspaces || []).find((w) => path3.resolve(expandPath(w.path)) === abs);
+  return (config2.workspaces || []).find((w) => path.resolve(expandPath(w.path)) === abs);
 }
 function addWorkspaceEntry(config2, rawPath, label) {
   const abs = expandPath(rawPath);
   const v = validateWorkspacePath(abs);
   if (!v.ok) return { error: v.error };
   const list = [...config2.workspaces || []];
-  if (list.some((w) => path3.resolve(w.path) === abs)) {
+  if (list.some((w) => path.resolve(w.path) === abs)) {
     return { error: "Workspace already in list" };
   }
   if (list.length >= MAX_WORKSPACES) {
@@ -18654,7 +18654,7 @@ function checkDateRotation() {
   const today = getDateStr();
   if (today !== currentDate) {
     currentDate = today;
-    currentLogFile = path32.join(LOG_DIR, `daemon-${currentDate}.log`);
+    currentLogFile = path3.join(LOG_DIR, `daemon-${currentDate}.log`);
     cleanOldLogs();
   }
 }
@@ -18668,7 +18668,7 @@ function cleanOldLogs() {
       const dateMatch = file2.match(/daemon-(\d{4}-\d{2}-\d{2})/);
       if (dateMatch && dateMatch[1] < cutoffStr) {
         try {
-          fs2.unlinkSync(path32.join(LOG_DIR, file2));
+          fs2.unlinkSync(path3.join(LOG_DIR, file2));
         } catch {
         }
       }
@@ -18808,7 +18808,7 @@ var init_logger = __esm2({
     LEVEL_NUM = { debug: 0, info: 1, warn: 2, error: 3 };
     LEVEL_LABEL = { debug: "DBG", info: "INF", warn: "WRN", error: "ERR" };
     currentLevel = "info";
-    LOG_DIR = process.platform === "darwin" ? path32.join(os4.homedir(), "Library", "Logs", "adhdev") : path32.join(os4.homedir(), ".local", "share", "adhdev", "logs");
+    LOG_DIR = process.platform === "darwin" ? path3.join(os4.homedir(), "Library", "Logs", "adhdev") : path3.join(os4.homedir(), ".local", "share", "adhdev", "logs");
     MAX_LOG_SIZE = 5 * 1024 * 1024;
     MAX_LOG_DAYS = 7;
     try {
@@ -18816,16 +18816,16 @@ var init_logger = __esm2({
     } catch {
     }
     currentDate = getDateStr();
-    currentLogFile = path32.join(LOG_DIR, `daemon-${currentDate}.log`);
+    currentLogFile = path3.join(LOG_DIR, `daemon-${currentDate}.log`);
     cleanOldLogs();
     try {
-      const oldLog = path32.join(LOG_DIR, "daemon.log");
+      const oldLog = path3.join(LOG_DIR, "daemon.log");
       if (fs2.existsSync(oldLog)) {
         const stat4 = fs2.statSync(oldLog);
         const oldDate = stat4.mtime.toISOString().slice(0, 10);
-        fs2.renameSync(oldLog, path32.join(LOG_DIR, `daemon-${oldDate}.log`));
+        fs2.renameSync(oldLog, path3.join(LOG_DIR, `daemon-${oldDate}.log`));
       }
-      const oldLogBackup = path32.join(LOG_DIR, "daemon.log.old");
+      const oldLogBackup = path3.join(LOG_DIR, "daemon.log.old");
       if (fs2.existsSync(oldLogBackup)) {
         fs2.unlinkSync(oldLogBackup);
       }
@@ -18857,7 +18857,7 @@ var init_logger = __esm2({
       }
     };
     interceptorInstalled = false;
-    LOG_PATH = path32.join(LOG_DIR, `daemon-${getDateStr()}.log`);
+    LOG_PATH = path3.join(LOG_DIR, `daemon-${getDateStr()}.log`);
   }
 });
 function isModuleNotFoundError(error48, ref) {
@@ -18931,6 +18931,9 @@ var init_ghostty_vt_backend = __esm2({
       terminal;
       constructor(options) {
         const binding = loadGhosttyVtBinding(true);
+        if (!binding) {
+          throw new Error("ghostty-vt backend requested but no binding is available");
+        }
         this.terminal = binding.createTerminal({
           cols: Math.max(1, options.cols | 0),
           rows: Math.max(1, options.rows | 0),
@@ -29644,7 +29647,7 @@ async function handleScriptsRun(ctx, req, res) {
     ctx.json(res, 400, { error: "type and script required" });
     return;
   }
-  await this.handleRunScript(type, req, res, body);
+  await ctx.handleRunScript(type, req, res, body);
 }
 async function handleTypeAndSend(ctx, type, req, res) {
   const body = await ctx.readBody(req);
@@ -29685,7 +29688,7 @@ async function handleTypeAndSendAt(ctx, type, req, res) {
   }
 }
 async function handleScriptHints(ctx, type, _req, res) {
-  const dir = this.findProviderDir(type);
+  const dir = ctx.findProviderDir(type);
   if (!dir) {
     ctx.json(res, 404, { error: `Provider not found: ${type}` });
     return;
@@ -33761,6 +33764,7 @@ async function shutdownDaemonComponents(components) {
 
 // src/session-host.ts
 var import_child_process8 = require("child_process");
+var path15 = __toESM(require("path"));
 var STARTUP_TIMEOUT_MS = 8e3;
 var STARTUP_POLL_MS = 200;
 var SESSION_HOST_APP_NAME = process.env.ADHDEV_SESSION_HOST_NAME || "adhdev";
@@ -33778,14 +33782,14 @@ async function waitForReady(endpoint, timeoutMs = STARTUP_TIMEOUT_MS) {
   const deadline = Date.now() + timeoutMs;
   while (Date.now() < deadline) {
     if (await canConnect(endpoint)) return;
-    await new Promise((resolve11) => setTimeout(resolve11, STARTUP_POLL_MS));
+    await new Promise((resolve12) => setTimeout(resolve12, STARTUP_POLL_MS));
   }
   throw new Error(`Session host did not become ready within ${timeoutMs}ms`);
 }
 function resolveSessionHostEntry() {
   const localCandidates = [
-    path.resolve(__dirname, "../vendor/session-host-daemon/index.js"),
-    path.resolve(__dirname, "../../vendor/session-host-daemon/index.js")
+    path15.resolve(__dirname, "../vendor/session-host-daemon/index.js"),
+    path15.resolve(__dirname, "../../vendor/session-host-daemon/index.js")
   ];
   for (const candidate of localCandidates) {
     if (require("fs").existsSync(candidate)) {
@@ -33803,9 +33807,9 @@ async function runSessionHostCli(args) {
       ADHDEV_SESSION_HOST_NAME: SESSION_HOST_APP_NAME
     }
   });
-  return await new Promise((resolve11, reject) => {
+  return await new Promise((resolve12, reject) => {
     child.on("error", reject);
-    child.on("exit", (code) => resolve11(code ?? 0));
+    child.on("exit", (code) => resolve12(code ?? 0));
   });
 }
 async function ensureSessionHostReady() {
@@ -33930,8 +33934,8 @@ var AdhMuxControlClient = class {
       }
       this.waiters.clear();
     });
-    await new Promise((resolve11, reject) => {
-      socket.once("connect", () => resolve11());
+    await new Promise((resolve12, reject) => {
+      socket.once("connect", () => resolve12());
       socket.once("error", reject);
     });
   }
@@ -33940,8 +33944,8 @@ var AdhMuxControlClient = class {
     if (!this.socket) throw new Error("adhmux control socket unavailable");
     const requestId = `${Date.now()}-${Math.random().toString(36).slice(2)}`;
     const envelope = { kind: "request", requestId, request };
-    const response = await new Promise((resolve11, reject) => {
-      this.waiters.set(requestId, { resolve: resolve11, reject });
+    const response = await new Promise((resolve12, reject) => {
+      this.waiters.set(requestId, { resolve: resolve12, reject });
       this.socket?.write(serializeEnvelope2(envelope));
     });
     return response;
@@ -33960,12 +33964,12 @@ var AdhMuxControlClient = class {
       waiter.reject(new Error("adhmux control client closed"));
     }
     this.waiters.clear();
-    await new Promise((resolve11) => {
+    await new Promise((resolve12) => {
       let settled = false;
       const done = () => {
         if (settled) return;
         settled = true;
-        resolve11();
+        resolve12();
       };
       socket.once("close", done);
       socket.end();
@@ -34023,8 +34027,8 @@ var pkgVersion = process.env.ADHDEV_PKG_VERSION || "unknown";
 if (pkgVersion === "unknown") {
   try {
     const possiblePaths = [
-      path16.join(__dirname, "..", "package.json"),
-      path16.join(__dirname, "package.json")
+      path17.join(__dirname, "..", "package.json"),
+      path17.join(__dirname, "package.json")
     ];
     for (const candidate of possiblePaths) {
       try {
@@ -34128,9 +34132,9 @@ var StandaloneServer = class {
       this.broadcastStatus();
     }, STATUS_INTERVAL);
     this.running = true;
-    await new Promise((resolve11) => {
+    await new Promise((resolve12) => {
       this.httpServer.listen(port, host, () => {
-        resolve11();
+        resolve12();
       });
     });
     console.log("");
@@ -34324,9 +34328,9 @@ var StandaloneServer = class {
     }
     if (publicDir) {
       const filePath = url2 === "/" ? "/index.html" : url2;
-      const fullPath = path16.join(publicDir, filePath);
+      const fullPath = path17.join(publicDir, filePath);
       if (fs12.existsSync(fullPath) && fs12.statSync(fullPath).isFile()) {
-        const ext = path16.extname(fullPath);
+        const ext = path17.extname(fullPath);
         const mimeTypes = {
           ".html": "text/html",
           ".js": "application/javascript",
@@ -34341,7 +34345,7 @@ var StandaloneServer = class {
         fs12.createReadStream(fullPath).pipe(res);
         return;
       }
-      const indexPath = path16.join(publicDir, "index.html");
+      const indexPath = path17.join(publicDir, "index.html");
       if (fs12.existsSync(indexPath) && !url2.startsWith("/api/")) {
         res.writeHead(200, { "Content-Type": "text/html" });
         fs12.createReadStream(indexPath).pipe(res);
@@ -34648,12 +34652,12 @@ Runtime commands:
   }
   if (!options.publicDir) {
     const candidates = [
-      path16.join(__dirname, "../../web-standalone/dist"),
-      path16.join(__dirname, "../public"),
-      path16.join(process.cwd(), "public")
+      path17.join(__dirname, "../../web-standalone/dist"),
+      path17.join(__dirname, "../public"),
+      path17.join(process.cwd(), "public")
     ];
     for (const candidate of candidates) {
-      if (fs12.existsSync(path16.join(candidate, "index.html"))) {
+      if (fs12.existsSync(path17.join(candidate, "index.html"))) {
         options.publicDir = candidate;
         break;
       }