@vitest/browser 2.0.0-beta.12 → 2.0.0-beta.13

package/dist/index.js

@@ -1,14 +1,15 @@
 import { createDebugger, isFileServingAllowed as isFileServingAllowed$1, getFilePoolName, resolveApiServerConfig, resolveFsAllow, distDir, createServer } from 'vitest/node';
-import fs, { existsSync, readdirSync, promises, readFileSync } from 'node:fs';
+import fs, { existsSync, readdirSync, readFileSync, promises } from 'node:fs';
 import { WebSocketServer } from 'ws';
 import { isFileServingAllowed } from 'vite';
 import { builtinModules, createRequire } from 'node:module';
 import { readFile as readFile$1, mkdir } from 'node:fs/promises';
 import { fileURLToPath } from 'node:url';
 import { createDefer, slash, toArray } from '@vitest/utils';
+import { parseErrorStacktrace, parseStacktrace } from '@vitest/utils/source-map';
 import sirv from 'sirv';
 import { defaultBrowserPort, coverageConfigDefaults } from 'vitest/config';
-import { P as PlaywrightBrowserProvider, W as WebdriverBrowserProvider } from './webdriver-CJA71Bgl.js';
+import { P as PlaywrightBrowserProvider, W as WebdriverBrowserProvider } from './webdriver-BdVqnfdE.js';
 import { resolve as resolve$1, dirname as dirname$1, normalize as normalize$1 } from 'node:path';
 import MagicString from 'magic-string';
 import { esmWalker } from '@vitest/utils/ast';
@@ -406,7 +407,9 @@ const stringify = (value, replacer, space) => {
 async function resolveMock(project, rawId, importer, hasFactory) {
   const { id, fsPath, external } = await resolveId(project, rawId, importer);
   if (hasFactory) {
-    return { type: "factory", resolvedId: id };
+    const needsInteropMap = viteDepsInteropMap(project.browser.vite.config);
+    const needsInterop = needsInteropMap?.get(fsPath) ?? false;
+    return { type: "factory", resolvedId: id, needsInterop };
   }
   const mockPath = resolveMockPath(project.config.root, fsPath, external);
   return {
@@ -497,6 +500,29 @@ const postfixRE = /[?#].*$/;
 function cleanUrl(url) {
   return url.replace(postfixRE, "");
 }
+const metadata = /* @__PURE__ */ new WeakMap();
+function viteDepsInteropMap(config) {
+  if (metadata.has(config)) {
+    return metadata.get(config);
+  }
+  const cacheDirPath = getDepsCacheDir(config);
+  const metadataPath = resolve(cacheDirPath, "_metadata.json");
+  if (!existsSync(metadataPath)) {
+    return null;
+  }
+  const { optimized } = JSON.parse(readFileSync(metadataPath, "utf-8"));
+  const needsInteropMap = /* @__PURE__ */ new Map();
+  for (const name in optimized) {
+    const dep = optimized[name];
+    const file = resolve(cacheDirPath, dep.file);
+    needsInteropMap.set(file, dep.needsInterop);
+  }
+  metadata.set(config, needsInteropMap);
+  return needsInteropMap;
+}
+function getDepsCacheDir(config) {
+  return resolve(config.cacheDir, "deps");
+}
 
 const debug$1 = createDebugger("vitest:browser:api");
 const BROWSER_API_PATH = "/__vitest_browser_api__";
@@ -711,10 +737,11 @@ class BrowserServerState {
   getContext(contextId) {
     return this.contexts.get(contextId);
   }
-  createAsyncContext(contextId, files) {
+  createAsyncContext(method, contextId, files) {
     const defer = createDefer();
     this.contexts.set(contextId, {
       files,
+      method,
       resolve: () => {
         defer.resolve();
         this.contexts.delete(contextId);
@@ -804,6 +831,24 @@ class BrowserServer {
   constructor(project, base) {
     this.project = project;
     this.base = base;
+    this.stackTraceOptions = {
+      frameFilter: project.config.onStackTrace,
+      getSourceMap: (id) => {
+        const result = this.vite.moduleGraph.getModuleById(id)?.transformResult;
+        return result?.map;
+      },
+      getFileName: (id) => {
+        const mod = this.vite.moduleGraph.getModuleById(id);
+        if (mod?.file) {
+          return mod.file;
+        }
+        const modUrl = this.vite.moduleGraph.urlToModuleMap.get(id);
+        if (modUrl?.file) {
+          return modUrl.file;
+        }
+        return id;
+      }
+    };
     this.state = new BrowserServerState();
     const pkgRoot = resolve(fileURLToPath(import.meta.url), "../..");
     const distRoot = resolve(pkgRoot, "dist");
@@ -840,6 +885,7 @@ class BrowserServer {
   state;
   provider;
   vite;
+  stackTraceOptions;
   setServer(server) {
     this.vite = server;
   }
@@ -894,6 +940,18 @@ class BrowserServer {
       options: providerOptions
     });
   }
+  parseErrorStacktrace(e, options = {}) {
+    return parseErrorStacktrace(e, {
+      ...this.stackTraceOptions,
+      ...options
+    });
+  }
+  parseStacktrace(trace, options = {}) {
+    return parseStacktrace(trace, {
+      ...this.stackTraceOptions,
+      ...options
+    });
+  }
   cdpSessions = /* @__PURE__ */ new Map();
   async ensureCDPHandler(contextId, sessionId) {
     const cachedHandler = this.state.cdps.get(sessionId);
@@ -935,35 +993,49 @@ function wrapConfig(config) {
   };
 }
 
-const click = async (context, xpath, options = {}) => {
+const click = async (context, selector, options = {}) => {
   const provider = context.provider;
   if (provider instanceof PlaywrightBrowserProvider) {
     const tester = context.iframe;
-    await tester.locator(`xpath=${xpath}`).click({
+    await tester.locator(`css=${selector}`).click({
       timeout: 1e3,
       ...options
     });
   } else if (provider instanceof WebdriverBrowserProvider) {
     const browser = context.browser;
-    const markedXpath = `//${xpath}`;
-    await browser.$(markedXpath).click(options);
+    await browser.$(selector).click(options);
   } else {
     throw new TypeError(`Provider "${provider.name}" doesn't support click command`);
   }
 };
-const dblClick = async (context, xpath, options = {}) => {
+const dblClick = async (context, selector, options = {}) => {
   const provider = context.provider;
   if (provider instanceof PlaywrightBrowserProvider) {
     const tester = context.iframe;
-    await tester.locator(`xpath=${xpath}`).dblclick(options);
+    await tester.locator(`css=${selector}`).dblclick(options);
   } else if (provider instanceof WebdriverBrowserProvider) {
     const browser = context.browser;
-    const markedXpath = `//${xpath}`;
-    await browser.$(markedXpath).doubleClick();
+    await browser.$(selector).doubleClick();
   } else {
     throw new TypeError(`Provider "${provider.name}" doesn't support dblClick command`);
   }
 };
+const tripleClick = async (context, selector, options = {}) => {
+  const provider = context.provider;
+  if (provider instanceof PlaywrightBrowserProvider) {
+    const tester = context.iframe;
+    await tester.locator(`css=${selector}`).click({
+      timeout: 1e3,
+      ...options,
+      clickCount: 3
+    });
+  } else if (provider instanceof WebdriverBrowserProvider) {
+    const browser = context.browser;
+    await browser.action("pointer", { parameters: { pointerType: "mouse" } }).move({ origin: await browser.$(selector) }).down().up().pause(50).down().up().pause(50).down().up().pause(50).perform();
+  } else {
+    throw new TypeError(`Provider "${provider.name}" doesn't support tripleClick command`);
+  }
+};
 
 var clickableInputTypes;
 (function(clickableInputTypes) {
@@ -1435,11 +1507,11 @@ async function keyboardImplementation(provider, contextId, text, selectAll, skip
   };
 }
 
-const type = async (context, xpath, text, options = {}) => {
+const type = async (context, selector, text, options = {}) => {
   const { skipClick = false, skipAutoClose = false } = options;
   if (context.provider instanceof PlaywrightBrowserProvider) {
     const { iframe } = context;
-    const element = iframe.locator(`xpath=${xpath}`);
+    const element = iframe.locator(`css=${selector}`);
     if (!skipClick) {
       await element.focus();
     }
@@ -1452,8 +1524,7 @@ const type = async (context, xpath, text, options = {}) => {
     );
   } else if (context.provider instanceof WebdriverBrowserProvider) {
     const browser = context.browser;
-    const markedXpath = `//${xpath}`;
-    const element = browser.$(markedXpath);
+    const element = browser.$(selector);
     if (!skipClick && !await element.isFocused()) {
       await element.click();
     }
@@ -1474,47 +1545,45 @@ const type = async (context, xpath, text, options = {}) => {
   }
 };
 
-const clear = async (context, xpath) => {
+const clear = async (context, selector) => {
   if (context.provider instanceof PlaywrightBrowserProvider) {
     const { iframe } = context;
-    const element = iframe.locator(`xpath=${xpath}`);
+    const element = iframe.locator(`css=${selector}`);
     await element.clear({
       timeout: 1e3
     });
   } else if (context.provider instanceof WebdriverBrowserProvider) {
     const browser = context.browser;
-    const markedXpath = `//${xpath}`;
-    const element = await browser.$(markedXpath);
+    const element = await browser.$(selector);
     await element.clearValue();
   } else {
     throw new TypeError(`Provider "${context.provider.name}" does not support clearing elements`);
   }
 };
 
-const fill = async (context, xpath, text, options = {}) => {
+const fill = async (context, selector, text, options = {}) => {
   if (context.provider instanceof PlaywrightBrowserProvider) {
     const { iframe } = context;
-    const element = iframe.locator(`xpath=${xpath}`);
+    const element = iframe.locator(`css=${selector}`);
     await element.fill(text, { timeout: 1e3, ...options });
   } else if (context.provider instanceof WebdriverBrowserProvider) {
     const browser = context.browser;
-    const markedXpath = `//${xpath}`;
-    await browser.$(markedXpath).setValue(text);
+    await browser.$(selector).setValue(text);
   } else {
     throw new TypeError(`Provider "${context.provider.name}" does not support clearing elements`);
   }
 };
 
-const selectOptions = async (context, xpath, userValues, options = {}) => {
+const selectOptions = async (context, selector, userValues, options = {}) => {
   if (context.provider instanceof PlaywrightBrowserProvider) {
     const value = userValues;
     const { iframe } = context;
-    const selectElement = iframe.locator(`xpath=${xpath}`);
+    const selectElement = iframe.locator(`css=${selector}`);
     const values = await Promise.all(value.map(async (v) => {
       if (typeof v === "string") {
         return v;
       }
-      const elementHandler = await iframe.locator(`xpath=${v.element}`).elementHandle();
+      const elementHandler = await iframe.locator(`css=${v.element}`).elementHandle();
       if (!elementHandler) {
         throw new Error(`Element not found: ${v.element}`);
       }
@@ -1529,10 +1598,9 @@ const selectOptions = async (context, xpath, userValues, options = {}) => {
     if (!values.length) {
       return;
     }
-    const markedXpath = `//${xpath}`;
     const browser = context.browser;
     if (values.length === 1 && "index" in values[0]) {
-      const selectElement = browser.$(markedXpath);
+      const selectElement = browser.$(selector);
       await selectElement.selectByIndex(values[0].index);
     } else {
       throw new Error(`Provider "webdriverio" doesn't support selecting multiple values at once`);
@@ -1562,18 +1630,16 @@ const dragAndDrop = async (context, source, target, options) => {
   if (context.provider instanceof PlaywrightBrowserProvider) {
     const frame = await context.frame();
     await frame.dragAndDrop(
-      `xpath=${source}`,
-      `xpath=${target}`,
+      `css=${source}`,
+      `css=${target}`,
       {
         timeout: 1e3,
         ...options
       }
     );
   } else if (context.provider instanceof WebdriverBrowserProvider) {
-    const sourceXpath = `//${source}`;
-    const targetXpath = `//${target}`;
-    const $source = context.browser.$(sourceXpath);
-    const $target = context.browser.$(targetXpath);
+    const $source = context.browser.$(source);
+    const $target = context.browser.$(target);
     const duration = options?.duration ?? 10;
     await context.browser.action("pointer").move({ duration: 0, origin: $source, x: 0, y: 0 }).down({ button: 0 }).move({ duration: 0, origin: "pointer", x: 0, y: 0 }).pause(duration).move({ duration: 0, origin: $target, x: 0, y: 0 }).move({ duration: 0, origin: "pointer", x: 1, y: 0 }).move({ duration: 0, origin: "pointer", x: -1, y: 0 }).up({ button: 0 }).perform();
   } else {
@@ -1581,16 +1647,15 @@ const dragAndDrop = async (context, source, target, options) => {
   }
 };
 
-const hover = async (context, xpath, options = {}) => {
+const hover = async (context, selector, options = {}) => {
   if (context.provider instanceof PlaywrightBrowserProvider) {
-    await context.iframe.locator(`xpath=${xpath}`).hover({
+    await context.iframe.locator(`css=${selector}`).hover({
       timeout: 1e3,
       ...options
     });
   } else if (context.provider instanceof WebdriverBrowserProvider) {
     const browser = context.browser;
-    const markedXpath = `//${xpath}`;
-    await browser.$(markedXpath).moveTo(options);
+    await browser.$(selector).moveTo(options);
   } else {
     throw new TypeError(`Provider "${context.provider.name}" does not support hover`);
   }
@@ -1639,28 +1704,31 @@ const screenshot = async (context, name, options = {}) => {
   await mkdir(dirname(path), { recursive: true });
   if (context.provider instanceof PlaywrightBrowserProvider) {
     if (options.element) {
-      const { element: elementXpath, ...config } = options;
-      const element = context.iframe.locator(`xpath=${elementXpath}`);
-      await element.screenshot({ ...config, path: savePath });
-    } else {
-      await context.iframe.locator("body").screenshot({
-        ...options,
+      const { element: css, ...config } = options;
+      const element = context.iframe.locator(`css=${css}`);
+      const buffer2 = await element.screenshot({
+        timeout: 1e3,
+        ...config,
         path: savePath
       });
+      return returnResult(options, path, buffer2);
     }
-    return path;
+    const buffer = await context.iframe.locator("body").screenshot({
+      ...options,
+      path: savePath
+    });
+    return returnResult(options, path, buffer);
   }
   if (context.provider instanceof WebdriverBrowserProvider) {
     const page = context.provider.browser;
     if (!options.element) {
       const body = await page.$("body");
-      await body.saveScreenshot(savePath);
-      return path;
+      const buffer2 = await body.saveScreenshot(savePath);
+      return returnResult(options, path, buffer2);
     }
-    const xpath = `//${options.element}`;
-    const element = await page.$(xpath);
-    await element.saveScreenshot(savePath);
-    return path;
+    const element = await page.$(`${options.element}`);
+    const buffer = await element.saveScreenshot(savePath);
+    return returnResult(options, path, buffer);
   }
   throw new Error(
     `Provider "${context.provider.name}" does not support screenshots`
@@ -1679,6 +1747,12 @@ function resolveScreenshotPath(testPath, name, config) {
   }
   return resolve(dir, "__screenshots__", base, name);
 }
+function returnResult(options, path, buffer) {
+  if (options.base64) {
+    return { path, base64: buffer.toString("base64") };
+  }
+  return path;
+}
 
 var builtinCommands = {
   readFile,
@@ -1686,6 +1760,7 @@ var builtinCommands = {
   writeFile,
   __vitest_click: click,
   __vitest_dblClick: dblClick,
+  __vitest_tripleClick: tripleClick,
   __vitest_screenshot: screenshot,
   __vitest_type: type,
   __vitest_clear: clear,
@@ -1900,7 +1975,9 @@ async function resolveTester(server, url, res) {
   const testFiles = await project.globTestFiles();
   const tests = testFile === "__vitest_all__" || !testFiles.includes(testFile) ? "__vitest_browser_runner__.files" : JSON.stringify([testFile]);
   const iframeId = JSON.stringify(testFile);
-  const files = state.getContext(contextId)?.files ?? [];
+  const context = state.getContext(contextId);
+  const files = context?.files ?? [];
+  const method = context?.method ?? "run";
   const injectorJs = typeof server.injectorJs === "string" ? server.injectorJs : await server.injectorJs;
   const config = server.getSerializableConfig();
   const injector = replacer(injectorJs, {
@@ -1932,7 +2009,7 @@ async function resolveTester(server, url, res) {
     __VITEST_APPEND__: `<script type="module">
 __vitest_browser_runner__.runningFiles = ${tests}
 __vitest_browser_runner__.iframeId = ${iframeId}
-__vitest_browser_runner__.runTests(__vitest_browser_runner__.runningFiles)
+__vitest_browser_runner__.${method === "run" ? "runTests" : "collectTests"}(__vitest_browser_runner__.runningFiles)
 <\/script>`
   });
 }
@@ -2057,6 +2134,9 @@ var BrowserPlugin = (browserServer, base = "/") => {
         }
         return {
           define,
+          resolve: {
+            dedupe: ["vitest"]
+          },
           optimizeDeps: {
             entries,
             exclude: [
@@ -2087,7 +2167,7 @@ var BrowserPlugin = (browserServer, base = "/") => {
               "vitest > pretty-format > ansi-regex",
               "vitest > chai",
               "vitest > chai > loupe",
-              "vitest > @vitest/runner > p-limit",
+              "vitest > @vitest/runner > pretty-format",
               "vitest > @vitest/utils > diff-sequences",
               "vitest > @vitest/utils > loupe",
               "@vitest/browser > @testing-library/user-event",
@@ -2265,11 +2345,11 @@ function resolveCoverageFolder(project) {
 const debug = createDebugger("vitest:browser:pool");
 function createBrowserPool(ctx) {
   const providers = /* @__PURE__ */ new Set();
-  const waitForTests = async (contextId, project, files) => {
-    const context = project.browser.state.createAsyncContext(contextId, files);
+  const waitForTests = async (method, contextId, project, files) => {
+    const context = project.browser.state.createAsyncContext(method, contextId, files);
     return await context;
   };
-  const runTests = async (project, files) => {
+  const executeTests = async (method, project, files) => {
     ctx.state.clearFiles(project, files);
     const browser = project.browser;
     const threadsCount = getThreadsCount(project);
@@ -2305,12 +2385,12 @@ function createBrowserPool(ctx) {
           contextId,
           [...files2.map((f) => relative(project.config.root, f))].join(", ")
         );
-        const promise = waitForTests(contextId, project, files2);
+        const promise = waitForTests(method, contextId, project, files2);
         promises.push(promise);
         orchestrator.createTesters(files2);
       } else {
         const contextId = crypto.randomUUID();
-        const waitPromise = waitForTests(contextId, project, files2);
+        const waitPromise = waitForTests(method, contextId, project, files2);
         debug?.(
           "Opening a new context %s for files: %s",
           contextId,
@@ -2324,7 +2404,7 @@ function createBrowserPool(ctx) {
     });
     await Promise.all(promises);
   };
-  const runWorkspaceTests = async (specs) => {
+  const runWorkspaceTests = async (method, specs) => {
     const groupedFiles = /* @__PURE__ */ new Map();
     for (const [project, file] of specs) {
       const files = groupedFiles.get(project) || [];
@@ -2339,7 +2419,7 @@ function createBrowserPool(ctx) {
       if (isCancelled) {
         break;
       }
-      await runTests(project, files);
+      await executeTests(method, project, files);
     }
   };
   const numCpus = typeof nodeos.availableParallelism === "function" ? nodeos.availableParallelism() : nodeos.cpus().length;
@@ -2359,7 +2439,8 @@ function createBrowserPool(ctx) {
       await Promise.all([...providers].map((provider) => provider.close()));
       providers.clear();
     },
-    runTests: runWorkspaceTests
+    runTests: (files) => runWorkspaceTests("run", files),
+    collectTests: (files) => runWorkspaceTests("collect", files)
   };
 }
 

package/dist/providers.js

@@ -1,4 +1,4 @@
-import { W as WebdriverBrowserProvider, P as PlaywrightBrowserProvider } from './webdriver-CJA71Bgl.js';
+import { W as WebdriverBrowserProvider, P as PlaywrightBrowserProvider } from './webdriver-BdVqnfdE.js';
 
 class PreviewBrowserProvider {
   name = "preview";
@@ -19,7 +19,7 @@ class PreviewBrowserProvider {
     this.open = false;
     if (ctx.config.browser.headless) {
       throw new Error(
-        `You've enabled headless mode for "preview" provider but it doesn't support it. Use "playwright" or "webdriverio" instead: https://vitest.dev/guide/browser#configuration`
+        `You've enabled headless mode for "preview" provider but it doesn't support it. Use "playwright" or "webdriverio" instead: https://vitest.dev/guide/browser/#configuration`
       );
     }
   }

package/dist/{webdriver-CJA71Bgl.js → webdriver-BdVqnfdE.js}

@@ -27,10 +27,19 @@ class PlaywrightBrowserProvider {
     this.browserPromise = (async () => {
       const options = this.ctx.config.browser;
       const playwright = await import('playwright');
-      const browser = await playwright[this.browserName].launch({
+      const launchOptions = {
         ...this.options?.launch,
         headless: options.headless
-      });
+      };
+      if (this.ctx.config.browser.ui && this.browserName === "chromium") {
+        if (!launchOptions.args) {
+          launchOptions.args = [];
+        }
+        if (!launchOptions.args.includes("--start-maximized") && !launchOptions.args.includes("--start-fullscreen")) {
+          launchOptions.args.push("--start-maximized");
+        }
+      }
+      const browser = await playwright[this.browserName].launch(launchOptions);
       this.browser = browser;
       this.browserPromise = null;
       return this.browser;
@@ -42,11 +51,15 @@ class PlaywrightBrowserProvider {
       return this.contexts.get(contextId);
     }
     const browser = await this.openBrowser();
-    const context = await browser.newContext({
+    const options = {
       ...this.options?.context,
       ignoreHTTPSErrors: true,
       serviceWorkers: "allow"
-    });
+    };
+    if (this.ctx.config.browser.ui) {
+      options.viewport = null;
+    }
+    const context = await browser.newContext(options);
     this.contexts.set(contextId, context);
     return context;
   }
@@ -210,6 +223,15 @@ class WebdriverBrowserProvider {
       const newArgs = [...currentValues.args || [], ...args];
       capabilities[key] = { ...currentValues, args: newArgs };
     }
+    if (options.ui && (browser === "chrome" || browser === "edge")) {
+      const key = browser === "chrome" ? "goog:chromeOptions" : "ms:edgeOptions";
+      const args = capabilities[key]?.args || [];
+      if (!args.includes("--start-maximized") && !args.includes("--start-fullscreen")) {
+        args.push("--start-maximized");
+      }
+      capabilities[key] ??= {};
+      capabilities[key].args = args;
+    }
     return capabilities;
   }
   async openPage(_contextId, url) {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@vitest/browser",
   "type": "module",
-  "version": "2.0.0-beta.12",
+  "version": "2.0.0-beta.13",
   "description": "Browser running for Vitest",
   "license": "MIT",
   "funding": "https://opencollective.com/vitest",
@@ -51,7 +51,7 @@
   "peerDependencies": {
     "playwright": "*",
     "webdriverio": "*",
-    "vitest": "2.0.0-beta.12"
+    "vitest": "2.0.0-beta.13"
   },
   "peerDependenciesMeta": {
     "playwright": {
@@ -65,13 +65,13 @@
     }
   },
   "dependencies": {
-    "@testing-library/dom": "^10.1.0",
+    "@testing-library/dom": "^10.2.0",
     "@testing-library/user-event": "^14.5.2",
     "magic-string": "^0.30.10",
     "msw": "^2.3.1",
     "sirv": "^2.0.4",
     "ws": "^8.17.1",
-    "@vitest/utils": "2.0.0-beta.12"
+    "@vitest/utils": "2.0.0-beta.13"
   },
   "devDependencies": {
     "@testing-library/jest-dom": "^6.4.6",
@@ -81,14 +81,14 @@
     "flatted": "^3.3.1",
     "pathe": "^1.1.2",
     "periscopic": "^4.0.2",
-    "playwright": "^1.44.1",
-    "playwright-core": "^1.44.1",
+    "playwright": "^1.45.0",
+    "playwright-core": "^1.45.0",
     "safaridriver": "^0.1.2",
-    "webdriverio": "^8.38.2",
-    "@vitest/runner": "2.0.0-beta.12",
-    "@vitest/ui": "2.0.0-beta.12",
-    "@vitest/ws-client": "2.0.0-beta.12",
-    "vitest": "2.0.0-beta.12"
+    "webdriverio": "^8.39.0",
+    "@vitest/ws-client": "2.0.0-beta.13",
+    "@vitest/runner": "2.0.0-beta.13",
+    "@vitest/ui": "2.0.0-beta.13",
+    "vitest": "2.0.0-beta.13"
   },
   "scripts": {
     "build": "rimraf dist && pnpm build:node && pnpm build:client",