@gjermundgaraba/effect-actions 0.19.0 → 0.21.0

package/examples/live-rpc/test/routes.test.ts

@@ -1,30 +1,35 @@
 import { describe, expect, it } from "@effect/vitest";
-import { Effect, Layer } from "effect";
-import { RpcClient, RpcSerialization, RpcServer } from "effect/rpc";
 import * as Action from "@gjermundgaraba/effect-actions/Action";
 import * as ActionRpc from "@gjermundgaraba/effect-actions/ActionRpc";
+import * as Event from "@gjermundgaraba/effect-actions/Event";
 import * as Testing from "@gjermundgaraba/effect-actions/Testing";
-import { roomHeader } from "../src/chat/Chat.js";
+import { Effect, Fiber, Layer, Stream } from "effect";
+import { RpcClient, RpcSerialization, RpcServer } from "effect/rpc";
+import { TestClock } from "effect/testing";
+
+import { MessagePosted, roomHeader } from "../src/chat/Chat.js";
 import { MessageStore } from "../src/chat/store.js";
 import { rpc } from "../src/routes.js";
 import { Rpc } from "../src/Rpc.js";
 
 // What the wire adds: the real rpcs, behind their real authentication and middleware,
 // answering in memory. The test gives them Effect's HTTP protocol, not the server's WebSocket,
-// because `Testing.layer` answers HTTP requests; no port is opened.
+// because `Testing.layer` answers HTTP requests; no port is opened. NDJSON, not JSON: over
+// HTTP, JSON sends a response once all its streams end, so a watch would never answer.
 const server = rpc.pipe(
   Layer.provide(RpcServer.layerProtocolHttp({ path: "/rpc" })),
-  Layer.provide(RpcSerialization.layerJson),
+  Layer.provide(RpcSerialization.layerNdjson)
 );
 
 const served = RpcClient.layerProtocolHttp({ url: "/rpc" }).pipe(
-  Layer.provide(RpcSerialization.layerJson),
+  Layer.provide(RpcSerialization.layerNdjson),
   Layer.provide(Testing.layer(server)),
-  Layer.provide(MessageStore.layerMemory),
+  Layer.provide([MessageStore.layerMemory, Event.layerMemory])
 );
 
 // Each call carries its caller's token, so one client serves every caller of a test.
-const as = (token: string) => RpcClient.withHeaders({ authorization: `Bearer ${token}` });
+const as = (token: string) =>
+  RpcClient.withHeaders({ authorization: `Bearer ${token}` });
 
 const inRoom = (room: string) => RpcClient.withHeaders({ [roomHeader]: room });
 
@@ -35,66 +40,145 @@ describe("the chat, over RPC", () => {
       Effect.gen(function* () {
         const client = yield* ActionRpc.client(Rpc);
         const signedOut = yield* Effect.flip(client.readMessages({ after: 0 }));
-        const stranger = yield* Effect.flip(client.readMessages({ after: 0 }).pipe(as("mallory")));
 
-        expect(yield* client.listRooms()).toEqual({ rooms: [] });
+        const stranger = yield* Effect.flip(
+          client.readMessages({ after: 0 }).pipe(as("mallory"))
+        );
+
+        expect(yield* client.listRooms()).toStrictEqual({ rooms: [] });
         expect(signedOut).toBeInstanceOf(Action.Unauthenticated);
         expect(signedOut.message).toBe("A bearer token is required.");
         expect(stranger).toBeInstanceOf(Action.Unauthenticated);
         expect(stranger.message).toBe("Unknown demo token.");
-      }).pipe(Effect.provide(served)),
+      }).pipe(Effect.provide(served))
   );
 
-  it.effect("authenticates each call by its own token: two callers on one client", () =>
-    Effect.gen(function* () {
-      const client = yield* ActionRpc.client(Rpc);
-
-      yield* client.postMessage({ text: "Deploying at noon." }).pipe(as("ada"));
-      yield* client.postMessage({ text: "Ready." }).pipe(as("grace"));
+  it.effect(
+    "authenticates each call by its own token: two callers on one client",
+    () =>
+      Effect.gen(function* () {
+        const client = yield* ActionRpc.client(Rpc);
 
-      expect(yield* client.readMessages({ after: 0 }).pipe(as("grace"))).toEqual({
-        messages: [
-          { id: 1, author: "ada", text: "Deploying at noon." },
-          { id: 2, author: "grace", text: "Ready." },
-        ],
-      });
-    }).pipe(Effect.provide(served)),
+        yield* client
+          .postMessage({ text: "Deploying at noon." })
+          .pipe(as("ada"));
+        yield* client.postMessage({ text: "Ready." }).pipe(as("grace"));
+
+        expect(
+          yield* client.readMessages({ after: 0 }).pipe(as("grace"))
+        ).toStrictEqual({
+          messages: [
+            { id: 1, author: "ada", text: "Deploying at noon." },
+            { id: 2, author: "grace", text: "Ready." },
+          ],
+        });
+      }).pipe(Effect.provide(served))
   );
 
-  it.effect("gives each call the room its header names, and the lobby when it names none", () =>
-    Effect.gen(function* () {
-      const client = yield* ActionRpc.client(Rpc);
-
-      yield* client.postMessage({ text: "Disk is full." }).pipe(as("ada"), inRoom("ops"));
-      yield* client.postMessage({ text: "Hello." }).pipe(as("ada"));
+  it.effect(
+    "gives each call the room its header names, and the lobby when it names none",
+    () =>
+      Effect.gen(function* () {
+        const client = yield* ActionRpc.client(Rpc);
 
-      expect(yield* client.readMessages({ after: 0 }).pipe(as("ada"), inRoom("ops"))).toEqual({
-        messages: [{ id: 1, author: "ada", text: "Disk is full." }],
-      });
-      expect(yield* client.readMessages({ after: 0 }).pipe(as("ada"), inRoom("lobby"))).toEqual({
-        messages: [{ id: 1, author: "ada", text: "Hello." }],
-      });
-    }).pipe(Effect.provide(served)),
+        yield* client
+          .postMessage({ text: "Disk is full." })
+          .pipe(as("ada"), inRoom("ops"));
+        yield* client.postMessage({ text: "Hello." }).pipe(as("ada"));
+
+        expect(
+          yield* client
+            .readMessages({ after: 0 })
+            .pipe(as("ada"), inRoom("ops"))
+        ).toStrictEqual({
+          messages: [{ id: 1, author: "ada", text: "Disk is full." }],
+        });
+        expect(
+          yield* client
+            .readMessages({ after: 0 })
+            .pipe(as("ada"), inRoom("lobby"))
+        ).toStrictEqual({
+          messages: [{ id: 1, author: "ada", text: "Hello." }],
+        });
+      }).pipe(Effect.provide(served))
   );
 
   it.effect("refuses a member a room they have not joined, naming it", () =>
     Effect.gen(function* () {
       const client = yield* ActionRpc.client(Rpc);
-      const read = client.readMessages({ after: 0 }).pipe(as("grace"), inRoom("ops"));
+
+      const read = client
+        .readMessages({ after: 0 })
+        .pipe(as("grace"), inRoom("ops"));
+
       const refused = yield* Effect.flip(read);
 
       expect(refused).toBeInstanceOf(Action.Forbidden);
       expect(refused.message).toBe("Not a member of ops.");
-    }).pipe(Effect.provide(served)),
+    }).pipe(Effect.provide(served))
   );
 
-  it.effect("serves a native RpcGroup: Effect's own client calls the same rpcs", () =>
-    Effect.gen(function* () {
-      // `Rpc.group` is what Effect's RPC tooling takes. Its methods take the payload as sent,
-      // `{}` included; `ActionRpc.client` is the one to write an application with.
-      const native = yield* RpcClient.make(Rpc.group);
+  it.effect(
+    "streams a room's posts to a member watching it, the room named by its header",
+    () =>
+      Effect.gen(function* () {
+        const client = yield* ActionRpc.client(Rpc);
+
+        const watching = yield* client
+          .watch(MessagePosted, {})
+          .pipe(
+            Stream.take(1),
+            Stream.runCollect,
+            as("grace"),
+            inRoom("lobby"),
+            Effect.forkChild
+          );
+
+        // Let the watch take its position through the in-memory socket before anyone posts.
+        yield* Effect.repeat(TestClock.adjust("0 millis"), { times: 10 });
+        yield* client
+          .postMessage({ text: "Disk is full." })
+          .pipe(as("ada"), inRoom("ops"));
+        yield* client
+          .postMessage({ text: "Ready." })
+          .pipe(as("ada"), inRoom("lobby"));
+
+        expect(yield* Fiber.join(watching)).toMatchObject([
+          {
+            _tag: "Occurrence",
+            data: { id: 1, author: "ada", text: "Ready." },
+          },
+        ]);
+      }).pipe(Effect.provide(served))
+  );
+
+  it.effect(
+    "refuses a watch of a room the member has not joined, as it starts",
+    () =>
+      Effect.gen(function* () {
+        const client = yield* ActionRpc.client(Rpc);
+
+        const refused = yield* Effect.flip(
+          Stream.runDrain(client.watch(MessagePosted, {})).pipe(
+            as("grace"),
+            inRoom("ops")
+          )
+        );
+
+        expect(refused).toBeInstanceOf(Action.Forbidden);
+        expect(refused).toMatchObject({ message: "Not a member of ops." });
+      }).pipe(Effect.provide(served))
+  );
+
+  it.effect(
+    "serves a native RpcGroup: Effect's own client calls the same rpcs",
+    () =>
+      Effect.gen(function* () {
+        // `Rpc.group` is what Effect's RPC tooling takes. Its methods take the payload as sent,
+        // `{}` included; `ActionRpc.client` is the one to write an application with.
+        const native = yield* RpcClient.make(Rpc.group);
 
-      expect(yield* native.listRooms({})).toEqual({ rooms: [] });
-    }).pipe(Effect.provide(served)),
+        expect(yield* native.listRooms({})).toStrictEqual({ rooms: [] });
+      }).pipe(Effect.provide(served))
   );
 });

package/examples/live-rpc/test/server.test.ts

@@ -1,11 +1,14 @@
 import { createServer } from "node:http";
+
 import { NodeHttpServer } from "@effect/platform-node";
 import { describe, expect, it } from "@effect/vitest";
-import { Effect, Layer } from "effect";
+import * as Event from "@gjermundgaraba/effect-actions/Event";
+import { Deferred, Effect, Layer } from "effect";
 import { HttpRouter, HttpServer } from "effect/http";
 import { RpcSerialization, RpcServer } from "effect/rpc";
-import { connect } from "../src/page.js";
+
 import { MessageStore } from "../src/chat/store.js";
+import { connect } from "../src/page.js";
 import { rpc } from "../src/routes.js";
 
 // What the socket adds, which no in-memory test reaches: the upgrade, the page's `connect(url)`
@@ -14,18 +17,25 @@ import { rpc } from "../src/routes.js";
 // by side. The server closes with the test's scope.
 const socket = rpc.pipe(
   Layer.provide(RpcServer.layerProtocolWebsocket({ path: "/rpc" })),
-  Layer.provide(RpcSerialization.layerJson),
+  Layer.provide(RpcSerialization.layerJson)
 );
 
 // server.ts allows 64 KiB. A bound this small is passed by a message the contract accepts.
 const maxPayload = 256;
 
-const listening = HttpRouter.serve(socket, { disableLogger: true, disableListenLog: true }).pipe(
+const listening = HttpRouter.serve(socket, {
+  disableLogger: true,
+  disableListenLog: true,
+}).pipe(
   // `provideMerge` keeps `HttpServer` for the test, which reads the port from it.
   Layer.provideMerge(
-    NodeHttpServer.layer(createServer, { host: "127.0.0.1", port: 0, websocket: { maxPayload } }),
+    NodeHttpServer.layer(createServer, {
+      host: "127.0.0.1",
+      port: 0,
+      websocket: { maxPayload },
+    })
   ),
-  Layer.provide(MessageStore.layerMemory),
+  Layer.provide([MessageStore.layerMemory, Event.layerMemory])
 );
 
 // The page's client, on Node's global `WebSocket`. Each test closes it with `Effect.scoped`,
@@ -36,40 +46,91 @@ const chat = Effect.gen(function* () {
 
   return yield* Effect.acquireRelease(
     Effect.sync(() => connect(`${url}/rpc`)),
-    (page) => Effect.promise(() => page.close()),
+    (page) =>
+      Effect.promise(async () => {
+        await page.close();
+      })
   );
 });
 
 describe("the chat, over a WebSocket", () => {
-  it.effect("answers the page's client on a listening port, each call as its token names", () =>
-    Effect.gen(function* () {
-      const page = yield* chat;
-
-      const posted = yield* Effect.promise(() =>
-        page.room("lobby", "ada").post("Deploying at noon."),
-      );
-
-      expect(posted).toEqual({ id: 1, author: "ada", text: "Deploying at noon." });
-      expect(yield* Effect.promise(() => page.room("lobby", "grace").read(0))).toEqual({
-        access: "member",
-        messages: [posted],
-      });
-    }).pipe(Effect.scoped, Effect.provide(listening)),
+  it.effect(
+    "answers the page's client on a listening port, each call as its token names",
+    () =>
+      Effect.gen(function* () {
+        const page = yield* chat;
+
+        const posted = yield* Effect.promise(
+          async () => await page.room("lobby", "ada").post("Deploying at noon.")
+        );
+
+        expect(posted).toStrictEqual({
+          id: 1,
+          author: "ada",
+          text: "Deploying at noon.",
+        });
+        expect(
+          yield* Effect.promise(
+            async () => await page.room("lobby", "grace").read(0)
+          )
+        ).toStrictEqual({
+          access: "member",
+          messages: [posted],
+        });
+      }).pipe(Effect.scoped, Effect.provide(listening))
+  );
+
+  it.effect(
+    "delivers a post to a page watching the room on the same socket, until it stops",
+    () =>
+      Effect.gen(function* () {
+        const page = yield* chat;
+        const received = yield* Deferred.make<string>();
+        const stopped = yield* Deferred.make<string>();
+
+        // From the room's start, id 0, so the post reaches it however soon after the watch it is
+        // sent.
+        const stop = page.room("lobby", "grace").watch(
+          0,
+          (message) => {
+            if (message._tag === "Occurrence") {
+              Deferred.doneUnsafe(received, Effect.succeed(message.data.text));
+            }
+          },
+          (why) => {
+            Deferred.doneUnsafe(stopped, Effect.succeed(why));
+          }
+        );
+
+        yield* Effect.promise(
+          async () => await page.room("lobby", "ada").post("Deploying at noon.")
+        );
+
+        expect(yield* Deferred.await(received)).toBe("Deploying at noon.");
+
+        stop();
+
+        expect(yield* Deferred.await(stopped)).toBe("stopped");
+      }).pipe(Effect.scoped, Effect.provide(listening))
   );
 
-  it.effect("closes the socket on a message over the bound, failing the call that sent it", () =>
-    Effect.gen(function* () {
-      const page = yield* chat;
-      const ada = page.room("lobby", "ada");
+  it.effect(
+    "closes the socket on a message over the bound, failing the call that sent it",
+    () =>
+      Effect.gen(function* () {
+        const page = yield* chat;
+        const ada = page.room("lobby", "ada");
 
-      yield* Effect.promise(() => ada.post("Short."));
+        yield* Effect.promise(async () => await ada.post("Short."));
 
-      // 400 characters are a text the contract accepts and a message over 256 bytes. The server
-      // reads none of it: it closes the socket with 1009, "message too big", and the call fails
-      // with Effect's `RpcClientError`, its reason the socket's close, which no action declares.
-      yield* Effect.promise(() =>
-        expect(ada.post("x".repeat(400))).rejects.toMatchObject({ reason: { code: 1009 } }),
-      );
-    }).pipe(Effect.scoped, Effect.provide(listening)),
+        // 400 characters are a text the contract accepts and a message over 256 bytes. The server
+        // reads none of it: it closes the socket with 1009, "message too big", and the call fails
+        // with Effect's `RpcClientError`, its reason the socket's close, which no action declares.
+        yield* Effect.promise(async () => {
+          await expect(ada.post("x".repeat(400))).rejects.toMatchObject({
+            reason: { code: 1009 },
+          });
+        });
+      }).pipe(Effect.scoped, Effect.provide(listening))
   );
 });

package/examples/mcp-tools/README.md

@@ -1,14 +1,10 @@
 # mcp-tools
 
-An MCP server whose tools wrap one upstream HTTP API: here, a 3D print farm's. It has no
-authentication of its own. It signs in to the farm once, with its own account, and whoever can
-reach it may call every tool, so it runs as a local subprocess of an agent or on a network only
-trusted clients are on.
+An MCP server whose tools wrap one upstream HTTP API: here, a 3D print farm's. It has no authentication of its own. It signs in to the farm once, with its own account, and whoever can reach it may call every tool, so it runs as a local subprocess of an agent or on a network only trusted clients are on.
 
 ## Run it
 
-From the repository root, after `vp install` (from an installed package, see
-[Run one](../README.md#run-one)):
+From the repository root, after `vp install` (from an installed package, see [Run one](../README.md#run-one)):
 
 ```sh
 export FARM_URL=https://farm.example.test FARM_USER=demo FARM_PASSWORD=demo
@@ -23,9 +19,7 @@ echo '{"jsonrpc":"2.0","id":1,"method":"initialize","params":{"protocolVersion":
 vp test examples/mcp-tools
 ```
 
-The farm is a fake, answered in memory, so any URL, user and password work. `ALLOWED_ORIGINS` lists the browser origins the HTTP
-endpoint accepts and answers with CORS headers, comma-separated; `HOST` is the interface it
-listens on.
+The farm is a fake, answered in memory, so any URL, user and password work. `ALLOWED_ORIGINS` lists the browser origins the HTTP endpoint accepts and answers with CORS headers, comma-separated; `HOST` is the interface it listens on.
 
 ## Connect a client
 
@@ -39,10 +33,7 @@ claude mcp add print-farm \
   -- "$PWD/node_modules/.bin/tsx" "$PWD/examples/mcp-tools/src/stdio.ts"
 ```
 
-`node --import tsx` finds `tsx` from the directory the process starts in, which the host
-chooses. So the line names both files by their full path, which `$PWD` gives it when run from
-the repository root; `tsx` runs the `node` on the host's `PATH`. Claude Desktop takes the same
-command as an entry of `mcpServers` in its `claude_desktop_config.json`, the paths written out:
+`node --import tsx` finds `tsx` from the directory the process starts in, which the host chooses. So the line names both files by their full path, which `$PWD` gives it when run from the repository root; `tsx` runs the `node` on the host's `PATH`. Claude Desktop takes the same command as an entry of `mcpServers` in its `claude_desktop_config.json`, the paths written out:
 
 ```json
 {
@@ -60,8 +51,7 @@ command as an entry of `mcpServers` in its `claude_desktop_config.json`, the pat
 }
 ```
 
-By hand, a tool is called with one request, which states its protocol revision, its method
-and its tool's name twice: in the body and in the three `MCP-` headers.
+By hand, a tool is called with one request, which states its protocol revision, its method and its tool's name twice: in the body and in the three `MCP-` headers.
 
 ```sh
 curl http://127.0.0.1:3000/mcp \
@@ -73,11 +63,7 @@ curl http://127.0.0.1:3000/mcp \
   -d '{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"list_printers","arguments":{},"_meta":{"io.modelcontextprotocol/protocolVersion":"2026-07-28","io.modelcontextprotocol/clientInfo":{"name":"curl","version":"0"},"io.modelcontextprotocol/clientCapabilities":{}}}}'
 ```
 
-It answers `{"jsonrpc":"2.0","id":1,"result":{…,"structuredContent":{"printers":[…]},"isError":false}}`.
-Every header is needed, as `ActionMcp.request` builds it, and
-[ActionMcp-failures.md](../../docs/ActionMcp-failures.md) lists what a missing one answers.
-`tools/list` takes the same request with that method, no `MCP-Name` header,
-and no `name` or `arguments`.
+It answers `{"jsonrpc":"2.0","id":1,"result":{…,"structuredContent":{"printers":[…]},"isError":false}}`. Every header is needed, as `ActionMcp.request` builds it, and [ActionMcp-failures.md](../../docs/ActionMcp-failures.md) lists what a missing one answers. `tools/list` takes the same request with that method, no `MCP-Name` header, and no `name` or `arguments`.
 
 ## Layout
 
@@ -101,21 +87,21 @@ test/
 
 ## Where to look
 
-| To see                                                                  | Read                             |
-| ----------------------------------------------------------------------- | -------------------------------- |
-| Public tools described for a model, with field descriptions             | `src/printers/Printers.ts`       |
-| `readOnly`, `title`, `idempotentHint`, and destructive as MCP's default | `src/printers/Printers.ts`       |
-| One declared error shared by every tool                                 | `src/printers/Printers.ts`       |
-| An input a model cannot use to reach another URL                        | `src/printers/Printers.ts`       |
-| A tool answering an image beside other fields                           | `src/printers/Printers.ts`       |
-| An upstream client reading `Config`, signing in once                    | `src/platform/print-farm.ts`     |
-| An upstream's failures mapped to the declared error                     | `src/platform/print-farm.ts`     |
-| A builder yielding a service, and handlers that only delegate           | `src/printers/handlers.ts`       |
-| Server `instructions`, shared by both transports                        | `src/instructions.ts`            |
-| Allowed origins from `Config`, their CORS, and `/healthz`               | `src/routes.ts`                  |
-| A request body limit, and where an unauthenticated server binds         | `src/server.ts`                  |
-| A stdio server whose logs go to stderr                                  | `src/stdio.ts`                   |
-| A fake upstream provided as a Layer, to a test or an entrypoint         | `src/platform/fake-farm.ts`      |
-| Testing tools and the upstream's failure messages in process            | `test/printers/printers.test.ts` |
-| Testing listed hints, an image and the origin check in memory           | `test/routes.test.ts`            |
-| Testing CORS for one configured origin and for several                  | `test/routes.test.ts`            |
+| To see | Read |
+| --- | --- |
+| Public tools described for a model, with field descriptions | `src/printers/Printers.ts` |
+| `readOnly`, `title`, `idempotentHint`, and destructive as MCP's default | `src/printers/Printers.ts` |
+| One declared error shared by every tool | `src/printers/Printers.ts` |
+| An input a model cannot use to reach another URL | `src/printers/Printers.ts` |
+| A tool answering an image beside other fields | `src/printers/Printers.ts` |
+| An upstream client reading `Config`, signing in once | `src/platform/print-farm.ts` |
+| An upstream's failures mapped to the declared error | `src/platform/print-farm.ts` |
+| A builder yielding a service, and handlers that only delegate | `src/printers/handlers.ts` |
+| Server `instructions`, shared by both transports | `src/instructions.ts` |
+| Allowed origins from `Config`, their CORS, and `/healthz` | `src/routes.ts` |
+| A request body limit, and where an unauthenticated server binds | `src/server.ts` |
+| A stdio server whose logs go to stderr | `src/stdio.ts` |
+| A fake upstream provided as a Layer, to a test or an entrypoint | `src/platform/fake-farm.ts` |
+| Testing tools and the upstream's failure messages in process | `test/printers/printers.test.ts` |
+| Testing listed hints, an image and the origin check in memory | `test/routes.test.ts` |
+| Testing CORS for one configured origin and for several | `test/routes.test.ts` |

package/examples/mcp-tools/src/platform/fake-farm.ts

@@ -1,6 +1,8 @@
 import { Buffer } from "node:buffer";
+
 import { Effect, Layer, Option, Schema } from "effect";
 import { HttpClient, HttpClientRequest, HttpClientResponse } from "effect/http";
+
 import type { Printer } from "../printers/Printers.js";
 
 // DEMO ONLY: the farm's HTTP API answered in memory, so the example and its tests run without
@@ -12,19 +14,25 @@ import type { Printer } from "../printers/Printers.js";
 export const picture = Uint8Array.from(
   Buffer.from(
     "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mNkYAAAAAYAAjCB0C8AAAAASUVORK5CYII=",
-    "base64",
-  ),
+    "base64"
+  )
 );
 
 const token = "demo-session";
 
 const Login = Schema.fromJsonString(
-  Schema.Struct({ user: Schema.NonEmptyString, password: Schema.NonEmptyString }),
+  Schema.Struct({
+    user: Schema.NonEmptyString,
+    password: Schema.NonEmptyString,
+  })
 );
 
-const Job = Schema.fromJsonString(Schema.Struct({ file: Schema.NonEmptyString }));
+const Job = Schema.fromJsonString(
+  Schema.Struct({ file: Schema.NonEmptyString })
+);
 
-const refuse = (status: number, error: string) => Response.json({ error }, { status });
+const refuse = (status: number, error: string) =>
+  Response.json({ error }, { status });
 
 export const fakeFarm = Layer.sync(HttpClient.HttpClient, () => {
   const printers = new Map<string, Printer>([
@@ -37,33 +45,46 @@ export const fakeFarm = Layer.sync(HttpClient.HttpClient, () => {
         job: { file: "bracket.gcode", progress: 62 },
       },
     ],
-    ["mk4-2", { id: "mk4-2", name: "MK4 by the window", state: "idle", job: null }],
-    ["mini-1", { id: "mini-1", name: "Mini on the shelf", state: "offline", job: null }],
+    [
+      "mk4-2",
+      { id: "mk4-2", name: "MK4 by the window", state: "idle", job: null },
+    ],
+    [
+      "mini-1",
+      { id: "mini-1", name: "Mini on the shelf", state: "offline", job: null },
+    ],
   ]);
 
   const answer = (
     method: string,
     path: string,
     authorization: string | undefined,
-    body: string,
+    body: string
   ): Response => {
     if (method === "POST" && path === "/api/login") {
-      return Option.match(Schema.decodeUnknownOption(Login)(body), {
+      return Option.match(Schema.decodeOption(Login)(body), {
         onNone: () => refuse(400, "Give a user and a password."),
         onSome: () => Response.json({ token }),
       });
     }
 
-    if (authorization !== `Bearer ${token}`) return refuse(401, "Sign in first.");
+    if (authorization !== `Bearer ${token}`) {
+      return refuse(401, "Sign in first.");
+    }
 
     if (method === "GET" && path === "/api/printers") {
-      return Response.json({ printers: Array.from(printers.values()) });
+      return Response.json({ printers: [...printers.values()] });
     }
 
-    const [id = "", action = ""] = path.replace("/api/printers/", "").split("/");
+    const [id = "", action = ""] = path
+      .replace("/api/printers/", "")
+      .split("/");
+
     const printer = printers.get(id);
 
-    if (printer === undefined) return refuse(404, `No printer has the id ${id}.`);
+    if (printer === undefined) {
+      return refuse(404, `No printer has the id ${id}.`);
+    }
 
     const becomes = (state: Printer["state"], job: Printer["job"]) => {
       const changed = { ...printer, state, job };
@@ -78,38 +99,56 @@ export const fakeFarm = Layer.sync(HttpClient.HttpClient, () => {
     }
 
     switch (`${method} ${action}`) {
-      case "GET ":
+      case "GET ": {
         return Response.json(printer);
-      case "GET camera":
-        return new Response(picture, { headers: { "content-type": "image/png" } });
-      case "POST job":
+      }
+
+      case "GET camera": {
+        return new Response(picture, {
+          headers: { "content-type": "image/png" },
+        });
+      }
+
+      case "POST job": {
         return printer.job === null
-          ? Option.match(Schema.decodeUnknownOption(Job)(body), {
+          ? Option.match(Schema.decodeOption(Job)(body), {
               onNone: () => refuse(400, "Name the file to print."),
               onSome: ({ file }) => becomes("printing", { file, progress: 0 }),
             })
           : refuse(409, `${printer.name} is busy with ${printer.job.file}.`);
+      }
+
       case "POST pause":
-      case "POST resume":
+      case "POST resume": {
         return printer.job === null
           ? refuse(409, `${printer.name} has no job.`)
           : becomes(action === "pause" ? "paused" : "printing", printer.job);
-      case "DELETE job":
+      }
+
+      case "DELETE job": {
         return becomes("idle", null);
-      default:
+      }
+
+      default: {
         return refuse(404, `No such route: ${method} ${path}.`);
+      }
     }
   };
 
   return HttpClient.make((request, url) =>
     Effect.gen(function* () {
       const sent = yield* Effect.orDie(HttpClientRequest.toWeb(request));
-      const body = yield* Effect.promise(() => sent.text());
+      const body = yield* Effect.promise(async () => await sent.text());
 
       return HttpClientResponse.fromWeb(
         request,
-        answer(request.method, url.pathname, request.headers["authorization"], body),
+        answer(
+          request.method,
+          url.pathname,
+          request.headers["authorization"],
+          body
+        )
       );
-    }),
+    })
   );
 });