@elench/testkit 0.1.21 → 0.1.23

package/README.md

@@ -1,11 +1,10 @@
 # @elench/testkit
 
-CLI that reads `testkit.config.json` from a product repo, discovers `*.testkit.ts` files by convention, starts the required local services, provisions local Postgres isolation, and runs suites across `k6` and Playwright.
+CLI that reads `testkit.config.json` from a product repo, discovers `*.testkit.ts` files by convention, starts the required local services, provisions local Postgres isolation, and runs HTTP, DAL, and Playwright suites.
 
 ## Prerequisites
 
-`@elench/testkit` ships its own `k6` binary and uses it for both HTTP and DAL suites by default.
-If you need to force a different binary, set `TESTKIT_K6_BIN` to an absolute or relative path.
+`@elench/testkit` ships its own execution engine for HTTP and DAL suites. Consumers do not need to install or invoke any separate load-testing binary.
 
 Database isolation uses Docker-managed local Postgres containers. `testkit` creates and reuses template databases automatically, then clones per-worker databases from those templates for fast reruns. The default image is `pgvector/pgvector:pg16`.
 
@@ -24,7 +23,7 @@ npx @elench/testkit e2e
 
 # Filter by framework
 npx @elench/testkit --framework playwright
-npx @elench/testkit --framework k6
+npx @elench/testkit --framework default
 
 # Parallelize with isolated worker stacks
 npx @elench/testkit --jobs 3
@@ -48,9 +47,9 @@ npx @elench/testkit status
 npx @elench/testkit destroy
 ```
 
-## K6 Authoring
+## Authoring
 
-Consumer k6 tests can import the shared authoring API directly from the package:
+Consumer tests can import the shared authoring API directly from the package:
 
 ```js
 import { defineHttpSuite } from "@elench/testkit";
@@ -76,15 +75,15 @@ const suite = defineHttpSuite({ auth: clerkSessionAuth }, ({ req, setupData }) =
 });
 ```
 
-`testkit` bundles these imports before invoking k6, so tests do not need
-generated `_testkit` files or direct package-manager path imports.
+Low-level runtime primitives are also available without exposing the underlying engine:
 
-If you need to override the packaged `k6` binary for local environment reasons:
-
-```bash
-TESTKIT_K6_BIN=/path/to/k6 npx @elench/testkit int
+```js
+import { check, group, http } from "@elench/testkit/runtime";
 ```
 
+`testkit` bundles these imports before execution, so tests do not need
+generated `_testkit` files, direct package-manager path imports, or any separate engine installation.
+
 Legacy compatibility:
 
 - `testkit runtime install`
@@ -104,12 +103,12 @@ npx @elench/testkit --dir my-product api int -s health
 
 1. **Discovery** — reads `testkit.config.json` for services, then discovers files by suffix:
    `*.int.testkit.ts`, `*.e2e.testkit.ts`, `*.dal.testkit.ts`, `*.load.testkit.ts`, `*.pw.testkit.ts`
-2. **Config** — reads `testkit.config.json` for local runtime, migration, dependency, database, and discovery settings
+2. **Config** — reads `testkit.config.json` for local runtime, migration, dependency, and database settings
    Per-service `.env` files declared in config are loaded when present.
 3. **Database** — provisions Docker-managed local Postgres when a service declares one
 4. **Seed** — runs optional product seed commands against the provisioned database
 5. **Runtime** — starts required local services, waits for readiness, and injects test env
-6. **Execution** — schedules file-level execution tasks across a global worker pool, reuses warm dependency graphs when possible, bundles `k6` files before execution so package imports resolve cleanly, and batches Playwright files per worker
+6. **Execution** — schedules file-level execution tasks across a global worker pool, reuses warm dependency graphs when possible, bundles test files before execution so package imports resolve cleanly, and batches Playwright files per worker
 7. **Cleanup** — stops local processes and preserves `.testkit/` state for inspection or later destroy
 
 Each run ends with a compact summary that shows per-service pass/fail status, suite totals, failed suites, and total duration.
@@ -124,7 +123,7 @@ Each run ends with a compact summary that shows per-service pass/fail status, su
 `testkit.config.json` can also declare:
 
 - `telemetry` for optional generic HTTP result upload
-- `discovery.include` / `discovery.exclude` for per-service test discovery
+- no test registration in config; `testkit` discovers `*.testkit.ts` files from the filesystem automatically
 - `envFile` / `envFiles` for service-specific environment loading
 - `databaseFrom` for dependency services that must share another service's `DATABASE_URL`
 - `database.provider` for local Postgres settings

package/lib/bundler/index.mjs

@@ -7,8 +7,7 @@ import { fileURLToPath } from "url";
 
 const PACKAGE_ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..", "..");
 const ROOT_ENTRY = path.join(PACKAGE_ROOT, "lib", "index.mjs");
-const K6_ENTRY = path.join(PACKAGE_ROOT, "lib", "k6", "index.mjs");
-const K6_DIR = path.join(PACKAGE_ROOT, "lib", "k6");
+const RUNTIME_ENTRY = path.join(PACKAGE_ROOT, "lib", "runtime", "index.mjs");
 const bundleCache = new Map();
 
 export async function bundleK6File({
@@ -82,14 +81,7 @@ function testkitPackageAliasPlugin() {
 function resolvePackageSubpath(specifier) {
   const subpath = specifier.slice("@elench/testkit".length);
   if (!subpath) return ROOT_ENTRY;
-  if (subpath === "/k6") return K6_ENTRY;
-  if (subpath.startsWith("/k6/")) {
-    const rel = subpath.slice("/k6/".length);
-    const candidate = path.join(K6_DIR, `${rel}.mjs`);
-    if (fs.existsSync(candidate)) {
-      return candidate;
-    }
-  }
+  if (subpath === "/runtime") return RUNTIME_ENTRY;
 
   throw new Error(`Unsupported @elench/testkit import "${specifier}" in ${os.platform()}`);
 }

package/lib/bundler/index.test.mjs

@@ -12,8 +12,8 @@ afterEach(() => {
   }
 });
 
-describe("k6 bundler", () => {
-  it("bundles root package imports for k6 execution", async () => {
+describe("runtime bundler", () => {
+  it("bundles root and runtime package imports for execution", async () => {
     const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "testkit-bundle-"));
     cleanups.push(() => fs.rmSync(tmpDir, { force: true, recursive: true }));
 
@@ -21,8 +21,8 @@ describe("k6 bundler", () => {
     fs.writeFileSync(
       sourceFile,
       [
-        'import { defineHttpSuite, json } from "@elench/testkit";',
-        'import { check } from "k6";',
+        'import { defineHttpSuite } from "@elench/testkit";',
+        'import { check, json } from "@elench/testkit/runtime";',
         "const suite = defineHttpSuite(({ rawReq }) => {",
         '  const res = rawReq("GET", "/health");',
         "  check(json(res), {",
@@ -44,10 +44,11 @@ describe("k6 bundler", () => {
 
     const bundled = fs.readFileSync(bundledFile, "utf8");
     expect(bundled).toContain("defineHttpSuite");
-    expect(bundled).toContain('import { check } from "k6"');
+    expect(bundled).toContain('import { check');
+    expect(bundled).toContain('from "k6"');
   });
 
-  it("bundles subpath package imports for DAL execution", async () => {
+  it("bundles DAL execution through the public package surface", async () => {
     const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "testkit-bundle-"));
     cleanups.push(() => fs.rmSync(tmpDir, { force: true, recursive: true }));
 
@@ -55,7 +56,7 @@ describe("k6 bundler", () => {
     fs.writeFileSync(
       sourceFile,
       [
-        'import { defineDalSuite } from "@elench/testkit/k6";',
+        'import { defineDalSuite } from "@elench/testkit";',
         "const suite = defineDalSuite(({ db }) => {",
         '  db.query("SELECT 1");',
         "});",

package/lib/cli/args.mjs

@@ -22,11 +22,12 @@ export function resolveCliSelection({ first, second, serviceNames }) {
 }
 
 export function validateFrameworkOption(value) {
-  if (!["all", "k6", "playwright"].includes(value)) {
+  if (!["all", "default", "playwright"].includes(value)) {
     throw new Error(
-      `Unknown framework "${value}". Expected one of: all, k6, playwright.`
+      `Unknown framework "${value}". Expected one of: all, default, playwright.`
     );
   }
+  return value === "default" ? "k6" : value;
 }
 
 export function parseJobsOption(value) {

package/lib/cli/args.test.mjs

@@ -44,7 +44,8 @@ describe("cli-args", () => {
   });
 
   it("validates framework names", () => {
-    expect(() => validateFrameworkOption("playwright")).not.toThrow();
+    expect(validateFrameworkOption("playwright")).toBe("playwright");
+    expect(validateFrameworkOption("default")).toBe("k6");
     expect(() => validateFrameworkOption("jest")).toThrow("Unknown framework");
   });
 

package/lib/cli/index.mjs

@@ -8,7 +8,6 @@ import {
   validateFrameworkOption,
 } from "./args.mjs";
 import * as runner from "../runner/index.mjs";
-import * as runtime from "../runtime/index.mjs";
 
 export function run() {
   const cli = cac("testkit");
@@ -18,11 +17,13 @@ export function run() {
     .option("--dir <path>", "Explicit product directory")
     .option("--path <path>", "Target runtime path relative to the product directory")
     .option("--strict", "Exit non-zero when runtime status is missing or drifted")
-    .action((action, options) => {
+    .action(async (action, options) => {
       if (!["install", "status", "update"].includes(action)) {
         throw new Error('Unknown runtime action. Expected one of: install, status, update.');
       }
 
+      const runtime = await import("../runtime-manager/index.mjs");
+
       if (action === "status") {
         const status = runtime.getRuntimeStatus(options);
         console.log(runtime.formatRuntimeStatus(status));
@@ -47,7 +48,7 @@ export function run() {
       default: "1",
     })
     .option("--shard <i/n>", "Run only shard i of n at suite granularity")
-    .option("--framework <name>", "Filter by framework (k6, playwright, all)", {
+    .option("--framework <name>", "Filter by framework (default, playwright, all)", {
       default: "all",
     })
     .option("--write-status", "Write a deterministic testkit.status.json snapshot")
@@ -91,7 +92,7 @@ export function run() {
         return;
       }
 
-      validateFrameworkOption(options.framework);
+      const framework = validateFrameworkOption(options.framework);
 
       const jobs = parseJobsOption(options.jobs);
       const shard = parseShardOption(options.shard);
@@ -105,6 +106,7 @@ export function run() {
         suiteNames,
         {
           ...options,
+          framework,
           fileNames,
           jobs,
           shard,

package/lib/config/discovery.mjs

@@ -9,148 +9,189 @@ const DISCOVERY_RULES = [
   { suffix: ".pw.testkit.ts", type: "e2e", framework: "playwright" },
 ];
 
-export function discoverServiceSuites(productDir, serviceName, serviceConfig) {
-  const include = serviceConfig.discovery?.include || [];
-  const exclude = serviceConfig.discovery?.exclude || [];
-  const grouped = {};
-  const seen = new Set();
-
-  for (const pattern of include) {
-    const normalizedPattern = normalizePath(pattern);
-    const patternInfo = compilePattern(normalizedPattern);
-    const rootDir = path.resolve(productDir, patternInfo.baseDir);
-    if (!fs.existsSync(rootDir)) continue;
-
-    for (const relativeFile of walkFiles(productDir, rootDir)) {
-      const normalizedFile = normalizePath(relativeFile);
-      if (!patternInfo.regex.test(normalizedFile)) continue;
-      if (exclude.some((candidate) => compilePattern(normalizePath(candidate)).regex.test(normalizedFile))) {
-        continue;
-      }
-      if (seen.has(normalizedFile)) continue;
+const IGNORED_DIRS = new Set([
+  ".cache",
+  ".git",
+  ".hg",
+  ".next",
+  ".nuxt",
+  ".playwright-browsers",
+  ".svn",
+  ".testkit",
+  ".turbo",
+  "build",
+  "coverage",
+  "dist",
+  "node_modules",
+  "playwright-report",
+  "test-results",
+]);
+
+export function discoverSuites(productDir, services) {
+  const serviceEntries = Object.entries(services || {});
+  const rules = serviceEntries.map(([serviceName, serviceConfig]) =>
+    buildServiceRule(serviceName, serviceConfig)
+  );
+  const groupedByService = Object.fromEntries(
+    serviceEntries.map(([serviceName]) => [serviceName, {}])
+  );
+  const discoveredFiles = discoverFiles(productDir);
+  const unowned = [];
+  const ambiguous = [];
+
+  for (const filePath of discoveredFiles) {
+    const rule = inferRule(filePath);
+    if (!rule) continue;
+
+    const matches = rules
+      .filter((serviceRule) => ownsFile(serviceRule, filePath))
+      .map((serviceRule) => serviceRule.name);
+
+    if (matches.length === 0) {
+      unowned.push(filePath);
+      continue;
+    }
 
-      const rule = inferRule(normalizedFile);
-      if (!rule) continue;
+    if (matches.length > 1) {
+      ambiguous.push({
+        filePath,
+        serviceNames: matches.sort((left, right) => left.localeCompare(right)),
+      });
+      continue;
+    }
 
-      const typeSuites = grouped[rule.type] || [];
-      typeSuites.push({
-        name: buildSuiteName(normalizedFile, rule.suffix, patternInfo.baseDir),
-        files: [normalizedFile],
+    const serviceName = matches[0];
+    const serviceRule = rules.find((candidate) => candidate.name === serviceName);
+    const relativeToService = relativeToServiceRoot(serviceRule, filePath);
+    const suiteName = deriveSuiteName(relativeToService, rule.suffix);
+    const grouped = groupedByService[serviceName];
+    const suitesForType = grouped[rule.type] || [];
+    let suite = suitesForType.find(
+      (candidate) => candidate.name === suiteName && candidate.framework === rule.framework
+    );
+
+    if (!suite) {
+      suite = {
+        name: suiteName,
+        files: [],
         framework: rule.framework,
-      });
-      grouped[rule.type] = typeSuites;
-      seen.add(normalizedFile);
+      };
+      suitesForType.push(suite);
+      grouped[rule.type] = suitesForType;
     }
-  }
 
-  for (const suites of Object.values(grouped)) {
-    suites.sort((left, right) => left.files[0].localeCompare(right.files[0]));
+    suite.files.push(filePath);
   }
 
-  return grouped;
-}
+  if (unowned.length > 0 || ambiguous.length > 0) {
+    throw buildDiscoveryError(unowned, ambiguous);
+  }
 
-function inferRule(filePath) {
-  return DISCOVERY_RULES.find((rule) => filePath.endsWith(rule.suffix)) || null;
-}
+  for (const grouped of Object.values(groupedByService)) {
+    for (const suites of Object.values(grouped)) {
+      for (const suite of suites) {
+        suite.files.sort((left, right) => left.localeCompare(right));
+      }
+      suites.sort((left, right) => left.name.localeCompare(right.name));
+    }
+  }
 
-function buildSuiteName(filePath, suffix, baseDir) {
-  const normalizedBase = normalizePath(baseDir);
-  const relativeToBase =
-    normalizedBase === "." || normalizedBase.length === 0
-      ? filePath
-      : path.posix.relative(normalizedBase, filePath);
-  const candidate = relativeToBase.length > 0 ? relativeToBase : path.posix.basename(filePath);
-  return candidate.slice(0, -suffix.length);
+  return groupedByService;
 }
 
-function walkFiles(productDir, rootDir) {
-  const rootStats = fs.statSync(rootDir);
-  if (rootStats.isFile()) {
-    return [normalizePath(path.relative(productDir, rootDir))];
-  }
-
+function discoverFiles(productDir) {
   const files = [];
-  const queue = [rootDir];
+  const queue = [productDir];
 
   while (queue.length > 0) {
     const current = queue.pop();
     for (const entry of fs.readdirSync(current, { withFileTypes: true })) {
-      const absolute = path.join(current, entry.name);
+      const absolutePath = path.join(current, entry.name);
+
+      if (entry.isSymbolicLink()) continue;
+
       if (entry.isDirectory()) {
-        queue.push(absolute);
+        if (IGNORED_DIRS.has(entry.name)) continue;
+        queue.push(absolutePath);
         continue;
       }
+
       if (!entry.isFile()) continue;
-      files.push(normalizePath(path.relative(productDir, absolute)));
+
+      const relativePath = normalizePath(path.relative(productDir, absolutePath));
+      if (inferRule(relativePath)) files.push(relativePath);
     }
   }
 
   return files.sort((left, right) => left.localeCompare(right));
 }
 
-function compilePattern(pattern) {
-  const baseDir = patternBase(pattern);
+function buildServiceRule(serviceName, serviceConfig) {
+  const testPrefix = normalizePath(path.posix.join("tests", serviceName));
+  const cwd = normalizePath(serviceConfig?.local?.cwd || ".");
   return {
-    baseDir,
-    regex: globToRegExp(pattern),
+    name: serviceName,
+    testPrefix,
+    cwdPrefix: cwd === "." ? null : cwd,
   };
 }
 
-function patternBase(pattern) {
-  const parts = pattern.split("/");
-  const baseParts = [];
+function ownsFile(serviceRule, filePath) {
+  if (hasPrefix(filePath, serviceRule.testPrefix)) return true;
+  if (serviceRule.cwdPrefix && hasPrefix(filePath, serviceRule.cwdPrefix)) return true;
+  return false;
+}
 
-  for (const part of parts) {
-    if (/[?*\[]/.test(part)) break;
-    baseParts.push(part);
+function relativeToServiceRoot(serviceRule, filePath) {
+  if (hasPrefix(filePath, serviceRule.testPrefix)) {
+    return path.posix.relative(serviceRule.testPrefix, filePath);
   }
-
-  return baseParts.length > 0 ? baseParts.join("/") : ".";
+  if (serviceRule.cwdPrefix && hasPrefix(filePath, serviceRule.cwdPrefix)) {
+    return path.posix.relative(serviceRule.cwdPrefix, filePath);
+  }
+  return filePath;
 }
 
-function globToRegExp(pattern) {
-  let source = "^";
-
-  for (let index = 0; index < pattern.length; index += 1) {
-    const current = pattern[index];
-    const next = pattern[index + 1];
-    const afterNext = pattern[index + 2];
-
-    if (current === "*" && next === "*" && afterNext === "/") {
-      source += "(?:.*/)?";
-      index += 2;
-      continue;
-    }
+function deriveSuiteName(relativePath, suffix) {
+  const parts = relativePath.split("/").filter(Boolean);
+  if (parts.length >= 3) return parts[1];
+  return path.posix.basename(relativePath, suffix);
+}
 
-    if (current === "*" && next === "*") {
-      source += ".*";
-      index += 1;
-      continue;
-    }
+function buildDiscoveryError(unowned, ambiguous) {
+  const lines = ["Filesystem discovery failed for one or more .testkit.ts files."];
 
-    if (current === "*") {
-      source += "[^/]*";
-      continue;
+  if (unowned.length > 0) {
+    lines.push("");
+    lines.push("Unowned test files:");
+    for (const filePath of unowned) {
+      lines.push(`- ${filePath}`);
     }
+  }
 
-    if (current === "?") {
-      source += "[^/]";
-      continue;
+  if (ambiguous.length > 0) {
+    lines.push("");
+    lines.push("Ambiguous test files:");
+    for (const entry of ambiguous) {
+      lines.push(`- ${entry.filePath} -> ${entry.serviceNames.join(", ")}`);
     }
+  }
 
-    if ("\\.[]{}()+-^$|".includes(current)) {
-      source += `\\${current}`;
-      continue;
-    }
+  lines.push("");
+  lines.push('Expected test files to live under "tests/<service>/..." or a non-root service local.cwd directory.');
+  return new Error(lines.join("\n"));
+}
 
-    source += current;
-  }
+function inferRule(filePath) {
+  return DISCOVERY_RULES.find((rule) => filePath.endsWith(rule.suffix)) || null;
+}
 
-  source += "$";
-  return new RegExp(source);
+function hasPrefix(filePath, prefix) {
+  return filePath === prefix || filePath.startsWith(`${prefix}/`);
 }
 
 function normalizePath(value) {
-  return value.split(path.sep).join("/");
+  const normalized = String(value).split(path.sep).join("/");
+  if (normalized === "." || normalized === "./") return ".";
+  return normalized.replace(/^\.\/+/, "").replace(/\/+$/, "") || ".";
 }

package/lib/config/discovery.test.mjs

@@ -2,7 +2,7 @@ import fs from "fs";
 import os from "os";
 import path from "path";
 import { afterEach, describe, expect, it } from "vitest";
-import { discoverServiceSuites } from "./discovery.mjs";
+import { discoverSuites } from "./discovery.mjs";
 
 const cleanups = [];
 
@@ -12,33 +12,91 @@ afterEach(() => {
   }
 });
 
-describe("config-discovery", () => {
-  it("discovers exact-file includes with stable suite names", () => {
+describe("filesystem-discovery", () => {
+  it("discovers tests by convention without config registration", () => {
     const productDir = fs.mkdtempSync(path.join(os.tmpdir(), "testkit-discovery-"));
     cleanups.push(() => fs.rmSync(productDir, { recursive: true, force: true }));
 
-    const filePath = path.join(
-      productDir,
-      "tests",
-      "api",
-      "integration",
-      "health.int.testkit.ts"
-    );
-    fs.mkdirSync(path.dirname(filePath), { recursive: true });
-    fs.writeFileSync(filePath, "export {};\n");
-
-    const suites = discoverServiceSuites(productDir, "api", {
-      discovery: {
-        include: ["tests/api/integration/health.int.testkit.ts"],
+    writeFile(productDir, "tests/api/integration/health.int.testkit.ts");
+    writeFile(productDir, "tests/api/integration/auth/me.int.testkit.ts");
+    writeFile(productDir, "frontend/e2e/homepage.pw.testkit.ts");
+
+    const suites = discoverSuites(productDir, {
+      api: {
+        local: {
+          cwd: ".",
+        },
+      },
+      frontend: {
+        local: {
+          cwd: "frontend",
+        },
       },
     });
 
-    expect(suites.integration).toEqual([
+    expect(suites.api.integration).toEqual([
+      {
+        name: "auth",
+        files: ["tests/api/integration/auth/me.int.testkit.ts"],
+        framework: "k6",
+      },
       {
         name: "health",
         files: ["tests/api/integration/health.int.testkit.ts"],
         framework: "k6",
       },
     ]);
+    expect(suites.frontend.e2e).toEqual([
+      {
+        name: "homepage",
+        files: ["frontend/e2e/homepage.pw.testkit.ts"],
+        framework: "playwright",
+      },
+    ]);
+  });
+
+  it("fails when a discovered file does not map to any configured service", () => {
+    const productDir = fs.mkdtempSync(path.join(os.tmpdir(), "testkit-discovery-"));
+    cleanups.push(() => fs.rmSync(productDir, { recursive: true, force: true }));
+
+    writeFile(productDir, "tests/unknown/integration/health.int.testkit.ts");
+
+    expect(() =>
+      discoverSuites(productDir, {
+        api: {
+          local: {
+            cwd: ".",
+          },
+        },
+      })
+    ).toThrow("Unowned test files");
+  });
+
+  it("fails when a discovered file maps to multiple services", () => {
+    const productDir = fs.mkdtempSync(path.join(os.tmpdir(), "testkit-discovery-"));
+    cleanups.push(() => fs.rmSync(productDir, { recursive: true, force: true }));
+
+    writeFile(productDir, "frontend/e2e/homepage.pw.testkit.ts");
+
+    expect(() =>
+      discoverSuites(productDir, {
+        frontend: {
+          local: {
+            cwd: "frontend",
+          },
+        },
+        web: {
+          local: {
+            cwd: "frontend",
+          },
+        },
+      })
+    ).toThrow("Ambiguous test files");
   });
 });
+
+function writeFile(productDir, relativePath) {
+  const absolutePath = path.join(productDir, relativePath);
+  fs.mkdirSync(path.dirname(absolutePath), { recursive: true });
+  fs.writeFileSync(absolutePath, "export {};\n");
+}

package/lib/config/index.mjs

@@ -1,7 +1,7 @@
 import fs from "fs";
 import path from "path";
 import { fileURLToPath } from "url";
-import { discoverServiceSuites } from "./discovery.mjs";
+import { discoverSuites } from "./discovery.mjs";
 import {
   getServiceEnvFiles as getServiceEnvFilesModel,
   isObject as isObjectModel,
@@ -34,6 +34,7 @@ export function loadConfigs(opts = {}) {
   const productDir = resolveProductDir(process.cwd(), opts.dir);
   const config = loadTestkitConfig(productDir);
   validateConfigCoverage(config);
+  const discoveredSuites = discoverSuites(productDir, config.services);
 
   const serviceEntries = Object.entries(config.services);
   const filtered = opts.service
@@ -46,7 +47,7 @@ export function loadConfigs(opts = {}) {
   }
 
   return filtered.map(([name, serviceConfig]) => {
-    const suites = discoverServiceSuites(productDir, name, serviceConfig);
+    const suites = discoveredSuites[name] || {};
     const resolvedDatabase = resolveSelectedDatabase(name, serviceConfig);
     const serviceEnv = loadServiceEnv(productDir, serviceConfig);
     const selectedBackend = resolvedDatabase?.selectedBackend;