@tscircuit/cli 0.1.1250 → 0.1.1251

package/dist/cli/main.js

@@ -95346,18 +95346,18 @@ globstar while`, file, fr3, pattern, pr3, swallowee);
           abs = abs.replace(/\\/g, "/");
         return abs;
       }
-      function isIgnored(self2, path48) {
+      function isIgnored(self2, path49) {
         if (!self2.ignore.length)
           return false;
         return self2.ignore.some(function(item) {
-          return item.matcher.match(path48) || !!(item.gmatcher && item.gmatcher.match(path48));
+          return item.matcher.match(path49) || !!(item.gmatcher && item.gmatcher.match(path49));
         });
       }
-      function childrenIgnored(self2, path48) {
+      function childrenIgnored(self2, path49) {
         if (!self2.ignore.length)
           return false;
         return self2.ignore.some(function(item) {
-          return !!(item.gmatcher && item.gmatcher.match(path48));
+          return !!(item.gmatcher && item.gmatcher.match(path49));
         });
       }
     }
@@ -96388,8 +96388,8 @@ See: https://github.com/isaacs/node-glob/issues/167`);
     "node_modules/glob-promise/lib/index.js"(exports3, module22) {
       var glob2 = require_glob();
       var promise = function(pattern, options) {
-        return new Promise((resolve9, reject) => {
-          glob2(pattern, options, (err, files) => err === null ? resolve9(files) : reject(err));
+        return new Promise((resolve10, reject) => {
+          glob2(pattern, options, (err, files) => err === null ? resolve10(files) : reject(err));
         });
       };
       module22.exports = promise;
@@ -99964,7 +99964,7 @@ var import_perfect_cli = __toESM2(require_dist2(), 1);
 // lib/getVersion.ts
 import { createRequire as createRequire2 } from "node:module";
 // package.json
-var version = "0.1.1249";
+var version = "0.1.1250";
 var package_default = {
   name: "@tscircuit/cli",
   version,
@@ -241656,9 +241656,64 @@ import * as fs51 from "node:fs";
 import * as net from "node:net";
 import * as path54 from "node:path";
 
-// cli/dev/DevServer.ts
-import fs49 from "node:fs";
-import path52 from "node:path";
+// cli/dev/resolve-dev-target.ts
+import * as fs45 from "node:fs";
+import * as path47 from "node:path";
+var findSelectableFiles = (projectDir) => {
+  const boardFiles = findBoardFiles({ projectDir }).filter((file) => fs45.existsSync(file)).sort();
+  if (boardFiles.length > 0) {
+    return boardFiles;
+  }
+  const files = globbySync(["**/*.tsx", "**/*.ts", "**/*.circuit.json"], {
+    cwd: projectDir,
+    ignore: DEFAULT_IGNORED_PATTERNS
+  });
+  return files.map((file) => path47.resolve(projectDir, file)).filter((file) => fs45.existsSync(file)).sort();
+};
+var isValidDevFile = (filePath) => {
+  return filePath.endsWith(".tsx") || filePath.endsWith(".ts") || filePath.endsWith(".circuit.json");
+};
+var resolveDevTarget = async (file) => {
+  let projectDir = process.cwd();
+  if (file) {
+    const resolvedPath = path47.resolve(file);
+    if (fs45.existsSync(resolvedPath) && fs45.statSync(resolvedPath).isDirectory()) {
+      projectDir = resolvedPath;
+      const availableFiles2 = findSelectableFiles(projectDir);
+      if (availableFiles2.length === 0) {
+        console.log(`No .tsx, .ts, or .circuit.json files found in ${projectDir}. Run 'tsci init' to bootstrap a basic project.`);
+        return null;
+      }
+      console.log("Selected file:", path47.relative(projectDir, availableFiles2[0]));
+      return { absolutePath: availableFiles2[0], projectDir };
+    }
+    if (!fs45.existsSync(resolvedPath)) {
+      console.error(`Error: File not found: ${file}`);
+      return null;
+    }
+    if (!isValidDevFile(resolvedPath)) {
+      console.error("Error: Only .tsx, .ts, and .circuit.json files are supported");
+      return null;
+    }
+    return { absolutePath: resolvedPath, projectDir };
+  }
+  const entrypointPath = await getEntrypoint({ onError: () => {} });
+  if (entrypointPath && fs45.existsSync(entrypointPath)) {
+    console.log("Found entrypoint at:", entrypointPath);
+    return { absolutePath: entrypointPath, projectDir };
+  }
+  const availableFiles = findSelectableFiles(projectDir);
+  if (availableFiles.length === 0) {
+    console.log("No .tsx, .ts, or .circuit.json files found in the project. Run 'tsci init' to bootstrap a basic project.");
+    return null;
+  }
+  console.log("Selected file:", path47.relative(projectDir, availableFiles[0]));
+  return { absolutePath: availableFiles[0], projectDir };
+};
+
+// lib/dev/DevServer.ts
+import fs50 from "node:fs";
+import path53 from "node:path";
 
 // node_modules/chokidar/esm/index.js
 import { stat as statcb } from "fs";
@@ -241737,7 +241792,7 @@ class ReaddirpStream extends Readable {
     this._directoryFilter = normalizeFilter(opts.directoryFilter);
     const statMethod = opts.lstat ? lstat : stat;
     if (wantBigintFsStats) {
-      this._stat = (path47) => statMethod(path47, { bigint: true });
+      this._stat = (path48) => statMethod(path48, { bigint: true });
     } else {
       this._stat = statMethod;
     }
@@ -241762,8 +241817,8 @@ class ReaddirpStream extends Readable {
         const par = this.parent;
         const fil = par && par.files;
         if (fil && fil.length > 0) {
-          const { path: path47, depth } = par;
-          const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path47));
+          const { path: path48, depth } = par;
+          const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path48));
           const awaited = await Promise.all(slice);
           for (const entry of awaited) {
             if (!entry)
@@ -241803,20 +241858,20 @@ class ReaddirpStream extends Readable {
       this.reading = false;
     }
   }
-  async _exploreDir(path47, depth) {
+  async _exploreDir(path48, depth) {
     let files;
     try {
-      files = await readdir(path47, this._rdOptions);
+      files = await readdir(path48, this._rdOptions);
     } catch (error) {
       this._onError(error);
     }
-    return { files, depth, path: path47 };
+    return { files, depth, path: path48 };
   }
-  async _formatEntry(dirent, path47) {
+  async _formatEntry(dirent, path48) {
     let entry;
     const basename4 = this._isDirent ? dirent.name : dirent;
     try {
-      const fullPath = presolve(pjoin(path47, basename4));
+      const fullPath = presolve(pjoin(path48, basename4));
       entry = { path: prelative(this._root, fullPath), fullPath, basename: basename4 };
       entry[this._statsProp] = this._isDirent ? dirent : await this._stat(fullPath);
     } catch (err) {
@@ -242214,16 +242269,16 @@ var delFromSet = (main, prop, item) => {
 };
 var isEmptySet = (val) => val instanceof Set ? val.size === 0 : !val;
 var FsWatchInstances = new Map;
-function createFsWatchInstance(path47, options, listener, errHandler, emitRaw) {
+function createFsWatchInstance(path48, options, listener, errHandler, emitRaw) {
   const handleEvent = (rawEvent, evPath) => {
-    listener(path47);
-    emitRaw(rawEvent, evPath, { watchedPath: path47 });
-    if (evPath && path47 !== evPath) {
-      fsWatchBroadcast(sysPath.resolve(path47, evPath), KEY_LISTENERS, sysPath.join(path47, evPath));
+    listener(path48);
+    emitRaw(rawEvent, evPath, { watchedPath: path48 });
+    if (evPath && path48 !== evPath) {
+      fsWatchBroadcast(sysPath.resolve(path48, evPath), KEY_LISTENERS, sysPath.join(path48, evPath));
     }
   };
   try {
-    return fs_watch(path47, {
+    return fs_watch(path48, {
       persistent: options.persistent
     }, handleEvent);
   } catch (error) {
@@ -242239,12 +242294,12 @@ var fsWatchBroadcast = (fullPath, listenerType, val1, val2, val3) => {
     listener(val1, val2, val3);
   });
 };
-var setFsWatchListener = (path47, fullPath, options, handlers) => {
+var setFsWatchListener = (path48, fullPath, options, handlers) => {
   const { listener, errHandler, rawEmitter } = handlers;
   let cont = FsWatchInstances.get(fullPath);
   let watcher;
   if (!options.persistent) {
-    watcher = createFsWatchInstance(path47, options, listener, errHandler, rawEmitter);
+    watcher = createFsWatchInstance(path48, options, listener, errHandler, rawEmitter);
     if (!watcher)
       return;
     return watcher.close.bind(watcher);
@@ -242254,7 +242309,7 @@ var setFsWatchListener = (path47, fullPath, options, handlers) => {
     addAndConvert(cont, KEY_ERR, errHandler);
     addAndConvert(cont, KEY_RAW, rawEmitter);
   } else {
-    watcher = createFsWatchInstance(path47, options, fsWatchBroadcast.bind(null, fullPath, KEY_LISTENERS), errHandler, fsWatchBroadcast.bind(null, fullPath, KEY_RAW));
+    watcher = createFsWatchInstance(path48, options, fsWatchBroadcast.bind(null, fullPath, KEY_LISTENERS), errHandler, fsWatchBroadcast.bind(null, fullPath, KEY_RAW));
     if (!watcher)
       return;
     watcher.on(EV.ERROR, async (error) => {
@@ -242263,7 +242318,7 @@ var setFsWatchListener = (path47, fullPath, options, handlers) => {
         cont.watcherUnusable = true;
       if (isWindows && error.code === "EPERM") {
         try {
-          const fd3 = await open(path47, "r");
+          const fd3 = await open(path48, "r");
           await fd3.close();
           broadcastErr(error);
         } catch (err) {}
@@ -242293,7 +242348,7 @@ var setFsWatchListener = (path47, fullPath, options, handlers) => {
   };
 };
 var FsWatchFileInstances = new Map;
-var setFsWatchFileListener = (path47, fullPath, options, handlers) => {
+var setFsWatchFileListener = (path48, fullPath, options, handlers) => {
   const { listener, rawEmitter } = handlers;
   let cont = FsWatchFileInstances.get(fullPath);
   const copts = cont && cont.options;
@@ -242315,7 +242370,7 @@ var setFsWatchFileListener = (path47, fullPath, options, handlers) => {
         });
         const currmtime = curr.mtimeMs;
         if (curr.size !== prev.size || currmtime > prev.mtimeMs || currmtime === 0) {
-          foreach(cont.listeners, (listener2) => listener2(path47, curr));
+          foreach(cont.listeners, (listener2) => listener2(path48, curr));
         }
       })
     };
@@ -242338,13 +242393,13 @@ class NodeFsHandler {
     this.fsw = fsW;
     this._boundHandleError = (error) => fsW._handleError(error);
   }
-  _watchWithNodeFs(path47, listener) {
+  _watchWithNodeFs(path48, listener) {
     const opts = this.fsw.options;
-    const directory = sysPath.dirname(path47);
-    const basename5 = sysPath.basename(path47);
+    const directory = sysPath.dirname(path48);
+    const basename5 = sysPath.basename(path48);
     const parent = this.fsw._getWatchedDir(directory);
     parent.add(basename5);
-    const absolutePath = sysPath.resolve(path47);
+    const absolutePath = sysPath.resolve(path48);
     const options = {
       persistent: opts.persistent
     };
@@ -242354,12 +242409,12 @@ class NodeFsHandler {
     if (opts.usePolling) {
       const enableBin = opts.interval !== opts.binaryInterval;
       options.interval = enableBin && isBinaryPath(basename5) ? opts.binaryInterval : opts.interval;
-      closer = setFsWatchFileListener(path47, absolutePath, options, {
+      closer = setFsWatchFileListener(path48, absolutePath, options, {
         listener,
         rawEmitter: this.fsw._emitRaw
       });
     } else {
-      closer = setFsWatchListener(path47, absolutePath, options, {
+      closer = setFsWatchListener(path48, absolutePath, options, {
         listener,
         errHandler: this._boundHandleError,
         rawEmitter: this.fsw._emitRaw
@@ -242377,7 +242432,7 @@ class NodeFsHandler {
     let prevStats = stats;
     if (parent.has(basename5))
       return;
-    const listener = async (path47, newStats) => {
+    const listener = async (path48, newStats) => {
       if (!this.fsw._throttle(THROTTLE_MODE_WATCH, file, 5))
         return;
       if (!newStats || newStats.mtimeMs === 0) {
@@ -242391,11 +242446,11 @@ class NodeFsHandler {
             this.fsw._emit(EV.CHANGE, file, newStats2);
           }
           if ((isMacos || isLinux) && prevStats.ino !== newStats2.ino) {
-            this.fsw._closeFile(path47);
+            this.fsw._closeFile(path48);
             prevStats = newStats2;
             const closer2 = this._watchWithNodeFs(file, listener);
             if (closer2)
-              this.fsw._addPathCloser(path47, closer2);
+              this.fsw._addPathCloser(path48, closer2);
           } else {
             prevStats = newStats2;
           }
@@ -242419,7 +242474,7 @@ class NodeFsHandler {
     }
     return closer;
   }
-  async _handleSymlink(entry, directory, path47, item) {
+  async _handleSymlink(entry, directory, path48, item) {
     if (this.fsw.closed) {
       return;
     }
@@ -242429,7 +242484,7 @@ class NodeFsHandler {
       this.fsw._incrReadyCount();
       let linkPath;
       try {
-        linkPath = await fsrealpath(path47);
+        linkPath = await fsrealpath(path48);
       } catch (e4) {
         this.fsw._emitReady();
         return true;
@@ -242439,12 +242494,12 @@ class NodeFsHandler {
       if (dir.has(item)) {
         if (this.fsw._symlinkPaths.get(full) !== linkPath) {
           this.fsw._symlinkPaths.set(full, linkPath);
-          this.fsw._emit(EV.CHANGE, path47, entry.stats);
+          this.fsw._emit(EV.CHANGE, path48, entry.stats);
         }
       } else {
         dir.add(item);
         this.fsw._symlinkPaths.set(full, linkPath);
-        this.fsw._emit(EV.ADD, path47, entry.stats);
+        this.fsw._emit(EV.ADD, path48, entry.stats);
       }
       this.fsw._emitReady();
       return true;
@@ -242473,9 +242528,9 @@ class NodeFsHandler {
         return;
       }
       const item = entry.path;
-      let path47 = sysPath.join(directory, item);
+      let path48 = sysPath.join(directory, item);
       current2.add(item);
-      if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path47, item)) {
+      if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path48, item)) {
         return;
       }
       if (this.fsw.closed) {
@@ -242484,11 +242539,11 @@ class NodeFsHandler {
       }
       if (item === target || !target && !previous.has(item)) {
         this.fsw._incrReadyCount();
-        path47 = sysPath.join(dir, sysPath.relative(dir, path47));
-        this._addToNodeFs(path47, initialAdd, wh3, depth + 1);
+        path48 = sysPath.join(dir, sysPath.relative(dir, path48));
+        this._addToNodeFs(path48, initialAdd, wh3, depth + 1);
       }
     }).on(EV.ERROR, this._boundHandleError);
-    return new Promise((resolve7, reject) => {
+    return new Promise((resolve8, reject) => {
       if (!stream)
         return reject();
       stream.once(STR_END, () => {
@@ -242497,7 +242552,7 @@ class NodeFsHandler {
           return;
         }
         const wasThrottled = throttler ? throttler.clear() : false;
-        resolve7(undefined);
+        resolve8(undefined);
         previous.getChildren().filter((item) => {
           return item !== directory && !current2.has(item);
         }).forEach((item) => {
@@ -242534,13 +242589,13 @@ class NodeFsHandler {
     }
     return closer;
   }
-  async _addToNodeFs(path47, initialAdd, priorWh, depth, target) {
+  async _addToNodeFs(path48, initialAdd, priorWh, depth, target) {
     const ready = this.fsw._emitReady;
-    if (this.fsw._isIgnored(path47) || this.fsw.closed) {
+    if (this.fsw._isIgnored(path48) || this.fsw.closed) {
       ready();
       return false;
     }
-    const wh3 = this.fsw._getWatchHelpers(path47);
+    const wh3 = this.fsw._getWatchHelpers(path48);
     if (priorWh) {
       wh3.filterPath = (entry) => priorWh.filterPath(entry);
       wh3.filterDir = (entry) => priorWh.filterDir(entry);
@@ -242556,8 +242611,8 @@ class NodeFsHandler {
       const follow = this.fsw.options.followSymlinks;
       let closer;
       if (stats.isDirectory()) {
-        const absPath = sysPath.resolve(path47);
-        const targetPath = follow ? await fsrealpath(path47) : path47;
+        const absPath = sysPath.resolve(path48);
+        const targetPath = follow ? await fsrealpath(path48) : path48;
         if (this.fsw.closed)
           return;
         closer = await this._handleDir(wh3.watchPath, stats, initialAdd, depth, target, wh3, targetPath);
@@ -242567,29 +242622,29 @@ class NodeFsHandler {
           this.fsw._symlinkPaths.set(absPath, targetPath);
         }
       } else if (stats.isSymbolicLink()) {
-        const targetPath = follow ? await fsrealpath(path47) : path47;
+        const targetPath = follow ? await fsrealpath(path48) : path48;
         if (this.fsw.closed)
           return;
         const parent = sysPath.dirname(wh3.watchPath);
         this.fsw._getWatchedDir(parent).add(wh3.watchPath);
         this.fsw._emit(EV.ADD, wh3.watchPath, stats);
-        closer = await this._handleDir(parent, stats, initialAdd, depth, path47, wh3, targetPath);
+        closer = await this._handleDir(parent, stats, initialAdd, depth, path48, wh3, targetPath);
         if (this.fsw.closed)
           return;
         if (targetPath !== undefined) {
-          this.fsw._symlinkPaths.set(sysPath.resolve(path47), targetPath);
+          this.fsw._symlinkPaths.set(sysPath.resolve(path48), targetPath);
         }
       } else {
         closer = this._handleFile(wh3.watchPath, stats, initialAdd);
       }
       ready();
       if (closer)
-        this.fsw._addPathCloser(path47, closer);
+        this.fsw._addPathCloser(path48, closer);
       return false;
     } catch (error) {
       if (this.fsw._handleError(error)) {
         ready();
-        return path47;
+        return path48;
       }
     }
   }
@@ -242621,37 +242676,37 @@ function createPattern(matcher) {
       if (matcher.path === string)
         return true;
       if (matcher.recursive) {
-        const relative7 = sysPath2.relative(matcher.path, string);
-        if (!relative7) {
+        const relative8 = sysPath2.relative(matcher.path, string);
+        if (!relative8) {
           return false;
         }
-        return !relative7.startsWith("..") && !sysPath2.isAbsolute(relative7);
+        return !relative8.startsWith("..") && !sysPath2.isAbsolute(relative8);
       }
       return false;
     };
   }
   return () => false;
 }
-function normalizePath(path47) {
-  if (typeof path47 !== "string")
+function normalizePath(path48) {
+  if (typeof path48 !== "string")
     throw new Error("string expected");
-  path47 = sysPath2.normalize(path47);
-  path47 = path47.replace(/\\/g, "/");
+  path48 = sysPath2.normalize(path48);
+  path48 = path48.replace(/\\/g, "/");
   let prepend2 = false;
-  if (path47.startsWith("//"))
+  if (path48.startsWith("//"))
     prepend2 = true;
   const DOUBLE_SLASH_RE2 = /\/\//;
-  while (path47.match(DOUBLE_SLASH_RE2))
-    path47 = path47.replace(DOUBLE_SLASH_RE2, "/");
+  while (path48.match(DOUBLE_SLASH_RE2))
+    path48 = path48.replace(DOUBLE_SLASH_RE2, "/");
   if (prepend2)
-    path47 = "/" + path47;
-  return path47;
+    path48 = "/" + path48;
+  return path48;
 }
 function matchPatterns(patterns, testString, stats) {
-  const path47 = normalizePath(testString);
+  const path48 = normalizePath(testString);
   for (let index = 0;index < patterns.length; index++) {
     const pattern = patterns[index];
-    if (pattern(path47, stats)) {
+    if (pattern(path48, stats)) {
       return true;
     }
   }
@@ -242691,19 +242746,19 @@ var toUnix = (string) => {
   }
   return str;
 };
-var normalizePathToUnix = (path47) => toUnix(sysPath2.normalize(toUnix(path47)));
-var normalizeIgnored = (cwd = "") => (path47) => {
-  if (typeof path47 === "string") {
-    return normalizePathToUnix(sysPath2.isAbsolute(path47) ? path47 : sysPath2.join(cwd, path47));
+var normalizePathToUnix = (path48) => toUnix(sysPath2.normalize(toUnix(path48)));
+var normalizeIgnored = (cwd = "") => (path48) => {
+  if (typeof path48 === "string") {
+    return normalizePathToUnix(sysPath2.isAbsolute(path48) ? path48 : sysPath2.join(cwd, path48));
   } else {
-    return path47;
+    return path48;
   }
 };
-var getAbsolutePath = (path47, cwd) => {
-  if (sysPath2.isAbsolute(path47)) {
-    return path47;
+var getAbsolutePath = (path48, cwd) => {
+  if (sysPath2.isAbsolute(path48)) {
+    return path48;
   }
-  return sysPath2.join(cwd, path47);
+  return sysPath2.join(cwd, path48);
 };
 var EMPTY_SET = Object.freeze(new Set);
 
@@ -242760,10 +242815,10 @@ var STAT_METHOD_F = "stat";
 var STAT_METHOD_L = "lstat";
 
 class WatchHelper {
-  constructor(path47, follow, fsw) {
+  constructor(path48, follow, fsw) {
     this.fsw = fsw;
-    const watchPath = path47;
-    this.path = path47 = path47.replace(REPLACER_RE, "");
+    const watchPath = path48;
+    this.path = path48 = path48.replace(REPLACER_RE, "");
     this.watchPath = watchPath;
     this.fullWatchPath = sysPath2.resolve(watchPath);
     this.dirParts = [];
@@ -242876,20 +242931,20 @@ class FSWatcher extends EventEmitter {
     this._closePromise = undefined;
     let paths = unifyPaths(paths_);
     if (cwd) {
-      paths = paths.map((path47) => {
-        const absPath = getAbsolutePath(path47, cwd);
+      paths = paths.map((path48) => {
+        const absPath = getAbsolutePath(path48, cwd);
         return absPath;
       });
     }
-    paths.forEach((path47) => {
-      this._removeIgnoredPath(path47);
+    paths.forEach((path48) => {
+      this._removeIgnoredPath(path48);
     });
     this._userIgnored = undefined;
     if (!this._readyCount)
       this._readyCount = 0;
     this._readyCount += paths.length;
-    Promise.all(paths.map(async (path47) => {
-      const res2 = await this._nodeFsHandler._addToNodeFs(path47, !_internal, undefined, 0, _origAdd);
+    Promise.all(paths.map(async (path48) => {
+      const res2 = await this._nodeFsHandler._addToNodeFs(path48, !_internal, undefined, 0, _origAdd);
       if (res2)
         this._emitReady();
       return res2;
@@ -242908,17 +242963,17 @@ class FSWatcher extends EventEmitter {
       return this;
     const paths = unifyPaths(paths_);
     const { cwd } = this.options;
-    paths.forEach((path47) => {
-      if (!sysPath2.isAbsolute(path47) && !this._closers.has(path47)) {
+    paths.forEach((path48) => {
+      if (!sysPath2.isAbsolute(path48) && !this._closers.has(path48)) {
         if (cwd)
-          path47 = sysPath2.join(cwd, path47);
-        path47 = sysPath2.resolve(path47);
+          path48 = sysPath2.join(cwd, path48);
+        path48 = sysPath2.resolve(path48);
       }
-      this._closePath(path47);
-      this._addIgnoredPath(path47);
-      if (this._watched.has(path47)) {
+      this._closePath(path48);
+      this._addIgnoredPath(path48);
+      if (this._watched.has(path48)) {
         this._addIgnoredPath({
-          path: path47,
+          path: path48,
           recursive: true
         });
       }
@@ -242967,38 +243022,38 @@ class FSWatcher extends EventEmitter {
     if (event !== EVENTS.ERROR)
       this.emit(EVENTS.ALL, ...args);
   }
-  async _emit(event, path47, stats) {
+  async _emit(event, path48, stats) {
     if (this.closed)
       return;
     const opts = this.options;
     if (isWindows)
-      path47 = sysPath2.normalize(path47);
+      path48 = sysPath2.normalize(path48);
     if (opts.cwd)
-      path47 = sysPath2.relative(opts.cwd, path47);
-    const args = [event, path47];
+      path48 = sysPath2.relative(opts.cwd, path48);
+    const args = [event, path48];
     if (stats != null)
       args.push(stats);
     const awf = opts.awaitWriteFinish;
     let pw;
-    if (awf && (pw = this._pendingWrites.get(path47))) {
+    if (awf && (pw = this._pendingWrites.get(path48))) {
       pw.lastChange = new Date;
       return this;
     }
     if (opts.atomic) {
       if (event === EVENTS.UNLINK) {
-        this._pendingUnlinks.set(path47, args);
+        this._pendingUnlinks.set(path48, args);
         setTimeout(() => {
-          this._pendingUnlinks.forEach((entry, path48) => {
+          this._pendingUnlinks.forEach((entry, path49) => {
             this.emit(...entry);
             this.emit(EVENTS.ALL, ...entry);
-            this._pendingUnlinks.delete(path48);
+            this._pendingUnlinks.delete(path49);
           });
         }, typeof opts.atomic === "number" ? opts.atomic : 100);
         return this;
       }
-      if (event === EVENTS.ADD && this._pendingUnlinks.has(path47)) {
+      if (event === EVENTS.ADD && this._pendingUnlinks.has(path48)) {
         event = args[0] = EVENTS.CHANGE;
-        this._pendingUnlinks.delete(path47);
+        this._pendingUnlinks.delete(path48);
       }
     }
     if (awf && (event === EVENTS.ADD || event === EVENTS.CHANGE) && this._readyEmitted) {
@@ -243016,16 +243071,16 @@ class FSWatcher extends EventEmitter {
           this.emitWithAll(event, args);
         }
       };
-      this._awaitWriteFinish(path47, awf.stabilityThreshold, event, awfEmit);
+      this._awaitWriteFinish(path48, awf.stabilityThreshold, event, awfEmit);
       return this;
     }
     if (event === EVENTS.CHANGE) {
-      const isThrottled = !this._throttle(EVENTS.CHANGE, path47, 50);
+      const isThrottled = !this._throttle(EVENTS.CHANGE, path48, 50);
       if (isThrottled)
         return this;
     }
     if (opts.alwaysStat && stats === undefined && (event === EVENTS.ADD || event === EVENTS.ADD_DIR || event === EVENTS.CHANGE)) {
-      const fullPath = opts.cwd ? sysPath2.join(opts.cwd, path47) : path47;
+      const fullPath = opts.cwd ? sysPath2.join(opts.cwd, path48) : path48;
       let stats2;
       try {
         stats2 = await stat3(fullPath);
@@ -243044,23 +243099,23 @@ class FSWatcher extends EventEmitter {
     }
     return error || this.closed;
   }
-  _throttle(actionType, path47, timeout2) {
+  _throttle(actionType, path48, timeout2) {
     if (!this._throttled.has(actionType)) {
       this._throttled.set(actionType, new Map);
     }
     const action = this._throttled.get(actionType);
     if (!action)
       throw new Error("invalid throttle");
-    const actionPath = action.get(path47);
+    const actionPath = action.get(path48);
     if (actionPath) {
       actionPath.count++;
       return false;
     }
     let timeoutObject;
     const clear = () => {
-      const item = action.get(path47);
+      const item = action.get(path48);
       const count = item ? item.count : 0;
-      action.delete(path47);
+      action.delete(path48);
       clearTimeout(timeoutObject);
       if (item)
         clearTimeout(item.timeoutObject);
@@ -243068,50 +243123,50 @@ class FSWatcher extends EventEmitter {
     };
     timeoutObject = setTimeout(clear, timeout2);
     const thr = { timeoutObject, clear, count: 0 };
-    action.set(path47, thr);
+    action.set(path48, thr);
     return thr;
   }
   _incrReadyCount() {
     return this._readyCount++;
   }
-  _awaitWriteFinish(path47, threshold, event, awfEmit) {
+  _awaitWriteFinish(path48, threshold, event, awfEmit) {
     const awf = this.options.awaitWriteFinish;
     if (typeof awf !== "object")
       return;
     const pollInterval = awf.pollInterval;
     let timeoutHandler;
-    let fullPath = path47;
-    if (this.options.cwd && !sysPath2.isAbsolute(path47)) {
-      fullPath = sysPath2.join(this.options.cwd, path47);
+    let fullPath = path48;
+    if (this.options.cwd && !sysPath2.isAbsolute(path48)) {
+      fullPath = sysPath2.join(this.options.cwd, path48);
     }
     const now = new Date;
     const writes = this._pendingWrites;
     function awaitWriteFinishFn(prevStat) {
       statcb(fullPath, (err, curStat) => {
-        if (err || !writes.has(path47)) {
+        if (err || !writes.has(path48)) {
           if (err && err.code !== "ENOENT")
             awfEmit(err);
           return;
         }
         const now2 = Number(new Date);
         if (prevStat && curStat.size !== prevStat.size) {
-          writes.get(path47).lastChange = now2;
+          writes.get(path48).lastChange = now2;
         }
-        const pw = writes.get(path47);
+        const pw = writes.get(path48);
         const df3 = now2 - pw.lastChange;
         if (df3 >= threshold) {
-          writes.delete(path47);
+          writes.delete(path48);
           awfEmit(undefined, curStat);
         } else {
           timeoutHandler = setTimeout(awaitWriteFinishFn, pollInterval, curStat);
         }
       });
     }
-    if (!writes.has(path47)) {
-      writes.set(path47, {
+    if (!writes.has(path48)) {
+      writes.set(path48, {
         lastChange: now,
         cancelWait: () => {
-          writes.delete(path47);
+          writes.delete(path48);
           clearTimeout(timeoutHandler);
           return event;
         }
@@ -243119,8 +243174,8 @@ class FSWatcher extends EventEmitter {
       timeoutHandler = setTimeout(awaitWriteFinishFn, pollInterval);
     }
   }
-  _isIgnored(path47, stats) {
-    if (this.options.atomic && DOT_RE.test(path47))
+  _isIgnored(path48, stats) {
+    if (this.options.atomic && DOT_RE.test(path48))
       return true;
     if (!this._userIgnored) {
       const { cwd } = this.options;
@@ -243130,13 +243185,13 @@ class FSWatcher extends EventEmitter {
       const list = [...ignoredPaths.map(normalizeIgnored(cwd)), ...ignored];
       this._userIgnored = anymatch(list, undefined);
     }
-    return this._userIgnored(path47, stats);
+    return this._userIgnored(path48, stats);
   }
-  _isntIgnored(path47, stat4) {
-    return !this._isIgnored(path47, stat4);
+  _isntIgnored(path48, stat4) {
+    return !this._isIgnored(path48, stat4);
   }
-  _getWatchHelpers(path47) {
-    return new WatchHelper(path47, this.options.followSymlinks, this);
+  _getWatchHelpers(path48) {
+    return new WatchHelper(path48, this.options.followSymlinks, this);
   }
   _getWatchedDir(directory) {
     const dir = sysPath2.resolve(directory);
@@ -243150,57 +243205,57 @@ class FSWatcher extends EventEmitter {
     return Boolean(Number(stats.mode) & 256);
   }
   _remove(directory, item, isDirectory2) {
-    const path47 = sysPath2.join(directory, item);
-    const fullPath = sysPath2.resolve(path47);
-    isDirectory2 = isDirectory2 != null ? isDirectory2 : this._watched.has(path47) || this._watched.has(fullPath);
-    if (!this._throttle("remove", path47, 100))
+    const path48 = sysPath2.join(directory, item);
+    const fullPath = sysPath2.resolve(path48);
+    isDirectory2 = isDirectory2 != null ? isDirectory2 : this._watched.has(path48) || this._watched.has(fullPath);
+    if (!this._throttle("remove", path48, 100))
       return;
     if (!isDirectory2 && this._watched.size === 1) {
       this.add(directory, item, true);
     }
-    const wp3 = this._getWatchedDir(path47);
+    const wp3 = this._getWatchedDir(path48);
     const nestedDirectoryChildren = wp3.getChildren();
-    nestedDirectoryChildren.forEach((nested) => this._remove(path47, nested));
+    nestedDirectoryChildren.forEach((nested) => this._remove(path48, 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 = path47;
+    let relPath = path48;
     if (this.options.cwd)
-      relPath = sysPath2.relative(this.options.cwd, path47);
+      relPath = sysPath2.relative(this.options.cwd, path48);
     if (this.options.awaitWriteFinish && this._pendingWrites.has(relPath)) {
       const event = this._pendingWrites.get(relPath).cancelWait();
       if (event === EVENTS.ADD)
         return;
     }
-    this._watched.delete(path47);
+    this._watched.delete(path48);
     this._watched.delete(fullPath);
     const eventName = isDirectory2 ? EVENTS.UNLINK_DIR : EVENTS.UNLINK;
-    if (wasTracked && !this._isIgnored(path47))
-      this._emit(eventName, path47);
-    this._closePath(path47);
+    if (wasTracked && !this._isIgnored(path48))
+      this._emit(eventName, path48);
+    this._closePath(path48);
   }
-  _closePath(path47) {
-    this._closeFile(path47);
-    const dir = sysPath2.dirname(path47);
-    this._getWatchedDir(dir).remove(sysPath2.basename(path47));
+  _closePath(path48) {
+    this._closeFile(path48);
+    const dir = sysPath2.dirname(path48);
+    this._getWatchedDir(dir).remove(sysPath2.basename(path48));
   }
-  _closeFile(path47) {
-    const closers = this._closers.get(path47);
+  _closeFile(path48) {
+    const closers = this._closers.get(path48);
     if (!closers)
       return;
     closers.forEach((closer) => closer());
-    this._closers.delete(path47);
+    this._closers.delete(path48);
   }
-  _addPathCloser(path47, closer) {
+  _addPathCloser(path48, closer) {
     if (!closer)
       return;
-    let list = this._closers.get(path47);
+    let list = this._closers.get(path48);
     if (!list) {
       list = [];
-      this._closers.set(path47, list);
+      this._closers.set(path48, list);
     }
     list.push(closer);
   }
@@ -243228,21 +243283,21 @@ function watch(paths, options = {}) {
   return watcher;
 }
 
-// cli/dev/DevServer.ts
+// lib/dev/DevServer.ts
 import Debug3 from "debug";
 
 // lib/dependency-analysis/getNodeModuleDependencies.ts
 import * as ts3 from "typescript";
-import * as path47 from "path";
-import * as fs45 from "fs";
+import * as path48 from "path";
+import * as fs46 from "fs";
 function getAllDependencyPackages(projectDir) {
-  const packageJsonPath = path47.join(projectDir, "package.json");
+  const packageJsonPath = path48.join(projectDir, "package.json");
   const allPackages = new Set;
-  if (!fs45.existsSync(packageJsonPath)) {
+  if (!fs46.existsSync(packageJsonPath)) {
     return allPackages;
   }
   try {
-    const packageJson = JSON.parse(fs45.readFileSync(packageJsonPath, "utf-8"));
+    const packageJson = JSON.parse(fs46.readFileSync(packageJsonPath, "utf-8"));
     const deps = packageJson.dependencies || {};
     const devDeps = packageJson.devDependencies || {};
     for (const packageName of Object.keys(deps)) {
@@ -243257,11 +243312,11 @@ function getAllDependencyPackages(projectDir) {
   return allPackages;
 }
 function getNodeModuleImports(filePath) {
-  const absolutePath = path47.resolve(filePath);
-  if (!fs45.existsSync(absolutePath)) {
+  const absolutePath = path48.resolve(filePath);
+  if (!fs46.existsSync(absolutePath)) {
     return [];
   }
-  const content = fs45.readFileSync(absolutePath, "utf-8");
+  const content = fs46.readFileSync(absolutePath, "utf-8");
   const sourceFile = ts3.createSourceFile(absolutePath, content, ts3.ScriptTarget.Latest, true);
   const imports = new Set;
   function visit(node) {
@@ -243311,17 +243366,17 @@ function resolveNodeModuleImport({
 }) {
   const packageName = getPackageNameFromImport(importPath);
   const searchPaths = [
-    path47.join(projectDir, "node_modules", packageName)
+    path48.join(projectDir, "node_modules", packageName)
   ];
   if (searchFromDir) {
-    let currentDir = path47.dirname(searchFromDir);
-    const projectDirNormalized = path47.normalize(projectDir);
+    let currentDir = path48.dirname(searchFromDir);
+    const projectDirNormalized = path48.normalize(projectDir);
     while (currentDir.startsWith(projectDirNormalized)) {
-      const candidatePath = path47.join(currentDir, "node_modules", packageName);
+      const candidatePath = path48.join(currentDir, "node_modules", packageName);
       if (!searchPaths.includes(candidatePath)) {
         searchPaths.push(candidatePath);
       }
-      const parentDir = path47.dirname(currentDir);
+      const parentDir = path48.dirname(currentDir);
       if (parentDir === currentDir)
         break;
       currentDir = parentDir;
@@ -243329,7 +243384,7 @@ function resolveNodeModuleImport({
   }
   let packageDir;
   for (const candidatePath of searchPaths) {
-    if (fs45.existsSync(candidatePath)) {
+    if (fs46.existsSync(candidatePath)) {
       packageDir = candidatePath;
       break;
     }
@@ -243337,25 +243392,25 @@ function resolveNodeModuleImport({
   if (!packageDir) {
     return [];
   }
-  const packageJsonPath = path47.join(packageDir, "package.json");
-  const hasPackageJson = fs45.existsSync(packageJsonPath);
-  const packageJson = hasPackageJson ? JSON.parse(fs45.readFileSync(packageJsonPath, "utf-8")) : null;
+  const packageJsonPath = path48.join(packageDir, "package.json");
+  const hasPackageJson = fs46.existsSync(packageJsonPath);
+  const packageJson = hasPackageJson ? JSON.parse(fs46.readFileSync(packageJsonPath, "utf-8")) : null;
   const resolvedFiles = [];
   if (importPath !== packageName) {
     const subpath = importPath.slice(packageName.length + 1);
     const possiblePaths = [
-      path47.join(packageDir, subpath),
-      path47.join(packageDir, `${subpath}.js`),
-      path47.join(packageDir, `${subpath}.mjs`),
-      path47.join(packageDir, `${subpath}.ts`),
-      path47.join(packageDir, `${subpath}.tsx`),
-      path47.join(packageDir, subpath, "index.js"),
-      path47.join(packageDir, subpath, "index.mjs"),
-      path47.join(packageDir, subpath, "index.ts"),
-      path47.join(packageDir, subpath, "index.tsx")
+      path48.join(packageDir, subpath),
+      path48.join(packageDir, `${subpath}.js`),
+      path48.join(packageDir, `${subpath}.mjs`),
+      path48.join(packageDir, `${subpath}.ts`),
+      path48.join(packageDir, `${subpath}.tsx`),
+      path48.join(packageDir, subpath, "index.js"),
+      path48.join(packageDir, subpath, "index.mjs"),
+      path48.join(packageDir, subpath, "index.ts"),
+      path48.join(packageDir, subpath, "index.tsx")
     ];
     for (const p3 of possiblePaths) {
-      if (fs45.existsSync(p3) && fs45.statSync(p3).isFile()) {
+      if (fs46.existsSync(p3) && fs46.statSync(p3).isFile()) {
         resolvedFiles.push(p3);
         break;
       }
@@ -243387,25 +243442,25 @@ function resolveNodeModuleImport({
     resolveExportValue(packageJson.exports?.["."]?.require)
   ].filter((entry) => typeof entry === "string");
   for (const entry of entryPoints) {
-    const entryPath = path47.join(packageDir, entry);
-    if (fs45.existsSync(entryPath) && fs45.statSync(entryPath).isFile()) {
+    const entryPath = path48.join(packageDir, entry);
+    if (fs46.existsSync(entryPath) && fs46.statSync(entryPath).isFile()) {
       resolvedFiles.push(entryPath);
     }
   }
   if (resolvedFiles.length === 0) {
     const fallbackPaths = [
-      path47.join(packageDir, "index.js"),
-      path47.join(packageDir, "index.mjs"),
-      path47.join(packageDir, "index.ts"),
-      path47.join(packageDir, "index.tsx"),
-      path47.join(packageDir, "dist", "index.js"),
-      path47.join(packageDir, "dist", "index.mjs"),
-      path47.join(packageDir, "lib", "index.js"),
-      path47.join(packageDir, "src", "index.ts"),
-      path47.join(packageDir, "src", "index.tsx")
+      path48.join(packageDir, "index.js"),
+      path48.join(packageDir, "index.mjs"),
+      path48.join(packageDir, "index.ts"),
+      path48.join(packageDir, "index.tsx"),
+      path48.join(packageDir, "dist", "index.js"),
+      path48.join(packageDir, "dist", "index.mjs"),
+      path48.join(packageDir, "lib", "index.js"),
+      path48.join(packageDir, "src", "index.ts"),
+      path48.join(packageDir, "src", "index.tsx")
     ];
     for (const p3 of fallbackPaths) {
-      if (fs45.existsSync(p3) && fs45.statSync(p3).isFile()) {
+      if (fs46.existsSync(p3) && fs46.statSync(p3).isFile()) {
         resolvedFiles.push(p3);
         break;
       }
@@ -243443,12 +243498,12 @@ function collectAllNodeModuleDependencies(entryFilePath, projectDir, maxDepth =
     }
   }
   function getLocalDependencies(filePath) {
-    const absolutePath = path47.resolve(filePath);
-    const baseDir = path47.dirname(absolutePath);
-    if (!fs45.existsSync(absolutePath)) {
+    const absolutePath = path48.resolve(filePath);
+    const baseDir = path48.dirname(absolutePath);
+    if (!fs46.existsSync(absolutePath)) {
       return [];
     }
-    const content = fs45.readFileSync(absolutePath, "utf-8");
+    const content = fs46.readFileSync(absolutePath, "utf-8");
     const sourceFile = ts3.createSourceFile(absolutePath, content, ts3.ScriptTarget.Latest, true);
     const dependencies = [];
     function visit(node) {
@@ -243470,20 +243525,20 @@ function collectAllNodeModuleDependencies(entryFilePath, projectDir, maxDepth =
   }
   function resolveLocalImport(importPath, baseDir) {
     const extensions = [".tsx", ".ts", ".jsx", ".js", ".mjs"];
-    const resolvedPath = path47.resolve(baseDir, importPath);
-    if (fs45.existsSync(resolvedPath) && fs45.statSync(resolvedPath).isFile()) {
+    const resolvedPath = path48.resolve(baseDir, importPath);
+    if (fs46.existsSync(resolvedPath) && fs46.statSync(resolvedPath).isFile()) {
       return resolvedPath;
     }
     for (const ext of extensions) {
       const pathWithExt = resolvedPath + ext;
-      if (fs45.existsSync(pathWithExt)) {
+      if (fs46.existsSync(pathWithExt)) {
         return pathWithExt;
       }
     }
-    if (fs45.existsSync(resolvedPath) && fs45.statSync(resolvedPath).isDirectory()) {
+    if (fs46.existsSync(resolvedPath) && fs46.statSync(resolvedPath).isDirectory()) {
       for (const ext of extensions) {
-        const indexPath = path47.join(resolvedPath, `index${ext}`);
-        if (fs45.existsSync(indexPath)) {
+        const indexPath = path48.join(resolvedPath, `index${ext}`);
+        if (fs46.existsSync(indexPath)) {
           return indexPath;
         }
       }
@@ -243508,12 +243563,12 @@ var EXCLUDED_PACKAGE_DIRECTORIES = new Set([
 function collectLocalPackageFiles(packageDir) {
   const buildDirs = ["dist", "build"];
   for (const dirName of buildDirs) {
-    const dirPath = path47.join(packageDir, dirName);
-    if (fs45.existsSync(dirPath)) {
+    const dirPath = path48.join(packageDir, dirName);
+    if (fs46.existsSync(dirPath)) {
       const files = walkDirectory(dirPath, new Set);
       if (files.length > 0) {
-        const packageJsonPath = path47.join(packageDir, "package.json");
-        if (fs45.existsSync(packageJsonPath)) {
+        const packageJsonPath = path48.join(packageDir, "package.json");
+        if (fs46.existsSync(packageJsonPath)) {
           files.push(packageJsonPath);
         }
         return files;
@@ -243524,11 +243579,11 @@ function collectLocalPackageFiles(packageDir) {
 }
 function walkDirectory(dir, excludedDirs) {
   const files = [];
-  if (!fs45.existsSync(dir))
+  if (!fs46.existsSync(dir))
     return files;
-  const entries = fs45.readdirSync(dir, { withFileTypes: true });
+  const entries = fs46.readdirSync(dir, { withFileTypes: true });
   for (const entry of entries) {
-    const fullPath = path47.join(dir, entry.name);
+    const fullPath = path48.join(dir, entry.name);
     if (entry.isDirectory()) {
       if (excludedDirs.has(entry.name)) {
         continue;
@@ -243589,13 +243644,13 @@ function getAllNodeModuleFilePaths(entryFilePath, projectDir) {
       processedPackages.add(packageName);
       if (resolvedFiles.length > 0) {
         const firstResolvedFile = resolvedFiles[0];
-        let packageDir = path47.dirname(firstResolvedFile);
+        let packageDir = path48.dirname(firstResolvedFile);
         let hasPackageJson = false;
         while (packageDir.includes("node_modules")) {
-          const packageJsonPath = path47.join(packageDir, "package.json");
-          if (fs45.existsSync(packageJsonPath)) {
+          const packageJsonPath = path48.join(packageDir, "package.json");
+          if (fs46.existsSync(packageJsonPath)) {
             try {
-              const pkgJson = JSON.parse(fs45.readFileSync(packageJsonPath, "utf-8"));
+              const pkgJson = JSON.parse(fs46.readFileSync(packageJsonPath, "utf-8"));
               if (pkgJson.name === packageName) {
                 hasPackageJson = true;
                 break;
@@ -243603,15 +243658,15 @@ function getAllNodeModuleFilePaths(entryFilePath, projectDir) {
             } catch {}
           }
           const expectedPackagePath = packageName.startsWith("@") ? `node_modules/${packageName}` : `node_modules/${packageName}`;
-          if (packageDir.endsWith(expectedPackagePath) || packageDir.endsWith(expectedPackagePath.replace(/\//g, path47.sep))) {
+          if (packageDir.endsWith(expectedPackagePath) || packageDir.endsWith(expectedPackagePath.replace(/\//g, path48.sep))) {
             break;
           }
-          const parentDir = path47.dirname(packageDir);
+          const parentDir = path48.dirname(packageDir);
           if (parentDir === packageDir)
             break;
           packageDir = parentDir;
         }
-        if (fs45.existsSync(packageDir)) {
+        if (fs46.existsSync(packageDir)) {
           if (hasPackageJson) {
             const packageFiles = collectLocalPackageFiles(packageDir);
             packageFiles.forEach((file) => allFiles.add(file));
@@ -243677,7 +243732,7 @@ class EventsWatcher extends EventEmitter2 {
 }
 
 // lib/server/createHttpServer.ts
-import * as fs47 from "node:fs";
+import * as fs48 from "node:fs";
 import * as http from "node:http";
 
 // node_modules/winterspec/dist/edge/transform-to-node.js
@@ -244380,10 +244435,10 @@ var databaseSchema = z7.object({
   files: z7.array(fileSchema).default([]),
   events: z7.array(eventSchema).default([])
 });
-function normalizePath2(path48) {
-  if (!path48 || path48 === "/")
+function normalizePath2(path49) {
+  if (!path49 || path49 === "/")
     return "";
-  let normalized = path48.replace(/\\+/g, "/").replace(/\/\/+/, "/");
+  let normalized = path49.replace(/\\+/g, "/").replace(/\/\/+/, "/");
   if (normalized.startsWith("/")) {
     normalized = normalized.slice(1);
   }
@@ -245240,14 +245295,14 @@ var getIndex = async (mainComponentPath, fileServerApiBaseUrl) => {
 };
 
 // lib/server/kicad-pcm-proxy.ts
-import * as fs46 from "node:fs";
-import * as path48 from "node:path";
+import * as fs47 from "node:fs";
+import * as path49 from "node:path";
 var getSourceFilesChecksum = (projectDir) => {
   const sourceFiles = globbySync(["**/*.tsx", "**/*.ts", "**/*.json", "!node_modules/**", "!dist/**"], { cwd: projectDir });
   let checksum = "";
   for (const file of sourceFiles) {
     try {
-      const stat4 = fs46.statSync(path48.join(projectDir, file));
+      const stat4 = fs47.statSync(path49.join(projectDir, file));
       checksum += `${file}:${stat4.mtimeMs};`;
     } catch {}
   }
@@ -245267,9 +245322,9 @@ var createKicadPcmProxy = ({
   };
   const handleRequest = async (url2, res2) => {
     const requestedFile = url2.pathname.replace(/^\/pcm\/?/, "") || "repository.json";
-    const distDir = path48.join(projectDir, "dist");
-    const pcmDir = path48.join(distDir, "pcm");
-    const filePath = path48.join(pcmDir, requestedFile);
+    const distDir = path49.join(projectDir, "dist");
+    const pcmDir = path49.join(distDir, "pcm");
+    const filePath = path49.join(pcmDir, requestedFile);
     const currentChecksum = getSourceFilesChecksum(projectDir);
     const needsRebuild = currentChecksum !== pcmState.lastFileChecksum;
     if (needsRebuild) {
@@ -245314,12 +245369,12 @@ Rebuilding KiCad PCM assets...`));
         }
       }
     }
-    if (!fs46.existsSync(filePath)) {
+    if (!fs47.existsSync(filePath)) {
       res2.writeHead(404);
       res2.end(`PCM file not found: ${requestedFile}`);
       return;
     }
-    const ext = path48.extname(filePath).toLowerCase();
+    const ext = path49.extname(filePath).toLowerCase();
     let contentType = "application/octet-stream";
     if (ext === ".json") {
       contentType = "application/json";
@@ -245327,7 +245382,7 @@ Rebuilding KiCad PCM assets...`));
       contentType = "application/zip";
     }
     try {
-      const content = fs46.readFileSync(filePath);
+      const content = fs47.readFileSync(filePath);
       res2.writeHead(200, { "Content-Type": contentType });
       res2.end(content);
     } catch (error) {
@@ -245407,7 +245462,7 @@ var createHttpServer = async ({
         return;
       }
       try {
-        const content = fs47.readFileSync(standaloneFilePath, "utf8");
+        const content = fs48.readFileSync(standaloneFilePath, "utf8");
         res2.writeHead(200, {
           "Content-Type": "application/javascript; charset=utf-8"
         });
@@ -245441,17 +245496,17 @@ var createHttpServer = async ({
     res2.writeHead(404);
     res2.end("Not found");
   });
-  return new Promise((resolve9) => {
+  return new Promise((resolve10) => {
     server.listen(port, () => {
-      resolve9({ server });
+      resolve10({ server });
     });
   });
 };
 
 // lib/shared/push-snippet.ts
 var import_semver3 = __toESM2(require_semver2(), 1);
-import * as fs48 from "node:fs";
-import * as path51 from "node:path";
+import * as fs49 from "node:fs";
+import * as path52 from "node:path";
 import Debug2 from "debug";
 
 // lib/utils/validate-package-name.ts
@@ -245468,8 +245523,8 @@ var validatePackageName = (name) => {
   return null;
 };
 
-// cli/dev/get-package-file-paths.ts
-import * as path49 from "node:path";
+// lib/dev/get-package-file-paths.ts
+import * as path50 from "node:path";
 var getPackageFilePaths = (projectDir, ignored = []) => {
   const ignorePatterns = [
     ...DEFAULT_IGNORED_PATTERNS,
@@ -245480,7 +245535,7 @@ var getPackageFilePaths = (projectDir, ignored = []) => {
     ignore: ignorePatterns
   });
   fileNames.sort();
-  return fileNames.map((fileName) => path49.join(projectDir, fileName));
+  return fileNames.map((fileName) => path50.join(projectDir, fileName));
 };
 
 // lib/utils/check-org-access.ts
@@ -245496,7 +245551,7 @@ var checkOrgAccess = async (ky3, orgTscircuitHandle) => {
 };
 
 // lib/shared/is-binary-file.ts
-import * as path50 from "node:path";
+import * as path51 from "node:path";
 var BINARY_FILE_EXTENSIONS = new Set([
   ".glb",
   ".gltf",
@@ -245512,7 +245567,7 @@ var BINARY_FILE_EXTENSIONS = new Set([
   ".tar"
 ]);
 var isBinaryFile = (filePath) => {
-  const ext = path50.extname(filePath).toLowerCase();
+  const ext = path51.extname(filePath).toLowerCase();
   return BINARY_FILE_EXTENSIONS.has(ext);
 };
 
@@ -245538,8 +245593,8 @@ var debug11 = Debug2("tsci:push-snippet");
 var getArchivePayload = async (filePaths, projectDir, packageNameWithVersion) => {
   const zip = new import_jszip4.default;
   for (const fullFilePath of filePaths) {
-    const relativeFilePath = path51.relative(projectDir, fullFilePath);
-    zip.file(relativeFilePath, fs48.readFileSync(fullFilePath));
+    const relativeFilePath = path52.relative(projectDir, fullFilePath);
+    zip.file(relativeFilePath, fs49.readFileSync(fullFilePath));
   }
   const archive = await zip.generateAsync({
     type: "uint8array",
@@ -245577,24 +245632,24 @@ var pushSnippet = async ({
     return onExit(1);
   }
   const packageJsonPath = [
-    path51.resolve(path51.join(path51.dirname(snippetFilePath), "package.json")),
-    path51.resolve(path51.join(process.cwd(), "package.json"))
-  ].find((path52) => fs48.existsSync(path52));
-  const projectDir = packageJsonPath ? path51.dirname(packageJsonPath) : path51.dirname(snippetFilePath);
+    path52.resolve(path52.join(path52.dirname(snippetFilePath), "package.json")),
+    path52.resolve(path52.join(process.cwd(), "package.json"))
+  ].find((path53) => fs49.existsSync(path53));
+  const projectDir = packageJsonPath ? path52.dirname(packageJsonPath) : path52.dirname(snippetFilePath);
   if (!packageJsonPath) {
     onError("No package.json found, try running 'tsci init' to bootstrap the project");
     return onExit(1);
   }
   let packageJson = {};
-  if (fs48.existsSync(packageJsonPath)) {
+  if (fs49.existsSync(packageJsonPath)) {
     try {
-      packageJson = JSON.parse(fs48.readFileSync(packageJsonPath).toString());
+      packageJson = JSON.parse(fs49.readFileSync(packageJsonPath).toString());
     } catch {
       onError("Invalid package.json");
       return onExit(1);
     }
   }
-  if (!fs48.existsSync(snippetFilePath)) {
+  if (!fs49.existsSync(snippetFilePath)) {
     onError(`File not found: ${snippetFilePath}`);
     return onExit(1);
   }
@@ -245635,7 +245690,7 @@ var pushSnippet = async ({
     }
     unscopedPackageName = inputName;
     packageJson.name = `@tsci/${currentUsername}.${unscopedPackageName}`;
-    fs48.writeFileSync(packageJsonPath, JSON.stringify(packageJson, null, 2));
+    fs49.writeFileSync(packageJsonPath, JSON.stringify(packageJson, null, 2));
   }
   let accountName = currentUsername;
   if (packageJsonAuthor && currentUsername !== packageJsonAuthor) {
@@ -245666,7 +245721,7 @@ var pushSnippet = async ({
   const updatePackageJsonVersion = (newVersion) => {
     try {
       packageJson.version = newVersion ?? `${packageVersion}`;
-      fs48.writeFileSync(packageJsonPath, JSON.stringify(packageJson, null, 2));
+      fs49.writeFileSync(packageJsonPath, JSON.stringify(packageJson, null, 2));
     } catch (error) {
       onError(`Failed to update package.json version: ${error}`);
     }
@@ -245774,7 +245829,7 @@ var pushSnippet = async ({
         json: archivePayload
       });
       for (const fullFilePath of filePaths) {
-        const relativeFilePath = path51.relative(projectDir, fullFilePath);
+        const relativeFilePath = path52.relative(projectDir, fullFilePath);
         uploadResults.succeeded.push(relativeFilePath);
       }
       log(kleur_default.gray(`\uD83D\uDCE6 Uploaded archive with ${filePaths.length} files`));
@@ -245784,8 +245839,8 @@ var pushSnippet = async ({
   }
   if (uploadResults.succeeded.length === 0) {
     for (const fullFilePath of filePaths) {
-      const relativeFilePath = path51.relative(projectDir, fullFilePath);
-      const fileBuffer = fs48.readFileSync(fullFilePath);
+      const relativeFilePath = path52.relative(projectDir, fullFilePath);
+      const fileBuffer = fs49.readFileSync(fullFilePath);
       const isBinary = isBinaryFile(relativeFilePath) || hasBinaryContent(fileBuffer);
       const payload = {
         file_path: relativeFilePath,
@@ -245851,7 +245906,7 @@ Publish completed with ${uploadResults.succeeded.length} files uploaded and ${up
   return onExit(0);
 };
 
-// cli/dev/DevServer.ts
+// lib/dev/DevServer.ts
 var debug13 = Debug3("tscircuit:devserver");
 var BINARY_FILE_EXTENSIONS2 = new Set([".glb", ".png", ".jpeg", ".jpg"]);
 
@@ -245874,7 +245929,7 @@ class DevServer {
   }) {
     this.port = port;
     this.componentFilePath = componentFilePath;
-    this.projectDir = projectDir ?? path52.dirname(componentFilePath);
+    this.projectDir = projectDir ?? path53.dirname(componentFilePath);
     this.kicadPcm = kicadPcm ?? false;
     const projectConfig2 = loadProjectConfig(this.projectDir);
     this.ignoredFiles = projectConfig2?.ignoredFiles ?? [];
@@ -245885,7 +245940,7 @@ class DevServer {
   async start() {
     const { server } = await createHttpServer({
       port: this.port,
-      defaultMainComponentPath: path52.relative(this.projectDir, this.componentFilePath),
+      defaultMainComponentPath: path53.relative(this.projectDir, this.componentFilePath),
       kicadPcm: this.kicadPcm,
       projectDir: this.projectDir,
       entryFile: this.componentFilePath
@@ -245901,7 +245956,7 @@ class DevServer {
     this.filesystemWatcher = watch(this.projectDir, {
       persistent: true,
       ignoreInitial: true,
-      ignored: (p3) => shouldIgnorePath(path52.relative(this.projectDir, p3), this.ignoredFiles)
+      ignored: (p3) => shouldIgnorePath(path53.relative(this.projectDir, p3), this.ignoredFiles)
     });
     this.filesystemWatcher.on("change", (filePath) => this.handleFileChangedOnFilesystem(filePath));
     this.filesystemWatcher.on("add", (filePath) => this.handleFileChangedOnFilesystem(filePath));
@@ -245916,27 +245971,27 @@ class DevServer {
     const { file } = await this.fsKy.get("api/files/get", {
       searchParams: { file_path: ev.file_path }
     }).json();
-    const fullPath = path52.join(this.projectDir, ev.file_path);
-    const dirPath = path52.dirname(fullPath);
-    if (!fs49.existsSync(dirPath)) {
-      fs49.mkdirSync(dirPath, { recursive: true });
+    const fullPath = path53.join(this.projectDir, ev.file_path);
+    const dirPath = path53.dirname(fullPath);
+    if (!fs50.existsSync(dirPath)) {
+      fs50.mkdirSync(dirPath, { recursive: true });
     }
     if (file.binary_content_b64) {
       const decodedContent = Buffer.from(file.binary_content_b64, "base64");
-      fs49.writeFileSync(fullPath, decodedContent);
+      fs50.writeFileSync(fullPath, decodedContent);
     } else {
-      fs49.writeFileSync(fullPath, file.text_content ?? "", "utf-8");
+      fs50.writeFileSync(fullPath, file.text_content ?? "", "utf-8");
     }
   }
   async handleFileDeletedEventFromServer(ev) {
-    const fullPath = path52.join(this.projectDir, ev.file_path);
-    if (fs49.existsSync(fullPath)) {
+    const fullPath = path53.join(this.projectDir, ev.file_path);
+    if (fs50.existsSync(fullPath)) {
       debug13(`Deleting file ${ev.file_path} from filesystem`);
-      fs49.unlinkSync(fullPath);
+      fs50.unlinkSync(fullPath);
     }
   }
   async handleFileChangedOnFilesystem(absoluteFilePath) {
-    const relativeFilePath = path52.relative(this.projectDir, absoluteFilePath);
+    const relativeFilePath = path53.relative(this.projectDir, absoluteFilePath);
     if (relativeFilePath.includes("manual-edits.json"))
       return;
     if (shouldIgnorePath(relativeFilePath, this.ignoredFiles))
@@ -245951,14 +246006,14 @@ class DevServer {
     await this.checkAndUploadNewNodeModules(absoluteFilePath);
   }
   async checkAndUploadNewNodeModules(filePath) {
-    const ext = path52.extname(filePath).toLowerCase();
+    const ext = path53.extname(filePath).toLowerCase();
     const isSourceFile = [".ts", ".tsx", ".js", ".jsx", ".mjs"].includes(ext);
     if (!isSourceFile)
       return;
     try {
       const nodeModuleFiles = getAllNodeModuleFilePaths(filePath, this.projectDir);
       const newFiles = nodeModuleFiles.filter((file) => {
-        const relativePath = path52.relative(this.projectDir, file);
+        const relativePath = path53.relative(this.projectDir, file);
         return !this.uploadedNodeModules.has(relativePath);
       });
       if (newFiles.length === 0)
@@ -245971,7 +246026,7 @@ class DevServer {
     }
   }
   async handleFileRemovedFromFilesystem(absoluteFilePath) {
-    const relativeFilePath = path52.relative(this.projectDir, absoluteFilePath);
+    const relativeFilePath = path53.relative(this.projectDir, absoluteFilePath);
     if (shouldIgnorePath(relativeFilePath, this.ignoredFiles))
       return;
     if (!relativeFilePath || relativeFilePath.trim() === "") {
@@ -246009,8 +246064,8 @@ class DevServer {
     debug13(`Successfully deleted file ${relativeFilePath} from server`);
   }
   async handleFileRename(oldPath, newPath) {
-    const oldRelativePath = path52.relative(this.projectDir, oldPath);
-    const newRelativePath = path52.relative(this.projectDir, newPath);
+    const oldRelativePath = path53.relative(this.projectDir, oldPath);
+    const newRelativePath = path53.relative(this.projectDir, newPath);
     if (shouldIgnorePath(oldRelativePath, this.ignoredFiles) || shouldIgnorePath(newRelativePath, this.ignoredFiles))
       return;
     await this.handleFileRemovedFromFilesystem(oldPath);
@@ -246028,7 +246083,7 @@ class DevServer {
     });
     const filePaths = getPackageFilePaths(this.projectDir, this.ignoredFiles);
     for (const filePath of filePaths) {
-      const relativeFilePath = path52.relative(this.projectDir, filePath);
+      const relativeFilePath = path53.relative(this.projectDir, filePath);
       const filePayload = this.createFileUploadPayload(filePath, relativeFilePath);
       await this.postFileUpsert({
         filePath: relativeFilePath,
@@ -246060,7 +246115,7 @@ class DevServer {
   }
   async uploadNodeModuleFiles(files) {
     for (const nodeModuleFile of files) {
-      const relativeFilePath = path52.relative(this.projectDir, nodeModuleFile);
+      const relativeFilePath = path53.relative(this.projectDir, nodeModuleFile);
       this.uploadedNodeModules.add(relativeFilePath);
       const filePayload = this.createFileUploadPayload(nodeModuleFile, relativeFilePath);
       await this.postFileUpsert({
@@ -246105,7 +246160,7 @@ class DevServer {
     formData.set("file_path", filePath);
     formData.set("initiator", initiator);
     const binaryBytes = Uint8Array.from(binaryContent);
-    formData.set("binary_file", new Blob([binaryBytes]), path52.basename(filePath));
+    formData.set("binary_file", new Blob([binaryBytes]), path53.basename(filePath));
     const response = await fetch(`http://localhost:${this.port}/api/files/upsert-multipart`, {
       method: "POST",
       body: formData
@@ -246145,12 +246200,12 @@ class DevServer {
     await this.filesystemWatcher?.close();
   }
   createFileUploadPayload(absoluteFilePath, relativeFilePath) {
-    const ext = path52.extname(relativeFilePath).toLowerCase();
+    const ext = path53.extname(relativeFilePath).toLowerCase();
     if (BINARY_FILE_EXTENSIONS2.has(ext)) {
-      const fileBuffer = fs49.readFileSync(absoluteFilePath);
+      const fileBuffer = fs50.readFileSync(absoluteFilePath);
       return { binary_content: fileBuffer };
     }
-    return { text_content: fs49.readFileSync(absoluteFilePath, "utf-8") };
+    return { text_content: fs50.readFileSync(absoluteFilePath, "utf-8") };
   }
   async handleInstallPackage(full_package_name) {
     const postEvent = async (event, message) => {
@@ -246179,61 +246234,6 @@ class DevServer {
   }
 }
 
-// cli/dev/resolve-dev-target.ts
-import * as fs50 from "node:fs";
-import * as path53 from "node:path";
-var findSelectableFiles = (projectDir) => {
-  const boardFiles = findBoardFiles({ projectDir }).filter((file) => fs50.existsSync(file)).sort();
-  if (boardFiles.length > 0) {
-    return boardFiles;
-  }
-  const files = globbySync(["**/*.tsx", "**/*.ts", "**/*.circuit.json"], {
-    cwd: projectDir,
-    ignore: DEFAULT_IGNORED_PATTERNS
-  });
-  return files.map((file) => path53.resolve(projectDir, file)).filter((file) => fs50.existsSync(file)).sort();
-};
-var isValidDevFile = (filePath) => {
-  return filePath.endsWith(".tsx") || filePath.endsWith(".ts") || filePath.endsWith(".circuit.json");
-};
-var resolveDevTarget = async (file) => {
-  let projectDir = process.cwd();
-  if (file) {
-    const resolvedPath = path53.resolve(file);
-    if (fs50.existsSync(resolvedPath) && fs50.statSync(resolvedPath).isDirectory()) {
-      projectDir = resolvedPath;
-      const availableFiles2 = findSelectableFiles(projectDir);
-      if (availableFiles2.length === 0) {
-        console.log(`No .tsx, .ts, or .circuit.json files found in ${projectDir}. Run 'tsci init' to bootstrap a basic project.`);
-        return null;
-      }
-      console.log("Selected file:", path53.relative(projectDir, availableFiles2[0]));
-      return { absolutePath: availableFiles2[0], projectDir };
-    }
-    if (!fs50.existsSync(resolvedPath)) {
-      console.error(`Error: File not found: ${file}`);
-      return null;
-    }
-    if (!isValidDevFile(resolvedPath)) {
-      console.error("Error: Only .tsx, .ts, and .circuit.json files are supported");
-      return null;
-    }
-    return { absolutePath: resolvedPath, projectDir };
-  }
-  const entrypointPath = await getEntrypoint({ onError: () => {} });
-  if (entrypointPath && fs50.existsSync(entrypointPath)) {
-    console.log("Found entrypoint at:", entrypointPath);
-    return { absolutePath: entrypointPath, projectDir };
-  }
-  const availableFiles = findSelectableFiles(projectDir);
-  if (availableFiles.length === 0) {
-    console.log("No .tsx, .ts, or .circuit.json files found in the project. Run 'tsci init' to bootstrap a basic project.");
-    return null;
-  }
-  console.log("Selected file:", path53.relative(projectDir, availableFiles[0]));
-  return { absolutePath: availableFiles[0], projectDir };
-};
-
 // cli/dev/register.ts
 var isPortAvailable = (port) => {
   return new Promise((resolve11) => {