@elench/testkit 0.1.38 → 0.1.39

package/lib/runner/runtime-contexts.mjs

@@ -3,86 +3,77 @@ import path from "path";
 import { execaCommand } from "execa";
 import { resolveServiceCwd } from "../config/index.mjs";
 import { prepareDatabaseRuntime } from "../database/index.mjs";
-import { buildExecutionEnv, resolveWorkerRuntimeConfigs } from "./template.mjs";
+import { buildExecutionEnv, resolveStackRuntimeConfigs } from "./template.mjs";
 import { writeGraphMetadata } from "./state.mjs";
 import { startLocalServices, stopLocalServices } from "./services.mjs";
 
-export function createGraphContext(worker, graph) {
-  const graphDir = path.join(worker.productDir, ".testkit", "_graphs", graph.dirName);
-  const workerStateDir = path.join(graphDir, "workers", `worker-${worker.workerId}`);
-  fs.mkdirSync(workerStateDir, { recursive: true });
+export function createStackContext(stackId, graph, productDir) {
+  const graphDir = path.join(productDir, ".testkit", "_graphs", graph.dirName);
+  const stackStateDir = path.join(graphDir, "stacks", stackId);
+  fs.mkdirSync(stackStateDir, { recursive: true });
   writeGraphMetadata(graphDir, graph);
 
-  const runtimeConfigs = resolveWorkerRuntimeConfigs(
+  const runtimeConfigs = resolveStackRuntimeConfigs(
     graph.rootConfig,
     graph.runtimeConfigs,
-    worker.workerId,
-    workerStateDir
+    stackId,
+    stackStateDir
   );
 
   return {
     graphKey: graph.key,
+    assignedTargets: [...graph.assignedTargets],
     graphDir,
-    workerStateDir,
+    stackId,
+    stackStateDir,
     runtimeConfigs,
     configByName: new Map(runtimeConfigs.map((config) => [config.name, config])),
     prepared: false,
+    preparationPromise: null,
     started: false,
+    startupPromise: null,
     startedServices: [],
   };
 }
 
-export async function ensureWorkerGraph(worker, batch, graphByKey, lifecycle) {
-  const graph = graphByKey.get(batch.graphKey);
-  if (!graph) {
-    throw new Error(`Unknown graph "${batch.graphKey}"`);
-  }
-
-  if (worker.currentGraphKey && worker.currentGraphKey !== batch.graphKey) {
-    await deactivateGraphContext(worker.graphContexts.get(worker.currentGraphKey), lifecycle);
-    worker.graphSwitches += 1;
-    worker.currentGraphKey = null;
-  }
-
-  let context = worker.graphContexts.get(batch.graphKey);
-  if (!context) {
-    context = createGraphContext(worker, graph);
-    worker.graphContexts.set(batch.graphKey, context);
-    lifecycle.trackGraphContext(context);
-  }
-
+export async function ensureStackContextReady(context, batch, lifecycle) {
   if (!context.prepared) {
-    await prepareDatabases(context.runtimeConfigs);
-    context.prepared = true;
+    if (!context.preparationPromise) {
+      context.preparationPromise = (async () => {
+        await prepareDatabases(context.runtimeConfigs);
+        context.prepared = true;
+      })().finally(() => {
+        context.preparationPromise = null;
+      });
+    }
+    await context.preparationPromise;
   }
 
   if (batchNeedsLocalRuntime(batch) && !context.started) {
-    context.startedServices = await startLocalServices(context.runtimeConfigs, lifecycle);
-    context.started = true;
+    if (!context.startupPromise) {
+      context.startupPromise = (async () => {
+        context.startedServices = await startLocalServices(context.runtimeConfigs, lifecycle);
+        context.started = true;
+      })().finally(() => {
+        context.startupPromise = null;
+      });
+    }
+    await context.startupPromise;
   }
 
-  worker.currentGraphKey = batch.graphKey;
   return context;
 }
 
-export async function deactivateGraphContext(context, lifecycle) {
+export async function deactivateStackContext(context, lifecycle) {
   if (!context?.started) return;
   await stopLocalServices(context.startedServices, lifecycle);
   context.started = false;
   context.startedServices = [];
 }
 
-export async function resetCurrentGraph(worker, lifecycle) {
-  if (!worker.currentGraphKey) return;
-  await deactivateGraphContext(worker.graphContexts.get(worker.currentGraphKey), lifecycle);
-  worker.currentGraphKey = null;
-}
-
-export async function cleanupWorker(worker, lifecycle) {
-  for (const context of worker.graphContexts.values()) {
-    await deactivateGraphContext(context, lifecycle);
-  }
-  worker.currentGraphKey = null;
+export async function cleanupStackContext(context, lifecycle) {
+  if (!context) return;
+  await deactivateStackContext(context, lifecycle);
 }
 
 export async function prepareDatabases(runtimeConfigs) {
@@ -103,7 +94,7 @@ async function runMigrate(config, databaseUrl) {
   const env = buildExecutionEnv(config, {}, process.env);
   if (databaseUrl) env.DATABASE_URL = databaseUrl;
 
-  console.log(`\n── migrate:${config.workerLabel}:${config.name} ──`);
+  console.log(`\n── migrate:${config.stackLabel}:${config.name} ──`);
   await execaCommand(migrate.cmd, {
     cwd: resolveServiceCwd(config.productDir, migrate.cwd),
     env,
@@ -119,7 +110,7 @@ async function runSeed(config, databaseUrl) {
   const env = buildExecutionEnv(config, {}, process.env);
   if (databaseUrl) env.DATABASE_URL = databaseUrl;
 
-  console.log(`\n── seed:${config.workerLabel}:${config.name} ──`);
+  console.log(`\n── seed:${config.stackLabel}:${config.name} ──`);
   await execaCommand(seed.cmd, {
     cwd: resolveServiceCwd(config.productDir, seed.cwd),
     env,

package/lib/runner/services.mjs

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

package/lib/runner/stack-manager.mjs

@@ -0,0 +1,146 @@
+import { buildStackIds } from "./execution-config.mjs";
+import {
+  cleanupStackContext,
+  createStackContext,
+  ensureStackContextReady,
+} from "./runtime-contexts.mjs";
+
+export function createStackManager({ productDir, graphs, execution, lifecycle }) {
+  const graphByKey = new Map(graphs.map((graph) => [graph.key, graph]));
+  const pools = new Map();
+
+  return {
+    async acquire(batch) {
+      const pool = getPool(pools, graphByKey, batch, execution, productDir, lifecycle);
+      while (true) {
+        if (lifecycle.isStopRequested()) {
+          throw lifecycle.signal.reason || new Error("testkit run interrupted");
+        }
+
+        const slot = claimSlot(pool, batch.accessMode);
+        if (!slot) {
+          await sleep(25);
+          continue;
+        }
+
+        try {
+          const context = await getReadyContext(slot, graphByKey, productDir, batch, lifecycle);
+          return {
+            slot,
+            context,
+          };
+        } catch (error) {
+          releaseSlot(slot, batch.accessMode);
+          await invalidateSlot(slot, lifecycle);
+          throw error;
+        }
+      }
+    },
+    async release(lease, options = {}) {
+      if (!lease?.slot) return;
+      releaseSlot(lease.slot, options.accessMode || lease.slot.lastAccessMode);
+      if (options.invalidate) {
+        await invalidateSlot(lease.slot, lifecycle);
+      }
+    },
+    async cleanupAll() {
+      for (const pool of pools.values()) {
+        for (const slot of pool.slots) {
+          await invalidateSlot(slot, lifecycle);
+        }
+      }
+    },
+  };
+}
+
+function getPool(pools, graphByKey, batch, execution, productDir, lifecycle) {
+  const key = `${batch.graphKey}:${batch.stackMode}`;
+  const existing = pools.get(key);
+  if (existing) return existing;
+
+  const graph = graphByKey.get(batch.graphKey);
+  if (!graph) {
+    throw new Error(`Unknown graph "${batch.graphKey}"`);
+  }
+
+  const slots = buildPoolStackIds(batch.stackMode, execution).map((stackId) => ({
+    graph,
+    stackId,
+    context: null,
+    activeSharedCount: 0,
+    exclusiveActive: false,
+    lastAccessMode: null,
+    contextPromise: null,
+  }));
+  const pool = {
+    productDir,
+    lifecycle,
+    slots,
+  };
+  pools.set(key, pool);
+  return pool;
+}
+
+function buildPoolStackIds(stackMode, execution) {
+  if (stackMode === "isolated") {
+    return Array.from({ length: execution.workers }, (_unused, index) => `isolated-${index + 1}`);
+  }
+  if (stackMode === "shared") {
+    return ["shared"];
+  }
+  return buildStackIds({
+    stackMode: "pooled",
+    stackCount: execution.stackCount,
+  });
+}
+
+function claimSlot(pool, accessMode) {
+  if (accessMode === "shared") {
+    const candidates = pool.slots.filter((slot) => !slot.exclusiveActive);
+    if (candidates.length === 0) return null;
+    const slot = [...candidates].sort((left, right) => left.activeSharedCount - right.activeSharedCount)[0];
+    slot.activeSharedCount += 1;
+    slot.lastAccessMode = "shared";
+    return slot;
+  }
+
+  const slot = pool.slots.find((candidate) => !candidate.exclusiveActive && candidate.activeSharedCount === 0);
+  if (!slot) return null;
+  slot.exclusiveActive = true;
+  slot.lastAccessMode = "exclusive";
+  return slot;
+}
+
+async function getReadyContext(slot, graphByKey, productDir, batch, lifecycle) {
+  if (!slot.context) {
+    slot.context = createStackContext(slot.stackId, slot.graph, productDir);
+    lifecycle.trackGraphContext(slot.context);
+  }
+  if (!slot.contextPromise) {
+    slot.contextPromise = Promise.resolve(slot.context);
+  }
+  await slot.contextPromise;
+  await ensureStackContextReady(slot.context, batch, lifecycle);
+  return slot.context;
+}
+
+function releaseSlot(slot, accessMode) {
+  if (accessMode === "shared") {
+    slot.activeSharedCount = Math.max(0, slot.activeSharedCount - 1);
+    return;
+  }
+  slot.exclusiveActive = false;
+}
+
+async function invalidateSlot(slot, lifecycle) {
+  if (!slot.context) return;
+  await cleanupStackContext(slot.context, lifecycle);
+  slot.context = null;
+  slot.contextPromise = null;
+  slot.activeSharedCount = 0;
+  slot.exclusiveActive = false;
+}
+
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}

package/lib/runner/template.mjs

@@ -3,8 +3,8 @@ import { readDatabaseInfo } from "./state-io.mjs";
 
 const PORT_STRIDE = 100;
 
-export function resolveWorkerRuntimeConfigs(targetConfig, runtimeConfigs, workerId, workerStateDir) {
-  const portMap = buildPortMap(runtimeConfigs, workerId);
+export function resolveStackRuntimeConfigs(targetConfig, runtimeConfigs, stackId, stackStateDir) {
+  const portMap = buildPortMap(runtimeConfigs, stackId);
   const baseUrlByService = new Map();
   const readyUrlByService = new Map();
   const stateDirByService = new Map();
@@ -12,7 +12,7 @@ export function resolveWorkerRuntimeConfigs(targetConfig, runtimeConfigs, worker
   for (const config of runtimeConfigs) {
     stateDirByService.set(
       config.name,
-      resolveServiceStateDir(workerStateDir, targetConfig.name, config)
+      resolveServiceStateDir(stackStateDir, targetConfig.name, config)
     );
   }
 
@@ -20,8 +20,9 @@ export function resolveWorkerRuntimeConfigs(targetConfig, runtimeConfigs, worker
     if (!config.testkit.local) continue;
     baseUrlByService.set(
       config.name,
-      resolveRuntimeUrl(config.testkit.local.baseUrl, config.name, targetConfig, workerId, {
-        workerStateDir,
+      resolveRuntimeUrl(config.testkit.local.baseUrl, config.name, targetConfig, stackId, {
+        stackId,
+        stackStateDir,
         portMap,
         baseUrlByService,
         readyUrlByService,
@@ -30,8 +31,9 @@ export function resolveWorkerRuntimeConfigs(targetConfig, runtimeConfigs, worker
     );
     readyUrlByService.set(
       config.name,
-      resolveRuntimeUrl(config.testkit.local.readyUrl, config.name, targetConfig, workerId, {
-        workerStateDir,
+      resolveRuntimeUrl(config.testkit.local.readyUrl, config.name, targetConfig, stackId, {
+        stackId,
+        stackStateDir,
         portMap,
         baseUrlByService,
         readyUrlByService,
@@ -54,11 +56,11 @@ export function resolveWorkerRuntimeConfigs(targetConfig, runtimeConfigs, worker
   }
 
   return runtimeConfigs.map((config) =>
-    resolveWorkerConfig(
+    resolveStackConfig(
       config,
       targetConfig,
-      workerId,
-      workerStateDir,
+      stackId,
+      stackStateDir,
       portMap,
       baseUrlByService,
       readyUrlByService,
@@ -68,10 +70,10 @@ export function resolveWorkerRuntimeConfigs(targetConfig, runtimeConfigs, worker
   );
 }
 
-export function buildPortMap(runtimeConfigs, workerId) {
+export function buildPortMap(runtimeConfigs, stackId) {
   const portMap = new Map();
   const seen = new Map();
-  const offset = PORT_STRIDE * (workerId - 1);
+  const offset = stackPortOffset(stackId);
 
   for (const config of runtimeConfigs) {
     if (!config.testkit.local) continue;
@@ -83,7 +85,7 @@ export function buildPortMap(runtimeConfigs, workerId) {
     const existing = seen.get(actualPort);
     if (existing) {
       throw new Error(
-        `Worker port collision: services "${existing}" and "${config.name}" both resolve to ${actualPort}. ` +
+        `Stack port collision: services "${existing}" and "${config.name}" both resolve to ${actualPort}. ` +
           `Assign distinct local.port/baseUrl ports in testkit.setup.ts.`
       );
     }
@@ -94,22 +96,22 @@ export function buildPortMap(runtimeConfigs, workerId) {
   return portMap;
 }
 
-export function resolveWorkerConfig(
+export function resolveStackConfig(
   config,
   targetConfig,
-  workerId,
-  workerStateDir,
+  stackId,
+  stackStateDir,
   portMap,
   baseUrlByService,
   readyUrlByService,
   stateDirByService,
   urlMappings
 ) {
-  const stateDir = resolveServiceStateDir(workerStateDir, targetConfig.name, config);
+  const stateDir = resolveServiceStateDir(stackStateDir, targetConfig.name, config);
   const context = {
-    workerId,
-    serviceName: config.name,
+    stackId,
     targetName: targetConfig.name,
+    serviceName: config.name,
     serviceStateDir: stateDir,
     portMap,
     baseUrlByService,
@@ -164,8 +166,8 @@ export function resolveWorkerConfig(
   return {
     ...config,
     stateDir,
-    workerId,
-    workerLabel: `w${workerId}`,
+    stackId,
+    stackLabel: stackId,
     targetName: targetConfig.name,
     testkit: {
       ...config.testkit,
@@ -178,16 +180,16 @@ export function resolveWorkerConfig(
   };
 }
 
-export function resolveServiceStateDir(workerStateDir, targetName, config) {
+export function resolveServiceStateDir(stackStateDir, targetName, config) {
   const dbSource = config.testkit.databaseFrom || config.name;
-  return getWorkerServiceStateDir(workerStateDir, targetName, dbSource);
+  return getStackServiceStateDir(stackStateDir, targetName, dbSource);
 }
 
-export function getWorkerServiceStateDir(workerStateDir, targetName, serviceName) {
+export function getStackServiceStateDir(stackStateDir, targetName, serviceName) {
   if (targetName === serviceName) {
-    return workerStateDir;
+    return stackStateDir;
   }
-  return path.join(workerStateDir, "deps", serviceName);
+  return path.join(stackStateDir, "deps", serviceName);
 }
 
 export function buildExecutionEnv(config, extraEnv = {}, processEnv = process.env) {
@@ -198,7 +200,7 @@ export function buildExecutionEnv(config, extraEnv = {}, processEnv = process.en
     ...resolveEnvTemplates(config.testkit.serviceEnv || {}, templateContext),
     ...resolveEnvTemplates(extraEnv, templateContext),
     TESTKIT_ACTIVE: "1",
-    ...(config.workerId ? { TESTKIT_WORKER_ID: String(config.workerId) } : {}),
+    ...(config.stackId ? { TESTKIT_STACK_ID: String(config.stackId) } : {}),
   };
   delete env.DATABASE_URL;
   return env;
@@ -213,17 +215,17 @@ export function buildPlaywrightEnv(config, baseUrl, processEnv = process.env) {
       PLAYWRIGHT_SKIP_VALIDATE_HOST_REQUIREMENTS:
         processEnv.PLAYWRIGHT_SKIP_VALIDATE_HOST_REQUIREMENTS || "1",
       TESTKIT_MANAGED_SERVERS: "1",
-      TESTKIT_WORKER_ID: String(config.workerId),
+      TESTKIT_STACK_ID: String(config.stackId),
     },
     processEnv
   );
 }
 
-export function resolveRuntimeUrl(rawUrl, serviceName, targetConfig, workerId, context) {
+export function resolveRuntimeUrl(rawUrl, serviceName, targetConfig, stackId, context) {
   const resolved = resolveTemplateString(rawUrl, {
     ...context,
     targetName: targetConfig.name,
-    workerId,
+    stackId,
     serviceName,
   });
   const actualPort = context.portMap.get(serviceName);
@@ -245,8 +247,8 @@ export function resolveTemplateString(value, context) {
 
   return value.replace(/\{([a-zA-Z]+)(?::([a-zA-Z0-9_-]+))?\}/g, (_match, token, arg) => {
     switch (token) {
-      case "worker":
-        return String(context.workerId);
+      case "stack":
+        return String(context.stackId);
       case "target":
         return context.targetName;
       case "service":
@@ -378,3 +380,9 @@ export function normalizeSocketHost(hostname) {
   if (hostname === "[::1]") return "::1";
   return hostname;
 }
+
+function stackPortOffset(stackId) {
+  const match = String(stackId).match(/(\d+)$/);
+  if (!match) return 0;
+  return PORT_STRIDE * (Number.parseInt(match[1], 10) - 1);
+}

package/lib/runner/template.test.mjs

@@ -7,12 +7,12 @@ import {
   buildPlaywrightEnv,
   buildPortMap,
   finalizeString,
-  getWorkerServiceStateDir,
+  getStackServiceStateDir,
   normalizeSocketHost,
   numericPortFromUrl,
   resolveServiceStateDir,
+  resolveStackRuntimeConfigs,
   resolveTemplateString,
-  resolveWorkerRuntimeConfigs,
   rewriteUrlPort,
   socketFromUrl,
 } from "./template.mjs";
@@ -37,7 +37,7 @@ describe("runner-template", () => {
       makeRuntimeConfig("frontend", { port: 3001, baseUrl: "http://127.0.0.1:{port}" }),
     ];
 
-    expect([...buildPortMap(configs, 2).entries()]).toEqual([
+    expect([...buildPortMap(configs, "stack-2").entries()]).toEqual([
       ["api", 3100],
       ["frontend", 3101],
     ]);
@@ -48,9 +48,9 @@ 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}" }),
         ],
-        1
+        "shared"
       )
-    ).toThrow("Worker port collision");
+    ).toThrow("Stack port collision");
   });
 
   it("resolves template strings and URL rewrites", () => {
@@ -63,7 +63,7 @@ describe("runner-template", () => {
     );
 
     const context = {
-      workerId: 2,
+      stackId: "stack-2",
       targetName: "frontend",
       serviceName: "frontend",
       serviceStateDir: "/tmp/state",
@@ -77,7 +77,9 @@ describe("runner-template", () => {
       urlMappings: [["http://api:3000", "http://127.0.0.1:3100"]],
     };
 
-    expect(resolveTemplateString("{worker}:{target}:{service}", context)).toBe("2:frontend:frontend");
+    expect(resolveTemplateString("{stack}:{target}:{service}", context)).toBe(
+      "stack-2:frontend:frontend"
+    );
     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"
@@ -90,22 +92,26 @@ describe("runner-template", () => {
     );
   });
 
-  it("builds worker runtime configs and execution env", () => {
-    const workerStateDir = fs.mkdtempSync(path.join(os.tmpdir(), "testkit-worker-"));
-    const api = makeRuntimeConfig("api", {
-      cwd: ".",
-      start: "npm run api",
-      port: 3000,
-      baseUrl: "http://127.0.0.1:{port}",
-      readyUrl: "http://127.0.0.1:{port}/health",
-      env: {
-        PORT: "{port}",
-      },
-    }, {
-      serviceEnv: {
-        API_KEY: "secret",
+  it("builds stack runtime configs and execution env", () => {
+    const stackStateDir = fs.mkdtempSync(path.join(os.tmpdir(), "testkit-stack-"));
+    const api = makeRuntimeConfig(
+      "api",
+      {
+        cwd: ".",
+        start: "npm run api",
+        port: 3000,
+        baseUrl: "http://127.0.0.1:{port}",
+        readyUrl: "http://127.0.0.1:{port}/health",
+        env: {
+          PORT: "{port}",
+        },
       },
-    });
+      {
+        serviceEnv: {
+          API_KEY: "secret",
+        },
+      }
+    );
     const frontend = makeRuntimeConfig("frontend", {
       cwd: "frontend",
       start: "npm run web",
@@ -118,17 +124,17 @@ describe("runner-template", () => {
       },
     });
 
-    const resolved = resolveWorkerRuntimeConfigs(frontend, [api, frontend], 2, workerStateDir);
+    const resolved = resolveStackRuntimeConfigs(frontend, [api, frontend], "stack-2", stackStateDir);
     expect(resolved[0].testkit.local.port).toBe(3100);
     expect(resolved[1].testkit.local.env.NEXT_PUBLIC_API_URL).toBe("{baseUrl:api}");
-    expect(resolveServiceStateDir(workerStateDir, "frontend", api)).toBe(
-      `${workerStateDir}/deps/api`
+    expect(resolveServiceStateDir(stackStateDir, "frontend", api)).toBe(
+      `${stackStateDir}/deps/api`
     );
-    expect(getWorkerServiceStateDir(workerStateDir, "frontend", "frontend")).toBe(workerStateDir);
+    expect(getStackServiceStateDir(stackStateDir, "frontend", "frontend")).toBe(stackStateDir);
 
-    fs.mkdirSync(path.join(workerStateDir, "deps", "api"), { recursive: true });
+    fs.mkdirSync(path.join(stackStateDir, "deps", "api"), { recursive: true });
     fs.writeFileSync(
-      path.join(workerStateDir, "deps", "api", "database_url"),
+      path.join(stackStateDir, "deps", "api", "database_url"),
       "postgres://testkit:testkit@127.0.0.1:55432/onix_db"
     );
 
@@ -148,15 +154,16 @@ describe("runner-template", () => {
       NEXT_PUBLIC_API_URL: "http://127.0.0.1:3100",
       ONIX_DB_HOST: "127.0.0.1",
       TESTKIT_ACTIVE: "1",
-      TESTKIT_WORKER_ID: "2",
+      TESTKIT_STACK_ID: "stack-2",
     });
 
-    expect(buildPlaywrightEnv({ workerId: 3, testkit: { serviceEnv: {} } }, "http://localhost:3000", {}))
-      .toMatchObject({
-        BASE_URL: "http://localhost:3000",
-        TESTKIT_WORKER_ID: "3",
-        PLAYWRIGHT_HTML_OPEN: "never",
-      });
+    expect(
+      buildPlaywrightEnv({ stackId: "shared", testkit: { serviceEnv: {} } }, "http://localhost:3000", {})
+    ).toMatchObject({
+      BASE_URL: "http://localhost:3000",
+      TESTKIT_STACK_ID: "shared",
+      PLAYWRIGHT_HTML_OPEN: "never",
+    });
   });
 
   it("parses runtime sockets", () => {