@elench/testkit 0.1.40 → 0.1.42

package/lib/runner/planning.test.mjs

@@ -4,7 +4,7 @@ import {
   buildGraphDirName,
   buildRuntimeGraphs,
   buildTaskQueue,
-  claimNextBatch,
+  claimNextTask,
   collectSuites,
   resolveRuntimeConfigs,
 } from "./planning.mjs";
@@ -14,20 +14,23 @@ function makeConfig(name, extras = {}) {
   return {
     name,
     suites: extras.suites || {},
-      testkit: {
-        dependsOn: extras.dependsOn || providedTestkit.dependsOn || [],
-        execution: providedTestkit.execution || {
-          workers: 1,
-          stackMode: "isolated",
-          stackCount: 1,
-        },
-        serviceExecution: providedTestkit.serviceExecution || {
-          suites: [],
-          files: [],
-          fileStackModeByPath: new Map(),
-        },
-        ...providedTestkit,
+    testkit: {
+      dependsOn: extras.dependsOn || providedTestkit.dependsOn || [],
+      execution: providedTestkit.execution || {
+        workers: 1,
+        fileTimeoutSeconds: 60,
       },
+      runtime: providedTestkit.runtime || {
+        instances: 1,
+        maxConcurrentTasks: Number.POSITIVE_INFINITY,
+      },
+      requirements: providedTestkit.requirements || {
+        suites: [],
+        files: [],
+        fileLocksByPath: new Map(),
+      },
+      ...providedTestkit,
+    },
     ...extras,
   };
 }
@@ -67,17 +70,6 @@ describe("runner-planning", () => {
           },
         ],
       },
-      testkit: {
-        dependsOn: [],
-        execution: {
-          workers: 1,
-          stackMode: "shared",
-          stackCount: 1,
-        },
-        serviceExecution: {
-          suites: [],
-        },
-      },
     });
 
     expect(collectSuites(config, ["int"], [], [])[0]).toMatchObject({
@@ -122,15 +114,6 @@ describe("runner-planning", () => {
         ],
       },
       testkit: {
-        dependsOn: [],
-        execution: {
-          workers: 1,
-          stackMode: "shared",
-          stackCount: 1,
-        },
-        serviceExecution: {
-          suites: [],
-        },
         skip: {
           fileReasonByPath: new Map([
             ["__testkit__/billing/a.int.testkit.ts", "Billing is stubbed"],
@@ -153,21 +136,9 @@ describe("runner-planning", () => {
         totalFileCount: 2,
       }),
     ]);
-
-    expect(collectSuites(config, ["int"], [], [], { ignoreSkipRules: true })).toEqual([
-      expect.objectContaining({
-        name: "billing",
-        files: [
-          "__testkit__/billing/a.int.testkit.ts",
-          "__testkit__/billing/b.int.testkit.ts",
-        ],
-        skippedFiles: [],
-        totalFileCount: 2,
-      }),
-    ]);
   });
 
-  it("applies file-level stack isolation overrides within the same suite", () => {
+  it("applies lock requirements to matching suites and files", () => {
     const api = makeConfig("api", {
       suites: {
         integration: [
@@ -180,28 +151,31 @@ describe("runner-planning", () => {
             ],
             orderIndex: 0,
             weight: 2,
-            maxFileConcurrency: 1,
           },
         ],
       },
       testkit: {
-        execution: {
-          workers: 8,
-          stackMode: "shared",
-          stackCount: 1,
+        runtime: {
+          instances: 3,
+          maxConcurrentTasks: 2,
         },
-        serviceExecution: {
-          suites: [],
+        requirements: {
+          suites: [
+            {
+              selector: { kind: "typed", type: "int", name: "routes", raw: "int:routes" },
+              locks: ["suite-lock"],
+            },
+          ],
           files: [
             {
               path: "src/api/routes/__testkit__/crawls-worker-concurrency.int.testkit.ts",
-              stackMode: "isolated",
+              locks: ["worker-loop"],
             },
           ],
-          fileStackModeByPath: new Map([
+          fileLocksByPath: new Map([
             [
               "src/api/routes/__testkit__/crawls-worker-concurrency.int.testkit.ts",
-              "isolated",
+              ["worker-loop"],
             ],
           ]),
         },
@@ -239,21 +213,35 @@ describe("runner-planning", () => {
       expect.arrayContaining([
         expect.objectContaining({
           file: "src/api/routes/__testkit__/health.int.testkit.ts",
-          stackMode: "shared",
-          accessMode: "shared",
+          locks: ["suite-lock"],
         }),
         expect.objectContaining({
           file: "src/api/routes/__testkit__/crawls-worker-concurrency.int.testkit.ts",
-          stackMode: "isolated",
-          accessMode: "exclusive",
+          locks: ["suite-lock", "worker-loop"],
         }),
       ])
     );
   });
 
-  it("applies shards, builds graphs, queues tasks, and claims batches", () => {
-    const api = makeConfig("api");
-    const frontend = makeConfig("frontend");
+  it("builds exact runtime graphs and claims single file tasks", () => {
+    const api = makeConfig("api", {
+      testkit: {
+        runtime: {
+          instances: 2,
+          maxConcurrentTasks: 4,
+        },
+      },
+    });
+    const frontend = makeConfig("frontend", {
+      dependsOn: ["api"],
+      testkit: {
+        runtime: {
+          instances: 1,
+          maxConcurrentTasks: 2,
+        },
+      },
+    });
+
     const plans = [
       {
         config: api,
@@ -269,9 +257,6 @@ describe("runner-planning", () => {
             files: ["a.js", "b.js"],
             orderIndex: 0,
             weight: 2,
-            maxFileConcurrency: 2,
-            stackMode: "isolated",
-            accessMode: "exclusive",
           },
         ],
       },
@@ -286,12 +271,9 @@ describe("runner-planning", () => {
             name: "auth",
             type: "e2e",
             framework: "playwright",
-            files: ["auth.spec.js", "signup.spec.js"],
+            files: ["auth.spec.js"],
             orderIndex: 0,
-            weight: 2,
-            maxFileConcurrency: 1,
-            stackMode: "isolated",
-            accessMode: "exclusive",
+            weight: 1,
           },
         ],
       },
@@ -300,112 +282,64 @@ describe("runner-planning", () => {
     expect(applyShard(["a", "b", "c", "d"], { index: 2, total: 2 })).toEqual(["b", "d"]);
 
     const graphs = buildRuntimeGraphs(plans);
-    expect(graphs).toHaveLength(1);
-    expect(plans[0].assignedGraphKey).toBe("api|frontend");
+    expect(graphs).toEqual([
+      expect.objectContaining({
+        key: "api",
+        instanceCount: 2,
+        maxConcurrentTasks: 4,
+        targetNames: ["api"],
+      }),
+      expect.objectContaining({
+        key: "api|frontend",
+        instanceCount: 1,
+        maxConcurrentTasks: 2,
+        targetNames: ["frontend"],
+      }),
+    ]);
     expect(buildGraphDirName(["api", "frontend"])).toBe("api__frontend");
 
     const queue = buildTaskQueue(plans, graphs, { files: {} });
-    expect(queue).toHaveLength(4);
-
-    const firstBatch = claimNextBatch(queue, "api|frontend");
-    expect(firstBatch.tasks).toHaveLength(1);
-    expect(firstBatch.framework).toBe("playwright");
-    expect(firstBatch.accessMode).toBe("exclusive");
-
-    const secondBatch = claimNextBatch(queue, "api|frontend");
-    expect(secondBatch.tasks).toHaveLength(1);
-    expect(secondBatch.framework).toBe("playwright");
-
-    const thirdBatch = claimNextBatch(queue, "api|frontend");
-    expect(thirdBatch.tasks).toHaveLength(2);
-    expect(thirdBatch.framework).toBe("k6");
+    expect(queue).toHaveLength(3);
+    expect(claimNextTask(queue, "api|frontend")).toMatchObject({
+      framework: "playwright",
+      graphKey: "api|frontend",
+      file: "auth.spec.js",
+    });
+    expect(claimNextTask(queue, "api")).toMatchObject({
+      framework: "k6",
+      graphKey: "api",
+    });
   });
 
-  it("allows Playwright suites to opt into bounded multi-file batches", () => {
-    const frontend = makeConfig("frontend");
-    const plans = [
+  it("skips blocked preferred-graph work and claims the next runnable task", () => {
+    const queue = [
       {
-        config: frontend,
-        skipped: false,
-        runtimeConfigs: [frontend],
-        runtimeNames: ["frontend"],
-        runtimeKey: "frontend",
-        suites: [
-          {
-            name: "auth",
-            type: "e2e",
-            framework: "playwright",
-            files: ["a.spec.js", "b.spec.js", "c.spec.js"],
-            orderIndex: 0,
-            weight: 3,
-            maxFileConcurrency: 2,
-            stackMode: "isolated",
-            accessMode: "exclusive",
-          },
-        ],
-      },
-    ];
-
-    const graphs = buildRuntimeGraphs(plans);
-    const queue = buildTaskQueue(plans, graphs, { files: {} });
-
-    const firstBatch = claimNextBatch(queue, "frontend");
-    expect(firstBatch.tasks.map((task) => task.file)).toEqual(["a.spec.js", "b.spec.js"]);
-    expect(firstBatch.tasks).toHaveLength(2);
-    expect(firstBatch.framework).toBe("playwright");
-
-    const secondBatch = claimNextBatch(queue, "frontend");
-    expect(secondBatch.tasks).toHaveLength(1);
-    expect(secondBatch.framework).toBe("playwright");
-  });
-
-  it("applies typed suite execution rules from config", () => {
-    const config = makeConfig("api", {
-      suites: {
-        integration: [{ name: "health", files: ["__testkit__/health/health.int.testkit.ts"] }],
-      },
-      testkit: {
-        dependsOn: [],
-        execution: {
-          workers: 8,
-          stackMode: "shared",
-          stackCount: 1,
-        },
-        serviceExecution: {
-          suites: [{ selector: { kind: "typed", type: "int", name: "health", raw: "int:health" }, stackMode: "isolated" }],
-        },
+        id: 1,
+        graphKey: "api",
+        file: "blocked.js",
       },
-    });
-
-    const graphs = buildRuntimeGraphs([
       {
-        config,
-        skipped: false,
-        runtimeConfigs: [config],
-        runtimeNames: ["api"],
-        runtimeKey: "api",
-        suites: collectSuites(config, ["int"], [], []),
+        id: 2,
+        graphKey: "api|frontend",
+        file: "runnable.js",
       },
-    ]);
-    const queue = buildTaskQueue(
-      [
-        {
-          config,
-          skipped: false,
-          runtimeConfigs: [config],
-          runtimeNames: ["api"],
-          runtimeKey: "api",
-          assignedGraphKey: "api",
-          suites: collectSuites(config, ["int"], [], []),
-        },
-      ],
-      graphs,
-      { files: {} }
+    ];
+
+    const claimed = claimNextTask(
+      queue,
+      "api",
+      (task) => task.file === "runnable.js"
     );
 
-    expect(queue[0]).toMatchObject({
-      stackMode: "isolated",
-      accessMode: "exclusive",
+    expect(claimed).toMatchObject({
+      id: 2,
+      file: "runnable.js",
     });
+    expect(queue).toEqual([
+      expect.objectContaining({
+        id: 1,
+        file: "blocked.js",
+      }),
+    ]);
   });
 });

package/lib/runner/playwright-config.mjs

@@ -3,8 +3,14 @@ import path from "path";
 import { pathToFileURL } from "url";
 import { normalizePathSeparators } from "./state.mjs";
 
-export function ensurePlaywrightTestConfig(targetConfig, cwd, requestedFiles) {
-  const stateDir = targetConfig.stateDir || path.join(targetConfig.productDir, ".testkit");
+export function ensurePlaywrightTestConfig(targetConfig, cwd, requestedFiles, lease) {
+  if (!lease?.leaseDir) {
+    throw new Error(
+      `Playwright task for service "${targetConfig.name}" requires a lease-scoped directory`
+    );
+  }
+
+  const stateDir = lease.leaseDir;
   const outputDir = resolvePlaywrightOutputDir(stateDir);
   fs.mkdirSync(stateDir, { recursive: true });
   fs.mkdirSync(outputDir, { recursive: true });
@@ -22,6 +28,9 @@ export function ensurePlaywrightTestConfig(targetConfig, cwd, requestedFiles) {
       `  testDir: ${JSON.stringify(cwd)},\n` +
       `  testMatch: ${JSON.stringify(normalizedFiles)},\n` +
       `  outputDir: ${JSON.stringify(outputDir)},\n` +
+      `  workers: 1,\n` +
+      `  fullyParallel: false,\n` +
+      `  webServer: undefined,\n` +
       `};\n`;
   } else {
     source =
@@ -29,6 +38,8 @@ export function ensurePlaywrightTestConfig(targetConfig, cwd, requestedFiles) {
       `  testDir: ${JSON.stringify(cwd)},\n` +
       `  testMatch: ${JSON.stringify(normalizedFiles)},\n` +
       `  outputDir: ${JSON.stringify(outputDir)},\n` +
+      `  workers: 1,\n` +
+      `  fullyParallel: false,\n` +
       `};\n`;
   }
 

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

@@ -24,29 +24,49 @@ function makeTempDir(prefix) {
 }
 
 describe("runner-playwright-config", () => {
-  it("uses a shard-local output directory under the state dir", async () => {
+  it("uses a lease-local output directory under the lease dir", async () => {
     const productDir = makeTempDir("testkit-playwright-product-");
-    const stateDir = path.join(productDir, ".testkit", "stack-3");
+    const leaseDir = path.join(productDir, ".testkit", "leases", "lease-12");
     const cwd = path.join(productDir, "frontend");
     fs.mkdirSync(cwd, { recursive: true });
     fs.writeFileSync(
       path.join(cwd, "playwright.config.mjs"),
-      "export default { outputDir: 'shared-test-results' };\n"
+      "export default { outputDir: 'shared-test-results', workers: 8, fullyParallel: true, webServer: { command: 'npm run dev', url: 'http://127.0.0.1:3000' } };\n"
     );
 
     const configPath = ensurePlaywrightTestConfig(
-      { productDir, stateDir },
+      { name: "frontend", productDir, stateDir: path.join(productDir, ".testkit", "frontend") },
       cwd,
-      ["frontend/__testkit__/homepage/homepage.pw.testkit.ts"]
+      ["frontend/__testkit__/homepage/homepage.pw.testkit.ts"],
+      { leaseDir }
     );
     const generated = await import(pathToFileURL(configPath).href + `?t=${Date.now()}`);
 
-    const expectedOutputDir = resolvePlaywrightOutputDir(stateDir);
+    const expectedOutputDir = resolvePlaywrightOutputDir(leaseDir);
     expect(generated.default.outputDir).toBe(expectedOutputDir);
+    expect(generated.default.workers).toBe(1);
+    expect(generated.default.fullyParallel).toBe(false);
+    expect(generated.default.webServer).toBeUndefined();
     expect(fs.existsSync(expectedOutputDir)).toBe(true);
     expect(fs.readFileSync(configPath, "utf8")).toContain(
       `outputDir: ${JSON.stringify(expectedOutputDir)}`
     );
+    expect(fs.readFileSync(configPath, "utf8")).toContain("workers: 1");
+    expect(fs.readFileSync(configPath, "utf8")).toContain("fullyParallel: false");
+  });
+
+  it("requires a lease-scoped directory", () => {
+    const productDir = makeTempDir("testkit-playwright-product-");
+    const cwd = path.join(productDir, "frontend");
+    fs.mkdirSync(cwd, { recursive: true });
+
+    expect(() =>
+      ensurePlaywrightTestConfig(
+        { name: "frontend", productDir, stateDir: path.join(productDir, ".testkit", "frontend") },
+        cwd,
+        ["frontend/__testkit__/homepage/homepage.pw.testkit.ts"]
+      )
+    ).toThrow('Playwright task for service "frontend" requires a lease-scoped directory');
   });
 
   it("finds a supported playwright config file", () => {

package/lib/runner/playwright-runner.mjs

@@ -1,16 +1,16 @@
 import path from "path";
 import { execa } from "execa";
-import {
-  parsePlaywrightJsonResults,
-} from "../reporters/playwright.mjs";
-import { resolveServiceCwd, } from "../config/index.mjs";
-import { formatPlaywrightBatchFiles } from "./formatting.mjs";
-import { printBufferedOutput } from "./processes.mjs";
+import { parsePlaywrightJsonResults } from "../reporters/playwright.mjs";
+import { resolveServiceCwd } from "../config/index.mjs";
+import { formatFileTimeoutBudgetError } from "../shared/file-timeout.mjs";
+import { settleSubprocess } from "./default-runtime-runner.mjs";
 import { ensurePlaywrightTestConfig } from "./playwright-config.mjs";
-import { buildPlaywrightEnv } from "./template.mjs";
+import { printBufferedOutput } from "./processes.mjs";
 import { normalizePathSeparators } from "./state.mjs";
+import { buildPlaywrightEnv } from "./template.mjs";
+import { killChildProcess } from "./processes.mjs";
 
-export async function runPlaywrightBatch(targetConfig, batch, lifecycle) {
+export async function runPlaywrightTask(targetConfig, task, lifecycle, lease) {
   const local = targetConfig.testkit.local;
   if (!local?.baseUrl) {
     throw new Error(
@@ -18,69 +18,63 @@ export async function runPlaywrightBatch(targetConfig, batch, lifecycle) {
     );
   }
 
-  console.log(
-    `\n── ${targetConfig.stackLabel} playwright:${targetConfig.name} (${batch.tasks.length} file${batch.tasks.length === 1 ? "" : "s"})${formatPlaywrightBatchFiles(batch)} ──`
-  );
-
   const cwd = resolveServiceCwd(targetConfig.productDir, local.cwd);
-  const requestedFiles = batch.tasks.map((task) =>
-    path.relative(cwd, path.join(targetConfig.productDir, task.file))
-  );
-  const playwrightConfigPath = ensurePlaywrightTestConfig(targetConfig, cwd, requestedFiles);
+  const requestedFile = path.relative(cwd, path.join(targetConfig.productDir, task.file));
+  const playwrightConfigPath = ensurePlaywrightTestConfig(targetConfig, cwd, [requestedFile], lease);
+  if (lifecycle.isStopRequested()) {
+    throw new Error(`testkit run interrupted before starting ${task.file}`);
+  }
   const startedAt = Date.now();
-  const result = await execa(
+  const fileTimeoutSeconds = targetConfig.testkit.execution.fileTimeoutSeconds;
+  const subprocess = execa(
     "npx",
     ["playwright", "test", "--config", playwrightConfigPath, "--reporter=json"],
     {
       cwd,
-      env: buildPlaywrightEnv(targetConfig, local.baseUrl, process.env),
+      env: buildPlaywrightEnv(targetConfig, local.baseUrl, lease, process.env),
       reject: false,
-      cancelSignal: lifecycle.signal,
       forceKillAfterDelay: 5_000,
     }
   );
+  lifecycle.registerProcess(subprocess, () => {
+    killChildProcess(subprocess, "SIGINT");
+  });
+  if (lifecycle.isStopRequested()) {
+    const interruptSubprocess = () => killChildProcess(subprocess, "SIGINT");
+    if (subprocess.pid) interruptSubprocess();
+    else subprocess.once?.("spawn", interruptSubprocess);
+  }
+  console.log(`\n── ${targetConfig.runtimeLabel} playwright:${targetConfig.name} (${task.file}) ──`);
+  let result;
+  let timedOut;
+  try {
+    ({ result, timedOut } = await settleSubprocess(subprocess, fileTimeoutSeconds));
+  } finally {
+    lifecycle.unregisterProcess(subprocess.pid);
+  }
 
   if (result.stderr) {
-    printBufferedOutput(result.stderr, `[${targetConfig.stackLabel}:${targetConfig.name}:playwright]`);
+    printBufferedOutput(result.stderr, `[${targetConfig.runtimeLabel}:${targetConfig.name}:playwright]`);
   }
 
-  const parsed = parsePlaywrightJsonResults(result.stdout, cwd);
+  const parsed = parsePlaywrightJsonResults(result.stdout || "", cwd);
   const finishedAt = Date.now();
-  const batchDurationMs = finishedAt - startedAt;
-  const genericError =
-    result.exitCode === 0
+  const durationMs = finishedAt - startedAt;
+  const relativeFile = normalizePathSeparators(requestedFile);
+  const fileResult = parsed.fileResults.get(relativeFile);
+  const genericError = timedOut
+    ? formatFileTimeoutBudgetError(fileTimeoutSeconds)
+    : result.exitCode === 0
       ? parsed.errors[0] || null
-      : parsed.errors[0] ||
-        result.stderr.trim() ||
-        `Playwright exited with code ${result.exitCode}`;
+      : parsed.errors[0] || result.stderr.trim() || `Playwright exited with code ${result.exitCode}`;
 
-  return batch.tasks.map((task) => {
-    const relativeFile = normalizePathSeparators(
-      path.relative(cwd, path.join(targetConfig.productDir, task.file))
-    );
-    const fileResult = parsed.fileResults.get(relativeFile);
-    if (fileResult) {
-      return {
-        task,
-        failed: fileResult.status === "failed",
-        status: fileResult.status,
-        error: fileResult.error,
-        durationMs:
-          fileResult.durationMs > 0
-            ? fileResult.durationMs
-            : Math.round(batchDurationMs / Math.max(1, batch.tasks.length)),
-        startedAt,
-        finishedAt,
-      };
-    }
-
-    return {
-      task,
-      failed: result.exitCode !== 0,
-      error: result.exitCode !== 0 ? genericError : null,
-      durationMs: Math.round(batchDurationMs / Math.max(1, batch.tasks.length)),
-      startedAt,
-      finishedAt,
-    };
-  });
+  return {
+    task,
+    failed: timedOut ? true : fileResult ? fileResult.status === "failed" : result.exitCode !== 0,
+    status: timedOut ? "failed" : fileResult?.status || (result.exitCode === 0 ? "passed" : "failed"),
+    error: timedOut ? genericError : fileResult?.error || genericError,
+    durationMs: fileResult?.durationMs > 0 ? fileResult.durationMs : durationMs,
+    startedAt,
+    finishedAt,
+  };
 }

package/lib/runner/readiness.mjs

@@ -54,11 +54,11 @@ export async function assertLocalServicePortsAvailable(config, isPortInUse) {
       const owner = findPortOwner(config.productDir, socket);
       const ownerDetail = owner
         ? owner.active
-          ? ` Active testkit run ${formatRunSummary(owner.manifest)} owns ${key} via ${owner.service.stackLabel}:${owner.service.serviceName}.`
+          ? ` Active testkit run ${formatRunSummary(owner.manifest)} owns ${key} via ${owner.service.runtimeLabel}:${owner.service.serviceName}.`
           : ` Stale testkit run ${formatRunSummary(owner.manifest)} owns ${key}.`
         : "";
       throw new Error(
-        `Cannot start "${config.stackLabel}:${config.name}" because ${key} is already in use. ` +
+        `Cannot start "${config.runtimeLabel}:${config.name}" because ${key} is already in use. ` +
           `Stop the existing process and rerun testkit.${ownerDetail}`
       );
     }

package/lib/runner/reporting.mjs

@@ -96,7 +96,8 @@ export function buildRunArtifact({
   finishedAt,
   execution,
   workerCount,
-  stackCount,
+  runtimeInstanceCount,
+  runtimeStats,
   typeValues,
   suiteSelectors,
   fileNames,
@@ -137,8 +138,8 @@ export function buildRunArtifact({
       workers: execution.workers,
       fileTimeoutSeconds: execution.fileTimeoutSeconds,
       workerCount,
-      stackMode: execution.stackMode,
-      stackCount,
+      runtimeInstanceCount,
+      runtimeStats: runtimeStats || [],
       dbBackend,
       types: typeValues,
       suiteSelectors: suiteSelectors.map((selector) => selector.raw),

package/lib/runner/reporting.test.mjs

@@ -54,11 +54,9 @@ describe("runner reporting", () => {
       execution: {
         workers: 2,
         fileTimeoutSeconds: 60,
-        stackMode: "shared",
-        stackCount: 1,
       },
       workerCount: 1,
-      stackCount: 1,
+      runtimeInstanceCount: 2,
       typeValues: ["all"],
       suiteSelectors: [],
       fileNames: [],
@@ -85,8 +83,7 @@ describe("runner reporting", () => {
       workers: 2,
       fileTimeoutSeconds: 60,
       workerCount: 1,
-      stackMode: "shared",
-      stackCount: 1,
+      runtimeInstanceCount: 2,
     });
     expect(artifact.summary.services).toEqual({
       total: 1,

package/lib/runner/results.mjs

@@ -142,7 +142,7 @@ export function recordTaskOutcome(trackers, task, outcome, finishedAt = Date.now
 }
 
 export function recordGraphError(trackers, graph, message, now = Date.now()) {
-  const targetNames = graph?.assignedTargets || [];
+  const targetNames = graph?.targetNames || [];
   for (const targetName of targetNames) {
     const tracker = trackers.get(targetName);
     if (tracker && !tracker.skipped) {