@vercel/rust 1.2.0 → 1.4.0

package/dist/index.js

@@ -31,6 +31,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var src_exports = {};
 __export(src_exports, {
   build: () => build,
+  diagnostics: () => diagnostics,
   prepareCache: () => prepareCache,
   shouldServe: () => shouldServe,
   startDevServer: () => startDevServer2,
@@ -38,7 +39,7 @@ __export(src_exports, {
 });
 module.exports = __toCommonJS(src_exports);
 var import_node_path4 = __toESM(require("path"));
-var import_build_utils6 = require("@vercel/build-utils");
+var import_build_utils7 = require("@vercel/build-utils");
 var import_execa4 = __toESM(require("execa"));
 
 // src/lib/rust-toolchain.ts
@@ -74,12 +75,11 @@ var import_node_fs = require("fs");
 var import_node_path = __toESM(require("path"));
 var import_smol_toml = require("smol-toml");
 var import_execa2 = __toESM(require("execa"));
-async function getCargoMetadata(options) {
-  const { stdout: cargoMetaData } = await (0, import_execa2.default)(
-    "cargo",
-    ["metadata", "--format-version", "1"],
-    options
-  );
+async function getCargoMetadata(options, filterPlatform) {
+  const args = ["metadata", "--format-version", "1"];
+  if (filterPlatform)
+    args.push("--filter-platform", filterPlatform);
+  const { stdout: cargoMetaData } = await (0, import_execa2.default)("cargo", args, options);
   return JSON.parse(cargoMetaData);
 }
 async function findCargoWorkspace(config) {
@@ -158,6 +158,7 @@ async function gatherExtraFiles(globMatcher, workPath) {
 // src/lib/start-dev-server.ts
 var import_child_process = require("child_process");
 var import_events = require("events");
+var import_get_port = __toESM(require("get-port"));
 var import_build_utils5 = require("@vercel/build-utils");
 
 // src/lib/dev-build.ts
@@ -213,7 +214,7 @@ async function buildExecutableForDev(workPath, entrypoint) {
 
 // src/lib/dev-server.ts
 var import_build_utils4 = require("@vercel/build-utils");
-function createDevServerEnv(baseEnv, meta = {}) {
+function createDevServerEnv(baseEnv, meta = {}, port) {
   const devEnv = {
     // Base environment
     ...Object.fromEntries(
@@ -225,6 +226,9 @@ function createDevServerEnv(baseEnv, meta = {}) {
     // Runtime environment from meta
     ...meta.env || {}
   };
+  if (typeof port === "number" && Number.isInteger(port)) {
+    devEnv.VERCEL_DEV_PORT = String(port);
+  }
   Object.keys(devEnv).forEach((key) => {
     if (devEnv[key] === void 0) {
       delete devEnv[key];
@@ -235,49 +239,147 @@ function createDevServerEnv(baseEnv, meta = {}) {
 }
 
 // src/lib/start-dev-server.ts
+var SHUTDOWN_TIMEOUT = 35e3;
+var ADDR_IN_USE_RE = /address (already )?in use|AddrInUse|EADDRINUSE/i;
+var MAX_STDERR_CAPTURE = 8192;
+var RUNNING_DEV_SERVERS = /* @__PURE__ */ new Set();
+var cleanupHandlersInstalled = false;
+function installGlobalCleanupHandlers() {
+  if (cleanupHandlersInstalled)
+    return;
+  cleanupHandlersInstalled = true;
+  const onSignal = () => {
+    for (const child of RUNNING_DEV_SERVERS) {
+      try {
+        child.kill("SIGTERM");
+      } catch (err) {
+        (0, import_build_utils5.debug)(`Error sending SIGTERM to Rust dev server on signal: ${err}`);
+      }
+    }
+  };
+  process.on("SIGINT", onSignal);
+  process.on("SIGTERM", onSignal);
+  process.on("SIGHUP", onSignal);
+  process.on("exit", () => {
+    for (const child of RUNNING_DEV_SERVERS) {
+      if (child.pid) {
+        try {
+          process.kill(child.pid, "SIGKILL");
+        } catch {
+        }
+      }
+    }
+    RUNNING_DEV_SERVERS.clear();
+  });
+}
+function trackDevServer(child) {
+  installGlobalCleanupHandlers();
+  RUNNING_DEV_SERVERS.add(child);
+  const untrack = () => {
+    RUNNING_DEV_SERVERS.delete(child);
+  };
+  child.once("exit", untrack);
+  child.once("close", untrack);
+}
+var RustDevServerError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "RustDevServerError";
+  }
+};
+function terminate(child) {
+  return new Promise((resolve) => {
+    if (!child.pid || child.exitCode !== null || child.signalCode !== null) {
+      resolve();
+      return;
+    }
+    let timer;
+    let settled = false;
+    const done = () => {
+      if (settled)
+        return;
+      settled = true;
+      if (timer)
+        clearTimeout(timer);
+      resolve();
+    };
+    child.once("exit", done);
+    child.once("close", done);
+    try {
+      child.kill("SIGTERM");
+    } catch (err) {
+      (0, import_build_utils5.debug)(`Error sending SIGTERM to Rust dev server: ${err}`);
+      done();
+      return;
+    }
+    timer = setTimeout(() => {
+      (0, import_build_utils5.debug)(
+        `Rust dev server did not exit within ${SHUTDOWN_TIMEOUT}ms, sending SIGKILL`
+      );
+      try {
+        child.kill("SIGKILL");
+      } catch (err) {
+        (0, import_build_utils5.debug)(`Error sending SIGKILL to Rust dev server: ${err}`);
+      }
+    }, SHUTDOWN_TIMEOUT);
+    timer.unref?.();
+  });
+}
 var startDevServer = async (opts) => {
-  const { entrypoint, workPath, meta = {} } = opts;
+  const { entrypoint, workPath, meta = {}, onStdout, onStderr } = opts;
   try {
     await installRustToolchain();
     const executablePath = await buildExecutableForDev(workPath, entrypoint);
-    (0, import_build_utils5.debug)(`Starting Rust dev server: ${executablePath}`);
-    const devEnv = createDevServerEnv(process.env, meta);
+    const requestedPort = typeof meta.port === "number" ? meta.port : meta.env?.VERCEL_DEV_PORT ? Number(meta.env.VERCEL_DEV_PORT) : void 0;
+    const port = typeof requestedPort === "number" && Number.isInteger(requestedPort) ? requestedPort : await (0, import_get_port.default)();
+    (0, import_build_utils5.debug)(`Starting Rust dev server: ${executablePath} (port=${port})`);
+    const devEnv = createDevServerEnv(process.env, meta, port);
     const child = (0, import_child_process.spawn)(executablePath, [], {
       cwd: workPath,
       env: devEnv,
       stdio: ["pipe", "pipe", "pipe"]
     });
     if (!child.pid) {
-      throw new Error("Failed to start dev server process");
+      throw new Error("Failed to start Rust dev server process");
     }
-    (0, import_build_utils5.debug)(`Dev server process started with PID: ${child.pid}`);
+    trackDevServer(child);
+    (0, import_build_utils5.debug)(`Rust dev server process started with PID: ${child.pid}`);
     let buffer = "";
     let portEmitted = false;
+    let stderrTail = "";
     child.stdout?.on("data", (data) => {
-      const output = data.toString();
-      buffer += output;
-      if (!portEmitted && buffer.includes("Dev server listening:")) {
-        const portMatch = buffer.match(/Dev server listening: (\d+)/);
-        if (portMatch) {
-          const port = parseInt(portMatch[1], 10);
-          (0, import_build_utils5.debug)(
-            `Rust dev server detected port ${port}, emitting message event`
-          );
-          child.emit("message", { port }, null);
+      const chunk = Buffer.isBuffer(data) ? data : Buffer.from(data);
+      buffer += chunk.toString();
+      if (!portEmitted) {
+        const match = buffer.match(/Dev server listening:\s*(\d+)/);
+        if (match) {
           portEmitted = true;
+          const reportedPort = parseInt(match[1], 10);
+          (0, import_build_utils5.debug)(`Rust dev server reported ready on port ${reportedPort}`);
+          child.emit("message", { port: reportedPort }, null);
+          buffer = "";
         }
-        buffer = "";
       }
-      console.log(output);
+      if (onStdout) {
+        onStdout(chunk);
+      } else {
+        process.stdout.write(chunk.toString());
+      }
     });
     child.stderr?.on("data", (data) => {
-      console.error(data.toString());
+      const chunk = Buffer.isBuffer(data) ? data : Buffer.from(data);
+      stderrTail = (stderrTail + chunk.toString()).slice(-MAX_STDERR_CAPTURE);
+      if (onStderr) {
+        onStderr(chunk);
+      } else {
+        process.stderr.write(chunk.toString());
+      }
     });
     child.on("error", (err) => {
-      (0, import_build_utils5.debug)(`Dev server error: ${err}`);
+      (0, import_build_utils5.debug)(`Rust dev server error: ${err}`);
     });
-    child.on("exit", (code, signal) => {
-      (0, import_build_utils5.debug)(`Dev server exited with code ${code}, signal ${signal}`);
+    child.on("exit", (code, signal2) => {
+      (0, import_build_utils5.debug)(`Rust dev server exited with code ${code}, signal ${signal2}`);
     });
     const onMessage = (0, import_events.once)(child, "message");
     const onExit = (0, import_events.once)(child, "close");
@@ -287,40 +389,150 @@ var startDevServer = async (opts) => {
         return { state: "message", value: messageData };
       }),
       onExit.then((args) => {
-        const [code, signal] = args;
-        return { state: "exit", value: [code, signal] };
+        const [code, signal2] = args;
+        return { state: "exit", value: [code, signal2] };
       })
     ]);
     if (result.state === "message") {
-      const { port } = result.value;
-      (0, import_build_utils5.debug)(`Rust dev server ready on port ${port}`);
+      const readyPort = typeof result.value?.port === "number" ? result.value.port : port;
+      (0, import_build_utils5.debug)(`Rust dev server ready on port ${readyPort} (pid ${child.pid})`);
       if (!child.pid) {
         throw new Error("Child process has no PID");
       }
-      const shutdown = async () => {
-        try {
-          process.kill(child.pid, "SIGTERM");
-        } catch (err) {
-          (0, import_build_utils5.debug)(`Error terminating Rust dev server: ${err}`);
-        }
+      return {
+        port: readyPort,
+        pid: child.pid,
+        // Wait for exit so the port is released before `vercel dev` continues.
+        shutdown: () => terminate(child)
       };
-      return { port, pid: child.pid, shutdown };
-    } else {
-      const [exitCode, signal] = result.value;
-      const reason = signal ? `"${signal}" signal` : `exit code ${exitCode}`;
-      throw new Error(`Rust dev server failed with ${reason}`);
     }
+    const [exitCode, signal] = result.value;
+    const reason = signal ? `"${signal}" signal` : `exit code ${exitCode}`;
+    const stderr = stderrTail.trim();
+    if (ADDR_IN_USE_RE.test(stderr)) {
+      throw new RustDevServerError(
+        `Rust dev server failed to bind port ${port} ("address already in use"). A previous dev server instance may not have shut down yet. Please retry, or ensure no other process is using that port.`
+      );
+    }
+    (0, import_build_utils5.debug)(
+      `Rust dev server exited before becoming ready (${reason}). Falling back to build-and-invoke mode.` + (stderr ? ` stderr:
+${stderr}` : "")
+    );
+    return null;
   } catch (error) {
-    (0, import_build_utils5.debug)(`Failed to start dev server: ${error}`);
+    (0, import_build_utils5.debug)(`Failed to start Rust dev server: ${error}`);
+    if (error instanceof RustDevServerError) {
+      throw error;
+    }
     return null;
   }
 };
 
+// src/diagnostics.ts
+var import_build_utils6 = require("@vercel/build-utils");
+function parseSource(source) {
+  if (!source)
+    return { include: false };
+  if (source.startsWith("path+file:"))
+    return { include: false };
+  if (source.startsWith("registry+https://github.com/rust-lang/crates.io-index")) {
+    return {
+      include: true,
+      source: "registry",
+      sourceUrl: "https://crates.io"
+    };
+  }
+  if (source.startsWith("registry+")) {
+    const url = source.slice("registry+".length).split(/[?#]/)[0];
+    return { include: true, source: "registry", sourceUrl: url };
+  }
+  if (source.startsWith("git+")) {
+    const url = source.slice("git+".length).split(/[?#]/)[0];
+    return { include: true, source: "git", sourceUrl: url };
+  }
+  return { include: true };
+}
+async function generateProjectManifest({
+  workPath,
+  cargoMetadata,
+  framework,
+  serviceType,
+  runtimeVersion
+}) {
+  try {
+    const { packages, resolve } = cargoMetadata;
+    const pkgById = new Map(packages.map((p) => [p.id, p]));
+    const rootId = resolve.root;
+    const rootNode = resolve.nodes.find((n) => n.id === rootId);
+    if (!rootNode)
+      return;
+    const rootPkg = pkgById.get(rootId);
+    const directMap = /* @__PURE__ */ new Map();
+    for (const dep of rootNode.deps) {
+      const scopes = dep.dep_kinds.map(
+        (dk) => dk.kind === "dev" ? "dev" : dk.kind === "build" ? "build" : "prod"
+      );
+      const depPkg = pkgById.get(dep.pkg);
+      const req = rootPkg?.dependencies.find((d) => d.name === depPkg?.name)?.req;
+      directMap.set(dep.pkg, {
+        scopes: [...new Set(scopes)].sort(),
+        requested: req
+      });
+    }
+    const directEntries = [];
+    const transitiveEntries = [];
+    for (const node of resolve.nodes) {
+      if (node.id === rootId)
+        continue;
+      const pkg = pkgById.get(node.id);
+      if (!pkg)
+        continue;
+      const sourceInfo = parseSource(pkg.source);
+      if (!sourceInfo.include)
+        continue;
+      const directInfo = directMap.get(node.id);
+      const entry = {
+        name: pkg.name,
+        type: directInfo ? "direct" : "transitive",
+        // Transitive scope would require full graph traversal to trace which
+        // root-level scope pulled this in. 'prod' is a safe default — accurate
+        // scope propagation for transitives is left to future work.
+        scopes: directInfo ? directInfo.scopes : ["prod"],
+        resolved: pkg.version
+      };
+      if (directInfo?.requested)
+        entry.requested = directInfo.requested;
+      if (sourceInfo.source)
+        entry.source = sourceInfo.source;
+      if (sourceInfo.sourceUrl)
+        entry.sourceUrl = sourceInfo.sourceUrl;
+      if (directInfo)
+        directEntries.push(entry);
+      else
+        transitiveEntries.push(entry);
+    }
+    const manifest = {
+      version: import_build_utils6.MANIFEST_VERSION,
+      runtime: "rust",
+      ...framework ? { framework } : {},
+      ...serviceType ? { serviceType } : {},
+      ...runtimeVersion ? { runtimeVersion } : {},
+      dependencies: [
+        ...directEntries.sort((a, b) => a.name.localeCompare(b.name)),
+        ...transitiveEntries.sort((a, b) => a.name.localeCompare(b.name))
+      ]
+    };
+    await (0, import_build_utils6.writeProjectManifest)(manifest, workPath, "rust");
+  } catch {
+  }
+}
+var diagnostics = (0, import_build_utils6.createDiagnostics)("rust");
+
 // src/index.ts
 async function buildHandler(options) {
   const BUILDER_DEBUG = Boolean(process.env.VERCEL_BUILDER_DEBUG ?? false);
   const isVercelBuild = Boolean(process.env.VERCEL_BUILD_IMAGE ?? false);
-  const { files, entrypoint, workPath, config, meta } = options;
+  const { files, entrypoint, workPath, config, meta, service } = options;
   const crossCompilationEnabled = !isVercelBuild && !meta?.isDev;
   if (crossCompilationEnabled && process.platform === "win32") {
     throw new Error(
@@ -328,8 +540,8 @@ async function buildHandler(options) {
     );
   }
   await installRustToolchain();
-  (0, import_build_utils6.debug)("Creating file system");
-  const downloadedFiles = await (0, import_build_utils6.download)(files, workPath, meta);
+  (0, import_build_utils7.debug)("Creating file system");
+  const downloadedFiles = await (0, import_build_utils7.download)(files, workPath, meta);
   const entryPath = downloadedFiles[entrypoint].fsPath;
   const HOME = process.platform === "win32" ? assertEnv("USERPROFILE") : assertEnv("HOME");
   const PATH = assertEnv("PATH");
@@ -345,25 +557,23 @@ async function buildHandler(options) {
   const cargoBuildConfiguration = await findCargoBuildConfiguration(cargoWorkspace);
   await runUserScripts(workPath);
   const extraFiles = await gatherExtraFiles(config.includeFiles, workPath);
-  const lambdaOptions = await (0, import_build_utils6.getLambdaOptionsFromFunction)({
+  const lambdaOptions = await (0, import_build_utils7.getLambdaOptionsFromFunction)({
     sourceFile: entrypoint,
     config
   });
   const architecture = lambdaOptions?.architecture || "x86_64";
   const buildVariant = meta?.isDev ? "debug" : "release";
   const buildTarget = cargoBuildConfiguration?.build.target ?? "";
+  const targetTriple = architecture === "x86_64" ? "x86_64-unknown-linux-gnu" : "aarch64-unknown-linux-gnu";
   try {
-    const args = crossCompilationEnabled ? [
-      "zigbuild",
-      "--target",
-      architecture === "x86_64" ? "x86_64-unknown-linux-gnu" : "aarch64-unknown-linux-gnu",
-      "--bin",
-      binaryName
-    ].concat(BUILDER_DEBUG ? ["--verbose"] : ["--quiet"], ["--release"]) : ["build", "--bin", binaryName].concat(
+    const args = crossCompilationEnabled ? ["zigbuild", "--target", targetTriple, "--bin", binaryName].concat(
+      BUILDER_DEBUG ? ["--verbose"] : ["--quiet"],
+      ["--release"]
+    ) : ["build", "--bin", binaryName].concat(
       BUILDER_DEBUG ? ["--verbose"] : ["--quiet"],
       meta?.isDev ? [] : ["--release"]
     );
-    (0, import_build_utils6.debug)(
+    (0, import_build_utils7.debug)(
       `Running \`cargo build\` for \`${binaryName}\` (\`${architecture}\`)`
     );
     await (0, import_execa4.default)("cargo", args, {
@@ -371,21 +581,19 @@ async function buildHandler(options) {
       env: rustEnv
     });
   } catch (err) {
-    (0, import_build_utils6.debug)(`Running \`cargo build\` for \`${binaryName}\` failed`);
+    (0, import_build_utils7.debug)(`Running \`cargo build\` for \`${binaryName}\` failed`);
     throw err;
   }
-  (0, import_build_utils6.debug)(
+  (0, import_build_utils7.debug)(
     `Building \`${binaryName}\` for \`${process.platform}\` (\`${architecture}\`) completed`
   );
-  let { target_directory: targetDirectory } = await getCargoMetadata({
-    cwd: workPath,
-    env: rustEnv
-  });
+  const cargoMetadata = await getCargoMetadata(
+    { cwd: workPath, env: rustEnv },
+    targetTriple
+  );
+  let { target_directory: targetDirectory } = cargoMetadata;
   if (crossCompilationEnabled) {
-    targetDirectory = import_node_path4.default.join(
-      targetDirectory,
-      architecture === "x86_64" ? "x86_64-unknown-linux-gnu" : "aarch64-unknown-linux-gnu"
-    );
+    targetDirectory = import_node_path4.default.join(targetDirectory, targetTriple);
   }
   targetDirectory = import_node_path4.default.join(targetDirectory, buildTarget);
   const bin = import_node_path4.default.join(
@@ -394,8 +602,8 @@ async function buildHandler(options) {
     getExecutableName(binaryName)
   );
   const handler = getExecutableName("executable");
-  const executableFile = new import_build_utils6.FileFsRef({ mode: 493, fsPath: bin });
-  const lambda = new import_build_utils6.Lambda({
+  const executableFile = new import_build_utils7.FileFsRef({ mode: 493, fsPath: bin });
+  const lambda = new import_build_utils7.Lambda({
     ...lambdaOptions,
     files: {
       ...extraFiles,
@@ -408,7 +616,31 @@ async function buildHandler(options) {
     runtimeLanguage: "rust"
   });
   lambda.zipBuffer = await lambda.createZip();
-  (0, import_build_utils6.debug)(`generating function for \`${entrypoint}\``);
+  let resolvedRustVersion;
+  try {
+    const { stdout: rustcOut } = await (0, import_execa4.default)("rustc", ["--version"], {
+      env: rustEnv,
+      cwd: workPath
+    });
+    resolvedRustVersion = rustcOut.split(" ")[1];
+  } catch {
+    (0, import_build_utils7.debug)("Failed to determine rustc version");
+  }
+  const rootPkg = cargoMetadata.packages.find(
+    (p) => p.id === cargoMetadata.resolve.root
+  );
+  const requestedRustVersion = rootPkg?.rust_version || void 0;
+  await generateProjectManifest({
+    workPath,
+    cargoMetadata,
+    framework: config?.framework ?? void 0,
+    serviceType: service ? (0, import_build_utils7.getReportedServiceType)(service) : void 0,
+    runtimeVersion: resolvedRustVersion ? {
+      ...requestedRustVersion ? { requested: requestedRustVersion } : {},
+      resolved: resolvedRustVersion
+    } : void 0
+  });
+  (0, import_build_utils7.debug)(`generating function for \`${entrypoint}\``);
   return {
     output: lambda
   };
@@ -417,8 +649,8 @@ var runtime = {
   version: 3,
   build: buildHandler,
   prepareCache: async ({ workPath }) => {
-    (0, import_build_utils6.debug)(`Caching \`${workPath}\``);
-    const cacheFiles = await (0, import_build_utils6.glob)("target/**", workPath);
+    (0, import_build_utils7.debug)(`Caching \`${workPath}\``);
+    const cacheFiles = await (0, import_build_utils7.glob)("target/**", workPath);
     for (const f of Object.keys(cacheFiles)) {
       const accept = /(?:^|\/)target\/release\/\.fingerprint\//.test(f) || /(?:^|\/)target\/release\/build\//.test(f) || /(?:^|\/)target\/release\/deps\//.test(f) || /(?:^|\/)target\/debug\/\.fingerprint\//.test(f) || /(?:^|\/)target\/debug\/build\//.test(f) || /(?:^|\/)target\/debug\/deps\//.test(f);
       if (!accept) {
@@ -429,10 +661,10 @@ var runtime = {
   },
   startDevServer,
   shouldServe: async (options) => {
-    (0, import_build_utils6.debug)(`Requested ${options.requestPath} for ${options.entrypoint}`);
+    (0, import_build_utils7.debug)(`Requested ${options.requestPath} for ${options.entrypoint}`);
     const entrypointWithoutExt = options.entrypoint.replace(/\.rs$/, "");
     const matches = options.requestPath === options.entrypoint || options.requestPath === entrypointWithoutExt;
-    (0, import_build_utils6.debug)(
+    (0, import_build_utils7.debug)(
       `shouldServe: ${matches} (entrypointWithoutExt: ${entrypointWithoutExt})`
     );
     return Promise.resolve(matches);
@@ -442,6 +674,7 @@ var { version, build, prepareCache, startDevServer: startDevServer2, shouldServe
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   build,
+  diagnostics,
   prepareCache,
   shouldServe,
   startDevServer,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vercel/rust",
-  "version": "1.2.0",
+  "version": "1.4.0",
   "license": "Apache-2.0",
   "main": "./dist/index",
   "homepage": "https://vercel.com/docs/runtimes#official-runtimes/rust",
@@ -14,27 +14,28 @@
   ],
   "dependencies": {
     "smol-toml": "1.5.2",
-    "execa": "5"
+    "execa": "5",
+    "get-port": "5.1.1"
   },
   "devDependencies": {
-    "@types/jest": "^29.4.0",
     "@types/ms": "^0.7.31",
     "@types/node": "20.11.0",
     "@vercel/style-guide": "^4.0.2",
     "eslint": "^8.35.0",
     "husky": "^8.0.3",
-    "jest": "^29.5.0",
     "ms": "^2.1.3",
     "prettier": "^2.8.4",
     "rimraf": "^4.1.1",
-    "ts-jest": "^29.0.5",
-    "@vercel/routing-utils": "6.2.0",
-    "@vercel/build-utils": "13.21.0"
+    "vitest": "2.0.3",
+    "@vercel/build-utils": "13.32.2",
+    "@vercel/routing-utils": "6.4.0"
   },
   "scripts": {
     "build": "node ../../utils/build-builder.mjs",
-    "test": "jest --reporters=default --reporters=jest-junit --env node --verbose --runInBand --bail",
+    "test": "vitest run --config ../../vitest.config.mts",
     "test-e2e": "pnpm test",
-    "type-check": "tsc --noEmit"
+    "type-check": "tsc --noEmit",
+    "vitest-run": "vitest -c ../../vitest.config.mts",
+    "vitest-e2e": "glob --absolute 'test/**/*.test.js' 'test/**/*.test.ts' 'tests/**/*.test.js' 'tests/**/*.test.ts'"
   }
 }