@elench/testkit 0.1.39 → 0.1.41

package/lib/runner/default-runtime-runner.mjs

@@ -3,89 +3,82 @@ import path from "path";
 import { execa } from "execa";
 import { bundleK6File } from "../bundler/index.mjs";
 import { resolveK6Binary } from "../config/index.mjs";
+import {
+  buildFileTimeoutEnv,
+  formatFileTimeoutBudgetError,
+} from "../shared/file-timeout.mjs";
 import { persistTaskArtifacts } from "./artifacts.mjs";
-import { RUNTIME_ARTIFACT_MARKER } from "../runtime-src/k6/artifacts.js";
 import { determineDefaultRuntimeFailure } from "./default-runtime-errors.mjs";
-import { formatBatchDescriptor } from "./formatting.mjs";
-import { buildExecutionEnv } from "./template.mjs";
+import { RUNTIME_ARTIFACT_MARKER } from "../runtime-src/k6/artifacts.js";
 import { readDatabaseUrl } from "./state-io.mjs";
+import { buildTaskExecutionEnv } from "./template.mjs";
 
-export async function runHttpK6Batch(targetConfig, batch, lifecycle) {
+export async function runHttpK6Task(targetConfig, task, lifecycle, lease) {
   const baseUrl = targetConfig.testkit.local?.baseUrl;
   if (!baseUrl) {
     throw new Error(`Service "${targetConfig.name}" requires local.baseUrl for HTTP suites`);
   }
 
-  console.log(
-    `\n── ${targetConfig.stackLabel} ${batch.type}:${batch.tasks[0].suiteName}${formatBatchDescriptor(batch)} ──`
-  );
-
-  return Promise.all(
-    batch.tasks.map((task) => runHttpK6Task(targetConfig, task, baseUrl, lifecycle))
-  );
-}
-
-export async function runDalBatch(targetConfig, batch, lifecycle) {
-  const databaseUrl = readDatabaseUrl(targetConfig.stateDir);
-  if (!databaseUrl) {
-    throw new Error(`Service "${targetConfig.name}" requires a database for DAL suites`);
-  }
-
-  console.log(
-    `\n── ${targetConfig.stackLabel} ${batch.type}:${batch.tasks[0].suiteName}${formatBatchDescriptor(batch)} ──`
-  );
-
-  return Promise.all(
-    batch.tasks.map((task) => runDalTask(targetConfig, task, databaseUrl, lifecycle))
-  );
-}
-
-async function runHttpK6Task(targetConfig, task, baseUrl, lifecycle) {
   const bundledFile = await bundleK6File({
     productDir: targetConfig.productDir,
     serviceName: targetConfig.name,
     sourceFile: path.join(targetConfig.productDir, task.file),
   });
-  console.log(`·· ${targetConfig.stackLabel}:${task.suiteName} → ${task.file}`);
+  console.log(`·· ${targetConfig.runtimeLabel}:${task.suiteName} → ${task.file}`);
   return runDefaultRuntimeTask(
     targetConfig,
     task,
+    lease,
     ["run", "--address", "127.0.0.1:0", "-e", `BASE_URL=${baseUrl}`, bundledFile],
     lifecycle
   );
 }
 
-async function runDalTask(targetConfig, task, databaseUrl, lifecycle) {
+export async function runDalTask(targetConfig, task, lifecycle, lease) {
+  const databaseUrl = readDatabaseUrl(targetConfig.stateDir);
+  if (!databaseUrl) {
+    throw new Error(`Service "${targetConfig.name}" requires a database for DAL suites`);
+  }
+
   const bundledFile = await bundleK6File({
     productDir: targetConfig.productDir,
     serviceName: targetConfig.name,
     sourceFile: path.join(targetConfig.productDir, task.file),
   });
-  console.log(`·· ${targetConfig.stackLabel}:${task.suiteName} → ${task.file}`);
+  console.log(`·· ${targetConfig.runtimeLabel}:${task.suiteName} → ${task.file}`);
   return runDefaultRuntimeTask(
     targetConfig,
     task,
+    lease,
     ["run", "--address", "127.0.0.1:0", "-e", `DATABASE_URL=${databaseUrl}`, bundledFile],
     lifecycle
   );
 }
 
-export async function runDefaultRuntimeTask(targetConfig, task, args, lifecycle, firstLine) {
+export async function runDefaultRuntimeTask(targetConfig, task, lease, args, lifecycle, firstLine) {
   const k6Binary = resolveK6Binary();
-  const summaryFile = buildDefaultRuntimeSummaryPath(targetConfig, task);
+  const getFirstLine = firstLine || defaultFirstLine;
+  const summaryFile = buildDefaultRuntimeSummaryPath(lease, task);
   fs.mkdirSync(path.dirname(summaryFile), { recursive: true });
   const startedAt = Date.now();
-  const result = await execa(
+  const fileTimeoutSeconds = targetConfig.testkit.execution.fileTimeoutSeconds;
+  const subprocess = execa(
     k6Binary,
     [...args.slice(0, 1), "--summary-export", summaryFile, ...args.slice(1)],
     {
       cwd: targetConfig.productDir,
-      env: buildExecutionEnv(targetConfig, {}, process.env),
+      env: buildTaskExecutionEnv(
+        targetConfig,
+        lease,
+        buildFileTimeoutEnv(fileTimeoutSeconds, startedAt),
+        process.env
+      ),
       reject: false,
       cancelSignal: lifecycle.signal,
       forceKillAfterDelay: 5_000,
     }
   );
+  const { result, timedOut } = await settleSubprocess(subprocess, fileTimeoutSeconds);
 
   const stdout = parseDefaultRuntimeOutput(result.stdout || "");
   const stderr = parseDefaultRuntimeOutput(result.stderr || "");
@@ -98,7 +91,9 @@ export async function runDefaultRuntimeTask(targetConfig, task, args, lifecycle,
     task,
     [...stdout.artifacts, ...stderr.artifacts]
   );
-  const runtimeError = determineDefaultRuntimeFailure(result, summary, firstLine);
+  const runtimeError = timedOut
+    ? formatFileTimeoutBudgetError(fileTimeoutSeconds)
+    : determineDefaultRuntimeFailure(result, summary, getFirstLine);
   const finishedAt = Date.now();
 
   return {
@@ -112,12 +107,30 @@ export async function runDefaultRuntimeTask(targetConfig, task, args, lifecycle,
   };
 }
 
-export function buildDefaultRuntimeSummaryPath(targetConfig, task) {
-  return path.join(
-    targetConfig.stateDir || path.join(targetConfig.productDir, ".testkit"),
-    "_runtime",
-    `task-${task.id}.summary.json`
-  );
+export async function settleSubprocess(subprocess, fileTimeoutSeconds) {
+  const timeoutMs = fileTimeoutSeconds * 1000 + 1_000;
+  let timeoutHandle = null;
+  let timedOut = false;
+
+  try {
+    return await Promise.race([
+      subprocess.then((result) => ({ result, timedOut })),
+      new Promise((resolve) => {
+        timeoutHandle = setTimeout(async () => {
+          timedOut = true;
+          subprocess.kill("SIGTERM");
+          const result = await subprocess.catch((error) => error);
+          resolve({ result, timedOut: true });
+        }, timeoutMs);
+      }),
+    ]);
+  } finally {
+    if (timeoutHandle) clearTimeout(timeoutHandle);
+  }
+}
+
+export function buildDefaultRuntimeSummaryPath(lease, task) {
+  return path.join(lease.leaseDir, "default-runtime", `task-${task.id}.summary.json`);
 }
 
 export function readDefaultRuntimeSummary(filePath) {
@@ -128,6 +141,13 @@ export function readDefaultRuntimeSummary(filePath) {
   }
 }
 
+function defaultFirstLine(output) {
+  return String(output || "")
+    .split(/\r?\n/)
+    .map((line) => line.trim())
+    .find(Boolean) || null;
+}
+
 function parseDefaultRuntimeOutput(output) {
   if (!output) {
     return {

package/lib/runner/execution-config.mjs

@@ -1,22 +1,30 @@
-export const STACK_MODES = new Set(["shared", "pooled", "isolated"]);
+import {
+  DEFAULT_FILE_TIMEOUT_SECONDS,
+  normalizeFileTimeoutSeconds,
+  parseFileTimeoutOption,
+} from "../shared/file-timeout.mjs";
+
+export const DATABASE_BINDINGS = new Set(["shared", "per-runtime"]);
+
+export { DEFAULT_FILE_TIMEOUT_SECONDS, parseFileTimeoutOption };
 
 export function parseWorkersOption(value) {
   return parsePositiveInteger(value, "--workers");
 }
 
-export function parseStackCountOption(value) {
-  return parsePositiveInteger(value, "--stack-count");
+export function parseRuntimeInstancesOption(value, label = "runtime.instances") {
+  return parsePositiveInteger(value, label);
 }
 
-export function parseStackModeOption(value) {
-  return normalizeStackModeValue(value, "--stack-mode");
+export function normalizeRuntimeInstances(value, label = "runtime.instances") {
+  return normalizePositiveInteger(value, label);
 }
 
-export function normalizeStackModeValue(value, label = "execution.stackMode") {
+export function normalizeDatabaseBinding(value, label = "database.binding") {
   const normalized = String(value || "").trim();
-  if (!STACK_MODES.has(normalized)) {
+  if (!DATABASE_BINDINGS.has(normalized)) {
     throw new Error(
-      `Invalid ${label} value "${value}". Expected one of: shared, pooled, isolated.`
+      `Invalid ${label} value "${value}". Expected one of: shared, per-runtime.`
     );
   }
   return normalized;
@@ -25,70 +33,22 @@ export function normalizeStackModeValue(value, label = "execution.stackMode") {
 export function resolveExecutionConfig({ cli = {}, repo = {} } = {}) {
   return normalizeExecutionConfig({
     workers: cli.workers ?? repo.workers ?? 1,
-    stackMode: cli.stackMode ?? repo.stackMode ?? "isolated",
-    stackCount: cli.stackCount ?? repo.stackCount ?? null,
+    fileTimeoutSeconds:
+      cli.fileTimeoutSeconds ?? repo.fileTimeoutSeconds ?? DEFAULT_FILE_TIMEOUT_SECONDS,
   });
 }
 
 export function normalizeExecutionConfig(input = {}) {
-  const workers = normalizePositiveInteger(input.workers, "execution.workers");
-  const stackMode = normalizeStackMode(input.stackMode);
-  const explicitStackCount =
-    input.stackCount == null ? null : normalizePositiveInteger(input.stackCount, "execution.stackCount");
-
-  if (stackMode === "shared") {
-    if (explicitStackCount !== null && explicitStackCount !== 1) {
-      throw new Error(`execution.stackCount must be 1 when stackMode is "shared".`);
-    }
-    return {
-      workers,
-      stackMode,
-      stackCount: 1,
-    };
-  }
-
-  if (stackMode === "pooled") {
-    return {
-      workers,
-      stackMode,
-      stackCount: explicitStackCount ?? 1,
-    };
-  }
-
-  if (explicitStackCount !== null && explicitStackCount !== workers) {
-    throw new Error(
-      `execution.stackCount must equal execution.workers when stackMode is "isolated".`
-    );
-  }
   return {
-    workers,
-    stackMode,
-    stackCount: workers,
+    workers: normalizePositiveInteger(input.workers ?? 1, "execution.workers"),
+    fileTimeoutSeconds: normalizeFileTimeoutSeconds(
+      input.fileTimeoutSeconds ?? DEFAULT_FILE_TIMEOUT_SECONDS
+    ),
   };
 }
 
-export function buildStackIds(execution) {
-  if (execution.stackMode === "shared") {
-    return ["shared"];
-  }
-
-  return Array.from({ length: execution.stackCount }, (_unused, index) => `stack-${index + 1}`);
-}
-
-export function resolveBatchStackMode(defaultMode, suiteMode = null) {
-  if (suiteMode == null) return defaultMode;
-  return normalizeStackMode(suiteMode);
-}
-
-export function resolveBatchAccessMode({ framework, type, stackMode }) {
-  if (stackMode === "isolated") return "exclusive";
-  if ((framework || "k6") === "playwright") return "exclusive";
-  if (type === "dal") return "exclusive";
-  return "shared";
-}
-
-function normalizeStackMode(value) {
-  return normalizeStackModeValue(value, "execution.stackMode");
+export function buildRuntimeIds(count) {
+  return Array.from({ length: count }, (_unused, index) => `runtime-${index + 1}`);
 }
 
 function parsePositiveInteger(value, label) {

package/lib/runner/execution-config.test.mjs

@@ -1,101 +1,59 @@
 import { describe, expect, it } from "vitest";
 import {
-  buildStackIds,
+  buildRuntimeIds,
+  DATABASE_BINDINGS,
+  DEFAULT_FILE_TIMEOUT_SECONDS,
+  normalizeDatabaseBinding,
   normalizeExecutionConfig,
-  parseStackCountOption,
-  parseStackModeOption,
+  normalizeRuntimeInstances,
+  parseFileTimeoutOption,
+  parseRuntimeInstancesOption,
   parseWorkersOption,
-  resolveBatchAccessMode,
-  resolveBatchStackMode,
   resolveExecutionConfig,
 } from "./execution-config.mjs";
 
 describe("execution-config", () => {
-  it("parses worker and stack CLI options", () => {
+  it("parses worker and runtime-instance options", () => {
     expect(parseWorkersOption("8")).toBe(8);
-    expect(parseStackCountOption("2")).toBe(2);
-    expect(parseStackModeOption("pooled")).toBe("pooled");
+    expect(parseRuntimeInstancesOption("2")).toBe(2);
+    expect(parseFileTimeoutOption("45")).toBe(45);
     expect(() => parseWorkersOption("0")).toThrow('Invalid --workers value "0"');
-    expect(() => parseStackModeOption("legacy")).toThrow('Invalid --stack-mode value "legacy"');
+    expect(() => parseRuntimeInstancesOption("0")).toThrow('Invalid runtime.instances value "0"');
+    expect(() => parseFileTimeoutOption("0")).toThrow(
+      'Invalid --file-timeout-seconds value "0"'
+    );
   });
 
-  it("normalizes shared, pooled, and isolated execution shapes", () => {
-    expect(normalizeExecutionConfig({ workers: 8, stackMode: "shared" })).toEqual({
+  it("normalizes execution defaults", () => {
+    expect(normalizeExecutionConfig({ workers: 8 })).toEqual({
       workers: 8,
-      stackMode: "shared",
-      stackCount: 1,
+      fileTimeoutSeconds: DEFAULT_FILE_TIMEOUT_SECONDS,
     });
-
-    expect(normalizeExecutionConfig({ workers: 8, stackMode: "pooled", stackCount: 3 })).toEqual({
-      workers: 8,
-      stackMode: "pooled",
-      stackCount: 3,
-    });
-
-    expect(normalizeExecutionConfig({ workers: 8, stackMode: "isolated" })).toEqual({
-      workers: 8,
-      stackMode: "isolated",
-      stackCount: 8,
-    });
-  });
-
-  it("rejects invalid stack-count combinations", () => {
-    expect(() =>
-      normalizeExecutionConfig({ workers: 8, stackMode: "shared", stackCount: 2 })
-    ).toThrow('execution.stackCount must be 1 when stackMode is "shared"');
-
-    expect(() =>
-      normalizeExecutionConfig({ workers: 8, stackMode: "isolated", stackCount: 2 })
-    ).toThrow('execution.stackCount must equal execution.workers when stackMode is "isolated"');
   });
 
   it("applies CLI values over repo execution defaults", () => {
     expect(
       resolveExecutionConfig({
-        repo: { workers: 3, stackMode: "shared" },
-        cli: { workers: 6, stackMode: "pooled", stackCount: 2 },
+        repo: { workers: 3, fileTimeoutSeconds: 30 },
+        cli: { workers: 6, fileTimeoutSeconds: 90 },
       })
     ).toEqual({
       workers: 6,
-      stackMode: "pooled",
-      stackCount: 2,
+      fileTimeoutSeconds: 90,
     });
   });
 
-  it("builds stack ids from the normalized execution shape", () => {
-    expect(buildStackIds({ stackMode: "shared", stackCount: 1 })).toEqual(["shared"]);
-    expect(buildStackIds({ stackMode: "pooled", stackCount: 2 })).toEqual([
-      "stack-1",
-      "stack-2",
-    ]);
+  it("builds runtime ids from an instance count", () => {
+    expect(buildRuntimeIds(3)).toEqual(["runtime-1", "runtime-2", "runtime-3"]);
   });
 
-  it("resolves batch stack and access modes", () => {
-    expect(resolveBatchStackMode("shared", null)).toBe("shared");
-    expect(resolveBatchStackMode("shared", "isolated")).toBe("isolated");
-
-    expect(
-      resolveBatchAccessMode({
-        framework: "k6",
-        type: "integration",
-        stackMode: "shared",
-      })
-    ).toBe("shared");
-
-    expect(
-      resolveBatchAccessMode({
-        framework: "playwright",
-        type: "e2e",
-        stackMode: "pooled",
-      })
-    ).toBe("exclusive");
-
-    expect(
-      resolveBatchAccessMode({
-        framework: "k6",
-        type: "dal",
-        stackMode: "shared",
-      })
-    ).toBe("exclusive");
+  it("normalizes runtime instances and database bindings", () => {
+    expect(normalizeRuntimeInstances(2)).toBe(2);
+    for (const binding of DATABASE_BINDINGS) {
+      expect(normalizeDatabaseBinding(binding)).toBe(binding);
+    }
+    expect(() => normalizeDatabaseBinding("legacy")).toThrow(
+      'Invalid database.binding value "legacy"'
+    );
   });
 });

package/lib/runner/formatting.mjs

@@ -36,21 +36,6 @@ export function longestServiceName(results) {
   return results.reduce((max, result) => Math.max(max, result.name.length), 4);
 }
 
-export function formatBatchDescriptor(batch) {
-  const fileLabel = `${batch.tasks.length} file${batch.tasks.length === 1 ? "" : "s"}`;
-  const frameworkLabel = formatFrameworkLabel(batch.framework);
-  return frameworkLabel ? ` (${frameworkLabel}, ${fileLabel})` : ` (${fileLabel})`;
-}
-
-export function formatPlaywrightBatchFiles(batch) {
-  if (!batch?.tasks?.length) return "";
-  const files = batch.tasks.map((task) => task.file);
-  if (files.length === 1) return ` · ${files[0]}`;
-  const preview = files.slice(0, 3).join(", ");
-  const suffix = files.length > 3 ? `, +${files.length - 3} more` : "";
-  return ` · ${preview}${suffix}`;
-}
-
 export function formatFrameworkLabel(framework) {
   if (!framework || framework === "k6") return "";
   return framework;

package/lib/runner/formatting.test.mjs

@@ -1,11 +1,9 @@
 import { describe, expect, it } from "vitest";
 import {
   buildRunSummaryLines,
-  formatBatchDescriptor,
   formatDuration,
   formatError,
   formatFrameworkLabel,
-  formatPlaywrightBatchFiles,
   formatServiceSummary,
   formatSuiteFramework,
   longestServiceName,
@@ -53,22 +51,6 @@ describe("runner formatting", () => {
     ).toBe("1/2 suites passed, 1/3 files passed, 1 suite skipped");
   });
 
-  it("formats batch descriptors", () => {
-    expect(formatBatchDescriptor({ framework: "k6", tasks: [{}, {}] })).toBe(" (2 files)");
-    expect(formatBatchDescriptor({ framework: "playwright", tasks: [{}] })).toBe(
-      " (playwright, 1 file)"
-    );
-  });
-
-  it("formats Playwright file previews", () => {
-    expect(formatPlaywrightBatchFiles({ tasks: [{ file: "a" }] })).toBe(" · a");
-    expect(
-      formatPlaywrightBatchFiles({
-        tasks: [{ file: "a" }, { file: "b" }, { file: "c" }, { file: "d" }],
-      })
-    ).toBe(" · a, b, c, +1 more");
-  });
-
   it("formats framework labels", () => {
     expect(formatFrameworkLabel("k6")).toBe("");
     expect(formatFrameworkLabel("playwright")).toBe("playwright");

package/lib/runner/lifecycle.mjs

@@ -21,7 +21,7 @@ export function createRunLifecycle(productDir) {
     interruptReason: null,
     services: [],
     graphDirs: [],
-    stackStateDirs: [],
+    runtimeDirs: [],
     runtimeStateDirs: [],
   };
   const signalListeners = [];
@@ -66,7 +66,7 @@ export function createRunLifecycle(productDir) {
     trackGraphContext(context) {
       mutate((draft) => {
         pushUnique(draft.graphDirs, context.graphDir);
-        pushUnique(draft.stackStateDirs, context.stackStateDir);
+        pushUnique(draft.runtimeDirs, context.runtimeDir);
         for (const runtimeConfig of context.runtimeConfigs || []) {
           if (runtimeConfig.stateDir) pushUnique(draft.runtimeStateDirs, runtimeConfig.stateDir);
         }
@@ -78,7 +78,7 @@ export function createRunLifecycle(productDir) {
         draft.services = draft.services.filter((service) => service.pid !== child.pid);
         draft.services.push({
           serviceName: config.name,
-          stackLabel: config.stackLabel,
+          runtimeLabel: config.runtimeLabel,
           command: config.testkit.local?.start || null,
           cwd,
           pid: child.pid,
@@ -195,8 +195,8 @@ export function findPortOwner(productDir, { host, port }) {
 }
 
 export function formatRunSummary(manifest) {
-  const stackLabels = [...new Set((manifest.services || []).map((service) => service.stackLabel).filter(Boolean))];
-  return `${manifest.runId} pid=${manifest.pid}${stackLabels.length > 0 ? ` stacks=${stackLabels.join(",")}` : ""}`;
+  const runtimeLabels = [...new Set((manifest.services || []).map((service) => service.runtimeLabel).filter(Boolean))];
+  return `${manifest.runId} pid=${manifest.pid}${runtimeLabels.length > 0 ? ` runtimes=${runtimeLabels.join(",")}` : ""}`;
 }
 
 export function isPidRunning(pid) {
@@ -220,8 +220,8 @@ async function cleanupRunManifest(productDir, manifest, { removeRuntimeState = f
       await destroyRuntimeDatabase({ productDir, stateDir });
     }
 
-    for (const stackStateDir of [...new Set(manifest.stackStateDirs || [])].sort((a, b) => b.length - a.length)) {
-      fs.rmSync(stackStateDir, { recursive: true, force: true });
+    for (const runtimeDir of [...new Set(manifest.runtimeDirs || [])].sort((a, b) => b.length - a.length)) {
+      fs.rmSync(runtimeDir, { recursive: true, force: true });
     }
 
     for (const graphDir of [...new Set(manifest.graphDirs || [])].sort((a, b) => b.length - a.length)) {

package/lib/runner/orchestrator.mjs

@@ -2,7 +2,7 @@ import {
   applyShard,
   buildRuntimeGraphs,
   buildTaskQueue,
-  claimNextBatch,
+  claimNextTask,
   collectSuites,
   resolveRuntimeConfigs,
 } from "./planning.mjs";
@@ -36,7 +36,7 @@ import {
   safeUsername,
 } from "./metadata.mjs";
 import { resolveExecutionConfig } from "./execution-config.mjs";
-import { createStackManager } from "./stack-manager.mjs";
+import { createRuntimeManager } from "./runtime-manager.mjs";
 import { createWorker, runWorker } from "./worker-loop.mjs";
 import { findUnmatchedRequestedFiles, isFullRunSelection } from "./selection.mjs";
 import { uploadTelemetryArtifact } from "../telemetry/index.mjs";
@@ -105,7 +105,7 @@ export async function runAll(configs, typeValues, suiteSelectors, opts, allConfi
   const trackers = buildServiceTrackers(servicePlans, startedAt);
   const executedPlans = servicePlans.filter((plan) => !plan.skipped);
   let workerCount = 0;
-  let stackCount = 0;
+  let runtimeInstanceCount = 0;
   let exitCode = 0;
   const lifecycle = createRunLifecycle(productDir);
   lifecycle.markRunning();
@@ -119,14 +119,13 @@ export async function runAll(configs, typeValues, suiteSelectors, opts, allConfi
       const graphs = buildRuntimeGraphs(executedPlans);
       const queue = buildTaskQueue(executedPlans, graphs, timings);
       workerCount = Math.max(1, Math.min(execution.workers, queue.length));
-      stackCount = execution.stackMode === "shared" ? 1 : execution.stackCount;
+      runtimeInstanceCount = graphs.reduce((sum, graph) => sum + graph.instanceCount, 0);
       const workers = Array.from({ length: workerCount }, (_unused, index) =>
         createWorker(index + 1, productDir)
       );
-      const stackManager = createStackManager({
+      const runtimeManager = createRuntimeManager({
         productDir,
         graphs,
-        execution,
         lifecycle,
       });
       const timingUpdates = [];
@@ -137,11 +136,11 @@ export async function runAll(configs, typeValues, suiteSelectors, opts, allConfi
             runWorker(
               worker,
               queue,
-              stackManager,
+              runtimeManager,
               trackers,
               timingUpdates,
               lifecycle,
-              claimNextBatch,
+              claimNextTask,
               recordTaskOutcome,
               recordGraphError
             )
@@ -157,7 +156,7 @@ export async function runAll(configs, typeValues, suiteSelectors, opts, allConfi
           }
         }
       } finally {
-        await stackManager.cleanupAll();
+        await runtimeManager.cleanupAll();
       }
 
       saveTimings(productDir, timings, timingUpdates);
@@ -174,7 +173,7 @@ export async function runAll(configs, typeValues, suiteSelectors, opts, allConfi
       finishedAt,
       execution,
       workerCount,
-      stackCount,
+      runtimeInstanceCount,
       typeValues,
       suiteSelectors,
       fileNames: requestedFiles,