@gjermundgaraba/effect-actions-cloudflare 0.21.0 → 0.23.0

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

@@ -5,7 +5,7 @@ import { RpcClient, RpcSerialization } from "effect/rpc";
 import { Socket } from "effect/socket";
 
 import { MessagePosted } from "./chat/Chat.js";
-import type { RoomName } from "./chat/Chat.js";
+import type { DemoRoomName } from "./chat/Chat.js";
 import { PreviewsChanged } from "./lobby/Lobby.js";
 import {
   LobbyRpc,
@@ -14,17 +14,6 @@ import {
   unsupportedProtocol,
 } from "./Rpc.js";
 
-// Client module: what a web page imports. It holds the binding and nothing of the server.
-
-// Effect's own client protocol, one WebSocket to an object, speaking JSON: the socket's URL is
-// `wss://<host>/rooms/<room>/rpc` for a room and `wss://<host>/lobby/rpc` for the lobby, given the version of the rpcs the page was built
-// with. An object serving another closes the socket at once with `unsupportedProtocol`, which
-// fails every call and stream with a `SocketCloseError` of that code; `reconnectUntil` stops
-// the client there, which Effect's own policy would not, connecting again every five seconds,
-// each attempt waking the object: show "reload". The layer owns the socket, so provide it
-// once, around the page's whole program; a page provides `Socket.layerWebSocketConstructorGlobal`, the browser's own
-// WebSocket. The client pings every five seconds and the object's runtime answers, so a page
-// left open does not wake the object.
 export const connection = (url: string) =>
   RpcClient.layerProtocolSocket({
     retryPolicy: ActionRpc.reconnectUntil(unsupportedProtocol),
@@ -33,27 +22,18 @@ export const connection = (url: string) =>
     Layer.provide(RpcSerialization.layerJson)
   );
 
-// A room as a page uses it, over the socket to that room's object: each call names the room, as
-// every call of a room does, and the object refuses one naming another. A browser WebSocket sets
-// no header when it connects, so the token travels on each message; a client that can set headers
-// on the upgrade, such as a Worker or a native app, sends it once there, and the socket keeps it.
-export const openRoom = (room: RoomName, token: string) =>
+export const openRoom = (room: DemoRoomName, token: string) =>
   Effect.gen(function* () {
     const client = yield* ActionRpc.client(RoomRpc);
     const headers = { authorization: `Bearer ${token}` };
     const signedIn = RpcClient.withHeaders(headers);
 
     return {
-      // The room's messages after `after`, the id of the last one the page holds: 0 reads them
-      // all.
       read: (after: number) =>
         client.readMessages({ room, after }).pipe(
           signedIn,
           Effect.map(({ messages }) => messages)
         ),
-      // A post the socket lost, as the room's object restarted, fails with an `RpcClientError`,
-      // whether or not it reached the room: sent again with its `request`, made once for the
-      // message, it is posted once.
       post: (text: string) =>
         Effect.flatMap(
           Effect.sync(() => crypto.randomUUID()),
@@ -66,14 +46,6 @@ export const openRoom = (room: RoomName, token: string) =>
               })
             )
         ),
-      // Each message posted to the room after `after`, the id of the last one the page holds: a
-      // page opening the room reads it, then watches from the last id it read, so a post between
-      // the two is not lost. The room's object keeps the watch while it hibernates, and resumes it
-      // when it next wakes, authenticating its token again: a token that expired meanwhile ends
-      // the watch with `Unauthenticated`, so watch again with a fresh one. `watch` connects again
-      // after a drop and resumes from the last message it delivered; a `Gap` says some were
-      // missed, which the page reads with `read`. The headers go with the stream, as `signedIn`
-      // puts them on a call, and so with every request it sends again.
       messages: (after: number) =>
         client
           .watch(MessagePosted, { room }, { cursor: String(after) })
@@ -95,10 +67,6 @@ export const openRoom = (room: RoomName, token: string) =>
     };
   });
 
-// The lobby as a page follows it, signed in or not: every room's preview, first as it is, then
-// whole again at each change. A watch given no cursor starts with the previews, so the page reads
-// nothing first; after a drop it resumes from the last it received, and hears the previews again
-// only if they changed meanwhile. A `Gap` needs no read either: the next occurrence is whole.
 export const followLobby = Effect.map(ActionRpc.client(LobbyRpc), (client) =>
   client.watch(PreviewsChanged, {}).pipe(
     Stream.filter((received) => Predicate.isTagged(received, "Occurrence")),

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

@@ -4,15 +4,10 @@ import { Schema } from "effect";
 
 import { CurrentMember } from "../identity/Identity.js";
 
-// DEMO ONLY: the rooms, fixed. Each name is one Durable Object, which the Worker reaches only
-// for a name listed here, so no caller creates an object of its own. A real application keeps
-// its rooms in a store and checks a name there before it reaches `getByName`.
-export const RoomName = Schema.Literals(["general", "design"]);
+export const DemoRoomName = Schema.Literals(["general", "design"]);
 
-export type RoomName = typeof RoomName.Type;
+export type DemoRoomName = typeof DemoRoomName.Type;
 
-// A message's `id` counts up within its room, so a client asks for what came after the last
-// one it holds. `at` is when it was posted, in milliseconds: messages expire a day later.
 export const Message = Schema.Struct({
   id: Schema.Int,
   author: Schema.String,
@@ -22,8 +17,6 @@ export const Message = Schema.Struct({
 
 export type Message = typeof Message.Type;
 
-// A declared error is part of the contract: every client decodes it as this class. Its status is
-// for the JSON routes; an rpc carries none.
 export class MessageNotFound extends Schema.TaggedError<
   MessageNotFound,
   { readonly brand: unique symbol }
@@ -34,16 +27,10 @@ export class NotAuthor extends Schema.TaggedError<
   { readonly brand: unique symbol }
 >()("NotAuthor", { id: Schema.Int }, { httpApiStatus: 403 }) {}
 
-// Every call and watch of a room names it in its input: the Worker sends each on to the room's
-// object, and the object refuses an input naming another room, so a page's socket to one room
-// cannot reach another. Its schema is the room names, so an unknown room is `InvalidInput`
-// before any object is reached.
-const inRoom = { room: RoomName };
+const inRoom = { room: DemoRoomName };
 
 const signedIn = { caller: CurrentMember } as const;
 
-// Reads once: a page opening a room reads what is there, then watches `MessagePosted` below from
-// the last id it read.
 export const ReadMessages = Action.make("readMessages", {
   ...signedIn,
   description: "Read the room's messages after the given id; 0 reads them all.",
@@ -52,9 +39,6 @@ export const ReadMessages = Action.make("readMessages", {
   readOnly: true,
 });
 
-// `request` is the post's idempotency key: a page makes one at random for each message and
-// sends it again when it retries the post, and the room answers the repeat as it answered the
-// first, posting once. A model reads its description beside the tool, so it does the same.
 export const PostMessage = Action.make("postMessage", {
   ...signedIn,
   description: "Post a message to the room. It expires a day later.",
@@ -83,10 +67,6 @@ export const DeleteMessage = Action.make("deleteMessage", {
 
 export const Messages = [ReadMessages, PostMessage, DeleteMessage] as const;
 
-// Each message posted to the room, as it is posted: a page watches it on the socket it keeps
-// open to the room's object. Signed-in, so each watch authenticates and runs `authorize` as it
-// starts, and again each time the object wakes after hibernating, refused for a member outside
-// the room, or one whose token has expired meanwhile.
 export const MessagePosted = Event.make("message.posted", {
   description: "A message posted to the room.",
   input: inRoom,

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

@@ -1,11 +1,6 @@
 import { Context } from "effect";
 import type { Effect } from "effect";
 
-/**
- * Where a room says its latest activity may have changed: the lobby's object, which worker.ts
- * chooses. `changing` runs a change, then tells, answering as the change did: a post stands
- * whether the lobby hears of it or not.
- */
 export class Activity extends Context.Service<
   Activity,
   {

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

@@ -4,9 +4,6 @@ import { Effect } from "effect";
 import { CurrentMember } from "../identity/Identity.js";
 import { Room } from "./room.js";
 
-// The one rule: a member reads and writes only the rooms they belong to. It is built as
-// handlers are: this Effect runs once per instance and gets the room, a startup service; the
-// function it returns runs before every handler and reads the caller of that call.
 export const authorize = Effect.gen(function* () {
   const room = yield* Room;
 

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,17 +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 post 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: `post` and `expire` set
-    // it for the oldest message, read from the table and set in one step, so posts running at
-    // once each set it for the oldest they see, and the last to set it has seen them all; reading
-    // the alarm first would let two posts both see none and the later one win. 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");
 
@@ -54,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(
@@ -82,7 +70,7 @@ export const layerSql = Layer.effect(MessageStore)(
             .one()
         );
 
-        yield* alarmForOldest;
+        yield* alarm.set(DateTime.makeUnsafe(message.at + day));
 
         return message;
       }),

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),