miravo 0.6.0 → 0.6.2

package/src/lib/shutdown.ts

@@ -1,621 +0,0 @@
-import type { Engine, EngineMetricsSnapshot } from "@miravo/core";
-import type { AdapterHealthSnapshot } from "@miravo/shared";
-import type { TreeItem } from "consola/utils";
-import { box, colors, formatTree, stripAnsi } from "consola/utils";
-import {
-  adapterLogger,
-  engineLog,
-  isJsonLogFormat,
-  isPlain,
-  isQuiet,
-  writeOutput,
-} from "../logger.ts";
-import { computeAverageThroughput, formatCount, formatDuration, sep } from "../output.ts";
-
-const SHUTDOWN_TASK_TIMEOUT_MS = 6_000;
-const FINAL_OUTPUT_GRACE_MS = 50;
-const FORWARDED_SIGINT_COALESCE_WINDOW_MS = 100;
-
-type ShutdownTaskStage = "cleanup" | "finalize";
-type ShutdownPhase = "booting" | "running" | "shutting_down" | "forced_exit" | "exited";
-type ShutdownRequestSource = "api" | "sigint" | "sigterm";
-
-interface ShutdownTask {
-  readonly name: string;
-  readonly run: () => void | Promise<void>;
-}
-
-/** Parameters for the shutdown controller. Supports dependency injection for tests. */
-interface ShutdownControllerOptions {
-  /** The RNG seed used for this run (printed in summary for reproducibility). */
-  readonly seed: number;
-  /** Whether the seed was explicitly configured (vs. randomly generated). */
-  readonly seedExplicit: boolean;
-  /** Optional aggregated engine-error counts by context. */
-  readonly errorContextCounts?: ReadonlyMap<string, number>;
-  /** Process exit function. Defaults to process.exit. Inject for testing. */
-  readonly exit?: (code: number) => void;
-  /** Optional writer override for the final shutdown summary render. */
-  readonly writeFinalOutput?: (text: string) => Promise<void>;
-  /** Per-task timeout in ms. Defaults to SHUTDOWN_TASK_TIMEOUT_MS. Inject a small value in tests. */
-  readonly taskTimeoutMs?: number;
-  /** Duplicate SIGINT coalescing window in ms. Inject a small value in tests. */
-  readonly sigintCoalesceWindowMs?: number;
-}
-
-interface ShutdownController {
-  readonly completion: Promise<void>;
-  addTask(stage: ShutdownTaskStage, name: string, run: () => void | Promise<void>): void;
-  isShuttingDown(): boolean;
-  markRunning(): void;
-  requestShutdown(reason: string): void;
-  runShutdown(): Promise<void>;
-  setEngine(engine: Engine): void;
-  setErrorContextCounts(counts: ReadonlyMap<string, number>): void;
-  teardown(): void;
-  waitForShutdownRequest(): Promise<string>;
-}
-
-/**
- * Create a single-owner shutdown controller for `miravo start`.
- *
- * Signals are installed immediately. The controller owns the full shutdown
- * lifecycle: pre-stop cleanup, engine stop, post-stop cleanup, final summary,
- * and process exit. Callers should await `completion` to keep the command alive
- * until shutdown fully finishes.
- */
-export function createShutdownController(options: ShutdownControllerOptions): ShutdownController {
-  const exit = options.exit ?? ((code: number) => process.exit(code));
-  const writeFinalOutput = options.writeFinalOutput ?? writeShutdownOutput;
-  const taskTimeoutMs = options.taskTimeoutMs ?? SHUTDOWN_TASK_TIMEOUT_MS;
-  const sigintCoalesceWindowMs =
-    options.sigintCoalesceWindowMs ?? FORWARDED_SIGINT_COALESCE_WINDOW_MS;
-
-  let phase: ShutdownPhase = "booting";
-  let forcedExitRequested = false;
-  let engine: Engine | null = null;
-  let errorContextCounts = options.errorContextCounts;
-  let requestedReason: string | null = null;
-  let requestSource: ShutdownRequestSource | null = null;
-  let shutdownPromise: Promise<void> | null = null;
-  let requestedAtMs = 0;
-  let forwardedSigintIgnored = false;
-
-  const tasks: Record<ShutdownTaskStage, ShutdownTask[]> = {
-    cleanup: [],
-    finalize: [],
-  };
-
-  let resolveCompletion = () => {};
-  const completion = new Promise<void>((resolve) => {
-    resolveCompletion = resolve;
-  });
-  let resolveRequest = (_reason: string) => {};
-  const request = new Promise<string>((resolve) => {
-    resolveRequest = resolve;
-  });
-
-  const keepAlive = setInterval(() => {}, 60_000);
-  const shouldIgnoreForwardedSigint = (): boolean => {
-    if (requestSource !== "sigint" || forwardedSigintIgnored) {
-      return false;
-    }
-    const elapsedMs = performance.now() - requestedAtMs;
-    if (elapsedMs > sigintCoalesceWindowMs) {
-      return false;
-    }
-    forwardedSigintIgnored = true;
-    engineLog.debug(`Ignoring duplicate SIGINT ${elapsedMs.toFixed(1)}ms after shutdown request.`);
-    return true;
-  };
-
-  const forceSignalHandler = (): void => {
-    if (shouldIgnoreForwardedSigint()) {
-      return;
-    }
-    forceExit();
-  };
-  // Absorbs SIGTERM during graceful shutdown without terminating.
-  // bun run / bunx forwards SIGTERM to the child process when the parent
-  // runner receives SIGINT and exits — leaving SIGTERM unhandled would restore
-  // the OS default (abrupt termination). This no-op keeps the process alive
-  // long enough for cleanup tasks and engine.stop() to complete.
-  const absorbSigterm = (): void => {};
-
-  const forceExit = (): void => {
-    if (phase === "forced_exit" || phase === "exited") return;
-    forcedExitRequested = true;
-    phase = "forced_exit";
-    clearInterval(keepAlive);
-    engineLog.warn("Force stopping. Goodbye.");
-    resolveCompletion();
-    exit(1);
-  };
-
-  const runWithTimeout = async (name: string, run: () => void | Promise<void>): Promise<void> => {
-    let timer: ReturnType<typeof setTimeout> | null = null;
-    // Declared outside try so finally can suppress late rejections on timeout.
-    // Remains null if run() throws synchronously — no dangling promise in that case.
-    let runPromise: Promise<void> | null = null;
-    try {
-      runPromise = Promise.resolve(run()); // sync throws are caught by this try block
-      await Promise.race([
-        runPromise,
-        new Promise<void>((resolve) => {
-          timer = setTimeout(() => {
-            engineLog.warn(`${name} timed out after ${taskTimeoutMs / 1000}s.`);
-            resolve();
-          }, taskTimeoutMs);
-        }),
-      ]);
-    } catch (error) {
-      engineLog.error(`Error during ${name}:`, error);
-    } finally {
-      if (timer !== null) {
-        clearTimeout(timer);
-      }
-      // If the timeout fired first, runPromise is still pending. Attach a no-op
-      // catch so a future rejection from the dangling task does not become an
-      // unhandled-rejection crash.
-      runPromise?.catch(() => {});
-    }
-  };
-
-  const runStage = async (stage: ShutdownTaskStage): Promise<void> => {
-    const stageTasks = tasks[stage];
-    let index = 0;
-    while (index < stageTasks.length) {
-      const task = stageTasks[index];
-      if (task !== undefined) {
-        await runWithTimeout(task.name, task.run);
-      }
-      index++;
-    }
-  };
-
-  const shutdown = async (reason: string): Promise<void> => {
-    if (phase === "forced_exit" || phase === "exited") return;
-    phase = "shutting_down";
-    engineLog.info("Stopping simulation...");
-
-    const finalMetrics = engine?.getMetrics() ?? null;
-
-    await runStage("cleanup");
-
-    const engineToStop = engine;
-    if (engineToStop) {
-      await runWithTimeout("engine stop", () => engineToStop.stop(reason));
-    }
-
-    if (!forcedExitRequested && finalMetrics !== null) {
-      await printShutdownSummary(
-        finalMetrics,
-        options.seed,
-        options.seedExplicit,
-        errorContextCounts,
-        writeFinalOutput,
-      ).catch((error) => {
-        engineLog.error("Error rendering shutdown summary:", error);
-      });
-    }
-
-    await runStage("finalize");
-
-    const forced = forcedExitRequested;
-    clearInterval(keepAlive);
-    phase = "exited";
-    resolveCompletion();
-
-    if (!forced) {
-      exit(0);
-    }
-  };
-
-  const armForceExitHandlers = (): void => {
-    process.removeListener("SIGINT", sigintHandler);
-    process.removeListener("SIGTERM", sigtermHandler);
-    // Use process.on (not once): under `bun run <script>` a single Ctrl+C sends
-    // SIGINT to the entire foreground process group, then Bun forwards the same
-    // SIGINT to its child process as well. The first duplicate is coalesced
-    // inside forceSignalHandler(); later SIGINTs still force-exit.
-    process.on("SIGINT", forceSignalHandler);
-    // SIGTERM is absorbed (no-op) rather than re-armed as a force handler.
-    // bun run / bunx forwards SIGTERM to the child process when the parent
-    // runner exits from its own SIGINT — leaving SIGTERM unhandled would
-    // restore the OS default (abrupt kill), so we absorb it instead and let
-    // cleanup tasks finish. A second Ctrl+C (SIGINT) still force-stops.
-    // Use process.on (not once): after the first SIGTERM is absorbed the listener
-    // must remain registered. If it were once, a second OS-level SIGTERM would
-    // find no handler and revert to the OS default (abrupt termination).
-    // teardown() removes it when shutdown completes.
-    process.on("SIGTERM", absorbSigterm);
-  };
-
-  const requestShutdownInternal = (reason: string, source: ShutdownRequestSource): void => {
-    if (phase === "forced_exit" || phase === "exited") return;
-    if (requestedReason !== null) {
-      // Only force-exit if shutdown is actively running. A duplicate request
-      // that arrives before runShutdown() starts (e.g. admin /shutdown racing
-      // with SIGINT) is silently deduplicated — first caller wins.
-      if (phase === "shutting_down") {
-        forceExit();
-      }
-      return;
-    }
-    requestedReason = reason;
-    requestSource = source;
-    requestedAtMs = performance.now();
-    forwardedSigintIgnored = false;
-    resolveRequest(reason);
-    armForceExitHandlers();
-  };
-
-  const requestShutdown = (reason: string): void => {
-    requestShutdownInternal(reason, "api");
-  };
-
-  const sigintHandler = (): void => {
-    requestShutdownInternal("user interrupt", "sigint");
-  };
-
-  const sigtermHandler = (): void => {
-    requestShutdownInternal("SIGTERM", "sigterm");
-  };
-
-  process.once("SIGINT", sigintHandler);
-  process.once("SIGTERM", sigtermHandler);
-
-  return {
-    completion,
-    addTask(stage, name, run) {
-      tasks[stage].push({ name, run });
-    },
-    isShuttingDown() {
-      return requestedReason !== null || phase === "shutting_down" || phase === "forced_exit";
-    },
-    markRunning() {
-      if (phase === "booting") {
-        phase = "running";
-      }
-    },
-    requestShutdown,
-    runShutdown() {
-      if (shutdownPromise) {
-        return shutdownPromise;
-      }
-      if (requestedReason === null) {
-        throw new Error("Shutdown was not requested before runShutdown().");
-      }
-      shutdownPromise = shutdown(requestedReason);
-      return shutdownPromise;
-    },
-    setEngine(nextEngine) {
-      engine = nextEngine;
-    },
-    setErrorContextCounts(counts) {
-      errorContextCounts = counts;
-    },
-    teardown() {
-      process.removeListener("SIGINT", sigintHandler);
-      process.removeListener("SIGTERM", sigtermHandler);
-      process.removeListener("SIGINT", forceSignalHandler);
-      process.removeListener("SIGTERM", absorbSigterm);
-      clearInterval(keepAlive);
-    },
-    waitForShutdownRequest() {
-      return request;
-    },
-  };
-}
-
-// ---------------------------------------------------------------------------
-// Shared helpers
-// ---------------------------------------------------------------------------
-
-interface SummaryInput {
-  readonly metrics: EngineMetricsSnapshot;
-  readonly seed?: number | undefined;
-  readonly seedExplicit?: boolean | undefined;
-  readonly errorContextCounts?: ReadonlyMap<string, number> | undefined;
-}
-
-function healthStateLabel(state: AdapterHealthSnapshot["state"]): string {
-  switch (state) {
-    case "healthy":
-      return colors.green(state);
-    case "busy":
-      return colors.yellow(state);
-    case "saturated":
-      return colors.red(state);
-    default: {
-      const _exhaustive: never = state;
-      return _exhaustive;
-    }
-  }
-}
-
-function adapterLabel(name: string): string {
-  if (name === "opcua") return "OPC UA";
-  if (name === "modbus") return "Modbus";
-  return name.toUpperCase();
-}
-
-function formatAdapterLine(
-  name: string,
-  m: EngineMetricsSnapshot["adapters"][number]["metrics"],
-  uptimeMs: number,
-): string {
-  const connStr = m.connected ? colors.green("✓") : colors.red("✗");
-  const verb = name === "opcua" || name === "modbus" ? "updates" : "published";
-  const avgThroughput = computeAverageThroughput(m.messagesPublished, uptimeMs);
-  const throughputStr = avgThroughput !== null ? `${sep}${formatCount(avgThroughput)} msg/s` : "";
-  const errStr =
-    m.errorsCount > 0 ? `${sep}${colors.yellow(formatCount(m.errorsCount))} errors` : "";
-  const health = m.health ? `${sep}${healthStateLabel(m.health.state)}` : "";
-  return `${connStr} ${formatCount(m.messagesPublished)} ${verb}${throughputStr}${errStr}${health}`;
-}
-
-// ---------------------------------------------------------------------------
-// Periodic summary (single-line per component)
-// ---------------------------------------------------------------------------
-
-/**
- * Print a compact periodic summary: one line for core stats, one per adapter.
- */
-export function printSummaryLine(metrics: EngineMetricsSnapshot): void {
-  if (isQuiet()) return;
-
-  if (isJsonLogFormat()) {
-    engineLog.info("Periodic summary", buildJsonSummary({ metrics }));
-    return;
-  }
-
-  // Blank line before each summary block to visually separate it from event lines
-  writeOutput();
-
-  const { core, fleet, adapters } = metrics;
-
-  // Core stats — omit tick count (redundant with rate) and instance count (static, already in banner)
-  const parts = [
-    formatDuration(core.uptimeMs),
-    `${core.actualTicksPerSecond.toFixed(1)} ticks/s`,
-    `${formatCount(core.memberValueCount)} data points`,
-  ];
-  if (fleet.activeFaultCount > 0) {
-    parts.push(`${colors.yellow(String(fleet.activeFaultCount))} faults`);
-  }
-  engineLog.info(parts.join(sep));
-
-  // Per-adapter line
-  for (const adapter of adapters) {
-    adapterLogger(adapter.name).info(
-      formatAdapterLine(adapter.name, adapter.metrics, core.uptimeMs),
-    );
-  }
-}
-
-// ---------------------------------------------------------------------------
-// Shutdown summary (box)
-// ---------------------------------------------------------------------------
-
-function buildSummaryLines(input: SummaryInput): string[] {
-  const { core, fleet, adapters } = input.metrics;
-  const lines: string[] = [];
-
-  // Core stats
-  lines.push(
-    `${colors.bold(formatDuration(core.uptimeMs))}${sep}${colors.bold(formatCount(core.tickCount))} ticks${sep}${colors.bold(String(core.actualTicksPerSecond.toFixed(1)))} ticks/s`,
-  );
-  lines.push(
-    `${colors.bold(formatCount(core.instanceCount))} instances${sep}${colors.bold(formatCount(core.memberValueCount))} data points${sep}sim: ${colors.bold(core.simulationTimeSeconds.toFixed(1))}s`,
-  );
-
-  // Adapters
-  for (const adapter of adapters) {
-    const m = adapter.metrics;
-    const label = adapterLabel(adapter.name);
-    const connStr = m.connected ? colors.green("connected") : colors.red("disconnected");
-    const errStr =
-      m.errorsCount === 0
-        ? colors.green(formatCount(m.errorsCount))
-        : colors.yellow(formatCount(m.errorsCount));
-    const avgThroughput = computeAverageThroughput(m.messagesPublished, core.uptimeMs);
-    const throughputStr = avgThroughput !== null ? `${sep}${formatCount(avgThroughput)} msg/s` : "";
-    const verb = adapter.name === "opcua" || adapter.name === "modbus" ? "updates" : "published";
-    lines.push(
-      `${label}: ${connStr}${sep}${colors.bold(formatCount(m.messagesPublished))} ${verb}${sep}${errStr} errors${throughputStr}`,
-    );
-    if (m.health) {
-      const pendingPrefix =
-        m.health.pendingWorkCount > 0
-          ? `${formatCount(m.health.pendingWorkCount)} pending${sep}`
-          : "";
-      lines.push(`  ${pendingPrefix}${healthStateLabel(m.health.state)}`);
-    }
-  }
-
-  // Fleet health warnings
-  const healthParts: string[] = [];
-  if (fleet.activeFaultCount > 0) {
-    healthParts.push(`${colors.yellow(String(fleet.activeFaultCount))} active faults`);
-  }
-  if (core.quarantinedInstanceCount > 0) {
-    healthParts.push(`${colors.yellow(String(core.quarantinedInstanceCount))} quarantined`);
-  }
-  if (core.engineErrorsCount > 0) {
-    healthParts.push(`${colors.yellow(formatCount(core.engineErrorsCount))} engine errors`);
-  }
-  if (core.tickOverrunsCount > 0) {
-    healthParts.push(`${colors.yellow(formatCount(core.tickOverrunsCount))} overruns`);
-  }
-  if (core.circuitBreakerTripsCount > 0) {
-    healthParts.push(`${colors.yellow(formatCount(core.circuitBreakerTripsCount))} breaker trips`);
-  }
-  if (healthParts.length > 0) {
-    lines.push(healthParts.join(sep));
-  }
-
-  // Fault breakdown
-  if (fleet.faultBreakdown.length > 0) {
-    const faultItems: TreeItem[] = fleet.faultBreakdown.map(
-      (f) => `${colors.yellow(String(f.count))} ${f.fault}`,
-    );
-    lines.push(formatTree(faultItems, { color: "yellow", prefix: "  " }).trimEnd());
-  }
-
-  // Models & lifecycle
-  const treeItems: TreeItem[] = [];
-  if (fleet.modelBreakdown.length > 0) {
-    treeItems.push({
-      text: `${colors.cyan("Models")} ${colors.dim(`(${fleet.modelBreakdown.length})`)}`,
-      children: fleet.modelBreakdown.map((m) => `${colors.bold(String(m.count))} ${m.model}`),
-    });
-  }
-  const lifecycleEntries = Object.entries(fleet.lifecycleBreakdown).filter(
-    ([, count]) => count > 0,
-  );
-  if (lifecycleEntries.length > 0) {
-    treeItems.push({
-      text: colors.cyan("Lifecycle"),
-      children: lifecycleEntries.map(([stage, count]) => `${colors.bold(String(count))} ${stage}`),
-    });
-  }
-  if (treeItems.length > 0) {
-    lines.push(formatTree(treeItems, { color: "gray", prefix: "  " }).trimEnd());
-  }
-
-  // Seed
-  if (input.seed !== undefined) {
-    const seedLine = input.seedExplicit
-      ? `Seed: ${colors.bold(String(input.seed))}`
-      : `Seed: ${colors.bold(String(input.seed))} ${colors.gray("(add seed to config to reproduce)")}`;
-    lines.push(seedLine);
-  }
-
-  // Top error contexts
-  if (input.errorContextCounts && input.errorContextCounts.size > 0) {
-    const topContexts = [...input.errorContextCounts.entries()]
-      .sort((a, b) => b[1] - a[1])
-      .slice(0, 5);
-    const errorItems: TreeItem[] = topContexts.map(
-      ([context, count]) => `${context} ${colors.dim("\u00B7")} ${colors.bold(formatCount(count))}`,
-    );
-    lines.push(colors.cyan("Top errors"));
-    lines.push(formatTree(errorItems, { color: "red", prefix: "  " }).trimEnd());
-  }
-
-  return lines;
-}
-
-function buildJsonSummary(input: SummaryInput): Record<string, unknown> {
-  const { core, fleet, adapters } = input.metrics;
-
-  const adapterSummaries: Record<string, unknown>[] = [];
-  for (const adapter of adapters) {
-    const m = adapter.metrics;
-    const avgThroughput = computeAverageThroughput(m.messagesPublished, core.uptimeMs);
-    adapterSummaries.push({
-      name: adapter.name,
-      messagesPublished: m.messagesPublished,
-      errorsCount: m.errorsCount,
-      connected: m.connected,
-      ...(avgThroughput !== null ? { avgMsgPerSecond: avgThroughput } : {}),
-      ...(m.health
-        ? { health: { state: m.health.state, pendingWorkCount: m.health.pendingWorkCount } }
-        : {}),
-    });
-  }
-
-  const summary: Record<string, unknown> = {
-    uptimeMs: core.uptimeMs,
-    tickCount: core.tickCount,
-    ticksPerSecond: Number(core.actualTicksPerSecond.toFixed(1)),
-    simulationTimeSeconds: Number(core.simulationTimeSeconds.toFixed(1)),
-    instanceCount: core.instanceCount,
-    memberValueCount: core.memberValueCount,
-    engineErrorsCount: core.engineErrorsCount,
-    activeFaultCount: fleet.activeFaultCount,
-    quarantinedInstanceCount: core.quarantinedInstanceCount,
-    tickOverrunsCount: core.tickOverrunsCount,
-    circuitBreakerTripsCount: core.circuitBreakerTripsCount,
-    lifecycleBreakdown: fleet.lifecycleBreakdown,
-    adapters: adapterSummaries,
-  };
-
-  if (input.seed !== undefined) {
-    summary["seed"] = input.seed;
-    summary["seedExplicit"] = input.seedExplicit ?? false;
-  }
-
-  if (input.errorContextCounts && input.errorContextCounts.size > 0) {
-    const topContexts = [...input.errorContextCounts.entries()]
-      .sort((a, b) => b[1] - a[1])
-      .slice(0, 5);
-    summary["topErrorContexts"] = Object.fromEntries(topContexts);
-  }
-
-  return summary;
-}
-
-function renderSummaryText(title: string, input: SummaryInput): string {
-  const lines = buildSummaryLines(input);
-
-  if (isPlain()) {
-    return [title, ...lines.map((line) => `  ${stripAnsi(line)}`), ""].join("\n");
-  }
-
-  return box(lines.join("\n"), {
-    title: ` ${title} `,
-    style: { borderColor: "gray", borderStyle: "rounded" },
-  });
-}
-
-async function printShutdownSummary(
-  metrics: EngineMetricsSnapshot,
-  seed: number,
-  seedExplicit: boolean,
-  errorContextCounts?: ReadonlyMap<string, number>,
-  writeFinal: (text: string) => Promise<void> = writeShutdownOutput,
-): Promise<void> {
-  if (isQuiet()) return;
-
-  if (isJsonLogFormat()) {
-    engineLog.info(
-      "Shutdown summary",
-      buildJsonSummary({ metrics, seed, seedExplicit, errorContextCounts }),
-    );
-    await flushOutputStreams();
-    return;
-  }
-
-  await writeFinal(
-    renderSummaryText("Shutdown Summary", {
-      metrics,
-      seed,
-      seedExplicit,
-      errorContextCounts,
-    }),
-  );
-}
-
-async function writeShutdownOutput(text: string): Promise<void> {
-  await writeToStream(process.stdout, text.endsWith("\n") ? text : `${text}\n`);
-  await flushOutputStreams();
-}
-
-async function writeToStream(stream: NodeJS.WriteStream, text: string): Promise<void> {
-  await new Promise<void>((resolve, reject) => {
-    stream.write(text, (error?: Error | null) => {
-      if (error) {
-        reject(error);
-        return;
-      }
-      resolve();
-    });
-  });
-}
-
-async function flushOutputStreams(): Promise<void> {
-  await Promise.all([writeToStream(process.stdout, ""), writeToStream(process.stderr, "")]);
-  await Bun.sleep(FINAL_OUTPUT_GRACE_MS);
-}

package/src/lib/template-category.test.ts

@@ -1,71 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import type { DiscoveredTemplate } from "@miravo/shared";
-import {
-  categorizeTemplate,
-  groupTemplatesByCategory,
-  sortTemplatesByCategoryAndName,
-} from "./template-category.ts";
-
-function discoveredTemplate(id: string, name: string): DiscoveredTemplate {
-  return {
-    path: `/tmp/${id}.miravo.yaml`,
-    id,
-    name,
-    areaCount: 1,
-    twinAssignmentCount: 1,
-    inlineModelCount: 0,
-    uniqueModelCount: 1,
-    modelNames: ["model-a"],
-    totalTwinCount: 1,
-  };
-}
-
-describe("template category helpers", () => {
-  test("categorizeTemplate maps stress templates to Stress & Benchmark", () => {
-    expect(categorizeTemplate(discoveredTemplate("stress-5k", "Stress 5K"))).toBe(
-      "Stress & Benchmark",
-    );
-    expect(categorizeTemplate(discoveredTemplate("stress-10k", "Stress 10K"))).toBe(
-      "Stress & Benchmark",
-    );
-    expect(categorizeTemplate(discoveredTemplate("smart-factory", "Smart Factory"))).toBe(
-      "Industrial Scenarios",
-    );
-  });
-
-  test("sortTemplatesByCategoryAndName sorts by category then name", () => {
-    const templates = [
-      discoveredTemplate("stress-100k", "Stress 100K"),
-      discoveredTemplate("water-treatment", "Water Treatment"),
-      discoveredTemplate("smart-factory", "Smart Factory"),
-      discoveredTemplate("stress-10k", "Stress 10K"),
-      discoveredTemplate("stress-5k", "Stress 5K"),
-      discoveredTemplate("stress-50k", "Stress 50K"),
-    ];
-
-    const sortedIds = sortTemplatesByCategoryAndName(templates).map((template) => template.id);
-    expect(sortedIds).toEqual([
-      "smart-factory",
-      "water-treatment",
-      "stress-100k",
-      "stress-10k",
-      "stress-50k",
-      "stress-5k",
-    ]);
-  });
-
-  test("groupTemplatesByCategory returns non-empty groups in category order", () => {
-    const templates = sortTemplatesByCategoryAndName([
-      discoveredTemplate("stress-50k", "Stress 50K"),
-      discoveredTemplate("water-treatment", "Water Treatment"),
-    ]);
-
-    const grouped = groupTemplatesByCategory(templates);
-    expect(grouped.map((group) => group.category)).toEqual([
-      "Industrial Scenarios",
-      "Stress & Benchmark",
-    ]);
-    expect(grouped[0]?.templates.map((template) => template.id)).toEqual(["water-treatment"]);
-    expect(grouped[1]?.templates.map((template) => template.id)).toEqual(["stress-50k"]);
-  });
-});