@ic-reactor/mcp 0.0.0-stage → 0.0.0

package/packages/vite-plugin/tests/icp-command.test.ts

@@ -0,0 +1,194 @@
+/**
+ * How the plugin starts `icp`. On Windows, npm links icp-cli's npm package as
+ * `node_modules/.bin/icp.cmd`, which `spawn` cannot start, so the package's
+ * bin script is run with Node there.
+ */
+import fs from "node:fs"
+import os from "node:os"
+import path from "node:path"
+import { execFileSync } from "node:child_process"
+import { afterEach, describe, expect, it } from "vitest"
+import { icpCommand, installIcpAdvice } from "../src/env.js"
+import { removeDirectory } from "./support.js"
+
+const roots: string[] = []
+
+afterEach(() => {
+  for (const root of roots.splice(0)) removeDirectory(root)
+})
+
+/** An app root, with `@icp-sdk/icp-cli` installed when `bin` is given. */
+function app(bin?: string | Record<string, string>): string {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), "icp-command-"))
+  roots.push(root)
+  fs.writeFileSync(path.join(root, "package.json"), '{"name":"app"}')
+  if (bin !== undefined) install(path.join(root, "node_modules"), bin)
+  return root
+}
+
+/**
+ * `@icp-sdk/icp-cli` in `nodeModules`, whose bin script prints its arguments,
+ * as the real one would print what `icp` answers.
+ */
+function install(nodeModules: string, bin: string | Record<string, string>) {
+  const dir = path.join(nodeModules, "@icp-sdk", "icp-cli")
+  fs.mkdirSync(path.join(dir, "bin"), { recursive: true })
+  fs.writeFileSync(
+    path.join(dir, "package.json"),
+    JSON.stringify({ name: "@icp-sdk/icp-cli", version: "1.2.0", bin })
+  )
+  fs.writeFileSync(
+    path.join(dir, "bin", "icp.js"),
+    "process.stdout.write(JSON.stringify(process.argv.slice(2)))\n"
+  )
+}
+
+/** icp-cli's platform package for this machine in `nodeModules`, with its icp.exe. */
+function nativeIcp(nodeModules: string): string {
+  fs.mkdirSync(nodeModules, { recursive: true })
+  const dir = path.join(
+    fs.realpathSync(nodeModules),
+    "@icp-sdk",
+    `icp-cli-win32-${process.arch}`,
+    "bin"
+  )
+  fs.mkdirSync(dir, { recursive: true })
+  fs.writeFileSync(path.join(dir, "icp.exe"), "")
+  return path.join(dir, "icp.exe")
+}
+
+/** A stand-in for `%APPDATA%`, with npm's global prefix in it. */
+function appData(withIcp: boolean): string {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), "icp-appdata-"))
+  roots.push(root)
+  if (withIcp)
+    install(path.join(root, "npm", "node_modules"), { icp: "bin/icp.js" })
+  return root
+}
+
+describe("icpCommand", () => {
+  it("runs the installed icp-cli's bin script with Node on Windows", () => {
+    const root = app({ icp: "bin/icp.js" })
+    expect(icpCommand(root, "win32")).toEqual({
+      file: process.execPath,
+      args: [
+        path.join(
+          fs.realpathSync(root),
+          "node_modules",
+          "@icp-sdk",
+          "icp-cli",
+          "bin",
+          "icp.js"
+        ),
+      ],
+    })
+  })
+
+  it("finds a package installed above the app, as in a workspace", () => {
+    const workspace = app({ icp: "bin/icp.js" })
+    const root = path.join(workspace, "packages", "web")
+    fs.mkdirSync(root, { recursive: true })
+    expect(icpCommand(root, "win32").args).toEqual([
+      path.join(
+        fs.realpathSync(workspace),
+        "node_modules",
+        "@icp-sdk",
+        "icp-cli",
+        "bin",
+        "icp.js"
+      ),
+    ])
+  })
+
+  it("reads a bin given as one string too", () => {
+    const root = app("bin/icp.js")
+    expect(icpCommand(root, "win32").file).toBe(process.execPath)
+  })
+
+  it("starts the bin script it names, so the command runs as given", () => {
+    // What spawn is handed on Windows, run here on any platform: Node and
+    // the script, never a .cmd shim.
+    const { file, args } = icpCommand(app({ icp: "bin/icp.js" }), "win32")
+    const out = execFileSync(file, [...args, "network", "status", "--json"], {
+      encoding: "utf-8",
+    })
+    expect(JSON.parse(out)).toEqual(["network", "status", "--json"])
+  })
+
+  it("runs a global npm install's bin script on Windows when the app has none", () => {
+    const data = appData(true)
+    expect(icpCommand(app(), "win32", data)).toEqual({
+      file: process.execPath,
+      args: [
+        path.join(
+          fs.realpathSync(path.join(data, "npm", "node_modules")),
+          "@icp-sdk",
+          "icp-cli",
+          "bin",
+          "icp.js"
+        ),
+      ],
+    })
+  })
+
+  it("prefers the app's own icp-cli to a global one", () => {
+    const root = app({ icp: "bin/icp.js" })
+    expect(icpCommand(root, "win32", appData(true)).args[0]).toContain(
+      fs.realpathSync(root)
+    )
+  })
+
+  it("runs the icp.exe the bin script would start, so a timeout kills icp itself", () => {
+    // Beside icp-cli, as a flat or global install puts it. Killing the bin
+    // script on a timeout would leave this child holding the output pipes.
+    const root = app({ icp: "bin/icp.js" })
+    const exe = nativeIcp(path.join(root, "node_modules"))
+    expect(icpCommand(root, "win32")).toEqual({
+      file: exe,
+      args: [],
+      env: { ICP_CLI_DIST: "npm" },
+    })
+    // And a global npm install's.
+    const data = appData(true)
+    const globalExe = nativeIcp(path.join(data, "npm", "node_modules"))
+    expect(icpCommand(app(), "win32", data).file).toBe(globalExe)
+  })
+
+  it("finds the icp.exe inside icp-cli's own node_modules as well", () => {
+    const root = app({ icp: "bin/icp.js" })
+    const exe = nativeIcp(
+      path.join(root, "node_modules", "@icp-sdk", "icp-cli", "node_modules")
+    )
+    expect(icpCommand(root, "win32").file).toBe(exe)
+  })
+
+  it("looks icp up on PATH on Windows when neither the app nor npm's prefix has icp-cli", () => {
+    expect(icpCommand(app(), "win32", appData(false))).toEqual({
+      file: "icp",
+      args: [],
+    })
+    expect(icpCommand(app(), "win32", undefined)).toEqual({
+      file: "icp",
+      args: [],
+    })
+  })
+
+  it("looks icp up on PATH elsewhere, installed package or not", () => {
+    const root = app({ icp: "bin/icp.js" })
+    expect(icpCommand(root, "linux")).toEqual({ file: "icp", args: [] })
+    expect(icpCommand(root, "darwin")).toEqual({ file: "icp", args: [] })
+  })
+})
+
+describe("installIcpAdvice", () => {
+  it("says an install is enough on Windows, and PATH elsewhere", () => {
+    expect(installIcpAdvice("win32")).toMatch(
+      /npm install --save-dev @icp-sdk\/icp-cli\) or globally with npm/
+    )
+    for (const platform of ["linux", "darwin"] as const) {
+      expect(installIcpAdvice(platform)).toMatch(
+        /^Put `icp` on PATH .*run vite from an npm script\.$/
+      )
+    }
+  })
+})

package/packages/vite-plugin/tests/icp-timeout.test.ts

@@ -0,0 +1,83 @@
+/**
+ * An `icp` that never exits is killed at the timeout together with the
+ * process it started. npm's `icp` is a Node script that starts the native
+ * binary as its child, on the script's own pipes, and killing the script alone
+ * left that child running: while detection is incomplete, each page load could
+ * leave one more (#980). Not on Windows, where the plugin runs `icp.exe`
+ * itself.
+ */
+import fs from "node:fs"
+import os from "node:os"
+import path from "node:path"
+import { afterEach, describe, expect, it, vi } from "vitest"
+import { runIcp } from "../src/env.js"
+import { removeDirectory } from "./support.js"
+
+/** A stand-in for npm's `icp`: it starts a child as the script does, and hangs. */
+const HANGING_ICP = `#!/usr/bin/env node
+const { spawn } = require("node:child_process")
+const fs = require("node:fs")
+const path = require("node:path")
+const child = spawn(process.execPath, ["-e", "setInterval(() => {}, 1000)"], {
+  stdio: "inherit",
+})
+fs.writeFileSync(path.join(__dirname, "child.pid"), String(child.pid))
+setInterval(() => {}, 1000)
+`
+
+const dirs: string[] = []
+const pids: number[] = []
+
+afterEach(() => {
+  vi.unstubAllEnvs()
+  for (const pid of pids.splice(0)) {
+    try {
+      process.kill(pid, "SIGKILL")
+    } catch {
+      // Gone already.
+    }
+  }
+  for (const dir of dirs.splice(0)) removeDirectory(dir)
+})
+
+/**
+ * Whether `pid` is a process still running: one that exited but was not
+ * reaped yet (a zombie, which `kill(pid, 0)` still finds) is not.
+ */
+function running(pid: number): boolean {
+  try {
+    process.kill(pid, 0)
+  } catch {
+    return false
+  }
+  try {
+    const stat = fs.readFileSync(`/proc/${pid}/stat`, "utf-8")
+    return stat.slice(stat.lastIndexOf(")") + 2)[0] !== "Z"
+  } catch {
+    return true
+  }
+}
+
+describe.skipIf(process.platform === "win32")("an icp that never exits", () => {
+  it("is killed at the timeout with the process it started", async () => {
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), "ic-reactor-icp-"))
+    dirs.push(dir)
+    fs.writeFileSync(path.join(dir, "icp"), HANGING_ICP, { mode: 0o755 })
+    vi.stubEnv("PATH", `${dir}${path.delimiter}${process.env.PATH}`)
+    const childPid = path.join(dir, "child.pid")
+
+    const failure = await runIcp(["network", "status"], dir, 1000).catch(
+      (error: unknown) => error
+    )
+
+    expect(failure).toMatchObject({ killed: true, signal: "SIGTERM" })
+    expect((failure as Error).message).toBe(
+      "Command failed: icp network status\n"
+    )
+    const pid = Number(fs.readFileSync(childPid, "utf-8"))
+    pids.push(pid)
+    await vi.waitFor(() => expect(running(pid)).toBe(false), {
+      timeout: 2000,
+    })
+  })
+})

package/packages/vite-plugin/tests/no-process-exit.test.ts

@@ -0,0 +1,83 @@
+/**
+ * A Vite plugin runs inside someone else's process, so it never ends that
+ * process: it reports a failure by throwing or logging, and Vite decides what
+ * to do. This reads the plugin's source and fails on any way of writing
+ * `process.exit`.
+ */
+import fs from "node:fs"
+import path from "node:path"
+import { fileURLToPath } from "node:url"
+import { describe, expect, it } from "vitest"
+
+const SRC = path.join(path.dirname(fileURLToPath(import.meta.url)), "../src")
+
+/**
+ * The ways source ends or aborts the process: `process.exit(`,
+ * `process["exit"](`, `process.abort(`, `process.kill(process.pid` and an
+ * import of `exit` from `node:process`.
+ */
+function endsTheProcess(source: string): boolean {
+  return [
+    /\bprocess\s*(\.|\?\.|\[\s*["'`])\s*(exit|abort|reallyExit)\b/,
+    /\bprocess\s*\.\s*kill\s*\(\s*process\s*\.\s*pid\b/,
+    /\bimport\s*\{[^}]*\b(exit|abort)\b[^}]*\}\s*from\s*["'](node:)?process["']/,
+  ].some((pattern) => pattern.test(source))
+}
+
+/** The files the package ships: its source, not its tests (see `files` in package.json). */
+function shippedSource(dir: string): string[] {
+  return fs.readdirSync(dir, { withFileTypes: true }).flatMap((entry) => {
+    const file = path.join(dir, entry.name)
+    if (entry.isDirectory()) return shippedSource(file)
+    return /\.[cm]?[jt]sx?$/.test(entry.name) &&
+      !/\.test\.[cm]?[jt]sx?$/.test(entry.name)
+      ? [file]
+      : []
+  })
+}
+
+describe("the plugin's source", () => {
+  it("scans the files that make up the plugin", () => {
+    const names = shippedSource(SRC).map((file) => path.basename(file))
+    expect(names).toEqual(
+      expect.arrayContaining([
+        "index.ts",
+        "generate.ts",
+        "env.ts",
+        "dev-environment.ts",
+      ])
+    )
+  })
+
+  it("never calls process.exit", () => {
+    const offenders = shippedSource(SRC).filter((file) =>
+      endsTheProcess(fs.readFileSync(file, "utf-8"))
+    )
+
+    expect(offenders.map((file) => path.relative(SRC, file))).toEqual([])
+  })
+
+  it("recognises each spelling it is meant to refuse", () => {
+    for (const source of [
+      "process.exit(1)",
+      "process . exit ( 0 )",
+      'process["exit"](1)',
+      "process?.exit(1)",
+      "process.abort()",
+      "process.kill(process.pid, 'SIGKILL')",
+      'import { exit } from "node:process"',
+      "import { env, exit as quit } from 'process'",
+    ]) {
+      expect(endsTheProcess(source), source).toBe(true)
+    }
+    for (const source of [
+      "process.exitCode = 1",
+      "const { exitCode } = run",
+      "child.kill('SIGKILL')",
+      "process.env.DEBUG",
+      "// the CLI exits with code 1",
+    ]) {
+      expect(endsTheProcess(source), source).toBe(false)
+    }
+  })
+})

package/packages/vite-plugin/tests/on-generated.test.ts

@@ -0,0 +1,323 @@
+/**
+ * `onGenerated`: called once for each module a run generated, inside the
+ * run, under a real `vite build` and a real `vite dev` server, with the real
+ * `@meantjs/cli`. A throw fails the module's canisters as a failed
+ * generation does, and they are generated, and the hook called, again on the
+ * next run.
+ */
+import fs from "node:fs"
+import path from "node:path"
+import { afterEach, describe, expect, it, vi } from "vitest"
+import type { Plugin } from "vite"
+import { icReactor, type IcReactorPluginOptions } from "../src/index.js"
+import {
+  BROKEN_DID,
+  createApp,
+  PING_DID,
+  recordingLogger,
+  runBuild,
+  startDev,
+  type App,
+  type Running,
+} from "./support.js"
+
+type Hook = NonNullable<IcReactorPluginOptions["onGenerated"]>
+type Call = Parameters<Hook>[0]
+
+const closers: Array<() => Promise<unknown>> = []
+const apps: App[] = []
+
+afterEach(async () => {
+  for (const close of closers.splice(0).reverse()) await close()
+  for (const app of apps.splice(0)) app.cleanup()
+})
+
+function newApp(files: Record<string, string>) {
+  const app = createApp(files, "real")
+  apps.push(app)
+  return app
+}
+
+async function serve(
+  root: string,
+  options: IcReactorPluginOptions
+): Promise<Running> {
+  const running = await startDev(root, options)
+  closers.push(running.close)
+  return running
+}
+
+/** A hook that records what it is called with, and the envelope it read. */
+function recordingHook(behave: (call: Call) => unknown = () => undefined) {
+  const calls: Array<Omit<Call, "signal"> & { envelopeText: string }> = []
+  const hook: Hook = async (call) => {
+    const { signal: _signal, ...rest } = call
+    calls.push({
+      ...rest,
+      envelopeText: fs.readFileSync(call.envelope, "utf-8"),
+    })
+    await behave(call)
+  }
+  return { calls, hook }
+}
+
+/** The plugin, driven by hand as a build drives it. */
+function buildPlugin(app: App, options: IcReactorPluginOptions) {
+  const plugin = icReactor(options) as Plugin & {
+    configResolved: (config: unknown) => void
+    buildStart: (this: unknown) => Promise<void>
+    closeBundle: (this: unknown) => void
+  }
+  const { logger, lines } = recordingLogger()
+  plugin.configResolved({ root: app.root, command: "build", logger })
+  const context = {
+    addWatchFile: vi.fn(),
+    error: vi.fn((message: unknown) => {
+      throw new Error(String(message))
+    }),
+  }
+  return {
+    lines,
+    buildStart: () => plugin.buildStart.call(context),
+    closeBundle: () => plugin.closeBundle.call({}),
+  }
+}
+
+describe("onGenerated under vite build", () => {
+  it("is called once for each module, after the generator wrote it and its envelope, and not for a canister that failed", async () => {
+    const app = newApp({
+      "did/ping.did": PING_DID,
+      "did/shared.did": "service : { pong : () -> () };\n",
+      "did/bad.did": BROKEN_DID,
+    })
+    const { calls, hook } = recordingHook()
+    const { result } = runBuild(app.root, {
+      failOnError: false,
+      onGenerated: hook,
+      canisters: {
+        ping: { didFile: "did/ping.did" },
+        left: { didFile: "did/shared.did" },
+        right: { didFile: "did/shared.did" },
+        bad: { didFile: "did/bad.did" },
+      },
+    })
+    await result
+
+    const out = path.join(app.root, "src/canisters")
+    expect(
+      calls
+        .map(({ envelopeText: _, ...call }) => call)
+        .sort((a, b) => a.module.localeCompare(b.module))
+    ).toEqual([
+      {
+        names: ["ping"],
+        didFile: path.join(app.root, "did/ping.did"),
+        module: path.join(out, "ping.ts"),
+        envelope: path.join(out, "ping.envelope.json"),
+        status: "written",
+      },
+      {
+        names: ["left", "right"],
+        didFile: path.join(app.root, "did/shared.did"),
+        module: path.join(out, "shared.ts"),
+        envelope: path.join(out, "shared.envelope.json"),
+        status: "written",
+      },
+    ])
+    // Each read its own envelope, already on disk.
+    for (const call of calls) {
+      expect(call.envelopeText).toBe(fs.readFileSync(call.envelope, "utf-8"))
+      expect(call.envelopeText.length).toBeGreaterThan(0)
+    }
+  })
+
+  it("fails the build with a hook that rejects, naming the canister and the hook", async () => {
+    const app = newApp({ "did/ping.did": PING_DID })
+    const { result } = runBuild(app.root, {
+      onGenerated: () => Promise.reject(new Error("ids differ")),
+      canisters: { ping: { didFile: "did/ping.did" } },
+    })
+
+    await expect(result).rejects.toThrow(
+      /could not generate 1 of 1 canisters:\n {2}- ping \(did\/ping\.did\): onGenerated failed for src\/canisters\/ping\.ts: .*ids differ/s
+    )
+  })
+
+  it("only logs a hook's failure when failOnError is off", async () => {
+    const app = newApp({ "did/ping.did": PING_DID })
+    const { result, lines } = runBuild(app.root, {
+      failOnError: false,
+      onGenerated: () => {
+        throw new Error("ids differ")
+      },
+      canisters: { ping: { didFile: "did/ping.did" } },
+    })
+
+    await result
+    expect(lines.filter((line) => line.startsWith("error:"))).toEqual([
+      expect.stringContaining("onGenerated failed for src/canisters/ping.ts"),
+    ])
+  })
+
+  it("is waited for by buildStart, which the next run waits for in turn", async () => {
+    const app = newApp({ "did/ping.did": PING_DID })
+    let release!: () => void
+    const held = new Promise<void>((resolve) => (release = resolve))
+    const { calls, hook } = recordingHook(() => held)
+    const { buildStart } = buildPlugin(app, {
+      onGenerated: hook,
+      canisters: { ping: { didFile: "did/ping.did" } },
+    })
+
+    const done: string[] = []
+    const first = buildStart().then(() => done.push("first"))
+    await vi.waitFor(() => expect(calls).toHaveLength(1))
+    // A second run is queued behind the first, hook included.
+    const second = buildStart().then(() => done.push("second"))
+    await new Promise((resolve) => setTimeout(resolve, 200))
+    expect(done).toEqual([])
+
+    release()
+    await Promise.all([first, second])
+    expect(done).toEqual(["first", "second"])
+  })
+
+  it("is abandoned when the build closes, so a hook that never settles holds nothing, and the next run calls it again", async () => {
+    const app = newApp({ "did/ping.did": PING_DID })
+    let hold = true
+    const { calls, hook } = recordingHook(() => {
+      // Ignores its signal, and never settles.
+      if (hold) return new Promise<void>(() => {})
+    })
+    const { buildStart, closeBundle, lines } = buildPlugin(app, {
+      onGenerated: hook,
+      canisters: { ping: { didFile: "did/ping.did" } },
+    })
+
+    const first = buildStart()
+    await vi.waitFor(() => expect(calls).toHaveLength(1))
+    closeBundle()
+    await first
+    await new Promise((resolve) => setTimeout(resolve, 50))
+    expect(lines.filter((line) => line.startsWith("error:"))).toEqual([])
+
+    // The .did is unchanged, but the hook never finished: generated again.
+    hold = false
+    await buildStart()
+    expect(calls).toHaveLength(2)
+  })
+
+  it("is called again on the next run after it failed, and not after it succeeded", async () => {
+    const app = newApp({ "did/ping.did": PING_DID })
+    let fail = true
+    const { calls, hook } = recordingHook(() => {
+      if (fail) throw new Error("not yet")
+    })
+    const { buildStart, lines } = buildPlugin(app, {
+      failOnError: false,
+      onGenerated: hook,
+      canisters: { ping: { didFile: "did/ping.did" } },
+    })
+
+    await buildStart()
+    expect(calls).toHaveLength(1)
+    expect(lines).toContainEqual(expect.stringContaining("not yet"))
+
+    // The .did is unchanged, but the failed module is generated again.
+    fail = false
+    await buildStart()
+    expect(calls).toHaveLength(2)
+
+    // Once it succeeded, an unchanged .did is not generated, and the hook is
+    // not called.
+    await buildStart()
+    expect(calls).toHaveLength(2)
+  })
+})
+
+describe("onGenerated under vite dev", () => {
+  it("is called at startup and again after a save, seeing the new envelope", async () => {
+    const app = newApp({ "did/ping.did": PING_DID })
+    const { calls, hook } = recordingHook()
+    const { server } = await serve(app.root, {
+      onGenerated: hook,
+      canisters: { ping: { didFile: "did/ping.did" } },
+    })
+    expect(calls).toHaveLength(1)
+    expect(calls[0].envelopeText).not.toContain("more")
+
+    const did = path.join(app.root, "did/ping.did")
+    fs.writeFileSync(did, "service : { ping : () -> (); more : () -> () };\n")
+    server.watcher.emit("change", did)
+
+    await vi.waitFor(() => expect(calls).toHaveLength(2))
+    expect(calls[1].envelopeText).toContain("more")
+  })
+
+  it("reports a hook that rejects as a failed generation, and calls it again on the next save", async () => {
+    const app = newApp({ "did/ping.did": PING_DID })
+    let fail = true
+    const { calls, hook } = recordingHook(() => {
+      if (fail) return Promise.reject(new Error("ids differ"))
+    })
+    const { server, lines } = await serve(app.root, {
+      onGenerated: hook,
+      canisters: { ping: { didFile: "did/ping.did" } },
+    })
+    const send = vi.spyOn(server.ws, "send")
+    const errors = () => lines.filter((line) => line.startsWith("error:"))
+    expect(errors()).toEqual([
+      expect.stringContaining(
+        "ping (did/ping.did): onGenerated failed for src/canisters/ping.ts"
+      ),
+    ])
+
+    // The same text saved again: the failed module is generated again.
+    fail = false
+    const did = path.join(app.root, "did/ping.did")
+    fs.writeFileSync(did, PING_DID)
+    server.watcher.emit("change", did)
+
+    await vi.waitFor(() => expect(calls).toHaveLength(2))
+    // The overlay is cleared once it succeeds.
+    await vi.waitFor(() =>
+      expect(send).toHaveBeenCalledWith({ type: "full-reload" })
+    )
+    expect(errors()).toHaveLength(1)
+  })
+
+  it("is handed a signal that the server's close aborts, and a hook still running then reports nothing", async () => {
+    const app = newApp({ "did/ping.did": PING_DID })
+    let seen: AbortSignal | undefined
+    let saves = 0
+    const { calls, hook } = recordingHook((call) => {
+      // Startup's call returns at once; the save's rejects once the server
+      // closed.
+      if (saves === 0) return
+      seen = call.signal
+      return new Promise<void>((_resolve, reject) =>
+        call.signal.addEventListener("abort", () => reject(new Error("closed")))
+      )
+    })
+    const { server, lines, close } = await serve(app.root, {
+      onGenerated: hook,
+      canisters: { ping: { didFile: "did/ping.did" } },
+    })
+
+    saves = 1
+    const did = path.join(app.root, "did/ping.did")
+    fs.writeFileSync(did, "service : { ping : () -> (); more : () -> () };\n")
+    server.watcher.emit("change", did)
+    await vi.waitFor(() => expect(calls).toHaveLength(2))
+    expect(seen?.aborted).toBe(false)
+
+    const before = lines.length
+    await close()
+    closers.splice(0)
+    expect(seen?.aborted).toBe(true)
+    await new Promise((resolve) => setTimeout(resolve, 50))
+    expect(
+      lines.slice(before).filter((line) => line.startsWith("error:"))
+    ).toEqual([])
+  })
+})