@gjermundgaraba/effect-actions-cloudflare 0.22.0 → 0.23.0

package/examples/chat-rooms/src/chat/events.ts

@@ -5,19 +5,12 @@ import { authorize } from "./authorize.js";
 import { MessagePosted } from "./Chat.js";
 import { MessageStore } from "./store.js";
 
-// A cursor is the id of the last message a page holds, as `readMessages`' `after` is.
 const idOf = Schema.decodeUnknownOption(
   Schema.NumberFromString.pipe(Schema.check(Schema.isInt()))
 );
 
-// An agent polling over MCP asks again after `nextPoll`, 5 seconds by default: a request that
-// often keeps the object from the 10 idle seconds after which the runtime may hibernate it, so it
-// asks every 30 seconds, and an agent that needs a message sooner holds a stream open instead.
 const nextPoll = "30 seconds";
 
-// The room's messages as an event, read from the store that keeps them: a check source.
-// `postMessage` notifies after each post, so a page receives it at once: when an object reads a
-// check source, and what a write that does not notify misses, is on `ActionDurableObject.handlers`.
 export const messageEvents = Event.implement(
   MessagePosted,
   Effect.gen(function* () {
@@ -33,11 +26,6 @@ export const messageEvents = Event.implement(
             (id) => id >= 0 && id <= last
           );
 
-          // No cursor starts after the room's last message. One this room never gave, such as
-          // an id past its last from another copy of its database, is answered `truncated` from
-          // there: the page learns it missed messages, and reads them with `readMessages`. A
-          // message deleted or expired after a cursor is simply not read: the store keeps no
-          // record of either, so no gap marks it.
           if (Option.isNone(after)) {
             return {
               cursor: String(last),

package/examples/chat-rooms/src/chat/handlers.ts

@@ -8,9 +8,6 @@ import { authorize } from "./authorize.js";
 import { MessagePosted, Messages } from "./Chat.js";
 import { MessageStore } from "./store.js";
 
-// The builder runs once per instance, when the object is constructed, and again on the
-// instance the runtime constructs after evicting one: it is where a handler gets its startup
-// services. The caller is read per call, because every message has its own.
 export const messages = Action.implement(
   Messages,
   Effect.gen(function* () {
@@ -21,9 +18,6 @@ export const messages = Action.implement(
     return {
       readMessages: ({ after }) =>
         Effect.map(store.read(after), (read) => ({ messages: read })),
-      // The message is in the store, which `MessagePosted`'s check reads: notifying wakes the
-      // pages watching the room to read it now. The lobby is another object, whose event this
-      // one cannot notify: the room tells it over its stub instead, and the lobby notifies.
       postMessage: ({ text }) =>
         Effect.flatMap(CurrentMember, (member) =>
           store.post(member.id, text)

package/examples/chat-rooms/src/chat/room.ts

@@ -1,12 +1,7 @@
 import { Context } from "effect";
 
-import type { RoomName } from "./Chat.js";
+import type { DemoRoomName } from "./Chat.js";
 
-/**
- * The room an instance holds. Each room is one Durable Object, reached by its name, so this is
- * a startup service: one value for the instance's whole life, unlike the caller, which every
- * message names again.
- */
-export class Room extends Context.Service<Room, RoomName>()(
+export class Room extends Context.Service<Room, DemoRoomName>()(
   "chat-rooms/Room"
 ) {}

package/examples/chat-rooms/src/chat/store.ts

@@ -3,16 +3,10 @@ import type { Effect } from "effect";
 
 import type { Message, MessageNotFound, NotAuthor } from "./Chat.js";
 
-/**
- * The room's messages. That only its author deletes a message is checked here, in the data
- * access, so no surface and no handler can skip it. A message expires a day after it was
- * posted: `expire` deletes those, and the store sees that it runs.
- */
 export class MessageStore extends Context.Service<
   MessageStore,
   {
     readonly latest: Effect.Effect<Message | null>;
-    /** The id of the last message ever posted, kept or not, or 0 before the first. */
     readonly last: Effect.Effect<number>;
     readonly read: (after: number) => Effect.Effect<readonly Message[]>;
     readonly post: (author: string, text: string) => Effect.Effect<Message>;

package/examples/chat-rooms/src/identity/Identity.ts

@@ -8,14 +8,8 @@ export const Member = Schema.Struct({
 
 export type Member = typeof Member.Type;
 
-/**
- * Who sent a message. A protected action declares it, `caller: CurrentMember`; authentication
- * provides it for each message, from the token the message carries or the one its socket kept.
- */
 export class CurrentMember extends Context.Service<CurrentMember, Member>()(
   "chat-rooms/CurrentMember"
 ) {}
 
-// How a remote caller proves it is CurrentMember: a bearer token, the default scheme. Clients
-// import this descriptor with the bindings; its verifier, in verifier.ts, stays on the server.
 export const Login = Authentication.make("chat-rooms.Login", CurrentMember);

package/examples/chat-rooms/src/identity/members.ts

@@ -1,8 +1,6 @@
 import type { Member } from "./Identity.js";
 
-// DEMO ONLY: fixed members, each token their name. A real application keeps members in its
-// identity provider and their rooms in a store.
-export const members = {
+export const demoMembers = {
   ada: { id: "ada", rooms: ["general", "design"] },
   grace: { id: "grace", rooms: ["general"] },
 } satisfies Record<string, Member>;

package/examples/chat-rooms/src/identity/verifier.ts

@@ -3,22 +3,19 @@ import * as Authentication from "@gjermundgaraba/effect-actions/Authentication";
 import { Effect, Redacted } from "effect";
 
 import { Login } from "./Identity.js";
-import { members } from "./members.js";
+import { demoMembers } from "./members.js";
 
-const isToken = (token: string): token is keyof typeof members =>
-  Object.hasOwn(members, token);
+const isToken = (token: string): token is keyof typeof demoMembers =>
+  Object.hasOwn(demoMembers, token);
 
-// DEMO ONLY: a token is a member's name. A real verifier checks a signed token with your
-// authorization server's library, its audience and expiry included: a socket keeps the token
-// its page connected with, and this runs on every message, so an expired one is refused.
-const verify = (token: Redacted.Redacted) => {
+const demoVerify = (token: Redacted.Redacted) => {
   const name = Redacted.value(token);
 
   return isToken(name)
-    ? Effect.succeed(members[name])
+    ? Effect.succeed(demoMembers[name])
     : Effect.fail(
         new Action.Unauthenticated({ message: "Unknown demo token." })
       );
 };
 
-export const authenticate = Authentication.layer(Login, verify);
+export const authenticate = Authentication.layer(Login, demoVerify);

package/examples/chat-rooms/src/lobby/Calls.ts

@@ -3,11 +3,6 @@ import { Rpc, RpcGroup } from "effect/rpc";
 
 import { RoomPreview } from "./Lobby.js";
 
-// The lobby's own API, over its stub: a room tells it its latest activity, and the Worker reads
-// the previews. A plain Effect `RpcGroup`, not actions: no page calls it, so it needs no contract
-// checks, no authentication and no JSON route, and nothing authenticates a stub call anyway, as
-// only a binding reaches it. Why a report heard late never overwrites a later one is at
-// `tellLobby`, in lobby-stubs.ts, which sends it.
 export const LobbyCalls = RpcGroup.make(
   Rpc.make("roomChanged", { payload: RoomPreview }),
   Rpc.make("previews", { success: Schema.Array(RoomPreview) })

package/examples/chat-rooms/src/lobby/Lobby.ts

@@ -2,18 +2,15 @@ import * as Action from "@gjermundgaraba/effect-actions/Action";
 import * as Event from "@gjermundgaraba/effect-actions/Event";
 import { Schema } from "effect";
 
-import { RoomName } from "../chat/Chat.js";
+import { DemoRoomName } from "../chat/Chat.js";
 
-// When one room was last active, in milliseconds, or null while it holds no message.
 export const RoomPreview = Schema.Struct({
-  room: RoomName,
+  room: DemoRoomName,
   latestAt: Schema.NullOr(Schema.Int),
 });
 
 export type RoomPreview = typeof RoomPreview.Type;
 
-// The Worker's own action, served by the Worker, not by an object: it asks the lobby's object,
-// which keeps every room's preview.
 export const Previews = Action.make("previews", {
   description:
     "When each room was last active, in milliseconds, if it holds any message.",
@@ -22,8 +19,6 @@ export const Previews = Action.make("previews", {
   caller: Action.Anyone,
 });
 
-// Every room's preview, sent whole each time one changes: a page watches it on its socket to the
-// lobby's object. Public, as `previews` is, so a page signed out follows it too.
 export const PreviewsChanged = Event.make("previews.changed", {
   description:
     "When each room was last active, sent whole: first as it is, then on each change.",

package/examples/chat-rooms/src/lobby/events.ts

@@ -4,11 +4,6 @@ import { Effect } from "effect";
 import { PreviewsChanged } from "./Lobby.js";
 import { PreviewStore } from "./store.js";
 
-// Every room's preview as one event, read from the lobby's store: a current source, for a value
-// small enough to send whole. A page watching is sent the previews as they are, then again after
-// each notify, which `roomChanged` makes after each change, so it needs no read before it and is
-// never sent each change it missed, which a whole value makes needless. The object keeps the
-// revision a page's cursor holds, so a page resuming at the latest is sent nothing.
 export const previewEvents = Event.implement(
   PreviewsChanged,
   Effect.map(PreviewStore, (store) => ({

package/examples/chat-rooms/src/lobby/handlers.ts

@@ -7,7 +7,6 @@ import { LobbyHost } from "./host.js";
 import { Previews, PreviewsChanged } from "./Lobby.js";
 import { PreviewStore } from "./store.js";
 
-// The Worker's `previews`, as the lobby's object keeps them.
 export const lobby = Action.implement(
   Previews,
   Effect.map(
@@ -16,8 +15,6 @@ export const lobby = Action.implement(
   )
 );
 
-// The lobby's own API, in its object. A change notifies `PreviewsChanged`, which an object
-// outside this one could not do itself: its event is this object's.
 export const calls = LobbyCalls.toLayer(
   Effect.gen(function* () {
     const store = yield* PreviewStore;

package/examples/chat-rooms/src/lobby/host.ts

@@ -3,7 +3,6 @@ import type { Effect } from "effect";
 
 import type { RoomPreview } from "./Lobby.js";
 
-/** The lobby's object as the Worker reaches it. */
 export class LobbyHost extends Context.Service<
   LobbyHost,
   { readonly previews: Effect.Effect<readonly RoomPreview[]> }

package/examples/chat-rooms/src/lobby/store.ts

@@ -1,17 +1,15 @@
 import { Context } from "effect";
 import type { Effect } from "effect";
 
-import type { RoomName } from "../chat/Chat.js";
+import type { DemoRoomName } from "../chat/Chat.js";
 import type { RoomPreview } from "./Lobby.js";
 
-/** Every room's preview, as the room last told the lobby. */
 export class PreviewStore extends Context.Service<
   PreviewStore,
   {
     readonly read: Effect.Effect<readonly RoomPreview[]>;
-    /** Keeps `room`'s latest activity, succeeding with whether it changed. */
     readonly record: (
-      room: RoomName,
+      room: DemoRoomName,
       latestAt: number | null
     ) => Effect.Effect<boolean>;
   }

package/examples/chat-rooms/src/platform/kv-previews.ts

@@ -1,7 +1,7 @@
 import * as ActionDurableObject from "@gjermundgaraba/effect-actions-cloudflare/ActionDurableObject";
 import { Effect, Layer, Schema } from "effect";
 
-import { RoomName } from "../chat/Chat.js";
+import { DemoRoomName } from "../chat/Chat.js";
 import { RoomPreview } from "../lobby/Lobby.js";
 import { PreviewStore } from "../lobby/store.js";
 
@@ -9,16 +9,17 @@ const decodeLatestAt = Schema.decodeUnknownSync(
   Schema.UndefinedOr(RoomPreview.fields.latestAt)
 );
 
-// The previews in the lobby's object's synchronous key-value storage: each read and each record
-// is one step no other call runs inside, so a record compares and writes what it read.
 export const layerKvPreviews = Layer.effect(PreviewStore)(
   Effect.map(ActionDurableObject.State, ({ storage: { kv } }) => {
-    const latestOf = (room: RoomName) =>
+    const latestOf = (room: DemoRoomName) =>
       decodeLatestAt(kv.get(`preview:${room}`)) ?? null;
 
     return PreviewStore.of({
       read: Effect.sync(() =>
-        RoomName.literals.map((room) => ({ room, latestAt: latestOf(room) }))
+        DemoRoomName.literals.map((room) => ({
+          room,
+          latestAt: latestOf(room),
+        }))
       ),
       record: (room, latestAt) =>
         Effect.sync(() => {

package/examples/chat-rooms/src/platform/lobby-stubs.ts

@@ -8,25 +8,14 @@ import { MessageStore } from "../chat/store.js";
 import { LobbyCalls } from "../lobby/Calls.js";
 import { LobbyHost } from "../lobby/host.js";
 
-// The lobby is one object, named `lobby`: a new stub for each call, read from `env` as the call
-// is sent, never as the module loads.
 const lobbyStub = () => env.CHAT_LOBBY.getByName("lobby");
 
-// The lobby's object as the Worker reaches it, for the previews: a lobby that cannot be reached
-// is the deployment's failure, not the caller's, so it is a defect, the Worker answers 500, and
-// the cause is in its logs.
 export const layerLobbyHost = Layer.effect(LobbyHost)(
   Effect.map(ActionDurableObject.client(LobbyCalls), (lobby) =>
     LobbyHost.of({ previews: Effect.orDie(lobby(lobbyStub).previews()) })
   )
 );
 
-// The room's task, worker.ts's `lobby`: telling the lobby the room's latest activity. The room's
-// alarm runs its tasks one run at a time, each waiting for the lobby's answer, and each run reads
-// the activity as it is then: the lobby hears a room's reports in the order the room made them,
-// so a report heard late never overwrites a later one, and the last it hears is the room's
-// latest. A run repeated after a lost answer sends what the lobby holds, which `record` finds
-// unchanged, notifying no page.
 export const tellLobby = Effect.gen(function* () {
   const room = yield* Room;
   const latest = yield* MessageStore.use((store) => store.latest);
@@ -35,10 +24,6 @@ export const tellLobby = Effect.gen(function* () {
   yield* lobby(lobbyStub).roomChanged({ room, latestAt: latest?.at ?? null });
 });
 
-// A room's activity, a startup service of the room's: each change runs the `lobby` task after it,
-// on the room's alarm once the call has answered, and again until the lobby hears it, so a lobby
-// that cannot be reached fails no post and misses no change. `runAfter` marks the task before the
-// change and again after it, so a crash at any point leaves the task to the alarm.
 export const layerActivity = Layer.effect(Activity)(
   Effect.map(ActionDurableObject.Tasks, (tasks) =>
     Activity.of({ changing: (change) => tasks.runAfter("lobby", change) })

package/examples/chat-rooms/src/platform/sql-store.ts

@@ -12,9 +12,6 @@ const decodeSequence = Schema.decodeUnknownSync(
   Schema.Array(Schema.Struct({ seq: Schema.Int }))
 );
 
-// The room's messages in the object's own SQLite database, which outlives every instance: an
-// evicted instance loses its memory, never these. The Layer runs each time an instance is
-// constructed, so creating the table is idempotent.
 export const layerSql = Layer.effect(MessageStore)(
   Effect.gen(function* () {
     const { storage } = yield* ActionDurableObject.State;
@@ -30,16 +27,10 @@ export const layerSql = Layer.effect(MessageStore)(
       "CREATE TABLE IF NOT EXISTS messages (id INTEGER PRIMARY KEY AUTOINCREMENT, author TEXT NOT NULL, text TEXT NOT NULL, at INTEGER NOT NULL)"
     );
 
-    // Every expiry looks up the oldest message: indexed, it reads one row, where a scan would read
-    // the whole table, and SQLite storage is billed by rows read.
     storage.sql.exec(
       "CREATE INDEX IF NOT EXISTS messages_by_at ON messages (at)"
     );
 
-    // The room's alarm is due no later than the oldest message's expiry: `Alarm.set` keeps the
-    // earliest time it is given, so each post sets its own message's, and `expire`, which runs on
-    // the alarm, sets the next from the oldest message left. Removing the oldest message leaves
-    // its alarm, which then finds nothing due and moves on.
     const alarmForOldest = Effect.suspend(() => {
       const [oldest] = query("SELECT * FROM messages ORDER BY at LIMIT 1");
 
@@ -53,8 +44,6 @@ export const layerSql = Layer.effect(MessageStore)(
         () =>
           query("SELECT * FROM messages ORDER BY id DESC LIMIT 1")[0] ?? null
       ),
-      // AUTOINCREMENT keeps the highest id it ever gave in `sqlite_sequence`, so the last id
-      // outlives the message: one that expired or was deleted still counts.
       last: Effect.sync(
         () =>
           decodeSequence(

package/examples/chat-rooms/src/rooms-entrypoint.ts

@@ -1,21 +1,13 @@
 import { WorkerEntrypoint } from "cloudflare:workers";
 import { Effect, Schema } from "effect";
 
-import { RoomName } from "./chat/Chat.js";
+import { DemoRoomName } from "./chat/Chat.js";
 import { LobbyHost } from "./lobby/host.js";
 import { layerLobbyHost } from "./platform/lobby-stubs.js";
 
-const decodeRoom = Schema.decodeUnknownEffect(RoomName);
+const decodeRoom = Schema.decodeUnknownEffect(DemoRoomName);
 
-// The rooms' activity for another Worker, over a service binding to this one's `RoomsEntrypoint`,
-// which worker.ts exports, as the lobby keeps it. A method of a `WorkerEntrypoint` is no Effect
-// program, so each call runs as one, given the lobby's Layer: its client is built in the request
-// that uses it and closed with it, which costs no I/O. Why a client kept across requests strands
-// is on `ActionDurableObject.layerStubClient`.
 export class RoomsEntrypoint extends WorkerEntrypoint {
-  // The calling Worker is another deployment, so its room is checked as any input is: an unknown
-  // room rejects the call with the schema's error, as a lobby that cannot be reached rejects it
-  // with the defect lobby-stubs.ts makes of it.
   async latestAt(room: string) {
     return await Effect.runPromise(
       Effect.flatMap(decodeRoom(room), (name) =>

package/examples/chat-rooms/src/routes.ts

@@ -25,9 +25,6 @@ const room = [messages, messageEvents];
 
 const byRoom = (input: { readonly room: string }) => input.room;
 
-// Where each room's calls and watches are served: in the room's object, the one each contract's
-// key names. worker.ts gives it to the room's class, which then refuses an input naming another
-// room, on its socket too; the Worker serves it below.
 export const rooms = ActionDurableObject.placed(RoomHttp, {
   readMessages: byRoom,
   postMessage: byRoom,
@@ -35,48 +32,26 @@ export const rooms = ActionDurableObject.placed(RoomHttp, {
   "message.posted": byRoom,
 });
 
-// One socket route for each object's pages, refusing a page of another version.
 const pageSocket = ActionDurableObject.layerWebSocket({
   path: "/rpc",
   protocol: { version: protocolVersion, code: unsupportedProtocol },
 });
 
-// What a room's object serves. Its rpcs on WebSockets the runtime holds while the object
-// hibernates: a socket keeps the token its upgrade request carried, and each message is
-// authenticated with it, or with the message's own. The socket's route refuses a page naming
-// another version in its URL, `?protocol=<n>` as browser.ts sends it, with a close code the page's
-// client reads as `SocketCloseError` and stops connecting again at, not a 403, which a browser
-// reports as a bare 1006 its page connects again after. Its JSON routes, where the Worker sends
-// each call and watch on, the token with it: the object authenticates it again, and authorizes.
-// It requires `MessageStore`, `Room` and `Activity` at startup: worker.ts chooses them.
 export const roomRoutes = Layer.mergeAll(
   ActionRpc.layer(RoomRpc, room).pipe(Layer.provide(pageSocket)),
   ActionHttp.layer(RoomHttp, room)
 ).pipe(Layer.provide(authenticate));
 
-// What the lobby's object serves: `PreviewsChanged` on its pages' sockets, a socket a page
-// signed out opens too, as nothing on it is protected. It requires `PreviewStore` at startup.
 export const lobbyRoutes = ActionRpc.layer(LobbyRpc, [previewEvents]).pipe(
   Layer.provide(pageSocket)
 );
 
-// What the lobby's object serves over its stub: its own calls, on Effect's own RpcServer, for
-// the rooms and the Worker, which call them with Cloudflare's own RPC. It requires `PreviewStore`
-// at startup.
 export const lobbyCalls = RpcServer.layer(LobbyCalls).pipe(
   Layer.provide(lobbyHandlers)
 );
 
-// The rooms as the Worker serves them, each call sent on to its room's object. The room is read
-// from `env` as each call is sent.
 const inRooms = ActionDurableObject.reaching(rooms, () => env.CHAT_ROOM);
 
-// What the Worker serves: the rooms' JSON routes and `previews`, which it asks the lobby's object
-// for, at `/api`, and all of them at `/mcp`, the actions as tools and `MessagePosted` as an MCP
-// event, so one agent's connection reaches every room. Nothing in a Worker outlives a request, so
-// the endpoint is request scoped: MCP 2026-07-28 alone, and events by `events/poll`, a poll every
-// 30 seconds as events.ts asks. The Worker authenticates each call, and the room's object again.
-// It requires `LobbyHost`.
 export const workerRoutes = Layer.mergeAll(
   ActionHttp.layer(LobbyHttp, lobby),
   ActionHttp.layer(RoomHttp, inRooms),

package/examples/chat-rooms/src/worker.ts

@@ -3,7 +3,7 @@ import { Effect, Layer, Schema } from "effect";
 import { HttpRouter, HttpServer } from "effect/http";
 
 import { Activity } from "./chat/activity.js";
-import { RoomName } from "./chat/Chat.js";
+import { DemoRoomName } from "./chat/Chat.js";
 import { Room } from "./chat/room.js";
 import { MessageStore } from "./chat/store.js";
 import { layerKvPreviews } from "./platform/kv-previews.js";
@@ -21,22 +21,10 @@ import {
   workerRoutes,
 } from "./routes.js";
 
-// The rooms for another Worker, over a service binding: a named entrypoint of this one.
 export { RoomsEntrypoint } from "./rooms-entrypoint.js";
 
-// Entrypoint, Wrangler's `main`: the composition root of the Worker and of every object. It
-// chooses the stores, the room and the stubs, and routes each request.
+const decodeRoom = Schema.decodeUnknownEffect(DemoRoomName);
 
-const decodeRoom = Schema.decodeUnknownEffect(RoomName);
-
-// A room's Durable Object, bound as CHAT_ROOM in wrangler.jsonc under this export's name. Each
-// instance builds its services, the store, the room and its activity, then its routes, as it is
-// constructed, again after every eviction. The room is the name the Worker reached the object by,
-// `getByName(room)`, decoded once there: `ActionDurableObject.name` dies for an object reached by
-// an id, and the build fails for a name `RoomName` does not list, each a bug in the Worker. Given
-// `rooms`, it refuses a call or a watch whose input names another room. Its `lobby` task tells
-// the lobby of each change, on the alarm until the lobby hears. The alarm expires old messages
-// and tells the lobby, as an expired message can be the room's latest.
 export class ChatRoom extends ActionDurableObject.make({
   placed: rooms,
   services: () =>
@@ -53,18 +41,12 @@ export class ChatRoom extends ActionDurableObject.make({
     ),
 }) {}
 
-// The lobby's Durable Object, bound as CHAT_LOBBY: one for the Worker, named `lobby`, keeping
-// every room's preview, which each room tells it of and its pages follow.
 export class ChatLobby extends ActionDurableObject.make({
   services: () => layerKvPreviews,
   routes: lobbyRoutes,
   calls: lobbyCalls,
 }) {}
 
-// The Worker's own handler, built once, when the module loads, which keeps the lobby's client
-// from stranding as `ActionDurableObject.layerStubClient`'s gotchas say: building it does no I/O,
-// which a Worker refuses outside a request. `toWebHandler` reads no `MaxBodySize`, so the
-// platform limits request bodies.
 const served = HttpRouter.toWebHandler(
   workerRoutes.pipe(
     Layer.provide(layerLobbyHost),
@@ -72,11 +54,8 @@ const served = HttpRouter.toWebHandler(
   )
 );
 
-const isRoomName = Schema.is(RoomName);
+const isRoomName = Schema.is(DemoRoomName);
 
-// A page's socket, `/rooms/<room>/rpc` or `/lobby/rpc`, is its object's `/rpc`: forwarding the
-// request forwards its upgrade, and the object answers it. Everything else is the Worker's own,
-// the rooms' calls among them, which it sends on to each room's object itself.
 export default {
   async fetch(request: Request, env: Cloudflare.Env) {
     const url = new URL(request.url);

package/examples/chat-rooms/test/platform/sql-store.test.ts

@@ -12,8 +12,6 @@ const day = 24 * 60 * 60 * 1000;
 
 let objects = 0;
 
-// The adapter against a room's real SQLite database, inside a fresh object of its own: what it
-// reaches is the Workers runtime, so the runtime is its stand-in.
 const inObject = <A, E>(
   use: (
     store: MessageStore["Service"],
@@ -39,9 +37,6 @@ const inObject = <A, E>(
     );
   });
 
-// A clock a millisecond later at each read, which never yields: posts running at once read
-// times of their own, where at one shared time the oldest message and the latest would set the
-// same alarm. Effect's TestClock moves on through a semaphore, which lets each post finish first.
 const tickingFrom = (start: number): Clock.Clock => {
   let now = start;
   const tick = () => (now += 1);

package/examples/chat-rooms/test/support/socket.ts

@@ -6,14 +6,6 @@ import { Socket } from "effect/socket";
 
 import { protocolVersion, unsupportedProtocol } from "../../src/Rpc.js";
 
-// A page's socket to an object, `<at>/rpc` upgraded through the Worker as a browser's would be,
-// naming the version of the rpcs as `connection(url)` does. A test has no network to open one by
-// its URL, so it hands the upgraded socket to Effect's client protocol, the protocol
-// `connection(url)` builds over a URL, its reconnection included, and keeps the socket, which a
-// test listens on for what the object sent. The socket is accepted as Effect's client listens to
-// it, as a browser's socket is constructed with its listeners: accepted before, a close the
-// object sent at once could go unheard. `connects` counts the client's attempts: each after the
-// first would be another upgrade in a browser.
 export const pageSocket = (
   at: string,
   headers: Record<string, string> = {},
@@ -62,7 +54,6 @@ export const pageSocket = (
     return { socket, protocol, connects: () => connects };
   });
 
-// A page's socket to a room.
 export const roomSocket = (
   room: string,
   headers: Record<string, string> = {},

package/examples/chat-rooms/test/worker.test.ts

@@ -14,17 +14,15 @@ import { TestClock } from "effect/testing";
 import { LobbyHttp, RoomHttp } from "../src/Api.js";
 import { followLobby, openRoom } from "../src/browser.js";
 import { MessagePosted, PostMessage } from "../src/chat/Chat.js";
-import type { RoomName } from "../src/chat/Chat.js";
+import type { DemoRoomName } from "../src/chat/Chat.js";
 import { Login } from "../src/identity/Identity.js";
 import { RoomRpc, unsupportedProtocol } from "../src/Rpc.js";
 import { pageSocket, roomSocket } from "./support/socket.js";
 
 const day = 24 * 60 * 60 * 1000;
 
-// Every request goes through the Worker's own `fetch`, as a deployed one would get it.
 const worker = ActionDurableObject.layerHttpClient(exports.default);
 
-// The rooms' JSON routes, the Worker's: each call names its room.
 const jsonAs = (token?: string) =>
   ActionHttp.client(RoomHttp, {
     baseUrl: "https://chat.example",
@@ -37,7 +35,6 @@ const jsonAs = (token?: string) =>
         }),
   });
 
-// An agent's one connection to the Worker's MCP endpoint, reaching every room.
 const agentAs = (token: string) =>
   ActionMcp.client([PostMessage, MessagePosted], {
     url: "https://chat.example/mcp",
@@ -47,8 +44,6 @@ const agentAs = (token: string) =>
     ),
   });
 
-// What the runtime does after a call answers, such as a room's alarm, is waited for in real time:
-// a test using this runs under `it.live`, as under the test clock its sleeps never pass.
 const eventually = <A, E>(
   check: Effect.Effect<A, E>,
   until: (value: A) => boolean
@@ -65,7 +60,7 @@ const arrivedIn = (received: readonly unknown[]) => (count: number) =>
   );
 
 const pageIn = (
-  room: RoomName,
+  room: DemoRoomName,
   token: string,
   headers: Record<string, string> = {}
 ) =>
@@ -92,10 +87,7 @@ const status = (path: string, body: Schema.Json = {}) =>
 
 const readAll = (room: string) => ({ room, after: 0 });
 
-// First in the file, whose Worker module is its own: no request has reached the lobby before, so
-// a first request ending without I/O is the one that would strand a client built inside it, as
-// `ActionDurableObject.layerStubClient`'s gotchas say.
-describe("the Worker's handler, built as the module loads", () => {
+describe("the Worker's handler, built as the module loads, before any other test of this file reaches the lobby", () => {
   it.effect(
     "answers a first request ending without I/O, then a call reaching the lobby",
     () =>
@@ -300,7 +292,7 @@ describe("the Worker and its rooms", () => {
           text: "Polled in design.",
         });
 
-        const polled = (room: RoomName, after: number) =>
+        const polled = (room: DemoRoomName, after: number) =>
           ada
             .watch(
               MessagePosted,
@@ -409,8 +401,6 @@ describe("the Worker and its rooms", () => {
           baseUrl: "https://chat.example",
         });
 
-        // The room tells the lobby from its `lobby` task, which the room's alarm runs once the
-        // post has answered: the lobby hears of it a moment later, not as the post returns.
         const { previews } = yield* eventually(lobby.previews(), (answer) =>
           answer.previews.some(
             ({ room, latestAt }) => room === "design" && latestAt === posted.at
@@ -487,7 +477,6 @@ describe("the Worker and its rooms", () => {
           )
         );
 
-        // The lobby hears of the post from the room's `lobby` task, a moment after it answered.
         const latestAt = yield* eventually(
           Effect.promise(
             async () => await exports.RoomsEntrypoint.latestAt("general")
@@ -541,9 +530,6 @@ describe("the Worker and its rooms", () => {
           text: "From today.",
         });
 
-        // A day passes for the first message alone: it is backdated, and the alarm set for its
-        // expiry, as its post would have set it a day ago. That time is past, so the runtime runs
-        // it at once: the test waits until it has set the next, for the recent one's.
         yield* Effect.promise(async () => {
           await runInDurableObject(stub, async (room, state) => {
             state.storage.sql.exec(