agent-web-os 0.1.1 → 0.1.3

package/dist/index.js

@@ -2134,16 +2134,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 }
       };
     }
@@ -36465,8 +36465,71 @@ function G7(e10) {
   }
 }
 
+// src/posix-path.ts
+function normalize(p) {
+  if (p === "") return ".";
+  const isAbsolute2 = 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 (isAbsolute2) result = "/" + result;
+  if (trailingSlash && result.length > 1) result += "/";
+  return result || (isAbsolute2 ? "/" : ".");
+}
+function join3(...parts) {
+  return normalize(parts.filter(Boolean).join("/"));
+}
+function resolve2(...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 dirname3(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 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);
+  let common = 0;
+  while (common < fromParts.length && common < toParts.length && fromParts[common] === toParts[common]) {
+    common++;
+  }
+  const ups = fromParts.length - common;
+  const remaining = toParts.slice(common);
+  return [...Array(ups).fill(".."), ...remaining].join("/");
+}
+function isAbsolute(p) {
+  return p.length > 0 && p.charCodeAt(0) === 47;
+}
+var posixPath = { normalize, join: join3, resolve: resolve2, dirname: dirname3, basename, relative: relative2, isAbsolute };
+
 // src/observable-in-memory-fs.ts
-import path2 from "path";
 function isObservableInMemoryFsLike(value) {
   if (!value || typeof value !== "object") {
     return false;
@@ -36493,18 +36556,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)
@@ -36517,7 +36580,7 @@ function mapUnlinkEvent(entryType) {
   return entryType === "directory" ? "unlinkDir" : "unlink";
 }
 function normalizeFsPathForLogScope(fsPath) {
-  const normalized = path2.posix.normalize(fsPath);
+  const normalized = posixPath.normalize(fsPath);
   return normalized === "." ? "/" : normalized;
 }
 function createWorkspacePathFilter(workspaceRoot) {
@@ -36527,7 +36590,7 @@ function createWorkspacePathFilter(workspaceRoot) {
     if (normalizedPath !== normalizedWorkspaceRoot && !normalizedPath.startsWith(`${normalizedWorkspaceRoot}/`)) {
       return false;
     }
-    const relativePath = path2.posix.relative(normalizedWorkspaceRoot, normalizedPath);
+    const relativePath = posixPath.relative(normalizedWorkspaceRoot, normalizedPath);
     if (!relativePath || relativePath === ".") {
       return true;
     }
@@ -36641,124 +36704,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()) {
@@ -36831,19 +36894,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
     });
   }
@@ -36865,27 +36928,24 @@ 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
-import path3 from "path";
-
 // node_modules/almostnode/src/utils/hash.ts
 function simpleHash(str) {
   let hash = 0;
@@ -36929,7 +36989,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,
@@ -36945,12 +37005,12 @@ function createNodeError(code2, syscall, path4, message) {
     ENOTEMPTY: "directory not empty"
   };
   const err = new Error(
-    message || `${code2}: ${messages[code2]}, ${syscall} '${path4}'`
+    message || `${code2}: ${messages[code2]}, ${syscall} '${path2}'`
   );
   err.code = code2;
   err.errno = errno[code2];
   err.syscall = syscall;
-  err.path = path4;
+  err.path = path2;
   return err;
 }
 var VirtualFS = class _VirtualFS {
@@ -37000,18 +37060,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);
         }
       }
@@ -37046,17 +37106,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 basename = this.getBasename(normalized);
-    if (!basename) {
-      throw new Error(`EISDIR: illegal operation on a directory, '${path4}'`);
+    const basename2 = this.getBasename(normalized);
+    if (!basename2) {
+      throw new Error(`EISDIR: illegal operation on a directory, '${path2}'`);
     }
     const parent = this.ensureDirectory(parentPath);
-    const existed = parent.children.has(basename);
+    const existed = parent.children.has(basename2);
     const content = typeof data2 === "string" ? this.encoder.encode(data2) : data2;
-    parent.children.set(basename, {
+    parent.children.set(basename2, {
       type: "file",
       content,
       mtime: Date.now()
@@ -37069,11 +37129,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 === "..") {
@@ -37087,30 +37147,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) {
@@ -37127,8 +37187,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) {
@@ -37139,7 +37199,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;
     }
@@ -37148,16 +37208,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;
@@ -37192,16 +37252,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") {
@@ -37212,21 +37272,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 basename = this.getBasename(normalized);
-    if (!basename) {
+    const basename2 = this.getBasename(normalized);
+    if (!basename2) {
       return;
     }
     const parent = this.getNode(parentPath);
@@ -37236,10 +37296,10 @@ var VirtualFS = class _VirtualFS {
     if (parent.type !== "directory") {
       throw createNodeError("ENOTDIR", "mkdir", parentPath);
     }
-    if (parent.children.has(basename)) {
-      throw createNodeError("EEXIST", "mkdir", path4);
+    if (parent.children.has(basename2)) {
+      throw createNodeError("EEXIST", "mkdir", path2);
     }
-    parent.children.set(basename, {
+    parent.children.set(basename2, {
       type: "directory",
       children: /* @__PURE__ */ new Map(),
       mtime: Date.now()
@@ -37248,63 +37308,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 basename = this.getBasename(normalized);
+    const basename2 = 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(basename);
+    const node = parent.children.get(basename2);
     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(basename);
+    parent.children.delete(basename2);
     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 basename = this.getBasename(normalized);
-    if (!basename) {
-      throw new Error(`EPERM: operation not permitted, '${path4}'`);
+    const basename2 = this.getBasename(normalized);
+    if (!basename2) {
+      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(basename);
+    const node = parent.children.get(basename2);
     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(basename);
+    parent.children.delete(basename2);
   }
   /**
    * Rename/move file or directory
@@ -37333,11 +37393,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);
       }
@@ -37350,9 +37410,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 (err) {
       setTimeout(() => callback(err), 0);
@@ -37361,16 +37421,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);
       }
@@ -37383,9 +37443,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 (err) {
       setTimeout(() => callback(err), 0);
@@ -37394,10 +37454,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;
   }
@@ -37445,15 +37505,15 @@ var VirtualFS = class _VirtualFS {
   /**
    * Notify watchers of file changes
    */
-  notifyWatchers(path4, eventType) {
-    const normalized = this.normalizePath(path4);
-    const basename = this.getBasename(normalized);
+  notifyWatchers(path2, eventType) {
+    const normalized = this.normalizePath(path2);
+    const basename2 = this.getBasename(normalized);
     const directWatchers = this.watchers.get(normalized);
     if (directWatchers) {
       for (const entry of directWatchers) {
         if (!entry.closed) {
           try {
-            entry.listener(eventType, basename);
+            entry.listener(eventType, basename2);
           } catch (err) {
             console.error("Error in file watcher:", err);
           }
@@ -37461,7 +37521,7 @@ var VirtualFS = class _VirtualFS {
       }
     }
     let currentPath = this.getParentPath(normalized);
-    let relativePath = basename;
+    let relativePath = basename2;
     while (currentPath) {
       const parentWatchers = this.watchers.get(currentPath);
       if (parentWatchers) {
@@ -37486,18 +37546,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 (err) {
       if (actualCallback) setTimeout(() => actualCallback(err), 0);
@@ -37513,7 +37573,7 @@ var VirtualFS = class _VirtualFS {
   /**
    * Create read stream - simplified implementation
    */
-  createReadStream(path4) {
+  createReadStream(path2) {
     const self = this;
     const listeners = {};
     const stream = {
@@ -37528,7 +37588,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 (err) {
@@ -37540,7 +37600,7 @@ var VirtualFS = class _VirtualFS {
   /**
    * Create write stream - simplified implementation
    */
-  createWriteStream(path4) {
+  createWriteStream(path2) {
     const self = this;
     const chunks = [];
     const listeners = {};
@@ -37563,7 +37623,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());
       },
@@ -37631,27 +37691,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;
@@ -37660,7 +37720,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();
@@ -37668,15 +37728,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 err = new Error();
     console.log(`[fs] Stack at ${count} calls:`, err.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) {
@@ -37691,7 +37751,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;
@@ -37699,9 +37759,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 (err) {
           reject(err);
@@ -37721,8 +37781,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 (err) {
           reject(err);
         }
@@ -37734,12 +37794,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 {
@@ -37780,10 +37840,10 @@ function createFsShim(vfs2, getCwd) {
         }
       });
     },
-    rmdir(path4) {
+    rmdir(path2) {
       return new Promise((resolve5, reject) => {
         try {
-          vfs2.rmdirSync(path4);
+          vfs2.rmdirSync(path2);
           resolve5();
         } catch (err) {
           reject(err);
@@ -37800,20 +37860,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 (err) {
           reject(err);
         }
       });
     },
-    realpath(path4) {
+    realpath(path2) {
       return new Promise((resolve5, reject) => {
         try {
-          resolve5(vfs2.realpathSync(path4));
+          resolve5(vfs2.realpathSync(path2));
         } catch (err) {
           reject(err);
         }
@@ -37832,7 +37892,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;
@@ -37840,9 +37900,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) {
@@ -37860,24 +37920,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 {
@@ -37889,24 +37949,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;
     },
@@ -37924,25 +37984,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 err = new Error(`ENOENT: no such file or directory, open '${path4}'`);
+        const err = new Error(`ENOENT: no such file or directory, open '${path2}'`);
         err.code = "ENOENT";
         err.errno = -2;
-        err.path = path4;
+        err.path = path2;
         throw err;
       }
       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 });
           }
@@ -37950,7 +38010,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)
@@ -38049,33 +38109,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));
@@ -38106,8 +38166,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);
@@ -38118,12 +38178,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 {
@@ -40699,8 +40759,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;
@@ -41146,7 +41206,7 @@ __export(url_exports, {
   format: () => format,
   parse: () => parse,
   pathToFileURL: () => pathToFileURL,
-  resolve: () => resolve2
+  resolve: () => resolve3
 });
 function parse(urlString, parseQueryString = false, slashesDenoteHost = false) {
   try {
@@ -41238,7 +41298,7 @@ function format(urlObject) {
   }
   return result;
 }
-function resolve2(from, to2) {
+function resolve3(from, to2) {
   try {
     return new URL2(to2, from).href;
   } catch {
@@ -41254,14 +41314,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,
   format,
-  resolve: resolve2,
+  resolve: resolve3,
   URL: URL2,
   URLSearchParams,
   fileURLToPath,
@@ -42105,8 +42165,8 @@ __export(dns_exports, {
   getServers: () => getServers,
   lookup: () => lookup,
   promises: () => promises2,
-  resolve: () => resolve3,
-  resolve4: () => resolve4,
+  resolve: () => resolve4,
+  resolve4: () => resolve42,
   resolve6: () => resolve6,
   reverse: () => reverse,
   setDefaultResultOrder: () => setDefaultResultOrder,
@@ -42131,13 +42191,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(() => {
@@ -42177,7 +42237,7 @@ var promises2 = {
   },
   resolve: (hostname2) => {
     return new Promise((promiseResolve, promiseReject) => {
-      resolve3(hostname2, (err, addresses) => {
+      resolve4(hostname2, (err, addresses) => {
         if (err) promiseReject(err);
         else promiseResolve(addresses || []);
       });
@@ -42203,8 +42263,8 @@ var V4MAPPED = 0;
 var ALL = 0;
 var dns_default = {
   lookup,
-  resolve: resolve3,
-  resolve4,
+  resolve: resolve4,
+  resolve4: resolve42,
   resolve6,
   reverse,
   setServers,
@@ -42284,63 +42344,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,
@@ -42353,23 +42413,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({
@@ -42386,32 +42446,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);
@@ -42419,7 +42479,7 @@ var VirtualFSAdapter = class {
         this.vfs.unlinkSync(fullPath);
       }
     }
-    this.vfs.rmdirSync(path4);
+    this.vfs.rmdirSync(path2);
   }
   /**
    * Copy a file or directory
@@ -42465,21 +42525,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 === "..") {
@@ -42548,25 +42608,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);
     }
   }
 };
@@ -43335,29 +43395,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;
@@ -43420,15 +43480,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();
@@ -43472,7 +43532,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;
@@ -43516,13 +43576,13 @@ var FSWatcher = class extends EventEmitter {
   }
   getWatched() {
     const result = {};
-    for (const path4 of this.watched.keys()) {
-      const dir = path4.substring(0, path4.lastIndexOf("/")) || "/";
-      const basename = path4.substring(path4.lastIndexOf("/") + 1);
+    for (const path2 of this.watched.keys()) {
+      const dir = path2.substring(0, path2.lastIndexOf("/")) || "/";
+      const basename2 = path2.substring(path2.lastIndexOf("/") + 1);
       if (!result[dir]) {
         result[dir] = [];
       }
-      result[dir].push(basename);
+      result[dir].push(basename2);
     }
     return result;
   }
@@ -43916,13 +43976,13 @@ var constants5 = {
   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
@@ -44589,8 +44649,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) {
@@ -44748,16 +44808,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;
@@ -53659,7 +53719,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;
@@ -53671,7 +53731,7 @@ var ServerBridge = class _ServerBridge extends EventEmitter {
       const response = await this.handleRequest(
         port,
         request3.method,
-        path4 + url2.search,
+        path2 + url2.search,
         headers,
         body
       );
@@ -53797,20 +53857,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",
@@ -53855,16 +53915,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;
@@ -53873,9 +53933,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;
     }
@@ -54199,13 +54259,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);
@@ -54230,8 +54290,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
@@ -54483,7 +54543,7 @@ function wrapCjsAsEsm(code2, virtualPrefix = "", requestPath = "") {
   if (!/\b(require\s*\(|module\.exports|exports\.)/.test(stripped)) {
     return code2;
   }
-  const requestDir = requestPath ? path3.posix.dirname(requestPath) : "";
+  const requestDir = requestPath ? posixPath.dirname(requestPath) : "";
   const commentFree = code2.replace(
     /("(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)*'|`(?:[^`\\]|\\.)*`|\/\*[\s\S]*?\*\/|\/\/[^\n]*)/g,
     (m) => {
@@ -54504,7 +54564,7 @@ function wrapCjsAsEsm(code2, virtualPrefix = "", requestPath = "") {
     const varName = `__cjs_req_${counter++}__`;
     let resolvedSpec;
     if (specifier.startsWith(".")) {
-      resolvedSpec = `${virtualPrefix}${path3.posix.resolve(requestDir, specifier)}`;
+      resolvedSpec = `${virtualPrefix}${posixPath.resolve(requestDir, specifier)}`;
     } else {
       resolvedSpec = `${virtualPrefix}/node_modules/${specifier}`;
     }
@@ -54594,7 +54654,7 @@ async function ensureEsbuildWasm() {
   await window.__esbuildInitPromise;
 }
 function normalizePath(inputPath) {
-  return path3.posix.normalize(inputPath.trim() || "/") || "/";
+  return posixPath.normalize(inputPath.trim() || "/") || "/";
 }
 function isInternalAlmostNodePath(targetPath) {
   const normalizedPath = normalizePath(targetPath);
@@ -54654,7 +54714,7 @@ function removeVirtualPath(vfs2, targetPath) {
     return;
   }
   for (const childName of vfs2.readdirSync(normalizedPath)) {
-    removeVirtualPath(vfs2, path3.posix.join(normalizedPath, childName));
+    removeVirtualPath(vfs2, posixPath.join(normalizedPath, childName));
   }
   vfs2.rmdirSync(normalizedPath);
 }
@@ -54964,8 +55024,8 @@ var AlmostNodeSession = class {
     return result;
   }
   async serveExistingVirtualStaticFile(root2, requestUrl, bufferCtor) {
-    const basePath = normalizePath(path3.posix.join(root2, getRequestPathname(requestUrl)));
-    const hasExtension = /\.[a-zA-Z0-9]+$/.test(path3.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];
@@ -54977,7 +55037,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(path3.posix.join(basePath, entry)));
+          if (entry) candidates.push(normalizePath(posixPath.join(basePath, entry)));
         }
       } catch {
       }
@@ -54986,7 +55046,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(path3.posix.join(basePath, entry)));
+          if (entry) candidates.push(normalizePath(posixPath.join(basePath, entry)));
         }
       } catch {
       }
@@ -55024,7 +55084,7 @@ var AlmostNodeSession = class {
         }
         const content = await this.fs.readFileBuffer(targetPath);
         this._vfs.withoutMirror(() => {
-          this._vfs.mkdirSync(path3.posix.dirname(targetPath), { recursive: true });
+          this._vfs.mkdirSync(posixPath.dirname(targetPath), { recursive: true });
           this._vfs.writeFileSync(targetPath, content);
         });
         const body = bufferCtor.from(content);
@@ -55070,7 +55130,7 @@ var AlmostNodeSession = class {
       }
     }
     for (const packageName of candidatePackageNames) {
-      const pkgJsonPath = normalizePath(path3.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;
       }
@@ -55080,16 +55140,16 @@ var AlmostNodeSession = class {
         if (!pkgJson) {
           continue;
         }
-        const pkgDir = normalizePath(path3.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(path3.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(path3.posix.join(pkgDir, namedBins[binName]));
+          return normalizePath(posixPath.join(pkgDir, namedBins[binName]));
         }
       } catch {
       }
@@ -55176,7 +55236,7 @@ var AlmostNodeSession = class {
       }
       const content = await this.fs.readFileBuffer(normalizedPath);
       this._vfs.withoutMirror(() => {
-        this._vfs.mkdirSync(path3.posix.dirname(normalizedPath), { recursive: true });
+        this._vfs.mkdirSync(posixPath.dirname(normalizedPath), { recursive: true });
         this._vfs.writeFileSync(normalizedPath, content);
       });
     } catch {
@@ -55239,7 +55299,7 @@ var AlmostNodeSession = class {
       });
       this._vfs.withoutMirror(() => {
         for (const [filePath, content] of contents) {
-          this._vfs.mkdirSync(path3.posix.dirname(filePath), { recursive: true });
+          this._vfs.mkdirSync(posixPath.dirname(filePath), { recursive: true });
           this._vfs.writeFileSync(filePath, content);
         }
       });
@@ -55260,7 +55320,7 @@ var AlmostNodeSession = class {
     }
     const dependencyPaths = [];
     for (const packageName of getPackageJsonDependencyNames(packageJsonResult.pkgJson)) {
-      const packageRoot = normalizePath(path3.posix.join(cwd, "node_modules", packageName));
+      const packageRoot = normalizePath(posixPath.join(cwd, "node_modules", packageName));
       if (!await this.fs.exists(packageRoot)) {
         continue;
       }
@@ -55294,7 +55354,7 @@ var AlmostNodeSession = class {
         return;
       }
       await this.withSuppressedObservableMirroring(async () => {
-        await ensureObservableDirectory(this.fs, path3.posix.dirname(normalizedPath));
+        await ensureObservableDirectory(this.fs, posixPath.dirname(normalizedPath));
         await this.fs.writeFile(normalizedPath, data2);
       });
     })());
@@ -55329,7 +55389,7 @@ var AlmostNodeSession = class {
         return;
       }
       await this.withSuppressedObservableMirroring(async () => {
-        await ensureObservableDirectory(this.fs, path3.posix.dirname(normalizedNextPath));
+        await ensureObservableDirectory(this.fs, posixPath.dirname(normalizedNextPath));
         await this.fs.mv(normalizedPreviousPath, normalizedNextPath);
       });
     })());
@@ -55350,7 +55410,7 @@ var AlmostNodeSession = class {
     await this.initializePromise;
   }
   async readPackageJson(cwd) {
-    const packageJsonPath = normalizePath(path3.posix.join(cwd, "package.json"));
+    const packageJsonPath = normalizePath(posixPath.join(cwd, "package.json"));
     if (!this.vfs.existsSync(packageJsonPath)) {
       await this.copyObservablePathIntoVirtualFs(packageJsonPath, { force: true });
     }
@@ -55462,7 +55522,7 @@ var AlmostNodeSession = class {
       ...baseEnv,
       npm_lifecycle_event: scriptName,
       PATH: Array.from(/* @__PURE__ */ new Set([
-        normalizePath(path3.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(":")
@@ -55664,7 +55724,7 @@ ${packages.map(([name, version4]) => `+-- ${name}@${version4}`).join("\n")}
           message: `Unsupported node flag in just-bash: ${firstArg}`
         };
       }
-      const scriptPath = path3.posix.isAbsolute(firstArg) ? normalizePath(firstArg) : normalizePath(path3.posix.resolve(cwd, firstArg));
+      const scriptPath = posixPath.isAbsolute(firstArg) ? normalizePath(firstArg) : normalizePath(posixPath.resolve(cwd, firstArg));
       return {
         kind: "run-file",
         scriptPath,
@@ -55863,7 +55923,7 @@ ${packages.map(([name, version4]) => `+-- ${name}@${version4}`).join("\n")}
       if (!targetPath.startsWith(`${cwdPrefix}node_modules/`)) {
         return true;
       }
-      const baseName = path3.posix.basename(targetPath).toLowerCase();
+      const baseName = posixPath.basename(targetPath).toLowerCase();
       if (baseName === "package.json") {
         return true;
       }
@@ -55881,7 +55941,7 @@ ${packages.map(([name, version4]) => `+-- ${name}@${version4}`).join("\n")}
       });
       this._vfs.withoutMirror(() => {
         for (const [filePath, content] of contents) {
-          this._vfs.mkdirSync(path3.posix.dirname(filePath), { recursive: true });
+          this._vfs.mkdirSync(posixPath.dirname(filePath), { recursive: true });
           this._vfs.writeFileSync(filePath, content);
         }
       });
@@ -56002,17 +56062,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 isAbsolute = posixPath.startsWith("/");
-  for (const segment of posixPath.split("/")) {
+  const isAbsolute2 = posixPath2.startsWith("/");
+  for (const segment of posixPath2.split("/")) {
     if (segment === "..") {
       segments.pop();
     } else if (segment !== "." && segment !== "") {
       segments.push(segment);
     }
   }
-  return (isAbsolute ? "/" : "") + segments.join("/") || "/";
+  return (isAbsolute2 ? "/" : "") + segments.join("/") || "/";
 }
 function truncateBashOutput(output, limitBytes = DEFAULT_BASH_OUTPUT_LIMIT) {
   if (!output || output.length <= limitBytes) {
@@ -56039,7 +56099,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) => {