Move service state into InstanceState, flatten service facades (#18483)

packages/opencode/test/format/format.test.ts

@@ -2,11 +2,16 @@ import { Effect } from "effect"
 import { afterEach, describe, expect, test } from "bun:test"
 import { tmpdir } from "../fixture/fixture"
 import { withServices } from "../fixture/instance"
+import { Bus } from "../../src/bus"
+import { File } from "../../src/file"
 import { Format } from "../../src/format"
+import * as Formatter from "../../src/format/formatter"
 import { Instance } from "../../src/project/instance"
 
 describe("Format", () => {
-  afterEach(() => Instance.disposeAll())
+  afterEach(async () => {
+    await Instance.disposeAll()
+  })
 
   test("status() returns built-in formatters when no config overrides", async () => {
     await using tmp = await tmpdir()
@@ -62,4 +67,106 @@ describe("Format", () => {
       await rt.runPromise(Format.Service.use(() => Effect.void))
     })
   })
+
+  test("status() initializes formatter state per directory", async () => {
+    await using off = await tmpdir({
+      config: { formatter: false },
+    })
+    await using on = await tmpdir()
+
+    const a = await Instance.provide({
+      directory: off.path,
+      fn: () => Format.status(),
+    })
+    const b = await Instance.provide({
+      directory: on.path,
+      fn: () => Format.status(),
+    })
+
+    expect(a).toEqual([])
+    expect(b.length).toBeGreaterThan(0)
+  })
+
+  test("runs enabled checks for matching formatters in parallel", async () => {
+    await using tmp = await tmpdir()
+
+    const file = `${tmp.path}/test.parallel`
+    await Bun.write(file, "x")
+
+    const one = {
+      extensions: Formatter.gofmt.extensions,
+      enabled: Formatter.gofmt.enabled,
+      command: Formatter.gofmt.command,
+    }
+    const two = {
+      extensions: Formatter.mix.extensions,
+      enabled: Formatter.mix.enabled,
+      command: Formatter.mix.command,
+    }
+
+    let active = 0
+    let max = 0
+
+    Formatter.gofmt.extensions = [".parallel"]
+    Formatter.mix.extensions = [".parallel"]
+    Formatter.gofmt.command = ["sh", "-c", "true"]
+    Formatter.mix.command = ["sh", "-c", "true"]
+    Formatter.gofmt.enabled = async () => {
+      active++
+      max = Math.max(max, active)
+      await Bun.sleep(20)
+      active--
+      return true
+    }
+    Formatter.mix.enabled = async () => {
+      active++
+      max = Math.max(max, active)
+      await Bun.sleep(20)
+      active--
+      return true
+    }
+
+    try {
+      await withServices(tmp.path, Format.layer, async (rt) => {
+        await rt.runPromise(Format.Service.use((s) => s.init()))
+        await Bus.publish(File.Event.Edited, { file })
+      })
+    } finally {
+      Formatter.gofmt.extensions = one.extensions
+      Formatter.gofmt.enabled = one.enabled
+      Formatter.gofmt.command = one.command
+      Formatter.mix.extensions = two.extensions
+      Formatter.mix.enabled = two.enabled
+      Formatter.mix.command = two.command
+    }
+
+    expect(max).toBe(2)
+  })
+
+  test("runs matching formatters sequentially for the same file", async () => {
+    await using tmp = await tmpdir({
+      config: {
+        formatter: {
+          first: {
+            command: ["sh", "-c", "sleep 0.05; v=$(cat \"$1\"); printf '%sA' \"$v\" > \"$1\"", "sh", "$FILE"],
+            extensions: [".seq"],
+          },
+          second: {
+            command: ["sh", "-c", "v=$(cat \"$1\"); printf '%sB' \"$v\" > \"$1\"", "sh", "$FILE"],
+            extensions: [".seq"],
+          },
+        },
+      },
+    })
+
+    const file = `${tmp.path}/test.seq`
+    await Bun.write(file, "x")
+
+    await withServices(tmp.path, Format.layer, async (rt) => {
+      await rt.runPromise(Format.Service.use((s) => s.init()))
+      await Bus.publish(File.Event.Edited, { file })
+    })
+
+    expect(await Bun.file(file).text()).toBe("xAB")
+  })
 })