browsermation 0.0.98-beta.1 → 0.0.98-beta.3

package/dist/bin/cli.js

@@ -3638,7 +3638,7 @@ var require_util = __commonJS({
       return path7;
     }
     exports2.normalize = normalize;
-    function join9(aRoot, aPath) {
+    function join8(aRoot, aPath) {
       if (aRoot === "") {
         aRoot = ".";
       }
@@ -3670,11 +3670,11 @@ var require_util = __commonJS({
       }
       return joined;
     }
-    exports2.join = join9;
+    exports2.join = join8;
     exports2.isAbsolute = function(aPath) {
       return aPath.charAt(0) === "/" || urlRegexp.test(aPath);
     };
-    function relative4(aRoot, aPath) {
+    function relative5(aRoot, aPath) {
       if (aRoot === "") {
         aRoot = ".";
       }
@@ -3693,7 +3693,7 @@ var require_util = __commonJS({
       }
       return Array(level + 1).join("../") + aPath.substr(aRoot.length + 1);
     }
-    exports2.relative = relative4;
+    exports2.relative = relative5;
     var supportsNullProto = (function() {
       var obj = /* @__PURE__ */ Object.create(null);
       return !("__proto__" in obj);
@@ -3843,7 +3843,7 @@ var require_util = __commonJS({
             parsed.path = parsed.path.substring(0, index + 1);
           }
         }
-        sourceURL = join9(urlGenerate(parsed), sourceURL);
+        sourceURL = join8(urlGenerate(parsed), sourceURL);
       }
       return normalize(sourceURL);
     }
@@ -15075,11 +15075,11 @@ ${lanes.join("\n")}
           return toComponents;
         }
         const components = toComponents.slice(start);
-        const relative4 = [];
+        const relative5 = [];
         for (; start < fromComponents.length; start++) {
-          relative4.push("..");
+          relative5.push("..");
         }
-        return ["", ...relative4, ...components];
+        return ["", ...relative5, ...components];
       }
       function getRelativePathFromDirectory(fromDirectory, to, getCanonicalFileNameOrIgnoreCase) {
         Debug.assert(getRootLength(fromDirectory) > 0 === getRootLength(to) > 0, "Paths must either both be absolute or both be relative");
@@ -53636,11 +53636,11 @@ ${lanes.join("\n")}
             if (i < rootLength) {
               return void 0;
             }
-            const sep = directory.lastIndexOf(directorySeparator, i - 1);
-            if (sep === -1) {
+            const sep3 = directory.lastIndexOf(directorySeparator, i - 1);
+            if (sep3 === -1) {
               return void 0;
             }
-            return directory.substr(0, Math.max(sep, rootLength));
+            return directory.substr(0, Math.max(sep3, rootLength));
           }
         }
       }
@@ -59546,9 +59546,9 @@ ${lanes.join("\n")}
               if (!startsWithDirectory(target, realPathDirectory, getCanonicalFileName)) {
                 return;
               }
-              const relative4 = getRelativePathFromDirectory(realPathDirectory, target, getCanonicalFileName);
+              const relative5 = getRelativePathFromDirectory(realPathDirectory, target, getCanonicalFileName);
               for (const symlinkDirectory of symlinkDirectories) {
-                const option = resolvePath(symlinkDirectory, relative4);
+                const option = resolvePath(symlinkDirectory, relative5);
                 const result2 = cb(option, target === referenceRedirect);
                 shouldFilterIgnoredPaths = true;
                 if (result2) return result2;
@@ -218118,7 +218118,7 @@ var require_path_browserify = __commonJS({
       }
       return res;
     }
-    function _format(sep, pathObject) {
+    function _format(sep3, pathObject) {
       var dir = pathObject.dir || pathObject.root;
       var base = pathObject.base || (pathObject.name || "") + (pathObject.ext || "");
       if (!dir) {
@@ -218127,7 +218127,7 @@ var require_path_browserify = __commonJS({
       if (dir === pathObject.root) {
         return dir + base;
       }
-      return dir + sep + base;
+      return dir + sep3 + base;
     }
     var posix = {
       // path.resolve([from ...], to)
@@ -218178,7 +218178,7 @@ var require_path_browserify = __commonJS({
         assertPath(path7);
         return path7.length > 0 && path7.charCodeAt(0) === 47;
       },
-      join: function join9() {
+      join: function join8() {
         if (arguments.length === 0)
           return ".";
         var joined;
@@ -218196,7 +218196,7 @@ var require_path_browserify = __commonJS({
           return ".";
         return posix.normalize(joined);
       },
-      relative: function relative4(from, to) {
+      relative: function relative5(from, to) {
         assertPath(from);
         assertPath(to);
         if (from === to) return "";
@@ -218265,7 +218265,7 @@ var require_path_browserify = __commonJS({
       _makeLong: function _makeLong(path7) {
         return path7;
       },
-      dirname: function dirname2(path7) {
+      dirname: function dirname3(path7) {
         assertPath(path7);
         if (path7.length === 0) return ".";
         var code = path7.charCodeAt(0);
@@ -220696,10 +220696,10 @@ var require_dist2 = __commonJS({
         ignore: ignorePatterns
       };
     }
-    function formatPaths(paths, relative4) {
+    function formatPaths(paths, relative5) {
       for (let i = paths.length - 1; i >= 0; i--) {
         const path$2 = paths[i];
-        paths[i] = relative4(path$2);
+        paths[i] = relative5(path$2);
       }
       return paths;
     }
@@ -220796,26 +220796,26 @@ var require_dist2 = __commonJS({
       props.root = props.root.replace(BACKSLASHES, "");
       const root = props.root;
       if (options.debug) log("internal properties:", props);
-      const relative4 = cwd !== root && !options.absolute && buildRelative(cwd, props.root);
-      return [new fdir.fdir(fdirOptions).crawl(root), relative4];
+      const relative5 = cwd !== root && !options.absolute && buildRelative(cwd, props.root);
+      return [new fdir.fdir(fdirOptions).crawl(root), relative5];
     }
     async function glob(patternsOrOptions, options) {
       if (patternsOrOptions && (options === null || options === void 0 ? void 0 : options.patterns)) throw new Error("Cannot pass patterns as both an argument and an option");
       const isModern = isReadonlyArray(patternsOrOptions) || typeof patternsOrOptions === "string";
       const opts = isModern ? options : patternsOrOptions;
       const patterns = isModern ? patternsOrOptions : patternsOrOptions.patterns;
-      const [crawler, relative4] = getCrawler(patterns, opts);
-      if (!relative4) return crawler.withPromise();
-      return formatPaths(await crawler.withPromise(), relative4);
+      const [crawler, relative5] = getCrawler(patterns, opts);
+      if (!relative5) return crawler.withPromise();
+      return formatPaths(await crawler.withPromise(), relative5);
     }
     function globSync(patternsOrOptions, options) {
       if (patternsOrOptions && (options === null || options === void 0 ? void 0 : options.patterns)) throw new Error("Cannot pass patterns as both an argument and an option");
       const isModern = isReadonlyArray(patternsOrOptions) || typeof patternsOrOptions === "string";
       const opts = isModern ? options : patternsOrOptions;
       const patterns = isModern ? patternsOrOptions : patternsOrOptions.patterns;
-      const [crawler, relative4] = getCrawler(patterns, opts);
-      if (!relative4) return crawler.sync();
-      return formatPaths(crawler.sync(), relative4);
+      const [crawler, relative5] = getCrawler(patterns, opts);
+      if (!relative5) return crawler.sync();
+      return formatPaths(crawler.sync(), relative5);
     }
     exports2.convertPathToPattern = convertPathToPattern;
     exports2.escapePath = escapePath;
@@ -246761,8 +246761,8 @@ var require_readdir_glob = __commonJS({
           useStat = true;
         }
         const filename = dir + "/" + name;
-        const relative4 = filename.slice(1);
-        const absolute = path7 + "/" + relative4;
+        const relative5 = filename.slice(1);
+        const absolute = path7 + "/" + relative5;
         let stats = null;
         if (useStat || followSymlinks) {
           stats = await stat(absolute, followSymlinks);
@@ -246774,12 +246774,12 @@ var require_readdir_glob = __commonJS({
           stats = { isDirectory: () => false };
         }
         if (stats.isDirectory()) {
-          if (!shouldSkip(relative4)) {
-            yield { relative: relative4, absolute, stats };
+          if (!shouldSkip(relative5)) {
+            yield { relative: relative5, absolute, stats };
             yield* exploreWalkAsync(filename, path7, followSymlinks, useStat, shouldSkip, false);
           }
         } else {
-          yield { relative: relative4, absolute, stats };
+          yield { relative: relative5, absolute, stats };
         }
       }
     }
@@ -246849,11 +246849,11 @@ var require_readdir_glob = __commonJS({
         }
         setTimeout(() => this._next(), 0);
       }
-      _shouldSkipDirectory(relative4) {
-        return this.skipMatchers.some((m) => m.match(relative4));
+      _shouldSkipDirectory(relative5) {
+        return this.skipMatchers.some((m) => m.match(relative5));
       }
-      _fileMatches(relative4, isDirectory) {
-        const file = relative4 + (isDirectory ? "/" : "");
+      _fileMatches(relative5, isDirectory) {
+        const file = relative5 + (isDirectory ? "/" : "");
         return (this.matchers.length === 0 || this.matchers.some((m) => m.match(file))) && !this.ignoreMatchers.some((m) => m.match(file)) && (!this.options.nodir || !isDirectory);
       }
       _next() {
@@ -246862,16 +246862,16 @@ var require_readdir_glob = __commonJS({
             if (!obj.done) {
               const isDirectory = obj.value.stats.isDirectory();
               if (this._fileMatches(obj.value.relative, isDirectory)) {
-                let relative4 = obj.value.relative;
+                let relative5 = obj.value.relative;
                 let absolute = obj.value.absolute;
                 if (this.options.mark && isDirectory) {
-                  relative4 += "/";
+                  relative5 += "/";
                   absolute += "/";
                 }
                 if (this.options.stat) {
-                  this.emit("match", { relative: relative4, absolute, stat: obj.value.stats });
+                  this.emit("match", { relative: relative5, absolute, stat: obj.value.stats });
                 } else {
-                  this.emit("match", { relative: relative4, absolute });
+                  this.emit("match", { relative: relative5, absolute });
                 }
               }
               this._next(this.iterator);
@@ -249841,7 +249841,7 @@ var require_BufferList = __commonJS({
         this.head = this.tail = null;
         this.length = 0;
       };
-      BufferList.prototype.join = function join9(s) {
+      BufferList.prototype.join = function join8(s) {
         if (this.length === 0) return "";
         var p = this.head;
         var ret = "" + p.data;
@@ -252376,8 +252376,8 @@ var require_primordials = __commonJS({
       ArrayPrototypeIndexOf(self2, el) {
         return self2.indexOf(el);
       },
-      ArrayPrototypeJoin(self2, sep) {
-        return self2.join(sep);
+      ArrayPrototypeJoin(self2, sep3) {
+        return self2.join(sep3);
       },
       ArrayPrototypeMap(self2, fn) {
         return self2.map(fn);
@@ -264413,7 +264413,7 @@ var require_commonjs7 = __commonJS({
        *
        * @internal
        */
-      constructor(cwd = process.cwd(), pathImpl, sep, { nocase, childrenCacheSize = 16 * 1024, fs = defaultFS } = {}) {
+      constructor(cwd = process.cwd(), pathImpl, sep3, { nocase, childrenCacheSize = 16 * 1024, fs = defaultFS } = {}) {
         this.#fs = fsFromOption(fs);
         if (cwd instanceof URL || cwd.startsWith("file://")) {
           cwd = (0, node_url_1.fileURLToPath)(cwd);
@@ -264424,7 +264424,7 @@ var require_commonjs7 = __commonJS({
         this.#resolveCache = new ResolveCache();
         this.#resolvePosixCache = new ResolveCache();
         this.#children = new ChildrenCache(childrenCacheSize);
-        const split = cwdPath.substring(this.rootPath.length).split(sep);
+        const split = cwdPath.substring(this.rootPath.length).split(sep3);
         if (split.length === 1 && !split[0]) {
           split.pop();
         }
@@ -265267,10 +265267,10 @@ var require_ignore = __commonJS({
       ignored(p) {
         const fullpath = p.fullpath();
         const fullpaths = `${fullpath}/`;
-        const relative4 = p.relative() || ".";
-        const relatives = `${relative4}/`;
+        const relative5 = p.relative() || ".";
+        const relatives = `${relative5}/`;
         for (const m of this.relative) {
-          if (m.match(relative4) || m.match(relatives))
+          if (m.match(relative5) || m.match(relatives))
             return true;
         }
         for (const m of this.absolute) {
@@ -265281,9 +265281,9 @@ var require_ignore = __commonJS({
       }
       childrenIgnored(p) {
         const fullpath = p.fullpath() + "/";
-        const relative4 = (p.relative() || ".") + "/";
+        const relative5 = (p.relative() || ".") + "/";
         for (const m of this.relativeChildren) {
-          if (m.match(relative4))
+          if (m.match(relative5))
             return true;
         }
         for (const m of this.absoluteChildren) {
@@ -282462,8 +282462,8 @@ var require_follow_redirects = __commonJS({
       }
       return parsed;
     }
-    function resolveUrl(relative4, base) {
-      return useNativeURL ? new URL2(relative4, base) : parseUrl(url2.resolve(base, relative4));
+    function resolveUrl(relative5, base) {
+      return useNativeURL ? new URL2(relative5, base) : parseUrl(url2.resolve(base, relative5));
     }
     function validateUrl(input) {
       if (/^\[/.test(input.hostname) && !/^\[[:0-9a-f]+\]$/i.test(input.hostname)) {
@@ -283064,7 +283064,7 @@ var {
 // package.json
 var package_default = {
   name: "browsermation",
-  version: "0.0.98-beta.1",
+  version: "0.0.98-beta.3",
   description: "The testing platform for Playwright by Browsermation.",
   main: "./dist/index.js",
   types: "./dist/index.d.ts",
@@ -283075,7 +283075,7 @@ var package_default = {
     "dist"
   ],
   scripts: {
-    "build:cli": "esbuild src/bin/cli.ts --bundle --platform=node --external:@browsermation/browser-engine --external:playwright --target=node22 --outfile=dist/bin/cli.js",
+    "build:cli": "esbuild src/bin/cli.ts --bundle --platform=node --external:@browsermation/browser-engine --external:playwright --external:esbuild --target=node22 --outfile=dist/bin/cli.js",
     build: "rm -rf dist && npm run build:cli",
     start: "node dist/bin/cli.js",
     "build:start": "npm run build && npm start",
@@ -283096,11 +283096,11 @@ var package_default = {
   devDependencies: {
     "@types/archiver": "^7.0.0",
     "@types/node": "^25.0.3",
-    esbuild: "^0.27.2",
     typescript: "^5.9.3",
     vitest: "^4.0.16"
   },
   dependencies: {
+    esbuild: "^0.27.2",
     "@browsermation/browser-engine": "^0.0.44",
     archiver: "^7.0.1",
     axios: "^1.13.2",
@@ -285760,100 +285760,55 @@ var ASSET_EXTENSIONS = [
   ".mp3",
   ".wav"
 ];
-var ImportExtractor = class {
-  project;
-  constructor(tsconfigPath) {
-    this.project = new import_ts_morph.Project({
-      tsConfigFilePath: tsconfigPath,
-      skipAddingFilesFromTsConfig: true,
-      compilerOptions: {
-        allowJs: true,
-        checkJs: false
-      }
-    });
-  }
+var FastImportExtractor = class _FastImportExtractor {
+  static IMPORT_PATTERNS = [
+    // ESM imports: import ... from 'module'
+    /import\s+(?:(?:[\w*{}\s,]+)\s+from\s+)?['"]([^'"]+)['"]/g,
+    // ESM exports: export ... from 'module'
+    /export\s+(?:(?:[\w*{}\s,]+)\s+from\s+)?['"]([^'"]+)['"]/g,
+    // Dynamic imports: import('module')
+    /import\s*\(\s*['"]([^'"]+)['"]\s*\)/g,
+    // Require: require('module')
+    /require\s*\(\s*['"]([^'"]+)['"]\s*\)/g
+  ];
   extractImports(filePath) {
-    let sourceFile;
+    const { readFileSync: readFileSync3 } = require("fs");
+    let content;
     try {
-      sourceFile = this.project.addSourceFileAtPath(filePath);
+      content = readFileSync3(filePath, "utf-8");
     } catch {
-      sourceFile = this.project.getSourceFile(filePath) || this.project.addSourceFileAtPath(filePath);
+      return { staticImports: [], dynamicImports: [], requireCalls: [], assetImports: [] };
+    }
+    content = this.removeComments(content);
+    const staticImports = [];
+    const dynamicImports = [];
+    const requireCalls = [];
+    for (const match of content.matchAll(_FastImportExtractor.IMPORT_PATTERNS[0])) {
+      if (match[1]) staticImports.push(match[1]);
+    }
+    for (const match of content.matchAll(_FastImportExtractor.IMPORT_PATTERNS[1])) {
+      if (match[1]) staticImports.push(match[1]);
+    }
+    for (const match of content.matchAll(_FastImportExtractor.IMPORT_PATTERNS[2])) {
+      if (match[1]) dynamicImports.push(match[1]);
+    }
+    for (const match of content.matchAll(_FastImportExtractor.IMPORT_PATTERNS[3])) {
+      if (match[1]) requireCalls.push(match[1]);
     }
-    const staticImports = this.getStaticImports(sourceFile);
-    const dynamicImports = this.getDynamicImports(sourceFile);
-    const requireCalls = this.getRequireCalls(sourceFile);
     const allImports = [...staticImports, ...dynamicImports, ...requireCalls];
     return {
       staticImports,
       dynamicImports,
       requireCalls,
-      assetImports: this.filterAssetImports(allImports)
+      assetImports: allImports.filter(
+        (imp) => ASSET_EXTENSIONS.some((ext) => imp.toLowerCase().endsWith(ext))
+      )
     };
   }
-  getStaticImports(sourceFile) {
-    const imports = [];
-    for (const imp of sourceFile.getImportDeclarations()) {
-      imports.push(imp.getModuleSpecifierValue());
-    }
-    for (const exp of sourceFile.getExportDeclarations()) {
-      const moduleSpecifier = exp.getModuleSpecifierValue();
-      if (moduleSpecifier) {
-        imports.push(moduleSpecifier);
-      }
-    }
-    return imports;
-  }
-  getDynamicImports(sourceFile) {
-    const imports = [];
-    const callExpressions = sourceFile.getDescendantsOfKind(
-      import_ts_morph.SyntaxKind.CallExpression
-    );
-    for (const call of callExpressions) {
-      const expression = call.getExpression();
-      if (expression.getKind() === import_ts_morph.SyntaxKind.ImportKeyword) {
-        const args = call.getArguments();
-        if (args.length > 0) {
-          const firstArg = args[0];
-          if (firstArg.isKind(import_ts_morph.SyntaxKind.StringLiteral)) {
-            imports.push(firstArg.getLiteralValue());
-          } else if (firstArg.isKind(import_ts_morph.SyntaxKind.NoSubstitutionTemplateLiteral)) {
-            imports.push(firstArg.getLiteralValue());
-          } else if (firstArg.isKind(import_ts_morph.SyntaxKind.TemplateExpression)) {
-            const head = firstArg.getHead().getLiteralValue();
-            if (head) {
-              console.warn(
-                `Dynamic import with template expression found: ${head}... - may not be fully resolved`
-              );
-            }
-          }
-        }
-      }
-    }
-    return imports;
-  }
-  getRequireCalls(sourceFile) {
-    const imports = [];
-    const callExpressions = sourceFile.getDescendantsOfKind(
-      import_ts_morph.SyntaxKind.CallExpression
-    );
-    for (const call of callExpressions) {
-      const expression = call.getExpression();
-      if (expression.isKind(import_ts_morph.SyntaxKind.Identifier) && expression.getText() === "require") {
-        const args = call.getArguments();
-        if (args.length > 0) {
-          const firstArg = args[0];
-          if (firstArg.isKind(import_ts_morph.SyntaxKind.StringLiteral)) {
-            imports.push(firstArg.getLiteralValue());
-          }
-        }
-      }
-    }
-    return imports;
-  }
-  filterAssetImports(imports) {
-    return imports.filter(
-      (imp) => ASSET_EXTENSIONS.some((ext) => imp.toLowerCase().endsWith(ext))
-    );
+  removeComments(content) {
+    content = content.replace(/\/\/.*$/gm, "");
+    content = content.replace(/\/\*[\s\S]*?\*\//g, "");
+    return content;
   }
 };
 
@@ -286044,11 +285999,8 @@ var PathResolver = class {
 };
 
 // src/analyzer/dependency-graph.ts
-var EXCLUDED_PACKAGES = [
-  "@playwright/test",
-  "playwright",
-  "playwright-core",
-  // Node.js built-in modules
+var PLAYWRIGHT_PACKAGES = ["@playwright/test", "playwright", "playwright-core"];
+var NODE_BUILTINS = /* @__PURE__ */ new Set([
   "assert",
   "buffer",
   "child_process",
@@ -286085,30 +286037,57 @@ var EXCLUDED_PACKAGES = [
   "vm",
   "worker_threads",
   "zlib"
-];
+]);
 var DependencyGraphBuilder = class {
   graph = /* @__PURE__ */ new Map();
   visited = /* @__PURE__ */ new Set();
+  skipped = /* @__PURE__ */ new Set();
   nodeModuleDeps = /* @__PURE__ */ new Set();
   assets = /* @__PURE__ */ new Set();
   extractor;
   resolver;
   projectRoot;
+  testDir = "";
   constructor(options) {
     this.projectRoot = options.projectRoot;
-    const tsconfigPath = path2.join(options.projectRoot, "tsconfig.json");
-    this.extractor = new ImportExtractor(
-      require("fs").existsSync(tsconfigPath) ? tsconfigPath : void 0
-    );
+    this.extractor = new FastImportExtractor();
     this.resolver = new PathResolver(options.projectRoot);
   }
-  async build(entryPoints) {
+  /**
+   * Check if a file is within the test directory (or is a config file)
+   * Files in node_modules are never test-related (they're npm dependencies)
+   */
+  isTestRelatedFile(filePath) {
+    const relativePath = path2.relative(this.projectRoot, filePath);
+    if (relativePath.startsWith("node_modules")) {
+      return false;
+    }
+    if (relativePath.includes("playwright.config") || relativePath === "tsconfig.json") {
+      return true;
+    }
+    const testDirRelative = path2.relative(this.projectRoot, this.testDir);
+    if (testDirRelative === "") {
+      return true;
+    }
+    if (relativePath.startsWith(testDirRelative + path2.sep) || relativePath === testDirRelative) {
+      return true;
+    }
+    return false;
+  }
+  async build(entryPoints, testDir) {
+    this.testDir = testDir;
+    const testDirRelative = path2.relative(this.projectRoot, testDir);
+    console.log(`Test directory: ${testDirRelative || "(project root)"}`);
     const queue = [...entryPoints];
     while (queue.length > 0) {
       const filePath = queue.shift();
       const normalizedPath = path2.resolve(filePath);
       if (this.visited.has(normalizedPath)) continue;
       this.visited.add(normalizedPath);
+      if (!this.isTestRelatedFile(normalizedPath)) {
+        this.skipped.add(path2.relative(this.projectRoot, normalizedPath));
+        continue;
+      }
       const node = this.processFile(normalizedPath);
       if (!node) continue;
       this.graph.set(normalizedPath, node);
@@ -286118,6 +286097,9 @@ var DependencyGraphBuilder = class {
         }
       }
     }
+    if (this.skipped.size > 0) {
+      console.log(`Skipped ${this.skipped.size} app source files (not needed for tests)`);
+    }
     return {
       nodes: this.graph,
       entryPoints,
@@ -286168,6 +286150,9 @@ var DependencyGraphBuilder = class {
     if (moduleSpecifier.startsWith("node:")) {
       return null;
     }
+    if (moduleSpecifier.startsWith(".") || moduleSpecifier.startsWith("/")) {
+      return null;
+    }
     if (moduleSpecifier.startsWith("@")) {
       const parts2 = moduleSpecifier.split("/");
       if (parts2.length >= 2) {
@@ -286176,10 +286161,36 @@ var DependencyGraphBuilder = class {
       return null;
     }
     const parts = moduleSpecifier.split("/");
-    return parts[0] || null;
+    const packageName = parts[0] || null;
+    const invalidPackageNames = [
+      "src",
+      "lib",
+      "dist",
+      "build",
+      "app",
+      "pages",
+      "components",
+      "utils",
+      "helpers",
+      "services",
+      "types",
+      "models",
+      "config",
+      "public",
+      "assets",
+      "styles",
+      "tests",
+      "test",
+      "spec",
+      "e2e"
+    ];
+    if (packageName && invalidPackageNames.includes(packageName)) {
+      return null;
+    }
+    return packageName;
   }
   isExcludedPackage(packageName) {
-    return EXCLUDED_PACKAGES.includes(packageName);
+    return PLAYWRIGHT_PACKAGES.includes(packageName) || NODE_BUILTINS.has(packageName);
   }
   determineType(filePath) {
     const lowerPath = filePath.toLowerCase();
@@ -286229,8 +286240,19 @@ var PackageGenerator = class {
       if (dep === "@playwright/test" || dep === "playwright" || dep === "playwright-core") {
         continue;
       }
-      if (allDeps[dep]) {
-        dependencies[dep] = allDeps[dep];
+      const declaredVersion = allDeps[dep];
+      if (declaredVersion?.startsWith("workspace:")) {
+        const version = this.getVersionFromNodeModules(dep);
+        if (version) {
+          dependencies[dep] = `^${version}`;
+        } else {
+          console.warn(
+            `Warning: Could not resolve workspace dependency ${dep}, using "latest"`
+          );
+          dependencies[dep] = "latest";
+        }
+      } else if (declaredVersion) {
+        dependencies[dep] = declaredVersion;
       } else {
         const version = this.getVersionFromNodeModules(dep);
         if (version) {
@@ -286277,6 +286299,19 @@ var PlaywrightConfigParser = class {
   constructor(projectRoot) {
     this.projectRoot = projectRoot;
   }
+  /**
+   * Detect package manager based on lock files
+   * Returns the command prefix to run playwright (e.g., 'yarn', 'pnpm', 'npx')
+   */
+  detectPackageManager() {
+    if ((0, import_node_fs3.existsSync)(path4.join(this.projectRoot, "yarn.lock"))) {
+      return "yarn";
+    }
+    if ((0, import_node_fs3.existsSync)(path4.join(this.projectRoot, "pnpm-lock.yaml"))) {
+      return "pnpm";
+    }
+    return "npx";
+  }
   async findConfig() {
     const candidates = [
       "playwright.config.ts",
@@ -286293,12 +286328,15 @@ var PlaywrightConfigParser = class {
     return null;
   }
   /**
-   * Use `npx playwright test --list --reporter=json` to discover test files
+   * Use playwright test --list --reporter=json to discover test files
    * This respects all Playwright config settings (testDir, testMatch, projects, etc.)
+   * Detects package manager (yarn/pnpm/npm) to run the correct command
+   * Returns both test files and the detected testDir from Playwright's config
    */
   async getTestFilesFromPlaywright(project) {
     try {
-      let command = "npx playwright test --list --reporter=json";
+      const pm = this.detectPackageManager();
+      let command = `${pm} playwright test --list --reporter=json`;
       if (project) {
         command += ` --project="${project}"`;
       }
@@ -286311,9 +286349,10 @@ var PlaywrightConfigParser = class {
       const parsed = JSON.parse(output);
       const rootDir = parsed.config?.rootDir || this.projectRoot;
       const files = this.extractFilesFromSuites(parsed.suites);
-      return [...new Set(files)].map(
+      const absoluteFiles = [...new Set(files)].map(
         (file) => path4.isAbsolute(file) ? file : path4.join(rootDir, file)
       );
+      return { files: absoluteFiles, testDir: rootDir };
     } catch (error2) {
       console.warn(
         "Warning: Could not run playwright test --list, falling back to file scan"
@@ -286321,9 +286360,35 @@ var PlaywrightConfigParser = class {
       if (error2 instanceof Error && error2.message) {
         console.warn(`  ${error2.message.split("\n")[0]}`);
       }
-      return this.fallbackGetTestFiles();
+      const files = await this.fallbackGetTestFiles();
+      const testDir = this.findCommonParentDir(files);
+      return { files, testDir };
     }
   }
+  /**
+   * Find the common parent directory of all given file paths
+   * Excludes node_modules paths since those are npm dependencies
+   */
+  findCommonParentDir(files) {
+    const projectFiles = files.filter((f) => {
+      const rel = path4.relative(this.projectRoot, f);
+      return !rel.startsWith("node_modules");
+    });
+    if (projectFiles.length === 0) return this.projectRoot;
+    if (projectFiles.length === 1) return path4.dirname(projectFiles[0]);
+    const dirs = projectFiles.map((f) => path4.dirname(f));
+    const parts = dirs.map((d) => d.split(path4.sep));
+    const commonParts = [];
+    for (let i = 0; i < parts[0].length; i++) {
+      const part = parts[0][i];
+      if (parts.every((p) => p[i] === part)) {
+        commonParts.push(part);
+      } else {
+        break;
+      }
+    }
+    return commonParts.join(path4.sep) || this.projectRoot;
+  }
   /**
    * Recursively extract file paths from Playwright's suite structure
    */
@@ -286348,10 +286413,19 @@ var PlaywrightConfigParser = class {
   }
   /**
    * Fallback: scan for test files if playwright --list fails
+   * Only scans e2e-specific directories to avoid picking up unit tests
    */
   async fallbackGetTestFiles() {
-    const { readdirSync, statSync } = await import("node:fs");
-    const testDirs = ["tests", "test", "e2e", "specs", "__tests__", "."];
+    const { readdirSync, statSync, readFileSync: readFileSync3 } = await import("node:fs");
+    const testDirs = [
+      "e2e",
+      "e2e-playwright",
+      "playwright",
+      "tests/e2e",
+      "test/e2e",
+      "tests",
+      "test"
+    ];
     const files = [];
     const testPatterns = [
       /\.spec\.(ts|js|tsx|jsx)$/,
@@ -286369,7 +286443,9 @@ var PlaywrightConfigParser = class {
             if (stat.isDirectory()) {
               scanDir(fullPath);
             } else if (testPatterns.some((p) => p.test(entry))) {
-              files.push(fullPath);
+              if (this.isPlaywrightTest(fullPath, readFileSync3)) {
+                files.push(fullPath);
+              }
             }
           } catch {
           }
@@ -286385,6 +286461,22 @@ var PlaywrightConfigParser = class {
     }
     return [...new Set(files)];
   }
+  /**
+   * Check if a file is likely a Playwright test
+   * Either imports from @playwright/test or is in an e2e-specific directory
+   */
+  isPlaywrightTest(filePath, readFileSync3) {
+    const lowerPath = filePath.toLowerCase();
+    if (lowerPath.includes("/e2e-playwright/") || lowerPath.includes("/e2e/") || lowerPath.includes("/playwright/")) {
+      return true;
+    }
+    try {
+      const content = readFileSync3(filePath, "utf-8");
+      return content.includes("@playwright/test") || content.includes('from "playwright"') || content.includes("from 'playwright'");
+    } catch {
+      return false;
+    }
+  }
 };
 
 // src/analyzer/index.ts
@@ -286398,7 +286490,7 @@ async function analyze(options) {
     );
   }
   console.log(`Found config: ${path5.relative(projectRoot, configPath)}`);
-  const testFiles = await configParser.getTestFilesFromPlaywright(options.project);
+  const { files: testFiles, testDir } = await configParser.getTestFilesFromPlaywright(options.project);
   console.log(`Found ${testFiles.length} test files via Playwright`);
   const entryPoints = [configPath, ...testFiles].filter(
     (file, index, self2) => self2.indexOf(file) === index
@@ -286408,7 +286500,7 @@ async function analyze(options) {
     console.warn("Warning: No test files found. Check your Playwright config.");
   }
   const graphBuilder = new DependencyGraphBuilder(options);
-  const graph = await graphBuilder.build(entryPoints);
+  const graph = await graphBuilder.build(entryPoints, testDir);
   console.log(`Analyzed ${graph.nodes.size} source files`);
   console.log(`Found ${graph.nodeModuleDeps.size} npm dependencies`);
   console.log(`Found ${graph.assets.size} assets`);
@@ -286443,16 +286535,70 @@ var import_archiver = __toESM(require_archiver());
 var import_fs = require("fs");
 var import_path = require("path");
 var import_stream = require("stream");
-async function zipFilesToBuffer(projectRoot, files, packageJson) {
+async function zipFilesToBuffer(projectRoot, files, packageJson, npmDeps) {
   const passthrough = new import_stream.PassThrough();
   const archive = (0, import_archiver.default)("zip", { zlib: { level: 9 } });
+  const includedPackages = /* @__PURE__ */ new Set();
+  const skippedPackages = /* @__PURE__ */ new Set();
+  const workspacePackages = /* @__PURE__ */ new Set();
+  const warnings = [];
   for (const file of files) {
     const filePath = (0, import_path.join)(projectRoot, file);
     if ((0, import_fs.existsSync)(filePath)) {
       archive.file(filePath, { name: file });
     }
   }
-  archive.append(JSON.stringify(packageJson, null, 2), { name: "package.json" });
+  archive.append(JSON.stringify(packageJson, null, 2), {
+    name: "package.json"
+  });
+  const skipPackages = /* @__PURE__ */ new Set([
+    // Playwright - pre-installed on runner
+    "@playwright/test",
+    "playwright",
+    "playwright-core",
+    // Frameworks - not needed for remote test execution (app already running)
+    "next",
+    "nuxt",
+    "gatsby",
+    "vite",
+    "webpack",
+    "turbopack",
+    // Dev tools - not needed at runtime
+    "eslint",
+    "prettier",
+    "typescript",
+    "ts-node",
+    "tsx",
+    "esbuild",
+    "rollup",
+    "parcel",
+    // Test runners (we use Playwright)
+    "jest",
+    "vitest",
+    "mocha",
+    "jasmine"
+  ]);
+  if (npmDeps && npmDeps.size > 0) {
+    const nodeModulesPath = (0, import_path.join)(projectRoot, "node_modules");
+    if ((0, import_fs.existsSync)(nodeModulesPath)) {
+      for (const dep of npmDeps) {
+        if (skipPackages.has(dep)) {
+          skippedPackages.add(dep);
+          continue;
+        }
+        await addPackageWithDeps(
+          archive,
+          nodeModulesPath,
+          dep,
+          includedPackages,
+          skipPackages,
+          skippedPackages,
+          warnings,
+          workspacePackages
+        );
+      }
+    }
+  }
   archive.finalize();
   archive.pipe(passthrough);
   const chunks = [];
@@ -286466,7 +286612,451 @@ async function zipFilesToBuffer(projectRoot, files, packageJson) {
   }
   writeStream.end();
   console.log(`Created test bundle at ${tmpZipPath}`);
-  return Buffer.concat(chunks);
+  return {
+    buffer: Buffer.concat(chunks),
+    includedPackages,
+    skippedPackages,
+    workspacePackages,
+    warnings
+  };
+}
+function isWorkspacePackage(packagePath, packageName) {
+  try {
+    const { lstatSync, readFileSync: readFileSync3 } = require("fs");
+    const stats = lstatSync(packagePath);
+    if (stats.isSymbolicLink()) {
+      return true;
+    }
+    const pkgJsonPath = (0, import_path.join)(packagePath, "package.json");
+    if ((0, import_fs.existsSync)(pkgJsonPath)) {
+      const pkgJson = JSON.parse(readFileSync3(pkgJsonPath, "utf-8"));
+      const version = pkgJson.version || "";
+      if (version === "0.0.0" || version === "^0.0.0" || version.startsWith("0.0.")) {
+        return true;
+      }
+      const main = pkgJson.main || "";
+      if (main.startsWith("src/") && main.endsWith(".ts")) {
+        return true;
+      }
+      if (pkgJson.private === true && !pkgJson.publishConfig) {
+        return true;
+      }
+    }
+    if (packageName.startsWith("@") && packageName.includes("/")) {
+      const scope = packageName.split("/")[0];
+      const nodeModulesPath = (0, import_path.join)(packagePath, "..");
+      const scopePath = (0, import_path.join)(nodeModulesPath, scope);
+      if ((0, import_fs.existsSync)(scopePath)) {
+        try {
+          const { readdirSync } = require("fs");
+          const scopePackages = readdirSync(scopePath);
+          if (scopePackages.length > 5) {
+            const symlinkCount = scopePackages.filter((pkg) => {
+              try {
+                return lstatSync((0, import_path.join)(scopePath, pkg)).isSymbolicLink();
+              } catch {
+                return false;
+              }
+            }).length;
+            if (symlinkCount > 3) {
+              return true;
+            }
+          }
+        } catch {
+        }
+      }
+    }
+    return false;
+  } catch {
+    return false;
+  }
+}
+function checkUnbuiltPackage(packagePath, packageName) {
+  const pkgJsonPath = (0, import_path.join)(packagePath, "package.json");
+  if (!(0, import_fs.existsSync)(pkgJsonPath)) {
+    return null;
+  }
+  try {
+    const { readFileSync: readFileSync3, lstatSync } = require("fs");
+    const pkgJson = JSON.parse(readFileSync3(pkgJsonPath, "utf-8"));
+    const main = pkgJson.main || "";
+    const isSourceMain = main.startsWith("src/") && main.endsWith(".ts");
+    if (!isSourceMain) {
+      return null;
+    }
+    const stats = lstatSync(packagePath);
+    const isSymlink = stats.isSymbolicLink();
+    const distPath = (0, import_path.join)(packagePath, "dist");
+    const hasDistFolder = (0, import_fs.existsSync)(distPath);
+    if (isSourceMain && !hasDistFolder) {
+      const symlinkNote = isSymlink ? " (symlinked monorepo package)" : "";
+      return `Package "${packageName}" has main="${main}" but no dist/ folder${symlinkNote}. This package needs to be built before bundling, or install the published version from npm.`;
+    }
+  } catch {
+  }
+  return null;
+}
+async function addWorkspacePackageFiltered(archive, packagePath, packageName) {
+  const { readdirSync, statSync, lstatSync, realpathSync } = require("fs");
+  const excludeDirs = /* @__PURE__ */ new Set([
+    "node_modules",
+    "src",
+    "test",
+    "tests",
+    "__tests__",
+    "__mocks__",
+    "coverage",
+    ".git",
+    ".turbo",
+    ".next",
+    "playwright",
+    "e2e",
+    "cypress"
+  ]);
+  const excludePatterns = [
+    /\.test\.(ts|js|tsx|jsx)$/,
+    /\.spec\.(ts|js|tsx|jsx)$/,
+    /\.stories\.(ts|js|tsx|jsx)$/,
+    /^tsconfig.*\.json$/,
+    /^jest\.config/,
+    /^vitest\.config/,
+    /^\.eslint/,
+    /^\.prettier/
+  ];
+  let realPath = packagePath;
+  try {
+    const stats = lstatSync(packagePath);
+    if (stats.isSymbolicLink()) {
+      realPath = realpathSync(packagePath);
+    }
+  } catch {
+  }
+  const addFilesRecursively = (dir, relativeTo, archivePath) => {
+    try {
+      const entries = readdirSync(dir);
+      for (const entry of entries) {
+        const fullPath = (0, import_path.join)(dir, entry);
+        const relPath = (0, import_path.join)(archivePath, entry);
+        if (excludeDirs.has(entry)) continue;
+        if (excludePatterns.some((p) => p.test(entry))) continue;
+        try {
+          const stat = statSync(fullPath);
+          if (stat.isDirectory()) {
+            addFilesRecursively(fullPath, relativeTo, relPath);
+          } else {
+            archive.file(fullPath, { name: relPath });
+          }
+        } catch {
+        }
+      }
+    } catch {
+    }
+  };
+  addFilesRecursively(realPath, realPath, `node_modules/${packageName}`);
+}
+async function addPackageFiltered(archive, packagePath, packageName) {
+  const { readdirSync, statSync } = require("fs");
+  const includeExtensions = /* @__PURE__ */ new Set([
+    ".js",
+    ".cjs",
+    ".mjs",
+    ".json",
+    ".node",
+    ".wasm"
+  ]);
+  const skipDirs = /* @__PURE__ */ new Set([
+    "node_modules",
+    "test",
+    "tests",
+    "__tests__",
+    "__mocks__",
+    "src",
+    "source",
+    "docs",
+    "doc",
+    "documentation",
+    "example",
+    "examples",
+    "benchmark",
+    "benchmarks",
+    ".git",
+    ".github",
+    ".vscode",
+    "coverage",
+    ".nyc_output",
+    "android",
+    "ios"
+    // Native mobile dirs
+  ]);
+  const skipPatterns = [
+    /\.d\.ts$/,
+    /\.d\.mts$/,
+    /\.d\.cts$/,
+    // Type definitions
+    /\.map$/,
+    /\.min\.js\.map$/,
+    // Source maps
+    /\.ts$/,
+    /\.tsx$/,
+    /\.mts$/,
+    /\.cts$/,
+    // TypeScript source
+    /\.md$/,
+    /\.txt$/,
+    /\.rst$/,
+    // Documentation
+    /^LICENSE/,
+    /^LICENCE/,
+    /^README/,
+    /^CHANGELOG/,
+    /^HISTORY/,
+    /^\.eslint/,
+    /^\.prettier/,
+    /^tsconfig/,
+    /^jest\.config/,
+    /^vitest\.config/,
+    /\.test\.js$/,
+    /\.spec\.js$/,
+    /\.test\.cjs$/,
+    /\.spec\.cjs$/,
+    /^Makefile$/,
+    /^Gruntfile/,
+    /^Gulpfile/
+  ];
+  const addFilesRecursively = (dir, archivePath) => {
+    try {
+      const entries = readdirSync(dir);
+      for (const entry of entries) {
+        if (entry.startsWith(".") && entry !== ".bin") continue;
+        if (skipDirs.has(entry)) continue;
+        if (skipPatterns.some((p) => p.test(entry))) continue;
+        const fullPath = (0, import_path.join)(dir, entry);
+        const relPath = (0, import_path.join)(archivePath, entry);
+        try {
+          const stat = statSync(fullPath);
+          if (stat.isDirectory()) {
+            addFilesRecursively(fullPath, relPath);
+          } else {
+            const ext = entry.substring(entry.lastIndexOf("."));
+            if (includeExtensions.has(ext) || entry === "package.json") {
+              archive.file(fullPath, { name: relPath });
+            }
+          }
+        } catch {
+        }
+      }
+    } catch {
+    }
+  };
+  addFilesRecursively(packagePath, `node_modules/${packageName}`);
+}
+async function addPackageWithDeps(archive, nodeModulesPath, packageName, includedPackages, skipPackages, skippedPackages, warnings, workspacePackages) {
+  if (skipPackages.has(packageName)) {
+    skippedPackages.add(packageName);
+    return;
+  }
+  if (includedPackages.has(packageName)) {
+    return;
+  }
+  const packagePath = (0, import_path.join)(nodeModulesPath, packageName);
+  if (!(0, import_fs.existsSync)(packagePath)) {
+    return;
+  }
+  const isWorkspace = isWorkspacePackage(packagePath, packageName);
+  if (isWorkspace) {
+    workspacePackages.add(packageName);
+  }
+  const unbuiltWarning = checkUnbuiltPackage(packagePath, packageName);
+  if (unbuiltWarning) {
+    warnings.push(unbuiltWarning);
+  }
+  includedPackages.add(packageName);
+  if (isWorkspace) {
+    await addWorkspacePackageFiltered(archive, packagePath, packageName);
+  } else {
+    archive.directory(packagePath, `node_modules/${packageName}`);
+  }
+  if (isWorkspace) {
+    return;
+  }
+  const pkgJsonPath = (0, import_path.join)(packagePath, "package.json");
+  if ((0, import_fs.existsSync)(pkgJsonPath)) {
+    try {
+      const { readFileSync: readFileSync3 } = await import("fs");
+      const pkgJson = JSON.parse(readFileSync3(pkgJsonPath, "utf-8"));
+      const deps = pkgJson.dependencies || {};
+      for (const dep of Object.keys(deps)) {
+        await addPackageWithDeps(archive, nodeModulesPath, dep, includedPackages, skipPackages, skippedPackages, warnings, workspacePackages);
+      }
+    } catch {
+    }
+  }
+}
+async function zipWithEsbuild(projectRoot, files, packageJson, _npmDeps) {
+  const esbuild = await import("esbuild");
+  const os2 = await import("os");
+  const result = {
+    buffer: Buffer.alloc(0),
+    bundledFiles: 0,
+    originalFiles: files.length,
+    errors: [],
+    warnings: []
+  };
+  const tmpDir = (0, import_path.join)(os2.tmpdir(), `browsermation-esbuild-${Date.now()}`);
+  (0, import_fs.mkdirSync)(tmpDir, { recursive: true });
+  try {
+    const tsFiles = files.filter((f) => /\.tsx?$/.test(f) && !/\.d\.ts$/.test(f));
+    const jsFiles = files.filter((f) => /\.(js|jsx|mjs)$/.test(f));
+    const otherFiles = files.filter((f) => !/\.(ts|tsx|js|jsx|mjs)$/.test(f) || /\.d\.ts$/.test(f));
+    const testFiles = tsFiles.filter(
+      (f) => /\.(spec|test|e2e)\.(ts|tsx|js|jsx)$/.test(f)
+    );
+    const testEntryPoints = testFiles.map((f) => (0, import_path.join)(projectRoot, f));
+    const allEntryPoints = tsFiles.map((f) => (0, import_path.join)(projectRoot, f));
+    const preInstalled = ["@playwright/test", "playwright", "playwright-core"];
+    console.log(`Analyzing dependencies from ${testFiles.length} test files...`);
+    const actualDeps = /* @__PURE__ */ new Set();
+    if (testEntryPoints.length > 0) {
+      try {
+        await esbuild.build({
+          entryPoints: testEntryPoints,
+          bundle: true,
+          write: false,
+          outdir: tmpDir,
+          outbase: projectRoot,
+          platform: "node",
+          target: "node18",
+          format: "cjs",
+          metafile: true,
+          logLevel: "silent",
+          external: preInstalled,
+          // Mark all npm packages as external and collect them
+          plugins: [{
+            name: "collect-deps",
+            setup(build) {
+              build.onResolve({ filter: /^[^./]/ }, (args) => {
+                if (args.path.startsWith("node:")) return null;
+                const parts = args.path.split("/");
+                const pkgName = args.path.startsWith("@") ? `${parts[0]}/${parts[1]}` : parts[0];
+                if (!preInstalled.includes(pkgName)) {
+                  actualDeps.add(pkgName);
+                }
+                return { path: args.path, external: true };
+              });
+            }
+          }]
+        });
+      } catch (e) {
+        if (e instanceof Error) {
+          result.warnings.push(`esbuild analysis failed, using fallback: ${e.message.slice(0, 80)}`);
+        }
+        const { readFileSync: readFileSync3 } = require("fs");
+        const importRegex = /(?:import|require)\s*\(?['"]([^'"./][^'"]*)['"]/g;
+        for (const file of testEntryPoints) {
+          try {
+            const content = readFileSync3(file, "utf-8");
+            for (const match of content.matchAll(importRegex)) {
+              const parts = match[1].split("/");
+              const pkgName = match[1].startsWith("@") ? `${parts[0]}/${parts[1]}` : parts[0];
+              if (!preInstalled.includes(pkgName) && !pkgName.startsWith("node:")) {
+                actualDeps.add(pkgName);
+              }
+            }
+          } catch {
+          }
+        }
+      }
+    }
+    console.log(`Found ${actualDeps.size} npm dependencies used by tests`);
+    console.log(`Transpiling ${tsFiles.length} TypeScript files...`);
+    if (allEntryPoints.length > 0) {
+      const buildResult = await esbuild.build({
+        entryPoints: allEntryPoints,
+        bundle: false,
+        // Just transpile
+        platform: "node",
+        target: "node18",
+        format: "cjs",
+        outdir: tmpDir,
+        outbase: projectRoot,
+        sourcemap: false,
+        logLevel: "warning"
+      });
+      for (const warning2 of buildResult.warnings) {
+        result.warnings.push(warning2.text);
+      }
+      for (const error2 of buildResult.errors) {
+        result.errors.push(error2.text);
+      }
+    }
+    result.bundledFiles = tsFiles.length;
+    const passthrough = new import_stream.PassThrough();
+    const archive = (0, import_archiver.default)("zip", { zlib: { level: 9 } });
+    for (const file of tsFiles) {
+      const jsFile = file.replace(/\.tsx?$/, ".js");
+      const transpiledPath = (0, import_path.join)(tmpDir, jsFile);
+      if ((0, import_fs.existsSync)(transpiledPath)) {
+        archive.file(transpiledPath, { name: jsFile });
+      }
+    }
+    for (const file of jsFiles) {
+      const filePath = (0, import_path.join)(projectRoot, file);
+      if ((0, import_fs.existsSync)(filePath)) {
+        archive.file(filePath, { name: file });
+      }
+    }
+    for (const file of otherFiles) {
+      const filePath = (0, import_path.join)(projectRoot, file);
+      if ((0, import_fs.existsSync)(filePath)) {
+        archive.file(filePath, { name: file });
+      }
+    }
+    const nodeModulesPath = (0, import_path.join)(projectRoot, "node_modules");
+    const includedPackages = /* @__PURE__ */ new Set();
+    const skippedWorkspacePackages = /* @__PURE__ */ new Set();
+    const depsToInclude = [...actualDeps].filter((d) => !d.startsWith("@types/"));
+    for (const dep of depsToInclude) {
+      const packagePath = (0, import_path.join)(nodeModulesPath, dep);
+      if (!(0, import_fs.existsSync)(packagePath)) continue;
+      if (isWorkspacePackage(packagePath, dep)) {
+        skippedWorkspacePackages.add(dep);
+      } else {
+        includedPackages.add(dep);
+        await addPackageFiltered(archive, packagePath, dep);
+      }
+    }
+    console.log(`Including ${includedPackages.size} npm packages (skipped ${skippedWorkspacePackages.size} workspace packages)`);
+    if (skippedWorkspacePackages.size > 0) {
+      console.log(`  Workspace packages (resolved from source): ${[...skippedWorkspacePackages].join(", ")}`);
+    }
+    const minimalPackageJson = {
+      name: packageJson.name,
+      version: packageJson.version,
+      dependencies: Object.fromEntries(
+        [...includedPackages].filter((pkg) => packageJson.dependencies[pkg]).map((pkg) => [pkg, packageJson.dependencies[pkg]])
+      )
+    };
+    archive.append(JSON.stringify(minimalPackageJson, null, 2), { name: "package.json" });
+    archive.finalize();
+    archive.pipe(passthrough);
+    const chunks = [];
+    for await (const chunk of passthrough) {
+      chunks.push(chunk);
+    }
+    result.buffer = Buffer.concat(chunks);
+  } catch (error2) {
+    if (error2 instanceof Error) {
+      result.errors.push(error2.message);
+    } else {
+      result.errors.push(String(error2));
+    }
+  } finally {
+    try {
+      (0, import_fs.rmSync)(tmpDir, { recursive: true, force: true });
+    } catch {
+    }
+  }
+  return result;
 }
 
 // node_modules/axios/lib/helpers/bind.js
@@ -290285,79 +290875,120 @@ async function upload(zipBuffer, shardNumber, totalShards, playwrightConfig, opt
 
 // src/tunnel.ts
 var import_node_child_process2 = require("node:child_process");
-function startTunnel(tunnelProcess, options) {
-  const token = getToken();
-  if (!token) {
-    console.error(
-      source_default.red.bold(
-        "\u274C Error: Not authenticated. Run 'browsermation login' or set BM_API_TOKEN environment variable."
-      )
-    );
-    process.exit(1);
-  }
-  if (!options?.port) {
-    console.error(
-      source_default.red.bold(
-        "\u274C Error: Please provide a port to expose via the tunnel using the --port option."
-      )
-    );
-    process.exit(1);
-  }
-  const defaultDomain = "browsermationtunnel.com";
-  const args = [
-    "-o",
-    "StrictHostKeyChecking=no",
-    "-o",
-    "UserKnownHostsFile=/dev/null",
-    "-R",
-    `:80:localhost:${options.port}`,
-    `v0@${defaultDomain}`,
-    "-p",
-    "2200",
-    "http",
-    "--user",
-    token
-  ];
-  if (options.host) {
-    args.push("--host-header-rewrite", options.host);
-  }
-  tunnelProcess = (0, import_node_child_process2.spawn)("ssh", args);
-  process.on("SIGINT", function() {
-    console.log("\nGracefully shutting down from SIGINT (Ctrl+C)");
-    if (tunnelProcess) {
-      console.log("Killing proxy process...");
-      tunnelProcess.kill();
-    }
-    process.exit();
-  });
-  tunnelProcess?.stdout?.on("data", (data) => {
-    if (process.env.BM_DEBUG) {
-      console.log(`stdout: ${data}`);
-    }
-    if (data.toString().includes("RemoteAddress:")) {
-      const domain = data.toString().split("\n").map((line) => line.trim()).find((line) => line.startsWith("RemoteAddress:")).replace("RemoteAddress: ", "");
-      if (domain) {
-        console.log(
-          source_default.green.bold(
-            `\u2705 Tunnel is running! Access your application at: https://${domain}`
-          )
-        );
+function startTunnel(_tunnelProcess, options) {
+  return new Promise((resolve3, reject) => {
+    const token = getToken();
+    if (!token) {
+      const errorMsg = "Not authenticated. Run 'browsermation login' or set BM_API_TOKEN environment variable.";
+      if (options.onError) {
+        options.onError(errorMsg);
+      }
+      if (options.exitOnError !== false) {
+        console.error(source_default.red.bold(`\u274C Error: ${errorMsg}`));
+        process.exit(1);
       }
+      reject(new Error(errorMsg));
+      return;
     }
-  });
-  tunnelProcess?.stderr?.on("data", (data) => {
-    if (data.toString().includes("Permanently added")) {
+    if (!options?.port) {
+      const errorMsg = "Please provide a port to expose via the tunnel using the --port option.";
+      if (options.onError) {
+        options.onError(errorMsg);
+      }
+      if (options.exitOnError !== false) {
+        console.error(source_default.red.bold(`\u274C Error: ${errorMsg}`));
+        process.exit(1);
+      }
+      reject(new Error(errorMsg));
       return;
     }
-    if (data.toString().includes("closed by remote host.")) {
-      console.error(
-        source_default.red.bold(
-          "\u274C Error: Please check that your BM_API_TOKEN is correct and has permissions to create tunnels."
-        )
-      );
-      process.exit(1);
+    const defaultDomain = "browsermationtunnel.com";
+    const args = [
+      "-o",
+      "StrictHostKeyChecking=no",
+      "-o",
+      "UserKnownHostsFile=/dev/null",
+      "-R",
+      `:80:localhost:${options.port}`,
+      `v0@${defaultDomain}`,
+      "-p",
+      "2200",
+      "http",
+      "--user",
+      token
+    ];
+    if (options.host) {
+      args.push("--host-header-rewrite", options.host);
     }
-    console.error(`stderr: ${data}`);
+    const tunnelProcess = (0, import_node_child_process2.spawn)("ssh", args);
+    process.on("SIGINT", function() {
+      console.log("\nGracefully shutting down from SIGINT (Ctrl+C)");
+      if (tunnelProcess) {
+        console.log("Killing proxy process...");
+        tunnelProcess.kill();
+      }
+      process.exit();
+    });
+    tunnelProcess?.stdout?.on("data", async (data) => {
+      if (process.env.BM_DEBUG) {
+        console.log(`stdout: ${data}`);
+      }
+      if (data.toString().includes("RemoteAddress:")) {
+        const domain = data.toString().split("\n").map((line) => line.trim()).find((line) => line.startsWith("RemoteAddress:"))?.replace("RemoteAddress: ", "");
+        if (domain) {
+          const tunnelUrl = `https://${domain}`;
+          if (options.onStart) {
+            await options.onStart(tunnelUrl);
+          }
+          if (process.env.BM_DEBUG) {
+            console.log(`Tunnel ready: ${tunnelUrl}`);
+          }
+          resolve3({
+            tunnelProcess,
+            tunnelUrl
+          });
+        }
+      }
+    });
+    tunnelProcess?.stderr?.on("data", (data) => {
+      const message = data.toString();
+      if (message.includes("Permanently added")) {
+        return;
+      }
+      if (message.includes("closed by remote host.")) {
+        const errorMsg = "Please check that your BM_API_TOKEN is correct and has permissions to create tunnels.";
+        if (options.onError) {
+          options.onError(errorMsg);
+        }
+        if (options.exitOnError !== false) {
+          console.error(source_default.red.bold(`\u274C Error: ${errorMsg}`));
+          process.exit(1);
+        }
+        reject(new Error(errorMsg));
+        return;
+      }
+      if (options.onError) {
+        options.onError(message);
+      } else {
+        console.error(`stderr: ${data}`);
+      }
+    });
+    tunnelProcess?.on("error", (error2) => {
+      const errorMsg = `Failed to start tunnel: ${error2.message}`;
+      if (options.onError) {
+        options.onError(errorMsg);
+      }
+      reject(new Error(errorMsg));
+    });
+    tunnelProcess?.on("close", (code) => {
+      if (code !== 0 && code !== null) {
+        const errorMsg = `Tunnel process exited with code ${code}`;
+        if (options.onError) {
+          options.onError(errorMsg);
+        }
+        reject(new Error(errorMsg));
+      }
+    });
   });
 }
 
@@ -290375,8 +291006,12 @@ async function runTestCommand(options) {
   }
   let tunnelProcess = null;
   let tunnelUrl;
+  const appUrl = process.env.APP_URL;
   try {
-    if (options.tunnel) {
+    if (appUrl) {
+      console.log(source_default.green(`Using APP_URL: ${appUrl}`));
+      tunnelUrl = appUrl;
+    } else if (options.tunnel) {
       const tunnelSpinner = ora("Starting tunnel...").start();
       try {
         const result2 = await startTunnel(null, {
@@ -290402,14 +291037,17 @@ async function runTestCommand(options) {
     console.log(source_default.dim("\u2500".repeat(50)));
     console.log(source_default.bold(`
 \u{1F4C1} Files to bundle (${result.files.length}):`));
+    const isConfigFile = (f) => /^(playwright\.config|tsconfig|jest\.config|vitest\.config)\.(ts|js|mjs|cjs|json)$/.test(
+      f.split("/").pop() || ""
+    );
     const filesByType = {
-      config: result.files.filter((f) => f.includes("config")),
+      config: result.files.filter(isConfigFile),
       tests: result.files.filter((f) => /\.(spec|test)\.(ts|js|tsx|jsx)$/.test(f)),
       source: result.files.filter(
-        (f) => !f.includes("config") && !/\.(spec|test)\.(ts|js|tsx|jsx)$/.test(f) && /\.(ts|js|tsx|jsx)$/.test(f)
+        (f) => !isConfigFile(f) && !/\.(spec|test)\.(ts|js|tsx|jsx)$/.test(f) && /\.(ts|js|tsx|jsx)$/.test(f)
       ),
       other: result.files.filter(
-        (f) => !f.includes("config") && !/\.(spec|test|ts|js|tsx|jsx)/.test(f)
+        (f) => !isConfigFile(f) && !/\.(spec|test)\.(ts|js|tsx|jsx)$/.test(f) && !/\.(ts|js|tsx|jsx)$/.test(f)
       )
     };
     if (filesByType.config.length > 0) {
@@ -290455,16 +291093,80 @@ async function runTestCommand(options) {
       return;
     }
     const zipSpinner = ora("Creating test bundle...").start();
-    const zipBuffer = await zipFilesToBuffer(
-      projectRoot,
-      result.files,
-      result.packageJson
-    );
-    zipSpinner.succeed(
-      source_default.green(
-        `Bundle created (${(zipBuffer.length / 1024 / 1024).toFixed(2)} MB)`
-      )
-    );
+    let zipBuffer;
+    let bundleInfo = {};
+    if (options.esbuild) {
+      zipSpinner.text = "Transpiling with esbuild...";
+      const esbuildResult = await zipWithEsbuild(
+        projectRoot,
+        result.files,
+        result.packageJson,
+        result.graph.nodeModuleDeps
+      );
+      zipBuffer = esbuildResult.buffer;
+      bundleInfo.warnings = esbuildResult.warnings;
+      bundleInfo.errors = esbuildResult.errors;
+      if (esbuildResult.errors.length > 0) {
+        zipSpinner.warn(source_default.yellow(`Bundle created with ${esbuildResult.errors.length} errors`));
+        console.log(source_default.red("\nEsbuild errors:"));
+        esbuildResult.errors.forEach((err) => console.log(source_default.red(`  ${err}`)));
+      }
+    } else {
+      const zipResult = await zipFilesToBuffer(
+        projectRoot,
+        result.files,
+        result.packageJson,
+        result.graph.nodeModuleDeps
+      );
+      zipBuffer = zipResult.buffer;
+      bundleInfo.workspacePackages = zipResult.workspacePackages;
+      bundleInfo.includedPackages = zipResult.includedPackages;
+      bundleInfo.warnings = zipResult.warnings;
+    }
+    if (process.env.KEEP_ZIP === "true") {
+      const zipPath = path6.join(projectRoot, "browsermation-bundle.zip");
+      (0, import_node_fs5.writeFileSync)(zipPath, zipBuffer);
+      zipSpinner.succeed(
+        source_default.green(
+          `Bundle created (${(zipBuffer.length / 1024 / 1024).toFixed(2)} MB) \u2192 ${zipPath}`
+        )
+      );
+    } else {
+      zipSpinner.succeed(
+        source_default.green(
+          `Bundle created (${(zipBuffer.length / 1024 / 1024).toFixed(2)} MB)${options.esbuild ? " [esbuild]" : ""}`
+        )
+      );
+    }
+    if (!options.esbuild && bundleInfo.includedPackages) {
+      const regularPackages = new Set(
+        [...bundleInfo.includedPackages].filter((p) => !bundleInfo.workspacePackages?.has(p))
+      );
+      if (bundleInfo.workspacePackages && bundleInfo.workspacePackages.size > 0) {
+        console.log(source_default.bold(`
+\u{1F517} Workspace packages (${bundleInfo.workspacePackages.size}) - bundled without transitive deps:`));
+        const sortedWorkspace = Array.from(bundleInfo.workspacePackages).sort();
+        sortedWorkspace.forEach((pkg) => console.log(source_default.yellow(`    ${pkg}`)));
+      }
+      if (regularPackages.size > 0) {
+        console.log(source_default.bold(`
+\u{1F4E6} Bundled node_modules (${regularPackages.size}):`));
+        const sortedPackages = Array.from(regularPackages).sort();
+        sortedPackages.forEach((pkg) => console.log(source_default.dim(`    ${pkg}`)));
+      }
+    }
+    if (bundleInfo.warnings && bundleInfo.warnings.length > 0) {
+      console.log(source_default.bold.yellow(`
+\u26A0\uFE0F  Warnings (${bundleInfo.warnings.length}):`));
+      bundleInfo.warnings.forEach((warning2) => {
+        console.log(source_default.yellow(`    ${warning2}`));
+      });
+      if (!options.esbuild) {
+        console.log(source_default.yellow("\n    Tests may fail due to unbuilt packages. Consider:"));
+        console.log(source_default.yellow("    1. Building the packages first (e.g., npm run build in the package directory)"));
+        console.log(source_default.yellow("    2. Installing published versions from npm instead of monorepo symlinks"));
+      }
+    }
     const uploadSpinner = ora("Uploading to BrowserMation...").start();
     const eventStream = new (await import("stream")).Readable({
       read() {
@@ -290513,8 +291215,18 @@ Error: ${error2.message}`));
 // src/commands/tunnel.ts
 async function runTunnelCommand(options) {
   console.log(source_default.blue(`Starting BrowserMation Tunnel...`));
-  let tunnelProcess = null;
-  await startTunnel(tunnelProcess, options);
+  const tunnelOptions = {
+    port: options.port || "",
+    host: options.host,
+    onStart: (tunnelUrl) => {
+      console.log(
+        source_default.green.bold(
+          `\u2705 Tunnel is running! Access your application at: ${tunnelUrl}`
+        )
+      );
+    }
+  };
+  await startTunnel(null, tunnelOptions);
 }
 
 // src/commands/runner.ts
@@ -290621,7 +291333,7 @@ program2.command("tunnel").description("Start a BrowserMation tunnel").option("-
 program2.command("runner").description("Start the browser engine server").option("-p, --port <port>").option("-t, --tunnel").action(async (options) => {
   await runRunnerCommand(options);
 });
-program2.command("test").description("Analyze and run Playwright tests on BrowserMation").option("--project <project>", "Run a specific Playwright project").option("-t, --tunnel <port>", "Expose local port via tunnel").option("-p, --proxy", "Use proxy for test execution").option("--dry-run", "Analyze dependencies without uploading").action(async (options) => {
+program2.command("test").description("Analyze and run Playwright tests on BrowserMation").option("--project <project>", "Run a specific Playwright project").option("-t, --tunnel <port>", "Expose local port via tunnel").option("-p, --proxy", "Use proxy for test execution").option("--dry-run", "Analyze dependencies without uploading").option("--esbuild", "Use esbuild tree-shaking for minimal bundle size (experimental)").action(async (options) => {
   console.log(source_default.blue("Starting BrowserMation Test Runner..."));
   await runTestCommand(options);
 });