// CRITICALimport { afterEach, describe, expect, it } from "bun:test";import { tmpdir } from "node:os";import { join } from "node:path";import type { Config } from "../../config/env";import type { Logger } from "../../core/logger";import type { Recipe, ProcessInfo, LaunchResult } from "../models/types";import { EngineCoordinator } from "./engine-coordinator";import type { ProcessManager } from "./process/process-manager"; const servers: Array<ReturnType<typeof Bun.serve>> = []; afterEach(() => {  for (const server of servers.splice(0)) {    server.stop(true);  }}); const recipe = (id: string, modelPath: string): Recipe =>  ({    id,    name: id,    backend: "vllm",    model_path: modelPath,    served_model_name: id,  }) as Recipe; const processFor = (activeRecipe: Recipe, port: number): ProcessInfo => ({  pid: process.pid,  backend: activeRecipe.backend,  model_path: activeRecipe.model_path,  port,  served_model_name: activeRecipe.served_model_name ?? null,}); const createCoordinator = (  initialRecipe: Recipe | null = null,  healthStatus: number = 200): {  coordinator: EngineCoordinator;  recipes: [Recipe, Recipe];  launched: Recipe[];  killed: number[];  events: Array<{ recipeId: string; stage: string; message: string; progress?: number }>;  abortedModels: string[];} => {  const server = Bun.serve({    port: 0,    fetch: () => new Response("ok", { status: healthStatus }),  });  servers.push(server);   const port = server.port;  if (port === undefined) {    throw new Error("Test server did not bind a port");  }  const recipes: [Recipe, Recipe] = [    recipe("alpha", "/models/alpha"),    recipe("beta", "/models/beta"),  ];  let current = initialRecipe ? processFor(initialRecipe, port) : null;  const launched: Recipe[] = [];  const killed: number[] = [];  const events: Array<{ recipeId: string; stage: string; message: string; progress?: number }> = [];  const abortedModels: string[] = [];   const processManager: ProcessManager = {    findInferenceProcess: async () => current,    launchModel: async (targetRecipe): Promise<LaunchResult> => {      launched.push(targetRecipe);      current = processFor(targetRecipe, port);      return {        success: true,        pid: current.pid,        message: "Process started",        log_file: join(tmpdir(), `${targetRecipe.id}.log`),      };    },    evictModel: async () => {      const pid = current?.pid ?? null;      current = null;      return pid;    },    killProcess: async (pid) => {      killed.push(pid);      current = null;      return true;    },  };   const coordinator = new EngineCoordinator({    config: {      inference_port: port,      data_dir: tmpdir(),    } as Config,    logger: {      info: () => {},      warn: () => {},      error: () => {},      debug: () => {},    } as Logger,    eventManager: {      publishLaunchProgress: async (        recipeId: string,        stage: string,        message: string,        progress?: number      ) => {        events.push({          recipeId,          stage,          message,          ...(progress === undefined ? {} : { progress }),        });      },      publish: async () => {},    } as never,    processManager,    recipeStore: {      list: () => recipes,    } as never,    downloadManager: {} as never,    abortRunsForModel: (modelName: string): number => {      abortedModels.push(modelName);      return 1;    },  });   return { coordinator, recipes, launched, killed, events, abortedModels };}; describe("EngineCoordinator.setActiveRecipe", () => {  it("treats null to null as a no-op", async () => {    const { coordinator, launched, killed } = createCoordinator();     await expect(coordinator.setActiveRecipe(null)).resolves.toEqual({ ok: true });     expect(launched).toHaveLength(0);    expect(killed).toHaveLength(0);    expect(coordinator.getCurrentRecipe()).toBeNull();  });   it("launches a recipe when no process is running", async () => {    const { coordinator, recipes, launched, killed, events } = createCoordinator();     await expect(coordinator.setActiveRecipe(recipes[0])).resolves.toEqual({ ok: true });     expect(launched).toEqual([recipes[0]]);    expect(killed).toHaveLength(0);    expect(coordinator.getCurrentRecipe()).toBe(recipes[0]);    expect(events.map((event) => event.stage)).toEqual(["launching", "waiting", "ready"]);  });   it("evicts the current recipe when setting null", async () => {    const active = recipe("alpha", "/models/alpha");    const { coordinator, launched, killed, abortedModels } = createCoordinator(active);     await expect(coordinator.setActiveRecipe(null)).resolves.toEqual({ ok: true });     expect(launched).toHaveLength(0);    expect(killed).toEqual([process.pid]);    expect(abortedModels).toEqual(["alpha"]);    expect(coordinator.getCurrentRecipe()).toBeNull();  });   it("swaps from one recipe to another", async () => {    const active = recipe("alpha", "/models/alpha");    const target = recipe("beta", "/models/beta");    const { coordinator, launched, killed, events, abortedModels } = createCoordinator(active);     await expect(coordinator.setActiveRecipe(target)).resolves.toEqual({ ok: true });     expect(killed).toEqual([process.pid]);    expect(abortedModels).toEqual(["alpha"]);    expect(launched).toEqual([target]);    expect(coordinator.getCurrentRecipe()).toBe(target);    expect(events.map((event) => event.stage)).toEqual([      "stopping",      "stopped",      "launching",      "waiting",      "ready",    ]);  });   it("blocks OpenAI auto-load after the user manually stops a model", async () => {    const active = recipe("alpha", "/models/alpha");    const { coordinator, recipes, launched } = createCoordinator(active);     await expect(coordinator.setActiveRecipe(null)).resolves.toEqual({ ok: true });    const result = await coordinator.ensureActive(recipes[1]);     expect(result.error).toContain("manually stopped");    expect(launched).toHaveLength(0);  });});