@elench/testkit 0.1.34 → 0.1.35

package/README.md

@@ -15,13 +15,11 @@ cd my-product
 npx @elench/testkit
 
 # Filter by type
-npx @elench/testkit int
-npx @elench/testkit dal
-npx @elench/testkit e2e
-
-# Filter by framework
-npx @elench/testkit --framework playwright
-npx @elench/testkit --framework default
+npx @elench/testkit --type int
+npx @elench/testkit --type dal
+npx @elench/testkit --type e2e
+npx @elench/testkit --type int,e2e,dal
+npx @elench/testkit --type pw
 
 # Parallelize with isolated worker stacks
 npx @elench/testkit --jobs 3
@@ -30,14 +28,15 @@ npx @elench/testkit --jobs 3
 npx @elench/testkit --shard 1/3
 
 # Specific service / suite
-npx @elench/testkit frontend e2e -s auth
-npx @elench/testkit api int -s health
+npx @elench/testkit --service frontend --type pw -s navigation
+npx @elench/testkit --service api --type int -s health
+npx @elench/testkit --type int,e2e,dal -s dal:queries
 
 # Exact file
-npx @elench/testkit int --file __testkit__/health/health.int.testkit.ts
+npx @elench/testkit --type int --file __testkit__/health/health.int.testkit.ts
 
 # Deterministic git-trackable status snapshot
-npx @elench/testkit int --write-status
+npx @elench/testkit --type int --write-status
 
 # Lifecycle
 npx @elench/testkit status

package/lib/cli/args.mjs

@@ -1,35 +1,43 @@
 import path from "path";
+import { normalizeTypeValues, parseSuiteSelectors } from "../runner/suite-selection.mjs";
 
-export const SUITE_TYPES = new Set(["int", "integration", "e2e", "dal", "load", "all"]);
+export const POSITIONAL_TYPES = new Set(["int", "e2e", "dal", "load", "pw", "all"]);
 export const LIFECYCLE = new Set(["status", "destroy", "cleanup"]);
-export const RESERVED = new Set([...SUITE_TYPES, ...LIFECYCLE]);
+export const RESERVED = new Set([...POSITIONAL_TYPES, ...LIFECYCLE]);
 
-export function resolveCliSelection({ first, second, serviceNames }) {
-  let service = null;
-  let type = null;
+export function resolveCliSelection({ first, second, third }) {
+  if (second || third) {
+    throw new Error(`Unexpected extra positional arguments. Use --service and --type instead.`);
+  }
+
+  let lifecycle = null;
+  let positionalType = null;
 
-  if (first && serviceNames.has(first)) {
-    service = first;
-    type = second || null;
-  } else if (first && RESERVED.has(first)) {
-    type = first;
+  if (first && LIFECYCLE.has(first)) {
+    lifecycle = first;
+  } else if (first && POSITIONAL_TYPES.has(first)) {
+    positionalType = first;
   } else if (first) {
     throw new Error(
-      `Unknown argument "${first}". Expected a service name (${[...serviceNames].join(", ") || "none found"}) ` +
-      `or suite type (int, e2e, dal, all).`
+      `Unknown argument "${first}". Expected a lifecycle command (status, destroy, cleanup) ` +
+      `or suite type (int, e2e, dal, load, pw, all).`
     );
   }
 
-  return { service, type };
+  return { lifecycle, positionalType };
 }
 
-export function validateFrameworkOption(value) {
-  if (!["all", "default", "playwright"].includes(value)) {
-    throw new Error(
-      `Unknown framework "${value}". Expected one of: all, default, playwright.`
-    );
-  }
-  return value === "default" ? "k6" : value;
+export function parseTypeOption(values, positionalType = null) {
+  const input = [];
+  if (positionalType) input.push(positionalType);
+  if (Array.isArray(values)) input.push(...values);
+  else if (values) input.push(values);
+  return normalizeTypeValues(input);
+}
+
+export function parseSuiteOption(values) {
+  const input = Array.isArray(values) ? values : values ? [values] : [];
+  return parseSuiteSelectors(input);
 }
 
 export function parseJobsOption(value) {

package/lib/cli/args.test.mjs

@@ -2,35 +2,36 @@ import { describe, expect, it } from "vitest";
 import {
   parseJobsOption,
   parseShardOption,
+  parseSuiteOption,
+  parseTypeOption,
   resolveRequestedFiles,
   resolveCliSelection,
-  validateFrameworkOption,
 } from "./args.mjs";
 
 describe("cli-args", () => {
-  it("resolves a service and suite type", () => {
+  it("resolves a positional suite type", () => {
     expect(
       resolveCliSelection({
-        first: "api",
-        second: "int",
-        serviceNames: new Set(["api", "frontend"]),
+        first: "int",
+        second: null,
+        third: null,
       })
     ).toEqual({
-      service: "api",
-      type: "int",
+      lifecycle: null,
+      positionalType: "int",
     });
   });
 
-  it("resolves a reserved suite type without a service", () => {
+  it("resolves lifecycle commands", () => {
     expect(
       resolveCliSelection({
-        first: "e2e",
+        first: "status",
         second: null,
-        serviceNames: new Set(["api"]),
+        third: null,
       })
     ).toEqual({
-      service: null,
-      type: "e2e",
+      lifecycle: "status",
+      positionalType: null,
     });
   });
 
@@ -39,15 +40,19 @@ describe("cli-args", () => {
       resolveCliSelection({
         first: "mystery",
         second: null,
-        serviceNames: new Set(["api"]),
+        third: null,
       })
     ).toThrow('Unknown argument "mystery"');
   });
 
-  it("validates framework names", () => {
-    expect(validateFrameworkOption("playwright")).toBe("playwright");
-    expect(validateFrameworkOption("default")).toBe("k6");
-    expect(() => validateFrameworkOption("jest")).toThrow("Unknown framework");
+  it("parses types and suite selectors", () => {
+    expect(parseTypeOption(["e2e,dal"], "int")).toEqual(["int", "e2e", "dal"]);
+    expect(() => parseTypeOption(["all", "int"])).toThrow("cannot be combined");
+
+    expect(parseSuiteOption(["auth,dal:queries"])).toEqual([
+      { kind: "plain", name: "auth", raw: "auth" },
+      { kind: "typed", type: "dal", name: "queries", raw: "dal:queries" },
+    ]);
   });
 
   it("parses and validates jobs", () => {

package/lib/cli/index.mjs

@@ -3,9 +3,10 @@ import { loadConfigs } from "../config/index.mjs";
 import {
   parseJobsOption,
   parseShardOption,
+  parseSuiteOption,
+  parseTypeOption,
   resolveRequestedFiles,
   resolveCliSelection,
-  validateFrameworkOption,
 } from "./args.mjs";
 import * as runner from "../runner/index.mjs";
 
@@ -13,7 +14,11 @@ export function run() {
   const cli = cac("testkit");
 
   cli
-    .command("[first] [second] [third]", "Run test suites (int, e2e, dal, all)")
+    .command("[first] [second] [third]", "Run test suites")
+    .option("--service <name>", "Run only one service")
+    .option("-t, --type <name>", "Run specific suite type(s): int, e2e, dal, load, pw, all", {
+      default: [],
+    })
     .option("-s, --suite <name>", "Run specific suite(s)", { default: [] })
     .option("-f, --file <path>", "Run specific file(s)", { default: [] })
     .option("--dir <path>", "Explicit product directory")
@@ -21,76 +26,56 @@ export function run() {
       default: "1",
     })
     .option("--shard <i/n>", "Run only shard i of n at suite granularity")
-    .option("--framework <name>", "Filter by framework (default, playwright, all)", {
-      default: "all",
-    })
     .option("--write-status", "Write a deterministic testkit.status.json snapshot")
     .option("--allow-partial-status", "Allow --write-status for filtered runs")
     .action(async (first, second, third, options) => {
-      // Resolve: service filter, suite type, and --dir.
-      //
-      // From product dir:
-      //   testkit                          → all services, all types
-      //   testkit int -s health            → all services, int, health
-      //   testkit api int                  → one service, int
-      //   testkit api                      → one service, all types
-      //
-      // From workspace root:
-      //   testkit --dir my-product int     → all services, int
-      //   testkit --dir my-product api int → one service, int
-
-      // Now resolve service vs type from remaining args
-      const allConfigs = await loadConfigs({ dir: options.dir });
-      const serviceNames = new Set(allConfigs.map((config) => config.name));
-      const { service, type } = resolveCliSelection({
+      const { lifecycle, positionalType } = resolveCliSelection({
         first,
         second,
-        serviceNames,
+        third,
       });
-      const configs = service
-        ? allConfigs.filter((config) => config.name === service)
+      const allConfigs = await loadConfigs({ dir: options.dir });
+      const configs = options.service
+        ? allConfigs.filter((config) => config.name === options.service)
         : allConfigs;
-      if (service && configs.length === 0) {
+      if (options.service && configs.length === 0) {
         const available = allConfigs.map((config) => config.name).join(", ");
-        throw new Error(`Service "${service}" not found. Available: ${available}`);
+        throw new Error(`Service "${options.service}" not found. Available: ${available}`);
       }
 
       // Lifecycle commands
-      if (type === "cleanup") {
+      if (lifecycle === "cleanup") {
         await runner.cleanup(allConfigs[0]?.productDir || process.cwd());
         return;
       }
 
-      if (type === "status" || type === "destroy") {
+      if (lifecycle === "status" || lifecycle === "destroy") {
         for (const config of configs) {
           if (configs.length > 1) console.log(`\n── ${config.name} ──`);
-          if (type === "status") runner.showStatus(config);
+          if (lifecycle === "status") runner.showStatus(config);
           else await runner.destroy(config);
         }
         return;
       }
 
-      const framework = validateFrameworkOption(options.framework);
-
       const jobs = parseJobsOption(options.jobs);
       const shard = parseShardOption(options.shard);
-
-      const suiteType = type || "all";
-      const suiteNames = Array.isArray(options.suite) ? options.suite : [options.suite].filter(Boolean);
+      const typeValues = parseTypeOption(options.type, positionalType);
+      const suiteSelectors = parseSuiteOption(options.suite);
       const rawFileNames = Array.isArray(options.file) ? options.file : [options.file].filter(Boolean);
       const productDir = allConfigs[0]?.productDir || process.cwd();
       const fileNames = resolveRequestedFiles(rawFileNames, productDir, process.cwd());
       await runner.runAll(
         configs,
-        suiteType,
-        suiteNames,
+        typeValues,
+        suiteSelectors,
         {
           ...options,
-          framework,
+          typeValues,
           fileNames,
           jobs,
           shard,
-          serviceFilter: service,
+          serviceFilter: options.service || null,
         },
         allConfigs
       );

package/lib/runner/orchestrator.mjs

@@ -33,7 +33,7 @@ import { createWorker, runWorker } from "./worker-loop.mjs";
 import { findUnmatchedRequestedFiles, isFullRunSelection } from "./selection.mjs";
 import { uploadTelemetryArtifact } from "../telemetry/index.mjs";
 
-export async function runAll(configs, suiteType, suiteNames, opts, allConfigs = configs) {
+export async function runAll(configs, typeValues, suiteSelectors, opts, allConfigs = configs) {
   const configMap = new Map(allConfigs.map((config) => [config.name, config]));
   const startedAt = Date.now();
   const telemetry = configs[0]?.telemetry || null;
@@ -51,9 +51,8 @@ export async function runAll(configs, suiteType, suiteNames, opts, allConfigs =
   if (requestedFiles.length > 0) {
     const unmatchedFiles = findUnmatchedRequestedFiles(
       configs,
-      suiteType,
-      suiteNames,
-      opts.framework || "all",
+      typeValues,
+      suiteSelectors,
       requestedFiles,
       collectSuites,
       normalizePathSeparators
@@ -69,9 +68,9 @@ export async function runAll(configs, suiteType, suiteNames, opts, allConfigs =
     opts.writeStatus &&
     !opts.allowPartialStatus &&
     !isFullRunSelection(
-      suiteNames,
+      typeValues,
+      suiteSelectors,
       requestedFiles,
-      opts.framework || "all",
       opts.shard || null,
       opts.serviceFilter || null
     )
@@ -82,7 +81,7 @@ export async function runAll(configs, suiteType, suiteNames, opts, allConfigs =
     );
   }
 
-  const servicePlans = collectServicePlans(configs, configMap, suiteType, suiteNames, opts);
+  const servicePlans = collectServicePlans(configs, configMap, typeValues, suiteSelectors, opts);
   const trackers = buildServiceTrackers(servicePlans, startedAt);
   const executedPlans = servicePlans.filter((plan) => !plan.skipped);
   let workerCount = 0;
@@ -144,10 +143,9 @@ export async function runAll(configs, suiteType, suiteNames, opts, allConfigs =
       finishedAt,
       requestedJobs: opts.jobs || 1,
       workerCount,
-      suiteType,
-      suiteNames,
+      typeValues,
+      suiteSelectors,
       fileNames: requestedFiles,
-      framework: opts.framework || "all",
       shard: opts.shard || null,
       serviceFilter: opts.serviceFilter || null,
       metadata,
@@ -161,10 +159,9 @@ export async function runAll(configs, suiteType, suiteNames, opts, allConfigs =
         buildStatusArtifact({
           productDir,
           results,
-          suiteType,
-          suiteNames,
+          typeValues,
+          suiteSelectors,
           fileNames: requestedFiles,
-          framework: opts.framework || "all",
           shard: opts.shard || null,
           serviceFilter: opts.serviceFilter || null,
           metadata,
@@ -188,17 +185,17 @@ export async function runAll(configs, suiteType, suiteNames, opts, allConfigs =
   }
 }
 
-function collectServicePlans(configs, configMap, suiteType, suiteNames, opts) {
+function collectServicePlans(configs, configMap, typeValues, suiteSelectors, opts) {
   return configs.map((config) => {
     console.log(`\n══ ${config.name} ══`);
     const suites = applyShard(
-      collectSuites(config, suiteType, suiteNames, opts.framework, opts.fileNames || []),
+      collectSuites(config, typeValues, suiteSelectors, opts.fileNames || []),
       opts.shard
     );
 
     if (suites.length === 0) {
       console.log(
-        `No test files for ${config.name} type="${suiteType}" suites=${suiteNames.join(",") || "all"} files=${(opts.fileNames || []).join(",") || "all"} — skipping`
+        `No test files for ${config.name} types=${typeValues.join(",") || "all"} suites=${suiteSelectors.map((selector) => selector.raw).join(",") || "all"} files=${(opts.fileNames || []).join(",") || "all"} — skipping`
       );
       return {
         config,

package/lib/runner/planning.mjs

@@ -1,4 +1,9 @@
 import { buildTimingKey, estimateTaskDuration } from "../timing/index.mjs";
+import {
+  matchesSelectedTypes,
+  matchesSuiteSelectors,
+  suiteSelectionType,
+} from "./suite-selection.mjs";
 
 const TYPE_ORDER = ["dal", "integration", "e2e", "load"];
 
@@ -34,26 +39,21 @@ export function resolveRuntimeConfigs(targetConfig, configMap) {
   return ordered;
 }
 
-export function collectSuites(config, suiteType, suiteNames, frameworkFilter, fileNames = []) {
-  const types =
-    suiteType === "all"
-      ? orderedTypes(Object.keys(config.suites))
-      : [suiteType === "int" ? "integration" : suiteType];
-
-  const selectedNames = new Set(suiteNames);
+export function collectSuites(config, typeValues, suiteSelectors, fileNames = []) {
   const selectedFiles = new Set(fileNames.map(normalizePathSeparators));
   const suites = [];
   let orderIndex = 0;
 
-  for (const type of types) {
+  for (const type of orderedTypes(Object.keys(config.suites))) {
     for (const suite of config.suites[type] || []) {
       const framework = suite.framework || "k6";
+      const displayType = suiteSelectionType(type, framework);
       const files =
         selectedFiles.size === 0
           ? suite.files
           : suite.files.filter((file) => selectedFiles.has(normalizePathSeparators(file)));
-      if (selectedNames.size > 0 && !selectedNames.has(suite.name)) continue;
-      if (frameworkFilter && frameworkFilter !== "all" && framework !== frameworkFilter) continue;
+      if (!matchesSelectedTypes(displayType, typeValues)) continue;
+      if (!matchesSuiteSelectors(displayType, suite.name, suiteSelectors)) continue;
       if (files.length === 0) continue;
 
       suites.push({
@@ -61,6 +61,7 @@ export function collectSuites(config, suiteType, suiteNames, frameworkFilter, fi
         files,
         framework,
         type,
+        displayType,
         orderIndex,
         sortKey: `${type}:${suite.name}`,
         weight:

package/lib/runner/planning.test.mjs

@@ -38,7 +38,7 @@ describe("runner-planning", () => {
     expect(() => resolveRuntimeConfigs(frontend, configMap)).toThrow("Dependency cycle");
   });
 
-  it("collects suites with aliases, weights, and framework filters", () => {
+  it("collects suites with user-facing type selection", () => {
     const config = makeConfig("api", {
       suites: {
         integration: [
@@ -57,15 +57,17 @@ describe("runner-planning", () => {
       },
     });
 
-    expect(collectSuites(config, "int", [], "all")[0]).toMatchObject({
+    expect(collectSuites(config, ["int"], [], [])[0]).toMatchObject({
       name: "health",
       type: "integration",
+      displayType: "int",
       framework: "k6",
       weight: 1,
     });
 
-    expect(collectSuites(config, "all", [], "playwright")[0]).toMatchObject({
+    expect(collectSuites(config, ["pw"], [], [])[0]).toMatchObject({
       name: "auth",
+      displayType: "pw",
       framework: "playwright",
       weight: 2,
     });
@@ -73,9 +75,8 @@ describe("runner-planning", () => {
     expect(
       collectSuites(
         config,
-        "all",
+        ["all"],
         [],
-        "all",
         ["tests/frontend/e2e/signup.pw.testkit.ts"]
       )[0]
     ).toMatchObject({

package/lib/runner/reporting.mjs

@@ -3,10 +3,9 @@ import path from "path";
 export function buildStatusArtifact({
   productDir,
   results,
-  suiteType,
-  suiteNames,
+  typeValues,
+  suiteSelectors,
   fileNames,
-  framework,
   shard,
   serviceFilter,
   metadata,
@@ -49,22 +48,22 @@ export function buildStatusArtifact({
   };
 
   const scope = {
-    suiteType,
-    suiteNames: [...(suiteNames || [])].sort(),
+    types: [...(typeValues || ["all"])].sort(),
+    suiteSelectors: [...(suiteSelectors || [])].map((selector) => selector.raw).sort(),
     fileNames: [...(fileNames || [])].sort(),
-    framework: formatFrameworkForArtifact(framework || "all"),
     shard: shard || null,
     serviceFilter: serviceFilter || null,
   };
   scope.isFullRun =
-    scope.suiteNames.length === 0 &&
+    scope.types.length === 1 &&
+    scope.types[0] === "all" &&
+    scope.suiteSelectors.length === 0 &&
     scope.fileNames.length === 0 &&
-    scope.framework === "all" &&
     scope.shard === null &&
     scope.serviceFilter === null;
 
   return {
-    schemaVersion: 1,
+    schemaVersion: 2,
     source: "testkit",
     notice: "Generated file. Do not edit manually.",
     product: {
@@ -88,10 +87,9 @@ export function buildRunArtifact({
   finishedAt,
   requestedJobs,
   workerCount,
-  suiteType,
-  suiteNames,
+  typeValues,
+  suiteSelectors,
   fileNames,
-  framework,
   shard,
   serviceFilter,
   metadata,
@@ -109,7 +107,7 @@ export function buildRunArtifact({
   const dbBackend = summarizeDbBackend(results);
 
   return {
-    schemaVersion: 1,
+    schemaVersion: 2,
     source: "testkit",
     generatedAt: new Date(finishedAt).toISOString(),
     product: {
@@ -126,10 +124,9 @@ export function buildRunArtifact({
       requestedJobs,
       workerCount,
       dbBackend,
-      suiteType,
-      suiteNames,
+      types: typeValues,
+      suiteSelectors: suiteSelectors.map((selector) => selector.raw),
       fileNames,
-      framework: formatFrameworkForArtifact(framework),
       shard,
       serviceFilter,
       testkitVersion: metadata.testkitVersion,
@@ -173,8 +170,3 @@ export function buildRunArtifact({
     })),
   };
 }
-
-function formatFrameworkForArtifact(framework) {
-  if (framework === "k6") return "default";
-  return framework;
-}

package/lib/runner/reporting.test.mjs

@@ -49,10 +49,9 @@ describe("runner reporting", () => {
       finishedAt: 4000,
       requestedJobs: 2,
       workerCount: 1,
-      suiteType: "all",
-      suiteNames: [],
+      typeValues: ["all"],
+      suiteSelectors: [],
       fileNames: [],
-      framework: "all",
       shard: null,
       serviceFilter: null,
       metadata: {
@@ -93,7 +92,7 @@ describe("runner reporting", () => {
           suites: [
             {
               name: "health",
-              type: "integration",
+              type: "int",
               framework: "k6",
               files: [
                 { path: "tests/api/integration/a.int.testkit.ts", status: "passed" },
@@ -103,10 +102,9 @@ describe("runner reporting", () => {
           ],
         },
       ],
-      suiteType: "int",
-      suiteNames: ["health"],
+      typeValues: ["int"],
+      suiteSelectors: [{ kind: "plain", name: "health", raw: "health" }],
       fileNames: ["tests/api/integration/b.int.testkit.ts"],
-      framework: "default",
       shard: null,
       serviceFilter: "api",
       metadata: {
@@ -119,7 +117,7 @@ describe("runner reporting", () => {
     });
 
     expect(status).toEqual({
-      schemaVersion: 1,
+      schemaVersion: 2,
       source: "testkit",
       notice: "Generated file. Do not edit manually.",
       product: {
@@ -131,10 +129,9 @@ describe("runner reporting", () => {
       },
       testkitVersion: "0.1.20",
       scope: {
-        suiteType: "int",
-        suiteNames: ["health"],
+        types: ["int"],
+        suiteSelectors: ["health"],
         fileNames: ["tests/api/integration/b.int.testkit.ts"],
-        framework: "default",
         shard: null,
         serviceFilter: "api",
         isFullRun: false,
@@ -155,13 +152,13 @@ describe("runner reporting", () => {
       tests: [
         {
           service: "api",
-          type: "integration",
+          type: "int",
           path: "tests/api/integration/a.int.testkit.ts",
           status: "passed",
         },
         {
           service: "api",
-          type: "integration",
+          type: "int",
           path: "tests/api/integration/b.int.testkit.ts",
           status: "failed",
         },
@@ -173,10 +170,9 @@ describe("runner reporting", () => {
     const status = buildStatusArtifact({
       productDir: "/tmp/my-product",
       results: [],
-      suiteType: "all",
-      suiteNames: [],
+      typeValues: ["all"],
+      suiteSelectors: [],
       fileNames: [],
-      framework: "all",
       shard: null,
       serviceFilter: null,
       metadata: {

package/lib/runner/results.mjs

@@ -26,6 +26,7 @@ export function buildServiceTrackers(servicePlans, startedAt) {
       key: `${suite.type}:${suite.name}`,
       name: suite.name,
       type: suite.type,
+      displayType: suite.displayType || suite.type,
       framework: suite.framework,
       orderIndex: suite.orderIndex,
       fileCount: suite.files.length,
@@ -215,7 +216,7 @@ function finalizeSuite(suite) {
 
   return {
     name: suite.name,
-    type: suite.type,
+    type: suite.displayType,
     framework: formatFrameworkForArtifact(suite.framework),
     failed: suite.failedFiles.length > 0,
     fileCount: suite.fileCount,

package/lib/runner/selection.mjs

@@ -1,15 +1,14 @@
 export function findUnmatchedRequestedFiles(
   configs,
-  suiteType,
-  suiteNames,
-  framework,
+  typeValues,
+  suiteSelectors,
   fileNames,
   collectSuites,
   normalizePathSeparators
 ) {
   const matchedFiles = new Set();
   for (const config of configs) {
-    const suites = collectSuites(config, suiteType, suiteNames, framework, []);
+    const suites = collectSuites(config, typeValues, suiteSelectors, []);
     for (const suite of suites) {
       for (const file of suite.files) {
         matchedFiles.add(normalizePathSeparators(file));
@@ -22,11 +21,12 @@ export function findUnmatchedRequestedFiles(
   );
 }
 
-export function isFullRunSelection(suiteNames, fileNames, framework, shard, serviceFilter) {
+export function isFullRunSelection(typeValues, suiteSelectors, fileNames, shard, serviceFilter) {
   return (
-    (suiteNames || []).length === 0 &&
+    (typeValues || []).length === 1 &&
+    typeValues[0] === "all" &&
+    (suiteSelectors || []).length === 0 &&
     (fileNames || []).length === 0 &&
-    (framework || "all") === "all" &&
     (shard || null) === null &&
     (serviceFilter || null) === null
   );

package/lib/runner/selection.test.mjs

@@ -5,9 +5,8 @@ describe("runner selection", () => {
   it("finds unmatched requested files", () => {
     const unmatched = findUnmatchedRequestedFiles(
       [{ name: "api" }],
-      "int",
+      ["int"],
       [],
-      "all",
       ["tests/a.int.testkit.ts", "tests/missing.int.testkit.ts"],
       () => [{ files: ["tests/a.int.testkit.ts"] }],
       (value) => value
@@ -17,9 +16,9 @@ describe("runner selection", () => {
   });
 
   it("detects a full run selection", () => {
-    expect(isFullRunSelection([], [], "all", null, null)).toBe(true);
-    expect(isFullRunSelection(["auth"], [], "all", null, null)).toBe(false);
-    expect(isFullRunSelection([], ["a"], "all", null, null)).toBe(false);
-    expect(isFullRunSelection([], [], "playwright", null, null)).toBe(false);
+    expect(isFullRunSelection(["all"], [], [], null, null)).toBe(true);
+    expect(isFullRunSelection(["all"], [{ raw: "auth" }], [], null, null)).toBe(false);
+    expect(isFullRunSelection(["all"], [], ["a"], null, null)).toBe(false);
+    expect(isFullRunSelection(["int"], [], [], null, null)).toBe(false);
   });
 });

package/lib/runner/suite-selection.mjs

@@ -0,0 +1,91 @@
+const USER_TYPES = new Set(["int", "e2e", "dal", "load", "pw", "all"]);
+
+export function normalizeTypeValues(values = []) {
+  const expanded = [];
+  for (const rawValue of values) {
+    if (rawValue == null) continue;
+    for (const part of String(rawValue).split(",")) {
+      const value = part.trim();
+      if (!value) continue;
+      if (!USER_TYPES.has(value)) {
+        throw new Error(
+          `Unknown type "${value}". Expected one of: int, e2e, dal, load, pw, all.`
+        );
+      }
+      expanded.push(value);
+    }
+  }
+
+  if (expanded.length === 0) {
+    return ["all"];
+  }
+
+  const deduped = [...new Set(expanded)];
+  if (deduped.includes("all") && deduped.length > 1) {
+    throw new Error(`"--type all" cannot be combined with other types.`);
+  }
+
+  const order = ["int", "e2e", "dal", "load", "pw", "all"];
+  return deduped.sort((left, right) => order.indexOf(left) - order.indexOf(right));
+}
+
+export function isAllTypeSelection(typeValues = []) {
+  return typeValues.length === 0 || (typeValues.length === 1 && typeValues[0] === "all");
+}
+
+export function parseSuiteSelectors(values = []) {
+  const selectors = [];
+
+  for (const rawValue of values) {
+    if (rawValue == null) continue;
+    for (const part of String(rawValue).split(",")) {
+      const value = part.trim();
+      if (!value) continue;
+
+      const typeMatch = value.match(/^([a-z]+):(.*)$/);
+      if (!typeMatch) {
+        selectors.push({ kind: "plain", name: value, raw: value });
+        continue;
+      }
+
+      const type = typeMatch[1];
+      const name = typeMatch[2].trim();
+      if (!USER_TYPES.has(type) || type === "all") {
+        throw new Error(
+          `Unknown suite selector type "${type}". Expected one of: int, e2e, dal, load, pw.`
+        );
+      }
+      if (!name) {
+        throw new Error(`Invalid suite selector "${value}". Expected "<type>:<suite-name>".`);
+      }
+
+      selectors.push({
+        kind: "typed",
+        type,
+        name,
+        raw: `${type}:${name}`,
+      });
+    }
+  }
+
+  return selectors;
+}
+
+export function suiteSelectionType(type, framework) {
+  if ((framework || "k6") === "playwright") return "pw";
+  if (type === "integration") return "int";
+  return type;
+}
+
+export function matchesSelectedTypes(selectionType, typeValues) {
+  return isAllTypeSelection(typeValues) || typeValues.includes(selectionType);
+}
+
+export function matchesSuiteSelectors(selectionType, suiteName, selectors = []) {
+  if (!selectors || selectors.length === 0) return true;
+
+  return selectors.some((selector) => {
+    if (selector.kind === "plain") return selector.name === suiteName;
+    return selector.type === selectionType && selector.name === suiteName;
+  });
+}

package/lib/runner/suite-selection.test.mjs

@@ -0,0 +1,42 @@
+import { describe, expect, it } from "vitest";
+import {
+  isAllTypeSelection,
+  matchesSelectedTypes,
+  matchesSuiteSelectors,
+  normalizeTypeValues,
+  parseSuiteSelectors,
+  suiteSelectionType,
+} from "./suite-selection.mjs";
+
+describe("runner suite selection", () => {
+  it("normalizes selected type values", () => {
+    expect(normalizeTypeValues([])).toEqual(["all"]);
+    expect(normalizeTypeValues(["int,e2e", "dal"])).toEqual(["int", "e2e", "dal"]);
+    expect(() => normalizeTypeValues(["all", "int"])).toThrow("cannot be combined");
+    expect(() => normalizeTypeValues(["jest"])).toThrow("Unknown type");
+  });
+
+  it("parses suite selectors", () => {
+    expect(parseSuiteSelectors(["auth,dal:queries"])).toEqual([
+      { kind: "plain", name: "auth", raw: "auth" },
+      { kind: "typed", type: "dal", name: "queries", raw: "dal:queries" },
+    ]);
+    expect(() => parseSuiteSelectors(["all:auth"])).toThrow("Unknown suite selector type");
+    expect(() => parseSuiteSelectors(["int:"])).toThrow("Invalid suite selector");
+  });
+
+  it("matches suite types and selectors", () => {
+    expect(isAllTypeSelection(["all"])).toBe(true);
+    expect(matchesSelectedTypes("int", ["int", "dal"])).toBe(true);
+    expect(matchesSelectedTypes("pw", ["int", "dal"])).toBe(false);
+    expect(matchesSuiteSelectors("int", "auth", parseSuiteSelectors(["auth"]))).toBe(true);
+    expect(matchesSuiteSelectors("e2e", "auth", parseSuiteSelectors(["int:auth"]))).toBe(false);
+    expect(matchesSuiteSelectors("int", "auth", parseSuiteSelectors(["int:auth"]))).toBe(true);
+  });
+
+  it("maps discovered suites to user-facing selection types", () => {
+    expect(suiteSelectionType("integration", "k6")).toBe("int");
+    expect(suiteSelectionType("e2e", "playwright")).toBe("pw");
+    expect(suiteSelectionType("dal", "k6")).toBe("dal");
+  });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@elench/testkit",
-  "version": "0.1.34",
+  "version": "0.1.35",
   "description": "CLI for discovering and running local HTTP, DAL, and Playwright test suites",
   "type": "module",
   "types": "./lib/index.d.ts",