woozlit 2.3.0 → 2.3.2

package/test/tool/question.test.ts

@@ -1,167 +0,0 @@
-import { describe, expect } from "bun:test"
-import { Effect, Fiber, Layer } from "effect"
-import { QuestionTool } from "../../src/tool/question"
-import { Question } from "../../src/question"
-import { SessionID, MessageID } from "../../src/session/schema"
-import { Agent } from "../../src/agent/agent"
-import * as CrossSpawnSpawner from "../../src/effect/cross-spawn-spawner"
-import { Truncate } from "../../src/tool"
-import { provideTmpdirInstance } from "../fixture/fixture"
-import { testEffect } from "../lib/effect"
-
-const ctx = {
-  sessionID: SessionID.make("ses_test-session"),
-  messageID: MessageID.make("test-message"),
-  callID: "test-call",
-  agent: "test-agent",
-  abort: AbortSignal.any([]),
-  messages: [],
-  metadata: () => Effect.void,
-  ask: () => Effect.void,
-}
-
-const it = testEffect(
-  Layer.mergeAll(Question.defaultLayer, CrossSpawnSpawner.defaultLayer, Truncate.defaultLayer, Agent.defaultLayer),
-)
-
-const pending = Effect.fn("QuestionToolTest.pending")(function* (question: Question.Interface) {
-  for (;;) {
-    const items = yield* question.list()
-    const item = items[0]
-    if (item) return item
-    yield* Effect.sleep("10 millis")
-  }
-})
-
-describe("tool.question", () => {
-  it.live("should successfully execute with valid question parameters", () =>
-    provideTmpdirInstance(() =>
-      Effect.gen(function* () {
-        const question = yield* Question.Service
-        const toolInfo = yield* QuestionTool
-        const tool = yield* toolInfo.init()
-        const questions = [
-          {
-            question: "What is your favorite color?",
-            header: "Color",
-            options: [
-              { label: "Red", description: "The color of passion" },
-              { label: "Blue", description: "The color of sky" },
-            ],
-            multiple: false,
-          },
-        ]
-
-        const fiber = yield* tool.execute({ questions }, ctx).pipe(Effect.forkScoped)
-        const item = yield* pending(question)
-        yield* question.reply({ requestID: item.id, answers: [["Red"]] })
-
-        const result = yield* Fiber.join(fiber)
-        expect(result.title).toBe("Asked 1 question")
-      }),
-    ),
-  )
-
-  it.live("should now pass with a header longer than 12 but less than 30 chars", () =>
-    provideTmpdirInstance(() =>
-      Effect.gen(function* () {
-        const question = yield* Question.Service
-        const toolInfo = yield* QuestionTool
-        const tool = yield* toolInfo.init()
-        const questions = [
-          {
-            question: "What is your favorite animal?",
-            header: "This Header is Over 12",
-            options: [{ label: "Dog", description: "Man's best friend" }],
-          },
-        ]
-
-        const fiber = yield* tool.execute({ questions }, ctx).pipe(Effect.forkScoped)
-        const item = yield* pending(question)
-        yield* question.reply({ requestID: item.id, answers: [["Dog"]] })
-
-        const result = yield* Fiber.join(fiber)
-        expect(result.output).toContain(`"What is your favorite animal?"="Dog"`)
-      }),
-    ),
-  )
-
-  it.live("should auto-resolve to a [Never-Ask] directive when never-ask is on", () =>
-    provideTmpdirInstance(() =>
-      Effect.gen(function* () {
-        const question = yield* Question.Service
-        yield* question.setNeverAsk(true)
-        const toolInfo = yield* QuestionTool
-        const tool = yield* toolInfo.init()
-        const questions = [
-          {
-            question: "Which approach should I take?",
-            header: "Approach",
-            options: [
-              { label: "A", description: "First" },
-              { label: "B", description: "Second" },
-            ],
-          },
-          {
-            question: "And the second one?",
-            header: "Second",
-            options: [{ label: "X", description: "Only" }],
-          },
-        ]
-
-        // No reply is provided: with never-ask on, execute must return without
-        // ever creating a pending question (i.e. it does not block on ask()).
-        const result = yield* tool.execute({ questions }, ctx)
-
-        expect(yield* question.list()).toHaveLength(0)
-        expect(result.title).toBe("Auto-resolved 2 questions")
-        expect(result.output).toContain("[Never-Ask]")
-        expect(result.output).toContain("explicitly state which option you chose")
-        // One auto-answer per question so the UI shows it instead of "(no answer)".
-        expect(result.metadata.answers).toHaveLength(2)
-        expect(result.metadata.answers[0]).toEqual(["[Never-Ask] The model will decide autonomously"])
-      }),
-    ),
-  )
-
-  // intentionally removed the zod validation due to tool call errors, hoping prompting is gonna be good enough
-  //   test("should throw an Error for header exceeding 30 characters", async () => {
-  //     const tool = await QuestionTool.init()
-  //     const questions = [
-  //       {
-  //         question: "What is your favorite animal?",
-  //         header: "This Header is Definitely More Than Thirty Characters Long",
-  //         options: [{ label: "Dog", description: "Man's best friend" }],
-  //       },
-  //     ]
-  //     try {
-  //       await tool.execute({ questions }, ctx)
-  //       // If it reaches here, the test should fail
-  //       expect(true).toBe(false)
-  //     } catch (e: any) {
-  //       expect(e).toBeInstanceOf(Error)
-  //       expect(e.cause).toBeInstanceOf(z.ZodError)
-  //     }
-  //   })
-
-  //   test("should throw an Error for label exceeding 30 characters", async () => {
-  //     const tool = await QuestionTool.init()
-  //     const questions = [
-  //       {
-  //         question: "A question with a very long label",
-  //         header: "Long Label",
-  //         options: [
-  //           { label: "This is a very, very, very long label that will exceed the limit", description: "A description" },
-  //         ],
-  //       },
-  //     ]
-  //     try {
-  //       await tool.execute({ questions }, ctx)
-  //       // If it reaches here, the test should fail
-  //       expect(true).toBe(false)
-  //     } catch (e: any) {
-  //       expect(e).toBeInstanceOf(Error)
-  //       expect(e.cause).toBeInstanceOf(z.ZodError)
-  //     }
-  //   })
-})

package/test/tool/read.test.ts

@@ -1,483 +0,0 @@
-import { afterEach, describe, expect } from "bun:test"
-import { Cause, Effect, Exit, Layer } from "effect"
-import path from "path"
-import { Agent } from "../../src/agent/agent"
-import * as CrossSpawnSpawner from "../../src/effect/cross-spawn-spawner"
-import { AppFileSystem } from "@woozlit/shared/filesystem"
-import { LSP } from "../../src/lsp"
-import { Permission } from "../../src/permission"
-import { Instance } from "../../src/project/instance"
-import { SessionID, MessageID } from "../../src/session/schema"
-import { Instruction } from "../../src/session/instruction"
-import { ReadTool } from "../../src/tool/read"
-import { Truncate } from "../../src/tool"
-import { Tool } from "../../src/tool"
-import { Filesystem } from "../../src/util"
-import { provideInstance, tmpdirScoped } from "../fixture/fixture"
-import { testEffect } from "../lib/effect"
-
-const FIXTURES_DIR = path.join(import.meta.dir, "fixtures")
-
-afterEach(async () => {
-  await Instance.disposeAll()
-})
-
-const ctx = {
-  sessionID: SessionID.make("ses_test"),
-  messageID: MessageID.make(""),
-  callID: "",
-  agent: "build",
-  abort: AbortSignal.any([]),
-  messages: [],
-  metadata: () => Effect.void,
-  ask: () => Effect.void,
-}
-
-const it = testEffect(
-  Layer.mergeAll(
-    Agent.defaultLayer,
-    AppFileSystem.defaultLayer,
-    CrossSpawnSpawner.defaultLayer,
-    Instruction.defaultLayer,
-    LSP.defaultLayer,
-    Truncate.defaultLayer,
-  ),
-)
-
-const init = Effect.fn("ReadToolTest.init")(function* () {
-  const info = yield* ReadTool
-  return yield* info.init()
-})
-
-const run = Effect.fn("ReadToolTest.run")(function* (
-  args: Tool.InferParameters<typeof ReadTool>,
-  next: Tool.Context = ctx,
-) {
-  const tool = yield* init()
-  return yield* tool.execute(args, next)
-})
-
-const exec = Effect.fn("ReadToolTest.exec")(function* (
-  dir: string,
-  args: Tool.InferParameters<typeof ReadTool>,
-  next: Tool.Context = ctx,
-) {
-  return yield* provideInstance(dir)(run(args, next))
-})
-
-const fail = Effect.fn("ReadToolTest.fail")(function* (
-  dir: string,
-  args: Tool.InferParameters<typeof ReadTool>,
-  next: Tool.Context = ctx,
-) {
-  const exit = yield* exec(dir, args, next).pipe(Effect.exit)
-  if (Exit.isFailure(exit)) {
-    const err = Cause.squash(exit.cause)
-    return err instanceof Error ? err : new Error(String(err))
-  }
-  throw new Error("expected read to fail")
-})
-
-const full = (p: string) => (process.platform === "win32" ? Filesystem.normalizePath(p) : p)
-const glob = (p: string) =>
-  process.platform === "win32" ? Filesystem.normalizePathPattern(p) : p.replaceAll("\\", "/")
-const put = Effect.fn("ReadToolTest.put")(function* (p: string, content: string | Buffer | Uint8Array) {
-  const fs = yield* AppFileSystem.Service
-  yield* fs.writeWithDirs(p, content)
-})
-const load = Effect.fn("ReadToolTest.load")(function* (p: string) {
-  const fs = yield* AppFileSystem.Service
-  return yield* fs.readFileString(p)
-})
-const asks = () => {
-  const items: Array<Omit<Permission.Request, "id" | "sessionID" | "tool">> = []
-  return {
-    items,
-    next: {
-      ...ctx,
-      ask: (req: Omit<Permission.Request, "id" | "sessionID" | "tool">) =>
-        Effect.sync(() => {
-          items.push(req)
-        }),
-    },
-  }
-}
-
-describe("tool.read external_directory permission", () => {
-  it.live("allows reading absolute path inside project directory", () =>
-    Effect.gen(function* () {
-      const dir = yield* tmpdirScoped()
-      yield* put(path.join(dir, "test.txt"), "hello world")
-
-      const result = yield* exec(dir, { filePath: path.join(dir, "test.txt") })
-      expect(result.output).toContain("hello world")
-    }),
-  )
-
-  it.live("allows reading file in subdirectory inside project directory", () =>
-    Effect.gen(function* () {
-      const dir = yield* tmpdirScoped()
-      yield* put(path.join(dir, "subdir", "test.txt"), "nested content")
-
-      const result = yield* exec(dir, { filePath: path.join(dir, "subdir", "test.txt") })
-      expect(result.output).toContain("nested content")
-    }),
-  )
-
-  it.live("asks for external_directory permission when reading absolute path outside project", () =>
-    Effect.gen(function* () {
-      const outer = yield* tmpdirScoped()
-      const dir = yield* tmpdirScoped({ git: true })
-      yield* put(path.join(outer, "secret.txt"), "secret data")
-
-      const { items, next } = asks()
-
-      yield* exec(dir, { filePath: path.join(outer, "secret.txt") }, next)
-      const ext = items.find((item) => item.permission === "external_directory")
-      expect(ext).toBeDefined()
-      expect(ext!.patterns).toContain(glob(path.join(outer, "*")))
-    }),
-  )
-
-  if (process.platform === "win32") {
-    it.live("normalizes read permission paths on Windows", () =>
-      Effect.gen(function* () {
-        const dir = yield* tmpdirScoped({ git: true })
-        yield* put(path.join(dir, "test.txt"), "hello world")
-
-        const { items, next } = asks()
-        const target = path.join(dir, "test.txt")
-        const alt = target
-          .replace(/^[A-Za-z]:/, "")
-          .replaceAll("\\", "/")
-          .toLowerCase()
-
-        yield* exec(dir, { filePath: alt }, next)
-        const read = items.find((item) => item.permission === "read")
-        expect(read).toBeDefined()
-        expect(read!.patterns).toEqual([full(target)])
-      }),
-    )
-  }
-
-  it.live("asks for directory-scoped external_directory permission when reading external directory", () =>
-    Effect.gen(function* () {
-      const outer = yield* tmpdirScoped()
-      const dir = yield* tmpdirScoped({ git: true })
-      yield* put(path.join(outer, "external", "a.txt"), "a")
-
-      const { items, next } = asks()
-
-      yield* exec(dir, { filePath: path.join(outer, "external") }, next)
-      const ext = items.find((item) => item.permission === "external_directory")
-      expect(ext).toBeDefined()
-      expect(ext!.patterns).toContain(glob(path.join(outer, "external", "*")))
-    }),
-  )
-
-  it.live("asks for external_directory permission when reading relative path outside project", () =>
-    Effect.gen(function* () {
-      const dir = yield* tmpdirScoped({ git: true })
-
-      const { items, next } = asks()
-
-      yield* fail(dir, { filePath: "../outside.txt" }, next)
-      const ext = items.find((item) => item.permission === "external_directory")
-      expect(ext).toBeDefined()
-    }),
-  )
-
-  it.live("does not ask for external_directory permission when reading inside project", () =>
-    Effect.gen(function* () {
-      const dir = yield* tmpdirScoped({ git: true })
-      yield* put(path.join(dir, "internal.txt"), "internal content")
-
-      const { items, next } = asks()
-
-      yield* exec(dir, { filePath: path.join(dir, "internal.txt") }, next)
-      const ext = items.find((item) => item.permission === "external_directory")
-      expect(ext).toBeUndefined()
-    }),
-  )
-})
-
-describe("tool.read env file permissions", () => {
-  const cases: [string, boolean][] = [
-    [".env", true],
-    [".env.local", true],
-    [".env.production", true],
-    [".env.development.local", true],
-    [".env.example", false],
-    [".envrc", false],
-    ["environment.ts", false],
-  ]
-
-  for (const agentName of ["build", "plan"] as const) {
-    describe(`agent=${agentName}`, () => {
-      for (const [filename, shouldAsk] of cases) {
-        it.live(`${filename} asks=${shouldAsk}`, () =>
-          Effect.gen(function* () {
-            const dir = yield* tmpdirScoped()
-            yield* put(path.join(dir, filename), "content")
-
-            const asked = yield* provideInstance(dir)(
-              Effect.gen(function* () {
-                const agent = yield* Agent.Service
-                const info = yield* agent.get(agentName)
-                let asked = false
-                const next = {
-                  ...ctx,
-                  ask: (req: Omit<Permission.Request, "id" | "sessionID" | "tool">) =>
-                    Effect.sync(() => {
-                      for (const pattern of req.patterns) {
-                        const rule = Permission.evaluate(req.permission, pattern, info.permission)
-                        if (rule.action === "ask" && req.permission === "read") {
-                          asked = true
-                        }
-                        if (rule.action === "deny") {
-                          throw new Permission.DeniedError({ ruleset: info.permission })
-                        }
-                      }
-                    }),
-                }
-
-                yield* run({ filePath: path.join(dir, filename) }, next)
-                return asked
-              }),
-            )
-
-            expect(asked).toBe(shouldAsk)
-          }),
-        )
-      }
-    })
-  }
-})
-
-describe("tool.read truncation", () => {
-  it.live("truncates large file by bytes and sets truncated metadata", () =>
-    Effect.gen(function* () {
-      const dir = yield* tmpdirScoped()
-      const base = yield* load(path.join(FIXTURES_DIR, "models-api.json"))
-      const target = 60 * 1024
-      const content = base.length >= target ? base : base.repeat(Math.ceil(target / base.length))
-      yield* put(path.join(dir, "large.json"), content)
-
-      const result = yield* exec(dir, { filePath: path.join(dir, "large.json") })
-      expect(result.metadata.truncated).toBe(true)
-      expect(result.output).toContain("Output capped at")
-      expect(result.output).toContain("Use offset=")
-    }),
-  )
-
-  it.live("truncates by line count when limit is specified", () =>
-    Effect.gen(function* () {
-      const dir = yield* tmpdirScoped()
-      const lines = Array.from({ length: 100 }, (_, i) => `line${i}`).join("\n")
-      yield* put(path.join(dir, "many-lines.txt"), lines)
-
-      const result = yield* exec(dir, { filePath: path.join(dir, "many-lines.txt"), limit: 10 })
-      expect(result.metadata.truncated).toBe(true)
-      expect(result.output).toContain("Showing lines 1-10 of 100")
-      expect(result.output).toContain("Use offset=11")
-      expect(result.output).toContain("line0")
-      expect(result.output).toContain("line9")
-      expect(result.output).not.toContain("line10")
-    }),
-  )
-
-  it.live("does not truncate small file", () =>
-    Effect.gen(function* () {
-      const dir = yield* tmpdirScoped()
-      yield* put(path.join(dir, "small.txt"), "hello world")
-
-      const result = yield* exec(dir, { filePath: path.join(dir, "small.txt") })
-      expect(result.metadata.truncated).toBe(false)
-      expect(result.output).toContain("End of file")
-    }),
-  )
-
-  it.live("respects offset parameter", () =>
-    Effect.gen(function* () {
-      const dir = yield* tmpdirScoped()
-      const lines = Array.from({ length: 20 }, (_, i) => `line${i + 1}`).join("\n")
-      yield* put(path.join(dir, "offset.txt"), lines)
-
-      const result = yield* exec(dir, { filePath: path.join(dir, "offset.txt"), offset: 10, limit: 5 })
-      expect(result.output).toContain("10: line10")
-      expect(result.output).toContain("14: line14")
-      expect(result.output).not.toContain("9: line10")
-      expect(result.output).not.toContain("15: line15")
-      expect(result.output).toContain("line10")
-      expect(result.output).toContain("line14")
-      expect(result.output).not.toContain("line0")
-      expect(result.output).not.toContain("line15")
-    }),
-  )
-
-  it.live("throws when offset is beyond end of file", () =>
-    Effect.gen(function* () {
-      const dir = yield* tmpdirScoped()
-      const lines = Array.from({ length: 3 }, (_, i) => `line${i + 1}`).join("\n")
-      yield* put(path.join(dir, "short.txt"), lines)
-
-      const err = yield* fail(dir, { filePath: path.join(dir, "short.txt"), offset: 4, limit: 5 })
-      expect(err.message).toContain("Offset 4 is out of range for this file (3 lines)")
-    }),
-  )
-
-  it.live("allows reading empty file at default offset", () =>
-    Effect.gen(function* () {
-      const dir = yield* tmpdirScoped()
-      yield* put(path.join(dir, "empty.txt"), "")
-
-      const result = yield* exec(dir, { filePath: path.join(dir, "empty.txt") })
-      expect(result.metadata.truncated).toBe(false)
-      expect(result.output).toContain("End of file - total 0 lines")
-    }),
-  )
-
-  it.live("throws when offset > 1 for empty file", () =>
-    Effect.gen(function* () {
-      const dir = yield* tmpdirScoped()
-      yield* put(path.join(dir, "empty.txt"), "")
-
-      const err = yield* fail(dir, { filePath: path.join(dir, "empty.txt"), offset: 2 })
-      expect(err.message).toContain("Offset 2 is out of range for this file (0 lines)")
-    }),
-  )
-
-  it.live("does not mark final directory page as truncated", () =>
-    Effect.gen(function* () {
-      const dir = yield* tmpdirScoped()
-      yield* Effect.forEach(
-        Array.from({ length: 10 }, (_, i) => i),
-        (i) => put(path.join(dir, "dir", `file-${i + 1}.txt`), `line${i}`),
-        {
-          concurrency: "unbounded",
-        },
-      )
-
-      const result = yield* exec(dir, { filePath: path.join(dir, "dir"), offset: 6, limit: 5 })
-      expect(result.metadata.truncated).toBe(false)
-      expect(result.output).not.toContain("Showing 5 of 10 entries")
-    }),
-  )
-
-  it.live("truncates long lines", () =>
-    Effect.gen(function* () {
-      const dir = yield* tmpdirScoped()
-      yield* put(path.join(dir, "long-line.txt"), "x".repeat(3000))
-
-      const result = yield* exec(dir, { filePath: path.join(dir, "long-line.txt") })
-      expect(result.output).toContain("(line truncated to 2000 chars)")
-      expect(result.output.length).toBeLessThan(3000)
-    }),
-  )
-
-  it.live("image files set truncated to false", () =>
-    Effect.gen(function* () {
-      const dir = yield* tmpdirScoped()
-      const png = Buffer.from(
-        "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mP8z8DwHwAFBQIAX8jx0gAAAABJRU5ErkJggg==",
-        "base64",
-      )
-      yield* put(path.join(dir, "image.png"), png)
-
-      const result = yield* exec(dir, { filePath: path.join(dir, "image.png") })
-      expect(result.metadata.truncated).toBe(false)
-      expect(result.attachments).toBeDefined()
-      expect(result.attachments?.length).toBe(1)
-      expect(result.attachments?.[0]).not.toHaveProperty("id")
-      expect(result.attachments?.[0]).not.toHaveProperty("sessionID")
-      expect(result.attachments?.[0]).not.toHaveProperty("messageID")
-    }),
-  )
-
-  it.live("detects attachment media from file contents", () =>
-    Effect.gen(function* () {
-      const dir = yield* tmpdirScoped()
-      const jpeg = Buffer.from([0xff, 0xd8, 0xff, 0xe0, 0x00, 0x10, 0x4a, 0x46, 0x49, 0x46, 0x00, 0x01])
-      yield* put(path.join(dir, "image.bin"), jpeg)
-
-      const result = yield* exec(dir, { filePath: path.join(dir, "image.bin") })
-      expect(result.output).toBe("Image read successfully")
-      expect(result.attachments?.[0].mime).toBe("image/jpeg")
-      expect(result.attachments?.[0].url.startsWith("data:image/jpeg;base64,")).toBe(true)
-    }),
-  )
-
-  it.live("large image files are properly attached without error", () =>
-    Effect.gen(function* () {
-      const result = yield* exec(FIXTURES_DIR, { filePath: path.join(FIXTURES_DIR, "large-image.png") })
-      expect(result.metadata.truncated).toBe(false)
-      expect(result.attachments).toBeDefined()
-      expect(result.attachments?.length).toBe(1)
-      expect(result.attachments?.[0].type).toBe("file")
-      expect(result.attachments?.[0]).not.toHaveProperty("id")
-      expect(result.attachments?.[0]).not.toHaveProperty("sessionID")
-      expect(result.attachments?.[0]).not.toHaveProperty("messageID")
-    }),
-  )
-
-  it.live(".fbs files (FlatBuffers schema) are read as text, not images", () =>
-    Effect.gen(function* () {
-      const dir = yield* tmpdirScoped()
-      const fbs = `namespace MyGame;
-
-table Monster {
-  pos:Vec3;
-  name:string;
-  inventory:[ubyte];
-}
-
-root_type Monster;`
-      yield* put(path.join(dir, "schema.fbs"), fbs)
-
-      const result = yield* exec(dir, { filePath: path.join(dir, "schema.fbs") })
-      expect(result.attachments).toBeUndefined()
-      expect(result.output).toContain("namespace MyGame")
-      expect(result.output).toContain("table Monster")
-    }),
-  )
-})
-
-describe("tool.read loaded instructions", () => {
-  it.live("loads AGENTS.md from parent directory and includes in metadata", () =>
-    Effect.gen(function* () {
-      const dir = yield* tmpdirScoped()
-      yield* put(path.join(dir, "subdir", "AGENTS.md"), "# Test Instructions\nDo something special.")
-      yield* put(path.join(dir, "subdir", "nested", "test.txt"), "test content")
-
-      const result = yield* exec(dir, { filePath: path.join(dir, "subdir", "nested", "test.txt") })
-      expect(result.output).toContain("test content")
-      expect(result.output).toContain("system-reminder")
-      expect(result.output).toContain("Test Instructions")
-      expect(result.metadata.loaded).toBeDefined()
-      expect(result.metadata.loaded).toContain(path.join(dir, "subdir", "AGENTS.md"))
-    }),
-  )
-})
-
-describe("tool.read binary detection", () => {
-  it.live("rejects text extension files with null bytes", () =>
-    Effect.gen(function* () {
-      const dir = yield* tmpdirScoped()
-      const bytes = Buffer.from([0x68, 0x65, 0x6c, 0x6c, 0x6f, 0x00, 0x77, 0x6f, 0x72, 0x6c, 0x64])
-      yield* put(path.join(dir, "null-byte.txt"), bytes)
-
-      const err = yield* fail(dir, { filePath: path.join(dir, "null-byte.txt") })
-      expect(err.message).toContain("Cannot read binary file")
-    }),
-  )
-
-  it.live("rejects known binary extensions", () =>
-    Effect.gen(function* () {
-      const dir = yield* tmpdirScoped()
-      yield* put(path.join(dir, "module.wasm"), "not really wasm")
-
-      const err = yield* fail(dir, { filePath: path.join(dir, "module.wasm") })
-      expect(err.message).toContain("Cannot read binary file")
-    }),
-  )
-})