A tiny stateful server for every thing in your app.

export class Document extends DurableObject {
  async fetch(request: Request) {
    const { 0: client, 1: server } = new WebSocketPair();
    this.ctx.acceptWebSocket(server);        // hibernation-friendly
    return new Response(null, { status: 101, webSocket: client });
  }

  async webSocketMessage(ws: WebSocket, raw: string) {
    const edit = JSON.parse(raw);
    // Single-threaded = edits apply in one global order. No OT server.
    this.ctx.storage.sql.exec(
      "INSERT INTO ops (site, op, ts) VALUES (?, ?, ?)",
      edit.site, JSON.stringify(edit.op), Date.now());
    for (const peer of this.ctx.getWebSockets())
      if (peer !== ws) peer.send(raw);       // fan out to every cursor
  }
}

export class Match extends DurableObject {
  state = { players: new Map(), tick: 0 };

  async webSocketMessage(ws: WebSocket, raw: string) {
    const input = JSON.parse(raw);
    this.applyInput(input);                  // ordered, race-free
    if (!(await this.ctx.storage.getAlarm()))
      await this.ctx.storage.setAlarm(Date.now() + 50);
  }

  async alarm() {                            // the game loop, 20 Hz
    this.state.tick++;
    this.stepPhysics();
    const frame = JSON.stringify(this.state);
    for (const ws of this.ctx.getWebSockets()) ws.send(frame);
    if (this.state.players.size)
      await this.ctx.storage.setAlarm(Date.now() + 50);
  }
}

export class Room extends DurableObject {
  async webSocketMessage(ws: WebSocket, raw: string) {
    const { user } = ws.deserializeAttachment();   // survives hibernation
    this.ctx.storage.sql.exec(
      "INSERT INTO messages (user, body, ts) VALUES (?, ?, ?)",
      user, raw, Date.now());
    this.broadcast({ type: "message", user, body: raw });
  }

  async webSocketClose(ws: WebSocket) {
    const { user } = ws.deserializeAttachment();
    this.broadcast({ type: "presence", user, online: false });
  }

  presence() {   // live sockets ARE the presence list
    return this.ctx.getWebSockets()
      .map((ws) => ws.deserializeAttachment().user);
  }
}

export class RateLimiter extends DurableObject {
  tokens = 10; last = Date.now();

  // One object per API key: all checks serialize right here.
  async allow(): Promise<boolean> {
    const now = Date.now();
    this.tokens = Math.min(10, this.tokens + (now - this.last) / 1000);
    this.last = now;
    if (this.tokens < 1) return false;   // atomic: no interleaving
    this.tokens -= 1;
    return true;
  }
}

// worker.ts — three lines to enforce it at the edge
const limiter = env.LIMITERS.getByName(apiKey);
if (!(await limiter.allow()))
  return new Response("429 Too Many Requests", { status: 429 });

export class Topic extends DurableObject {
  async fetch(request: Request) {       // subscribers connect here
    const { 0: client, 1: server } = new WebSocketPair();
    this.ctx.acceptWebSocket(server);   // hibernates while quiet
    return new Response(null, { status: 101, webSocket: client });
  }

  async publish(event: unknown) {       // producers call this via RPC
    const msg = JSON.stringify(event);
    for (const ws of this.ctx.getWebSockets()) ws.send(msg);
    return this.ctx.getWebSockets().length;   // delivered count
  }
}

// Anywhere in your Worker — publish to match "liv-ars":
await env.TOPICS.getByName("scores:liv-ars").publish({ goal: "LIV 2-1" });

export class WebhookOutbox extends DurableObject {
  async enqueue(url: string, payload: unknown) {
    this.ctx.storage.sql.exec(
      "INSERT INTO jobs (url, body, tries) VALUES (?, ?, 0)",
      url, JSON.stringify(payload));
    await this.ctx.storage.setAlarm(Date.now());   // drain now
  }

  async alarm() {
    const job = this.ctx.storage.sql
      .exec("SELECT * FROM jobs ORDER BY id LIMIT 1").toArray()[0];
    if (!job) return;                              // queue drained
    const ok = (await fetch(job.url, { method: "POST", body: job.body })).ok;
    if (ok) this.ctx.storage.sql.exec("DELETE FROM jobs WHERE id = ?", job.id);
    else this.ctx.storage.sql.exec(
      "UPDATE jobs SET tries = tries + 1 WHERE id = ?", job.id);
    const delay = ok ? 0 : Math.min(60_000, 1000 * 2 ** job.tries);
    await this.ctx.storage.setAlarm(Date.now() + delay);  // next / backoff
  }
}

export class Tenant extends DurableObject {
  constructor(ctx: DurableObjectState, env: Env) {
    super(ctx, env);
    ctx.storage.sql.exec(`CREATE TABLE IF NOT EXISTS invoices (
      id INTEGER PRIMARY KEY, total REAL, status TEXT, due TEXT)`);
  }

  invoicesDue(): Invoice[] {   // zero-latency: SQLite is local
    return this.ctx.storage.sql.exec<Invoice>(
      "SELECT * FROM invoices WHERE status = 'open' ORDER BY due"
    ).toArray();
  }
}

// "acme-corp" gets its own database. So does every other tenant.
const tenant = env.TENANTS.getByName("acme-corp");
const due = await tenant.invoicesDue();

export class Assistant extends DurableObject {
  async chat(userMsg: string) {
    this.remember("user", userMsg);
    const reply = await this.env.AI.run("@cf/meta/llama-3.3-70b", {
      messages: this.recall(20),          // memory: local SQLite
    });
    this.remember("assistant", reply.response);
    return reply.response;
  }

  async scheduleFollowUp(inMs: number) {  // "check back tomorrow"
    await this.ctx.storage.setAlarm(Date.now() + inMs);
  }

  async alarm() {                          // wakes up on its own
    const nudge = await this.chat("It's time — run the follow-up.");
    for (const ws of this.ctx.getWebSockets()) ws.send(nudge);
  }
}