@miaws/miaw 1.18.5 → 1.18.6

package/parsers-config.ts

@@ -1 +0,0 @@
-export { default } from "@miaw/tui/parsers-config"

package/script/bench-search.ts

@@ -1,94 +0,0 @@
-import { Effect } from "effect"
-import { Fff } from "@miaw/core/filesystem/fff.bun"
-import { AppRuntime } from "@/effect/app-runtime"
-import { FileSystem } from "@miaw/core/filesystem"
-import { AbsolutePath } from "@miaw/core/schema"
-import { InstanceStore } from "@/project/instance-store"
-
-const dir = AbsolutePath.make(process.cwd())
-
-const FILE_QUERIES = ["fff", "package.json", "tools/ experiment"]
-const GREP_QUERIES = ["FileFinder", "import", "grep", "autocomplete"]
-const GLOB_QUERIES = ["**/*.test.ts"]
-
-const FILE_LIMIT = 100
-const GREP_LIMIT = 50
-const GLOB_LIMIT = 50
-
-const run = <A, R>(effect: Effect.Effect<A, unknown, R>) =>
-  AppRuntime.runPromise(
-    InstanceStore.Service.use((store) => store.provide({ directory: dir }, effect as never)),
-  ) as Promise<A>
-
-// --- raw Fff picker ---
-const t0 = performance.now()
-const made = Fff.create({ basePath: dir, aiMode: true })
-if (!made.ok) {
-  console.error("Fff.create failed:", made.error)
-  process.exit(1)
-}
-const picker = made.value
-console.log(`picker create: ${(performance.now() - t0).toFixed(1)}ms`)
-
-const tw = performance.now()
-await picker.waitForScan(2_500)
-console.log(`wait for scan: ${(performance.now() - tw).toFixed(1)}ms`)
-
-// warmup grep to let the content index build
-const tWarmup = performance.now()
-picker.grep("_warmup_", { mode: "regex", maxMatchesPerFile: 1, timeBudgetMs: 1_500 })
-console.log(`grep warmup: ${(performance.now() - tWarmup).toFixed(1)}ms`)
-
-console.log()
-console.log("--- raw picker (warm) ---")
-
-for (const q of FILE_QUERIES) {
-  const t = performance.now()
-  const r = picker.fileSearch(q, { pageSize: Math.max(FILE_LIMIT, 100) })
-  const count = r.ok ? r.value.items.length : "err"
-  console.log(`[picker] fileSearch "${q}": ${(performance.now() - t).toFixed(1)}ms (${count} results)`)
-}
-
-for (const q of GREP_QUERIES) {
-  const t = performance.now()
-  const r = picker.grep(q, { mode: "regex", pageSize: GREP_LIMIT, timeBudgetMs: 1_500 })
-  const count = r.ok ? r.value.items.length : "err"
-  console.log(`[picker] grep "${q}": ${(performance.now() - t).toFixed(1)}ms (${count} matches)`)
-}
-
-picker.destroy()
-
-// --- Search service: init breakdown ---
-console.log()
-
-// 1) runtime + InstanceState + picker create + scan poll
-const tRuntime = performance.now()
-console.log(`[Search] init file (runtime + picker + scan): ${(performance.now() - tRuntime).toFixed(1)}ms`)
-
-// 2) grep warmup (content index cold-start inside the Search service picker)
-const tGrepWarmup = performance.now()
-await run(FileSystem.Service.use((svc) => svc.grep({ pattern: "_warmup_grep_", limit: 1 })))
-console.log(`[Search] init grep (content index warmup):    ${(performance.now() - tGrepWarmup).toFixed(1)}ms`)
-
-console.log()
-console.log("--- Search service (warm) ---")
-
-for (const q of FILE_QUERIES) {
-  const t = performance.now()
-  const r = await run(FileSystem.Service.use((svc) => svc.find({ query: q, limit: FILE_LIMIT })))
-  console.log(`[Search.find] "${q}": ${(performance.now() - t).toFixed(1)}ms (${r.length} results)`)
-}
-
-for (const q of GREP_QUERIES) {
-  const t = performance.now()
-  const r = await run(FileSystem.Service.use((svc) => svc.grep({ pattern: q, limit: GREP_LIMIT })))
-  console.log(`[Search.grep] "${q}": ${(performance.now() - t).toFixed(1)}ms (${r.length} matches)`)
-}
-
-for (const q of GLOB_QUERIES) {
-  const t = performance.now()
-  const r = await run(FileSystem.Service.use((svc) => svc.glob({ pattern: q, limit: GLOB_LIMIT })))
-  console.log(`[Search.glob] "${q}": ${(performance.now() - t).toFixed(1)}ms (${r.length} files)`)
-}
-
-process.exit(0)

package/script/bench-test-suite.ts

@@ -1,52 +0,0 @@
-// Full-suite timing harness for the test-speed research in ../../perf/test-suite.md.
-// Use this for periodic sanity checks; use profile-test-files.ts for discovery.
-// Env: BENCH_WARMUPS=0 BENCH_RUNS=1 bun run bench:test
-const warmups = Number(Bun.env.BENCH_WARMUPS ?? 0)
-const runs = Number(Bun.env.BENCH_RUNS ?? 1)
-const timings: number[] = []
-
-if (!Number.isInteger(warmups) || warmups < 0) {
-  console.error("BENCH_WARMUPS must be a non-negative integer")
-  process.exit(1)
-}
-if (!Number.isInteger(runs) || runs < 1) {
-  console.error("BENCH_RUNS must be a positive integer")
-  process.exit(1)
-}
-
-for (const index of Array.from({ length: warmups + runs }, (_, index) => index)) {
-  const measured = index >= warmups
-  const label = measured ? `run ${index - warmups + 1}/${runs}` : `warmup ${index + 1}/${warmups}`
-  const start = performance.now()
-  console.log(`bench:test ${label}`)
-
-  const proc = Bun.spawn(["bun", "test", "--timeout", "30000"], {
-    cwd: import.meta.dir + "/..",
-    stdout: "inherit",
-    stderr: "inherit",
-    env: Bun.env,
-  })
-
-  const exitCode = await proc.exited
-  if (exitCode !== 0) {
-    console.error(`bench:test failed during ${label} with exit code ${exitCode}`)
-    process.exit(exitCode)
-  }
-
-  const seconds = (performance.now() - start) / 1000
-  console.log(`bench:test ${label} ${seconds.toFixed(3)}s`)
-  if (measured) timings.push(seconds)
-}
-
-const sorted = timings.toSorted((a, b) => a - b)
-const median = sorted[Math.floor(sorted.length / 2)]
-const mean = timings.reduce((sum, timing) => sum + timing, 0) / timings.length
-const best = sorted[0] ?? median
-const worst = sorted.at(-1) ?? median
-
-console.log(
-  `bench:test median=${median.toFixed(3)}s mean=${mean.toFixed(3)}s best=${best.toFixed(3)}s worst=${worst.toFixed(3)}s`,
-)
-console.log(`METRIC test_suite_seconds=${median.toFixed(3)}`)
-console.log(`METRIC test_suite_best_seconds=${best.toFixed(3)}`)
-console.log(`METRIC test_suite_worst_seconds=${worst.toFixed(3)}`)

package/script/build.ts

@@ -1,243 +0,0 @@
-#!/usr/bin/env bun
-
-import { $ } from "bun"
-import fs from "fs"
-import path from "path"
-import { fileURLToPath } from "url"
-import { createSolidTransformPlugin } from "@opentui/solid/bun-plugin"
-
-const __filename = fileURLToPath(import.meta.url)
-const __dirname = path.dirname(__filename)
-const dir = path.resolve(__dirname, "..")
-
-process.chdir(dir)
-
-const generated = await import("./generate.ts")
-
-import { Script } from "@miaw/script"
-import pkg from "../package.json"
-
-const singleFlag = process.argv.includes("--single")
-const baselineFlag = process.argv.includes("--baseline")
-const skipInstall = process.argv.includes("--skip-install")
-const sourcemapsFlag = process.argv.includes("--sourcemaps")
-const plugin = createSolidTransformPlugin()
-const skipEmbedWebUi = process.argv.includes("--skip-embed-web-ui")
-
-const createEmbeddedWebUIBundle = async () => {
-  console.log(`Building Web UI to embed in the binary`)
-  const appDir = path.join(import.meta.dirname, "../../app")
-  const dist = path.join(appDir, "dist")
-  await $`MIAW_CHANNEL=${Script.channel} bun run --cwd ${appDir} build`
-  const files = (await Array.fromAsync(new Bun.Glob("**/*").scan({ cwd: dist })))
-    .map((file) => file.replaceAll("\\", "/"))
-    .filter((file) => !file.endsWith(".map"))
-    .sort()
-  const imports = files.map((file, i) => {
-    const spec = path.relative(dir, path.join(dist, file)).replaceAll("\\", "/")
-    return `import file_${i} from ${JSON.stringify(spec.startsWith(".") ? spec : `./${spec}`)} with { type: "file" };`
-  })
-  const entries = files.map((file, i) => `  ${JSON.stringify(file)}: file_${i},`)
-  return [
-    `// Import all files as file_$i with type: "file"`,
-    ...imports,
-    `// Export with original mappings`,
-    `export default {`,
-    ...entries,
-    `}`,
-  ].join("\n")
-}
-
-const embeddedFileMap = skipEmbedWebUi ? null : await createEmbeddedWebUIBundle()
-
-const allTargets: {
-  os: string
-  arch: "arm64" | "x64"
-  abi?: "musl"
-  avx2?: false
-}[] = [
-  {
-    os: "linux",
-    arch: "arm64",
-  },
-  {
-    os: "linux",
-    arch: "x64",
-  },
-  {
-    os: "linux",
-    arch: "x64",
-    avx2: false,
-  },
-  {
-    os: "linux",
-    arch: "arm64",
-    abi: "musl",
-  },
-  {
-    os: "linux",
-    arch: "x64",
-    abi: "musl",
-  },
-  {
-    os: "linux",
-    arch: "x64",
-    abi: "musl",
-    avx2: false,
-  },
-  {
-    os: "darwin",
-    arch: "arm64",
-  },
-  {
-    os: "darwin",
-    arch: "x64",
-  },
-  {
-    os: "darwin",
-    arch: "x64",
-    avx2: false,
-  },
-  {
-    os: "win32",
-    arch: "arm64",
-  },
-  {
-    os: "win32",
-    arch: "x64",
-  },
-  {
-    os: "win32",
-    arch: "x64",
-    avx2: false,
-  },
-]
-
-const targets = singleFlag
-  ? allTargets.filter((item) => {
-      if (item.os !== process.platform || item.arch !== process.arch) {
-        return false
-      }
-
-      // When building for the current platform, prefer a single native binary by default.
-      // Baseline binaries require additional Bun artifacts and can be flaky to download.
-      if (item.avx2 === false) {
-        return baselineFlag
-      }
-
-      // also skip abi-specific builds for the same reason
-      if (item.abi !== undefined) {
-        return false
-      }
-
-      return true
-    })
-  : allTargets
-
-await $`rm -rf dist`
-
-const binaries: Record<string, string> = {}
-if (!skipInstall) {
-  await $`bun install --os="*" --cpu="*" @opentui/core@${pkg.dependencies["@opentui/core"]}`
-  await $`bun install --os="*" --cpu="*" @parcel/watcher@${pkg.dependencies["@parcel/watcher"]}`
-  await $`bun install --os="*" --cpu="*" @ff-labs/fff-bun@${pkg.dependencies["@ff-labs/fff-bun"]}`
-}
-for (const item of targets) {
-  const name = [
-    pkg.name,
-    // changing to win32 flags npm for some reason
-    item.os === "win32" ? "windows" : item.os,
-    item.arch,
-    item.avx2 === false ? "baseline" : undefined,
-    item.abi === undefined ? undefined : item.abi,
-  ]
-    .filter(Boolean)
-    .join("-")
-  console.log(`building ${name}`)
-  await $`mkdir -p dist/${name}/bin`
-
-  const localPath = path.resolve(dir, "node_modules/@opentui/core/parser.worker.js")
-  const rootPath = path.resolve(dir, "../../node_modules/@opentui/core/parser.worker.js")
-  const parserWorker = fs.realpathSync(fs.existsSync(localPath) ? localPath : rootPath)
-  const workerPath = "./src/cli/tui/worker.ts"
-
-  // Use platform-specific bunfs root path based on target OS
-  const bunfsRoot = item.os === "win32" ? "B:/~BUN/root/" : "/$bunfs/root/"
-  const workerRelativePath = path.relative(dir, parserWorker).replaceAll("\\", "/")
-
-  await Bun.build({
-    conditions: ["bun", "node"],
-    tsconfig: "./tsconfig.json",
-    plugins: [plugin],
-    external: ["node-gyp"],
-    format: "esm",
-    minify: true,
-    sourcemap: sourcemapsFlag ? "linked" : "none",
-    splitting: true,
-    compile: {
-      autoloadBunfig: false,
-      autoloadDotenv: false,
-      autoloadTsconfig: true,
-      autoloadPackageJson: true,
-      target: name.replace(pkg.name, "bun") as any,
-      outfile: `dist/${name}/bin/miaw`,
-      execArgv: [`--user-agent=miaw/${Script.version}`, "--use-system-ca", "--"],
-      windows: {},
-    },
-    files: embeddedFileMap ? { "miaw-web-ui.gen.ts": embeddedFileMap } : {},
-    entrypoints: ["./src/index.ts", parserWorker, workerPath, ...(embeddedFileMap ? ["miaw-web-ui.gen.ts"] : [])],
-    define: {
-      FFF_LIBC: JSON.stringify(item.abi === "musl" ? "musl" : "gnu"),
-      MIAW_VERSION: `'${Script.version}'`,
-      MIAW_MODELS_DEV: generated.modelsData,
-      OTUI_TREE_SITTER_WORKER_PATH: bunfsRoot + workerRelativePath,
-      MIAW_WORKER_PATH: workerPath,
-      MIAW_CHANNEL: `'${Script.channel}'`,
-      MIAW_LIBC: item.os === "linux" ? `'${item.abi ?? "glibc"}'` : "",
-      ...(item.os === "linux" ? { "process.env.OPENTUI_LIBC": JSON.stringify(item.abi ?? "glibc") } : {}),
-    },
-  })
-
-  // Smoke test: only run if binary is for current platform
-  if (item.os === process.platform && item.arch === process.arch && !item.abi) {
-    const binaryPath = `dist/${name}/bin/miaw`
-    console.log(`Running smoke test: ${binaryPath} --version`)
-    try {
-      const versionOutput = await $`${binaryPath} --version`.text()
-      console.log(`Smoke test passed: ${versionOutput.trim()}`)
-    } catch (e) {
-      console.error(`Smoke test failed for ${name}:`, e)
-      process.exit(1)
-    }
-  }
-
-  await $`rm -rf ./dist/${name}/bin/tui`
-  await Bun.file(`dist/${name}/package.json`).write(
-    JSON.stringify(
-      {
-        name,
-        version: Script.version,
-        preferUnplugged: true,
-        os: [item.os],
-        cpu: [item.arch],
-        ...(item.abi ? { libc: [item.abi] } : {}),
-      },
-      null,
-      2,
-    ),
-  )
-  binaries[name] = Script.version
-}
-
-if (Script.release) {
-  for (const key of Object.keys(binaries)) {
-    if (key.includes("linux")) {
-      await $`tar -czf ../../${key}.tar.gz *`.cwd(`dist/${key}/bin`)
-    } else {
-      await $`zip -r ../../${key}.zip *`.cwd(`dist/${key}/bin`)
-    }
-  }
-  await $`gh release upload v${Script.version} ./dist/*.zip ./dist/*.tar.gz --clobber --repo ${process.env.GH_REPO}`
-}
-
-export { binaries }

package/script/generate.ts

@@ -1,14 +0,0 @@
-import path from "path"
-import { fileURLToPath } from "url"
-
-const __filename = fileURLToPath(import.meta.url)
-const __dirname = path.dirname(__filename)
-const dir = path.resolve(__dirname, "..")
-
-process.chdir(dir)
-
-const modelsUrl = process.env.MIAW_MODELS_URL || "https://models.dev"
-export const modelsData = process.env.MODELS_DEV_API_JSON
-  ? await Bun.file(process.env.MODELS_DEV_API_JSON).text()
-  : await fetch(`${modelsUrl}/api.json`).then((x) => x.text())
-console.log("Loaded models.dev snapshot")

package/script/httpapi-exercise.ts

@@ -1 +0,0 @@
-await import("../test/server/httpapi-exercise/index")

package/script/postinstall.mjs

@@ -1,189 +0,0 @@
-#!/usr/bin/env node
-
-import childProcess from "child_process"
-import fs from "fs"
-import os from "os"
-import path from "path"
-import { createRequire } from "module"
-import { fileURLToPath } from "url"
-
-const __dirname = path.dirname(fileURLToPath(import.meta.url))
-const require = createRequire(import.meta.url)
-const packageJson = JSON.parse(fs.readFileSync(path.join(__dirname, "package.json"), "utf8"))
-
-const platformMap = {
-  darwin: "darwin",
-  linux: "linux",
-  win32: "windows",
-}
-const archMap = {
-  x64: "x64",
-  arm64: "arm64",
-  arm: "arm",
-}
-
-const platform = platformMap[os.platform()] ?? os.platform()
-const arch = archMap[os.arch()] ?? os.arch()
-const base = `miaw-${platform}-${arch}`
-const sourceBinary = platform === "windows" ? "miaw.exe" : "miaw"
-const targetBinary = path.join(__dirname, "bin", "miaw.exe")
-
-function supportsAvx2() {
-  if (arch !== "x64") return false
-
-  if (platform === "linux") {
-    try {
-      return /(^|\s)avx2(\s|$)/i.test(fs.readFileSync("/proc/cpuinfo", "utf8"))
-    } catch {
-      return false
-    }
-  }
-
-  if (platform === "darwin") {
-    try {
-      const result = childProcess.spawnSync("sysctl", ["-n", "hw.optional.avx2_0"], {
-        encoding: "utf8",
-        timeout: 1500,
-      })
-      if (result.status !== 0) return false
-      return (result.stdout || "").trim() === "1"
-    } catch {
-      return false
-    }
-  }
-
-  if (platform === "windows") {
-    const command =
-      '(Add-Type -MemberDefinition "[DllImport(""kernel32.dll"")] public static extern bool IsProcessorFeaturePresent(int ProcessorFeature);" -Name Kernel32 -Namespace Win32 -PassThru)::IsProcessorFeaturePresent(40)'
-
-    for (const executable of ["powershell.exe", "pwsh.exe", "pwsh", "powershell"]) {
-      try {
-        const result = childProcess.spawnSync(executable, ["-NoProfile", "-NonInteractive", "-Command", command], {
-          encoding: "utf8",
-          timeout: 3000,
-          windowsHide: true,
-        })
-        if (result.status !== 0) continue
-        const output = (result.stdout || "").trim().toLowerCase()
-        if (output === "true" || output === "1") return true
-        if (output === "false" || output === "0") return false
-      } catch {
-        continue
-      }
-    }
-  }
-
-  return false
-}
-
-function isMusl() {
-  if (platform !== "linux") return false
-
-  try {
-    if (fs.existsSync("/etc/alpine-release")) return true
-  } catch {
-    // Ignore filesystem probes that are blocked by the host.
-  }
-
-  try {
-    const result = childProcess.spawnSync("ldd", ["--version"], { encoding: "utf8" })
-    return `${result.stdout || ""}${result.stderr || ""}`.toLowerCase().includes("musl")
-  } catch {
-    return false
-  }
-}
-
-function packageNames() {
-  const baseline = arch === "x64" && !supportsAvx2()
-
-  if (platform === "linux") {
-    if (isMusl()) {
-      if (arch === "x64")
-        return baseline
-          ? [`${base}-baseline-musl`, `${base}-musl`, `${base}-baseline`, base]
-          : [`${base}-musl`, `${base}-baseline-musl`, base, `${base}-baseline`]
-      return [`${base}-musl`, base]
-    }
-
-    if (arch === "x64")
-      return baseline
-        ? [`${base}-baseline`, base, `${base}-baseline-musl`, `${base}-musl`]
-        : [base, `${base}-baseline`, `${base}-musl`, `${base}-baseline-musl`]
-    return [base, `${base}-musl`]
-  }
-
-  if (arch === "x64") return baseline ? [`${base}-baseline`, base] : [base, `${base}-baseline`]
-  return [base]
-}
-
-function resolveBinary(name) {
-  const packageJsonPath = require.resolve(`${name}/package.json`)
-  const binaryPath = path.join(path.dirname(packageJsonPath), "bin", sourceBinary)
-  if (!fs.existsSync(binaryPath)) throw new Error(`Binary not found at ${binaryPath}`)
-  return binaryPath
-}
-
-function installPackage(name) {
-  const version = packageJson.optionalDependencies?.[name]
-  if (!version) return
-
-  const temp = fs.mkdtempSync(path.join(os.tmpdir(), "miaw-install-"))
-  try {
-    const result = childProcess.spawnSync(
-      "npm",
-      ["install", "--ignore-scripts", "--no-save", "--loglevel=error", "--prefix", temp, `${name}@${version}`],
-      { stdio: "inherit", windowsHide: true },
-    )
-    if (result.status !== 0) return
-    const packageDir = path.join(temp, "node_modules", name)
-    copyBinary(path.join(packageDir, "bin", sourceBinary), targetBinary)
-    return true
-  } finally {
-    fs.rmSync(temp, { recursive: true, force: true })
-  }
-}
-
-function copyBinary(source, target) {
-  if (!fs.existsSync(source)) throw new Error(`Binary not found at ${source}`)
-  fs.mkdirSync(path.dirname(target), { recursive: true })
-  if (fs.existsSync(target)) fs.unlinkSync(target)
-  try {
-    fs.linkSync(source, target)
-  } catch {
-    fs.copyFileSync(source, target)
-  }
-  fs.chmodSync(target, 0o755)
-}
-
-function verifyBinary() {
-  const result = childProcess.spawnSync(targetBinary, ["--version"], {
-    encoding: "utf8",
-    stdio: "ignore",
-    windowsHide: true,
-  })
-  return result.status === 0
-}
-
-function main() {
-  for (const name of packageNames()) {
-    try {
-      copyBinary(resolveBinary(name), targetBinary)
-      if (verifyBinary()) return
-    } catch {
-      if (installPackage(name) && verifyBinary()) return
-    }
-  }
-
-  throw new Error(
-    `It seems your package manager failed to install the right miaw CLI package. Try manually installing ${packageNames()
-      .map((name) => JSON.stringify(name))
-      .join(" or ")}.`,
-  )
-}
-
-try {
-  main()
-} catch (error) {
-  console.error(error.message)
-  process.exit(1)
-}

package/script/profile-test-files.ts

@@ -1,42 +0,0 @@
-// Per-file profiler for finding candidate test-speed work; see ../../perf/test-suite.md
-// for the benchmark notes, kept wins, and discarded experiments.
-// Example: TEST_PROFILE_GLOB='test/server/**/*.test.ts' TEST_PROFILE_TOP=15 bun run profile:test
-const pattern = Bun.env.TEST_PROFILE_GLOB ?? "test/**/*.test.{ts,tsx}"
-const limit = Number(Bun.env.TEST_PROFILE_LIMIT ?? 0)
-const timeout = Bun.env.TEST_PROFILE_TIMEOUT ?? "30000"
-const files = Array.fromAsync(new Bun.Glob(pattern).scan({ cwd: import.meta.dir + "/..", onlyFiles: true }))
-  .then((files) => files.toSorted())
-  .then((files) => (limit > 0 ? files.slice(0, limit) : files))
-
-const results = []
-for (const file of await files) {
-  const start = performance.now()
-  const proc = Bun.spawn(["bun", "test", "--timeout", timeout, file], {
-    cwd: import.meta.dir + "/..",
-    stdout: "pipe",
-    stderr: "pipe",
-    env: Bun.env,
-  })
-  const [output, error, exitCode] = await Promise.all([
-    new Response(proc.stdout).text(),
-    new Response(proc.stderr).text(),
-    proc.exited,
-  ])
-  const seconds = (performance.now() - start) / 1000
-  results.push({ file, seconds, exitCode })
-  console.log(`${exitCode === 0 ? "PASS" : "FAIL"} ${seconds.toFixed(3)}s ${file}`)
-  if (exitCode !== 0) console.log((output + error).trim())
-}
-
-const sorted = results.toSorted((a, b) => b.seconds - a.seconds)
-console.log("\nSlowest test files:")
-for (const result of sorted.slice(0, Number(Bun.env.TEST_PROFILE_TOP ?? 20))) {
-  console.log(`${result.seconds.toFixed(3)}s ${result.exitCode === 0 ? "PASS" : "FAIL"} ${result.file}`)
-}
-
-if (sorted[0]) {
-  console.log(`METRIC slowest_test_file_seconds=${sorted[0].seconds.toFixed(3)}`)
-  console.log(`METRIC profiled_test_files=${results.length}`)
-}
-
-if (results.some((result) => result.exitCode !== 0)) process.exit(1)