durable-actors 0.2.4

package/dist/templates/ai-chat/src/backend.ts

@@ -0,0 +1,41 @@
+import { openai } from "@ai-sdk/openai"
+import { convertToModelMessages, generateId, pipeUIMessageStreamToResponse, streamText, toUIMessageStream, validateUIMessages } from "ai"
+import express from "express"
+import { createServer } from "vite"
+
+import { ChatHistory } from "./durable-objects.js"
+
+const app = express()
+app.use(express.json())
+
+app.get("/api/chat/:id", async (request, response) => {
+    response.json(await ChatHistory.get(request.params.id).load())
+})
+
+app.post("/api/chat", async (request, response) => {
+    const [message] = await validateUIMessages({ messages: [request.body.messages.at(-1)] })
+    if (message.role !== "user") return response.sendStatus(400)
+    const chat = ChatHistory.get(request.body.id)
+    const messages = await chat.append(message)
+    const result = streamText({
+        model: openai("gpt-5-mini"),
+        messages: await convertToModelMessages(messages)
+    })
+    await pipeUIMessageStreamToResponse({
+        response,
+        stream: toUIMessageStream({
+            stream: result.stream,
+            originalMessages: messages,
+            generateMessageId: generateId,
+            onEnd: async ({ responseMessage, outcome }) => {
+                if (outcome.status === "completed") await chat.append(responseMessage)
+            }
+        })
+    })
+})
+
+const vite = await createServer({
+    server: { middlewareMode: true, fs: { deny: [".env", ".env.*", "**/.durable-actors/**", "**/.little-actors/**", "**/.git/**"] } }
+})
+app.use(vite.middlewares)
+app.listen(3000, "127.0.0.1", () => console.log("AI chat: http://127.0.0.1:3000"))

package/dist/templates/ai-chat/src/durable-objects.ts

@@ -0,0 +1,15 @@
+import type { UIMessage } from "ai"
+import { Actor, Persisted } from "durable-actors"
+
+export class ChatHistory extends Actor {
+    @Persisted private messages: UIMessage[] = []
+
+    async load() {
+        return this.messages
+    }
+
+    async append(message: UIMessage) {
+        this.messages.push(message)
+        return this.messages
+    }
+}

package/dist/templates/ai-chat/tsconfig.json

@@ -0,0 +1,13 @@
+{
+    "compilerOptions": {
+        "target": "ES2022",
+        "module": "ESNext",
+        "moduleResolution": "Bundler",
+        "jsx": "react-jsx",
+        "strict": true,
+        "skipLibCheck": true,
+        "noEmit": true,
+        "types": ["node"]
+    },
+    "include": ["src", "generated"]
+}

package/dist/templates/chat/LICENSE.md

@@ -0,0 +1,9 @@
+MIT License
+
+Copyright (c) 2026 Terse
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/dist/templates/chat/README.md

@@ -0,0 +1,29 @@
+# Express + React chat
+
+Requires Node.js 20+ and Bun 1.4.2+ on your PATH; Bun executes the actors.
+
+Create this sample with `npx durable-actors init chat-example --template chat`.
+
+## Run it
+
+```sh
+npm install
+npx durable-actors generate
+npx durable-actors dev
+```
+
+Wait for `Local actors ready`. In another terminal, run the printed export command, then:
+
+```sh
+npm run dev
+```
+
+Open [the chat](http://127.0.0.1:3000) in two tabs. Send a message, then reload to see the saved history.
+
+## How it works
+
+Everyone is a guest in this demo. In your app, authenticate the request before `actors.ChatRoom.prepareWebsocket` and derive metadata from the signed-in user.
+
+The frontend fetches a signed URL from the backend and passes it to `new WebSocket()`. The actor sends history explicitly on connection and after each message. Reload to reconnect if the socket closes.
+
+After changing the actor's types, rerun `npx durable-actors generate` and restart the actor server.

package/dist/templates/chat/gitignore

@@ -0,0 +1,8 @@
+node_modules/
+dist/
+generated/
+.durable-actors/
+.little-actors/
+.env
+.env.*
+!.env.example

package/dist/templates/chat/index.html

@@ -0,0 +1,12 @@
+<!doctype html>
+<html lang="en">
+    <head>
+        <meta charset="UTF-8" />
+        <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+        <title>Chat · Durable Actors</title>
+    </head>
+    <body>
+        <div id="root"></div>
+        <script type="module" src="/src/Chat.tsx"></script>
+    </body>
+</html>

package/dist/templates/chat/package.json

@@ -0,0 +1,27 @@
+{
+    "name": "durable-actors-example-chat",
+    "private": true,
+    "type": "module",
+    "engines": {
+        "node": ">=22.19.0"
+    },
+    "scripts": {
+        "dev": "tsx src/backend.ts",
+        "build": "tsc --noEmit && vite build"
+    },
+    "dependencies": {
+        "express": "^5.2.1",
+        "durable-actors": "0.2.4",
+        "react": "^19.3.0",
+        "react-dom": "^19.3.0"
+    },
+    "devDependencies": {
+        "@types/express": "^5.0.0",
+        "@types/node": "^22.0.0",
+        "@types/react": "^19.0.0",
+        "@types/react-dom": "^19.0.0",
+        "tsx": "^4.0.0",
+        "typescript": "~5.9.3",
+        "vite": "^8.3.0"
+    }
+}

package/dist/templates/chat/src/Chat.tsx

@@ -0,0 +1,63 @@
+import { useEffect, useRef, useState } from "react"
+import { createRoot } from "react-dom/client"
+
+function Chat() {
+    const room = useRef<WebSocket | undefined>(undefined)
+    const [history, setHistory] = useState<{ name: string; text: string }[]>([])
+    const [connected, setConnected] = useState(false)
+
+    useEffect(() => {
+        let disposed = false
+        async function open() {
+            const response = await fetch("/api/socket/ChatRoom/lobby", { method: "POST" })
+            if (!response.ok) throw new Error(`Connection denied (${response.status})`)
+            const { websocketUrl } = await response.json()
+            if (disposed) return
+            const socket = new WebSocket(websocketUrl)
+            room.current = socket
+            socket.onopen = () => {
+                if (!disposed) setConnected(true)
+            }
+            socket.onmessage = event => {
+                if (!disposed) setHistory(JSON.parse(event.data))
+            }
+            socket.onclose = () => {
+                if (!disposed) setConnected(false)
+            }
+            socket.onerror = () => {
+                if (!disposed) setConnected(false)
+            }
+        }
+        void open().catch(console.error)
+        return () => {
+            disposed = true
+            room.current?.close()
+        }
+    }, [])
+
+    function send(form: FormData) {
+        if (room.current?.readyState === WebSocket.OPEN) room.current.send(JSON.stringify(String(form.get("message"))))
+    }
+
+    return (
+        <main>
+            <h1>The lobby</h1>
+            <ul role="log" aria-label="Messages">
+                {history.map((item, index) => (
+                    <li key={index}>
+                        <strong>{item.name}:</strong> {item.text}
+                    </li>
+                ))}
+            </ul>
+            <form action={send}>
+                <label>
+                    Message <input name="message" required disabled={!connected} />
+                </label>
+                <button disabled={!connected}>Send</button>
+            </form>
+            {!connected && <p>Connecting or disconnected. Reload to retry.</p>}
+        </main>
+    )
+}
+
+createRoot(document.getElementById("root")!).render(<Chat />)

package/dist/templates/chat/src/backend.ts

@@ -0,0 +1,20 @@
+import express from "express"
+import { createServer } from "vite"
+
+import { actors } from "../generated/index.js"
+
+const app = express()
+
+app.post("/api/socket/ChatRoom/:actorId", async (request, response) => {
+    const grant = await actors.ChatRoom.prepareWebsocket({
+        actorId: request.params.actorId,
+        metadata: { name: "Guest" }
+    })
+    response.set("Cache-Control", "no-store").json(grant)
+})
+
+const vite = await createServer({
+    server: { middlewareMode: true, fs: { deny: [".env", ".env.*", "**/.durable-actors/**", "**/.little-actors/**", "**/.git/**"] } }
+})
+app.use(vite.middlewares)
+app.listen(3000, "127.0.0.1", () => console.log("Chat: http://127.0.0.1:3000"))

package/dist/templates/chat/src/durable-objects.ts

@@ -0,0 +1,18 @@
+import { Actor, Persisted } from "durable-actors"
+import type { ActorSocket } from "durable-actors"
+
+export class ChatRoom extends Actor<Member, string, ChatMessage[]> {
+    @Persisted history: ChatMessage[] = []
+
+    async onConnect(socket: ActorSocket<Member, ChatMessage[]>) {
+        socket.send(this.history)
+    }
+
+    async onMessage(socket: ActorSocket<Member, ChatMessage[]>, text: string) {
+        this.history.push({ name: socket.metadata.name, text })
+        this.broadcast(this.history)
+    }
+}
+
+type Member = { name: string }
+type ChatMessage = { name: string; text: string }

package/dist/templates/chat/tsconfig.json

@@ -0,0 +1,13 @@
+{
+    "compilerOptions": {
+        "target": "ES2022",
+        "module": "ESNext",
+        "moduleResolution": "Bundler",
+        "jsx": "react-jsx",
+        "strict": true,
+        "skipLibCheck": true,
+        "noEmit": true,
+        "types": ["node"]
+    },
+    "include": ["src", "generated"]
+}

package/dist/templates/documents/LICENSE.md

@@ -0,0 +1,9 @@
+MIT License
+
+Copyright (c) 2026 Terse
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/dist/templates/documents/README.md

@@ -0,0 +1,38 @@
+# Shared documents
+
+Requires Node.js 20+ and Bun 1.4.2+ on your PATH; Bun executes the actors.
+
+A small Tiptap editor with Yjs for concurrent edits and durable actors for saved documents.
+
+## Run it
+
+```sh
+npx durable-actors init documents-example --template documents
+cd documents-example
+npm install
+npx durable-actors generate
+npx durable-actors dev
+```
+
+Wait for `Local actors ready`. In another terminal, run the printed export command, then:
+
+```sh
+npm run dev
+```
+
+Open [the editor](http://127.0.0.1:3000) in two tabs. Type in Welcome, format some text, and edit from both tabs. Add another document and switch between them. Reload after changes arrive in the other tab to see the saved content.
+
+If you already have this directory, start at `npm install`. No external service is needed.
+
+## The code
+
+- [src/durable-objects.ts](src/durable-objects.ts): a workspace actor stores the document list; one document actor per ID merges and saves Yjs state. The actors send initial data in `onConnect` and broadcast updates explicitly.
+- [src/backend.ts](src/backend.ts): issues WebSocket credentials using the generated `prepareWebsocket` helpers and local defaults.
+- [src/collaboration.ts](src/collaboration.ts): connects Yjs to a native WebSocket. It sends local updates and applies remote state without echoing it.
+- [src/App.tsx](src/App.tsx) and [src/Editor.tsx](src/Editor.tsx): document navigation and Tiptap’s editor, formatting controls, and collaborative undo/redo.
+
+Yjs updates are encoded as base64 strings to fit the SDK’s JSON protocol. The actor saves the Yjs state, preserving the information needed to merge concurrent edits. Clients receive the complete merged document after each edit; this keeps the sample small rather than optimizing for large documents.
+
+Editing pauses while disconnected. Reload to request a fresh connection. There is no automatic reconnect or browser storage for unsaved edits. Keep `.durable-actors/` and restart both servers to restore saved documents.
+
+This demo has one shared workspace and no authentication. In an application, authenticate the proxy route and authorize access to the requested workspace or document. Presence cursors, document deletion, and permissions UI are left out.

package/dist/templates/documents/gitignore

@@ -0,0 +1,8 @@
+node_modules/
+dist/
+generated/
+.durable-actors/
+.little-actors/
+.env
+.env.*
+!.env.example

package/dist/templates/documents/index.html

@@ -0,0 +1,12 @@
+<!doctype html>
+<html lang="en">
+    <head>
+        <meta charset="UTF-8" />
+        <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+        <title>Shared documents</title>
+    </head>
+    <body>
+        <div id="root"></div>
+        <script type="module" src="/src/App.tsx"></script>
+    </body>
+</html>

package/dist/templates/documents/package.json

@@ -0,0 +1,35 @@
+{
+    "name": "durable-actors-example-documents",
+    "private": true,
+    "type": "module",
+    "engines": {
+        "node": ">=22.19.0"
+    },
+    "scripts": {
+        "dev": "tsx src/backend.ts",
+        "build": "tsc --noEmit && vite build"
+    },
+    "dependencies": {
+        "@tiptap/core": "^3.31.3",
+        "@tiptap/extension-collaboration": "^3.31.3",
+        "@tiptap/pm": "^3.31.3",
+        "@tiptap/react": "^3.31.3",
+        "@tiptap/starter-kit": "^3.31.3",
+        "@tiptap/y-tiptap": "^3.0.7",
+        "express": "^5.2.1",
+        "lib0": "^0.2.117",
+        "durable-actors": "0.2.4",
+        "react": "^19.3.0",
+        "react-dom": "^19.3.0",
+        "yjs": "^13.6.32"
+    },
+    "devDependencies": {
+        "@types/express": "^5.0.0",
+        "@types/node": "^22.0.0",
+        "@types/react": "^19.0.0",
+        "@types/react-dom": "^19.0.0",
+        "tsx": "^4.0.0",
+        "typescript": "~5.9.3",
+        "vite": "^8.3.0"
+    }
+}

package/dist/templates/documents/src/App.tsx

@@ -0,0 +1,81 @@
+import { useEffect, useRef, useState } from "react"
+import { createRoot } from "react-dom/client"
+
+import { DocumentEditor } from "./Editor.js"
+import "./style.css"
+
+function App() {
+    const workspace = useRef<WebSocket | undefined>(undefined)
+    const [documents, setDocuments] = useState<{ id: string; title: string }[]>([])
+    const [selected, select] = useState("welcome")
+    const [status, setStatus] = useState("connecting")
+
+    useEffect(() => {
+        let disposed = false
+        async function open() {
+            const response = await fetch("/api/socket/Workspace/demo", { method: "POST" })
+            if (!response.ok) throw new Error(`Connection denied (${response.status})`)
+            const { websocketUrl } = await response.json()
+            if (disposed) return
+            const socket = new WebSocket(websocketUrl)
+            workspace.current = socket
+            socket.onopen = () => {
+                if (!disposed) setStatus("open")
+            }
+            socket.onmessage = event => {
+                if (!disposed) setDocuments(JSON.parse(event.data))
+            }
+            socket.onclose = () => {
+                if (!disposed) setStatus("closed")
+            }
+            socket.onerror = () => {
+                if (!disposed) setStatus("error")
+            }
+        }
+        void open().catch(error => {
+            if (disposed) return
+            setStatus("error")
+            console.error(error)
+        })
+        return () => {
+            disposed = true
+            workspace.current?.close()
+        }
+    }, [])
+
+    function create(form: FormData) {
+        const title = String(form.get("title")).trim()
+        if (!title || workspace.current?.readyState !== WebSocket.OPEN) return
+        const id = crypto.randomUUID()
+        workspace.current.send(JSON.stringify({ id, title }))
+        select(id)
+    }
+
+    return (
+        <div className="app">
+            <header>
+                <h1>Documents</h1>
+                <p>Open another tab to write together.</p>
+            </header>
+            <main>
+                <aside aria-label="Document list">
+                    <form action={create}>
+                        <input name="title" aria-label="New document title" placeholder="Document title" required disabled={status !== "open"} />
+                        <button disabled={status !== "open"}>Add document</button>
+                    </form>
+                    <nav aria-label="Documents">
+                        {documents.map(document => (
+                            <button key={document.id} aria-current={selected === document.id ? "page" : undefined} onClick={() => select(document.id)}>
+                                {document.title}
+                            </button>
+                        ))}
+                    </nav>
+                    {(status === "error" || status === "closed") && <p role="alert">Disconnected. Reload to retry.</p>}
+                </aside>
+                <DocumentEditor key={selected} id={selected} title={documents.find(document => document.id === selected)?.title ?? "New document"} />
+            </main>
+        </div>
+    )
+}
+
+createRoot(document.getElementById("root")!).render(<App />)

package/dist/templates/documents/src/Editor.tsx

@@ -0,0 +1,69 @@
+import { useEffect, useState } from "react"
+
+import Collaboration from "@tiptap/extension-collaboration"
+import { EditorContent, useEditor, useEditorState } from "@tiptap/react"
+import StarterKit from "@tiptap/starter-kit"
+import type { Doc } from "yjs"
+
+import { openDocument } from "./collaboration.js"
+import type { ConnectionStatus } from "./collaboration.js"
+
+export function DocumentEditor({ id, title }: DocumentProps) {
+    const [document, setDocument] = useState<Doc>()
+    const [status, setStatus] = useState<ConnectionStatus>("connecting")
+
+    useEffect(() => {
+        const session = openDocument(id, status => {
+            setStatus(status)
+            if (status === "open") setDocument(session.document)
+        })
+        return session.close
+    }, [id])
+
+    return (
+        <section aria-label={title}>
+            <div className="document-heading">
+                <h2>{title}</h2>
+                <span role="status">{status === "open" ? "Connected" : status === "connecting" ? "Connecting…" : "Disconnected. Reload to retry."}</span>
+            </div>
+            {document ? <RichText document={document} connected={status === "open"} /> : <p>Loading document…</p>}
+        </section>
+    )
+}
+
+function RichText({ document, connected }: EditorProps) {
+    const editor = useEditor({
+        extensions: [StarterKit.configure({ undoRedo: false }), Collaboration.configure({ document })],
+        editorProps: { attributes: { role: "textbox", "aria-label": "Document content", "aria-multiline": "true" } }
+    })
+    const active = useEditorState({
+        editor,
+        selector: ({ editor }) => ({ bold: editor?.isActive("bold"), italic: editor?.isActive("italic"), heading: editor?.isActive("heading"), list: editor?.isActive("bulletList") })
+    })
+    useEffect(() => {
+        editor?.setEditable(connected)
+    }, [editor, connected])
+
+    return (
+        <>
+            <div className="formatting" role="group" aria-label="Formatting">
+                <button disabled={!connected} aria-pressed={active?.bold} onClick={() => editor?.chain().focus().toggleBold().run()}>
+                    Bold
+                </button>
+                <button disabled={!connected} aria-pressed={active?.italic} onClick={() => editor?.chain().focus().toggleItalic().run()}>
+                    Italic
+                </button>
+                <button disabled={!connected} aria-pressed={active?.heading} onClick={() => editor?.chain().focus().toggleHeading({ level: 2 }).run()}>
+                    Heading
+                </button>
+                <button disabled={!connected} aria-pressed={active?.list} onClick={() => editor?.chain().focus().toggleBulletList().run()}>
+                    List
+                </button>
+            </div>
+            <EditorContent editor={editor} />
+        </>
+    )
+}
+
+type DocumentProps = { id: string; title: string }
+type EditorProps = { document: Doc; connected: boolean }

package/dist/templates/documents/src/backend.ts

@@ -0,0 +1,18 @@
+import express from "express"
+import { createServer } from "vite"
+
+import { actors } from "../generated/index.js"
+
+const app = express()
+
+app.post("/api/socket/:actorName/:actorId", async (request, response) => {
+    const { actorName, actorId } = request.params
+    if (actorName !== "Workspace" && actorName !== "Document") return response.sendStatus(404)
+    response.set("Cache-Control", "no-store").json(await actors[actorName].prepareWebsocket({ actorId, metadata: null }))
+})
+
+const vite = await createServer({
+    server: { middlewareMode: true, fs: { deny: [".env", ".env.*", "**/.durable-actors/**", "**/.little-actors/**", "**/.git/**"] } }
+})
+app.use(vite.middlewares)
+app.listen(3000, "127.0.0.1", () => console.log("Documents: http://127.0.0.1:3000"))

package/dist/templates/documents/src/collaboration.ts

@@ -0,0 +1,46 @@
+import { fromBase64, toBase64 } from "lib0/buffer"
+import * as Y from "yjs"
+
+export type ConnectionStatus = "connecting" | "open" | "closed" | "error"
+
+export function openDocument(id: string, onStatus: (status: ConnectionStatus) => void) {
+    let socket: WebSocket | undefined
+    let disposed = false
+    const document = new Y.Doc()
+    const send = (update: Uint8Array, origin: unknown) => {
+        if (origin !== socket && socket?.readyState === WebSocket.OPEN) socket.send(JSON.stringify(toBase64(update)))
+    }
+    document.on("update", send)
+    async function open() {
+        const response = await fetch(`/api/socket/Document/${encodeURIComponent(id)}`, { method: "POST" })
+        if (!response.ok) throw new Error(`Connection denied (${response.status})`)
+        const { websocketUrl } = await response.json()
+        if (disposed) return
+        socket = new WebSocket(websocketUrl)
+        socket.onmessage = event => {
+            if (disposed) return
+            Y.applyUpdate(document, fromBase64(JSON.parse(event.data)), socket)
+            onStatus("open")
+        }
+        socket.onclose = () => {
+            if (!disposed) onStatus("closed")
+        }
+        socket.onerror = () => {
+            if (!disposed) onStatus("error")
+        }
+    }
+    void open().catch(error => {
+        if (disposed) return
+        onStatus("error")
+        console.error(error)
+    })
+    return {
+        document,
+        close() {
+            document.off("update", send)
+            disposed = true
+            socket?.close()
+            document.destroy()
+        }
+    }
+}

package/dist/templates/documents/src/durable-objects.ts

@@ -0,0 +1,48 @@
+import { fromBase64, toBase64 } from "lib0/buffer"
+import { Actor, Persisted } from "durable-actors"
+import type { ActorSocket } from "durable-actors"
+import * as Y from "yjs"
+
+export class Workspace extends Actor<null, DocumentInfo, DocumentInfo[]> {
+    @Persisted documents: DocumentInfo[] = [{ id: "welcome", title: "Welcome" }]
+
+    async onConnect(socket: ActorSocket<null, DocumentInfo[]>) {
+        socket.send(this.documents)
+    }
+
+    async onMessage(_socket: ActorSocket<null, DocumentInfo[]>, document: DocumentInfo) {
+        if (!this.documents.some(item => item.id === document.id)) this.documents.push(document)
+        this.broadcast(this.documents)
+    }
+}
+
+export class Document extends Actor<null, string, string> {
+    @Persisted content = emptyDocument()
+
+    async onConnect(socket: ActorSocket<null, string>) {
+        socket.send(this.content)
+    }
+
+    async onMessage(_socket: ActorSocket<null, string>, update: string) {
+        const document = new Y.Doc()
+        try {
+            Y.applyUpdate(document, fromBase64(this.content))
+            Y.applyUpdate(document, fromBase64(update))
+            this.content = toBase64(Y.encodeStateAsUpdate(document))
+            this.broadcast(this.content)
+        } finally {
+            document.destroy()
+        }
+    }
+}
+
+function emptyDocument() {
+    const document = new Y.Doc()
+    // Seed on the server so simultaneous first joins share the same paragraph.
+    document.getXmlFragment("default").push([new Y.XmlElement("paragraph")])
+    const content = toBase64(Y.encodeStateAsUpdate(document))
+    document.destroy()
+    return content
+}
+
+type DocumentInfo = { id: string; title: string }