@gjermundgaraba/effect-actions 0.20.0 → 0.21.0

package/examples/notes-service/test/notes/in-process.test.ts

@@ -1,6 +1,7 @@
 import { describe, expect, it } from "@effect/vitest";
-import { Effect } from "effect";
 import * as Action from "@gjermundgaraba/effect-actions/Action";
+import { Effect } from "effect";
+
 import { CurrentUser } from "../../src/identity/Identity.js";
 import { users } from "../../src/identity/users.js";
 import { notes } from "../../src/notes/handlers.js";
@@ -10,31 +11,41 @@ import { NoteStore } from "../../src/notes/store.js";
 // What the implementation does, with no transport: `Action.client` runs the same decoding,
 // `authorize` and handler a server runs. The caller is provided around each call, as a server
 // provides it per request.
-const as = (user: keyof typeof users) => Effect.provideService(CurrentUser, users[user]);
+const as = (user: keyof typeof users) =>
+  Effect.provideService(CurrentUser, users[user]);
 
 describe("notes, in process", () => {
   it.effect("keeps each user's notes their own", () =>
     Effect.gen(function* () {
       const client = yield* Action.client(notes);
-      const note = yield* client.createNote({ title: "Plan", body: "Draft" }).pipe(as("ada"));
 
-      expect(yield* client.listNotes().pipe(as("ada"))).toEqual({
+      const note = yield* client
+        .createNote({ title: "Plan", body: "Draft" })
+        .pipe(as("ada"));
+
+      expect(yield* client.listNotes().pipe(as("ada"))).toStrictEqual({
         notes: [{ id: note.id, title: "Plan" }],
       });
-      expect(yield* client.listNotes().pipe(as("grace"))).toEqual({ notes: [] });
+      expect(yield* client.listNotes().pipe(as("grace"))).toStrictEqual({
+        notes: [],
+      });
 
       const missing = new NoteNotFound({ id: note.id });
       const update = { id: note.id, body: "Mine now", revision: note.revision };
 
-      expect(yield* Effect.flip(client.getNote({ id: note.id }).pipe(as("grace")))).toEqual(
-        missing,
-      );
-      expect(yield* Effect.flip(client.updateNote(update).pipe(as("grace")))).toEqual(missing);
-      expect(yield* Effect.flip(client.deleteNote({ id: note.id }).pipe(as("grace")))).toEqual(
-        missing,
-      );
-      expect(yield* client.getNote({ id: note.id }).pipe(as("ada"))).toEqual(note);
-    }).pipe(Effect.provide(NoteStore.layerMemory)),
+      expect(
+        yield* Effect.flip(client.getNote({ id: note.id }).pipe(as("grace")))
+      ).toStrictEqual(missing);
+      expect(
+        yield* Effect.flip(client.updateNote(update).pipe(as("grace")))
+      ).toStrictEqual(missing);
+      expect(
+        yield* Effect.flip(client.deleteNote({ id: note.id }).pipe(as("grace")))
+      ).toStrictEqual(missing);
+      expect(
+        yield* client.getNote({ id: note.id }).pipe(as("ada"))
+      ).toStrictEqual(note);
+    }).pipe(Effect.provide(NoteStore.layerMemory))
   );
 
   it.effect("refuses a write from a caller holding the read scope alone", () =>
@@ -45,6 +56,6 @@ describe("notes, in process", () => {
 
       expect(refusal).toBeInstanceOf(Action.Forbidden);
       expect(refusal.message).toBe("Requires notes:write.");
-    }).pipe(Effect.provide(NoteStore.layerMemory)),
+    }).pipe(Effect.provide(NoteStore.layerMemory))
   );
 });

package/examples/notes-service/test/notes/notes.test.ts

@@ -1,6 +1,7 @@
 import { describe, expect, it } from "@effect/vitest";
-import { Array, Effect, Exit, References } from "effect";
 import * as Action from "@gjermundgaraba/effect-actions/Action";
+import { Array, Effect, Exit, References } from "effect";
+
 import { notes } from "../../src/notes/handlers.js";
 import { NoteChanged, NoteNotFound } from "../../src/notes/Notes.js";
 import { NoteStore } from "../../src/notes/store.js";
@@ -13,52 +14,69 @@ describe("notes, in process", () => {
   it.effect("deletes a note for its owner", () =>
     Effect.gen(function* () {
       const client = yield* Action.client(notes);
-      const note = yield* client.createNote({ title: "Plan", body: "Draft" }).pipe(as("ada"));
+
+      const note = yield* client
+        .createNote({ title: "Plan", body: "Draft" })
+        .pipe(as("ada"));
 
       yield* client.deleteNote({ id: note.id }).pipe(as("ada"));
 
-      expect(yield* Effect.flip(client.getNote({ id: note.id }).pipe(as("ada")))).toEqual(
-        new NoteNotFound({ id: note.id }),
-      );
-    }).pipe(Effect.provide(NoteStore.layerMemory)),
+      expect(
+        yield* Effect.flip(client.getNote({ id: note.id }).pipe(as("ada")))
+      ).toStrictEqual(new NoteNotFound({ id: note.id }));
+    }).pipe(Effect.provide(NoteStore.layerMemory))
   );
 
   it.effect("refuses an update of a revision that is no longer current", () =>
     Effect.gen(function* () {
       const client = yield* Action.client(notes);
-      const note = yield* client.createNote({ title: "Plan", body: "Draft" }).pipe(as("ada"));
+
+      const note = yield* client
+        .createNote({ title: "Plan", body: "Draft" })
+        .pipe(as("ada"));
+
       const update = { id: note.id, body: "Final", revision: note.revision };
 
-      expect(yield* client.updateNote(update).pipe(as("ada"))).toMatchObject({ revision: 2 });
-      expect(yield* Effect.flip(client.updateNote(update).pipe(as("ada")))).toEqual(
-        new NoteChanged({ id: note.id, revision: 2 }),
-      );
-    }).pipe(Effect.provide(NoteStore.layerMemory)),
+      expect(yield* client.updateNote(update).pipe(as("ada"))).toMatchObject({
+        revision: 2,
+      });
+      expect(
+        yield* Effect.flip(client.updateNote(update).pipe(as("ada")))
+      ).toStrictEqual(new NoteChanged({ id: note.id, revision: 2 }));
+    }).pipe(Effect.provide(NoteStore.layerMemory))
   );
 
-  it.effect("lets one of two concurrent updates of the same revision through", () =>
-    Effect.gen(function* () {
-      const client = yield* Action.client(notes);
+  it.effect(
+    "lets one of two concurrent updates of the same revision through",
+    () =>
+      Effect.gen(function* () {
+        const client = yield* Action.client(notes);
 
-      // A fiber is set aside after every `steps` steps, and two that run at once then take
-      // turns. Each count sets the first update aside at another point of its work; under
-      // three, the two do not finish.
-      const succeeded = yield* Effect.forEach(Array.range(3, 60), (steps) =>
-        Effect.gen(function* () {
-          const note = yield* client.createNote({ title: "Plan", body: "Draft" }).pipe(as("ada"));
+        // A fiber is set aside after every `steps` steps, and two that run at once then take
+        // turns. Each count sets the first update aside at another point of its work; under
+        // three, the two do not finish.
+        const succeeded = yield* Effect.forEach(Array.range(3, 60), (steps) =>
+          Effect.gen(function* () {
+            const note = yield* client
+              .createNote({ title: "Plan", body: "Draft" })
+              .pipe(as("ada"));
 
-          const update = (body: string) =>
-            Effect.exit(client.updateNote({ id: note.id, body, revision: 1 }).pipe(as("ada")));
+            const update = (body: string) =>
+              Effect.exit(
+                client
+                  .updateNote({ id: note.id, body, revision: 1 })
+                  .pipe(as("ada"))
+              );
 
-          const exits = yield* Effect.all([update("One"), update("Two")], {
-            concurrency: "unbounded",
-          }).pipe(Effect.provideService(References.MaxOpsBeforeYield, steps));
+            const exits = yield* Effect.all([update("One"), update("Two")], {
+              concurrency: "unbounded",
+            }).pipe(Effect.provideService(References.MaxOpsBeforeYield, steps));
 
-          return exits.filter(Exit.isSuccess).length;
-        }),
-      );
+            return exits.filter(Exit.isSuccess).length;
+          })
+        );
 
-      expect(succeeded).toEqual(Array.range(3, 60).map(() => 1));
-    }).pipe(Effect.provide(NoteStore.layerMemory)),
+        expect(succeeded).toStrictEqual(Array.range(3, 60).map(() => 1));
+      }).pipe(Effect.provide(NoteStore.layerMemory))
   );
 });

package/examples/notes-service/test/routes.test.ts

@@ -1,10 +1,11 @@
 import { describe, expect, it } from "@effect/vitest";
-import { Effect, Layer } from "effect";
-import { HttpClient, HttpClientError, HttpClientRequest } from "effect/http";
 import * as Action from "@gjermundgaraba/effect-actions/Action";
 import * as ActionHttp from "@gjermundgaraba/effect-actions/ActionHttp";
 import * as ActionMcp from "@gjermundgaraba/effect-actions/ActionMcp";
 import * as Testing from "@gjermundgaraba/effect-actions/Testing";
+import { Effect, Layer } from "effect";
+import { HttpClient, HttpClientError, HttpClientRequest } from "effect/http";
+
 import { Http } from "../src/Api.js";
 import { Notes } from "../src/notes/Notes.js";
 import { NoteStore } from "../src/notes/store.js";
@@ -22,13 +23,20 @@ const as = (token: string) => ({
 });
 
 describe("the service, over HTTP and MCP", () => {
-  it.effect("answers the public action without a token and refuses a protected one", () =>
-    Effect.gen(function* () {
-      const anyone = yield* ActionHttp.client(Http);
-
-      expect(yield* anyone.getStatus()).toEqual({ service: "notes-service", notes: 0 });
-      expect(yield* Effect.flip(anyone.whoAmI())).toBeInstanceOf(Action.Unauthenticated);
-    }).pipe(Effect.provide(served)),
+  it.effect(
+    "answers the public action without a token and refuses a protected one",
+    () =>
+      Effect.gen(function* () {
+        const anyone = yield* ActionHttp.client(Http);
+
+        expect(yield* anyone.getStatus()).toStrictEqual({
+          service: "notes-service",
+          notes: 0,
+        });
+        expect(yield* Effect.flip(anyone.whoAmI())).toBeInstanceOf(
+          Action.Unauthenticated
+        );
+      }).pipe(Effect.provide(served))
   );
 
   it.effect("refuses a token no user holds", () =>
@@ -39,7 +47,7 @@ describe("the service, over HTTP and MCP", () => {
 
       expect(refusal).toBeInstanceOf(Action.Unauthenticated);
       expect(refusal.message).toBe("Unknown demo token.");
-    }).pipe(Effect.provide(served)),
+    }).pipe(Effect.provide(served))
   );
 
   it.effect("serves the host's own routes beside the actions'", () =>
@@ -49,78 +57,105 @@ describe("the service, over HTTP and MCP", () => {
 
       expect(yield* health.text).toBe("ok");
       expect(yield* openApi.text).toContain('"/api/createNote"');
-    }).pipe(Effect.provide(served)),
+    }).pipe(Effect.provide(served))
   );
 
-  it.effect("names the scope a caller lacks, so an OAuth client can ask for it", () =>
-    Effect.gen(function* () {
-      const reader = yield* ActionHttp.client(Http, as("reader"));
+  it.effect(
+    "names the scope a caller lacks, so an OAuth client can ask for it",
+    () =>
+      Effect.gen(function* () {
+        const reader = yield* ActionHttp.client(Http, as("reader"));
 
-      expect(yield* reader.whoAmI()).toEqual({ id: "reader", scopes: ["notes:read"] });
+        expect(yield* reader.whoAmI()).toStrictEqual({
+          id: "reader",
+          scopes: ["notes:read"],
+        });
 
-      const refusal = yield* Effect.flip(reader.createNote({ title: "Plan", body: "" }));
+        const refusal = yield* Effect.flip(
+          reader.createNote({ title: "Plan", body: "" })
+        );
 
-      expect(refusal).toBeInstanceOf(Action.Forbidden);
-      expect(refusal).toHaveProperty("scopes", ["notes:write"]);
-    }).pipe(Effect.provide(served)),
+        expect(refusal).toBeInstanceOf(Action.Forbidden);
+        expect(refusal).toHaveProperty("scopes", ["notes:write"]);
+      }).pipe(Effect.provide(served))
   );
 
-  it.effect("serves one store to both surfaces: a note written over HTTP is read as a tool", () =>
-    Effect.gen(function* () {
-      const http = yield* ActionHttp.client(Http, as("ada"));
-      const mcp = yield* ActionMcp.client([GetStatus, ...Notes], as("ada"));
-      const note = yield* http.createNote({ title: "Plan", body: "Draft" });
-
-      expect(yield* mcp.getNote({ id: note.id })).toEqual(note);
-      expect(yield* mcp.getStatus()).toEqual({ service: "notes-service", notes: 1 });
-    }).pipe(Effect.provide(served)),
+  it.effect(
+    "serves one store to both surfaces: a note written over HTTP is read as a tool",
+    () =>
+      Effect.gen(function* () {
+        const http = yield* ActionHttp.client(Http, as("ada"));
+        const mcp = yield* ActionMcp.client([GetStatus, ...Notes], as("ada"));
+        const note = yield* http.createNote({ title: "Plan", body: "Draft" });
+
+        expect(yield* mcp.getNote({ id: note.id })).toStrictEqual(note);
+        expect(yield* mcp.getStatus()).toStrictEqual({
+          service: "notes-service",
+          notes: 1,
+        });
+      }).pipe(Effect.provide(served))
   );
 
-  it.effect("lists protected tools to a signed-out MCP client, as one tool is public", () =>
-    Effect.gen(function* () {
-      const response = yield* HttpClient.execute(ActionMcp.request("tools/list"));
-
-      expect(response.status).toBe(200);
-      expect(yield* response.text).toContain('"name":"createNote"');
-    }).pipe(Effect.provide(served)),
+  it.effect(
+    "lists protected tools to a signed-out MCP client, as one tool is public",
+    () =>
+      Effect.gen(function* () {
+        const response = yield* HttpClient.execute(
+          ActionMcp.request("tools/list")
+        );
+
+        expect(response.status).toBe(200);
+        expect(yield* response.text).toContain('"name":"createNote"');
+      }).pipe(Effect.provide(served))
   );
 
-  it.effect("retries a committed HTTP write over MCP after its response is lost", () =>
-    Effect.gen(function* () {
-      const http = yield* ActionHttp.client(Http, {
-        transformClient: (client) =>
-          client.pipe(
-            as("ada").transformClient,
-            // The real server finishes the write, but the caller receives no response.
-            HttpClient.transform((response, request) =>
-              response.pipe(
-                Effect.andThen(
-                  Effect.fail(
-                    new HttpClientError.HttpClientError({
-                      reason: new HttpClientError.TransportError({
-                        request,
-                        description: "Response lost after commit",
-                      }),
-                    }),
-                  ),
-                ),
-              ),
+  it.effect(
+    "retries a committed HTTP write over MCP after its response is lost",
+    () =>
+      Effect.gen(function* () {
+        const http = yield* ActionHttp.client(Http, {
+          transformClient: (client) =>
+            client.pipe(
+              as("ada").transformClient,
+              // The real server finishes the write, but the caller receives no response.
+              HttpClient.transform((response, request) =>
+                response.pipe(
+                  Effect.andThen(
+                    Effect.fail(
+                      new HttpClientError.HttpClientError({
+                        reason: new HttpClientError.TransportError({
+                          request,
+                          description: "Response lost after commit",
+                        }),
+                      })
+                    )
+                  )
+                )
+              )
             ),
-          ),
-      });
-
-      const mcp = yield* ActionMcp.client([GetStatus, ...Notes], as("ada"));
-      const input = { requestId: "plan", title: "Plan", body: "Draft" };
-
-      expect(yield* Effect.flip(http.createNote(input))).toBeInstanceOf(
-        HttpClientError.HttpClientError,
-      );
-      expect(yield* mcp.getStatus()).toEqual({ service: "notes-service", notes: 1 });
-
-      const replay = yield* mcp.createNote(input);
-
-      expect(replay).toMatchObject({ title: "Plan", body: "Draft", revision: 1 });
-      expect(yield* mcp.listNotes()).toEqual({ notes: [{ id: replay.id, title: "Plan" }] });
-    }).pipe(Effect.provide(served)),
+        });
+
+        const mcp = yield* ActionMcp.client([GetStatus, ...Notes], as("ada"));
+        const input = { requestId: "plan", title: "Plan", body: "Draft" };
+
+        expect(yield* Effect.flip(http.createNote(input))).toBeInstanceOf(
+          HttpClientError.HttpClientError
+        );
+        expect(yield* mcp.getStatus()).toStrictEqual({
+          service: "notes-service",
+          notes: 1,
+        });
+
+        const replay = yield* mcp.createNote(input);
+
+        expect(replay).toMatchObject({
+          title: "Plan",
+          body: "Draft",
+          revision: 1,
+        });
+        expect(yield* mcp.listNotes()).toStrictEqual({
+          notes: [{ id: replay.id, title: "Plan" }],
+        });
+      }).pipe(Effect.provide(served))
   );
 });

package/examples/notes-service/test/worker.test.ts

@@ -1,9 +1,10 @@
 import { describe, expect, it } from "@effect/vitest";
-import { Effect } from "effect";
-import { HttpClient, HttpClientRequest } from "effect/http";
 import * as Action from "@gjermundgaraba/effect-actions/Action";
 import * as ActionMcp from "@gjermundgaraba/effect-actions/ActionMcp";
 import * as Testing from "@gjermundgaraba/effect-actions/Testing";
+import { Effect } from "effect";
+import { HttpClient, HttpClientRequest } from "effect/http";
+
 import { CreateNote, GetNote } from "../src/notes/Notes.js";
 import { GetStatus } from "../src/status/Status.js";
 import worker from "../src/worker.js";
@@ -16,19 +17,26 @@ const as = (token: string) => ({
 });
 
 describe("the worker", () => {
-  it.effect("serves the tools, each request as the caller it authenticates", () =>
-    Effect.gen(function* () {
-      const anyone = yield* ActionMcp.client([GetStatus, GetNote]);
-      const ada = yield* ActionMcp.client([CreateNote, GetNote], as("ada"));
+  it.effect(
+    "serves the tools, each request as the caller it authenticates",
+    () =>
+      Effect.gen(function* () {
+        const anyone = yield* ActionMcp.client([GetStatus, GetNote]);
+        const ada = yield* ActionMcp.client([CreateNote, GetNote], as("ada"));
 
-      expect(yield* anyone.getStatus()).toMatchObject({ service: "notes-service" });
+        expect(yield* anyone.getStatus()).toMatchObject({
+          service: "notes-service",
+        });
 
-      const note = yield* ada.createNote({ title: "Plan", body: "First draft" });
+        const note = yield* ada.createNote({
+          title: "Plan",
+          body: "First draft",
+        });
 
-      expect(yield* ada.getNote({ id: note.id })).toEqual(note);
-      expect(yield* Effect.flip(anyone.getNote({ id: note.id }))).toBeInstanceOf(
-        Action.Unauthenticated,
-      );
-    }).pipe(Effect.provide(served)),
+        expect(yield* ada.getNote({ id: note.id })).toStrictEqual(note);
+        expect(
+          yield* Effect.flip(anyone.getNote({ id: note.id }))
+        ).toBeInstanceOf(Action.Unauthenticated);
+      }).pipe(Effect.provide(served))
   );
 });

package/examples/quickstart/README.md

@@ -1,14 +1,10 @@
 # quickstart
 
-The smallest complete program: one action, served as a JSON route and as an MCP tool, called
-with its typed client. It is the skeleton of [notes-service](../notes-service/), which adds
-authentication, authorization, declared errors, a store, a CLI and a browser client to the same
-layout.
+The smallest complete program: one action, served as a JSON route and as an MCP tool, called with its typed client. It is the skeleton of [notes-service](../notes-service/), which adds authentication, authorization, declared errors, a store, a CLI and a browser client to the same layout.
 
 ## 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
 node --import tsx examples/quickstart/src/server.ts     # 127.0.0.1:3000

package/examples/quickstart/src/Api.ts

@@ -1,4 +1,5 @@
 import * as ActionHttp from "@gjermundgaraba/effect-actions/ActionHttp";
+
 import { Greet } from "./greeting/Greeting.js";
 
 // The HTTP binding: `POST /api/greet`. The server serves it and the client calls it.

package/examples/quickstart/src/client.ts

@@ -1,14 +1,17 @@
 import { NodeRuntime } from "@effect/platform-node";
+import * as ActionHttp from "@gjermundgaraba/effect-actions/ActionHttp";
 import { Console, Effect } from "effect";
 import { FetchHttpClient } from "effect/http";
-import * as ActionHttp from "@gjermundgaraba/effect-actions/ActionHttp";
+
 import { Http } from "./Api.js";
 
 // Entrypoint: `node --import tsx examples/quickstart/src/client.ts`, with the server running.
 // One typed method per action of the binding.
 // DEMO ONLY: a deployed client reads its `baseUrl` from configuration (kitchen-sink/src/seed.ts).
 Effect.gen(function* () {
-  const client = yield* ActionHttp.client(Http, { baseUrl: "http://127.0.0.1:3000" });
+  const client = yield* ActionHttp.client(Http, {
+    baseUrl: "http://127.0.0.1:3000",
+  });
 
   yield* Console.log(yield* client.greet({ name: "Ada" }));
-}).pipe(Effect.provide(FetchHttpClient.layer), NodeRuntime.runMain);
+}).pipe(Effect.provide(FetchHttpClient.layer), NodeRuntime.runMain());

package/examples/quickstart/src/greeting/Greeting.ts

@@ -1,5 +1,5 @@
-import { Schema } from "effect";
 import * as Action from "@gjermundgaraba/effect-actions/Action";
+import { Schema } from "effect";
 
 // A contract: what the action takes and answers, whether it changes anything, and who may
 // call it. It imports no server code, so any client can import it, a browser page included.

package/examples/quickstart/src/greeting/handlers.ts

@@ -1,6 +1,9 @@
-import { Effect } from "effect";
 import * as Action from "@gjermundgaraba/effect-actions/Action";
+import { Effect } from "effect";
+
 import { Greet } from "./Greeting.js";
 
 // The implementation: the contract bound to its handler. Every surface takes this one value.
-export const greeting = Action.implement(Greet, ({ name }) => Effect.succeed(`Hello, ${name}!`));
+export const greeting = Action.implement(Greet, ({ name }) =>
+  Effect.succeed(`Hello, ${name}!`)
+);

package/examples/quickstart/src/routes.ts

@@ -1,11 +1,12 @@
-import { Layer } from "effect";
 import * as ActionHttp from "@gjermundgaraba/effect-actions/ActionHttp";
 import * as ActionMcp from "@gjermundgaraba/effect-actions/ActionMcp";
+import { Layer } from "effect";
+
 import { Http } from "./Api.js";
 import { greeting } from "./greeting/handlers.js";
 
 // One implementation, two surfaces: a JSON route and an MCP tool at `/mcp`.
 export const routes = Layer.mergeAll(
   ActionHttp.layer(Http, greeting),
-  ActionMcp.layerHttp(greeting, { name: "greetings", version: "1.0.0" }),
+  ActionMcp.layerHttp(greeting, { name: "greetings", version: "1.0.0" })
 );

package/examples/quickstart/src/server.ts

@@ -1,14 +1,18 @@
 import { createServer } from "node:http";
+
 import { NodeHttpServer, NodeRuntime } from "@effect/platform-node";
 import { Layer } from "effect";
 import { HttpRouter } from "effect/http";
+
 import { routes } from "./routes.js";
 
 // Entrypoint: `node --import tsx examples/quickstart/src/server.ts`.
 // DEMO ONLY: a deployed server reads its host and port from config and limits request bodies,
 // as notes-service/src/server.ts does; `127.0.0.1` serves this machine alone.
 HttpRouter.serve(routes).pipe(
-  Layer.provide(NodeHttpServer.layer(createServer, { host: "127.0.0.1", port: 3000 })),
+  Layer.provide(
+    NodeHttpServer.layer(createServer, { host: "127.0.0.1", port: 3000 })
+  ),
   Layer.launch,
-  NodeRuntime.runMain,
+  NodeRuntime.runMain()
 );

package/examples/quickstart/test/routes.test.ts

@@ -1,8 +1,9 @@
 import { expect, it } from "@effect/vitest";
-import { Effect } from "effect";
 import * as ActionHttp from "@gjermundgaraba/effect-actions/ActionHttp";
 import * as ActionMcp from "@gjermundgaraba/effect-actions/ActionMcp";
 import * as Testing from "@gjermundgaraba/effect-actions/Testing";
+import { Effect } from "effect";
+
 import { Http } from "../src/Api.js";
 import { Greet } from "../src/greeting/Greeting.js";
 import { routes } from "../src/routes.js";
@@ -15,5 +16,5 @@ it.effect("greets over HTTP and as an MCP tool", () =>
 
     expect(yield* http.greet({ name: "Ada" })).toBe("Hello, Ada!");
     expect(yield* mcp.greet({ name: "Ada" })).toBe("Hello, Ada!");
-  }).pipe(Effect.provide(Testing.layer(routes))),
+  }).pipe(Effect.provide(Testing.layer(routes)))
 );

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gjermundgaraba/effect-actions",
-  "version": "0.20.0",
+  "version": "0.21.0",
   "description": "Define Effect action contracts once and project them onto HTTP, MCP, Effect RPC, native Toolkits, and CLIs.",
   "keywords": [
     "ai-agents",
@@ -42,7 +42,9 @@
     "./ActionRpc": "./dist/ActionRpc.mjs",
     "./ActionToolkit": "./dist/ActionToolkit.mjs",
     "./Authentication": "./dist/Authentication.mjs",
+    "./Event": "./dist/Event.mjs",
     "./Testing": "./dist/Testing.mjs",
+    "./Webhook": "./dist/Webhook.mjs",
     "./package.json": "./package.json"
   },
   "publishConfig": {
@@ -50,18 +52,22 @@
   },
   "devDependencies": {
     "@effect/platform-node": "4.0.6",
+    "@effect/tsgo": "0.57.0",
     "@effect/vitest": "4.0.6",
     "@modelcontextprotocol/client": "2.3.1",
     "@types/node": "26.6.5",
     "effect": "4.0.6",
+    "oxfmt": "0.74.0",
+    "oxlint": "1.89.0",
     "tsx": "4.23.15",
     "typescript": "7.0.2",
+    "ultracite": "8.0.2",
     "vite": "npm:@voidzero-dev/vite-plus-core@1.4.0",
     "vite-plus": "1.4.0",
     "vitest": "5.0.5"
   },
   "peerDependencies": {
-    "effect": "~4.0.4"
+    "effect": "~4.0.5"
   },
   "devEngines": {
     "packageManager": {
@@ -71,7 +77,7 @@
     }
   },
   "engines": {
-    "node": ">=26"
+    "node": ">=26.12.0"
   },
   "scripts": {
     "build": "vp pack",
@@ -79,7 +85,7 @@
     "test": "vp test",
     "check": "vp check",
     "example": "vpx examples/notes-service/src/server.ts",
-    "test:package": "vp run build && vpx scripts/test-package.ts",
+    "test:package": "vp run -r build && vpx scripts/test-package.ts",
     "docs:sync": "vpx scripts/sync-skill.ts",
     "ready": "vp check && vp test && vp run test:package"
   }