@elench/testkit 0.1.17 → 0.1.18

package/lib/{runner.mjs → runner/index.mjs}

@@ -3,7 +3,7 @@ import path from "path";
 import { spawn } from "child_process";
 import net from "net";
 import { execa, execaCommand } from "execa";
-import { resolveDalBinary, resolveServiceCwd } from "./config.mjs";
+import { resolveDalBinary, resolveServiceCwd } from "../config/index.mjs";
 import {
   cleanupOrphanedLocalInfrastructure,
   destroyRuntimeDatabase,
@@ -11,28 +11,102 @@ import {
   isDatabaseStateDir,
   prepareDatabaseRuntime,
   showServiceDatabaseStatus,
-} from "./database.mjs";
+} from "../database/index.mjs";
+import {
+  batchNeedsLocalRuntime as batchNeedsLocalRuntimeModel,
+  buildGraphDirName as buildGraphDirNameModel,
+  buildRuntimeGraphs as buildRuntimeGraphsModel,
+  buildTaskQueue as buildTaskQueueModel,
+  claimNextBatch as claimNextBatchModel,
+  collectSuites as collectSuitesModel,
+  compareGraphsForAssignment as compareGraphsForAssignmentModel,
+  isRuntimeSuperset as isRuntimeSupersetModel,
+  orderedTypes as orderedTypesModel,
+  resolveRuntimeConfigs as resolveRuntimeConfigsModel,
+  applyShard as applyShardModel,
+} from "./planning.mjs";
+import {
+  buildExecutionEnv as buildExecutionEnvModel,
+  buildPlaywrightEnv as buildPlaywrightEnvModel,
+  buildPortMap as buildPortMapModel,
+  finalizeString as finalizeStringModel,
+  getWorkerServiceStateDir as getWorkerServiceStateDirModel,
+  normalizeSocketHost as normalizeSocketHostModel,
+  numericPortFromUrl as numericPortFromUrlModel,
+  resolveRuntimeUrl as resolveRuntimeUrlModel,
+  resolveServiceStateDir as resolveServiceStateDirModel,
+  resolveTemplateString as resolveTemplateStringModel,
+  resolveWorkerConfig as resolveWorkerConfigModel,
+  resolveWorkerRuntimeConfigs as resolveWorkerRuntimeConfigsModel,
+  rewriteUrlPort as rewriteUrlPortModel,
+  socketFromUrl as socketFromUrlModel,
+} from "./template.mjs";
+import {
+  addTrackerError as addTrackerErrorModel,
+  buildRunArtifact as buildRunArtifactModel,
+  buildServiceTrackers as buildServiceTrackersModel,
+  finalizeServiceResult as finalizeServiceResultModel,
+  formatDuration as formatDurationModel,
+  formatError as formatErrorModel,
+  formatServiceSummary as formatServiceSummaryModel,
+  longestServiceName as longestServiceNameModel,
+  recordGraphError as recordGraphErrorModel,
+  recordTaskOutcome as recordTaskOutcomeModel,
+  summarizeDbBackend as summarizeDbBackendModel,
+} from "./results.mjs";
+import {
+  applyTimingUpdates,
+  buildTimingKey as buildTimingKeyModel,
+  createEmptyTimings,
+  estimateTaskDuration as estimateTaskDurationModel,
+  normalizeTimings,
+} from "../timing/index.mjs";
+import {
+  choosePlaywrightFinalResult as choosePlaywrightFinalResultModel,
+  collectPlaywrightSpec as collectPlaywrightSpecModel,
+  extractPlaywrightFailure as extractPlaywrightFailureModel,
+  extractReporterFile as extractReporterFileModel,
+  firstLine as firstLineModel,
+  formatPlaywrightReporterError as formatPlaywrightReporterErrorModel,
+  isPlaywrightPassingStatus as isPlaywrightPassingStatusModel,
+  normalizeReportedFile as normalizeReportedFileModel,
+  parsePlaywrightJsonResults as parsePlaywrightJsonResultsModel,
+  visitPlaywrightSuites as visitPlaywrightSuitesModel,
+} from "../reporters/playwright.mjs";
+import {
+  collectGitMetadata as collectGitMetadataModel,
+  readPackageMetadata as readPackageMetadataModel,
+  safeHostname as safeHostnameModel,
+  safeUsername as safeUsernameModel,
+} from "./metadata.mjs";
+import {
+  findGraphDirsForService as findGraphDirsForServiceModel,
+  findRuntimeStateDirs as findRuntimeStateDirsModel,
+  normalizePathSeparators as normalizePathSeparatorsModel,
+  readGraphMetadata as readGraphMetadataModel,
+  writeGraphMetadata as writeGraphMetadataModel,
+} from "./state.mjs";
+import { uploadTelemetryArtifact } from "../telemetry/index.mjs";
 
-const TYPE_ORDER = ["dal", "integration", "e2e", "load"];
 const HTTP_K6_TYPES = new Set(["integration", "e2e", "load"]);
 const DEFAULT_READY_TIMEOUT_MS = 120_000;
-const PORT_STRIDE = 100;
 const TIMINGS_FILENAME = "timings.json";
-const GRAPH_METADATA = "graph.json";
 
 export async function runAll(configs, suiteType, suiteNames, opts, allConfigs = configs) {
   const configMap = new Map(allConfigs.map((config) => [config.name, config]));
   const startedAt = Date.now();
+  const telemetry = configs[0]?.telemetry || null;
   const servicePlans = collectServicePlans(configs, configMap, suiteType, suiteNames, opts);
   const trackers = buildServiceTrackers(servicePlans, startedAt);
   const executedPlans = servicePlans.filter((plan) => !plan.skipped);
+  let workerCount = 0;
 
   if (executedPlans.length > 0) {
     const productDir = executedPlans[0].config.productDir;
     const timings = loadTimings(productDir);
     const graphs = buildRuntimeGraphs(executedPlans);
     const queue = buildTaskQueue(executedPlans, graphs, timings);
-    const workerCount = Math.max(1, Math.min(opts.jobs || 1, queue.length));
+    workerCount = Math.max(1, Math.min(opts.jobs || 1, queue.length));
     const graphByKey = new Map(graphs.map((graph) => [graph.key, graph]));
     const workers = Array.from({ length: workerCount }, (_unused, index) =>
       createWorker(index + 1, productDir)
@@ -61,8 +135,24 @@ export async function runAll(configs, suiteType, suiteNames, opts, allConfigs =
   const results = configs.map((config) =>
     finalizeServiceResult(trackers.get(config.name), startedAt, finishedAt)
   );
+  const artifact = buildRunArtifact({
+    productDir: configs[0]?.productDir || process.cwd(),
+    results,
+    startedAt,
+    finishedAt,
+    requestedJobs: opts.jobs || 1,
+    workerCount,
+    suiteType,
+    suiteNames,
+    framework: opts.framework || "all",
+    shard: opts.shard || null,
+    serviceFilter: configs.length === 1 ? configs[0].name : null,
+  });
+
+  writeRunArtifact(configs[0]?.productDir || process.cwd(), artifact);
 
   printRunSummary(results, finishedAt - startedAt);
+  await reportTelemetry(telemetry, artifact);
   if (results.some((result) => result.failed)) process.exit(1);
 }
 
@@ -141,161 +231,15 @@ function collectServicePlans(configs, configMap, suiteType, suiteNames, opts) {
 }
 
 function buildServiceTrackers(servicePlans, startedAt) {
-  const trackers = new Map();
-
-  for (const plan of servicePlans) {
-    if (plan.skipped) {
-      trackers.set(plan.config.name, {
-        name: plan.config.name,
-        skipped: true,
-        suiteCount: 0,
-        suites: [],
-        suitesByKey: new Map(),
-        errors: [],
-        errorSet: new Set(),
-        startedAt,
-        firstTaskAt: null,
-        lastTaskAt: null,
-      });
-      continue;
-    }
-
-    const suites = plan.suites.map((suite) => ({
-      key: `${suite.type}:${suite.name}`,
-      name: suite.name,
-      type: suite.type,
-      framework: suite.framework,
-      orderIndex: suite.orderIndex,
-      fileCount: suite.files.length,
-      completedFileCount: 0,
-      failedFiles: [],
-      failedFileSet: new Set(),
-      durationMs: 0,
-      error: null,
-    }));
-
-    trackers.set(plan.config.name, {
-      name: plan.config.name,
-      skipped: false,
-      suiteCount: suites.length,
-      suites,
-      suitesByKey: new Map(suites.map((suite) => [suite.key, suite])),
-      errors: [],
-      errorSet: new Set(),
-      startedAt,
-      firstTaskAt: null,
-      lastTaskAt: null,
-    });
-  }
-
-  return trackers;
+  return buildServiceTrackersModel(servicePlans, startedAt);
 }
 
 function buildRuntimeGraphs(servicePlans) {
-  const executed = servicePlans.filter((plan) => !plan.skipped);
-  const uniqueGraphs = [];
-  const graphByRuntimeKey = new Map();
-
-  for (const plan of executed) {
-    if (graphByRuntimeKey.has(plan.runtimeKey)) {
-      graphByRuntimeKey.get(plan.runtimeKey).exactTargets.push(plan.config.name);
-      continue;
-    }
-
-    const graph = {
-      key: plan.runtimeKey,
-      runtimeNames: plan.runtimeNames,
-      runtimeConfigs: plan.runtimeConfigs,
-      exactTargets: [plan.config.name],
-      assignedTargets: [],
-      dirName: null,
-      rootConfig: null,
-    };
-    uniqueGraphs.push(graph);
-    graphByRuntimeKey.set(plan.runtimeKey, graph);
-  }
-
-  const maximalGraphs = uniqueGraphs.filter(
-    (graph) =>
-      !uniqueGraphs.some(
-        (other) =>
-          other.key !== graph.key &&
-          isRuntimeSuperset(other.runtimeNames, graph.runtimeNames)
-      )
-  );
-
-  for (const plan of executed) {
-    const compatible = maximalGraphs.filter((graph) =>
-      isRuntimeSuperset(graph.runtimeNames, plan.runtimeNames)
-    );
-    if (compatible.length === 0) {
-      throw new Error(`No runtime graph found for service "${plan.config.name}"`);
-    }
-
-    const assigned = compatible.sort(compareGraphsForAssignment)[0];
-    plan.assignedGraphKey = assigned.key;
-    assigned.assignedTargets.push(plan.config.name);
-  }
-
-  for (const graph of maximalGraphs) {
-    const rootName = [...graph.exactTargets].sort()[0];
-    const rootPlan = executed.find((plan) => plan.config.name === rootName);
-    if (!rootPlan) {
-      throw new Error(`Missing root plan for graph "${graph.key}"`);
-    }
-    graph.rootConfig = rootPlan.config;
-    graph.dirName = buildGraphDirName(graph.runtimeNames);
-  }
-
-  return maximalGraphs.sort((a, b) => a.dirName.localeCompare(b.dirName));
+  return buildRuntimeGraphsModel(servicePlans);
 }
 
 function buildTaskQueue(servicePlans, graphs, timings) {
-  const graphByKey = new Map(graphs.map((graph) => [graph.key, graph]));
-  const tasks = [];
-  let nextId = 1;
-
-  for (const plan of servicePlans) {
-    if (plan.skipped) continue;
-
-    const graph = graphByKey.get(plan.assignedGraphKey);
-    if (!graph) {
-      throw new Error(`Assigned graph "${plan.assignedGraphKey}" not found for ${plan.config.name}`);
-    }
-
-    for (const suite of plan.suites) {
-      for (const file of suite.files) {
-        const timingKey = buildTimingKey(plan.config.name, suite, file);
-        tasks.push({
-          id: nextId,
-          graphKey: graph.key,
-          targetName: plan.config.name,
-          serviceName: plan.config.name,
-          suiteKey: `${suite.type}:${suite.name}`,
-          suiteName: suite.name,
-          type: suite.type,
-          framework: suite.framework,
-          orderIndex: suite.orderIndex,
-          file,
-          timingKey,
-          estimatedDurationMs: estimateTaskDuration(timings, timingKey, suite),
-          maxBatchSize:
-            suite.framework === "playwright"
-              ? Number.POSITIVE_INFINITY
-              : suite.maxFileConcurrency || 1,
-        });
-        nextId += 1;
-      }
-    }
-  }
-
-  return tasks.sort(
-    (a, b) =>
-      b.estimatedDurationMs - a.estimatedDurationMs ||
-      a.serviceName.localeCompare(b.serviceName) ||
-      a.suiteKey.localeCompare(b.suiteKey) ||
-      a.file.localeCompare(b.file)
-  );
+  return buildTaskQueueModel(servicePlans, graphs, timings);
 }
 
 function createWorker(workerId, productDir) {
@@ -352,58 +296,7 @@ async function runWorker(worker, queue, graphByKey, trackers, timingUpdates) {
 }
 
 function claimNextBatch(queue, preferredGraphKey) {
-  if (queue.length === 0) return null;
-
-  let index = -1;
-  if (preferredGraphKey) {
-    index = queue.findIndex((task) => task.graphKey === preferredGraphKey);
-  }
-  if (index === -1) index = 0;
-
-  const seed = queue.splice(index, 1)[0];
-  const tasks = [seed];
-
-  if (seed.framework === "playwright") {
-    for (let cursor = queue.length - 1; cursor >= 0; cursor -= 1) {
-      const candidate = queue[cursor];
-      if (
-        candidate.framework === "playwright" &&
-        candidate.graphKey === seed.graphKey &&
-        candidate.targetName === seed.targetName
-      ) {
-        tasks.push(candidate);
-        queue.splice(cursor, 1);
-      }
-    }
-  } else if (seed.maxBatchSize > 1) {
-    for (let cursor = queue.length - 1; cursor >= 0 && tasks.length < seed.maxBatchSize; cursor -= 1) {
-      const candidate = queue[cursor];
-      if (
-        candidate.framework === seed.framework &&
-        candidate.type === seed.type &&
-        candidate.graphKey === seed.graphKey &&
-        candidate.targetName === seed.targetName &&
-        candidate.suiteKey === seed.suiteKey
-      ) {
-        tasks.push(candidate);
-        queue.splice(cursor, 1);
-      }
-    }
-  }
-
-  tasks.sort(
-    (a, b) =>
-      a.orderIndex - b.orderIndex ||
-      a.file.localeCompare(b.file)
-  );
-
-  return {
-    graphKey: seed.graphKey,
-    targetName: seed.targetName,
-    framework: seed.framework,
-    type: seed.type,
-    tasks,
-  };
+  return claimNextBatchModel(queue, preferredGraphKey);
 }
 
 async function ensureWorkerGraph(worker, batch, graphByKey) {
@@ -812,168 +705,31 @@ async function waitForReady({ name, url, timeoutMs, process }) {
 }
 
 function batchNeedsLocalRuntime(batch) {
-  return batch.tasks.some((task) => task.type !== "dal");
+  return batchNeedsLocalRuntimeModel(batch);
 }
 
 function resolveRuntimeConfigs(targetConfig, configMap) {
-  const ordered = [];
-  const visiting = new Set();
-  const seen = new Set();
-
-  const visit = (config) => {
-    if (seen.has(config.name)) return;
-    if (visiting.has(config.name)) {
-      throw new Error(`Dependency cycle detected involving "${config.name}"`);
-    }
-
-    visiting.add(config.name);
-    for (const depName of config.testkit.dependsOn || []) {
-      const dep = configMap.get(depName);
-      if (!dep) {
-        throw new Error(`Service "${config.name}" depends on unknown service "${depName}"`);
-      }
-      visit(dep);
-    }
-    visiting.delete(config.name);
-    seen.add(config.name);
-    ordered.push(config);
-  };
-
-  visit(targetConfig);
-  return ordered;
+  return resolveRuntimeConfigsModel(targetConfig, configMap);
 }
 
 function collectSuites(config, suiteType, suiteNames, frameworkFilter) {
-  const types =
-    suiteType === "all"
-      ? orderedTypes(Object.keys(config.suites))
-      : [suiteType === "int" ? "integration" : suiteType];
-
-  const selectedNames = new Set(suiteNames);
-  const suites = [];
-  let orderIndex = 0;
-
-  for (const type of types) {
-    for (const suite of config.suites[type] || []) {
-      const framework = suite.framework || "k6";
-      if (selectedNames.size > 0 && !selectedNames.has(suite.name)) continue;
-      if (frameworkFilter && frameworkFilter !== "all" && framework !== frameworkFilter) continue;
-
-      suites.push({
-        ...suite,
-        framework,
-        type,
-        orderIndex,
-        sortKey: `${type}:${suite.name}`,
-        weight:
-          suite.testkit?.weight ||
-          (framework === "playwright"
-            ? Math.max(2, suite.files.length)
-            : Math.max(1, suite.files.length)),
-        maxFileConcurrency:
-          framework === "k6" ? suite.testkit?.maxFileConcurrency || 1 : 1,
-      });
-      orderIndex += 1;
-    }
-  }
-
-  return suites;
+  return collectSuitesModel(config, suiteType, suiteNames, frameworkFilter);
 }
 
 function applyShard(suites, shard) {
-  if (!shard) return suites;
-  return suites.filter((unused, index) => index % shard.total === shard.index - 1);
+  return applyShardModel(suites, shard);
 }
 
 function orderedTypes(types) {
-  const ordered = [];
-  for (const known of TYPE_ORDER) {
-    if (types.includes(known)) ordered.push(known);
-  }
-  for (const type of types) {
-    if (!ordered.includes(type)) ordered.push(type);
-  }
-  return ordered;
+  return orderedTypesModel(types);
 }
 
 function resolveWorkerRuntimeConfigs(targetConfig, runtimeConfigs, workerId, workerStateDir) {
-  const portMap = buildPortMap(runtimeConfigs, workerId);
-  const baseUrlByService = new Map();
-  const readyUrlByService = new Map();
-
-  for (const config of runtimeConfigs) {
-    if (!config.testkit.local) continue;
-    baseUrlByService.set(
-      config.name,
-      resolveRuntimeUrl(config.testkit.local.baseUrl, config.name, targetConfig, workerId, {
-        workerStateDir,
-        portMap,
-        baseUrlByService,
-        readyUrlByService,
-      })
-    );
-    readyUrlByService.set(
-      config.name,
-      resolveRuntimeUrl(config.testkit.local.readyUrl, config.name, targetConfig, workerId, {
-        workerStateDir,
-        portMap,
-        baseUrlByService,
-        readyUrlByService,
-      })
-    );
-  }
-
-  const urlMappings = [];
-  for (const config of runtimeConfigs) {
-    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]);
-    }
-  }
-
-  return runtimeConfigs.map((config) =>
-    resolveWorkerConfig(
-      config,
-      targetConfig,
-      workerId,
-      workerStateDir,
-      portMap,
-      baseUrlByService,
-      readyUrlByService,
-      urlMappings
-    )
-  );
+  return resolveWorkerRuntimeConfigsModel(targetConfig, runtimeConfigs, workerId, workerStateDir);
 }
 
 function buildPortMap(runtimeConfigs, workerId) {
-  const portMap = new Map();
-  const seen = new Map();
-  const offset = PORT_STRIDE * (workerId - 1);
-
-  for (const config of runtimeConfigs) {
-    if (!config.testkit.local) continue;
-
-    const basePort = config.testkit.local.port || numericPortFromUrl(config.testkit.local.baseUrl);
-    if (!basePort) continue;
-
-    const actualPort = basePort + offset;
-    const existing = seen.get(actualPort);
-    if (existing) {
-      throw new Error(
-        `Worker port collision: services "${existing}" and "${config.name}" both resolve to ${actualPort}. ` +
-          `Assign distinct local.port/baseUrl ports in testkit.config.json.`
-      );
-    }
-    seen.set(actualPort, config.name);
-    portMap.set(config.name, actualPort);
-  }
-
-  return portMap;
+  return buildPortMapModel(runtimeConfigs, workerId);
 }
 
 function resolveWorkerConfig(
@@ -986,210 +742,48 @@ function resolveWorkerConfig(
   readyUrlByService,
   urlMappings
 ) {
-  const stateDir = resolveServiceStateDir(workerStateDir, targetConfig.name, config);
-  const context = {
+  return resolveWorkerConfigModel(
+    config,
+    targetConfig,
     workerId,
-    serviceName: config.name,
-    targetName: targetConfig.name,
-    serviceStateDir: stateDir,
+    workerStateDir,
     portMap,
     baseUrlByService,
     readyUrlByService,
-    urlMappings,
-  };
-
-  const database = config.testkit.database
-    ? {
-        ...config.testkit.database,
-        branchName:
-          config.testkit.database.provider === "neon" &&
-          config.testkit.database.branchName !== undefined
-            ? finalizeString(config.testkit.database.branchName, context)
-            : config.testkit.database.provider === "neon"
-              ? `${targetConfig.name}-${config.name}-w${workerId}-testkit`
-              : undefined,
-      }
-    : undefined;
-
-  const migrate = config.testkit.migrate
-    ? {
-        ...config.testkit.migrate,
-        cmd: finalizeString(config.testkit.migrate.cmd, context),
-        cwd:
-          config.testkit.migrate.cwd !== undefined
-            ? finalizeString(config.testkit.migrate.cwd, context)
-            : config.testkit.migrate.cwd,
-      }
-    : undefined;
-
-  const seed = config.testkit.seed
-    ? {
-        ...config.testkit.seed,
-        cmd: finalizeString(config.testkit.seed.cmd, context),
-        cwd:
-          config.testkit.seed.cwd !== undefined
-            ? finalizeString(config.testkit.seed.cwd, context)
-            : config.testkit.seed.cwd,
-      }
-    : undefined;
-
-  const local = config.testkit.local
-    ? {
-        ...config.testkit.local,
-        start: finalizeString(config.testkit.local.start, context),
-        cwd:
-          config.testkit.local.cwd !== undefined
-            ? finalizeString(config.testkit.local.cwd, context)
-            : config.testkit.local.cwd,
-        port: portMap.get(config.name) || config.testkit.local.port,
-        baseUrl: baseUrlByService.get(config.name),
-        readyUrl: readyUrlByService.get(config.name),
-        env: Object.fromEntries(
-          Object.entries(config.testkit.local.env || {}).map(([key, value]) => [
-            key,
-            finalizeString(String(value), context),
-          ])
-        ),
-      }
-    : undefined;
-
-  return {
-    ...config,
-    stateDir,
-    workerId,
-    workerLabel: `w${workerId}`,
-    targetName: targetConfig.name,
-    testkit: {
-      ...config.testkit,
-      database,
-      migrate,
-      seed,
-      local,
-    },
-  };
+    urlMappings
+  );
 }
 
 function resolveServiceStateDir(workerStateDir, targetName, config) {
-  const dbSource = config.testkit.databaseFrom || config.name;
-  return getWorkerServiceStateDir(workerStateDir, targetName, dbSource);
+  return resolveServiceStateDirModel(workerStateDir, targetName, config);
 }
 
 function getWorkerServiceStateDir(workerStateDir, targetName, serviceName) {
-  if (targetName === serviceName) {
-    return workerStateDir;
-  }
-  return path.join(workerStateDir, "deps", serviceName);
+  return getWorkerServiceStateDirModel(workerStateDir, targetName, serviceName);
 }
 
 function buildExecutionEnv(config, extraEnv = {}) {
-  return {
-    ...process.env,
-    ...(config.testkit.serviceEnv || {}),
-    ...extraEnv,
-  };
+  return buildExecutionEnvModel(config, extraEnv, process.env);
 }
 
 function buildPlaywrightEnv(config, baseUrl) {
-  return buildExecutionEnv(config, {
-    BASE_URL: baseUrl,
-    PLAYWRIGHT_HTML_OPEN: "never",
-    PLAYWRIGHT_SKIP_VALIDATE_HOST_REQUIREMENTS:
-      process.env.PLAYWRIGHT_SKIP_VALIDATE_HOST_REQUIREMENTS || "1",
-    TESTKIT_MANAGED_SERVERS: "1",
-    TESTKIT_WORKER_ID: String(config.workerId),
-  });
+  return buildPlaywrightEnvModel(config, baseUrl, process.env);
 }
 
 function recordTaskOutcome(trackers, task, outcome) {
-  const tracker = trackers.get(task.serviceName);
-  if (!tracker || tracker.skipped) return;
-
-  const finishedAt = Date.now();
-  if (!tracker.firstTaskAt) tracker.firstTaskAt = finishedAt;
-  tracker.lastTaskAt = finishedAt;
-
-  const suite = tracker.suitesByKey.get(task.suiteKey);
-  if (!suite) return;
-
-  suite.completedFileCount += 1;
-  suite.durationMs += outcome.durationMs;
-  if (outcome.failed && !suite.failedFileSet.has(task.file)) {
-    suite.failedFileSet.add(task.file);
-    suite.failedFiles.push(task.file);
-  }
-  if (outcome.error && !suite.error) {
-    suite.error = outcome.error;
-  }
+  return recordTaskOutcomeModel(trackers, task, outcome);
 }
 
 function recordGraphError(trackers, graph, message) {
-  const targetNames = graph?.assignedTargets || [];
-  for (const targetName of targetNames) {
-    const tracker = trackers.get(targetName);
-    if (tracker && !tracker.skipped) {
-      addTrackerError(tracker, message);
-      tracker.lastTaskAt = Date.now();
-    }
-  }
+  return recordGraphErrorModel(trackers, graph, message);
 }
 
 function addTrackerError(tracker, message) {
-  if (tracker.errorSet.has(message)) return;
-  tracker.errorSet.add(message);
-  tracker.errors.push(message);
+  return addTrackerErrorModel(tracker, message);
 }
 
 function finalizeServiceResult(tracker, startedAt, finishedAt) {
-  if (!tracker || tracker.skipped) {
-    return {
-      name: tracker?.name || "unknown",
-      failed: false,
-      skipped: true,
-      suiteCount: 0,
-      completedSuiteCount: 0,
-      failedSuiteCount: 0,
-      durationMs: 0,
-      suites: [],
-      errors: [],
-    };
-  }
-
-  const suites = [...tracker.suites].sort(
-    (a, b) => a.orderIndex - b.orderIndex || a.name.localeCompare(b.name)
-  );
-  const completedSuiteCount = suites.filter(
-    (suite) => suite.completedFileCount === suite.fileCount
-  ).length;
-  const failedSuiteCount = suites.filter((suite) => suite.failedFiles.length > 0).length;
-  const accumulatedDurationMs = suites.reduce((sum, suite) => sum + suite.durationMs, 0);
-  const durationMs =
-    tracker.firstTaskAt && tracker.lastTaskAt
-      ? Math.max(tracker.lastTaskAt - tracker.firstTaskAt, accumulatedDurationMs)
-      : Math.max(finishedAt - startedAt, accumulatedDurationMs);
-
-  return {
-    name: tracker.name,
-    failed:
-      failedSuiteCount > 0 ||
-      tracker.errors.length > 0 ||
-      completedSuiteCount < tracker.suiteCount,
-    skipped: false,
-    suiteCount: tracker.suiteCount,
-    completedSuiteCount,
-    failedSuiteCount,
-    durationMs,
-    suites: suites.map((suite) => ({
-      name: suite.name,
-      type: suite.type,
-      framework: suite.framework,
-      failed: suite.failedFiles.length > 0,
-      fileCount: suite.fileCount,
-      failedFiles: suite.failedFiles,
-      durationMs: suite.durationMs,
-      error: suite.error,
-    })),
-    errors: tracker.errors,
-  };
+  return finalizeServiceResultModel(tracker, startedAt, finishedAt);
 }
 
 function printRunSummary(results, durationMs) {
@@ -1251,86 +845,121 @@ function printRunSummary(results, durationMs) {
   console.log("\nResult: PASSED");
 }
 
+async function reportTelemetry(telemetry, artifact) {
+  if (!telemetry?.enabled) return;
+
+  try {
+    const outcome = await uploadTelemetryArtifact(telemetry, artifact);
+    if (outcome?.ok) {
+      console.log("Telemetry: uploaded run artifact");
+      return;
+    }
+    if (outcome?.reason === "missing-token") {
+      console.log(
+        `Telemetry: skipped upload because ${telemetry.tokenEnv || "configured token env"} is not set`
+      );
+      return;
+    }
+    if (outcome?.reason && !outcome.skipped) return;
+  } catch (error) {
+    console.log(`Telemetry: upload failed (${formatError(error)})`);
+  }
+}
+
 function longestServiceName(results) {
-  return results.reduce((max, result) => Math.max(max, result.name.length), 4);
+  return longestServiceNameModel(results);
+}
+
+function buildRunArtifact({
+  productDir,
+  results,
+  startedAt,
+  finishedAt,
+  requestedJobs,
+  workerCount,
+  suiteType,
+  suiteNames,
+  framework,
+  shard,
+  serviceFilter,
+}) {
+  return buildRunArtifactModel({
+    productDir,
+    results,
+    startedAt,
+    finishedAt,
+    requestedJobs,
+    workerCount,
+    suiteType,
+    suiteNames,
+    framework,
+    shard,
+    serviceFilter,
+    metadata: {
+      git: collectGitMetadata(productDir),
+      host: {
+        hostname: safeHostname(),
+        username: safeUsername(),
+      },
+      testkitVersion: readPackageMetadata().version,
+    },
+  });
+}
+
+function writeRunArtifact(productDir, artifact) {
+  const resultsDir = path.join(productDir, ".testkit", "results");
+  fs.mkdirSync(resultsDir, { recursive: true });
+  fs.writeFileSync(path.join(resultsDir, "latest.json"), JSON.stringify(artifact, null, 2));
+}
+
+function summarizeDbBackend(results) {
+  return summarizeDbBackendModel(results);
+}
+
+function collectGitMetadata(productDir) {
+  return collectGitMetadataModel(productDir);
+}
+
+function readPackageMetadata() {
+  return readPackageMetadataModel();
+}
+
+function safeHostname() {
+  return safeHostnameModel();
+}
+
+function safeUsername() {
+  return safeUsernameModel();
 }
 
 function formatDuration(durationMs) {
-  const totalSeconds = Math.max(0, Math.round(durationMs / 1000));
-  const minutes = Math.floor(totalSeconds / 60);
-  const seconds = totalSeconds % 60;
-  if (minutes === 0) return `${seconds}s`;
-  return `${minutes}m ${String(seconds).padStart(2, "0")}s`;
+  return formatDurationModel(durationMs);
 }
 
 function formatServiceSummary(result) {
-  const passedSuites = result.completedSuiteCount - result.failedSuiteCount;
-  const notRun = result.suiteCount - result.completedSuiteCount;
-  let detail = `${passedSuites}/${result.suiteCount} suites passed`;
-  if (notRun > 0) {
-    detail += `, ${notRun} not run`;
-  }
-  return detail;
+  return formatServiceSummaryModel(result);
 }
 
 function formatError(error) {
-  if (error instanceof Error) return error.message;
-  return String(error);
+  return formatErrorModel(error);
 }
 
 function loadTimings(productDir) {
   const filePath = path.join(productDir, ".testkit", TIMINGS_FILENAME);
   if (!fs.existsSync(filePath)) {
-    return {
-      version: 1,
-      files: {},
-    };
+    return createEmptyTimings();
   }
 
   try {
-    const parsed = JSON.parse(fs.readFileSync(filePath, "utf8"));
-    return {
-      version: 1,
-      files: parsed.files && typeof parsed.files === "object" ? parsed.files : {},
-    };
+    return normalizeTimings(JSON.parse(fs.readFileSync(filePath, "utf8")));
   } catch {
-    return {
-      version: 1,
-      files: {},
-    };
+    return createEmptyTimings();
   }
 }
 
 function saveTimings(productDir, timings, updates) {
   if (updates.length === 0) return;
-
-  const next = {
-    version: 1,
-    files: { ...timings.files },
-  };
-
-  for (const update of updates) {
-    const existing = next.files[update.key];
-    if (!existing) {
-      next.files[update.key] = {
-        durationMs: Math.max(1, Math.round(update.durationMs)),
-        runs: 1,
-        updatedAt: new Date().toISOString(),
-      };
-      continue;
-    }
-
-    const runs = Number(existing.runs || 0) + 1;
-    const durationMs = Math.max(
-      1,
-      Math.round(((existing.durationMs || update.durationMs) * (runs - 1) + update.durationMs) / runs)
-    );
-    next.files[update.key] = {
-      durationMs,
-      runs,
-      updatedAt: new Date().toISOString(),
-    };
-  }
+  const next = applyTimingUpdates(timings, updates);
 
   const rootDir = path.join(productDir, ".testkit");
   fs.mkdirSync(rootDir, { recursive: true });
@@ -1341,140 +970,51 @@ function saveTimings(productDir, timings, updates) {
 }
 
 function estimateTaskDuration(timings, timingKey, suite) {
-  const cached = timings.files[timingKey];
-  if (cached?.durationMs) return cached.durationMs;
-
-  const base =
-    suite.framework === "playwright"
-      ? 20_000
-      : suite.type === "dal"
-        ? 4_000
-        : 8_000;
-  return Math.max(1_000, Math.round((base * suite.weight) / Math.max(1, suite.files.length)));
+  return estimateTaskDurationModel(timings, timingKey, suite);
 }
 
 function buildTimingKey(serviceName, suite, file) {
-  return [
-    serviceName,
-    suite.framework,
-    suite.type,
-    normalizePathSeparators(file),
-  ].join("|");
+  return buildTimingKeyModel(serviceName, suite, file);
 }
 
 function parsePlaywrightJsonResults(stdout, cwd) {
-  if (!stdout.trim()) {
-    return { fileResults: new Map(), errors: [] };
-  }
-
-  let parsed;
-  try {
-    parsed = JSON.parse(stdout);
-  } catch (error) {
-    return {
-      fileResults: new Map(),
-      errors: [`Could not parse Playwright JSON output: ${formatError(error)}`],
-    };
-  }
-
-  const fileResults = new Map();
-  visitPlaywrightSuites(parsed.suites || [], null, fileResults, cwd);
-  return {
-    fileResults,
-    errors: (parsed.errors || []).map(formatPlaywrightReporterError).filter(Boolean),
-  };
+  return parsePlaywrightJsonResultsModel(stdout, cwd);
 }
 
 function visitPlaywrightSuites(suites, inheritedFile, fileResults, cwd) {
-  for (const suite of suites || []) {
-    const suiteFile = normalizeReportedFile(extractReporterFile(suite) || inheritedFile, cwd);
-    for (const child of suite.suites || []) {
-      visitPlaywrightSuites([child], suiteFile, fileResults, cwd);
-    }
-    for (const spec of suite.specs || []) {
-      collectPlaywrightSpec(spec, suiteFile, fileResults, cwd);
-    }
-  }
+  return visitPlaywrightSuitesModel(suites, inheritedFile, fileResults, cwd);
 }
 
 function collectPlaywrightSpec(spec, inheritedFile, fileResults, cwd) {
-  const file = normalizeReportedFile(extractReporterFile(spec) || inheritedFile, cwd);
-  if (!file) return;
-
-  const current = fileResults.get(file) || {
-    failed: false,
-    error: null,
-    durationMs: 0,
-  };
-
-  for (const test of spec.tests || []) {
-    const results = Array.isArray(test.results) ? test.results : [];
-    current.durationMs += results.reduce(
-      (sum, result) => sum + Number(result?.duration || 0),
-      0
-    );
-
-    const final = choosePlaywrightFinalResult(results);
-    const failed =
-      test.outcome === "unexpected" ||
-      !isPlaywrightPassingStatus(final?.status);
-
-    if (failed) {
-      current.failed = true;
-      current.error ||= extractPlaywrightFailure(final, spec, test);
-    }
-  }
-
-  fileResults.set(file, current);
+  return collectPlaywrightSpecModel(spec, inheritedFile, fileResults, cwd);
 }
 
 function choosePlaywrightFinalResult(results) {
-  if (!results || results.length === 0) return null;
-  return results[results.length - 1];
+  return choosePlaywrightFinalResultModel(results);
 }
 
 function isPlaywrightPassingStatus(status) {
-  return !status || ["passed", "skipped", "expected"].includes(status);
+  return isPlaywrightPassingStatusModel(status);
 }
 
 function extractPlaywrightFailure(finalResult, spec, test) {
-  const fromResult =
-    finalResult?.error?.message ||
-    finalResult?.error?.value ||
-    finalResult?.error?.stack;
-  if (fromResult) return firstLine(fromResult);
-
-  const fromTest = test?.errors?.[0]?.message;
-  if (fromTest) return firstLine(fromTest);
-
-  return firstLine(spec?.title || "Playwright test failed");
+  return extractPlaywrightFailureModel(finalResult, spec, test);
 }
 
 function formatPlaywrightReporterError(error) {
-  if (!error) return null;
-  if (typeof error === "string") return firstLine(error);
-  if (typeof error.message === "string") return firstLine(error.message);
-  if (typeof error.value === "string") return firstLine(error.value);
-  return null;
+  return formatPlaywrightReporterErrorModel(error);
 }
 
 function extractReporterFile(node) {
-  if (!node || typeof node !== "object") return null;
-  if (typeof node.file === "string" && node.file.length > 0) return node.file;
-  if (node.location && typeof node.location.file === "string" && node.location.file.length > 0) {
-    return node.location.file;
-  }
-  return null;
+  return extractReporterFileModel(node);
 }
 
 function normalizeReportedFile(filePath, cwd) {
-  if (!filePath) return null;
-  const absolute = path.isAbsolute(filePath) ? filePath : path.join(cwd, filePath);
-  return normalizePathSeparators(path.relative(cwd, absolute));
+  return normalizeReportedFileModel(filePath, cwd);
 }
 
 function firstLine(value) {
-  return String(value).split(/\r?\n/).find((line) => line.trim().length > 0)?.trim() || null;
+  return firstLineModel(value);
 }
 
 function printBufferedOutput(output, prefix) {
@@ -1486,95 +1026,23 @@ function printBufferedOutput(output, prefix) {
 }
 
 function resolveRuntimeUrl(rawUrl, serviceName, targetConfig, workerId, context) {
-  const resolved = resolveTemplateString(rawUrl, {
-    ...context,
-    targetName: targetConfig.name,
-    workerId,
-    serviceName,
-  });
-  const actualPort = context.portMap.get(serviceName);
-  return actualPort ? rewriteUrlPort(resolved, actualPort) : resolved;
+  return resolveRuntimeUrlModel(rawUrl, serviceName, targetConfig, workerId, context);
 }
 
 function finalizeString(value, context) {
-  let resolved = resolveTemplateString(value, context);
-  for (const [source, destination] of context.urlMappings || []) {
-    if (source && destination && source !== destination) {
-      resolved = resolved.split(source).join(destination);
-    }
-  }
-  return resolved;
+  return finalizeStringModel(value, context);
 }
 
 function resolveTemplateString(value, context) {
-  if (typeof value !== "string") return value;
-
-  return value.replace(/\{([a-zA-Z]+)(?::([a-zA-Z0-9_-]+))?\}/g, (_match, token, arg) => {
-    switch (token) {
-      case "worker":
-        return String(context.workerId);
-      case "target":
-        return context.targetName;
-      case "service":
-        return context.serviceName;
-      case "stateDir":
-        return context.serviceStateDir;
-      case "port": {
-        const serviceName = arg || context.serviceName;
-        const port = context.portMap.get(serviceName);
-        if (!port) {
-          throw new Error(`Unknown port placeholder for service "${serviceName}"`);
-        }
-        return String(port);
-      }
-      case "baseUrl": {
-        const serviceName = arg || context.serviceName;
-        const baseUrl = context.baseUrlByService.get(serviceName);
-        if (!baseUrl) {
-          throw new Error(`Unknown baseUrl placeholder for service "${serviceName}"`);
-        }
-        return baseUrl;
-      }
-      case "readyUrl": {
-        const serviceName = arg || context.serviceName;
-        const readyUrl = context.readyUrlByService.get(serviceName);
-        if (!readyUrl) {
-          throw new Error(`Unknown readyUrl placeholder for service "${serviceName}"`);
-        }
-        return readyUrl;
-      }
-      default:
-        throw new Error(`Unsupported template token "{${token}${arg ? `:${arg}` : ""}}"`);
-    }
-  });
+  return resolveTemplateStringModel(value, context);
 }
 
 function rewriteUrlPort(rawUrl, port) {
-  try {
-    const original = new URL(rawUrl);
-    if (!original.port) return rawUrl;
-
-    const rewritten = new URL(rawUrl);
-    rewritten.port = String(port);
-
-    let next = rewritten.toString();
-    if (!rawUrl.endsWith("/") && original.pathname === "/" && next.endsWith("/")) {
-      next = next.slice(0, -1);
-    }
-    return next;
-  } catch {
-    return rawUrl;
-  }
+  return rewriteUrlPortModel(rawUrl, port);
 }
 
 function numericPortFromUrl(rawUrl) {
-  try {
-    const url = new URL(rawUrl);
-    const port = Number(url.port);
-    return Number.isInteger(port) && port > 0 ? port : null;
-  } catch {
-    return null;
-  }
+  return numericPortFromUrlModel(rawUrl);
 }
 
 async function assertLocalServicePortsAvailable(config) {
@@ -1599,22 +1067,11 @@ async function assertLocalServicePortsAvailable(config) {
 }
 
 function socketFromUrl(rawUrl) {
-  try {
-    const url = new URL(rawUrl);
-    const port = Number(url.port);
-    if (!Number.isInteger(port) || port <= 0) return null;
-
-    const host = normalizeSocketHost(url.hostname);
-    return host ? { host, port } : null;
-  } catch {
-    return null;
-  }
+  return socketFromUrlModel(rawUrl);
 }
 
 function normalizeSocketHost(hostname) {
-  if (!hostname || hostname === "localhost") return "127.0.0.1";
-  if (hostname === "[::1]") return "::1";
-  return hostname;
+  return normalizeSocketHostModel(hostname);
 }
 
 async function isPortInUse({ host, port }) {
@@ -1728,82 +1185,31 @@ function sleep(ms) {
 }
 
 function findRuntimeStateDirs(rootDir) {
-  const found = [];
-
-  const visit = (dir) => {
-    if (!fs.existsSync(dir)) return;
-    const entries = fs.readdirSync(dir, { withFileTypes: true });
-    if (isDatabaseStateDir(dir)) {
-      found.push(dir);
-    }
-
-    for (const entry of entries) {
-      if (entry.isDirectory()) {
-        visit(path.join(dir, entry.name));
-      }
-    }
-  };
-
-  visit(rootDir);
-  return found.sort((a, b) => b.length - a.length);
+  return findRuntimeStateDirsModel(rootDir, isDatabaseStateDir);
 }
 
 function findGraphDirsForService(productDir, serviceName) {
-  const graphsRoot = path.join(productDir, ".testkit", "_graphs");
-  if (!fs.existsSync(graphsRoot)) return [];
-
-  const matches = [];
-  for (const entry of fs.readdirSync(graphsRoot, { withFileTypes: true })) {
-    if (!entry.isDirectory()) continue;
-    const graphDir = path.join(graphsRoot, entry.name);
-    const metadata = readGraphMetadata(graphDir);
-    if (!metadata) continue;
-    if ((metadata.runtimeServices || []).includes(serviceName)) {
-      matches.push(graphDir);
-    }
-  }
-
-  return matches.sort();
+  return findGraphDirsForServiceModel(productDir, serviceName);
 }
 
 function writeGraphMetadata(graphDir, graph) {
-  fs.mkdirSync(graphDir, { recursive: true });
-  const metadata = {
-    runtimeServices: graph.runtimeNames,
-    assignedTargets: [...graph.assignedTargets].sort(),
-    rootService: graph.rootConfig.name,
-  };
-  fs.writeFileSync(
-    path.join(graphDir, GRAPH_METADATA),
-    JSON.stringify(metadata, null, 2)
-  );
+  return writeGraphMetadataModel(graphDir, graph);
 }
 
 function readGraphMetadata(graphDir) {
-  const metadataPath = path.join(graphDir, GRAPH_METADATA);
-  if (!fs.existsSync(metadataPath)) return null;
-
-  try {
-    return JSON.parse(fs.readFileSync(metadataPath, "utf8"));
-  } catch {
-    return null;
-  }
+  return readGraphMetadataModel(graphDir);
 }
 
 function isRuntimeSuperset(candidate, target) {
-  return target.every((name) => candidate.includes(name));
+  return isRuntimeSupersetModel(candidate, target);
 }
 
 function compareGraphsForAssignment(left, right) {
-  if (left.runtimeNames.length !== right.runtimeNames.length) {
-    return left.runtimeNames.length - right.runtimeNames.length;
-  }
-  return left.key.localeCompare(right.key);
+  return compareGraphsForAssignmentModel(left, right);
 }
 
 function buildGraphDirName(runtimeNames) {
-  const slug = runtimeNames.map(slugSegment).join("__");
-  return slug.length > 0 ? slug : "graph";
+  return buildGraphDirNameModel(runtimeNames);
 }
 
 function slugSegment(value) {
@@ -1811,5 +1217,5 @@ function slugSegment(value) {
 }
 
 function normalizePathSeparators(filePath) {
-  return filePath.split(path.sep).join("/");
+  return normalizePathSeparatorsModel(filePath);
 }