@elench/testkit 0.1.86 → 0.1.88

package/lib/cli/tui/inspect-model.mjs

@@ -0,0 +1,817 @@
+import { fileDisplayName } from "../../discovery/index.mjs";
+import { suiteSelectionType } from "../../runner/suite-selection.mjs";
+import { formatDuration } from "../../runner/formatting.mjs";
+import { matchInspectEntry } from "./fuzzy-match.mjs";
+
+export const INSPECT_PANES = ["detail", "artifacts", "logs", "setup"];
+
+export function buildSummaryRows({
+  result,
+  passed,
+  failed,
+  skipped,
+  notRun,
+  files,
+  duration,
+  serviceErrors = 0,
+  regressionSummary = null,
+}) {
+  const rows = [
+    ["Result", result],
+    ["Passed", String(passed)],
+    ["Failed", String(failed)],
+    ["Skipped", String(skipped)],
+    ["Not run", String(notRun)],
+    ["Files", String(files)],
+    ["Duration", duration],
+  ];
+  if (serviceErrors > 0) rows.push(["Runtime errors", String(serviceErrors)]);
+  if ((regressionSummary?.newRegressions || 0) > 0) {
+    rows.push(["New regressions", String(regressionSummary.newRegressions)]);
+  }
+  if ((regressionSummary?.knownRegressions || 0) > 0) {
+    rows.push(["Known regressions", String(regressionSummary.knownRegressions)]);
+  }
+  if ((regressionSummary?.fixedKnownRegressions || 0) > 0) {
+    rows.push(["Fixed known", String(regressionSummary.fixedKnownRegressions)]);
+  }
+  if ((regressionSummary?.catalogStale || 0) > 0) {
+    rows.push(["Catalog stale", String(regressionSummary.catalogStale)]);
+  }
+  return rows;
+}
+
+export function createEmptyInspectModel(dataSource = "live") {
+  return {
+    dataSource,
+    services: new Map(),
+    summaryData: null,
+    regressionCatalog: null,
+    runArtifact: null,
+    finished: dataSource === "artifact",
+    totalCount: 0,
+    completedCount: 0,
+    phase: null,
+    filterActive: false,
+    filterQuery: "",
+    filterMatches: new Map(),
+    collapsedOverrides: new Map(),
+    selectedEntryId: null,
+    paneMode: "detail",
+  };
+}
+
+export function resetInspectModel(model, dataSource = model.dataSource) {
+  model.dataSource = dataSource;
+  model.services = new Map();
+  model.summaryData = null;
+  model.regressionCatalog = null;
+  model.runArtifact = null;
+  model.finished = dataSource === "artifact";
+  model.totalCount = 0;
+  model.completedCount = 0;
+  model.phase = null;
+  model.filterActive = false;
+  model.filterQuery = "";
+  model.filterMatches = new Map();
+  model.collapsedOverrides = new Map();
+  model.selectedEntryId = null;
+  model.paneMode = "detail";
+}
+
+export function initModelFromPlans(model, servicePlans) {
+  for (const plan of servicePlans) {
+    const service = getOrCreateService(model, plan.config.name);
+    if (plan.skipped) {
+      service.skipped = true;
+      continue;
+    }
+    for (const suite of plan.suites || []) {
+      const displayType = suite.displayType || suiteSelectionType(suite.type, suite.framework);
+      const typeNode = getOrCreateType(service, displayType);
+      const suiteKey = buildSuiteKey(displayType, suite.name);
+      const suiteNode = getOrCreateSuite(typeNode, suiteKey, {
+        name: suite.name,
+        groupLabel: fileDisplayName(suite.name),
+        framework: suite.framework,
+      });
+      for (const filePath of suite.files || []) {
+        if (suiteNode.files.has(filePath)) continue;
+        suiteNode.files.set(filePath, {
+          id: buildFileId(service.name, filePath),
+          kind: "file",
+          serviceName: service.name,
+          type: displayType,
+          suiteKey,
+          suiteName: suite.name,
+          framework: suite.framework,
+          path: filePath,
+          displayName: fileDisplayName(filePath),
+          status: "pending",
+          durationMs: null,
+          error: null,
+          failureDetails: [],
+          diagnosis: null,
+          skipReason: null,
+          artifacts: [],
+        });
+      }
+    }
+  }
+  if (!model.selectedEntryId) {
+    model.selectedEntryId = findFirstNavigableEntryId(model);
+  }
+}
+
+export function applyArtifactToModel(model, artifact) {
+  resetInspectModel(model, artifact?.run?.status === "running" ? "live" : "artifact");
+  model.runArtifact = artifact;
+  model.finished = artifact?.run?.status !== "running";
+  model.phase = model.finished ? "run complete" : "live artifact";
+  const fileSummary = artifact?.summary?.files || {};
+  model.totalCount = fileSummary.total || 0;
+  model.completedCount = (fileSummary.passed || 0) + (fileSummary.failed || 0) + (fileSummary.skipped || 0) + (fileSummary.notRun || 0);
+  model.summaryData = {
+    rows: buildSummaryRows({
+      result: String(artifact?.run?.status || "passed").toUpperCase(),
+      passed: fileSummary.passed || 0,
+      failed: fileSummary.failed || 0,
+      skipped: fileSummary.skipped || 0,
+      notRun: fileSummary.notRun || 0,
+      files: fileSummary.total || 0,
+      duration: formatDuration(artifact?.run?.durationMs || 0),
+      serviceErrors: countArtifactServiceErrors(artifact),
+      regressionSummary: artifact?.regressions?.summary || null,
+    }),
+    result: String(artifact?.run?.status || "passed").toUpperCase(),
+  };
+
+  for (const serviceResult of artifact?.services || []) {
+    const service = getOrCreateService(model, serviceResult.name);
+    service.skipped = Boolean(serviceResult.skipped);
+    service.durationMs = serviceResult.durationMs || 0;
+    service.errors = Array.isArray(serviceResult.errors) ? serviceResult.errors : [];
+    for (const suiteResult of serviceResult.suites || []) {
+      const displayType = suiteResult.displayType || suiteResult.type || suiteSelectionType(suiteResult.type, suiteResult.framework);
+      const typeNode = getOrCreateType(service, displayType);
+      const suiteKey = buildSuiteKey(displayType, suiteResult.name);
+      const suiteNode = getOrCreateSuite(typeNode, suiteKey, {
+        name: suiteResult.name,
+        groupLabel: fileDisplayName(suiteResult.name),
+        framework: suiteResult.framework,
+      });
+      for (const fileResult of suiteResult.files || []) {
+        suiteNode.files.set(fileResult.path, {
+          id: buildFileId(service.name, fileResult.path),
+          kind: "file",
+          serviceName: service.name,
+          type: displayType,
+          suiteKey,
+          suiteName: suiteResult.name,
+          framework: suiteResult.framework,
+          path: fileResult.path,
+          displayName: fileDisplayName(fileResult.path),
+          status: fileResult.status,
+          durationMs: fileResult.durationMs || null,
+          error: fileResult.error || null,
+          failureDetails: Array.isArray(fileResult.failureDetails) ? fileResult.failureDetails : [],
+          diagnosis: fileResult.diagnosis || null,
+          skipReason: fileResult.reason || null,
+          artifacts: Array.isArray(fileResult.artifacts) ? fileResult.artifacts : [],
+        });
+      }
+    }
+  }
+
+  model.selectedEntryId = findFirstFailureEntryId(model) || findFirstNavigableEntryId(model);
+}
+
+export function markFileRunning(model, serviceName, suiteKey, filePath) {
+  const file = findFile(model, serviceName, suiteKey, filePath) || findFileByServiceAndPath(model, serviceName, filePath);
+  if (!file) return;
+  file.status = "running";
+}
+
+export function markFileFinished(model, task, outcome) {
+  const suiteKey = buildSuiteKey(task.displayType || suiteSelectionType(task.type, task.framework), task.suiteName);
+  const file = findFile(model, task.serviceName, suiteKey, task.file) || findFileByServiceAndPath(model, task.serviceName, task.file);
+  if (!file) return;
+  const selectedEntry = model.selectedEntryId ? getEntryById(model, model.selectedEntryId) : null;
+  if (outcome.status === "skipped") {
+    file.status = "skipped";
+    file.skipReason = outcome.reason || null;
+  } else if (outcome.status === "not_run") {
+    file.status = "not_run";
+    file.skipReason = outcome.reason || null;
+  } else if (outcome.failed) {
+    file.status = "failed";
+    file.error = outcome.error || null;
+    file.failureDetails = Array.isArray(outcome.failureDetails) ? outcome.failureDetails : [];
+    file.diagnosis = outcome.diagnosis || file.diagnosis || null;
+    file.artifacts = Array.isArray(outcome.artifacts) ? outcome.artifacts : file.artifacts;
+  } else {
+    file.status = "passed";
+    file.error = null;
+    file.failureDetails = [];
+  }
+  file.durationMs = outcome.durationMs || null;
+  model.completedCount += 1;
+  if (file.status === "failed" && (!selectedEntry || selectedEntry.kind !== "file" || selectedEntry.status !== "failed")) {
+    model.selectedEntryId = file.id;
+  }
+}
+
+export function markServiceSkipped(model, serviceName, reason) {
+  const service = getOrCreateService(model, serviceName);
+  service.skipped = true;
+  service.skipReason = reason || null;
+}
+
+export function markPlannedSkip(model, entry) {
+  const file = findFileByServiceAndPath(model, entry.serviceName, entry.file);
+  if (!file) return;
+  file.status = "skipped";
+  file.skipReason = entry.reason || null;
+  model.completedCount += 1;
+}
+
+export function markRuntimeError(model, task, message) {
+  const file = findFileByServiceAndPath(model, task.serviceName, task.file);
+  if (!file) return;
+  const selectedEntry = model.selectedEntryId ? getEntryById(model, model.selectedEntryId) : null;
+  file.status = "failed";
+  file.error = message || "runtime error";
+  model.completedCount += 1;
+  if (!selectedEntry || selectedEntry.kind !== "file" || selectedEntry.status !== "failed") {
+    model.selectedEntryId = file.id;
+  }
+}
+
+export function setTotalFileCount(model, count) {
+  model.totalCount = count;
+}
+
+export function setPhase(model, label) {
+  model.phase = label;
+}
+
+export function setRegressionCatalog(model, document) {
+  model.regressionCatalog = document;
+}
+
+export function finishModel(model, results, durationMs, regressionReport) {
+  model.finished = true;
+  model.phase = "run complete";
+  const totals = summarizeModelFiles(model);
+  model.summaryData = {
+    rows: buildSummaryRows({
+      result: totals.failed > 0 ? "FAILED" : "PASSED",
+      passed: totals.passed,
+      failed: totals.failed,
+      skipped: totals.skipped,
+      notRun: totals.notRun,
+      files: totals.total,
+      duration: formatDuration(durationMs),
+      serviceErrors: countServiceErrors(results),
+      regressionSummary: regressionReport?.summary || null,
+    }),
+    result: totals.failed > 0 ? "FAILED" : "PASSED",
+  };
+  model.selectedEntryId = findFirstFailureEntryId(model) || model.selectedEntryId || findFirstNavigableEntryId(model);
+}
+
+export function updateFilter(model, query) {
+  model.filterActive = true;
+  model.filterQuery = String(query || "");
+  model.filterMatches = new Map();
+  const normalizedQuery = model.filterQuery.trim();
+  if (!normalizedQuery) return;
+  for (const entry of collectAllEntries(model)) {
+    const match = matchInspectEntry(normalizedQuery, entry);
+    if (match.matched) {
+      model.filterMatches.set(entry.id, match);
+    }
+  }
+}
+
+export function cyclePane(model) {
+  const index = INSPECT_PANES.indexOf(model.paneMode);
+  model.paneMode = INSPECT_PANES[(index + 1) % INSPECT_PANES.length];
+}
+
+export function setPane(model, paneMode) {
+  if (INSPECT_PANES.includes(paneMode)) {
+    model.paneMode = paneMode;
+  }
+}
+
+export function toggleCollapsed(model, entryId) {
+  const entry = getEntryById(model, entryId);
+  if (!entry || (entry.kind !== "type" && entry.kind !== "suite")) return;
+  const current = isCollapsed(model, entry);
+  model.collapsedOverrides.set(entryId, !current);
+}
+
+export function revealEntry(model, entryId) {
+  const ancestors = getAncestorIds(model, entryId);
+  for (const ancestorId of ancestors) {
+    const ancestor = getEntryById(model, ancestorId);
+    if (ancestor && (ancestor.kind === "type" || ancestor.kind === "suite")) {
+      model.collapsedOverrides.set(ancestor.id, false);
+    }
+  }
+  model.selectedEntryId = entryId;
+}
+
+export function buildSnapshot(model) {
+  const nestedServices = buildNestedServices(model);
+  const visibleEntries = buildVisibleEntries(model, nestedServices);
+  const selectedEntry = visibleEntries.find((entry) => entry.id === model.selectedEntryId)
+    || visibleEntries[0]
+    || null;
+  const selectedEntryId = selectedEntry?.id || null;
+  const selectedFailure = toSelectedFailure(selectedEntry);
+  const filterResults = [...model.filterMatches.entries()]
+    .map(([id, match]) => ({ id, ...match }))
+    .sort((left, right) => right.score - left.score || left.id.localeCompare(right.id));
+
+  return {
+    dataSource: model.dataSource,
+    services: nestedServices,
+    visibleEntries,
+    selectedEntryId,
+    selectedEntry,
+    selectedFailureKey: selectedFailure ? `${selectedFailure.serviceName}::${selectedFailure.filePath}` : null,
+    selectedFailure,
+    failures: collectFailedEntries(model).map(toSelectedFailure),
+    completedCount: model.completedCount,
+    totalCount: model.totalCount,
+    phase: model.phase,
+    finished: model.finished,
+    summaryData: model.summaryData,
+    regressionCatalog: model.regressionCatalog,
+    paneMode: model.paneMode,
+    filter: {
+      active: model.filterActive,
+      query: model.filterQuery,
+      results: filterResults,
+      count: filterResults.length,
+    },
+    runArtifact: model.runArtifact,
+  };
+}
+
+function getOrCreateService(model, serviceName) {
+  if (!model.services.has(serviceName)) {
+    model.services.set(serviceName, {
+      id: buildServiceId(serviceName),
+      kind: "service",
+      name: serviceName,
+      skipped: false,
+      skipReason: null,
+      durationMs: 0,
+      errors: [],
+      types: new Map(),
+    });
+  }
+  return model.services.get(serviceName);
+}
+
+function getOrCreateType(service, displayType) {
+  if (!service.types.has(displayType)) {
+    service.types.set(displayType, {
+      id: buildTypeId(service.name, displayType),
+      kind: "type",
+      serviceName: service.name,
+      type: displayType,
+      suites: new Map(),
+    });
+  }
+  return service.types.get(displayType);
+}
+
+function getOrCreateSuite(typeNode, suiteKey, meta) {
+  if (!typeNode.suites.has(suiteKey)) {
+    typeNode.suites.set(suiteKey, {
+      id: buildSuiteId(typeNode.serviceName, suiteKey),
+      kind: "suite",
+      serviceName: typeNode.serviceName,
+      type: typeNode.type,
+      key: suiteKey,
+      name: meta.name,
+      groupLabel: meta.groupLabel,
+      framework: meta.framework,
+      files: new Map(),
+    });
+  }
+  return typeNode.suites.get(suiteKey);
+}
+
+function buildNestedServices(model) {
+  return [...model.services.values()].map((service) => {
+    const types = [...service.types.values()].map((typeNode) => {
+      const suites = [...typeNode.suites.values()].map((suite) => {
+        const files = [...suite.files.values()];
+        const summary = summarizeFiles(files);
+        const autoCollapsed = summary.total > 0 && (summary.passed === summary.total || summary.skipped === summary.total);
+        return {
+          id: suite.id,
+          kind: "suite",
+          serviceName: service.name,
+          type: typeNode.type,
+          key: suite.key,
+          name: suite.name,
+          groupLabel: suite.groupLabel,
+          framework: suite.framework,
+          files,
+          summary,
+          autoCollapsed,
+          collapsed: isCollapsed(model, { ...suite, autoCollapsed }),
+        };
+      });
+      const summary = summarizeNestedEntries(suites.map((suite) => suite.summary));
+      const autoCollapsed = suites.length > 0 && suites.every((suite) => suite.collapsed);
+      return {
+        id: typeNode.id,
+        kind: "type",
+        serviceName: service.name,
+        type: typeNode.type,
+        suites,
+        summary,
+        autoCollapsed,
+        collapsed: isCollapsed(model, { ...typeNode, autoCollapsed }),
+      };
+    });
+    const summary = summarizeNestedEntries(types.map((typeNode) => typeNode.summary));
+    return {
+      id: service.id,
+      kind: "service",
+      name: service.name,
+      serviceName: service.name,
+      skipped: service.skipped,
+      skipReason: service.skipReason,
+      durationMs: service.durationMs,
+      errors: service.errors,
+      types,
+      summary,
+    };
+  });
+}
+
+function buildVisibleEntries(model, services) {
+  const entries = [];
+  const filterActive = model.filterActive && model.filterQuery.trim().length > 0;
+  const includedIds = filterActive ? buildFilteredIdSet(model, services) : null;
+
+  for (const service of services) {
+    pushVisibleEntry(entries, model, service, 0, includedIds);
+    if (service.skipped) continue;
+    for (const typeNode of service.types) {
+      if (!pushVisibleEntry(entries, model, typeNode, 1, includedIds)) continue;
+      const typeExpanded = filterActive || !typeNode.collapsed;
+      if (!typeExpanded) continue;
+      for (const suite of typeNode.suites) {
+        if (!pushVisibleEntry(entries, model, suite, 2, includedIds)) continue;
+        const suiteExpanded = filterActive || !suite.collapsed;
+        if (!suiteExpanded) continue;
+        for (const file of suite.files) {
+          pushVisibleEntry(entries, model, file, 3, includedIds);
+        }
+      }
+    }
+  }
+
+  return entries;
+}
+
+function pushVisibleEntry(entries, model, entry, depth, includedIds) {
+  if (includedIds && !includedIds.has(entry.id)) return false;
+  const base = toPublicEntry(entry, depth);
+  const match = model.filterMatches.get(entry.id) || null;
+  entries.push({
+    ...base,
+    match,
+  });
+  return true;
+}
+
+function buildFilteredIdSet(model, services) {
+  const included = new Set();
+  const childrenById = new Map();
+  const parentsById = new Map();
+
+  for (const service of services) {
+    childrenById.set(service.id, service.types.map((entry) => entry.id));
+    for (const typeNode of service.types) {
+      parentsById.set(typeNode.id, service.id);
+      childrenById.set(typeNode.id, typeNode.suites.map((entry) => entry.id));
+      for (const suite of typeNode.suites) {
+        parentsById.set(suite.id, typeNode.id);
+        childrenById.set(suite.id, suite.files.map((entry) => entry.id));
+        for (const file of suite.files) {
+          parentsById.set(file.id, suite.id);
+          childrenById.set(file.id, []);
+        }
+      }
+    }
+  }
+
+  for (const entryId of model.filterMatches.keys()) {
+    included.add(entryId);
+    let current = parentsById.get(entryId) || null;
+    while (current) {
+      included.add(current);
+      current = parentsById.get(current) || null;
+    }
+    const entry = getEntryById(model, entryId);
+    if (entry && entry.kind !== "file") {
+      includeDescendants(entryId, childrenById, included);
+    }
+  }
+
+  return included;
+}
+
+function includeDescendants(entryId, childrenById, included) {
+  for (const childId of childrenById.get(entryId) || []) {
+    included.add(childId);
+    includeDescendants(childId, childrenById, included);
+  }
+}
+
+function toPublicEntry(entry, depth) {
+  if (entry.kind === "service") {
+    return {
+      id: entry.id,
+      kind: "service",
+      depth,
+      label: entry.name,
+      serviceName: entry.name,
+      skipped: entry.skipped,
+      skipReason: entry.skipReason,
+      status: entry.skipped ? "skipped" : summarizeStatus(entry.summary),
+      summary: entry.summary,
+    };
+  }
+  if (entry.kind === "type") {
+    return {
+      id: entry.id,
+      kind: "type",
+      depth,
+      label: entry.type,
+      serviceName: entry.serviceName,
+      type: entry.type,
+      status: summarizeStatus(entry.summary),
+      summary: entry.summary,
+      collapsed: entry.collapsed,
+    };
+  }
+  if (entry.kind === "suite") {
+    return {
+      id: entry.id,
+      kind: "suite",
+      depth,
+      label: entry.groupLabel,
+      serviceName: entry.serviceName,
+      type: entry.type,
+      suiteKey: entry.key,
+      suiteName: entry.name,
+      status: summarizeStatus(entry.summary),
+      summary: entry.summary,
+      collapsed: entry.collapsed,
+      framework: entry.framework,
+    };
+  }
+  return {
+    id: entry.id,
+    kind: "file",
+    depth,
+    label: entry.displayName,
+    displayName: entry.displayName,
+    serviceName: entry.serviceName,
+    type: entry.type,
+    suiteKey: entry.suiteKey,
+    suiteName: entry.suiteName,
+    framework: entry.framework,
+    filePath: entry.path,
+    status: entry.status,
+    durationMs: entry.durationMs,
+    error: entry.error,
+    failureDetails: entry.failureDetails,
+    diagnosis: entry.diagnosis,
+    skipReason: entry.skipReason,
+    artifacts: entry.artifacts,
+  };
+}
+
+export function getEntryById(model, entryId) {
+  for (const service of model.services.values()) {
+    if (service.id === entryId) return service;
+    for (const typeNode of service.types.values()) {
+      if (typeNode.id === entryId) return typeNode;
+      for (const suite of typeNode.suites.values()) {
+        if (suite.id === entryId) return suite;
+        for (const file of suite.files.values()) {
+          if (file.id === entryId) return file;
+        }
+      }
+    }
+  }
+  return null;
+}
+
+export function findEntryIdForFile(model, serviceName, filePath) {
+  const service = model.services.get(serviceName);
+  if (!service) return null;
+  for (const typeNode of service.types.values()) {
+    for (const suite of typeNode.suites.values()) {
+      const file = suite.files.get(filePath);
+      if (file) return file.id;
+    }
+  }
+  return null;
+}
+
+export function findEntryIdForService(model, serviceName) {
+  return model.services.get(serviceName)?.id || null;
+}
+
+function isCollapsed(model, entry) {
+  if (model.collapsedOverrides.has(entry.id)) {
+    return Boolean(model.collapsedOverrides.get(entry.id));
+  }
+  return Boolean(entry.autoCollapsed);
+}
+
+function summarizeFiles(files) {
+  return files.reduce(
+    (summary, file) => {
+      summary.total += 1;
+      summary.durationMs += file.durationMs || 0;
+      if (file.status === "passed") summary.passed += 1;
+      else if (file.status === "failed") summary.failed += 1;
+      else if (file.status === "skipped") summary.skipped += 1;
+      else if (file.status === "not_run") summary.notRun += 1;
+      else if (file.status === "running") summary.running += 1;
+      else summary.pending += 1;
+      return summary;
+    },
+    { total: 0, passed: 0, failed: 0, skipped: 0, notRun: 0, running: 0, pending: 0, durationMs: 0 }
+  );
+}
+
+function summarizeNestedEntries(summaries) {
+  return summaries.reduce(
+    (aggregate, summary) => {
+      aggregate.total += summary.total;
+      aggregate.passed += summary.passed;
+      aggregate.failed += summary.failed;
+      aggregate.skipped += summary.skipped;
+      aggregate.notRun += summary.notRun;
+      aggregate.running += summary.running;
+      aggregate.pending += summary.pending;
+      aggregate.durationMs += summary.durationMs;
+      return aggregate;
+    },
+    { total: 0, passed: 0, failed: 0, skipped: 0, notRun: 0, running: 0, pending: 0, durationMs: 0 }
+  );
+}
+
+function summarizeStatus(summary) {
+  if (!summary || summary.total === 0) return "pending";
+  if (summary.failed > 0) return "failed";
+  if (summary.running > 0) return "running";
+  if (summary.pending > 0) return "pending";
+  if (summary.notRun > 0) return "not_run";
+  if (summary.skipped === summary.total) return "skipped";
+  return "passed";
+}
+
+function collectAllEntries(model) {
+  const entries = [];
+  for (const service of buildNestedServices(model)) {
+    entries.push(toPublicEntry(service, 0));
+    for (const typeNode of service.types) {
+      entries.push(toPublicEntry(typeNode, 1));
+      for (const suite of typeNode.suites) {
+        entries.push(toPublicEntry(suite, 2));
+        for (const file of suite.files) {
+          entries.push(toPublicEntry(file, 3));
+        }
+      }
+    }
+  }
+  return entries;
+}
+
+function summarizeModelFiles(model) {
+  return collectAllEntries(model)
+    .filter((entry) => entry.kind === "file")
+    .reduce(
+      (summary, entry) => {
+        summary.total += 1;
+        if (entry.status === "passed") summary.passed += 1;
+        else if (entry.status === "failed") summary.failed += 1;
+        else if (entry.status === "skipped") summary.skipped += 1;
+        else if (entry.status === "not_run") summary.notRun += 1;
+        return summary;
+      },
+      { total: 0, passed: 0, failed: 0, skipped: 0, notRun: 0 }
+    );
+}
+
+function countServiceErrors(results) {
+  return (results || []).filter((result) => Array.isArray(result.errors) && result.errors.length > 0).length;
+}
+
+function countArtifactServiceErrors(artifact) {
+  return (artifact?.services || []).filter((service) => Array.isArray(service.errors) && service.errors.length > 0).length;
+}
+
+function findFile(model, serviceName, suiteKey, filePath) {
+  const service = model.services.get(serviceName);
+  if (!service) return null;
+  for (const typeNode of service.types.values()) {
+    const suite = typeNode.suites.get(suiteKey);
+    if (!suite) continue;
+    const file = suite.files.get(filePath);
+    if (file) return file;
+  }
+  return null;
+}
+
+function findFileByServiceAndPath(model, serviceName, filePath) {
+  const service = model.services.get(serviceName);
+  if (!service) return null;
+  for (const typeNode of service.types.values()) {
+    for (const suite of typeNode.suites.values()) {
+      const file = suite.files.get(filePath);
+      if (file) return file;
+    }
+  }
+  return null;
+}
+
+function findFirstFailureEntryId(model) {
+  const failed = collectFailedEntries(model)[0];
+  return failed?.id || null;
+}
+
+function collectFailedEntries(model) {
+  return collectAllEntries(model)
+    .filter((entry) => entry.kind === "file" && entry.status === "failed")
+    .sort((left, right) => left.serviceName.localeCompare(right.serviceName) || left.filePath.localeCompare(right.filePath));
+}
+
+function findFirstNavigableEntryId(model) {
+  return collectAllEntries(model)[0]?.id || null;
+}
+
+function toSelectedFailure(entry) {
+  if (!entry || entry.kind !== "file" || entry.status !== "failed") return null;
+  return {
+    key: `${entry.serviceName}::${entry.filePath}`,
+    serviceName: entry.serviceName,
+    suiteKey: entry.suiteKey,
+    suiteName: entry.suiteName,
+    displayType: entry.type,
+    framework: entry.framework,
+    filePath: entry.filePath,
+    displayName: entry.displayName,
+    error: entry.error,
+    failureDetails: entry.failureDetails,
+  };
+}
+
+function getAncestorIds(model, entryId) {
+  const entry = getEntryById(model, entryId);
+  if (!entry) return [];
+  if (entry.kind === "service") return [];
+  if (entry.kind === "type") return [buildServiceId(entry.serviceName)];
+  if (entry.kind === "suite") return [buildServiceId(entry.serviceName), buildTypeId(entry.serviceName, entry.type)];
+  return [
+    buildServiceId(entry.serviceName),
+    buildTypeId(entry.serviceName, entry.type),
+    buildSuiteId(entry.serviceName, entry.suiteKey),
+  ];
+}
+
+function buildSuiteKey(displayType, suiteName) {
+  return `${displayType}:${suiteName}`;
+}
+
+function buildServiceId(serviceName) {
+  return `service:${serviceName}`;
+}
+
+function buildTypeId(serviceName, displayType) {
+  return `type:${serviceName}:${displayType}`;
+}
+
+function buildSuiteId(serviceName, suiteKey) {
+  return `suite:${serviceName}:${suiteKey}`;
+}
+
+function buildFileId(serviceName, filePath) {
+  return `file:${serviceName}:${filePath}`;
+}