refactor: route direct extension test targets

scripts/test-projects.mjs

@@ -1,8 +1,8 @@
+import fs from "node:fs";
 import { acquireLocalHeavyCheckLockSync } from "./lib/local-heavy-check-runtime.mjs";
 import { spawnPnpmRunner } from "./pnpm-runner.mjs";
-import { buildVitestArgs } from "./test-projects.test-support.mjs";
+import { createVitestRunSpecs, writeVitestIncludeFile } from "./test-projects.test-support.mjs";
 
-const vitestArgs = buildVitestArgs(process.argv.slice(2));
 const releaseLock = acquireLocalHeavyCheckLockSync({
   cwd: process.cwd(),
   env: process.env,
@@ -18,21 +18,62 @@ const releaseLockOnce = () => {
   releaseLock();
 };
 
-const child = spawnPnpmRunner({
-  pnpmArgs: vitestArgs,
-  env: process.env,
-});
-
-child.on("exit", (code, signal) => {
-  releaseLockOnce();
-  if (signal) {
-    process.kill(process.pid, signal);
+function cleanupVitestRunSpec(spec) {
+  if (!spec.includeFilePath) {
     return;
   }
-  process.exit(code ?? 1);
-});
+  try {
+    fs.rmSync(spec.includeFilePath, { force: true });
+  } catch {
+    // Best-effort cleanup for temp include lists.
+  }
+}
 
-child.on("error", (error) => {
+function runVitestSpec(spec) {
+  if (spec.includeFilePath && spec.includePatterns) {
+    writeVitestIncludeFile(spec.includeFilePath, spec.includePatterns);
+  }
+  return new Promise((resolve, reject) => {
+    const child = spawnPnpmRunner({
+      pnpmArgs: spec.pnpmArgs,
+      env: spec.env,
+    });
+
+    child.on("exit", (code, signal) => {
+      cleanupVitestRunSpec(spec);
+      resolve({ code: code ?? 1, signal });
+    });
+
+    child.on("error", (error) => {
+      cleanupVitestRunSpec(spec);
+      reject(error);
+    });
+  });
+}
+
+async function main() {
+  const runSpecs = createVitestRunSpecs(process.argv.slice(2), {
+    baseEnv: process.env,
+    cwd: process.cwd(),
+  });
+
+  for (const spec of runSpecs) {
+    const result = await runVitestSpec(spec);
+    if (result.signal) {
+      releaseLockOnce();
+      process.kill(process.pid, result.signal);
+      return;
+    }
+    if (result.code !== 0) {
+      releaseLockOnce();
+      process.exit(result.code);
+    }
+  }
+
+  releaseLockOnce();
+}
+
+main().catch((error) => {
   releaseLockOnce();
   console.error(error);
   process.exit(1);