@elench/testkit 0.1.108 → 0.1.110

package/lib/runner/status-model.mjs

@@ -0,0 +1,520 @@
+import fs from "fs";
+import path from "path";
+import { buildRuntimeIds } from "./execution-config.mjs";
+import { buildGraphDirName, resolveRuntimeConfigs } from "./planning.mjs";
+import { isPidRunning, listRunManifests } from "./lifecycle.mjs";
+import { readGraphMetadata } from "./state.mjs";
+
+const BUNDLE_MANIFEST = "manifest.json";
+const ASSISTANT_LARGE_RESULT_BYTES = 10 * 1024 * 1024;
+const ASSISTANT_RESULT_TTL_MS = 7 * 24 * 60 * 60 * 1000;
+
+export function collectStatusModel(config, { allConfigs = [config] } = {}) {
+  const productDir = config.productDir;
+  const desiredGraphs = collectDesiredRuntimeGraphs(allConfigs);
+  const runtimeGraphs = collectRuntimeGraphStatus(productDir, {
+    desiredGraphs,
+    serviceName: config.name,
+  });
+  const serviceState = collectDirectorySummary(config.stateDir);
+  const runs = collectRunStatus(productDir);
+  const bundles = collectBundleCacheStatus(productDir, config.name);
+  const assistant = collectAssistantResultStatus(productDir);
+  const warnings = collectWarnings({ runtimeGraphs, bundles, assistant });
+  const hasState =
+    serviceState.exists ||
+    runtimeGraphs.some((graph) => graph.exists) ||
+    runs.total > 0 ||
+    bundles.exists ||
+    assistant.exists;
+
+  return {
+    schemaVersion: 1,
+    name: config.name,
+    product: {
+      dir: productDir,
+      configFile: config.configFile || null,
+      services: allConfigs.map((entry) => entry.name).sort(),
+      selectedService: config.name,
+      dependencies: [...(config.testkit?.dependsOn || [])].sort(),
+    },
+    hasState,
+    runs,
+    serviceState,
+    runtimeGraphs,
+    caches: {
+      bundles,
+      assistant,
+    },
+    warnings,
+  };
+}
+
+export function collectCleanupTargets(productDir, { allConfigs = [], serviceName = null, cache = [] } = {}) {
+  const desiredGraphs = collectDesiredRuntimeGraphs(allConfigs);
+  const runtimeGraphs = collectRuntimeGraphStatus(productDir, { desiredGraphs, serviceName });
+  const cacheSet = normalizeCacheSelection(cache);
+  return {
+    runtime: runtimeGraphs.flatMap((graph) =>
+      graph.staleRuntimeDirs
+        .filter((runtime) => !runtime.active)
+        .map((runtime) => ({
+          graph: graph.name,
+          runtimeId: runtime.id,
+          path: runtime.path,
+        }))
+    ),
+    bundles: cacheSet.has("bundles") ? collectBundleCleanupTargets(productDir, { allConfigs, serviceName }) : [],
+    assistant: cacheSet.has("assistant") ? collectAssistantCleanupTargets(productDir) : [],
+  };
+}
+
+export function collectDesiredRuntimeGraphs(allConfigs = []) {
+  const configMap = new Map(allConfigs.map((config) => [config.name, config]));
+  const graphByKey = new Map();
+
+  for (const config of allConfigs) {
+    const runtimeConfigs = resolveRuntimeConfigs(config, configMap);
+    const runtimeNames = runtimeConfigs.map((runtimeConfig) => runtimeConfig.name).sort();
+    const key = runtimeNames.join("|");
+    const existing = graphByKey.get(key);
+    if (existing) {
+      existing.targetNames.push(config.name);
+      existing.targetNames.sort();
+      existing.instanceCount = Math.max(existing.instanceCount, config.testkit.runtime.instances);
+      continue;
+    }
+    graphByKey.set(key, {
+      key,
+      dirName: buildGraphDirName(runtimeNames),
+      runtimeNames,
+      targetNames: [config.name],
+      instanceCount: config.testkit.runtime.instances,
+    });
+  }
+
+  return [...graphByKey.values()].sort((left, right) => left.dirName.localeCompare(right.dirName));
+}
+
+export function collectRuntimeGraphStatus(productDir, { desiredGraphs = [], serviceName = null } = {}) {
+  const graphsRoot = path.join(productDir, ".testkit", "_graphs");
+  const desiredByName = new Map(desiredGraphs.map((graph) => [graph.dirName, graph]));
+  const actualByName = new Map();
+
+  if (fs.existsSync(graphsRoot)) {
+    for (const entry of fs.readdirSync(graphsRoot, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name))) {
+      if (!entry.isDirectory()) continue;
+      const graphDir = path.join(graphsRoot, entry.name);
+      actualByName.set(entry.name, {
+        name: entry.name,
+        path: graphDir,
+        metadata: readGraphMetadata(graphDir),
+      });
+    }
+  }
+
+  const activeRuntimeDirs = collectActiveRuntimeDirs(productDir);
+  const names = new Set([...desiredByName.keys(), ...actualByName.keys()]);
+  return [...names]
+    .sort()
+    .map((name) => {
+      const desired = desiredByName.get(name) || null;
+      const actual = actualByName.get(name) || null;
+      const graphDir = actual?.path || path.join(graphsRoot, name);
+      const runtimeDirs = listRuntimeDirs(graphDir);
+      const desiredRuntimeIds = desired ? buildRuntimeIds(desired.instanceCount) : [];
+      const desiredRuntimeSet = new Set(desiredRuntimeIds);
+      const staleRuntimeDirs = runtimeDirs
+        .filter((runtime) => !desiredRuntimeSet.has(runtime.id))
+        .map((runtime) => ({
+          ...runtime,
+          active: activeRuntimeDirs.has(runtime.path),
+        }));
+      const currentRuntimeDirs = runtimeDirs.filter((runtime) => desiredRuntimeSet.has(runtime.id));
+      return {
+        name,
+        path: graphDir,
+        exists: Boolean(actual),
+        desired: desired
+          ? {
+              instanceCount: desired.instanceCount,
+              runtimeIds: desiredRuntimeIds,
+              runtimeServices: desired.runtimeNames,
+              targetServices: desired.targetNames,
+            }
+          : null,
+        actual: actual
+          ? {
+              runtimeServices: [...(actual.metadata?.runtimeServices || [])].sort(),
+              targetServices: [...(actual.metadata?.targetServices || [])].sort(),
+            }
+          : null,
+        runtimeDirCount: runtimeDirs.length,
+        currentRuntimeDirs,
+        staleRuntimeDirs,
+        orphan: !desired,
+      };
+    })
+    .filter((graph) => {
+      if (!serviceName) return true;
+      const namesForGraph = new Set([
+        ...(graph.desired?.runtimeServices || []),
+        ...(graph.desired?.targetServices || []),
+        ...(graph.actual?.runtimeServices || []),
+        ...(graph.actual?.targetServices || []),
+      ]);
+      return namesForGraph.has(serviceName);
+    });
+}
+
+export function collectBundleCacheStatus(productDir, serviceName = "shared") {
+  const dir = path.join(productDir, ".testkit", "_bundles", serviceName || "shared");
+  const summary = collectDirectorySummary(dir);
+  const files = listFiles(dir);
+  const jsFiles = files.filter((file) => file.path.endsWith(".js"));
+  const entryFiles = files.filter((file) => file.path.endsWith(".entry.mjs"));
+  const manifest = readBundleManifest(dir);
+  const manifestFiles = new Set(
+    manifest.entries.flatMap((entry) => [entry.outputFile, entry.entryFile].filter(Boolean).map((filePath) => path.resolve(filePath)))
+  );
+  const inferredSources = inferBundleSources(entryFiles);
+  const sourcesWithDuplicates = [...inferredSources.values()].filter((entries) => entries.length > 1).length;
+  const unmanagedFiles = files.filter((file) => path.basename(file.path) !== BUNDLE_MANIFEST && !manifestFiles.has(path.resolve(file.path)));
+  const sourcemaps = collectInlineSourcemapStatus(jsFiles, manifest);
+
+  return {
+    serviceName,
+    path: dir,
+    exists: summary.exists,
+    sizeBytes: summary.sizeBytes,
+    fileCount: summary.fileCount,
+    jsFileCount: jsFiles.length,
+    entryFileCount: entryFiles.length,
+    sourceFileCount: inferredSources.size || manifest.sourceFileCount,
+    duplicatedSourceCount: sourcesWithDuplicates,
+    sourcemapFileCount: sourcemaps.count,
+    sourcemapStatus: sourcemaps.status,
+    manifest: {
+      exists: manifest.exists,
+      entryCount: manifest.entries.length,
+    },
+    unmanagedFileCount: unmanagedFiles.length,
+  };
+}
+
+export function collectAssistantResultStatus(productDir) {
+  const dir = path.join(productDir, ".testkit", "assistant", "command-results");
+  const files = listFiles(dir).sort((left, right) => right.size - left.size || left.path.localeCompare(right.path));
+  return {
+    path: dir,
+    exists: fs.existsSync(dir),
+    sizeBytes: files.reduce((sum, file) => sum + file.size, 0),
+    fileCount: files.length,
+    largeFileCount: files.filter((file) => file.size >= ASSISTANT_LARGE_RESULT_BYTES).length,
+    largestFiles: files.slice(0, 3).map((file) => ({
+      path: file.path,
+      sizeBytes: file.size,
+      modifiedAt: new Date(file.mtimeMs).toISOString(),
+    })),
+  };
+}
+
+export function collectBundleCleanupTargets(productDir, { allConfigs = [], serviceName = null } = {}) {
+  const serviceNames = serviceName ? [serviceName] : allConfigs.map((config) => config.name).sort();
+  const targets = [];
+  for (const name of serviceNames) {
+    const dir = path.join(productDir, ".testkit", "_bundles", name || "shared");
+    const files = listFiles(dir);
+    if (files.length === 0) continue;
+    const manifest = readBundleManifest(dir);
+    const manifestTargets = collectManifestBundleCleanupTargets(manifest.entries);
+    if (manifestTargets.length > 0) {
+      targets.push(...manifestTargets.map((target) => ({ ...target, serviceName: name })));
+      continue;
+    }
+    targets.push(...collectLegacyBundleCleanupTargets(dir).map((target) => ({ ...target, serviceName: name })));
+  }
+  return dedupeCleanupFiles(targets);
+}
+
+export function collectAssistantCleanupTargets(productDir) {
+  const now = Date.now();
+  const dir = path.join(productDir, ".testkit", "assistant", "command-results");
+  return listFiles(dir)
+    .filter((file) => file.size >= ASSISTANT_LARGE_RESULT_BYTES || now - file.mtimeMs >= ASSISTANT_RESULT_TTL_MS)
+    .map((file) => ({
+      path: file.path,
+      reason: file.size >= ASSISTANT_LARGE_RESULT_BYTES ? "large" : "expired",
+      sizeBytes: file.size,
+    }));
+}
+
+function collectRunStatus(productDir) {
+  const manifests = listRunManifests(productDir);
+  const runs = manifests.map((manifest) => ({
+    runId: manifest.runId,
+    pid: manifest.pid,
+    status: isPidRunning(manifest.pid) ? "active" : "stale",
+    startedAt: manifest.startedAt || null,
+    ports: collectRunPorts(manifest),
+  }));
+  return {
+    total: runs.length,
+    active: runs.filter((run) => run.status === "active").length,
+    stale: runs.filter((run) => run.status === "stale").length,
+    runs,
+  };
+}
+
+function collectRunPorts(manifest) {
+  const ports = [];
+  for (const service of manifest.services || []) {
+    for (const socket of service.ports || []) {
+      if (socket?.host && socket?.port) ports.push(`${socket.host}:${socket.port}`);
+    }
+  }
+  return [...new Set(ports)].sort();
+}
+
+function collectActiveRuntimeDirs(productDir) {
+  const active = new Set();
+  for (const manifest of listRunManifests(productDir)) {
+    if (!isPidRunning(manifest.pid)) continue;
+    for (const runtimeDir of manifest.runtimeDirs || []) {
+      active.add(path.resolve(runtimeDir));
+    }
+  }
+  return active;
+}
+
+function listRuntimeDirs(graphDir) {
+  const runtimesDir = path.join(graphDir, "runtimes");
+  if (!fs.existsSync(runtimesDir)) return [];
+  return fs.readdirSync(runtimesDir, { withFileTypes: true })
+    .filter((entry) => entry.isDirectory() && /^runtime-\d+$/.test(entry.name))
+    .map((entry) => ({
+      id: entry.name,
+      path: path.resolve(runtimesDir, entry.name),
+    }))
+    .sort((left, right) => runtimeIndex(left.id) - runtimeIndex(right.id) || left.id.localeCompare(right.id));
+}
+
+function runtimeIndex(runtimeId) {
+  return Number(String(runtimeId).match(/^runtime-(\d+)$/)?.[1] || Number.MAX_SAFE_INTEGER);
+}
+
+function collectDirectorySummary(dir) {
+  const files = listFiles(dir);
+  return {
+    path: dir,
+    exists: fs.existsSync(dir),
+    fileCount: files.length,
+    sizeBytes: files.reduce((sum, file) => sum + file.size, 0),
+  };
+}
+
+function listFiles(dir) {
+  const files = [];
+  const visit = (current) => {
+    if (!fs.existsSync(current)) return;
+    for (const entry of fs.readdirSync(current, { withFileTypes: true })) {
+      const filePath = path.join(current, entry.name);
+      if (entry.isDirectory()) {
+        visit(filePath);
+      } else if (entry.isFile()) {
+        const stat = fs.statSync(filePath);
+        files.push({
+          path: path.resolve(filePath),
+          size: stat.size,
+          mtimeMs: stat.mtimeMs,
+        });
+      }
+    }
+  };
+  visit(dir);
+  return files;
+}
+
+function readBundleManifest(dir) {
+  const manifestPath = path.join(dir, BUNDLE_MANIFEST);
+  if (!fs.existsSync(manifestPath)) {
+    return {
+      exists: false,
+      entries: [],
+      sourceFileCount: 0,
+    };
+  }
+  try {
+    const parsed = JSON.parse(fs.readFileSync(manifestPath, "utf8"));
+    const entries = Array.isArray(parsed.entries) ? parsed.entries : [];
+    return {
+      exists: true,
+      entries,
+      sourceFileCount: new Set(entries.map((entry) => entry.sourceFile).filter(Boolean)).size,
+    };
+  } catch {
+    return {
+      exists: true,
+      entries: [],
+      sourceFileCount: 0,
+    };
+  }
+}
+
+function inferBundleSources(entryFiles) {
+  const bySource = new Map();
+  for (const file of entryFiles) {
+    const sourceFile = readEntrySourceFile(file.path);
+    if (!sourceFile) continue;
+    const entries = bySource.get(sourceFile) || [];
+    entries.push(file);
+    bySource.set(sourceFile, entries);
+  }
+  return bySource;
+}
+
+function readEntrySourceFile(filePath) {
+  try {
+    const text = fs.readFileSync(filePath, "utf8");
+    const match = text.match(/import \* as suiteModule from ("(?:\\.|[^"])+");/);
+    return match ? JSON.parse(match[1]) : null;
+  } catch {
+    return null;
+  }
+}
+
+function collectInlineSourcemapStatus(files, manifest) {
+  if (manifest.entries.length > 0) {
+    const count = manifest.entries.filter((entry) => entry.hasSourcemap).length;
+    return {
+      count,
+      status: count > 0 ? "present" : "none",
+    };
+  }
+
+  const sample = files.slice(0, 25);
+  const detected = sample.some((file) => fileContainsInlineSourcemap(file.path));
+  if (detected) {
+    return {
+      count: null,
+      status: "detected",
+    };
+  }
+  return {
+    count: 0,
+    status: files.length > sample.length ? "not-detected-in-sample" : "none",
+  };
+}
+
+function fileContainsInlineSourcemap(filePath) {
+  try {
+    return /sourceMappingURL=data:application\/json/.test(fs.readFileSync(filePath, "utf8"));
+  } catch {
+    return false;
+  }
+}
+
+function collectManifestBundleCleanupTargets(entries) {
+  if (entries.length === 0) return [];
+  const now = Date.now();
+  const bySource = groupBy(entries, (entry) => entry.sourceFile || entry.cacheKey || entry.outputFile);
+  const targets = [];
+  for (const sourceEntries of bySource.values()) {
+    const sorted = [...sourceEntries].sort(compareBundleEntryRecentFirst);
+    const kept = new Set(
+      sorted
+        .filter((entry, index) => index < 2 || now - Date.parse(entry.lastUsedAt || entry.createdAt || 0) < ASSISTANT_RESULT_TTL_MS)
+        .map((entry) => entry.cacheKey || entry.outputFile)
+    );
+    for (const entry of sorted) {
+      const key = entry.cacheKey || entry.outputFile;
+      if (kept.has(key)) continue;
+      for (const filePath of [entry.outputFile, entry.entryFile].filter(Boolean)) {
+        targets.push({
+          path: path.resolve(filePath),
+          reason: "stale-bundle-version",
+          sourceFile: entry.sourceFile || null,
+        });
+      }
+    }
+  }
+  return targets;
+}
+
+function collectLegacyBundleCleanupTargets(dir) {
+  const entryFiles = listFiles(dir).filter((file) => file.path.endsWith(".entry.mjs"));
+  const bySource = inferBundleSources(entryFiles);
+  const targets = [];
+  for (const [sourceFile, files] of bySource.entries()) {
+    const sorted = [...files].sort((left, right) => right.mtimeMs - left.mtimeMs || left.path.localeCompare(right.path));
+    for (const file of sorted.slice(2)) {
+      const outputFile = file.path.replace(/\.entry\.mjs$/, ".js");
+      targets.push({ path: file.path, reason: "stale-legacy-bundle-version", sourceFile });
+      if (fs.existsSync(outputFile)) {
+        targets.push({ path: outputFile, reason: "stale-legacy-bundle-version", sourceFile });
+      }
+    }
+  }
+  return targets;
+}
+
+function compareBundleEntryRecentFirst(left, right) {
+  return Date.parse(right.lastUsedAt || right.createdAt || 0) - Date.parse(left.lastUsedAt || left.createdAt || 0) ||
+    String(left.outputFile || "").localeCompare(String(right.outputFile || ""));
+}
+
+function groupBy(entries, keyFn) {
+  const grouped = new Map();
+  for (const entry of entries) {
+    const key = keyFn(entry);
+    const values = grouped.get(key) || [];
+    values.push(entry);
+    grouped.set(key, values);
+  }
+  return grouped;
+}
+
+function dedupeCleanupFiles(targets) {
+  const byPath = new Map();
+  for (const target of targets) {
+    if (!target.path) continue;
+    byPath.set(path.resolve(target.path), {
+      ...target,
+      path: path.resolve(target.path),
+    });
+  }
+  return [...byPath.values()].sort((left, right) => left.path.localeCompare(right.path));
+}
+
+function normalizeCacheSelection(cache) {
+  const values = Array.isArray(cache) ? cache : [cache].filter(Boolean);
+  const selected = new Set(values.map(String));
+  if (selected.has("all")) {
+    selected.add("runtime");
+    selected.add("bundles");
+    selected.add("assistant");
+  }
+  return selected;
+}
+
+function collectWarnings({ runtimeGraphs, bundles, assistant }) {
+  const warnings = [];
+  const staleRuntimeCount = runtimeGraphs.reduce((sum, graph) => sum + graph.staleRuntimeDirs.length, 0);
+  if (staleRuntimeCount > 0) {
+    warnings.push(`${staleRuntimeCount} stale runtime ${staleRuntimeCount === 1 ? "directory" : "directories"} found outside the configured runtime set.`);
+  }
+  if (bundles.duplicatedSourceCount > 0) {
+    warnings.push(`${bundles.duplicatedSourceCount} source file${bundles.duplicatedSourceCount === 1 ? "" : "s"} have duplicate bundle versions.`);
+  }
+  if (bundles.unmanagedFileCount > 0) {
+    warnings.push(`${bundles.unmanagedFileCount} bundle cache file${bundles.unmanagedFileCount === 1 ? "" : "s"} are unmanaged by the manifest.`);
+  }
+  if (bundles.sourcemapFileCount > 0 || bundles.sourcemapStatus === "detected") {
+    const count = bundles.sourcemapFileCount == null ? "Legacy bundle files" : `${bundles.sourcemapFileCount} bundle file${bundles.sourcemapFileCount === 1 ? "" : "s"}`;
+    warnings.push(`${count} contain inline sourcemaps.`);
+  }
+  if (assistant.largeFileCount > 0) {
+    warnings.push(`${assistant.largeFileCount} assistant command result file${assistant.largeFileCount === 1 ? "" : "s"} exceed the large-file threshold.`);
+  }
+  return warnings;
+}

package/lib/runner/suite-selection.mjs

@@ -1,4 +1,11 @@
-const USER_TYPES = new Set(["int", "e2e", "scenario", "dal", "load", "pw", "all"]);
+import {
+  RUN_TYPE_ORDER,
+  RUN_TYPES,
+  TEST_TYPE_ORDER,
+  TEST_TYPES,
+  normalizePublicTestType,
+  publicTestTypeListText,
+} from "../domain/test-types.mjs";
 
 export function normalizeTypeValues(values = []) {
   const expanded = [];
@@ -7,12 +14,13 @@ export function normalizeTypeValues(values = []) {
     for (const part of String(rawValue).split(",")) {
       const value = part.trim();
       if (!value) continue;
-      if (!USER_TYPES.has(value)) {
+      const normalized = normalizePublicTestType(value);
+      if (!RUN_TYPES.has(normalized)) {
         throw new Error(
-          `Unknown type "${value}". Expected one of: int, e2e, scenario, dal, load, pw, all.`
+          `Unknown type "${value}". Expected one of: ${publicTestTypeListText({ includeAll: true })}.`
         );
       }
-      expanded.push(value);
+      expanded.push(normalized);
     }
   }
 
@@ -25,8 +33,7 @@ export function normalizeTypeValues(values = []) {
     throw new Error(`"--type all" cannot be combined with other types.`);
   }
 
-  const order = ["int", "e2e", "scenario", "dal", "load", "pw", "all"];
-  return deduped.sort((left, right) => order.indexOf(left) - order.indexOf(right));
+  return deduped.sort((left, right) => RUN_TYPE_ORDER.indexOf(left) - RUN_TYPE_ORDER.indexOf(right));
 }
 
 export function isAllTypeSelection(typeValues = []) {
@@ -50,9 +57,10 @@ export function parseSuiteSelectors(values = []) {
 
       const type = typeMatch[1];
       const name = typeMatch[2].trim();
-      if (!USER_TYPES.has(type) || type === "all") {
+      const normalizedType = normalizePublicTestType(type);
+      if (!TEST_TYPES.has(normalizedType)) {
         throw new Error(
-          `Unknown suite selector type "${type}". Expected one of: int, e2e, scenario, dal, load, pw.`
+          `Unknown suite selector type "${type}". Expected one of: ${publicTestTypeListText()}.`
         );
       }
       if (!name) {
@@ -61,9 +69,9 @@ export function parseSuiteSelectors(values = []) {
 
       selectors.push({
         kind: "typed",
-        type,
+        type: normalizedType,
         name,
-        raw: `${type}:${name}`,
+        raw: `${normalizedType}:${name}`,
       });
     }
   }
@@ -72,8 +80,9 @@ export function parseSuiteSelectors(values = []) {
 }
 
 export function suiteSelectionType(type, framework) {
-  if ((framework || "k6") === "playwright") return "pw";
+  if (type === "ui" || (framework || "k6") === "playwright") return "ui";
   if (type === "integration") return "int";
+  if (TEST_TYPE_ORDER.includes(type)) return type;
   return type;
 }
 

package/lib/runner/template-steps.mjs

@@ -31,7 +31,7 @@ const CONFIG_NEXT_TSCONFIG_ENTRY = path.join(
 );
 const DRIZZLE_ENTRY = path.join(PACKAGE_ROOT, "lib", "drizzle", "index.mjs");
 const ENV_ENTRY = path.join(PACKAGE_ROOT, "lib", "env", "index.mjs");
-const PLAYWRIGHT_ENTRY = path.join(PACKAGE_ROOT, "lib", "playwright", "index.mjs");
+const UI_ENTRY = path.join(PACKAGE_ROOT, "lib", "ui", "index.mjs");
 const RUNTIME_ENTRY = path.join(PACKAGE_ROOT, "lib", "runtime", "index.mjs");
 const VITEST_ENTRY = path.join(PACKAGE_ROOT, "lib", "vitest", "index.mjs");
 const DISCOVERY_ENTRY = path.join(PACKAGE_ROOT, "lib", "discovery", "index.mjs");
@@ -259,7 +259,7 @@ function resolvePackageSubpath(specifier) {
   if (subpath === "/config/next-runtime-tsconfig") return CONFIG_NEXT_TSCONFIG_ENTRY;
   if (subpath === "/drizzle") return DRIZZLE_ENTRY;
   if (subpath === "/env") return ENV_ENTRY;
-  if (subpath === "/playwright") return PLAYWRIGHT_ENTRY;
+  if (subpath === "/ui") return UI_ENTRY;
   if (subpath === "/runtime") return RUNTIME_ENTRY;
   if (subpath === "/vitest") return VITEST_ENTRY;
   if (subpath === "/discovery") return DISCOVERY_ENTRY;

package/lib/runner/template.mjs

@@ -119,6 +119,7 @@ export function resolveRuntimeConfig(
     runtimeId,
     runtimeLabel,
     runtimeDir,
+    productDir: config.productDir,
     serviceName: config.name,
     serviceStateDir: stateDir,
     prepareDir,
@@ -258,6 +259,7 @@ function buildTemplateContext(config, lease) {
     ...baseContext,
     runtimeId: config.runtimeId || baseContext.runtimeId || null,
     runtimeLabel: config.runtimeLabel || baseContext.runtimeLabel || null,
+    productDir: config.productDir || baseContext.productDir || null,
     serviceName: config.name,
     serviceStateDir: config.stateDir || baseContext.serviceStateDir || null,
     prepareDir: config.testkit?.prepareDir || baseContext.prepareDir || null,
@@ -298,6 +300,8 @@ export function resolveTemplateString(value, context) {
         return context.serviceName;
       case "stateDir":
         return context.serviceStateDir;
+      case "productDir":
+        return context.productDir || "";
       case "prepareDir":
         return context.prepareDir || "";
       case "lease":

package/lib/ui/index.d.ts

@@ -0,0 +1 @@
+export * from "@playwright/test";

package/lib/ui/index.mjs

@@ -0,0 +1 @@
+export * from "@playwright/test";

package/lib/vitest/index.mjs

@@ -4,7 +4,8 @@ const TESTKIT_SUITE_GLOBS = [
   "**/*.scenario.testkit.ts",
   "**/*.dal.testkit.ts",
   "**/*.load.testkit.ts",
-  "**/*.pw.testkit.ts",
+  "**/*.ui.testkit.ts",
+  "**/*.ui.testkit.ts",
 ];
 
 export function defineConfig(config = {}, options = {}) {

package/node_modules/@elench/next-analysis/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@elench/next-analysis",
-  "version": "0.1.108",
+  "version": "0.1.110",
   "description": "SWC-backed Next.js source analysis primitives for Erench tools",
   "type": "module",
   "exports": {