agent-web-os 0.1.1 → 0.1.3

package/dist/index.cjs

@@ -4758,32 +4758,32 @@ var init_pako_esm = __esm({
 // node_modules/almostnode/src/shims/path.ts
 var path_exports = {};
 __export(path_exports, {
-  basename: () => basename,
+  basename: () => basename2,
   default: () => path_default,
   delimiter: () => delimiter,
-  dirname: () => dirname2,
+  dirname: () => dirname3,
   extname: () => extname,
   format: () => format,
-  isAbsolute: () => isAbsolute,
-  join: () => join2,
-  normalize: () => normalize,
+  isAbsolute: () => isAbsolute2,
+  join: () => join3,
+  normalize: () => normalize2,
   parse: () => parse,
   posix: () => posix,
-  relative: () => relative,
-  resolve: () => resolve,
+  relative: () => relative2,
+  resolve: () => resolve2,
   sep: () => sep2,
   win32: () => win32
 });
-function normalize(path4) {
-  if (!path4) return ".";
-  const isAbsolute2 = path4.startsWith("/");
-  const parts = path4.split("/").filter(Boolean);
+function normalize2(path2) {
+  if (!path2) return ".";
+  const isAbsolute3 = path2.startsWith("/");
+  const parts = path2.split("/").filter(Boolean);
   const resolved = [];
   for (const part of parts) {
     if (part === "..") {
       if (resolved.length > 0 && resolved[resolved.length - 1] !== "..") {
         resolved.pop();
-      } else if (!isAbsolute2) {
+      } else if (!isAbsolute3) {
         resolved.push("..");
       }
     } else if (part !== ".") {
@@ -4791,57 +4791,57 @@ function normalize(path4) {
     }
   }
   let result = resolved.join("/");
-  if (isAbsolute2) {
+  if (isAbsolute3) {
     result = "/" + result;
   }
   return result || ".";
 }
-function join2(...paths) {
+function join3(...paths) {
   if (paths.length === 0) return ".";
-  return normalize(paths.filter(Boolean).join("/"));
+  return normalize2(paths.filter(Boolean).join("/"));
 }
-function resolve(...paths) {
+function resolve2(...paths) {
   let resolvedPath2 = "";
   for (let i = paths.length - 1; i >= 0 && !resolvedPath2.startsWith("/"); i--) {
-    const path4 = paths[i];
-    if (!path4) continue;
-    resolvedPath2 = path4 + (resolvedPath2 ? "/" + resolvedPath2 : "");
+    const path2 = paths[i];
+    if (!path2) continue;
+    resolvedPath2 = path2 + (resolvedPath2 ? "/" + resolvedPath2 : "");
   }
   if (!resolvedPath2.startsWith("/")) {
     const cwd = typeof globalThis !== "undefined" && globalThis.process && typeof globalThis.process.cwd === "function" ? globalThis.process.cwd() : "/";
     resolvedPath2 = cwd + (resolvedPath2 ? "/" + resolvedPath2 : "");
   }
-  return normalize(resolvedPath2);
+  return normalize2(resolvedPath2);
 }
-function isAbsolute(path4) {
-  return path4.startsWith("/");
+function isAbsolute2(path2) {
+  return path2.startsWith("/");
 }
-function dirname2(path4) {
-  if (!path4) return ".";
-  const normalized = normalize(path4);
+function dirname3(path2) {
+  if (!path2) return ".";
+  const normalized = normalize2(path2);
   const lastSlash = normalized.lastIndexOf("/");
   if (lastSlash === -1) return ".";
   if (lastSlash === 0) return "/";
   return normalized.slice(0, lastSlash);
 }
-function basename(path4, ext2) {
-  if (!path4) return "";
-  const normalized = normalize(path4);
+function basename2(path2, ext2) {
+  if (!path2) return "";
+  const normalized = normalize2(path2);
   let base = normalized.slice(normalized.lastIndexOf("/") + 1);
   if (ext2 && base.endsWith(ext2)) {
     base = base.slice(0, -ext2.length);
   }
   return base;
 }
-function extname(path4) {
-  const base = basename(path4);
+function extname(path2) {
+  const base = basename2(path2);
   const dotIndex = base.lastIndexOf(".");
   if (dotIndex <= 0) return "";
   return base.slice(dotIndex);
 }
-function relative(from, to2) {
-  from = resolve(from);
-  to2 = resolve(to2);
+function relative2(from, to2) {
+  from = resolve2(from);
+  to2 = resolve2(to2);
   if (from === to2) return "";
   const fromParts = from.split("/").filter(Boolean);
   const toParts = to2.split("/").filter(Boolean);
@@ -4855,11 +4855,11 @@ function relative(from, to2) {
   const result = [...Array(upCount).fill(".."), ...remainingPath];
   return result.join("/") || ".";
 }
-function parse(path4) {
-  const normalized = normalize(path4);
-  const isAbs = isAbsolute(normalized);
-  const dir = dirname2(normalized);
-  const base = basename(normalized);
+function parse(path2) {
+  const normalized = normalize2(path2);
+  const isAbs = isAbsolute2(normalized);
+  const dir = dirname3(normalized);
+  const base = basename2(normalized);
   const ext2 = extname(normalized);
   const name = base.slice(0, base.length - ext2.length);
   return {
@@ -4885,42 +4885,42 @@ var init_path = __esm({
     posix = {
       sep: sep2,
       delimiter,
-      normalize,
-      join: join2,
-      resolve,
-      isAbsolute,
-      dirname: dirname2,
-      basename,
+      normalize: normalize2,
+      join: join3,
+      resolve: resolve2,
+      isAbsolute: isAbsolute2,
+      dirname: dirname3,
+      basename: basename2,
       extname,
-      relative,
+      relative: relative2,
       parse,
       format
     };
     win32 = {
       sep: "\\",
       delimiter: ";",
-      normalize,
-      join: join2,
-      resolve,
-      isAbsolute,
-      dirname: dirname2,
-      basename,
+      normalize: normalize2,
+      join: join3,
+      resolve: resolve2,
+      isAbsolute: isAbsolute2,
+      dirname: dirname3,
+      basename: basename2,
       extname,
-      relative,
+      relative: relative2,
       parse,
       format
     };
     path_default = {
       sep: sep2,
       delimiter,
-      normalize,
-      join: join2,
-      resolve,
-      isAbsolute,
-      dirname: dirname2,
-      basename,
+      normalize: normalize2,
+      join: join3,
+      resolve: resolve2,
+      isAbsolute: isAbsolute2,
+      dirname: dirname3,
+      basename: basename2,
       extname,
-      relative,
+      relative: relative2,
       parse,
       format,
       posix,
@@ -5017,11 +5017,11 @@ function extractTarball(tarballData, vfs2, destPath, options2 = {}) {
     if (filter2 && !filter2(entryPath)) {
       continue;
     }
-    const fullPath = join2(destPath, entryPath);
+    const fullPath = join3(destPath, entryPath);
     if (entry.type === "directory") {
       vfs2.mkdirSync(fullPath, { recursive: true });
     } else if (entry.type === "file" && entry.content) {
-      const parentDir = dirname2(fullPath);
+      const parentDir = dirname3(fullPath);
       vfs2.mkdirSync(parentDir, { recursive: true });
       vfs2.writeFileSync(fullPath, entry.content);
       extractedFiles.push(fullPath);
@@ -5414,7 +5414,7 @@ var init_npm = __esm({
        */
       async installFromPackageJson(options2 = {}) {
         const { onProgress } = options2;
-        const pkgJsonPath = join2(this.cwd, "package.json");
+        const pkgJsonPath = join3(this.cwd, "package.json");
         if (!this.vfs.existsSync(pkgJsonPath)) {
           throw new Error("No package.json found");
         }
@@ -5436,12 +5436,12 @@ var init_npm = __esm({
       async installResolved(resolved, options2) {
         const { onProgress } = options2;
         const added = [];
-        const nodeModulesPath = join2(this.cwd, "node_modules");
+        const nodeModulesPath = join3(this.cwd, "node_modules");
         this.vfs.mkdirSync(nodeModulesPath, { recursive: true });
         const toInstall = [];
         for (const [name, pkg] of resolved) {
-          const pkgPath = join2(nodeModulesPath, name);
-          const existingPkgJson = join2(pkgPath, "package.json");
+          const pkgPath = join3(nodeModulesPath, name);
+          const existingPkgJson = join3(pkgPath, "package.json");
           if (this.vfs.existsSync(existingPkgJson)) {
             try {
               const existing = JSON.parse(
@@ -5483,16 +5483,16 @@ var init_npm = __esm({
                 }
               }
               try {
-                const pkgJsonPath = join2(pkgPath, "package.json");
+                const pkgJsonPath = join3(pkgPath, "package.json");
                 if (this.vfs.existsSync(pkgJsonPath)) {
                   const pkgJson = JSON.parse(this.vfs.readFileSync(pkgJsonPath, "utf8"));
                   const binEntries = normalizeBin(name, pkgJson.bin);
-                  const binDir = join2(nodeModulesPath, ".bin");
+                  const binDir = join3(nodeModulesPath, ".bin");
                   for (const [cmdName, entryPath] of Object.entries(binEntries)) {
                     this.vfs.mkdirSync(binDir, { recursive: true });
-                    const targetPath = join2(pkgPath, entryPath);
+                    const targetPath = join3(pkgPath, entryPath);
                     this.vfs.writeFileSync(
-                      join2(binDir, cmdName),
+                      join3(binDir, cmdName),
                       `node "${targetPath}" "$@"
 `
                     );
@@ -5518,14 +5518,14 @@ var init_npm = __esm({
             resolved: pkg.tarballUrl
           };
         }
-        const lockfilePath = join2(this.cwd, "node_modules", ".package-lock.json");
+        const lockfilePath = join3(this.cwd, "node_modules", ".package-lock.json");
         this.vfs.writeFileSync(lockfilePath, JSON.stringify(lockfile, null, 2));
       }
       /**
        * Update package.json with new dependency
        */
       async updatePackageJson(packageName, version4, isDev) {
-        const pkgJsonPath = join2(this.cwd, "package.json");
+        const pkgJsonPath = join3(this.cwd, "package.json");
         let pkgJson = {};
         if (this.vfs.existsSync(pkgJsonPath)) {
           pkgJson = JSON.parse(this.vfs.readFileSync(pkgJsonPath, "utf8"));
@@ -5541,7 +5541,7 @@ var init_npm = __esm({
        * List installed packages
        */
       list() {
-        const nodeModulesPath = join2(this.cwd, "node_modules");
+        const nodeModulesPath = join3(this.cwd, "node_modules");
         if (!this.vfs.existsSync(nodeModulesPath)) {
           return {};
         }
@@ -5550,17 +5550,17 @@ var init_npm = __esm({
         for (const entry of entries) {
           if (entry.startsWith(".")) continue;
           if (entry.startsWith("@")) {
-            const scopePath = join2(nodeModulesPath, entry);
+            const scopePath = join3(nodeModulesPath, entry);
             const scopedPkgs = this.vfs.readdirSync(scopePath);
             for (const scopedPkg of scopedPkgs) {
-              const pkgJsonPath = join2(scopePath, scopedPkg, "package.json");
+              const pkgJsonPath = join3(scopePath, scopedPkg, "package.json");
               if (this.vfs.existsSync(pkgJsonPath)) {
                 const pkgJson = JSON.parse(this.vfs.readFileSync(pkgJsonPath, "utf8"));
                 packages[`${entry}/${scopedPkg}`] = pkgJson.version;
               }
             }
           } else {
-            const pkgJsonPath = join2(nodeModulesPath, entry, "package.json");
+            const pkgJsonPath = join3(nodeModulesPath, entry, "package.json");
             if (this.vfs.existsSync(pkgJsonPath)) {
               const pkgJson = JSON.parse(this.vfs.readFileSync(pkgJsonPath, "utf8"));
               packages[entry] = pkgJson.version;
@@ -7940,16 +7940,16 @@ var Diff = class {
       }
     }
   }
-  addToPath(path4, added, removed, oldPosInc, options2) {
-    const last = path4.lastComponent;
+  addToPath(path2, added, removed, oldPosInc, options2) {
+    const last = path2.lastComponent;
     if (last && !options2.oneChangePerToken && last.added === added && last.removed === removed) {
       return {
-        oldPos: path4.oldPos + oldPosInc,
+        oldPos: path2.oldPos + oldPosInc,
         lastComponent: { count: last.count + 1, added, removed, previousComponent: last.previousComponent }
       };
     } else {
       return {
-        oldPos: path4.oldPos + oldPosInc,
+        oldPos: path2.oldPos + oldPosInc,
         lastComponent: { count: 1, added, removed, previousComponent: last }
       };
     }
@@ -42271,8 +42271,71 @@ function G7(e10) {
   }
 }
 
+// src/posix-path.ts
+function normalize(p) {
+  if (p === "") return ".";
+  const isAbsolute3 = p.charCodeAt(0) === 47;
+  const trailingSlash = p.charCodeAt(p.length - 1) === 47;
+  const segments = [];
+  for (const seg of p.split("/")) {
+    if (seg === ".." && segments.length > 0 && segments[segments.length - 1] !== "..") {
+      segments.pop();
+    } else if (seg !== "." && seg !== "") {
+      segments.push(seg);
+    }
+  }
+  let result = segments.join("/");
+  if (isAbsolute3) result = "/" + result;
+  if (trailingSlash && result.length > 1) result += "/";
+  return result || (isAbsolute3 ? "/" : ".");
+}
+function join2(...parts) {
+  return normalize(parts.filter(Boolean).join("/"));
+}
+function resolve(...parts) {
+  let resolved = "";
+  for (let i = parts.length - 1; i >= 0; i--) {
+    const p = parts[i];
+    if (!p) continue;
+    resolved = resolved ? p + "/" + resolved : p;
+    if (p.charCodeAt(0) === 47) break;
+  }
+  return normalize(resolved || "/");
+}
+function dirname2(p) {
+  if (p === "" || p === "/") return p || ".";
+  const i = p.lastIndexOf("/");
+  if (i === -1) return ".";
+  if (i === 0) return "/";
+  return p.slice(0, i);
+}
+function basename(p, ext2) {
+  let base = p.slice(p.lastIndexOf("/") + 1);
+  if (ext2 && base.endsWith(ext2)) {
+    base = base.slice(0, -ext2.length);
+  }
+  return base;
+}
+function relative(from, to2) {
+  from = resolve(from);
+  to2 = resolve(to2);
+  if (from === to2) return "";
+  const fromParts = from.split("/").filter(Boolean);
+  const toParts = to2.split("/").filter(Boolean);
+  let common2 = 0;
+  while (common2 < fromParts.length && common2 < toParts.length && fromParts[common2] === toParts[common2]) {
+    common2++;
+  }
+  const ups = fromParts.length - common2;
+  const remaining = toParts.slice(common2);
+  return [...Array(ups).fill(".."), ...remaining].join("/");
+}
+function isAbsolute(p) {
+  return p.length > 0 && p.charCodeAt(0) === 47;
+}
+var posixPath = { normalize, join: join2, resolve, dirname: dirname2, basename, relative, isAbsolute };
+
 // src/observable-in-memory-fs.ts
-var import_node_path = __toESM(require("path"), 1);
 function isObservableInMemoryFsLike(value) {
   if (!value || typeof value !== "object") {
     return false;
@@ -42299,18 +42362,18 @@ function normalizeEntryType(stat) {
   }
   return "file";
 }
-async function readPathState(fs, path4) {
-  const exists = await fs.exists(path4);
+async function readPathState(fs, path2) {
+  const exists = await fs.exists(path2);
   if (!exists) {
     return { exists: false };
   }
-  if (isObservableInMemoryFsLike(fs) && fs.isPathLazy(path4)) {
+  if (isObservableInMemoryFsLike(fs) && fs.isPathLazy(path2)) {
     return {
       exists: true,
       entryType: "file"
     };
   }
-  const stat = await fs.lstat(path4);
+  const stat = await fs.lstat(path2);
   return {
     exists: true,
     entryType: normalizeEntryType(stat)
@@ -42323,7 +42386,7 @@ function mapUnlinkEvent(entryType) {
   return entryType === "directory" ? "unlinkDir" : "unlink";
 }
 function normalizeFsPathForLogScope(fsPath) {
-  const normalized = import_node_path.default.posix.normalize(fsPath);
+  const normalized = posixPath.normalize(fsPath);
   return normalized === "." ? "/" : normalized;
 }
 function createWorkspacePathFilter(workspaceRoot) {
@@ -42333,7 +42396,7 @@ function createWorkspacePathFilter(workspaceRoot) {
     if (normalizedPath !== normalizedWorkspaceRoot && !normalizedPath.startsWith(`${normalizedWorkspaceRoot}/`)) {
       return false;
     }
-    const relativePath = import_node_path.default.posix.relative(normalizedWorkspaceRoot, normalizedPath);
+    const relativePath = posixPath.relative(normalizedWorkspaceRoot, normalizedPath);
     if (!relativePath || relativePath === ".") {
       return true;
     }
@@ -42447,124 +42510,124 @@ var ObservableInMemoryFs = class extends Ir {
       this.suppressSyncEventCount -= 1;
     }
   }
-  writeFileSync(path4, content, options2, metadata) {
-    const previous = this.areSyncEventsSuppressed() || !this.shouldEmitChanges() ? null : readPathState(this, path4);
-    super.writeFileSync(path4, content, options2, metadata);
-    this.clearLazyPath(path4);
+  writeFileSync(path2, content, options2, metadata) {
+    const previous = this.areSyncEventsSuppressed() || !this.shouldEmitChanges() ? null : readPathState(this, path2);
+    super.writeFileSync(path2, content, options2, metadata);
+    this.clearLazyPath(path2);
     if (!previous) {
       return;
     }
-    this.queueChangeEmission(previous.then((state) => this.emitWriteEvent(path4, state)));
+    this.queueChangeEmission(previous.then((state) => this.emitWriteEvent(path2, state)));
   }
-  writeFileLazy(path4, lazy, metadata) {
-    const previous = this.areSyncEventsSuppressed() || !this.shouldEmitChanges() ? null : readPathState(this, path4);
-    super.writeFileLazy(path4, lazy, metadata);
-    this.lazyPaths.add(normalizeFsPathForLogScope(path4));
+  writeFileLazy(path2, lazy, metadata) {
+    const previous = this.areSyncEventsSuppressed() || !this.shouldEmitChanges() ? null : readPathState(this, path2);
+    super.writeFileLazy(path2, lazy, metadata);
+    this.lazyPaths.add(normalizeFsPathForLogScope(path2));
     if (!previous) {
       return;
     }
-    this.queueChangeEmission(previous.then((state) => this.emitWriteEvent(path4, state)));
+    this.queueChangeEmission(previous.then((state) => this.emitWriteEvent(path2, state)));
   }
-  async emitWriteEvent(path4, previous) {
-    const current2 = await readPathState(this, path4);
+  async emitWriteEvent(path2, previous) {
+    const current2 = await readPathState(this, path2);
     if (!current2.exists || !current2.entryType) {
       return;
     }
     if (!previous.exists) {
       this.emit({
         event: mapAddEvent(current2.entryType),
-        path: path4,
+        path: path2,
         entryType: current2.entryType
       });
       return;
     }
     this.emit({
       event: "change",
-      path: path4,
+      path: path2,
       entryType: current2.entryType
     });
   }
-  async emitMkdirEvent(path4, previous) {
-    const current2 = await readPathState(this, path4);
+  async emitMkdirEvent(path2, previous) {
+    const current2 = await readPathState(this, path2);
     if (!current2.exists || current2.entryType !== "directory" || previous.exists) {
       return;
     }
     this.emit({
       event: "addDir",
-      path: path4,
+      path: path2,
       entryType: "directory"
     });
   }
-  emitRemovalEvent(path4, previous, options2) {
+  emitRemovalEvent(path2, previous, options2) {
     if (!previous.exists || !previous.entryType) {
       return;
     }
     this.emit({
       event: mapUnlinkEvent(previous.entryType),
-      path: path4,
+      path: path2,
       entryType: previous.entryType
     }, options2);
   }
-  mkdirSync(path4, options2) {
-    const previous = this.areSyncEventsSuppressed() || !this.shouldEmitChanges() ? null : readPathState(this, path4);
-    super.mkdirSync(path4, options2);
+  mkdirSync(path2, options2) {
+    const previous = this.areSyncEventsSuppressed() || !this.shouldEmitChanges() ? null : readPathState(this, path2);
+    super.mkdirSync(path2, options2);
     if (!previous) {
       return;
     }
-    this.queueChangeEmission(previous.then((state) => this.emitMkdirEvent(path4, state)));
+    this.queueChangeEmission(previous.then((state) => this.emitMkdirEvent(path2, state)));
   }
-  async readFileBuffer(path4) {
-    const content = await super.readFileBuffer(path4);
-    this.clearLazyPath(path4);
+  async readFileBuffer(path2) {
+    const content = await super.readFileBuffer(path2);
+    this.clearLazyPath(path2);
     return content;
   }
-  async stat(path4) {
-    const stat = await super.stat(path4);
-    this.clearLazyPath(path4);
+  async stat(path2) {
+    const stat = await super.stat(path2);
+    this.clearLazyPath(path2);
     return stat;
   }
-  async lstat(path4) {
-    const stat = await super.lstat(path4);
-    this.clearLazyPath(path4);
+  async lstat(path2) {
+    const stat = await super.lstat(path2);
+    this.clearLazyPath(path2);
     return stat;
   }
-  async writeFile(path4, content, options2) {
+  async writeFile(path2, content, options2) {
     if (!this.shouldEmitChanges()) {
-      await super.writeFile(path4, content, options2);
+      await super.writeFile(path2, content, options2);
       return;
     }
-    const previous = await readPathState(this, path4);
-    await this.runWithSuppressedSyncEvents(() => super.writeFile(path4, content, options2));
-    await this.emitWriteEvent(path4, previous);
+    const previous = await readPathState(this, path2);
+    await this.runWithSuppressedSyncEvents(() => super.writeFile(path2, content, options2));
+    await this.emitWriteEvent(path2, previous);
   }
-  async appendFile(path4, content, options2) {
+  async appendFile(path2, content, options2) {
     if (!this.shouldEmitChanges()) {
-      await super.appendFile(path4, content, options2);
+      await super.appendFile(path2, content, options2);
       return;
     }
-    const previous = await readPathState(this, path4);
-    await this.runWithSuppressedSyncEvents(() => super.appendFile(path4, content, options2));
-    await this.emitWriteEvent(path4, previous);
+    const previous = await readPathState(this, path2);
+    await this.runWithSuppressedSyncEvents(() => super.appendFile(path2, content, options2));
+    await this.emitWriteEvent(path2, previous);
   }
-  async mkdir(path4, options2) {
+  async mkdir(path2, options2) {
     if (!this.shouldEmitChanges()) {
-      await super.mkdir(path4, options2);
+      await super.mkdir(path2, options2);
       return;
     }
-    const previous = await readPathState(this, path4);
-    await this.runWithSuppressedSyncEvents(() => super.mkdir(path4, options2));
-    await this.emitMkdirEvent(path4, previous);
+    const previous = await readPathState(this, path2);
+    await this.runWithSuppressedSyncEvents(() => super.mkdir(path2, options2));
+    await this.emitMkdirEvent(path2, previous);
   }
-  async rm(path4, options2) {
+  async rm(path2, options2) {
     if (!this.shouldEmitChanges()) {
-      await super.rm(path4, options2);
-      this.clearLazyPathsUnder(path4);
+      await super.rm(path2, options2);
+      this.clearLazyPathsUnder(path2);
       return;
     }
-    const previous = await readPathState(this, path4);
-    await super.rm(path4, options2);
-    this.clearLazyPathsUnder(path4);
-    this.emitRemovalEvent(path4, previous);
+    const previous = await readPathState(this, path2);
+    await super.rm(path2, options2);
+    this.clearLazyPathsUnder(path2);
+    this.emitRemovalEvent(path2, previous);
   }
   async cp(src, dest, options2) {
     if (!this.shouldEmitChanges()) {
@@ -42637,19 +42700,19 @@ var ObservableInMemoryFs = class extends Ir {
       shouldConsoleLog: shouldConsoleLogMove
     });
   }
-  async chmod(path4, mode) {
+  async chmod(path2, mode) {
     if (!this.shouldEmitChanges()) {
-      await super.chmod(path4, mode);
+      await super.chmod(path2, mode);
       return;
     }
-    await super.chmod(path4, mode);
-    const current2 = await readPathState(this, path4);
+    await super.chmod(path2, mode);
+    const current2 = await readPathState(this, path2);
     if (!current2.exists || !current2.entryType) {
       return;
     }
     this.emit({
       event: "change",
-      path: path4,
+      path: path2,
       entryType: current2.entryType
     });
   }
@@ -42671,26 +42734,25 @@ var ObservableInMemoryFs = class extends Ir {
     await super.link(existingPath, newPath);
     await this.emitWriteEvent(newPath, previous);
   }
-  async utimes(path4, atime, mtime) {
+  async utimes(path2, atime, mtime) {
     if (!this.shouldEmitChanges()) {
-      await super.utimes(path4, atime, mtime);
+      await super.utimes(path2, atime, mtime);
       return;
     }
-    await super.utimes(path4, atime, mtime);
-    const current2 = await readPathState(this, path4);
+    await super.utimes(path2, atime, mtime);
+    const current2 = await readPathState(this, path2);
     if (!current2.exists || !current2.entryType) {
       return;
     }
     this.emit({
       event: "change",
-      path: path4,
+      path: path2,
       entryType: current2.entryType
     });
   }
 };
 
 // src/almostnode-session.ts
-var import_node_path2 = __toESM(require("path"), 1);
 init_npm();
 
 // node_modules/almostnode/src/utils/hash.ts
@@ -42736,7 +42798,7 @@ function uint8ToBinaryString(bytes) {
 }
 
 // node_modules/almostnode/src/virtual-fs.ts
-function createNodeError(code2, syscall, path4, message) {
+function createNodeError(code2, syscall, path2, message) {
   const errno = {
     ENOENT: -2,
     ENOTDIR: -20,
@@ -42752,12 +42814,12 @@ function createNodeError(code2, syscall, path4, message) {
     ENOTEMPTY: "directory not empty"
   };
   const err2 = new Error(
-    message || `${code2}: ${messages2[code2]}, ${syscall} '${path4}'`
+    message || `${code2}: ${messages2[code2]}, ${syscall} '${path2}'`
   );
   err2.code = code2;
   err2.errno = errno[code2];
   err2.syscall = syscall;
-  err2.path = path4;
+  err2.path = path2;
   return err2;
 }
 var VirtualFS = class _VirtualFS {
@@ -42807,18 +42869,18 @@ var VirtualFS = class _VirtualFS {
     this.serializeNode("/", this.root, files);
     return { files };
   }
-  serializeNode(path4, node, files) {
+  serializeNode(path2, node, files) {
     if (node.type === "file") {
       let content = "";
       if (node.content && node.content.length > 0) {
         content = uint8ToBase64(node.content);
       }
-      files.push({ path: path4, type: "file", content });
+      files.push({ path: path2, type: "file", content });
     } else if (node.type === "directory") {
-      files.push({ path: path4, type: "directory" });
+      files.push({ path: path2, type: "directory" });
       if (node.children) {
         for (const [name, child] of node.children) {
-          const childPath = path4 === "/" ? `/${name}` : `${path4}/${name}`;
+          const childPath = path2 === "/" ? `/${name}` : `${path2}/${name}`;
           this.serializeNode(childPath, child, files);
         }
       }
@@ -42853,17 +42915,17 @@ var VirtualFS = class _VirtualFS {
   /**
    * Internal write that optionally emits events
    */
-  writeFileSyncInternal(path4, data2, emitEvent) {
-    const normalized = this.normalizePath(path4);
+  writeFileSyncInternal(path2, data2, emitEvent) {
+    const normalized = this.normalizePath(path2);
     const parentPath = this.getParentPath(normalized);
-    const basename2 = this.getBasename(normalized);
-    if (!basename2) {
-      throw new Error(`EISDIR: illegal operation on a directory, '${path4}'`);
+    const basename3 = this.getBasename(normalized);
+    if (!basename3) {
+      throw new Error(`EISDIR: illegal operation on a directory, '${path2}'`);
     }
     const parent = this.ensureDirectory(parentPath);
-    const existed = parent.children.has(basename2);
+    const existed = parent.children.has(basename3);
     const content = typeof data2 === "string" ? this.encoder.encode(data2) : data2;
-    parent.children.set(basename2, {
+    parent.children.set(basename3, {
       type: "file",
       content,
       mtime: Date.now()
@@ -42876,11 +42938,11 @@ var VirtualFS = class _VirtualFS {
   /**
    * Normalize path - resolve . and .. segments, ensure leading /
    */
-  normalizePath(path4) {
-    if (!path4.startsWith("/")) {
-      path4 = "/" + path4;
+  normalizePath(path2) {
+    if (!path2.startsWith("/")) {
+      path2 = "/" + path2;
     }
-    const parts = path4.split("/").filter(Boolean);
+    const parts = path2.split("/").filter(Boolean);
     const resolved = [];
     for (const part of parts) {
       if (part === "..") {
@@ -42894,30 +42956,30 @@ var VirtualFS = class _VirtualFS {
   /**
    * Get path segments from normalized path
    */
-  getPathSegments(path4) {
-    return this.normalizePath(path4).split("/").filter(Boolean);
+  getPathSegments(path2) {
+    return this.normalizePath(path2).split("/").filter(Boolean);
   }
   /**
    * Get parent directory path
    */
-  getParentPath(path4) {
-    const normalized = this.normalizePath(path4);
+  getParentPath(path2) {
+    const normalized = this.normalizePath(path2);
     const lastSlash = normalized.lastIndexOf("/");
     return lastSlash <= 0 ? "/" : normalized.slice(0, lastSlash);
   }
   /**
    * Get basename from path
    */
-  getBasename(path4) {
-    const normalized = this.normalizePath(path4);
+  getBasename(path2) {
+    const normalized = this.normalizePath(path2);
     const lastSlash = normalized.lastIndexOf("/");
     return normalized.slice(lastSlash + 1);
   }
   /**
    * Get node at path, returns undefined if not found
    */
-  getNode(path4) {
-    const segments = this.getPathSegments(path4);
+  getNode(path2) {
+    const segments = this.getPathSegments(path2);
     let current2 = this.root;
     for (const segment of segments) {
       if (current2.type !== "directory" || !current2.children) {
@@ -42934,8 +42996,8 @@ var VirtualFS = class _VirtualFS {
   /**
    * Get or create directory at path (for mkdir -p behavior)
    */
-  ensureDirectory(path4) {
-    const segments = this.getPathSegments(path4);
+  ensureDirectory(path2) {
+    const segments = this.getPathSegments(path2);
     let current2 = this.root;
     for (const segment of segments) {
       if (!current2.children) {
@@ -42946,7 +43008,7 @@ var VirtualFS = class _VirtualFS {
         child = { type: "directory", children: /* @__PURE__ */ new Map(), mtime: Date.now() };
         current2.children.set(segment, child);
       } else if (child.type !== "directory") {
-        throw new Error(`ENOTDIR: not a directory, '${path4}'`);
+        throw new Error(`ENOTDIR: not a directory, '${path2}'`);
       }
       current2 = child;
     }
@@ -42955,16 +43017,16 @@ var VirtualFS = class _VirtualFS {
   /**
    * Check if path exists
    */
-  existsSync(path4) {
-    return this.getNode(path4) !== void 0;
+  existsSync(path2) {
+    return this.getNode(path2) !== void 0;
   }
   /**
    * Get stats for path
    */
-  statSync(path4) {
-    const node = this.getNode(path4);
+  statSync(path2) {
+    const node = this.getNode(path2);
     if (!node) {
-      throw createNodeError("ENOENT", "stat", path4);
+      throw createNodeError("ENOENT", "stat", path2);
     }
     const size = node.type === "file" ? node.content?.length || 0 : 0;
     const mtime = node.mtime;
@@ -42999,16 +43061,16 @@ var VirtualFS = class _VirtualFS {
   /**
    * lstatSync - same as statSync for our virtual FS (no symlinks)
    */
-  lstatSync(path4) {
-    return this.statSync(path4);
+  lstatSync(path2) {
+    return this.statSync(path2);
   }
-  readFileSync(path4, encoding) {
-    const node = this.getNode(path4);
+  readFileSync(path2, encoding) {
+    const node = this.getNode(path2);
     if (!node) {
-      throw createNodeError("ENOENT", "open", path4);
+      throw createNodeError("ENOENT", "open", path2);
     }
     if (node.type !== "file") {
-      throw createNodeError("EISDIR", "read", path4);
+      throw createNodeError("EISDIR", "read", path2);
     }
     const content = node.content || new Uint8Array(0);
     if (encoding === "utf8" || encoding === "utf-8") {
@@ -43019,21 +43081,21 @@ var VirtualFS = class _VirtualFS {
   /**
    * Write data to file, creating parent directories as needed
    */
-  writeFileSync(path4, data2) {
-    this.writeFileSyncInternal(path4, data2, true);
+  writeFileSync(path2, data2) {
+    this.writeFileSyncInternal(path2, data2, true);
   }
   /**
    * Create directory, optionally with recursive parent creation
    */
-  mkdirSync(path4, options2) {
-    const normalized = this.normalizePath(path4);
+  mkdirSync(path2, options2) {
+    const normalized = this.normalizePath(path2);
     if (options2?.recursive) {
       this.ensureDirectory(normalized);
       return;
     }
     const parentPath = this.getParentPath(normalized);
-    const basename2 = this.getBasename(normalized);
-    if (!basename2) {
+    const basename3 = this.getBasename(normalized);
+    if (!basename3) {
       return;
     }
     const parent = this.getNode(parentPath);
@@ -43043,10 +43105,10 @@ var VirtualFS = class _VirtualFS {
     if (parent.type !== "directory") {
       throw createNodeError("ENOTDIR", "mkdir", parentPath);
     }
-    if (parent.children.has(basename2)) {
-      throw createNodeError("EEXIST", "mkdir", path4);
+    if (parent.children.has(basename3)) {
+      throw createNodeError("EEXIST", "mkdir", path2);
     }
-    parent.children.set(basename2, {
+    parent.children.set(basename3, {
       type: "directory",
       children: /* @__PURE__ */ new Map(),
       mtime: Date.now()
@@ -43055,63 +43117,63 @@ var VirtualFS = class _VirtualFS {
   /**
    * Read directory contents
    */
-  readdirSync(path4) {
-    const node = this.getNode(path4);
+  readdirSync(path2) {
+    const node = this.getNode(path2);
     if (!node) {
-      throw createNodeError("ENOENT", "scandir", path4);
+      throw createNodeError("ENOENT", "scandir", path2);
     }
     if (node.type !== "directory") {
-      throw createNodeError("ENOTDIR", "scandir", path4);
+      throw createNodeError("ENOTDIR", "scandir", path2);
     }
     return Array.from(node.children.keys());
   }
   /**
    * Remove file
    */
-  unlinkSync(path4) {
-    const normalized = this.normalizePath(path4);
+  unlinkSync(path2) {
+    const normalized = this.normalizePath(path2);
     const parentPath = this.getParentPath(normalized);
-    const basename2 = this.getBasename(normalized);
+    const basename3 = this.getBasename(normalized);
     const parent = this.getNode(parentPath);
     if (!parent || parent.type !== "directory") {
-      throw createNodeError("ENOENT", "unlink", path4);
+      throw createNodeError("ENOENT", "unlink", path2);
     }
-    const node = parent.children.get(basename2);
+    const node = parent.children.get(basename3);
     if (!node) {
-      throw createNodeError("ENOENT", "unlink", path4);
+      throw createNodeError("ENOENT", "unlink", path2);
     }
     if (node.type !== "file") {
-      throw createNodeError("EISDIR", "unlink", path4);
+      throw createNodeError("EISDIR", "unlink", path2);
     }
-    parent.children.delete(basename2);
+    parent.children.delete(basename3);
     this.notifyWatchers(normalized, "rename");
     this.emit("delete", normalized);
   }
   /**
    * Remove directory (must be empty)
    */
-  rmdirSync(path4) {
-    const normalized = this.normalizePath(path4);
+  rmdirSync(path2) {
+    const normalized = this.normalizePath(path2);
     const parentPath = this.getParentPath(normalized);
-    const basename2 = this.getBasename(normalized);
-    if (!basename2) {
-      throw new Error(`EPERM: operation not permitted, '${path4}'`);
+    const basename3 = this.getBasename(normalized);
+    if (!basename3) {
+      throw new Error(`EPERM: operation not permitted, '${path2}'`);
     }
     const parent = this.getNode(parentPath);
     if (!parent || parent.type !== "directory") {
-      throw createNodeError("ENOENT", "rmdir", path4);
+      throw createNodeError("ENOENT", "rmdir", path2);
     }
-    const node = parent.children.get(basename2);
+    const node = parent.children.get(basename3);
     if (!node) {
-      throw createNodeError("ENOENT", "rmdir", path4);
+      throw createNodeError("ENOENT", "rmdir", path2);
     }
     if (node.type !== "directory") {
-      throw createNodeError("ENOTDIR", "rmdir", path4);
+      throw createNodeError("ENOTDIR", "rmdir", path2);
     }
     if (node.children.size > 0) {
-      throw createNodeError("ENOTEMPTY", "rmdir", path4);
+      throw createNodeError("ENOTEMPTY", "rmdir", path2);
     }
-    parent.children.delete(basename2);
+    parent.children.delete(basename3);
   }
   /**
    * Rename/move file or directory
@@ -43140,11 +43202,11 @@ var VirtualFS = class _VirtualFS {
   /**
    * Read file with optional options parameter
    */
-  readFile(path4, optionsOrCallback, callback) {
+  readFile(path2, optionsOrCallback, callback) {
     const actualCallback = typeof optionsOrCallback === "function" ? optionsOrCallback : callback;
     const options2 = typeof optionsOrCallback === "object" ? optionsOrCallback : void 0;
     try {
-      const data2 = options2?.encoding ? this.readFileSync(path4, options2.encoding) : this.readFileSync(path4);
+      const data2 = options2?.encoding ? this.readFileSync(path2, options2.encoding) : this.readFileSync(path2);
       if (actualCallback) {
         setTimeout(() => actualCallback(null, data2), 0);
       }
@@ -43157,9 +43219,9 @@ var VirtualFS = class _VirtualFS {
   /**
    * Async stat
    */
-  stat(path4, callback) {
+  stat(path2, callback) {
     try {
-      const stats = this.statSync(path4);
+      const stats = this.statSync(path2);
       setTimeout(() => callback(null, stats), 0);
     } catch (err2) {
       setTimeout(() => callback(err2), 0);
@@ -43168,16 +43230,16 @@ var VirtualFS = class _VirtualFS {
   /**
    * Async lstat
    */
-  lstat(path4, callback) {
-    this.stat(path4, callback);
+  lstat(path2, callback) {
+    this.stat(path2, callback);
   }
   /**
    * Async readdir
    */
-  readdir(path4, optionsOrCallback, callback) {
+  readdir(path2, optionsOrCallback, callback) {
     const actualCallback = typeof optionsOrCallback === "function" ? optionsOrCallback : callback;
     try {
-      const files = this.readdirSync(path4);
+      const files = this.readdirSync(path2);
       if (actualCallback) {
         setTimeout(() => actualCallback(null, files), 0);
       }
@@ -43190,9 +43252,9 @@ var VirtualFS = class _VirtualFS {
   /**
    * Async realpath
    */
-  realpath(path4, callback) {
+  realpath(path2, callback) {
     try {
-      const resolved = this.realpathSync(path4);
+      const resolved = this.realpathSync(path2);
       setTimeout(() => callback(null, resolved), 0);
     } catch (err2) {
       setTimeout(() => callback(err2), 0);
@@ -43201,10 +43263,10 @@ var VirtualFS = class _VirtualFS {
   /**
    * Sync realpath - in our VFS, just normalize the path
    */
-  realpathSync(path4) {
-    const normalized = this.normalizePath(path4);
+  realpathSync(path2) {
+    const normalized = this.normalizePath(path2);
     if (!this.existsSync(normalized)) {
-      throw createNodeError("ENOENT", "realpath", path4);
+      throw createNodeError("ENOENT", "realpath", path2);
     }
     return normalized;
   }
@@ -43252,15 +43314,15 @@ var VirtualFS = class _VirtualFS {
   /**
    * Notify watchers of file changes
    */
-  notifyWatchers(path4, eventType) {
-    const normalized = this.normalizePath(path4);
-    const basename2 = this.getBasename(normalized);
+  notifyWatchers(path2, eventType) {
+    const normalized = this.normalizePath(path2);
+    const basename3 = this.getBasename(normalized);
     const directWatchers = this.watchers.get(normalized);
     if (directWatchers) {
       for (const entry of directWatchers) {
         if (!entry.closed) {
           try {
-            entry.listener(eventType, basename2);
+            entry.listener(eventType, basename3);
           } catch (err2) {
             console.error("Error in file watcher:", err2);
           }
@@ -43268,7 +43330,7 @@ var VirtualFS = class _VirtualFS {
       }
     }
     let currentPath = this.getParentPath(normalized);
-    let relativePath = basename2;
+    let relativePath = basename3;
     while (currentPath) {
       const parentWatchers = this.watchers.get(currentPath);
       if (parentWatchers) {
@@ -43293,18 +43355,18 @@ var VirtualFS = class _VirtualFS {
   /**
    * Access check - in our VFS, always succeeds if file exists
    */
-  accessSync(path4, mode) {
-    if (!this.existsSync(path4)) {
-      throw createNodeError("ENOENT", "access", path4);
+  accessSync(path2, mode) {
+    if (!this.existsSync(path2)) {
+      throw createNodeError("ENOENT", "access", path2);
     }
   }
   /**
    * Async access
    */
-  access(path4, modeOrCallback, callback) {
+  access(path2, modeOrCallback, callback) {
     const actualCallback = typeof modeOrCallback === "function" ? modeOrCallback : callback;
     try {
-      this.accessSync(path4);
+      this.accessSync(path2);
       if (actualCallback) setTimeout(() => actualCallback(null), 0);
     } catch (err2) {
       if (actualCallback) setTimeout(() => actualCallback(err2), 0);
@@ -43320,7 +43382,7 @@ var VirtualFS = class _VirtualFS {
   /**
    * Create read stream - simplified implementation
    */
-  createReadStream(path4) {
+  createReadStream(path2) {
     const self = this;
     const listeners = {};
     const stream = {
@@ -43335,7 +43397,7 @@ var VirtualFS = class _VirtualFS {
     };
     setTimeout(() => {
       try {
-        const data2 = self.readFileSync(path4);
+        const data2 = self.readFileSync(path2);
         listeners["data"]?.forEach((cb2) => cb2(data2));
         listeners["end"]?.forEach((cb2) => cb2());
       } catch (err2) {
@@ -43347,7 +43409,7 @@ var VirtualFS = class _VirtualFS {
   /**
    * Create write stream - simplified implementation
    */
-  createWriteStream(path4) {
+  createWriteStream(path2) {
     const self = this;
     const chunks = [];
     const listeners = {};
@@ -43370,7 +43432,7 @@ var VirtualFS = class _VirtualFS {
           combined.set(chunk, offset2);
           offset2 += chunk.length;
         }
-        self.writeFileSync(path4, combined);
+        self.writeFileSync(path2, combined);
         listeners["finish"]?.forEach((cb2) => cb2());
         listeners["close"]?.forEach((cb2) => cb2());
       },
@@ -43438,27 +43500,27 @@ function createBuffer(data2) {
   return buffer;
 }
 function toPath(pathLike, getCwd) {
-  let path4;
+  let path2;
   if (typeof pathLike === "string") {
-    path4 = pathLike;
+    path2 = pathLike;
   } else if (pathLike instanceof URL) {
     if (pathLike.protocol === "file:") {
-      path4 = decodeURIComponent(pathLike.pathname);
+      path2 = decodeURIComponent(pathLike.pathname);
     } else {
       throw new Error(`Unsupported URL protocol: ${pathLike.protocol}`);
     }
   } else if (Buffer.isBuffer(pathLike)) {
-    path4 = pathLike.toString("utf8");
+    path2 = pathLike.toString("utf8");
   } else if (pathLike && typeof pathLike === "object" && "toString" in pathLike) {
-    path4 = String(pathLike);
+    path2 = String(pathLike);
   } else {
     throw new TypeError(`Path must be a string, URL, or Buffer. Received: ${typeof pathLike}`);
   }
-  if (!path4.startsWith("/") && getCwd) {
+  if (!path2.startsWith("/") && getCwd) {
     const cwd = getCwd();
-    path4 = cwd.endsWith("/") ? cwd + path4 : cwd + "/" + path4;
+    path2 = cwd.endsWith("/") ? cwd + path2 : cwd + "/" + path2;
   }
-  return path4;
+  return path2;
 }
 var fdMap = /* @__PURE__ */ new Map();
 var nextFd = 3;
@@ -43467,7 +43529,7 @@ var callTracker = {
   readdirSync: /* @__PURE__ */ new Map(),
   lastReset: Date.now()
 };
-function trackCall(method, path4) {
+function trackCall(method, path2) {
   const now = Date.now();
   if (now - callTracker.lastReset > 500) {
     callTracker.statSync.clear();
@@ -43475,15 +43537,15 @@ function trackCall(method, path4) {
     callTracker.lastReset = now;
   }
   const map = callTracker[method];
-  const count = (map.get(path4) || 0) + 1;
-  map.set(path4, count);
-  if (count === 10 && path4.includes("_generated")) {
-    console.warn(`[fs] ${method} called ${count}x on ${path4}`);
+  const count = (map.get(path2) || 0) + 1;
+  map.set(path2, count);
+  if (count === 10 && path2.includes("_generated")) {
+    console.warn(`[fs] ${method} called ${count}x on ${path2}`);
     const err2 = new Error();
     console.log(`[fs] Stack at ${count} calls:`, err2.stack?.split("\n").slice(1, 10).join("\n"));
   }
   if (count === 50) {
-    console.warn(`[fs] Potential infinite loop: ${method} called ${count}+ times on ${path4}`);
+    console.warn(`[fs] Potential infinite loop: ${method} called ${count}+ times on ${path2}`);
   }
 }
 function createFsShim(vfs2, getCwd) {
@@ -43498,7 +43560,7 @@ function createFsShim(vfs2, getCwd) {
     readFile(pathLike, encodingOrOptions) {
       return new Promise((resolve5, reject) => {
         try {
-          const path4 = resolvePath(pathLike);
+          const path2 = resolvePath(pathLike);
           let encoding;
           if (typeof encodingOrOptions === "string") {
             encoding = encodingOrOptions;
@@ -43506,9 +43568,9 @@ function createFsShim(vfs2, getCwd) {
             encoding = encodingOrOptions.encoding;
           }
           if (encoding === "utf8" || encoding === "utf-8") {
-            resolve5(vfs2.readFileSync(path4, "utf8"));
+            resolve5(vfs2.readFileSync(path2, "utf8"));
           } else {
-            resolve5(createBuffer(vfs2.readFileSync(path4)));
+            resolve5(createBuffer(vfs2.readFileSync(path2)));
           }
         } catch (err2) {
           reject(err2);
@@ -43528,8 +43590,8 @@ function createFsShim(vfs2, getCwd) {
     stat(pathLike) {
       return new Promise((resolve5, reject) => {
         try {
-          const path4 = typeof pathLike === "string" ? pathLike : resolvePath(pathLike);
-          resolve5(vfs2.statSync(path4));
+          const path2 = typeof pathLike === "string" ? pathLike : resolvePath(pathLike);
+          resolve5(vfs2.statSync(path2));
         } catch (err2) {
           reject(err2);
         }
@@ -43541,12 +43603,12 @@ function createFsShim(vfs2, getCwd) {
     readdir(pathLike, options2) {
       return new Promise((resolve5, reject) => {
         try {
-          const path4 = resolvePath(pathLike);
-          const entries = vfs2.readdirSync(path4);
+          const path2 = resolvePath(pathLike);
+          const entries = vfs2.readdirSync(path2);
           const opts = typeof options2 === "string" ? {} : options2;
           if (opts?.withFileTypes) {
             const dirents = entries.map((name) => {
-              const entryPath = path4.endsWith("/") ? path4 + name : path4 + "/" + name;
+              const entryPath = path2.endsWith("/") ? path2 + name : path2 + "/" + name;
               let isDir = false;
               let isFile = false;
               try {
@@ -43587,10 +43649,10 @@ function createFsShim(vfs2, getCwd) {
         }
       });
     },
-    rmdir(path4) {
+    rmdir(path2) {
       return new Promise((resolve5, reject) => {
         try {
-          vfs2.rmdirSync(path4);
+          vfs2.rmdirSync(path2);
           resolve5();
         } catch (err2) {
           reject(err2);
@@ -43607,20 +43669,20 @@ function createFsShim(vfs2, getCwd) {
         }
       });
     },
-    access(path4, mode) {
+    access(path2, mode) {
       return new Promise((resolve5, reject) => {
         try {
-          vfs2.accessSync(path4, mode);
+          vfs2.accessSync(path2, mode);
           resolve5();
         } catch (err2) {
           reject(err2);
         }
       });
     },
-    realpath(path4) {
+    realpath(path2) {
       return new Promise((resolve5, reject) => {
         try {
-          resolve5(vfs2.realpathSync(path4));
+          resolve5(vfs2.realpathSync(path2));
         } catch (err2) {
           reject(err2);
         }
@@ -43639,7 +43701,7 @@ function createFsShim(vfs2, getCwd) {
   };
   return {
     readFileSync(pathLike, encodingOrOptions) {
-      const path4 = resolvePath(pathLike);
+      const path2 = resolvePath(pathLike);
       let encoding;
       if (typeof encodingOrOptions === "string") {
         encoding = encodingOrOptions;
@@ -43647,9 +43709,9 @@ function createFsShim(vfs2, getCwd) {
         encoding = encodingOrOptions.encoding;
       }
       if (encoding === "utf8" || encoding === "utf-8") {
-        return vfs2.readFileSync(path4, "utf8");
+        return vfs2.readFileSync(path2, "utf8");
       }
-      const data2 = vfs2.readFileSync(path4);
+      const data2 = vfs2.readFileSync(path2);
       return createBuffer(data2);
     },
     writeFileSync(pathLike, data2) {
@@ -43667,24 +43729,24 @@ function createFsShim(vfs2, getCwd) {
         entry.position = bytes.length;
         return;
       }
-      const path4 = resolvePath(pathLike);
-      vfs2.writeFileSync(path4, data2);
+      const path2 = resolvePath(pathLike);
+      vfs2.writeFileSync(path2, data2);
     },
     existsSync(pathLike) {
       return vfs2.existsSync(resolvePath(pathLike));
     },
     mkdirSync(pathLike, options2) {
-      const path4 = resolvePath(pathLike);
-      vfs2.mkdirSync(path4, options2);
+      const path2 = resolvePath(pathLike);
+      vfs2.mkdirSync(path2, options2);
     },
     readdirSync(pathLike, options2) {
-      const path4 = resolvePath(pathLike);
-      trackCall("readdirSync", path4);
-      const entries = vfs2.readdirSync(path4);
+      const path2 = resolvePath(pathLike);
+      trackCall("readdirSync", path2);
+      const entries = vfs2.readdirSync(path2);
       const opts = typeof options2 === "string" ? { encoding: options2 } : options2;
       if (opts?.withFileTypes) {
         const dirents = entries.map((name) => {
-          const entryPath = path4.endsWith("/") ? path4 + name : path4 + "/" + name;
+          const entryPath = path2.endsWith("/") ? path2 + name : path2 + "/" + name;
           let isDir = false;
           let isFile = false;
           try {
@@ -43696,24 +43758,24 @@ function createFsShim(vfs2, getCwd) {
           }
           return new Dirent(name, isDir, isFile);
         });
-        if (path4.includes("_generated")) {
-          console.log(`[fs] readdirSync(${path4}, withFileTypes) -> [${dirents.map((d) => d.name).join(", ")}]`);
+        if (path2.includes("_generated")) {
+          console.log(`[fs] readdirSync(${path2}, withFileTypes) -> [${dirents.map((d) => d.name).join(", ")}]`);
         }
         return dirents;
       }
-      if (path4.includes("_generated")) {
-        console.log(`[fs] readdirSync(${path4}) -> [${entries.join(", ")}]`);
+      if (path2.includes("_generated")) {
+        console.log(`[fs] readdirSync(${path2}) -> [${entries.join(", ")}]`);
       }
       return entries;
     },
     statSync(pathLike) {
       const origPath = typeof pathLike === "string" ? pathLike : String(pathLike);
-      const path4 = resolvePath(pathLike);
-      trackCall("statSync", path4);
-      const result = vfs2.statSync(path4);
-      if (path4.includes("_generated")) {
-        const wasRemapped = origPath !== path4;
-        console.log(`[fs] statSync(${origPath}${wasRemapped ? " -> " + path4 : ""}) -> isDir: ${result.isDirectory()}`);
+      const path2 = resolvePath(pathLike);
+      trackCall("statSync", path2);
+      const result = vfs2.statSync(path2);
+      if (path2.includes("_generated")) {
+        const wasRemapped = origPath !== path2;
+        console.log(`[fs] statSync(${origPath}${wasRemapped ? " -> " + path2 : ""}) -> isDir: ${result.isDirectory()}`);
       }
       return result;
     },
@@ -43731,25 +43793,25 @@ function createFsShim(vfs2, getCwd) {
       return vfs2.statSync(entry.path);
     },
     openSync(pathLike, flags, _mode) {
-      const path4 = resolvePath(pathLike);
+      const path2 = resolvePath(pathLike);
       const flagStr = typeof flags === "number" ? "r" : flags;
-      const exists = vfs2.existsSync(path4);
+      const exists = vfs2.existsSync(path2);
       const isWriteMode = flagStr.includes("w") || flagStr.includes("a");
       const isReadMode = flagStr.includes("r") && !flagStr.includes("+");
       if (!exists && isReadMode) {
-        const err2 = new Error(`ENOENT: no such file or directory, open '${path4}'`);
+        const err2 = new Error(`ENOENT: no such file or directory, open '${path2}'`);
         err2.code = "ENOENT";
         err2.errno = -2;
-        err2.path = path4;
+        err2.path = path2;
         throw err2;
       }
       let content;
       if (exists && !flagStr.includes("w")) {
-        content = vfs2.readFileSync(path4);
+        content = vfs2.readFileSync(path2);
       } else {
         content = new Uint8Array(0);
         if (isWriteMode) {
-          const parentPath = path4.substring(0, path4.lastIndexOf("/")) || "/";
+          const parentPath = path2.substring(0, path2.lastIndexOf("/")) || "/";
           if (!vfs2.existsSync(parentPath)) {
             vfs2.mkdirSync(parentPath, { recursive: true });
           }
@@ -43757,7 +43819,7 @@ function createFsShim(vfs2, getCwd) {
       }
       const fd2 = nextFd++;
       fdMap.set(fd2, {
-        path: path4,
+        path: path2,
         position: flagStr.includes("a") ? content.length : 0,
         flags: flagStr,
         content: new Uint8Array(content)
@@ -43856,33 +43918,33 @@ function createFsShim(vfs2, getCwd) {
       return resolvedPath2;
     },
     rmSync(pathLike, options2) {
-      const path4 = resolvePath(pathLike);
-      if (!vfs2.existsSync(path4)) {
+      const path2 = resolvePath(pathLike);
+      if (!vfs2.existsSync(path2)) {
         if (options2?.force) return;
-        throw createNodeError("ENOENT", "rm", path4);
+        throw createNodeError("ENOENT", "rm", path2);
       }
-      const stats = vfs2.statSync(path4);
+      const stats = vfs2.statSync(path2);
       if (stats.isDirectory()) {
         if (options2?.recursive) {
-          const entries = vfs2.readdirSync(path4);
+          const entries = vfs2.readdirSync(path2);
           for (const entry of entries) {
-            const entryPath = path4.endsWith("/") ? path4 + entry : path4 + "/" + entry;
+            const entryPath = path2.endsWith("/") ? path2 + entry : path2 + "/" + entry;
             this.rmSync(entryPath, options2);
           }
-          vfs2.rmdirSync(path4);
+          vfs2.rmdirSync(path2);
         } else {
-          throw createNodeError("EISDIR", "rm", path4);
+          throw createNodeError("EISDIR", "rm", path2);
         }
       } else {
-        vfs2.unlinkSync(path4);
+        vfs2.unlinkSync(path2);
       }
     },
     unlinkSync(pathLike) {
-      const path4 = resolvePath(pathLike);
-      if (path4.includes("_generated")) {
-        console.log(`[fs] unlinkSync(${path4})`);
+      const path2 = resolvePath(pathLike);
+      if (path2.includes("_generated")) {
+        console.log(`[fs] unlinkSync(${path2})`);
       }
-      vfs2.unlinkSync(path4);
+      vfs2.unlinkSync(path2);
     },
     rmdirSync(pathLike) {
       vfs2.rmdirSync(resolvePath(pathLike));
@@ -43913,8 +43975,8 @@ function createFsShim(vfs2, getCwd) {
       return vfs2.watch(resolvePath(pathLike), optionsOrListener, listener);
     },
     readFile(pathLike, optionsOrCallback, callback) {
-      const path4 = resolvePath(pathLike);
-      vfs2.readFile(path4, optionsOrCallback, callback);
+      const path2 = resolvePath(pathLike);
+      vfs2.readFile(path2, optionsOrCallback, callback);
     },
     stat(pathLike, callback) {
       vfs2.stat(resolvePath(pathLike), callback);
@@ -43925,12 +43987,12 @@ function createFsShim(vfs2, getCwd) {
     readdir(pathLike, optionsOrCallback, callback) {
       const cb2 = typeof optionsOrCallback === "function" ? optionsOrCallback : callback;
       const opts = typeof optionsOrCallback === "function" ? void 0 : optionsOrCallback;
-      const path4 = resolvePath(pathLike);
+      const path2 = resolvePath(pathLike);
       try {
-        const entries = vfs2.readdirSync(path4);
+        const entries = vfs2.readdirSync(path2);
         if (opts?.withFileTypes) {
           const dirents = entries.map((name) => {
-            const entryPath = path4.endsWith("/") ? path4 + name : path4 + "/" + name;
+            const entryPath = path2.endsWith("/") ? path2 + name : path2 + "/" + name;
             let isDir = false;
             let isFile = false;
             try {
@@ -46509,8 +46571,8 @@ var ClientRequest = class extends Writable {
         }
       }
       if (!hostname2) hostname2 = "localhost";
-      const path4 = this._options.path || "/";
-      const url2 = `${protocol}//${hostname2}${port}${path4}`;
+      const path2 = this._options.path || "/";
+      const url2 = `${protocol}//${hostname2}${port}${path2}`;
       if (this.headers["upgrade"]?.toLowerCase() === "websocket") {
         this._handleWebSocketUpgrade(url2);
         return;
@@ -46956,7 +47018,7 @@ __export(url_exports, {
   format: () => format2,
   parse: () => parse2,
   pathToFileURL: () => pathToFileURL,
-  resolve: () => resolve2
+  resolve: () => resolve3
 });
 function parse2(urlString, parseQueryString = false, slashesDenoteHost = false) {
   try {
@@ -47048,7 +47110,7 @@ function format2(urlObject) {
   }
   return result;
 }
-function resolve2(from, to2) {
+function resolve3(from, to2) {
   try {
     return new URL2(to2, from).href;
   } catch {
@@ -47064,14 +47126,14 @@ function fileURLToPath(url2) {
   }
   return decodeURIComponent(urlObj.pathname);
 }
-function pathToFileURL(path4) {
-  const encoded = encodeURIComponent(path4).replace(/%2F/g, "/");
+function pathToFileURL(path2) {
+  const encoded = encodeURIComponent(path2).replace(/%2F/g, "/");
   return new globalThis.URL("file://" + encoded);
 }
 var url_default = {
   parse: parse2,
   format: format2,
-  resolve: resolve2,
+  resolve: resolve3,
   URL: URL2,
   URLSearchParams,
   fileURLToPath,
@@ -47916,8 +47978,8 @@ __export(dns_exports, {
   getServers: () => getServers,
   lookup: () => lookup,
   promises: () => promises2,
-  resolve: () => resolve3,
-  resolve4: () => resolve4,
+  resolve: () => resolve4,
+  resolve4: () => resolve42,
   resolve6: () => resolve6,
   reverse: () => reverse,
   setDefaultResultOrder: () => setDefaultResultOrder,
@@ -47942,13 +48004,13 @@ function lookup(hostname2, optionsOrCallback, callback) {
     }
   });
 }
-function resolve3(hostname2, callback) {
+function resolve4(hostname2, callback) {
   setImmediate(() => {
     callback(null, ["0.0.0.0"]);
   });
 }
-function resolve4(hostname2, callback) {
-  resolve3(hostname2, callback);
+function resolve42(hostname2, callback) {
+  resolve4(hostname2, callback);
 }
 function resolve6(hostname2, callback) {
   setImmediate(() => {
@@ -47988,7 +48050,7 @@ var promises2 = {
   },
   resolve: (hostname2) => {
     return new Promise((promiseResolve, promiseReject) => {
-      resolve3(hostname2, (err2, addresses) => {
+      resolve4(hostname2, (err2, addresses) => {
         if (err2) promiseReject(err2);
         else promiseResolve(addresses || []);
       });
@@ -48014,8 +48076,8 @@ var V4MAPPED = 0;
 var ALL = 0;
 var dns_default = {
   lookup,
-  resolve: resolve3,
-  resolve4,
+  resolve: resolve4,
+  resolve4: resolve42,
   resolve6,
   reverse,
   setServers,
@@ -48095,63 +48157,63 @@ var VirtualFSAdapter = class {
   /**
    * Read the contents of a file as a string
    */
-  async readFile(path4, options2) {
+  async readFile(path2, options2) {
     const encoding = typeof options2 === "string" ? options2 : options2?.encoding;
     if (!encoding || encoding === "utf8" || encoding === "utf-8") {
-      return this.vfs.readFileSync(path4, "utf8");
+      return this.vfs.readFileSync(path2, "utf8");
     }
     if (encoding === "binary" || encoding === "latin1") {
-      const buffer = this.vfs.readFileSync(path4);
+      const buffer = this.vfs.readFileSync(path2);
       return uint8ToBinaryString(buffer);
     }
-    return this.vfs.readFileSync(path4, "utf8");
+    return this.vfs.readFileSync(path2, "utf8");
   }
   /**
    * Read the contents of a file as a Uint8Array (binary)
    */
-  async readFileBuffer(path4) {
-    return this.vfs.readFileSync(path4);
+  async readFileBuffer(path2) {
+    return this.vfs.readFileSync(path2);
   }
   /**
    * Write content to a file, creating it if it doesn't exist
    */
-  async writeFile(path4, content, _options2) {
-    this.vfs.writeFileSync(path4, content);
+  async writeFile(path2, content, _options2) {
+    this.vfs.writeFileSync(path2, content);
   }
   /**
    * Append content to a file, creating it if it doesn't exist
    */
-  async appendFile(path4, content, _options2) {
+  async appendFile(path2, content, _options2) {
     let existing = "";
     try {
-      existing = this.vfs.readFileSync(path4, "utf8");
+      existing = this.vfs.readFileSync(path2, "utf8");
     } catch {
     }
     const newContent = typeof content === "string" ? content : _decoder3.decode(content);
-    this.vfs.writeFileSync(path4, existing + newContent);
+    this.vfs.writeFileSync(path2, existing + newContent);
   }
   /**
    * Check if a path exists
    */
-  async exists(path4) {
-    return this.vfs.existsSync(path4);
+  async exists(path2) {
+    return this.vfs.existsSync(path2);
   }
   /**
    * Get file/directory information
    */
-  async stat(path4) {
-    const stats = this.vfs.statSync(path4);
+  async stat(path2) {
+    const stats = this.vfs.statSync(path2);
     const isFile = stats.isFile();
     const isDirectory = stats.isDirectory();
     let size = 0;
     if (isFile) {
       try {
-        const content = this.vfs.readFileSync(path4);
+        const content = this.vfs.readFileSync(path2);
         size = content.length;
       } catch {
       }
     }
-    const isExecutable = isFile && path4.includes("/node_modules/.bin/");
+    const isExecutable = isFile && path2.includes("/node_modules/.bin/");
     return {
       isFile,
       isDirectory,
@@ -48164,23 +48226,23 @@ var VirtualFSAdapter = class {
   /**
    * Create a directory
    */
-  async mkdir(path4, options2) {
-    this.vfs.mkdirSync(path4, options2);
+  async mkdir(path2, options2) {
+    this.vfs.mkdirSync(path2, options2);
   }
   /**
    * Read directory contents
    */
-  async readdir(path4) {
-    return this.vfs.readdirSync(path4);
+  async readdir(path2) {
+    return this.vfs.readdirSync(path2);
   }
   /**
    * Read directory contents with file type information
    */
-  async readdirWithFileTypes(path4) {
-    const entries = this.vfs.readdirSync(path4);
+  async readdirWithFileTypes(path2) {
+    const entries = this.vfs.readdirSync(path2);
     const result = [];
     for (const name of entries) {
-      const fullPath = path4 === "/" ? `/${name}` : `${path4}/${name}`;
+      const fullPath = path2 === "/" ? `/${name}` : `${path2}/${name}`;
       try {
         const stats = this.vfs.statSync(fullPath);
         result.push({
@@ -48197,32 +48259,32 @@ var VirtualFSAdapter = class {
   /**
    * Remove a file or directory
    */
-  async rm(path4, options2) {
-    const exists = this.vfs.existsSync(path4);
+  async rm(path2, options2) {
+    const exists = this.vfs.existsSync(path2);
     if (!exists) {
       if (options2?.force) {
         return;
       }
-      throw createNodeError("ENOENT", "rm", path4);
+      throw createNodeError("ENOENT", "rm", path2);
     }
-    const stats = this.vfs.statSync(path4);
+    const stats = this.vfs.statSync(path2);
     if (stats.isFile()) {
-      this.vfs.unlinkSync(path4);
+      this.vfs.unlinkSync(path2);
     } else if (stats.isDirectory()) {
       if (options2?.recursive) {
-        await this.rmRecursive(path4);
+        await this.rmRecursive(path2);
       } else {
-        this.vfs.rmdirSync(path4);
+        this.vfs.rmdirSync(path2);
       }
     }
   }
   /**
    * Recursively remove a directory and its contents
    */
-  async rmRecursive(path4) {
-    const entries = this.vfs.readdirSync(path4);
+  async rmRecursive(path2) {
+    const entries = this.vfs.readdirSync(path2);
     for (const entry of entries) {
-      const fullPath = path4 === "/" ? `/${entry}` : `${path4}/${entry}`;
+      const fullPath = path2 === "/" ? `/${entry}` : `${path2}/${entry}`;
       const stats = this.vfs.statSync(fullPath);
       if (stats.isDirectory()) {
         await this.rmRecursive(fullPath);
@@ -48230,7 +48292,7 @@ var VirtualFSAdapter = class {
         this.vfs.unlinkSync(fullPath);
       }
     }
-    this.vfs.rmdirSync(path4);
+    this.vfs.rmdirSync(path2);
   }
   /**
    * Copy a file or directory
@@ -48276,21 +48338,21 @@ var VirtualFSAdapter = class {
   /**
    * Resolve a relative path against a base path
    */
-  resolvePath(base, path4) {
-    if (path4.startsWith("/")) {
-      return this.normalizePath(path4);
+  resolvePath(base, path2) {
+    if (path2.startsWith("/")) {
+      return this.normalizePath(path2);
     }
-    const combined = base.endsWith("/") ? `${base}${path4}` : `${base}/${path4}`;
+    const combined = base.endsWith("/") ? `${base}${path2}` : `${base}/${path2}`;
     return this.normalizePath(combined);
   }
   /**
    * Normalize a path (resolve . and .. segments)
    */
-  normalizePath(path4) {
-    if (!path4.startsWith("/")) {
-      path4 = "/" + path4;
+  normalizePath(path2) {
+    if (!path2.startsWith("/")) {
+      path2 = "/" + path2;
     }
-    const parts = path4.split("/").filter(Boolean);
+    const parts = path2.split("/").filter(Boolean);
     const resolved = [];
     for (const part of parts) {
       if (part === "..") {
@@ -48359,25 +48421,25 @@ var VirtualFSAdapter = class {
    * Get file/directory information without following symlinks
    * Since VFS doesn't support symlinks, this is the same as stat
    */
-  async lstat(path4) {
-    return this.stat(path4);
+  async lstat(path2) {
+    return this.stat(path2);
   }
   /**
    * Resolve all symlinks in a path
    * Since VFS doesn't support symlinks, just normalize and return
    */
-  async realpath(path4) {
-    if (!this.vfs.existsSync(path4)) {
-      throw createNodeError("ENOENT", "realpath", path4);
+  async realpath(path2) {
+    if (!this.vfs.existsSync(path2)) {
+      throw createNodeError("ENOENT", "realpath", path2);
     }
-    return this.normalizePath(path4);
+    return this.normalizePath(path2);
   }
   /**
    * Set access and modification times (no-op - VFS doesn't track times)
    */
-  async utimes(path4, _atime, _mtime) {
-    if (!this.vfs.existsSync(path4)) {
-      throw createNodeError("ENOENT", "utimes", path4);
+  async utimes(path2, _atime, _mtime) {
+    if (!this.vfs.existsSync(path2)) {
+      throw createNodeError("ENOENT", "utimes", path2);
     }
   }
 };
@@ -49146,29 +49208,29 @@ var FSWatcher = class extends EventEmitter {
     this.vfs = globalVFS;
     this.options = options2;
   }
-  shouldIgnore(path4) {
+  shouldIgnore(path2) {
     const { ignored } = this.options;
     if (!ignored) return false;
     const ignoreList = Array.isArray(ignored) ? ignored : [ignored];
     for (const pattern of ignoreList) {
       if (typeof pattern === "string") {
-        if (path4 === pattern || path4.startsWith(pattern + "/")) return true;
+        if (path2 === pattern || path2.startsWith(pattern + "/")) return true;
       } else if (pattern instanceof RegExp) {
-        if (pattern.test(path4)) return true;
+        if (pattern.test(path2)) return true;
       } else if (typeof pattern === "function") {
-        if (pattern(path4)) return true;
+        if (pattern(path2)) return true;
       }
     }
     return false;
   }
-  normalizePath(path4) {
-    if (this.options.cwd && !path4.startsWith("/")) {
-      path4 = this.options.cwd + "/" + path4;
+  normalizePath(path2) {
+    if (this.options.cwd && !path2.startsWith("/")) {
+      path2 = this.options.cwd + "/" + path2;
     }
-    if (!path4.startsWith("/")) {
-      path4 = "/" + path4;
+    if (!path2.startsWith("/")) {
+      path2 = "/" + path2;
     }
-    return path4;
+    return path2;
   }
   add(paths) {
     if (this.closed) return this;
@@ -49231,15 +49293,15 @@ var FSWatcher = class extends EventEmitter {
     } catch {
     }
   }
-  watchPath(path4, watchFor) {
-    if (this.watched.has(path4)) return;
-    const watcher = this.vfs.watch(path4, { recursive: true }, (eventType, filename2) => {
+  watchPath(path2, watchFor) {
+    if (this.watched.has(path2)) return;
+    const watcher = this.vfs.watch(path2, { recursive: true }, (eventType, filename2) => {
       if (this.closed) return;
       let fullPath;
       if (filename2) {
-        fullPath = path4 === "/" ? "/" + filename2 : path4 + "/" + filename2;
+        fullPath = path2 === "/" ? "/" + filename2 : path2 + "/" + filename2;
       } else {
-        fullPath = path4;
+        fullPath = path2;
       }
       const eventKey = `${eventType}:${fullPath}`;
       if (!this._eventCounts) this._eventCounts = /* @__PURE__ */ new Map();
@@ -49283,7 +49345,7 @@ var FSWatcher = class extends EventEmitter {
         }
       }
     });
-    this.watched.set(path4, watcher);
+    this.watched.set(path2, watcher);
   }
   watchDirRecursive(dirPath, depth = 0) {
     if (this.options.depth !== void 0 && depth > this.options.depth) return;
@@ -49327,13 +49389,13 @@ var FSWatcher = class extends EventEmitter {
   }
   getWatched() {
     const result = {};
-    for (const path4 of this.watched.keys()) {
-      const dir = path4.substring(0, path4.lastIndexOf("/")) || "/";
-      const basename2 = path4.substring(path4.lastIndexOf("/") + 1);
+    for (const path2 of this.watched.keys()) {
+      const dir = path2.substring(0, path2.lastIndexOf("/")) || "/";
+      const basename3 = path2.substring(path2.lastIndexOf("/") + 1);
       if (!result[dir]) {
         result[dir] = [];
       }
-      result[dir].push(basename2);
+      result[dir].push(basename3);
     }
     return result;
   }
@@ -49727,13 +49789,13 @@ var constants6 = {
   kFSEventStreamEventFlagItemIsDir: 131072,
   kFSEventStreamEventFlagItemIsSymlink: 262144
 };
-function watch2(path4, handler) {
+function watch2(path2, handler) {
   return () => Promise.resolve();
 }
-function getInfo(path4, flags) {
+function getInfo(path2, flags) {
   return {
     event: "unknown",
-    path: path4,
+    path: path2,
     type: "file",
     changes: { inode: false, finder: false, access: false, xattrs: false },
     flags
@@ -50401,8 +50463,8 @@ async function transformToCommonJS(code2, options2) {
   });
   return result.code;
 }
-function remapVFSPath(path4) {
-  return path4;
+function remapVFSPath(path2) {
+  return path2;
 }
 function findVFSFile(vfs2, originalPath, extensions) {
   for (const ext2 of extensions) {
@@ -50560,16 +50622,16 @@ async function build(options2) {
       }
       if (ep2.startsWith("./")) {
         const base = absWorkingDir.endsWith("/") ? absWorkingDir.slice(0, -1) : absWorkingDir;
-        const relative2 = ep2.slice(2);
-        const resolved = base + "/" + relative2;
+        const relative3 = ep2.slice(2);
+        const resolved = base + "/" + relative3;
         return resolved;
       }
       if (ep2.startsWith("../")) {
         const base = absWorkingDir.endsWith("/") ? absWorkingDir.slice(0, -1) : absWorkingDir;
         const parts = base.split("/").filter(Boolean);
         parts.pop();
-        const relative2 = ep2.slice(3);
-        const resolved = "/" + parts.join("/") + "/" + relative2;
+        const relative3 = ep2.slice(3);
+        const resolved = "/" + parts.join("/") + "/" + relative3;
         return resolved;
       }
       return ep2;
@@ -58172,9 +58234,9 @@ function transformEsmToCjsAst2(code2, filename2) {
 function transformEsmToCjsRegexFallback(code2, filename2) {
   let transformed = code2;
   transformed = transformed.replace(/\bimport\.meta\.url\b/g, `"file://${filename2}"`);
-  transformed = transformed.replace(/\bimport\.meta\.dirname\b/g, `"${dirname2(filename2)}"`);
+  transformed = transformed.replace(/\bimport\.meta\.dirname\b/g, `"${dirname3(filename2)}"`);
   transformed = transformed.replace(/\bimport\.meta\.filename\b/g, `"${filename2}"`);
-  transformed = transformed.replace(/\bimport\.meta\b/g, `({ url: "file://${filename2}", dirname: "${dirname2(filename2)}", filename: "${filename2}" })`);
+  transformed = transformed.replace(/\bimport\.meta\b/g, `({ url: "file://${filename2}", dirname: "${dirname3(filename2)}", filename: "${filename2}" })`);
   transformed = transformDynamicImportsRegex(transformed);
   const hasImport = /\bimport\s+[\w{*'"]/m.test(code2);
   const hasExport = /\bexport\s+(?:default|const|let|var|function|class|{|\*)/m.test(code2);
@@ -58413,19 +58475,19 @@ function createRequire2(vfs, fsShim, process, currentDir, moduleCache, options,
     if (id2.startsWith("#")) {
       let searchDir2 = fromDir;
       while (searchDir2 !== "/") {
-        const pkgPath = join2(searchDir2, "package.json");
+        const pkgPath = join3(searchDir2, "package.json");
         const pkg = getParsedPackageJson(pkgPath);
         if (pkg?.imports) {
           try {
             const resolved = f(pkg, id2, { require: true });
             if (resolved && resolved.length > 0) {
-              const fullPath = join2(searchDir2, resolved[0]);
+              const fullPath = join3(searchDir2, resolved[0]);
               if (vfs.existsSync(fullPath)) return fullPath;
             }
           } catch {
           }
         }
-        searchDir2 = dirname2(searchDir2);
+        searchDir2 = dirname3(searchDir2);
       }
       throw new Error(`Cannot find module '${id2}'`);
     }
@@ -58438,14 +58500,14 @@ function createRequire2(vfs, fsShim, process, currentDir, moduleCache, options,
       return cached;
     }
     if (id2.startsWith("./") || id2.startsWith("../") || id2.startsWith("/")) {
-      const resolved = id2.startsWith("/") ? id2 : resolve(fromDir, id2);
+      const resolved = id2.startsWith("/") ? id2 : resolve2(fromDir, id2);
       if (vfs.existsSync(resolved)) {
         const stats = vfs.statSync(resolved);
         if (stats.isFile()) {
           resolutionCache.set(cacheKey, resolved);
           return resolved;
         }
-        const indexPath = join2(resolved, "index.js");
+        const indexPath = join3(resolved, "index.js");
         if (vfs.existsSync(indexPath)) {
           resolutionCache.set(cacheKey, indexPath);
           return indexPath;
@@ -58468,7 +58530,7 @@ function createRequire2(vfs, fsShim, process, currentDir, moduleCache, options,
         if (stats.isFile()) {
           return basePath;
         }
-        const indexPath = join2(basePath, "index.js");
+        const indexPath = join3(basePath, "index.js");
         if (vfs.existsSync(indexPath)) {
           return indexPath;
         }
@@ -58485,12 +58547,12 @@ function createRequire2(vfs, fsShim, process, currentDir, moduleCache, options,
     const applyBrowserFieldRemap = (resolvedPath2, pkg, pkgRoot) => {
       if (!pkg.browser || typeof pkg.browser !== "object") return resolvedPath2;
       const browserMap = pkg.browser;
-      const relPath = "./" + relative(pkgRoot, resolvedPath2);
+      const relPath = "./" + relative2(pkgRoot, resolvedPath2);
       const relPathNoExt = relPath.replace(/\.(js|json|cjs|mjs)$/, "");
       for (const key of [relPath, relPathNoExt]) {
         if (key in browserMap) {
           if (browserMap[key] === false) return null;
-          return tryResolveFile(join2(pkgRoot, browserMap[key]));
+          return tryResolveFile(join3(pkgRoot, browserMap[key]));
         }
       }
       return resolvedPath2;
@@ -58498,8 +58560,8 @@ function createRequire2(vfs, fsShim, process, currentDir, moduleCache, options,
     const tryResolveFromNodeModules = (nodeModulesDir, moduleId) => {
       const parts = moduleId.split("/");
       const pkgName = parts[0].startsWith("@") && parts.length > 1 ? `${parts[0]}/${parts[1]}` : parts[0];
-      const pkgRoot = join2(nodeModulesDir, pkgName);
-      const pkgPath = join2(pkgRoot, "package.json");
+      const pkgRoot = join3(nodeModulesDir, pkgName);
+      const pkgPath = join3(pkgRoot, "package.json");
       const pkg = getParsedPackageJson(pkgPath);
       if (pkg) {
         if (pkg.exports) {
@@ -58508,7 +58570,7 @@ function createRequire2(vfs, fsShim, process, currentDir, moduleCache, options,
               const resolved2 = s(pkg, moduleId, conditions);
               if (resolved2 && resolved2.length > 0) {
                 const exportPath = resolved2[0];
-                const fullExportPath = join2(pkgRoot, exportPath);
+                const fullExportPath = join3(pkgRoot, exportPath);
                 const resolvedFile = tryResolveFile(fullExportPath);
                 if (resolvedFile) {
                   if (resolvedFile.endsWith(".cjs")) {
@@ -58538,25 +58600,25 @@ function createRequire2(vfs, fsShim, process, currentDir, moduleCache, options,
           if (!main) {
             main = pkg.main || "index.js";
           }
-          const mainPath = join2(pkgRoot, main);
+          const mainPath = join3(pkgRoot, main);
           const resolvedMain = tryResolveFile(mainPath);
           if (resolvedMain) return resolvedMain;
         }
       }
-      const fullPath = join2(nodeModulesDir, moduleId);
+      const fullPath = join3(nodeModulesDir, moduleId);
       const resolved = tryResolveFile(fullPath);
       if (resolved) return resolved;
       return null;
     };
     let searchDir = fromDir;
     while (searchDir !== "/") {
-      const nodeModulesDir = join2(searchDir, "node_modules");
+      const nodeModulesDir = join3(searchDir, "node_modules");
       const resolved = tryResolveFromNodeModules(nodeModulesDir, id2);
       if (resolved) {
         resolutionCache.set(cacheKey, resolved);
         return resolved;
       }
-      searchDir = dirname2(searchDir);
+      searchDir = dirname3(searchDir);
     }
     const rootResolved = tryResolveFromNodeModules("/node_modules", id2);
     if (rootResolved) {
@@ -58590,7 +58652,7 @@ function createRequire2(vfs, fsShim, process, currentDir, moduleCache, options,
       return module;
     }
     const rawCode = vfs.readFileSync(resolvedPath, "utf8");
-    const dirname = dirname2(resolvedPath);
+    const dirname = dirname3(resolvedPath);
     const codeCacheKey = `${resolvedPath}|${simpleHash(rawCode)}`;
     let code = processedCodeCache?.get(codeCacheKey);
     if (!code) {
@@ -58687,7 +58749,7 @@ ${code}
               fromPath = fromPath.slice(1);
             }
           }
-          const fromDir = dirname2(fromPath);
+          const fromDir = dirname3(fromPath);
           const newRequire = createRequire2(
             vfs,
             fsShim,
@@ -59004,7 +59066,7 @@ var Runtime = class {
    * Execute code as a module (synchronous - backward compatible)
    */
   execute(code, filename = "/index.js") {
-    const dirname = dirname2(filename);
+    const dirname = dirname3(filename);
     this.vfs.writeFileSync(filename, code);
     const require = createRequire2(
       this.vfs,
@@ -59473,7 +59535,7 @@ var ServerBridge = class _ServerBridge extends EventEmitter {
         throw new Error("Not a virtual server request");
       }
       const port = parseInt(match3[1], 10);
-      const path4 = match3[2] || "/";
+      const path2 = match3[2] || "/";
       const headers = {};
       request3.headers.forEach((value, key) => {
         headers[key] = value;
@@ -59485,7 +59547,7 @@ var ServerBridge = class _ServerBridge extends EventEmitter {
       const response = await this.handleRequest(
         port,
         request3.method,
-        path4 + url2.search,
+        path2 + url2.search,
         headers,
         body
       );
@@ -59611,20 +59673,20 @@ var DevServer = class extends EventEmitter {
    * Resolve a URL path to a filesystem path
    */
   resolvePath(urlPath) {
-    let path4 = urlPath.split("?")[0].split("#")[0];
-    if (!path4.startsWith("/")) {
-      path4 = "/" + path4;
+    let path2 = urlPath.split("?")[0].split("#")[0];
+    if (!path2.startsWith("/")) {
+      path2 = "/" + path2;
     }
     if (this.root !== "/") {
-      path4 = this.root + path4;
+      path2 = this.root + path2;
     }
-    return path4;
+    return path2;
   }
   /**
    * Create a 404 Not Found response
    */
-  notFound(path4) {
-    const body = `Not found: ${path4}`;
+  notFound(path2) {
+    const body = `Not found: ${path2}`;
     return {
       statusCode: 404,
       statusMessage: "Not Found",
@@ -59669,16 +59731,16 @@ var DevServer = class extends EventEmitter {
   /**
    * Get MIME type for a file path
    */
-  getMimeType(path4) {
-    const ext2 = path4.split(".").pop()?.toLowerCase() || "";
+  getMimeType(path2) {
+    const ext2 = path2.split(".").pop()?.toLowerCase() || "";
     return MIME_TYPES[ext2] || "application/octet-stream";
   }
   /**
    * Check if a path exists in the virtual filesystem
    */
-  exists(path4) {
+  exists(path2) {
     try {
-      this.vfs.statSync(path4);
+      this.vfs.statSync(path2);
       return true;
     } catch {
       return false;
@@ -59687,9 +59749,9 @@ var DevServer = class extends EventEmitter {
   /**
    * Check if a path is a directory
    */
-  isDirectory(path4) {
+  isDirectory(path2) {
     try {
-      return this.vfs.statSync(path4).isDirectory();
+      return this.vfs.statSync(path2).isDirectory();
     } catch {
       return false;
     }
@@ -60014,13 +60076,13 @@ var ViteDevServer = class extends DevServer {
   /**
    * Handle file change event
    */
-  handleFileChange(path4) {
-    const isCSS = path4.endsWith(".css");
-    const isJS = /\.(jsx?|tsx?)$/.test(path4);
+  handleFileChange(path2) {
+    const isCSS = path2.endsWith(".css");
+    const isJS = /\.(jsx?|tsx?)$/.test(path2);
     const updateType = isCSS || isJS ? "update" : "full-reload";
     const update = {
       type: updateType,
-      path: path4,
+      path: path2,
       timestamp: Date.now()
     };
     this.emitHMRUpdate(update);
@@ -60045,8 +60107,8 @@ var ViteDevServer = class extends DevServer {
   /**
    * Check if a file needs transformation
    */
-  needsTransform(path4) {
-    return /\.(jsx|tsx|ts)$/.test(path4);
+  needsTransform(path2) {
+    return /\.(jsx|tsx|ts)$/.test(path2);
   }
   /**
    * Transform and serve a JSX/TS file
@@ -60298,7 +60360,7 @@ function wrapCjsAsEsm(code2, virtualPrefix = "", requestPath = "") {
   if (!/\b(require\s*\(|module\.exports|exports\.)/.test(stripped)) {
     return code2;
   }
-  const requestDir = requestPath ? import_node_path2.default.posix.dirname(requestPath) : "";
+  const requestDir = requestPath ? posixPath.dirname(requestPath) : "";
   const commentFree = code2.replace(
     /("(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)*'|`(?:[^`\\]|\\.)*`|\/\*[\s\S]*?\*\/|\/\/[^\n]*)/g,
     (m) => {
@@ -60319,7 +60381,7 @@ function wrapCjsAsEsm(code2, virtualPrefix = "", requestPath = "") {
     const varName = `__cjs_req_${counter++}__`;
     let resolvedSpec;
     if (specifier.startsWith(".")) {
-      resolvedSpec = `${virtualPrefix}${import_node_path2.default.posix.resolve(requestDir, specifier)}`;
+      resolvedSpec = `${virtualPrefix}${posixPath.resolve(requestDir, specifier)}`;
     } else {
       resolvedSpec = `${virtualPrefix}/node_modules/${specifier}`;
     }
@@ -60409,7 +60471,7 @@ async function ensureEsbuildWasm() {
   await window.__esbuildInitPromise;
 }
 function normalizePath(inputPath) {
-  return import_node_path2.default.posix.normalize(inputPath.trim() || "/") || "/";
+  return posixPath.normalize(inputPath.trim() || "/") || "/";
 }
 function isInternalAlmostNodePath(targetPath) {
   const normalizedPath = normalizePath(targetPath);
@@ -60469,7 +60531,7 @@ function removeVirtualPath(vfs2, targetPath) {
     return;
   }
   for (const childName of vfs2.readdirSync(normalizedPath)) {
-    removeVirtualPath(vfs2, import_node_path2.default.posix.join(normalizedPath, childName));
+    removeVirtualPath(vfs2, posixPath.join(normalizedPath, childName));
   }
   vfs2.rmdirSync(normalizedPath);
 }
@@ -60779,8 +60841,8 @@ var AlmostNodeSession = class {
     return result;
   }
   async serveExistingVirtualStaticFile(root2, requestUrl, bufferCtor) {
-    const basePath = normalizePath(import_node_path2.default.posix.join(root2, getRequestPathname(requestUrl)));
-    const hasExtension = /\.[a-zA-Z0-9]+$/.test(import_node_path2.default.posix.basename(basePath));
+    const basePath = normalizePath(posixPath.join(root2, getRequestPathname(requestUrl)));
+    const hasExtension = /\.[a-zA-Z0-9]+$/.test(posixPath.basename(basePath));
     let candidates;
     if (hasExtension) {
       candidates = [basePath];
@@ -60792,7 +60854,7 @@ var AlmostNodeSession = class {
           const raw = this.vfs.readFileSync(pkgPath, "utf8");
           const pkg = this.parseCachedPackageJson(pkgPath, raw);
           const entry = pkg ? typeof pkg.module === "string" && pkg.module || typeof pkg.main === "string" && pkg.main : null;
-          if (entry) candidates.push(normalizePath(import_node_path2.default.posix.join(basePath, entry)));
+          if (entry) candidates.push(normalizePath(posixPath.join(basePath, entry)));
         }
       } catch {
       }
@@ -60801,7 +60863,7 @@ var AlmostNodeSession = class {
           const raw = await this.fs.readFile(pkgPath, "utf-8");
           const pkg = this.parseCachedPackageJson(pkgPath, raw);
           const entry = pkg ? typeof pkg.module === "string" && pkg.module || typeof pkg.main === "string" && pkg.main : null;
-          if (entry) candidates.push(normalizePath(import_node_path2.default.posix.join(basePath, entry)));
+          if (entry) candidates.push(normalizePath(posixPath.join(basePath, entry)));
         }
       } catch {
       }
@@ -60839,7 +60901,7 @@ var AlmostNodeSession = class {
         }
         const content = await this.fs.readFileBuffer(targetPath);
         this._vfs.withoutMirror(() => {
-          this._vfs.mkdirSync(import_node_path2.default.posix.dirname(targetPath), { recursive: true });
+          this._vfs.mkdirSync(posixPath.dirname(targetPath), { recursive: true });
           this._vfs.writeFileSync(targetPath, content);
         });
         const body = bufferCtor.from(content);
@@ -60885,7 +60947,7 @@ var AlmostNodeSession = class {
       }
     }
     for (const packageName of candidatePackageNames) {
-      const pkgJsonPath = normalizePath(import_node_path2.default.posix.join(cwd, "node_modules", packageName, "package.json"));
+      const pkgJsonPath = normalizePath(posixPath.join(cwd, "node_modules", packageName, "package.json"));
       if (!await this.fs.exists(pkgJsonPath)) {
         continue;
       }
@@ -60895,16 +60957,16 @@ var AlmostNodeSession = class {
         if (!pkgJson) {
           continue;
         }
-        const pkgDir = normalizePath(import_node_path2.default.posix.join(cwd, "node_modules", packageName));
+        const pkgDir = normalizePath(posixPath.join(cwd, "node_modules", packageName));
         if (typeof pkgJson.bin === "string") {
           const inferredBinName = typeof pkgJson.name === "string" ? pkgJson.name.split("/").pop() ?? pkgJson.name : packageName.split("/").pop() ?? packageName;
           if (binName === inferredBinName) {
-            return normalizePath(import_node_path2.default.posix.join(pkgDir, pkgJson.bin));
+            return normalizePath(posixPath.join(pkgDir, pkgJson.bin));
           }
         }
         if (typeof pkgJson.bin === "object" && pkgJson.bin !== null && binName in pkgJson.bin) {
           const namedBins = pkgJson.bin;
-          return normalizePath(import_node_path2.default.posix.join(pkgDir, namedBins[binName]));
+          return normalizePath(posixPath.join(pkgDir, namedBins[binName]));
         }
       } catch {
       }
@@ -60991,7 +61053,7 @@ var AlmostNodeSession = class {
       }
       const content = await this.fs.readFileBuffer(normalizedPath);
       this._vfs.withoutMirror(() => {
-        this._vfs.mkdirSync(import_node_path2.default.posix.dirname(normalizedPath), { recursive: true });
+        this._vfs.mkdirSync(posixPath.dirname(normalizedPath), { recursive: true });
         this._vfs.writeFileSync(normalizedPath, content);
       });
     } catch {
@@ -61054,7 +61116,7 @@ var AlmostNodeSession = class {
       });
       this._vfs.withoutMirror(() => {
         for (const [filePath, content] of contents) {
-          this._vfs.mkdirSync(import_node_path2.default.posix.dirname(filePath), { recursive: true });
+          this._vfs.mkdirSync(posixPath.dirname(filePath), { recursive: true });
           this._vfs.writeFileSync(filePath, content);
         }
       });
@@ -61075,7 +61137,7 @@ var AlmostNodeSession = class {
     }
     const dependencyPaths = [];
     for (const packageName of getPackageJsonDependencyNames(packageJsonResult.pkgJson)) {
-      const packageRoot = normalizePath(import_node_path2.default.posix.join(cwd, "node_modules", packageName));
+      const packageRoot = normalizePath(posixPath.join(cwd, "node_modules", packageName));
       if (!await this.fs.exists(packageRoot)) {
         continue;
       }
@@ -61109,7 +61171,7 @@ var AlmostNodeSession = class {
         return;
       }
       await this.withSuppressedObservableMirroring(async () => {
-        await ensureObservableDirectory(this.fs, import_node_path2.default.posix.dirname(normalizedPath));
+        await ensureObservableDirectory(this.fs, posixPath.dirname(normalizedPath));
         await this.fs.writeFile(normalizedPath, data2);
       });
     })());
@@ -61144,7 +61206,7 @@ var AlmostNodeSession = class {
         return;
       }
       await this.withSuppressedObservableMirroring(async () => {
-        await ensureObservableDirectory(this.fs, import_node_path2.default.posix.dirname(normalizedNextPath));
+        await ensureObservableDirectory(this.fs, posixPath.dirname(normalizedNextPath));
         await this.fs.mv(normalizedPreviousPath, normalizedNextPath);
       });
     })());
@@ -61165,7 +61227,7 @@ var AlmostNodeSession = class {
     await this.initializePromise;
   }
   async readPackageJson(cwd) {
-    const packageJsonPath = normalizePath(import_node_path2.default.posix.join(cwd, "package.json"));
+    const packageJsonPath = normalizePath(posixPath.join(cwd, "package.json"));
     if (!this.vfs.existsSync(packageJsonPath)) {
       await this.copyObservablePathIntoVirtualFs(packageJsonPath, { force: true });
     }
@@ -61277,7 +61339,7 @@ var AlmostNodeSession = class {
       ...baseEnv,
       npm_lifecycle_event: scriptName,
       PATH: Array.from(/* @__PURE__ */ new Set([
-        normalizePath(import_node_path2.default.posix.join(cwd, "node_modules/.bin")),
+        normalizePath(posixPath.join(cwd, "node_modules/.bin")),
         "/node_modules/.bin",
         ...(baseEnv.PATH?.trim() || DEFAULT_PATH).split(":").filter(Boolean)
       ])).join(":")
@@ -61479,7 +61541,7 @@ ${packages.map(([name, version4]) => `+-- ${name}@${version4}`).join("\n")}
           message: `Unsupported node flag in just-bash: ${firstArg}`
         };
       }
-      const scriptPath = import_node_path2.default.posix.isAbsolute(firstArg) ? normalizePath(firstArg) : normalizePath(import_node_path2.default.posix.resolve(cwd, firstArg));
+      const scriptPath = posixPath.isAbsolute(firstArg) ? normalizePath(firstArg) : normalizePath(posixPath.resolve(cwd, firstArg));
       return {
         kind: "run-file",
         scriptPath,
@@ -61678,7 +61740,7 @@ ${packages.map(([name, version4]) => `+-- ${name}@${version4}`).join("\n")}
       if (!targetPath.startsWith(`${cwdPrefix}node_modules/`)) {
         return true;
       }
-      const baseName = import_node_path2.default.posix.basename(targetPath).toLowerCase();
+      const baseName = posixPath.basename(targetPath).toLowerCase();
       if (baseName === "package.json") {
         return true;
       }
@@ -61696,7 +61758,7 @@ ${packages.map(([name, version4]) => `+-- ${name}@${version4}`).join("\n")}
       });
       this._vfs.withoutMirror(() => {
         for (const [filePath, content] of contents) {
-          this._vfs.mkdirSync(import_node_path2.default.posix.dirname(filePath), { recursive: true });
+          this._vfs.mkdirSync(posixPath.dirname(filePath), { recursive: true });
           this._vfs.writeFileSync(filePath, content);
         }
       });
@@ -61817,17 +61879,17 @@ var DEFAULT_BASH_SHELL_ENV = {
 var DEFAULT_BASH_COMMAND_TIMEOUT_MS = 5 * 60 * 1e3;
 var DEFAULT_BASH_OUTPUT_LIMIT = 1e4;
 function normalizeBashPath(input) {
-  const posixPath = input.trim().replace(/\\/g, "/") || "/";
+  const posixPath2 = input.trim().replace(/\\/g, "/") || "/";
   const segments = [];
-  const isAbsolute2 = posixPath.startsWith("/");
-  for (const segment of posixPath.split("/")) {
+  const isAbsolute3 = posixPath2.startsWith("/");
+  for (const segment of posixPath2.split("/")) {
     if (segment === "..") {
       segments.pop();
     } else if (segment !== "." && segment !== "") {
       segments.push(segment);
     }
   }
-  return (isAbsolute2 ? "/" : "") + segments.join("/") || "/";
+  return (isAbsolute3 ? "/" : "") + segments.join("/") || "/";
 }
 function truncateBashOutput(output, limitBytes = DEFAULT_BASH_OUTPUT_LIMIT) {
   if (!output || output.length <= limitBytes) {
@@ -61854,7 +61916,8 @@ function createBrowserBashSession(options2 = {}) {
     fs,
     customCommands: [
       Dx("node", async (args, ctx) => almostNodeSession.executeNode(args, ctx)),
-      Dx("npm", async (args, ctx) => almostNodeSession.executeNpm(args, ctx))
+      Dx("npm", async (args, ctx) => almostNodeSession.executeNpm(args, ctx)),
+      ...options2.customCommands ?? []
     ]
   });
   almostNodeSession.setBinCommandRegistrar((name, handler) => {