feat(celld): Durable Objects on AWS via denoland/celld

[sam-goodwin]

Self-hosted Durable Objects on AWS, built on celld. A top-level Celld namespace mirroring celld's own model: a Fleet is the infrastructure (nodes + an S3 bucket), it runs one Worker deployment, and the Worker contains the cells (Durable Objects). Hosting is a pluggable layer — AWS.providers() contributes the aws-ecs fleet host.

Start with a single file — a Fleet, a Worker deployed onto it, and an inline cell; the Worker's fetch runs on the fleet's nodes with native access to the cells:

// cells.ts
export class Cells extends Celld.Fleet<Cells>()("Cells", {
  instances: 2,
}) {}

export class Counter extends Celld.DurableObject<Counter>()(
  "Counter",
  Effect.gen(function* () {
    const state = yield* Celld.DurableObjectState;
    return Effect.gen(function* () {
      const count = (yield* state.storage.get<number>("count")) ?? 0;
      return {
        increment: () =>
          Effect.gen(function* () {
            const next = count + 1;
            yield* state.storage.put("count", next);
            return next;
          }),
      };
    });
  }),
) {}

export default class CellsWorker extends Celld.Worker<CellsWorker>()(
  "CellsWorker",
  { fleet: () => Cells, main: import.meta.url },
  Effect.gen(function* () {
    const counters = yield* Counter;
    return {
      fetch: Effect.gen(function* () {
        const request = yield* HttpServerRequest;
        const room =
          new URL(request.url, "http://cells").pathname.slice(1) || "lobby";
        const value = yield* counters.getByName(room).increment();
        return yield* HttpServerResponse.json({ room, value });
      }),
    };
  }),
) {}

As the app grows, split the cell from the Worker — the class becomes a pure tag and the layer binds the implementation to the Worker that hosts it:

// counter.ts
export class Counter extends Celld.DurableObject<Counter>()("Counter") {}

export const CounterLive = Counter.make(
  CellsWorker,
  Effect.gen(function* () {
    /* same two-phase impl as above */
  }),
);

// main.ts — the deployable Worker module hosts the class by providing the layer
export default CellsWorker.make(
  { fleet: Cells, main: import.meta.url },
  Effect.gen(function* () {
    const counters = yield* Counter;
    return { fetch: /* … */ };
  }).pipe(Effect.provide(CounterLive)),
);

Running the same class on a different Worker is just a different layer, and any other binding host connects the same way — a Lambda Function provides Counter.client(CellsWorker) (network attachment + connection secrets bind automatically) and calls cells over the fleet gateway:

export const CounterOnEdge = Counter.make(EdgeWorker, impl);

// api.ts — an AWS Lambda caller
Effect.gen(function* () {
  const counters = yield* Counter;
  const n = yield* counters.getByName("room-1").increment();
  // ...
}).pipe(Effect.provide(Counter.client(CellsWorker)));

RPC methods behave like local Effects — Stream-returning methods arrive as Streams, and Effect.fail decodes as the typed failure on the caller.

🤖 Generated with Claude Code