@gjermundgaraba/effect-actions 0.10.0 → 0.12.0

package/examples/kitchen-sink/test/identity/identity.test.ts

@@ -0,0 +1,137 @@
+import { describe, expect, it } from "@effect/vitest";
+import { Array, Effect, flow, Layer } from "effect";
+import { HttpClient, HttpClientRequest } from "effect/http";
+import * as Action from "@gjermundgaraba/effect-actions/Action";
+import * as ActionHttp from "@gjermundgaraba/effect-actions/ActionHttp";
+import * as Testing from "@gjermundgaraba/effect-actions/Testing";
+import { Http } from "../../src/Api.js";
+import { Directory } from "../../src/identity/directory.js";
+import { IssuerUnavailable, QuotaExceeded, WhoAmI } from "../../src/identity/Identity.js";
+import { memory } from "../../src/memory.js";
+import { publicRoutes } from "../../src/routes.js";
+
+// What authentication adds on the wire: the public port behind its real providers, answering
+// in memory. A caller is the credential its client sends.
+const served = Testing.layer(publicRoutes).pipe(Layer.provide(memory));
+
+// A test replaces the one service it is about. Provided before `memory`, this layer is the
+// `Directory` the routes are built with; `memory` gives them the rest.
+const servedWith = (directory: Layer.Layer<Directory>) =>
+  Testing.layer(publicRoutes).pipe(Layer.provide(directory), Layer.provide(memory));
+
+// A directory that cannot reach its issuer.
+const issuerDown = Layer.succeed(
+  Directory,
+  Directory.of({
+    ofToken: () => Effect.fail(new IssuerUnavailable({ retryAfterSeconds: 30 })),
+    ofSession: () => Effect.fail(new Action.Unauthenticated()),
+  }),
+);
+
+const as = (token: string, workspace: string) => ({
+  transformClient: HttpClient.mapRequest(
+    flow(
+      HttpClientRequest.bearerToken(token),
+      HttpClientRequest.setHeader("x-workspace", workspace),
+    ),
+  ),
+});
+
+describe("a bearer token", () => {
+  it.effect("makes the caller the member it is in the workspace the request names", () =>
+    Effect.gen(function* () {
+      const atAcme = yield* ActionHttp.client(Http, as("ada", "acme"));
+      const atGlobex = yield* ActionHttp.client(Http, as("ada", "globex"));
+      const elsewhere = yield* ActionHttp.client(Http, as("linus", "globex"));
+
+      expect(yield* atAcme.whoAmI()).toMatchObject({ workspace: "acme" });
+      expect(yield* atGlobex.whoAmI()).toEqual({
+        id: "ada",
+        workspace: "globex",
+        scopes: ["issues:read"],
+      });
+
+      // A member of acme alone, asking for globex: refused, with no scope to step up to.
+      const refused = yield* Effect.flip(elsewhere.whoAmI());
+
+      expect(refused).toBeInstanceOf(Action.Forbidden);
+      expect(refused.message).toBe("Name a workspace you belong to in the X-Workspace header.");
+    }).pipe(Effect.provide(served)),
+  );
+
+  it.effect(
+    "is refused a write it lacks the scope for, by an error and a challenge naming it",
+    () =>
+      Effect.gen(function* () {
+        const reader = yield* ActionHttp.client(Http, as("linus", "acme"));
+
+        const refused = yield* Effect.flip(reader.createIssue({ title: "Crash", body: "" }));
+
+        // `toEqual` compares an error's own fields, here `scopes`; never its `message`.
+        expect(refused).toEqual(new Action.Forbidden({ scopes: ["issues:write"] }));
+        expect(refused.message).toBe("Requires issues:write.");
+
+        // The same refusal as sent: the 403 an OAuth client re-authorizes on.
+        const response = yield* HttpClientRequest.post("/api/v1/closeIssue").pipe(
+          HttpClientRequest.bearerToken("linus"),
+          HttpClientRequest.setHeader("x-workspace", "acme"),
+          HttpClientRequest.bodyJsonUnsafe({ id: "ACME-1" }),
+          HttpClient.execute,
+        );
+
+        expect(response.status).toBe(403);
+        expect(response.headers["www-authenticate"]).toContain(
+          'error="insufficient_scope", scope="issues:write"',
+        );
+      }).pipe(Effect.provide(served)),
+  );
+
+  it.effect("finds where to sign in: published discovery, named in the challenge of a 401", () =>
+    Effect.gen(function* () {
+      const discovery = yield* HttpClient.get("/.well-known/oauth-protected-resource/mcp");
+
+      expect(yield* discovery.json).toMatchObject({
+        resource: "http://localhost:3000/mcp",
+        scopes_supported: ["issues:read", "issues:write"],
+      });
+
+      // A protected tool's call without a token: the endpoint's own 401, before any tool runs.
+      const refused = yield* HttpClient.execute(
+        Testing.mcpRequest("tools/call", { name: "whoAmI", arguments: {} }),
+      );
+
+      expect(refused.status).toBe(401);
+      expect(refused.headers["www-authenticate"]).toBe(
+        'Bearer scope="issues:read", resource_metadata="http://localhost:3000/.well-known/oauth-protected-resource/mcp"',
+      );
+    }).pipe(Effect.provide(served)),
+  );
+
+  it.effect("fails with the verifier's declared error, a typed 503, when the issuer is down", () =>
+    Effect.gen(function* () {
+      const http = yield* ActionHttp.client(Http, as("ada", "acme"));
+      const mcp = yield* Testing.mcpClient([WhoAmI], as("ada", "acme"));
+
+      expect(yield* Effect.flip(http.whoAmI())).toEqual(
+        new IssuerUnavailable({ retryAfterSeconds: 30 }),
+      );
+      // Over MCP it is the endpoint's HTTP answer, before any tool runs, not a tool's result:
+      // the client fails with the error that holds such an answer.
+      expect(yield* Effect.flip(mcp.whoAmI())).toBeInstanceOf(Testing.McpCallError);
+    }).pipe(Effect.provide(servedWith(issuerDown))),
+  );
+});
+
+describe("the request quota", () => {
+  it.effect("is spent per member, and answered as the binding's typed error", () =>
+    Effect.gen(function* () {
+      const ada = yield* ActionHttp.client(Http, as("ada", "acme"));
+      const grace = yield* ActionHttp.client(Http, as("grace", "globex"));
+
+      yield* Effect.forEach(Array.range(1, 60), () => ada.whoAmI());
+
+      expect(yield* Effect.flip(ada.whoAmI())).toBeInstanceOf(QuotaExceeded);
+      expect(yield* grace.whoAmI()).toMatchObject({ id: "grace" });
+    }).pipe(Effect.provide(served)),
+  );
+});

package/examples/kitchen-sink/test/identity/session.test.ts

@@ -0,0 +1,110 @@
+import { describe, expect, it } from "@effect/vitest";
+import { Array, Effect, flow, Layer } from "effect";
+import { HttpClient, HttpClientRequest } from "effect/http";
+import { RpcClient, RpcSerialization, RpcServer } from "effect/rpc";
+import * as Action from "@gjermundgaraba/effect-actions/Action";
+import * as ActionHttp from "@gjermundgaraba/effect-actions/ActionHttp";
+import * as ActionRpc from "@gjermundgaraba/effect-actions/ActionRpc";
+import * as Testing from "@gjermundgaraba/effect-actions/Testing";
+import { Http } from "../../src/Api.js";
+import { QuotaExceeded } from "../../src/identity/Identity.js";
+import { memory } from "../../src/memory.js";
+import { publicRoutes, rpc } from "../../src/routes.js";
+import { Rpc } from "../../src/Rpc.js";
+import { WorkspaceRegistry } from "../../src/workspaces/registry.js";
+
+// The web app's rpcs in memory. The server serves them over a WebSocket; here the same layer
+// is given Effect's HTTP protocol, which a client reaches through `Testing.layer`.
+const server = rpc.pipe(
+  Layer.provide(RpcServer.layerProtocolHttp({ path: "/rpc" })),
+  Layer.provide(RpcSerialization.layerJson),
+);
+
+const protocol = RpcClient.layerProtocolHttp({ url: "/rpc" }).pipe(
+  Layer.provide(RpcSerialization.layerJson),
+);
+
+const socket = protocol.pipe(Layer.provide(Testing.layer(server)));
+
+// `provideMerge`: the test reads the registry the rpcs' verifier reads.
+const served = socket.pipe(Layer.provideMerge(memory));
+
+// The rpcs beside the public port's routes under one `Testing.layer`, as server.ts serves them
+// under one router, there over a WebSocket. `provideMerge`: the test calls the JSON routes
+// with the `HttpClient` the rpc client's protocol is given.
+const servedWithHttp = protocol.pipe(
+  Layer.provideMerge(Testing.layer(Layer.merge(server, publicRoutes))),
+  Layer.provide(memory),
+);
+
+// Each call carries its caller's session cookie, as a browser attaches it, so one client
+// serves several callers. Authentication is per message.
+const as = (session: string) => RpcClient.withHeaders({ cookie: `tracker_session=${session}` });
+
+describe("a session cookie, over RPC", () => {
+  it.effect("authenticates each message", () =>
+    Effect.gen(function* () {
+      const client = yield* ActionRpc.client(Rpc);
+      const issue = yield* client.createIssue({ title: "Crash", body: "" }).pipe(as("ada-at-acme"));
+
+      expect(issue.id).toBe("ACME-1");
+      expect(yield* client.whoAmI().pipe(as("grace-at-globex"))).toMatchObject({
+        workspace: "globex",
+      });
+      expect(yield* client.listIssues().pipe(as("grace-at-globex"))).toEqual({ issues: [] });
+    }).pipe(Effect.scoped, Effect.provide(served)),
+  );
+
+  it.effect("fails a call without a session, or with an unknown one, as a typed refusal", () =>
+    Effect.gen(function* () {
+      const client = yield* ActionRpc.client(Rpc);
+
+      expect(yield* Effect.flip(client.whoAmI())).toBeInstanceOf(Action.Unauthenticated);
+
+      const unknown = yield* Effect.flip(client.whoAmI().pipe(as("stolen")));
+
+      expect(unknown).toBeInstanceOf(Action.Unauthenticated);
+      expect(unknown.message).toBe("Unknown demo session.");
+    }).pipe(Effect.scoped, Effect.provide(served)),
+  );
+
+  it.effect("is refused once its workspace is suspended, as a token is", () =>
+    Effect.gen(function* () {
+      const client = yield* ActionRpc.client(Rpc);
+      const registry = yield* WorkspaceRegistry;
+
+      yield* registry.setSuspended("acme", true);
+
+      const refused = yield* Effect.flip(client.whoAmI().pipe(as("ada-at-acme")));
+
+      expect(refused).toBeInstanceOf(Action.Forbidden);
+      expect(refused.message).toBe("This workspace is suspended.");
+      expect(yield* client.whoAmI().pipe(as("grace-at-globex"))).toMatchObject({ id: "grace" });
+    }).pipe(Effect.scoped, Effect.provide(served)),
+  );
+
+  it.effect("spends the one request quota its member also spends over HTTP", () =>
+    Effect.gen(function* () {
+      const rpcs = yield* ActionRpc.client(Rpc);
+
+      const http = yield* ActionHttp.client(Http, {
+        transformClient: HttpClient.mapRequest(
+          flow(
+            HttpClientRequest.bearerToken("ada"),
+            HttpClientRequest.setHeader("x-workspace", "acme"),
+          ),
+        ),
+      });
+
+      // Sixty requests as ada in acme, half on each surface: each middleware counts, and the
+      // next request is refused on either.
+      yield* Effect.forEach(Array.range(1, 30), () => http.whoAmI());
+      yield* Effect.forEach(Array.range(1, 30), () => rpcs.whoAmI().pipe(as("ada-at-acme")));
+
+      expect(yield* Effect.flip(rpcs.whoAmI().pipe(as("ada-at-acme")))).toBeInstanceOf(
+        QuotaExceeded,
+      );
+      expect(yield* Effect.flip(http.whoAmI())).toBeInstanceOf(QuotaExceeded);
+    }).pipe(Effect.scoped, Effect.provide(servedWithHttp)),
+  );
+});

package/examples/kitchen-sink/test/issues/assistant.test.ts

@@ -0,0 +1,75 @@
+import { describe, expect, it } from "@effect/vitest";
+import { Effect, Layer, Stream } from "effect";
+import { LanguageModel } from "effect/ai";
+import * as Action from "@gjermundgaraba/effect-actions/Action";
+import { CurrentMember } from "../../src/identity/Identity.js";
+import { members } from "../../src/identity/members.js";
+import { layer, toolkit, triage } from "../../src/issues/assistant.js";
+import { issues } from "../../src/issues/handlers.js";
+import { memory } from "../../src/memory.js";
+
+// A model that asks for the same two tools in every turn stands in for a provider's.
+const model = LanguageModel.make({
+  generateText: () =>
+    Effect.succeed([
+      { type: "tool-call", id: "1", name: "getIssue", params: { id: "ACME-1" } },
+      { type: "tool-call", id: "2", name: "closeIssue", params: { id: "ACME-1" } },
+    ] as const),
+  streamText: () => Stream.empty,
+});
+
+const asAda = Effect.provideService(CurrentMember, members.ada);
+
+// The toolkit's handlers and a client of the same implementation, over one store.
+const services = layer.pipe(Layer.provideMerge(memory));
+
+describe("the assistant's tools", () => {
+  it.effect("runs a model's read and holds its write for approval", () =>
+    Effect.gen(function* () {
+      const tracker = yield* Action.client(issues);
+
+      yield* tracker.createIssue({ title: "Crash", body: "" }).pipe(asAda);
+
+      const turn = yield* triage("Close what is done.").pipe(
+        asAda,
+        Effect.provideServiceEffect(LanguageModel.LanguageModel, model),
+      );
+
+      expect(turn.toolResults.map(({ name }) => name)).toEqual(["getIssue"]);
+      expect(
+        turn.content.flatMap((part) =>
+          part.type === "tool-approval-request" ? [part.toolCallId] : [],
+        ),
+      ).toEqual(["2"]);
+      expect(yield* tracker.getIssue({ id: "ACME-1" }).pipe(asAda)).toMatchObject({
+        status: "open",
+      });
+    }).pipe(Effect.provide(services)),
+  );
+
+  it.effect("offers the listed actions alone, and runs `authorize` for a call made by hand", () =>
+    Effect.gen(function* () {
+      const tools = yield* toolkit;
+
+      expect(Object.keys(tools.tools)).toEqual([
+        "listIssues",
+        "getIssue",
+        "commentOnIssue",
+        "closeIssue",
+      ]);
+
+      // `tools.handle` is a caller that is not a model's turn: it asks no approval, and takes
+      // the arguments as JSON. The implementation's `authorize` runs all the same.
+      const refused = yield* tools
+        .handle("closeIssue", { id: "ACME-1" })
+        .pipe(
+          Effect.flatMap(Stream.runCollect),
+          Effect.provideService(CurrentMember, members.linus),
+        );
+
+      expect(refused.map(({ isFailure, result }) => [isFailure, result])).toEqual([
+        [true, new Action.Forbidden({ scopes: ["issues:write"] })],
+      ]);
+    }).pipe(Effect.provide(services)),
+  );
+});

package/examples/kitchen-sink/test/issues/issues.test.ts

@@ -0,0 +1,135 @@
+import { describe, expect, it } from "@effect/vitest";
+import { Array, Effect, Layer, References } from "effect";
+import { RateLimiter } from "effect/persistence";
+import * as Action from "@gjermundgaraba/effect-actions/Action";
+import { CurrentMember } from "../../src/identity/Identity.js";
+import { members } from "../../src/identity/members.js";
+import { issues } from "../../src/issues/handlers.js";
+import { IssueNotFound, Issues, RateLimited } from "../../src/issues/Issues.js";
+import { IssueStore } from "../../src/issues/store.js";
+import { status } from "../../src/workspaces/handlers.js";
+
+// What the implementation does, with no transport: `Action.client` runs the same decoding,
+// `authorize` and handler a server runs. Each call names its caller, as a request would.
+const as = (member: keyof typeof members) => Effect.provideService(CurrentMember, members[member]);
+
+// The two startup services the issues' builder yields, and nothing else of the application.
+const services = Layer.mergeAll(
+  IssueStore.layerMemory,
+  RateLimiter.layer.pipe(Layer.provide(RateLimiter.layerStoreMemory)),
+);
+
+describe("issues, in process", () => {
+  it.effect("keeps each workspace's issues its own", () =>
+    Effect.gen(function* () {
+      const client = yield* Action.client(issues);
+      const issue = yield* client.createIssue({ title: "Crash", body: "On save." }).pipe(as("ada"));
+
+      expect(issue).toMatchObject({ id: "ACME-1", status: "open" });
+      expect(yield* client.listIssues().pipe(as("linus"))).toEqual({
+        issues: [{ id: "ACME-1", title: "Crash", status: "open" }],
+      });
+      expect(yield* client.listIssues().pipe(as("grace"))).toEqual({ issues: [] });
+      expect(yield* Effect.flip(client.getIssue({ id: issue.id }).pipe(as("grace")))).toEqual(
+        new IssueNotFound({ id: "ACME-1" }),
+      );
+    }).pipe(Effect.provide(services)),
+  );
+
+  it.effect("lists twenty by default, newest first, or the status and limit asked for", () =>
+    Effect.gen(function* () {
+      const client = yield* Action.client(issues);
+      const store = yield* IssueStore;
+
+      // Written to the store, not through `createIssue`: twenty-one are over its write limit.
+      yield* Effect.forEach(Array.range(1, 21), (n) =>
+        store.create(members.ada.workspace, { title: `Issue ${n}`, body: "" }),
+      );
+      yield* client.closeIssue({ id: "ACME-2" }).pipe(as("ada"));
+
+      // No argument is the input `{}`: `status` is absent and `limit` its default.
+      const all = yield* client.listIssues().pipe(as("ada"));
+      const closed = yield* client.listIssues({ status: "closed", limit: 20 }).pipe(as("ada"));
+      const newest = yield* client.listIssues({ limit: 1 }).pipe(as("ada"));
+
+      expect(all.issues.map(({ id }) => id)).toEqual(
+        Array.range(2, 21)
+          .map((n) => `ACME-${n}`)
+          .toReversed(),
+      );
+      expect(closed.issues.map(({ id }) => id)).toEqual(["ACME-2"]);
+      expect(newest.issues.map(({ id }) => id)).toEqual(["ACME-21"]);
+    }).pipe(Effect.provide(services)),
+  );
+
+  it.effect("refuses a write from a member holding the read scope alone", () =>
+    Effect.gen(function* () {
+      const client = yield* Action.client(issues);
+      const create = client.createIssue({ title: "Crash", body: "" });
+
+      const refused = yield* Effect.flip(create.pipe(as("linus")));
+
+      // `toEqual` compares an error's own fields, here `scopes`; never its `message`.
+      expect(refused).toEqual(new Action.Forbidden({ scopes: ["issues:write"] }));
+      expect(refused.message).toBe("Requires issues:write.");
+    }).pipe(Effect.provide(services)),
+  );
+
+  it.effect("keeps both of two comments made at once", () =>
+    Effect.gen(function* () {
+      const store = yield* IssueStore;
+      const { workspace } = members.ada;
+
+      // Asked of the store, not through `commentOnIssue`, whose write limit this would spend.
+      // A fiber is set aside after every `steps` steps, and two that run at once then take
+      // turns. Each count sets the first comment aside at another point of its work; under
+      // three, the two do not finish.
+      const kept = yield* Effect.forEach(Array.range(3, 60), (steps) =>
+        Effect.gen(function* () {
+          const { id } = yield* store.create(workspace, { title: "Crash", body: "" });
+
+          yield* Effect.all(
+            ["One", "Two"].map((text) => store.comment(workspace, id, { author: "ada", text })),
+            { concurrency: "unbounded" },
+          ).pipe(Effect.provideService(References.MaxOpsBeforeYield, steps));
+
+          return (yield* store.get(workspace, id)).comments.length;
+        }),
+      );
+
+      expect(kept).toEqual(Array.range(3, 60).map(() => 2));
+    }).pipe(Effect.provide(services)),
+  );
+
+  it.effect("counts every write of a member against one limit, and no one else's", () =>
+    Effect.gen(function* () {
+      const client = yield* Action.client(issues);
+
+      yield* client.createIssue({ title: "Crash", body: "" }).pipe(as("ada"));
+      yield* Effect.forEach(Array.range(1, 9), (n) =>
+        client.commentOnIssue({ id: "ACME-1", text: `Comment ${n}` }).pipe(as("ada")),
+      );
+
+      // Ten writes are spent, by two actions: the eleventh, of a third, is refused.
+      expect(
+        yield* Effect.flip(client.closeIssue({ id: "ACME-1" }).pipe(as("ada"))),
+      ).toBeInstanceOf(RateLimited);
+      expect(yield* client.getIssue({ id: "ACME-1" }).pipe(as("ada"))).toMatchObject({
+        status: "open",
+      });
+      expect(
+        yield* client.createIssue({ title: "Mine", body: "" }).pipe(as("grace")),
+      ).toMatchObject({ id: "GLOBEX-1" });
+    }).pipe(Effect.provide(services)),
+  );
+
+  it.effect("builds only the implementations whose actions a client lists", () =>
+    Effect.gen(function* () {
+      // Two implementations are passed, and `actions` selects the issues': `status` is left
+      // out, unbuilt, so `services` need not hold the registry its builder yields.
+      const client = yield* Action.client([status, issues], { actions: Issues });
+
+      expect(yield* client.listIssues().pipe(as("ada"))).toEqual({ issues: [] });
+    }).pipe(Effect.provide(services)),
+  );
+});

package/examples/kitchen-sink/test/request-policy.test.ts

@@ -0,0 +1,125 @@
+import { afterAll, describe, expect, it } from "@effect/vitest";
+import { Effect, Layer } from "effect";
+import { HttpRouter, HttpServer } from "effect/http";
+import * as ActionHttp from "@gjermundgaraba/effect-actions/ActionHttp";
+import * as Testing from "@gjermundgaraba/effect-actions/Testing";
+import { Http } from "../src/Api.js";
+import { memory } from "../src/memory.js";
+import { adminRoutes, publicRoutes } from "../src/routes.js";
+
+// Each port as a web handler, `Request` in and `Response` out: what a platform without
+// Effect's server runs, and what a test sends raw requests to. A handler builds its routes
+// once; the test owns it, and disposes it when done.
+const web = HttpRouter.toWebHandler(
+  publicRoutes.pipe(Layer.provide(HttpServer.layerServices), Layer.provide(memory)),
+);
+
+const adminWeb = HttpRouter.toWebHandler(
+  adminRoutes.pipe(Layer.provide(HttpServer.layerServices), Layer.provide(memory)),
+);
+
+afterAll(() => Promise.all([web.dispose(), adminWeb.dispose()]));
+
+const post = (url: string, headers: Record<string, string> = {}) =>
+  new Request(url, {
+    method: "POST",
+    headers: { "content-type": "application/json", ...headers },
+    body: "{}",
+  });
+
+const discovery = "/.well-known/oauth-protected-resource/mcp";
+
+describe("the request policy", () => {
+  it("refuses a foreign Host or Origin", async () => {
+    const foreignHost = await web.handler(post("http://tracker.evil.example/api/v1/getStatus"));
+
+    const foreignOrigin = await web.handler(
+      post("http://localhost/api/v1/getStatus", { origin: "http://evil.example" }),
+    );
+
+    expect([foreignHost.status, await foreignHost.text()]).toEqual([403, "Host not allowed"]);
+    expect([foreignOrigin.status, await foreignOrigin.text()]).toEqual([403, "Origin not allowed"]);
+  });
+
+  it("runs before authentication: a foreign Host is refused, not asked to sign in", async () => {
+    const signedOut = await web.handler(post("http://localhost/api/v1/whoAmI"));
+    const foreignHost = await web.handler(post("http://tracker.evil.example/api/v1/whoAmI"));
+
+    expect([signedOut.status, foreignHost.status]).toEqual([401, 403]);
+    expect(foreignHost.headers.get("www-authenticate")).toBeNull();
+  });
+
+  it("runs before the discovery the Bearer provider publishes", async () => {
+    const read = (url: string, headers: Record<string, string> = {}) =>
+      web.handler(new Request(url, { headers }));
+
+    const here = await read(`http://localhost${discovery}`);
+    const foreignHost = await read(`http://tracker.evil.example${discovery}`);
+
+    const foreignOrigin = await read(`http://localhost${discovery}`, {
+      origin: "http://evil.test",
+    });
+
+    expect([here.status, foreignHost.status, foreignOrigin.status]).toEqual([200, 403, 403]);
+  });
+
+  it("answers the browser MCP client's origin, and its CORS preflight", async () => {
+    const allowed = await web.handler(
+      post("http://localhost/api/v1/getStatus", { origin: "http://localhost:6274" }),
+    );
+
+    const preflight = await web.handler(
+      new Request("http://localhost/mcp", {
+        method: "OPTIONS",
+        headers: {
+          origin: "http://localhost:6274",
+          "access-control-request-method": "POST",
+          "access-control-request-headers": "authorization, mcp-protocol-version",
+        },
+      }),
+    );
+
+    expect(allowed.status).toBe(200);
+    expect(allowed.headers.get("access-control-allow-origin")).toBe("http://localhost:6274");
+    expect(preflight.status).toBe(204);
+    expect(preflight.headers.get("access-control-allow-headers")).toContain("MCP-Protocol-Version");
+    expect(allowed.headers.get("access-control-expose-headers")).toContain("Mcp-Session-Id");
+  });
+
+  it("lets a browser client of an MCP revision with sessions end its session", async () => {
+    const preflight = await web.handler(
+      new Request("http://localhost/mcp", {
+        method: "OPTIONS",
+        headers: {
+          origin: "http://localhost:6274",
+          "access-control-request-method": "DELETE",
+          "access-control-request-headers": "authorization, mcp-session-id",
+        },
+      }),
+    );
+
+    expect(preflight.status).toBe(204);
+    expect(preflight.headers.get("access-control-allow-methods")).toContain("DELETE");
+    expect(preflight.headers.get("access-control-allow-headers")).toContain("Mcp-Session-Id");
+  });
+
+  it("covers the admin port too, whatever key a request carries", async () => {
+    const key = { "x-operator-key": "ops-key" };
+    const here = await adminWeb.handler(post("http://localhost/admin/listWorkspaces", key));
+
+    const foreignHost = await adminWeb.handler(
+      post("http://tracker.evil.example/admin/listWorkspaces", key),
+    );
+
+    expect([here.status, foreignHost.status]).toEqual([200, 403]);
+  });
+
+  // `Testing.layer(handler)` gives the typed clients the same handler the raw requests hit.
+  it.effect("leaves the typed client, served from the same web handler, alone", () =>
+    Effect.gen(function* () {
+      const client = yield* ActionHttp.client(Http);
+
+      expect(yield* client.getStatus()).toMatchObject({ service: "tracker", workspaces: 2 });
+    }).pipe(Effect.provide(Testing.layer(web.handler))),
+  );
+});