@elench/testkit 0.1.40 → 0.1.41

package/lib/runner/services.mjs

@@ -36,12 +36,12 @@ export async function startLocalService(config, lifecycle) {
 
   await assertLocalServicePortsAvailable(config, isPortInUse);
 
-  console.log(`Starting ${config.stackLabel}:${config.name}: ${config.testkit.local.start}`);
+  console.log(`Starting ${config.runtimeLabel}:${config.name}: ${config.testkit.local.start}`);
   const child = startDetachedCommand(config.testkit.local.start, cwd, env);
 
   const outputDrains = [
-    pipeOutput(child.stdout, `[${config.stackLabel}:${config.name}]`),
-    pipeOutput(child.stderr, `[${config.stackLabel}:${config.name}]`),
+    pipeOutput(child.stdout, `[${config.runtimeLabel}:${config.name}]`),
+    pipeOutput(child.stderr, `[${config.runtimeLabel}:${config.name}]`),
   ];
   lifecycle.registerService(config, child, cwd);
 
@@ -49,7 +49,7 @@ export async function startLocalService(config, lifecycle) {
 
   try {
     await waitForReady({
-      name: `${config.stackLabel}:${config.name}`,
+      name: `${config.runtimeLabel}:${config.name}`,
       url: config.testkit.local.readyUrl,
       timeoutMs: readyTimeoutMs,
       process: child,

package/lib/runner/state.mjs

@@ -46,8 +46,7 @@ export function writeGraphMetadata(graphDir, graph) {
   fs.mkdirSync(graphDir, { recursive: true });
   const metadata = {
     runtimeServices: graph.runtimeNames,
-    assignedTargets: [...graph.assignedTargets].sort(),
-    rootService: graph.rootConfig.name,
+    targetServices: [...(graph.targetNames || [])].sort(),
   };
   fs.writeFileSync(
     path.join(graphDir, GRAPH_METADATA),

package/lib/runner/state.test.mjs

@@ -48,14 +48,12 @@ describe("runner-state", () => {
     const graphDir = path.join(productDir, ".testkit", "_graphs", "api__frontend");
     writeGraphMetadata(graphDir, {
       runtimeNames: ["api", "frontend"],
-      assignedTargets: ["frontend", "api"],
-      rootConfig: { name: "api" },
+      targetNames: ["frontend", "api"],
     });
 
     expect(readGraphMetadata(graphDir)).toEqual({
       runtimeServices: ["api", "frontend"],
-      assignedTargets: ["api", "frontend"],
-      rootService: "api",
+      targetServices: ["api", "frontend"],
     });
 
     expect(findGraphDirsForService(productDir, "frontend")).toEqual([graphDir]);

package/lib/runner/template.mjs

@@ -3,26 +3,28 @@ import { readDatabaseInfo } from "./state-io.mjs";
 
 const PORT_STRIDE = 100;
 
-export function resolveStackRuntimeConfigs(targetConfig, runtimeConfigs, stackId, stackStateDir) {
-  const portMap = buildPortMap(runtimeConfigs, stackId);
+export function resolveRuntimeInstanceConfigs(runtimeConfigs, runtimeId, runtimeDir, options = {}) {
+  const runtimeLabel = buildRuntimeLabel(options.graphDirName, runtimeId);
+  const portMap = buildPortMap(runtimeConfigs, runtimeId, {
+    index: options.portNamespaceIndex || 0,
+    stride: options.portNamespaceStride || 1,
+  });
   const baseUrlByService = new Map();
   const readyUrlByService = new Map();
   const stateDirByService = new Map();
 
   for (const config of runtimeConfigs) {
-    stateDirByService.set(
-      config.name,
-      resolveServiceStateDir(stackStateDir, targetConfig.name, config)
-    );
+    stateDirByService.set(config.name, resolveServiceStateDir(runtimeDir, config));
   }
 
   for (const config of runtimeConfigs) {
     if (!config.testkit.local) continue;
     baseUrlByService.set(
       config.name,
-      resolveRuntimeUrl(config.testkit.local.baseUrl, config.name, targetConfig, stackId, {
-        stackId,
-        stackStateDir,
+      resolveRuntimeUrl(config.testkit.local.baseUrl, config.name, runtimeId, {
+        runtimeId,
+        runtimeLabel,
+        runtimeDir,
         portMap,
         baseUrlByService,
         readyUrlByService,
@@ -31,9 +33,10 @@ export function resolveStackRuntimeConfigs(targetConfig, runtimeConfigs, stackId
     );
     readyUrlByService.set(
       config.name,
-      resolveRuntimeUrl(config.testkit.local.readyUrl, config.name, targetConfig, stackId, {
-        stackId,
-        stackStateDir,
+      resolveRuntimeUrl(config.testkit.local.readyUrl, config.name, runtimeId, {
+        runtimeId,
+        runtimeLabel,
+        runtimeDir,
         portMap,
         baseUrlByService,
         readyUrlByService,
@@ -47,20 +50,16 @@ export function resolveStackRuntimeConfigs(targetConfig, runtimeConfigs, stackId
     if (!config.testkit.local) continue;
     const resolvedBaseUrl = baseUrlByService.get(config.name);
     const resolvedReadyUrl = readyUrlByService.get(config.name);
-    if (resolvedBaseUrl) {
-      urlMappings.push([config.testkit.local.baseUrl, resolvedBaseUrl]);
-    }
-    if (resolvedReadyUrl) {
-      urlMappings.push([config.testkit.local.readyUrl, resolvedReadyUrl]);
-    }
+    if (resolvedBaseUrl) urlMappings.push([config.testkit.local.baseUrl, resolvedBaseUrl]);
+    if (resolvedReadyUrl) urlMappings.push([config.testkit.local.readyUrl, resolvedReadyUrl]);
   }
 
   return runtimeConfigs.map((config) =>
-    resolveStackConfig(
+    resolveRuntimeConfig(
       config,
-      targetConfig,
-      stackId,
-      stackStateDir,
+      runtimeId,
+      runtimeLabel,
+      runtimeDir,
       portMap,
       baseUrlByService,
       readyUrlByService,
@@ -70,10 +69,10 @@ export function resolveStackRuntimeConfigs(targetConfig, runtimeConfigs, stackId
   );
 }
 
-export function buildPortMap(runtimeConfigs, stackId) {
+export function buildPortMap(runtimeConfigs, runtimeId, namespace = {}) {
   const portMap = new Map();
   const seen = new Map();
-  const offset = stackPortOffset(stackId);
+  const offset = runtimePortOffset(runtimeId, namespace);
 
   for (const config of runtimeConfigs) {
     if (!config.testkit.local) continue;
@@ -82,10 +81,16 @@ export function buildPortMap(runtimeConfigs, stackId) {
     if (!basePort) continue;
 
     const actualPort = basePort + offset;
+    if (actualPort > 65_535) {
+      throw new Error(
+        `Runtime port resolution exceeded 65535 for service "${config.name}" (${actualPort}). ` +
+          `Reduce runtime instances or choose lower local.port/baseUrl ports in testkit.setup.ts.`
+      );
+    }
     const existing = seen.get(actualPort);
     if (existing) {
       throw new Error(
-        `Stack port collision: services "${existing}" and "${config.name}" both resolve to ${actualPort}. ` +
+        `Runtime port collision: services "${existing}" and "${config.name}" both resolve to ${actualPort}. ` +
           `Assign distinct local.port/baseUrl ports in testkit.setup.ts.`
       );
     }
@@ -96,21 +101,22 @@ export function buildPortMap(runtimeConfigs, stackId) {
   return portMap;
 }
 
-export function resolveStackConfig(
+export function resolveRuntimeConfig(
   config,
-  targetConfig,
-  stackId,
-  stackStateDir,
+  runtimeId,
+  runtimeLabel,
+  runtimeDir,
   portMap,
   baseUrlByService,
   readyUrlByService,
   stateDirByService,
   urlMappings
 ) {
-  const stateDir = resolveServiceStateDir(stackStateDir, targetConfig.name, config);
+  const stateDir = resolveServiceStateDir(runtimeDir, config);
   const context = {
-    stackId,
-    targetName: targetConfig.name,
+    runtimeId,
+    runtimeLabel,
+    runtimeDir,
     serviceName: config.name,
     serviceStateDir: stateDir,
     portMap,
@@ -118,6 +124,8 @@ export function resolveStackConfig(
     readyUrlByService,
     stateDirByService,
     urlMappings,
+    leaseId: null,
+    leaseDir: null,
   };
 
   const database = config.testkit.database
@@ -166,9 +174,8 @@ export function resolveStackConfig(
   return {
     ...config,
     stateDir,
-    stackId,
-    stackLabel: stackId,
-    targetName: targetConfig.name,
+    runtimeId,
+    runtimeLabel,
     testkit: {
       ...config.testkit,
       database,
@@ -180,52 +187,66 @@ export function resolveStackConfig(
   };
 }
 
-export function resolveServiceStateDir(stackStateDir, targetName, config) {
-  const dbSource = config.testkit.databaseFrom || config.name;
-  return getStackServiceStateDir(stackStateDir, targetName, dbSource);
+export function resolveServiceStateDir(runtimeDir, config) {
+  return path.join(runtimeDir, "services", config.name);
 }
 
-export function getStackServiceStateDir(stackStateDir, targetName, serviceName) {
-  if (targetName === serviceName) {
-    return stackStateDir;
-  }
-  return path.join(stackStateDir, "deps", serviceName);
+export function buildExecutionEnv(config, extraEnv = {}, processEnv = process.env) {
+  return buildExecutionEnvWithContext(config, null, extraEnv, processEnv);
 }
 
-export function buildExecutionEnv(config, extraEnv = {}, processEnv = process.env) {
+export function buildTaskExecutionEnv(config, lease, extraEnv = {}, processEnv = process.env) {
+  return buildExecutionEnvWithContext(config, lease, extraEnv, processEnv);
+}
+
+function buildExecutionEnvWithContext(config, lease, extraEnv, processEnv) {
   const inheritedEnv = { ...processEnv };
-  const templateContext = config.testkit?.templateContext;
+  const templateContext = buildTemplateContext(config, lease);
   const env = {
     ...inheritedEnv,
     ...resolveEnvTemplates(config.testkit.serviceEnv || {}, templateContext),
     ...resolveEnvTemplates(extraEnv, templateContext),
     TESTKIT_ACTIVE: "1",
-    ...(config.stackId ? { TESTKIT_STACK_ID: String(config.stackId) } : {}),
+    ...(config.runtimeId ? { TESTKIT_RUNTIME_ID: String(config.runtimeId) } : {}),
+    ...(lease?.leaseId ? { TESTKIT_LEASE_ID: String(lease.leaseId) } : {}),
+    ...(lease?.leaseDir ? { TESTKIT_LEASE_DIR: lease.leaseDir } : {}),
   };
   delete env.DATABASE_URL;
   return env;
 }
 
-export function buildPlaywrightEnv(config, baseUrl, processEnv = process.env) {
-  return buildExecutionEnv(
+export function buildPlaywrightEnv(config, baseUrl, lease, processEnv = process.env) {
+  return buildTaskExecutionEnv(
     config,
+    lease,
     {
       BASE_URL: baseUrl,
       PLAYWRIGHT_HTML_OPEN: "never",
       PLAYWRIGHT_SKIP_VALIDATE_HOST_REQUIREMENTS:
         processEnv.PLAYWRIGHT_SKIP_VALIDATE_HOST_REQUIREMENTS || "1",
       TESTKIT_MANAGED_SERVERS: "1",
-      TESTKIT_STACK_ID: String(config.stackId),
     },
     processEnv
   );
 }
 
-export function resolveRuntimeUrl(rawUrl, serviceName, targetConfig, stackId, context) {
+function buildTemplateContext(config, lease) {
+  const baseContext = config.testkit?.templateContext || {};
+  return {
+    ...baseContext,
+    runtimeId: config.runtimeId || baseContext.runtimeId || null,
+    runtimeLabel: config.runtimeLabel || baseContext.runtimeLabel || null,
+    serviceName: config.name,
+    serviceStateDir: config.stateDir || baseContext.serviceStateDir || null,
+    leaseId: lease?.leaseId || null,
+    leaseDir: lease?.leaseDir || null,
+  };
+}
+
+export function resolveRuntimeUrl(rawUrl, serviceName, runtimeId, context) {
   const resolved = resolveTemplateString(rawUrl, {
     ...context,
-    targetName: targetConfig.name,
-    stackId,
+    runtimeId,
     serviceName,
   });
   const actualPort = context.portMap.get(serviceName);
@@ -247,14 +268,16 @@ export function resolveTemplateString(value, context) {
 
   return value.replace(/\{([a-zA-Z]+)(?::([a-zA-Z0-9_-]+))?\}/g, (_match, token, arg) => {
     switch (token) {
-      case "stack":
-        return String(context.stackId);
-      case "target":
-        return context.targetName;
+      case "runtime":
+        return String(context.runtimeId);
       case "service":
         return context.serviceName;
       case "stateDir":
         return context.serviceStateDir;
+      case "lease":
+        return context.leaseId ? String(context.leaseId) : "";
+      case "leaseDir":
+        return context.leaseDir || "";
       case "port": {
         const serviceName = arg || context.serviceName;
         const port = context.portMap.get(serviceName);
@@ -381,8 +404,15 @@ export function normalizeSocketHost(hostname) {
   return hostname;
 }
 
-function stackPortOffset(stackId) {
-  const match = String(stackId).match(/(\d+)$/);
-  if (!match) return 0;
-  return PORT_STRIDE * (Number.parseInt(match[1], 10) - 1);
+function runtimePortOffset(runtimeId, namespace = {}) {
+  const match = String(runtimeId).match(/(\d+)$/);
+  const runtimeIndex = match ? Number.parseInt(match[1], 10) - 1 : 0;
+  const namespaceIndex = Math.max(0, Number(namespace.index || 0));
+  const namespaceStride = Math.max(1, Number(namespace.stride || 1));
+  return PORT_STRIDE * (namespaceIndex * namespaceStride + runtimeIndex);
+}
+
+function buildRuntimeLabel(graphDirName, runtimeId) {
+  if (!graphDirName) return runtimeId;
+  return `${graphDirName}/${runtimeId}`;
 }

package/lib/runner/template.test.mjs

@@ -6,12 +6,12 @@ import {
   buildExecutionEnv,
   buildPlaywrightEnv,
   buildPortMap,
+  buildTaskExecutionEnv,
   finalizeString,
-  getStackServiceStateDir,
   normalizeSocketHost,
   numericPortFromUrl,
+  resolveRuntimeInstanceConfigs,
   resolveServiceStateDir,
-  resolveStackRuntimeConfigs,
   resolveTemplateString,
   rewriteUrlPort,
   socketFromUrl,
@@ -20,12 +20,15 @@ import {
 function makeRuntimeConfig(name, local, extras = {}) {
   return {
     name,
+    stateDir: extras.stateDir,
+    runtimeId: extras.runtimeId,
     testkit: {
       local,
       serviceEnv: extras.serviceEnv || {},
       databaseFrom: extras.databaseFrom,
       migrate: extras.migrate,
       seed: extras.seed,
+      templateContext: extras.templateContext,
     },
   };
 }
@@ -37,10 +40,14 @@ describe("runner-template", () => {
       makeRuntimeConfig("frontend", { port: 3001, baseUrl: "http://127.0.0.1:{port}" }),
     ];
 
-    expect([...buildPortMap(configs, "stack-2").entries()]).toEqual([
+    expect([...buildPortMap(configs, "runtime-2").entries()]).toEqual([
       ["api", 3100],
       ["frontend", 3101],
     ]);
+    expect([...buildPortMap(configs, "runtime-1", { index: 1, stride: 2 }).entries()]).toEqual([
+      ["api", 3200],
+      ["frontend", 3201],
+    ]);
 
     expect(() =>
       buildPortMap(
@@ -48,9 +55,10 @@ describe("runner-template", () => {
           makeRuntimeConfig("api", { port: 3000, baseUrl: "http://127.0.0.1:{port}" }),
           makeRuntimeConfig("other", { port: 3000, baseUrl: "http://127.0.0.1:{port}" }),
         ],
-        "shared"
+        "runtime-1",
+        { index: 0, stride: 2 }
       )
-    ).toThrow("Stack port collision");
+    ).toThrow("Runtime port collision");
   });
 
   it("resolves template strings and URL rewrites", () => {
@@ -59,12 +67,11 @@ describe("runner-template", () => {
     fs.mkdirSync(apiStateDir, { recursive: true });
     fs.writeFileSync(
       path.join(apiStateDir, "database_url"),
-      "postgres://testkit:testkit@127.0.0.1:55432/onix_db"
+      "postgres://testkit:testkit@127.0.0.1:55432/runtime_db"
     );
 
     const context = {
-      stackId: "stack-2",
-      targetName: "frontend",
+      runtimeId: "runtime-2",
       serviceName: "frontend",
       serviceStateDir: "/tmp/state",
       portMap: new Map([
@@ -75,14 +82,16 @@ describe("runner-template", () => {
       readyUrlByService: new Map([["api", "http://127.0.0.1:3100/health"]]),
       stateDirByService: new Map([["api", apiStateDir]]),
       urlMappings: [["http://api:3000", "http://127.0.0.1:3100"]],
+      leaseId: "lease-1",
+      leaseDir: "/tmp/lease-1",
     };
 
-    expect(resolveTemplateString("{stack}:{target}:{service}", context)).toBe(
-      "stack-2:frontend:frontend"
+    expect(resolveTemplateString("{runtime}:{service}:{lease}", context)).toBe(
+      "runtime-2:frontend:lease-1"
     );
     expect(resolveTemplateString("{baseUrl:api}", context)).toBe("http://127.0.0.1:3100");
     expect(resolveTemplateString("{dbHost:api}:{dbPort:api}/{dbName:api}", context)).toBe(
-      "127.0.0.1:55432/onix_db"
+      "127.0.0.1:55432/runtime_db"
     );
     expect(finalizeString("API={baseUrl:api} OLD=http://api:3000", context)).toBe(
       "API=http://127.0.0.1:3100 OLD=http://127.0.0.1:3100"
@@ -92,8 +101,8 @@ describe("runner-template", () => {
     );
   });
 
-  it("builds stack runtime configs and execution env", () => {
-    const stackStateDir = fs.mkdtempSync(path.join(os.tmpdir(), "testkit-stack-"));
+  it("builds runtime configs and execution env", () => {
+    const runtimeDir = fs.mkdtempSync(path.join(os.tmpdir(), "testkit-runtime-"));
     const api = makeRuntimeConfig(
       "api",
       {
@@ -120,22 +129,23 @@ describe("runner-template", () => {
       readyUrl: "http://127.0.0.1:{port}",
       env: {
         NEXT_PUBLIC_API_URL: "{baseUrl:api}",
-        ONIX_DB_HOST: "{dbHost:api}",
+        API_DB_HOST: "{dbHost:api}",
       },
     });
 
-    const resolved = resolveStackRuntimeConfigs(frontend, [api, frontend], "stack-2", stackStateDir);
+    const resolved = resolveRuntimeInstanceConfigs([api, frontend], "runtime-2", runtimeDir, {
+      graphDirName: "api__frontend",
+      portNamespaceIndex: 0,
+      portNamespaceStride: 2,
+    });
     expect(resolved[0].testkit.local.port).toBe(3100);
-    expect(resolved[1].testkit.local.env.NEXT_PUBLIC_API_URL).toBe("{baseUrl:api}");
-    expect(resolveServiceStateDir(stackStateDir, "frontend", api)).toBe(
-      `${stackStateDir}/deps/api`
-    );
-    expect(getStackServiceStateDir(stackStateDir, "frontend", "frontend")).toBe(stackStateDir);
+    expect(resolved[0].runtimeLabel).toBe("api__frontend/runtime-2");
+    expect(resolveServiceStateDir(runtimeDir, api)).toBe(`${runtimeDir}/services/api`);
 
-    fs.mkdirSync(path.join(stackStateDir, "deps", "api"), { recursive: true });
+    fs.mkdirSync(path.join(runtimeDir, "services", "api"), { recursive: true });
     fs.writeFileSync(
-      path.join(stackStateDir, "deps", "api", "database_url"),
-      "postgres://testkit:testkit@127.0.0.1:55432/onix_db"
+      path.join(runtimeDir, "services", "api", "database_url"),
+      "postgres://testkit:testkit@127.0.0.1:55432/runtime_db"
     );
 
     expect(
@@ -152,16 +162,38 @@ describe("runner-template", () => {
     ).toEqual({
       PATH: "/usr/bin",
       NEXT_PUBLIC_API_URL: "http://127.0.0.1:3100",
-      ONIX_DB_HOST: "127.0.0.1",
+      API_DB_HOST: "127.0.0.1",
       TESTKIT_ACTIVE: "1",
-      TESTKIT_STACK_ID: "stack-2",
+      TESTKIT_RUNTIME_ID: "runtime-2",
+    });
+
+    expect(
+      buildTaskExecutionEnv(
+        resolved[1],
+        {
+          leaseId: "lease-1",
+          leaseDir: "/tmp/lease-1",
+        },
+        {},
+        {}
+      )
+    ).toMatchObject({
+      TESTKIT_RUNTIME_ID: "runtime-2",
+      TESTKIT_LEASE_ID: "lease-1",
+      TESTKIT_LEASE_DIR: "/tmp/lease-1",
     });
 
     expect(
-      buildPlaywrightEnv({ stackId: "shared", testkit: { serviceEnv: {} } }, "http://localhost:3000", {})
+      buildPlaywrightEnv(
+        { runtimeId: "runtime-1", testkit: { serviceEnv: {}, templateContext: {} } },
+        "http://localhost:3000",
+        { leaseId: "lease-2", leaseDir: "/tmp/lease-2" },
+        {}
+      )
     ).toMatchObject({
       BASE_URL: "http://localhost:3000",
-      TESTKIT_STACK_ID: "shared",
+      TESTKIT_RUNTIME_ID: "runtime-1",
+      TESTKIT_LEASE_ID: "lease-2",
       PLAYWRIGHT_HTML_OPEN: "never",
     });
   });

package/lib/runner/worker-loop.mjs

@@ -1,6 +1,6 @@
 import { formatError } from "./formatting.mjs";
-import { runDalBatch, runHttpK6Batch } from "./default-runtime-runner.mjs";
-import { runPlaywrightBatch } from "./playwright-runner.mjs";
+import { runDalTask, runHttpK6Task } from "./default-runtime-runner.mjs";
+import { runPlaywrightTask } from "./playwright-runner.mjs";
 
 const HTTP_K6_TYPES = new Set(["integration", "e2e", "load"]);
 
@@ -17,11 +17,11 @@ export function createWorker(workerId, productDir) {
 export async function runWorker(
   worker,
   queue,
-  stackManager,
+  runtimeManager,
   trackers,
   timingUpdates,
   lifecycle,
-  claimNextBatch,
+  claimNextTask,
   recordTaskOutcome,
   recordGraphError
 ) {
@@ -32,32 +32,29 @@ export async function runWorker(
   try {
     while (true) {
       if (lifecycle.isStopRequested()) break;
-      const batch = claimNextBatch(queue, worker.currentGraphKey);
-      if (!batch) break;
+      const task = claimNextTask(queue, worker.currentGraphKey);
+      if (!task) break;
 
       let lease = null;
       try {
-        if (worker.currentGraphKey && worker.currentGraphKey !== batch.graphKey) {
+        if (worker.currentGraphKey && worker.currentGraphKey !== task.graphKey) {
           worker.graphSwitches += 1;
         }
-        worker.currentGraphKey = batch.graphKey;
-        lease = await stackManager.acquire(batch);
-        const outcomes = await runBatch(lease.context, batch, lifecycle);
-        for (const outcome of outcomes) {
-          recordTaskOutcome(trackers, outcome.task, outcome);
-          timingUpdates.push({
-            key: outcome.task.timingKey,
-            durationMs: outcome.durationMs,
-          });
-          worker.taskCount += 1;
-        }
-        await stackManager.release(lease, { accessMode: batch.accessMode });
+        worker.currentGraphKey = task.graphKey;
+        lease = await runtimeManager.acquire(task);
+        const outcome = await runTask(lease.context, task, lifecycle, lease);
+        recordTaskOutcome(trackers, outcome.task, outcome);
+        timingUpdates.push({
+          key: outcome.task.timingKey,
+          durationMs: outcome.durationMs,
+        });
+        worker.taskCount += 1;
+        await runtimeManager.release(lease);
       } catch (error) {
         const message = formatError(error);
         errors.push(message);
-        recordGraphError(trackers, { assignedTargets: lease?.context?.assignedTargets || [batch.targetName] }, message);
-        await stackManager.release(lease, {
-          accessMode: batch.accessMode,
+        recordGraphError(trackers, { targetNames: lease?.context?.targetNames || [task.targetName] }, message);
+        await runtimeManager.release(lease, {
           invalidate: lease !== null,
         });
       }
@@ -76,23 +73,23 @@ export async function runWorker(
   };
 }
 
-async function runBatch(context, batch, lifecycle) {
-  const targetConfig = context.configByName.get(batch.targetName);
+async function runTask(context, task, lifecycle, lease) {
+  const targetConfig = context.configByName.get(task.targetName);
   if (!targetConfig) {
-    throw new Error(`Stack is missing target config "${batch.targetName}"`);
+    throw new Error(`Runtime instance is missing target config "${task.targetName}"`);
   }
 
-  if (batch.framework === "playwright") {
-    return runPlaywrightBatch(targetConfig, batch, lifecycle);
+  if (task.framework === "playwright") {
+    return runPlaywrightTask(targetConfig, task, lifecycle, lease);
   }
-  if (batch.type === "dal") {
-    return runDalBatch(targetConfig, batch, lifecycle);
+  if (task.type === "dal") {
+    return runDalTask(targetConfig, task, lifecycle, lease);
   }
-  if (batch.framework === "k6" && HTTP_K6_TYPES.has(batch.type)) {
-    return runHttpK6Batch(targetConfig, batch, lifecycle);
+  if (task.framework === "k6" && HTTP_K6_TYPES.has(task.type)) {
+    return runHttpK6Task(targetConfig, task, lifecycle, lease);
   }
 
   throw new Error(
-    `Unsupported task combination for ${batch.targetName}: type=${batch.type} framework=${batch.framework}`
+    `Unsupported task combination for ${task.targetName}: type=${task.type} framework=${task.framework}`
   );
 }