A tiny server for every thing you care about.

export class Whiteboard extends DurableObject {
  strokes: Stroke[] = [];                 // authoritative, in-memory

  async fetch(req: Request) {
    const url = new URL(req.url);
    const [client, server] = Object.values(new WebSocketPair());
    this.ctx.acceptWebSocket(server, [url.searchParams.get("user") ?? "guest"]);
    server.send(JSON.stringify({ type: "init", strokes: this.strokes }));
    return new Response(null, { status: 101, webSocket: client });
  }

  async webSocketMessage(ws: WebSocket, raw: string) {
    const stroke = JSON.parse(raw);
    this.strokes.push(stroke);            // serialized: no two-at-once
    this.ctx.storage.sql.exec(
      "INSERT INTO strokes (id, points) VALUES (?, ?)",
      stroke.id, JSON.stringify(stroke.points),
    );
    this.broadcastBut(ws, raw);           // everyone else draws it live
  }

  broadcastBut(sender: WebSocket, text: string) {
    for (const peer of this.ctx.getWebSockets()) if (peer !== sender) peer.send(text);
  }
}

export class Chat extends DurableObject {
  async fetch(request: Request) {
    const [client, server] = Object.values(new WebSocketPair());
    this.ctx.acceptWebSocket(server);           // hibernation on
    return new Response(null, { status: 101, webSocket: client });
  }

  async webSocketMessage(ws: WebSocket, msg: string) {
    this.ctx.storage.sql.exec(
      "INSERT INTO messages (user, body) VALUES (?, ?)",
      this.userOf(ws), msg,
    );
    this.broadcast(JSON.stringify({ from: this.userOf(ws), text: msg }));
  }

  // Hibernation-safe: rehydrate from storage on wake, not from RAM.
  async webSocketClose(ws: WebSocket) {
    this.broadcast(JSON.stringify({ presence: "left", user: this.userOf(ws) }));
  }

  broadcast(text: string) {
    for (const peer of this.ctx.getWebSockets()) peer.send(text);
  }
}

export class RateLimiter extends DurableObject {
  limit: number;
  windowStart = Date.now();
  count = 0;

  constructor(ctx: DurableObjectState, env: Env) {
    super(ctx, env);
    this.limit = Number(ctx.id.name.split(":")[1] ?? 100); // "user-42:100"
  }

  // Called directly from any Worker via RPC — billed as one request.
  async check(cost = 1): Promise<{ ok: boolean; remaining: number }> {
    const now = Date.now();
    if (now - this.windowStart > 60_000) {     // new minute window
      this.windowStart = now;
      this.count = 0;
    }
    if (this.count + cost > this.limit) {
      await this.ctx.storage.put("lastDenied", now);
      return { ok: false, remaining: 0 };
    }
    this.count += cost;                          // atomic: one thread
    await this.ctx.storage.put("count", this.count);
    return { ok: true, remaining: this.limit - this.count };
  }
}

// Worker side:
// const id = env.RATE_LIMITERS.idFromName(`user-42:${100}`);
// const { ok } = await env.RATE_LIMITERS.get(id).check();

export class LiveFeed extends DurableObject {
  subscribers = new Set();

  async fetch(req: Request) {
    const [client, server] = Object.values(new WebSocketPair());
    this.ctx.acceptWebSocket(server);
    return new Response(null, { status: 101, webSocket: client });
  }

  // Any Worker (or another object, or a Queue consumer) can call this:
  async publish(event: string) {
    let sent = 0;
    for (const ws of this.ctx.getWebSockets()) {
      ws.send(event);                        // fan-out: one loop, one hop
      sent++;
    }
    // Tag+subscribe fan-out: this.ctx.getWebSockets("esports") filters topics.
    return sent;
  }

  // Keep the hot path cheap: answer pings without waking the object.
  async webSocketMessage() {}
}

export class IngestJob extends DurableObject {
  attempts = 0;

  async run(payload: unknown) {
    this.ctx.storage.sql.exec(
      "INSERT INTO runs (payload, status) VALUES (?, 'running')",
      JSON.stringify(payload),
    );
    await this.ctx.storage.setAlarm(Date.now() + 1_000);  // tick in 1s
  }

  async alarm() {                       // retries survive restarts
    const cursor = await this.ctx.storage.get("cursor") ?? 0;
    try {
      const next = await this.processBatch(cursor);
      await this.ctx.storage.put("cursor", next);
      if (next !== null) {
        await this.ctx.storage.setAlarm(Date.now() + 1_000); // keep going
      } else {
        this.ctx.storage.sql.exec("UPDATE runs SET status='done'");
      }
    } catch (err) {
      this.attempts++;
      const backoff = Math.min(2 ** this.attempts, 3600) * 1_000;
      await this.ctx.storage.setAlarm(Date.now() + backoff); // retry later
    }
  }
}

// The entire multi-tenant routing layer:
export default {
  async fetch(req, env) {
    const tenant = new URL(req.url).host.split(".")[0];   // acme.app.example.com

    // One object — one database — per tenant. That's the whole model.
    const id = env.TENANT_DB.idFromName(tenant);
    return env.TENANT_DB.get(id).fetch(req);
  },
};

export class TenantDB extends DurableObject {
  async query(sql: string, params: unknown[]) {
    // No WHERE tenant_id = ? — this database *is* the tenant's.
    return [...this.ctx.storage.sql.exec(sql, ...params)];
  }
}

export class SupportAgent extends DurableObject {
  memory() {
    return this.ctx.storage.sql.exec(
      "SELECT role, content FROM turns ORDER BY id",
    );
  }

  async userTurn(text: string) {
    this.ctx.storage.sql.exec(
      "INSERT INTO turns (role, content) VALUES ('user', ?)", text,
    );
    const reply = await this.think([...this.memory()]);   // model call
    this.ctx.storage.sql.exec(
      "INSERT INTO turns (role, content) VALUES ('agent', ?)", reply,
    );
    this.push(reply);                                      // live, if attached
    return reply;
  }

  // "Follow up tomorrow at 9am if the ticket is still open."
  async schedule(delayMs: number) {
    await this.ctx.storage.setAlarm(Date.now() + delayMs);
  }

  async alarm() {
    const open = await this.ctx.storage.get("ticketOpen");
    if (open) this.push("Checking in — did that fix work?");
  }

  push(text: string) {
    for (const ws of this.ctx.getWebSockets()) ws.send(text);
  }
}