@gjermundgaraba/effect-actions 0.20.0 → 0.21.0

package/examples/kitchen-sink/src/admin/authenticate.ts

@@ -1,17 +1,21 @@
-import { Effect, Redacted } from "effect";
 import * as Action from "@gjermundgaraba/effect-actions/Action";
 import * as Authentication from "@gjermundgaraba/effect-actions/Authentication";
-import { type KeyOperator, OperatorKey } from "./Admin.js";
+import { Effect, Redacted } from "effect";
+
+import { OperatorKey } from "./Admin.js";
+import type { KeyOperator } from "./Admin.js";
 import { keys } from "./keys.js";
 
 // Typed to return a `KeyOperator`, never the `Operator` union (Admin.ts says why). The verifier
 // receives what its scheme decodes, the header's value, and needs no startup service, so it is
 // passed as it is.
 const verify = (
-  key: Redacted.Redacted<string>,
+  key: Redacted.Redacted
 ): Effect.Effect<KeyOperator, Action.Unauthenticated> =>
   Effect.fromNullishOr(keys.get(Redacted.value(key))).pipe(
-    Effect.mapError(() => new Action.Unauthenticated({ message: "Unknown operator key." })),
+    Effect.mapError(
+      () => new Action.Unauthenticated({ message: "Unknown operator key." })
+    )
   );
 
 // Server only: `OperatorKey`'s provider, which the admin port's routes require.

package/examples/kitchen-sink/src/admin/authorize.ts

@@ -1,7 +1,9 @@
-import { Effect } from "effect";
 import * as Action from "@gjermundgaraba/effect-actions/Action";
+import { Effect } from "effect";
+
 import { Operator } from "./Admin.js";
-import { type Grant, Grants } from "./grants.js";
+import { Grants } from "./grants.js";
+import type { Grant } from "./grants.js";
 
 // An authorizer built from a startup service, as a handler builder builds handlers: the
 // Effect yields `Grants` once, when the implementation is built, and the function it returns
@@ -14,13 +16,19 @@ export const authorize = Effect.gen(function* () {
       const operator = yield* Operator;
 
       // The one rule admits the console's operator too: no surface has a bypass of its own.
-      if (operator.trusted) return;
+      if (operator.trusted) {
+        return;
+      }
 
-      const grant: Grant = action.readOnly ? "workspaces:read" : "workspaces:suspend";
+      const grant: Grant = action.readOnly
+        ? "workspaces:read"
+        : "workspaces:suspend";
 
       // No `scopes`: a key cannot be re-authorized, so this is a plain 403.
       if (!(yield* grants.of(operator.id)).includes(grant)) {
-        return yield* new Action.Forbidden({ message: `Requires the ${grant} grant.` });
+        return yield* new Action.Forbidden({
+          message: `Requires the ${grant} grant.`,
+        });
       }
     });
 });

package/examples/kitchen-sink/src/admin/grants.ts

@@ -8,15 +8,17 @@ export type Grant = "workspaces:read" | "workspaces:suspend";
  */
 export class Grants extends Context.Service<
   Grants,
-  { readonly of: (operator: string) => Effect.Effect<ReadonlyArray<Grant>> }
+  { readonly of: (operator: string) => Effect.Effect<readonly Grant[]> }
 >()("tracker/Grants") {
   // DEMO ONLY: fixed grants. A real application reads them from its database.
   static readonly layerDemo = Layer.sync(Grants, () => {
-    const grants = new Map<string, ReadonlyArray<Grant>>([
+    const grants = new Map<string, readonly Grant[]>([
       ["ops", ["workspaces:read", "workspaces:suspend"]],
       ["support", ["workspaces:read"]],
     ]);
 
-    return Grants.of({ of: (operator) => Effect.sync(() => grants.get(operator) ?? []) });
+    return Grants.of({
+      of: (operator) => Effect.sync(() => grants.get(operator) ?? []),
+    });
   });
 }

package/examples/kitchen-sink/src/admin/handlers.ts

@@ -1,5 +1,6 @@
-import { Effect } from "effect";
 import * as Action from "@gjermundgaraba/effect-actions/Action";
+import { Effect } from "effect";
+
 import { WorkspaceRegistry } from "../workspaces/registry.js";
 import { Admin } from "./Admin.js";
 import { authorize } from "./authorize.js";
@@ -12,10 +13,13 @@ export const admin = Action.implement(
     const registry = yield* WorkspaceRegistry;
 
     return {
-      listWorkspaces: () => Effect.map(registry.list, (workspaces) => ({ workspaces })),
-      suspendWorkspace: ({ workspace }) => registry.setSuspended(workspace, true),
-      resumeWorkspace: ({ workspace }) => registry.setSuspended(workspace, false),
+      listWorkspaces: () =>
+        Effect.map(registry.list, (workspaces) => ({ workspaces })),
+      suspendWorkspace: ({ workspace }) =>
+        registry.setSuspended(workspace, true),
+      resumeWorkspace: ({ workspace }) =>
+        registry.setSuspended(workspace, false),
     };
   }),
-  { authorize },
+  { authorize }
 );

package/examples/kitchen-sink/src/agent.ts

@@ -1,6 +1,7 @@
 import { NodeRuntime } from "@effect/platform-node";
-import { Console, Effect, Layer } from "effect";
 import * as Action from "@gjermundgaraba/effect-actions/Action";
+import { Console, Effect, Layer } from "effect";
+
 import { demoModel } from "./assistant/demo-model.js";
 import { CurrentMember } from "./identity/Identity.js";
 import { members } from "./identity/members.js";
@@ -18,7 +19,10 @@ const program = Effect.gen(function* () {
   // `authorize` and handler, with no transport. The store is memory, so file an issue first.
   const tracker = yield* Action.client(issues);
 
-  yield* tracker.createIssue({ title: "Crash on save", body: "Stack trace attached." });
+  yield* tracker.createIssue({
+    title: "Crash on save",
+    body: "Stack trace attached.",
+  });
 
   const turn = yield* triage("Close what is done.");
 
@@ -40,8 +44,12 @@ program.pipe(
   // No remote caller: this host names the member the assistant acts for, around the turn.
   // DEMO ONLY: a real host names whoever asked.
   Effect.provideService(CurrentMember, members.ada),
-  Effect.provide(layer.pipe(Layer.provideMerge(Layer.merge(IssueStore.layerMemory, limiter)))),
-  // DEMO ONLY: a scripted model. A real one is a provider's layer, in its place.
-  Effect.provide(demoModel),
-  NodeRuntime.runMain,
+  Effect.provide(
+    layer.pipe(
+      Layer.provideMerge(Layer.merge(IssueStore.layerMemory, limiter)),
+      // DEMO ONLY: a scripted model. A real one is a provider's layer, in its place.
+      Layer.provideMerge(demoModel)
+    )
+  ),
+  NodeRuntime.runMain()
 );

package/examples/kitchen-sink/src/assistant/Assistant.ts

@@ -1,5 +1,6 @@
-import { Schema } from "effect";
 import * as Action from "@gjermundgaraba/effect-actions/Action";
+import { Schema } from "effect";
+
 import { CurrentMember } from "../identity/Identity.js";
 
 // The assistant behind a route: a model working on the issues with the tools of
@@ -16,31 +17,35 @@ import { CurrentMember } from "../identity/Identity.js";
 export const Turn = Schema.Struct({
   conversation: Schema.String,
   text: Schema.String,
-  ran: Schema.Array(Schema.Struct({ tool: Schema.String, failed: Schema.Boolean })),
+  ran: Schema.Array(
+    Schema.Struct({ tool: Schema.String, failed: Schema.Boolean })
+  ),
   waiting: Schema.Array(
     Schema.Struct({
       approvalId: Schema.String,
       tool: Schema.String,
       // The arguments the model gave the call, as JSON text: what the member approves.
       arguments: Schema.String,
-    }),
+    })
   ),
 });
 
 // Another member's conversation is not found either: an id tells nothing of who holds it.
-export class ConversationNotFound extends Schema.TaggedError<ConversationNotFound>()(
+export class ConversationNotFound extends Schema.TaggedError<
+  ConversationNotFound,
+  { readonly brand: unique symbol }
+>()(
   "ConversationNotFound",
   { conversation: Schema.String },
-  { httpApiStatus: 404 },
+  { httpApiStatus: 404 }
 ) {}
 
 // The model failed in the middle of a turn. The conversation is over: its history holds
 // nothing of that turn, so it no longer says which calls ran.
-export class AssistantFailed extends Schema.TaggedError<AssistantFailed>()(
-  "AssistantFailed",
-  { message: Schema.String },
-  { httpApiStatus: 502 },
-) {}
+export class AssistantFailed extends Schema.TaggedError<
+  AssistantFailed,
+  { readonly brand: unique symbol }
+>()("AssistantFailed", { message: Schema.String }, { httpApiStatus: 502 }) {}
 
 export const AskAssistant = Action.make("askAssistant", {
   description:
@@ -58,19 +63,20 @@ export const AskAssistant = Action.make("askAssistant", {
 });
 
 export const AnswerAssistant = Action.make("answerAssistant", {
-  description: "Approve or deny the calls a turn of your conversation waits for.",
+  description:
+    "Approve or deny the calls a turn of your conversation waits for.",
   input: {
     conversation: Schema.String,
     // Each request once. Effect acts on every answer it is given: an `approvalId` approved
     // twice in one request would run its call twice.
     answers: Schema.Array(
-      Schema.Struct({ approvalId: Schema.String, approved: Schema.Boolean }),
+      Schema.Struct({ approvalId: Schema.String, approved: Schema.Boolean })
     ).check(
       Schema.makeFilter(
         (answers) =>
-          new Set(answers.map(({ approvalId }) => approvalId)).size === answers.length ||
-          "Answer each approvalId once",
-      ),
+          new Set(answers.map(({ approvalId }) => approvalId)).size ===
+            answers.length || "Answer each approvalId once"
+      )
     ),
   },
   success: Turn,

package/examples/kitchen-sink/src/assistant/conversations.ts

@@ -1,5 +1,6 @@
 import { Context, Effect, Layer, Semaphore } from "effect";
 import { Chat } from "effect/ai";
+
 import type { Member } from "../identity/Identity.js";
 import { ConversationNotFound } from "./Assistant.js";
 
@@ -9,6 +10,11 @@ interface Conversation {
   readonly lock: Semaphore.Semaphore;
 }
 
+// A member is a person in a workspace, and an id is unguessable: both are in the key, as
+// JSON, which keeps its three parts apart whatever they hold.
+const keyOf = (owner: Member, id: string) =>
+  JSON.stringify([owner.workspace, owner.id, id]);
+
 /**
  * Where conversations are kept between requests, each with the member it belongs to. A turn
  * names the member, so only its owner reaches a conversation: an approval is acted on as the
@@ -28,7 +34,7 @@ export class Conversations extends Context.Service<
     readonly turn: <A, E, R>(
       owner: Member,
       id: string,
-      run: (chat: Chat.Chat) => Effect.Effect<A, E, R>,
+      run: (chat: Chat.Chat) => Effect.Effect<A, E, R>
     ) => Effect.Effect<A, E | ConversationNotFound, R>;
   }
 >()("tracker/Conversations") {
@@ -37,21 +43,20 @@ export class Conversations extends Context.Service<
   static readonly layerMemory = Layer.sync(Conversations, () => {
     const kept = new Map<string, Conversation>();
 
-    // A member is a person in a workspace, and an id is unguessable: both are in the key, as
-    // JSON, which keeps its three parts apart whatever they hold.
-    const keyOf = (owner: Member, id: string) => JSON.stringify([owner.workspace, owner.id, id]);
-
     // Read when it runs, not when it is written: the second lookup of a turn runs under the lock.
     const find = (key: string, id: string) =>
       Effect.suspend(() => Effect.fromNullishOr(kept.get(key))).pipe(
-        Effect.mapError(() => new ConversationNotFound({ conversation: id })),
+        Effect.mapError(() => new ConversationNotFound({ conversation: id }))
       );
 
     return Conversations.of({
       open: Effect.fn("Conversations.open")(function* (owner) {
         const id = crypto.randomUUID();
 
-        kept.set(keyOf(owner, id), { chat: yield* Chat.empty, lock: yield* Semaphore.make(1) });
+        kept.set(keyOf(owner, id), {
+          chat: yield* Chat.empty,
+          lock: yield* Semaphore.make(1),
+        });
 
         return id;
       }),
@@ -62,8 +67,8 @@ export class Conversations extends Context.Service<
           // Looked up again once the lock is held: a turn that waited for one that failed
           // must find its conversation gone, not run on the history that turn left behind.
           Effect.flatMap(find(key, id), ({ chat }) =>
-            Effect.onError(run(chat), () => Effect.sync(() => kept.delete(key))),
-          ).pipe(lock.withPermits(1)),
+            Effect.onError(run(chat), () => Effect.sync(() => kept.delete(key)))
+          ).pipe(lock.withPermits(1))
         );
       },
     });

package/examples/kitchen-sink/src/assistant/demo-model.ts

@@ -26,8 +26,8 @@ export const demoModel = Layer.effect(
                 name: "closeIssue",
                 params: { id: "ACME-1" },
               } as const,
-            ],
+            ]
       ),
     streamText: () => Stream.empty,
-  }),
+  })
 );

package/examples/kitchen-sink/src/assistant/handlers.ts

@@ -1,7 +1,9 @@
-import { Effect, Ref, Schema } from "effect";
-import { type Chat, LanguageModel, type Prompt } from "effect/ai";
 import * as Action from "@gjermundgaraba/effect-actions/Action";
 import * as ActionToolkit from "@gjermundgaraba/effect-actions/ActionToolkit";
+import { Effect, Ref, Schema } from "effect";
+import { LanguageModel } from "effect/ai";
+import type { Chat, Prompt } from "effect/ai";
+
 import { CurrentMember } from "../identity/Identity.js";
 import { toolkit } from "../issues/assistant.js";
 import { AssistantFailed, Assistant } from "./Assistant.js";
@@ -10,7 +12,10 @@ import { Conversations } from "./conversations.js";
 // A model that keeps calling tools is asked this many times in one turn, and no more.
 const requestsPerTurn = 6;
 
-type Response = LanguageModel.GenerateTextResponse<typeof toolkit.tools, "opaque">;
+type Response = LanguageModel.GenerateTextResponse<
+  typeof toolkit.tools,
+  "opaque"
+>;
 
 const approvalsOf = (response: Response) =>
   response.content.filter((part) => part.type === "tool-approval-request");
@@ -19,7 +24,9 @@ const approvalsOf = (response: Response) =>
 // or one in a reply the provider cut short. Left out of `ran` below, which lists the calls that
 // ran.
 const didNotRun = Schema.is(
-  Schema.Struct({ type: Schema.Literals(["execution-denied", "execution-interrupted"]) }),
+  Schema.Struct({
+    type: Schema.Literals(["execution-denied", "execution-interrupted"]),
+  })
 );
 
 const callsToRead = (response: Response) =>
@@ -38,7 +45,11 @@ export const assistant = Action.implement(
     const model = yield* LanguageModel.LanguageModel;
     const conversations = yield* Conversations;
 
-    const converse = (conversation: string, chat: Chat.Chat, prompt: Prompt.RawInput) =>
+    const converse = (
+      conversation: string,
+      chat: Chat.Chat,
+      prompt: Prompt.RawInput
+    ) =>
       Effect.gen(function* () {
         // One `generateText` is one request to the model: its tool calls run, and their
         // results come back unread. The model is asked again, with nothing new, while it
@@ -48,7 +59,11 @@ export const assistant = Action.implement(
         let response = yield* chat.generateText({ prompt, toolkit: tools });
         const results = [...response.toolResults];
 
-        for (let asked = 1; asked < requestsPerTurn && callsToRead(response); asked++) {
+        for (
+          let asked = 1;
+          asked < requestsPerTurn && callsToRead(response);
+          asked += 1
+        ) {
           response = yield* chat.generateText({ prompt: [], toolkit: tools });
           results.push(...response.toolResults);
         }
@@ -57,45 +72,50 @@ export const assistant = Action.implement(
           conversation,
           text: response.text,
           ran: results
+            .values()
             .filter(({ result }) => !didNotRun(result))
-            .map(({ name, isFailure }) => ({ tool: name, failed: isFailure })),
+            .map(({ name, isFailure }) => ({ tool: name, failed: isFailure }))
+            .toArray(),
           // Every request of the conversation still waiting for an answer, with the call it
           // would run, read from the `Chat`'s history by the rule Effect applies when an answer
           // arrives: one an earlier answer left open is listed in every turn until answered.
           // The arguments are shown as JSON, as the member approves them.
-          waiting: ActionToolkit.openApprovals(yield* Ref.get(chat.history)).map(
-            ({ approvalId, name, params }) => ({
-              approvalId,
-              tool: name,
-              arguments: JSON.stringify(params),
-            }),
-          ),
+          waiting: ActionToolkit.openApprovals(
+            yield* Ref.get(chat.history)
+          ).map(({ approvalId, name, params }) => ({
+            approvalId,
+            tool: name,
+            arguments: JSON.stringify(params),
+          })),
         };
       }).pipe(
         // The model is a startup service, given to each turn here.
-        Effect.provideService(LanguageModel.LanguageModel, model),
+        Effect.provideService(LanguageModel.LanguageModel, model)
       );
 
     // A failed turn says what may have run.
     const turn = (conversation: string, prompt: Prompt.RawInput) =>
       Effect.flatMap(CurrentMember, (member) =>
-        conversations.turn(member, conversation, (chat) => converse(conversation, chat, prompt)),
+        conversations.turn(member, conversation, (chat) =>
+          converse(conversation, chat, prompt)
+        )
       ).pipe(
         Effect.catchTag("AiError", () =>
           Effect.fail(
             new AssistantFailed({
               message:
                 "The model failed and this conversation has ended. A call you approved in this turn may have run: read the issue before asking again.",
-            }),
-          ),
-        ),
+            })
+          )
+        )
       );
 
     return {
       askAssistant: ({ prompt, conversation }) =>
         conversation === undefined
-          ? Effect.flatMap(Effect.flatMap(CurrentMember, conversations.open), (opened) =>
-              turn(opened, prompt),
+          ? Effect.flatMap(
+              Effect.flatMap(CurrentMember, conversations.open),
+              (opened) => turn(opened, prompt)
             )
           : turn(conversation, prompt),
       // The answers start the next turn, in which an approved call runs, as this request's
@@ -117,5 +137,5 @@ export const assistant = Action.implement(
   }),
   // Any member may ask. What the assistant may do for them is each tool's rule, not this one:
   // a member without the write scope gets the tool's refusal as a result the model reads.
-  { authorize: Action.allowAll },
+  { authorize: Action.allowAll }
 );

package/examples/kitchen-sink/src/attachments/Attachments.ts

@@ -1,5 +1,6 @@
-import { Schema } from "effect";
 import * as Action from "@gjermundgaraba/effect-actions/Action";
+import { Schema } from "effect";
+
 import { CurrentMember } from "../identity/Identity.js";
 import { IssueWriteErrors } from "../issues/Issues.js";
 
@@ -13,11 +14,10 @@ export const Attachment = Schema.Struct({
 
 export type Attachment = typeof Attachment.Type;
 
-export class AttachmentNotFound extends Schema.TaggedError<AttachmentNotFound>()(
-  "AttachmentNotFound",
-  { id: Schema.String },
-  { httpApiStatus: 404 },
-) {}
+export class AttachmentNotFound extends Schema.TaggedError<
+  AttachmentNotFound,
+  { readonly brand: unique symbol }
+>()("AttachmentNotFound", { id: Schema.String }, { httpApiStatus: 404 }) {}
 
 // `Action.Image` is `{ data: Uint8Array, mimeType: string }`. In an input it is JSON over HTTP,
 // RPC and the CLI, the bytes in base64.

package/examples/kitchen-sink/src/attachments/download.ts

@@ -1,6 +1,7 @@
+import * as Authentication from "@gjermundgaraba/effect-actions/Authentication";
 import { Effect, Layer } from "effect";
 import { HttpRouter, HttpServerResponse } from "effect/http";
-import * as Authentication from "@gjermundgaraba/effect-actions/Authentication";
+
 import { authorize } from "../identity/authorize.js";
 import { CurrentMember, Session } from "../identity/Identity.js";
 import { GetAttachment } from "./Attachments.js";
@@ -38,9 +39,9 @@ export const download = Layer.unwrap(
         });
       }).pipe(
         Effect.catchTag("AttachmentNotFound", () =>
-          Effect.succeed(HttpServerResponse.empty({ status: 404 })),
-        ),
-      ),
-    ).pipe(Layer.provide(Authentication.protect(Session).layer)),
-  ),
+          Effect.succeed(HttpServerResponse.empty({ status: 404 }))
+        )
+      )
+    ).pipe(Layer.provide(Authentication.protect(Session).layer))
+  )
 );

package/examples/kitchen-sink/src/attachments/handlers.ts

@@ -1,5 +1,6 @@
-import { Effect } from "effect";
 import * as Action from "@gjermundgaraba/effect-actions/Action";
+import { Effect } from "effect";
+
 import { authorize } from "../identity/authorize.js";
 import { CurrentMember } from "../identity/Identity.js";
 import { writeLimit } from "../issues/write-limit.js";
@@ -27,11 +28,15 @@ export const attachments = Action.implement(
             });
           }
 
-          return yield* limited((member) => store.add(member.workspace, issue, name, image));
+          return yield* limited((member) =>
+            store.add(member.workspace, issue, name, image)
+          );
         }),
       getAttachment: ({ id }) =>
-        Effect.flatMap(CurrentMember, (member) => store.get(member.workspace, id)),
+        Effect.flatMap(CurrentMember, (member) =>
+          store.get(member.workspace, id)
+        ),
     };
   }),
-  { authorize },
+  { authorize }
 );

package/examples/kitchen-sink/src/attachments/store.ts

@@ -1,8 +1,10 @@
-import { Context, Effect, Layer } from "effect";
 import type * as Action from "@gjermundgaraba/effect-actions/Action";
+import { Context, Effect, Layer } from "effect";
+
 import type { IssueNotFound } from "../issues/Issues.js";
 import { IssueStore } from "../issues/store.js";
-import { type Attachment, AttachmentNotFound } from "./Attachments.js";
+import { AttachmentNotFound } from "./Attachments.js";
+import type { Attachment } from "./Attachments.js";
 
 type Image = typeof Action.Image.Type;
 
@@ -19,9 +21,12 @@ export class AttachmentStore extends Context.Service<
       workspace: string,
       issue: string,
       name: string,
-      image: Image,
+      image: Image
     ) => Effect.Effect<Attachment, IssueNotFound>;
-    readonly get: (workspace: string, id: string) => Effect.Effect<Stored, AttachmentNotFound>;
+    readonly get: (
+      workspace: string,
+      id: string
+    ) => Effect.Effect<Stored, AttachmentNotFound>;
   }
 >()("tracker/AttachmentStore") {
   // DEMO ONLY: memory. A service captures what it depends on when it is built, here the issue
@@ -33,26 +38,28 @@ export class AttachmentStore extends Context.Service<
       const stored = new Map<string, Stored>();
 
       return AttachmentStore.of({
-        add: Effect.fn("AttachmentStore.add")(function* (workspace, issue, name, image) {
-          yield* issues.get(workspace, issue);
+        add: Effect.fn("AttachmentStore.add")(
+          function* (workspace, issue, name, image) {
+            yield* issues.get(workspace, issue);
 
-          const attachment = {
-            id: crypto.randomUUID(),
-            issue,
-            name,
-            mimeType: image.mimeType,
-            size: image.data.byteLength,
-          };
+            const attachment = {
+              id: crypto.randomUUID(),
+              issue,
+              name,
+              mimeType: image.mimeType,
+              size: image.data.byteLength,
+            };
 
-          stored.set(`${workspace}/${attachment.id}`, { attachment, image });
+            stored.set(`${workspace}/${attachment.id}`, { attachment, image });
 
-          return attachment;
-        }),
+            return attachment;
+          }
+        ),
         get: (workspace, id) =>
           Effect.fromNullishOr(stored.get(`${workspace}/${id}`)).pipe(
-            Effect.mapError(() => new AttachmentNotFound({ id })),
+            Effect.mapError(() => new AttachmentNotFound({ id }))
           ),
       });
-    }),
+    })
   );
 }

package/examples/kitchen-sink/src/browser.ts

@@ -1,7 +1,8 @@
+import * as ActionRpc from "@gjermundgaraba/effect-actions/ActionRpc";
 import { Effect, Layer } from "effect";
 import { RpcClient, RpcSerialization } from "effect/rpc";
 import { Socket } from "effect/socket";
-import * as ActionRpc from "@gjermundgaraba/effect-actions/ActionRpc";
+
 import { Rpc } from "./Rpc.js";
 
 // Entrypoint of the web app, an Effect program in a page. It imports the RPC binding and
@@ -22,11 +23,16 @@ export const board = Effect.gen(function* () {
 export const protocol = (url: string) =>
   RpcClient.layerProtocolSocket().pipe(
     Layer.provide(Socket.layerWebSocket(url)),
-    Layer.provide([RpcSerialization.layerJson, Socket.layerWebSocketConstructorGlobal]),
+    Layer.provide([
+      RpcSerialization.layerJson,
+      Socket.layerWebSocketConstructorGlobal,
+    ])
   );
 
 // `open("wss://tracker.example.com/rpc")`: one run on a socket of its own, closed when it ends.
 // A page that stays connected builds the protocol's Layer once, such as in a `ManagedRuntime`,
 // and runs its programs in it.
-export const open = (url: string) =>
-  Effect.runPromise(board.pipe(Effect.scoped, Effect.provide(protocol(url))));
+export const open = async (url: string) =>
+  await Effect.runPromise(
+    board.pipe(Effect.scoped, Effect.provide(protocol(url)))
+  );