@alchemy.run/effect-cluster 0.0.0 → 2.0.0-beta.87

package/src/Hetzner/Database.ts

@@ -0,0 +1,142 @@
+import * as Hetzner from "@alchemy.run/hetzner";
+import * as Output from "alchemy/Output";
+import { Random } from "alchemy/Random";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Redacted from "effect/Redacted";
+import { clusterShardGroups, Database as ClusterDatabase } from "../Database.ts";
+import type { Providers } from "../Providers.ts";
+
+export interface DatabaseProps {
+  /**
+   * Hetzner location of the database and the cluster's Network.
+   * @default "nbg1"
+   */
+  location?: string;
+  /**
+   * Server type of the database.
+   * @default "cx23"
+   */
+  serverType?: string;
+  /**
+   * Size of the database's Volume, in GB (at least 10).
+   * @default 10
+   */
+  diskSize?: number;
+  /**
+   * Postgres image.
+   * @default "postgres:17-alpine"
+   */
+  image?: string;
+  /**
+   * IPv4 range of the cluster's private Network.
+   * @default "10.46.0.0/16"
+   */
+  ipRange?: string;
+}
+
+/** The network zone a location belongs to. */
+const networkZoneOf = (location: string) =>
+  location.startsWith("ash")
+    ? "us-east"
+    : location.startsWith("hil")
+      ? "us-west"
+      : location.startsWith("sin")
+        ? "ap-southeast"
+        : "eu-central";
+
+const shellQuote = (value: string) => `'${value.replaceAll("'", `'"'"'`)}'`;
+
+/** Mount the Volume and run Postgres on it, on the Server's own network. */
+const userData = (options: { volumeId: number; image: string; password: string }) => `#!/bin/bash
+set -euo pipefail
+DEVICE=/dev/disk/by-id/scsi-0HC_Volume_${options.volumeId}
+for _ in $(seq 1 60); do [ -e "$DEVICE" ] && break; sleep 2; done
+blkid "$DEVICE" >/dev/null || mkfs.ext4 -F "$DEVICE"
+mkdir -p /mnt/postgres
+grep -q " /mnt/postgres " /etc/fstab || echo "$DEVICE /mnt/postgres ext4 discard,nofail,defaults 0 0" >> /etc/fstab
+mountpoint -q /mnt/postgres || mount /mnt/postgres
+until docker info >/dev/null 2>&1; do sleep 2; done
+docker rm -f postgres >/dev/null 2>&1 || true
+docker run -d --name postgres --restart always --network host \\
+  -v /mnt/postgres:/var/lib/postgresql/data \\
+  -e PGDATA=/var/lib/postgresql/data/pgdata \\
+  -e POSTGRES_DB=cluster \\
+  -e POSTGRES_PASSWORD=${shellQuote(options.password)} \\
+  ${shellQuote(options.image)}
+`;
+
+/**
+ * The database an Effect Cluster coordinates through, on Hetzner Cloud, as
+ * a `Cluster.Database` Layer: Postgres on a Server with a Volume, on a
+ * private Network that the pool's Servers attach to. A firewall drops every
+ * inbound connection on the Server's public address; runners reach it
+ * over the Network.
+ *
+ * ### Running the database on Hetzner
+ * **Example:** Postgres in Nuremberg
+ * ```typescript
+ * export const Database = ClusterHetzner.Database("Cluster");
+ * ```
+ *
+ * @primitive
+ */
+export const Database = (id: string, props: DatabaseProps = {}) =>
+  Layer.effect(
+    ClusterDatabase,
+    Effect.gen(function* () {
+      if (globalThis.__ALCHEMY_RUNTIME__) {
+        // Runners read their database from their own environment at runtime.
+        return { url: Redacted.make(""), shardGroups: undefined as never };
+      }
+      const location = props.location ?? "nbg1";
+      const ipRange = props.ipRange ?? "10.46.0.0/16";
+      const password = yield* Random(`${id}Password`, { bytes: 24 }) as unknown as Effect.Effect<
+        Random,
+        never,
+        Providers
+      >;
+      const network = yield* Hetzner.Network(`${id}Network`, {
+        ipRange,
+        subnets: [{ type: "cloud", networkZone: networkZoneOf(location) }],
+      });
+      // No inbound rules: only the Network reaches Postgres.
+      const firewall = yield* Hetzner.Firewall(`${id}Firewall`, {});
+      const volume = yield* Hetzner.Volume(`${id}Data`, {
+        size: props.diskSize ?? 10,
+        format: "ext4",
+        location,
+      });
+      const server = yield* Hetzner.Server(`${id}Postgres`, {
+        serverType: props.serverType ?? "cx23",
+        // Hetzner's Ubuntu image with Docker preinstalled.
+        image: "docker-ce",
+        location,
+        // IPv4 pulls the Postgres image; IPv6 would only spend an address.
+        enableIpv6: false,
+        networks: [network],
+        firewalls: [firewall],
+        volumes: [volume],
+        userData: Output.all(volume.id, password.text).pipe(
+          Output.map(([volumeId, text]) =>
+            userData({
+              volumeId,
+              image: props.image ?? "postgres:17-alpine",
+              password: Redacted.value(text),
+            }),
+          ),
+        ) as unknown as string,
+      });
+      return {
+        url: Output.all(server.privateIps, password.text).pipe(
+          Output.map(([ips, text]) =>
+            Redacted.make(
+              `postgres://postgres:${encodeURIComponent(text.pipe(Redacted.value))}@${ips[0]}:5432/cluster`,
+            ),
+          ),
+        ),
+        network: { kind: "hetzner" as const, networkId: network.networkId, ipRange, location },
+        shardGroups: yield* clusterShardGroups(id),
+      };
+    }),
+  );

package/src/Hetzner/ServerPool.ts

@@ -0,0 +1,116 @@
+import * as Hetzner from "@alchemy.run/hetzner";
+import * as Output from "alchemy/Output";
+import * as Effect from "effect/Effect";
+import { GATEWAY_PORT } from "../internal/Gateway.ts";
+import { makePoolLayer, type PoolSettings } from "../internal/PoolHost.ts";
+
+export interface ServerPoolOptions extends PoolSettings {
+  /**
+   * Number of runners, one Server each.
+   * @default 2
+   */
+  replicas?: number;
+  /**
+   * Server type of each runner.
+   * @default "cx23"
+   */
+  serverType?: string;
+}
+
+/** The label the gateway's Load Balancer finds the pool's Servers by. */
+const POOL_LABEL = "cluster-pool";
+
+/**
+ * Run a pool of Effect Cluster runners on Hetzner Cloud: Servers on the
+ * database's private Network, each running every class given these
+ * runners as a `Hetzner.Service`, behind a Load Balancer that serves their
+ * gateway to callers anywhere. Runners talk to each other and the database
+ * over the Network; their firewall only lets SSH in, which deploys them.
+ * Requires a database on a Hetzner Network — `ClusterHetzner.Database`.
+ *
+ * ### Running on Hetzner
+ * **Example:** Two runners
+ * ```typescript
+ * export const Database = ClusterHetzner.Database("Cluster");
+ * export const Default = ClusterHetzner.ServerPool("Default", { replicas: 2 }).pipe(
+ *   Layer.provide(Database),
+ * );
+ * ```
+ *
+ * @primitive
+ */
+export const ServerPool = (id: string, options: ServerPoolOptions = {}) =>
+  makePoolLayer({
+    label: "ClusterHetzner.ServerPool",
+    id,
+    settings: options,
+    expected: "a Hetzner Network (ClusterHetzner.Database)",
+    network: (database) => (database.network?.kind === "hetzner" ? database.network : undefined),
+    // The Load Balancer finds the Servers by label, so it needs none of them.
+    gateway: (name, network) =>
+      Effect.gen(function* () {
+        const balancer = yield* Hetzner.LoadBalancer(`${id}Gateway`, {
+          loadBalancerType: "lb11",
+          location: network.location,
+          // A stub of the database's Network, by id.
+          networks: [{ networkId: network.networkId } as unknown as Hetzner.Network],
+          services: [
+            {
+              protocol: "tcp",
+              listenPort: 80,
+              destinationPort: GATEWAY_PORT,
+              healthCheck: {
+                protocol: "http",
+                port: GATEWAY_PORT,
+                interval: 10,
+                timeout: 5,
+                retries: 3,
+                http: { path: "/health" },
+              },
+            },
+          ],
+          targets: [
+            { type: "label_selector", selector: `${POOL_LABEL}=${name}`, usePrivateIp: true },
+          ],
+        });
+        return { url: Output.interpolate`http://${balancer.ipv4}` };
+      }),
+    nodes: ({ network, name, program, environment }) =>
+      Effect.gen(function* () {
+        const firewall = yield* Hetzner.Firewall(`${id}Firewall`, {
+          rules: [
+            {
+              description: "SSH, which deploys the pool",
+              direction: "in",
+              protocol: "tcp",
+              port: "22",
+              sourceIps: ["0.0.0.0/0", "::/0"],
+            },
+          ],
+        });
+        for (let i = 0; i < (options.replicas ?? 2); i++) {
+          const server = yield* Hetzner.Server(`${id}Runner${i}`, {
+            serverType: options.serverType ?? "cx23",
+            image: "ubuntu-24.04",
+            location: network.location,
+            // IPv4 installs Node and deploys over SSH; IPv6 would only spend an address.
+            enableIpv6: false,
+            networks: [{ networkId: network.networkId as number }],
+            firewalls: [firewall],
+            labels: { [POOL_LABEL]: name },
+          });
+          yield* Hetzner.Service(`${id}Runner${i}Service`, {
+            server,
+            main: program.pipe(Output.map((p) => `${p.dir}/runner.mjs`)) as unknown as string,
+            port: GATEWAY_PORT,
+            env: environment.pipe(
+              // Each runner finds its own address in the Network's range.
+              Output.map((env) => ({
+                ...env,
+                CLUSTER_RUNNER_NETWORK: network.ipRange,
+              })),
+            ) as unknown as Record<string, string>,
+          });
+        }
+      }),
+  });

package/src/Hetzner/index.ts

@@ -0,0 +1,6 @@
+/**
+ * @alchemy.run/effect-cluster/Hetzner — run an Effect Cluster's database and
+ * runners on Hetzner Cloud. Requires `@alchemy.run/hetzner`.
+ */
+export * from "./Database.ts";
+export * from "./ServerPool.ts";

package/src/Host.ts

@@ -0,0 +1,68 @@
+/**
+ * What a platform built on Effect Cluster entities, such as
+ * `@alchemy.run/domain/EffectCluster`, needs from the runner it is built on
+ * and from the gateway its callers reach entities through.
+ *
+ * @module
+ */
+import * as Context from "effect/Context";
+import type * as Effect from "effect/Effect";
+import type * as Layer from "effect/Layer";
+import type { HostedEntity } from "./Entity.ts";
+
+export { type GatewayTarget, makeNamespace } from "./internal/Gateway.ts";
+export { HasNoPool } from "./internal/HostedRuntime.ts";
+
+/**
+ * The runner a Layer is being built on. A runner's bootstrap provides it
+ * while it builds its entrypoints, so a Layer that hosts an entity itself
+ * (a Domain platform's, built by the model's Layer rather than exported as
+ * a class) hands the runner that entity, and the Layer to launch with it
+ * inside the cluster (with Sharding and the workflow engine). Anywhere
+ * else, the service is absent.
+ */
+export class RunnerHost extends Context.Service<
+  RunnerHost,
+  {
+    /** Host an entity on this runner, launching `layer` in the cluster beside it. */
+    readonly host: (
+      entity: HostedEntity,
+      layer: Layer.Layer<never, never, any>,
+    ) => Effect.Effect<void>;
+  }
+>()("Cluster.RunnerHost") {}
+
+/** Options for {@link InstanceStorage}'s `list`. Keys come back in order. */
+export interface InstanceStorageListOptions {
+  /** Only keys that start with this prefix. */
+  readonly prefix?: string;
+  /** Only keys at or after this key. */
+  readonly start?: string;
+  /** Only keys after this key. */
+  readonly startAfter?: string;
+  /** Only keys before this key. */
+  readonly end?: string;
+  /** At most this many entries. */
+  readonly limit?: number;
+}
+
+/**
+ * The key-value storage of the object an entity instance runs on, on pools
+ * that give every instance an object of its own
+ * (`ClusterCloudflare.DurableObjectPool`: the instance's Durable Object).
+ * Values are structured-cloneable; writes inside `transaction` commit
+ * together, or not at all. The pool provides it to every instance it runs;
+ * on pools that share one database, the service is absent.
+ */
+export class InstanceStorage extends Context.Service<
+  InstanceStorage,
+  {
+    get<T>(key: string): Effect.Effect<T | undefined>;
+    put<T>(key: string, value: T): Effect.Effect<void>;
+    put<T>(entries: Record<string, T>): Effect.Effect<void>;
+    delete(key: string): Effect.Effect<boolean>;
+    delete(keys: ReadonlyArray<string>): Effect.Effect<number>;
+    list<T>(options?: InstanceStorageListOptions): Effect.Effect<Map<string, T>>;
+    transaction<A, E, R>(effect: Effect.Effect<A, E, R>): Effect.Effect<A, E, R>;
+  }
+>()("Cluster.InstanceStorage") {}

package/src/Kubernetes/Database.ts

@@ -0,0 +1,89 @@
+import * as Kubernetes from "@alchemy.run/kubernetes";
+import type { Input } from "alchemy/Input";
+import * as Output from "alchemy/Output";
+import { Random } from "alchemy/Random";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Redacted from "effect/Redacted";
+import { clusterShardGroups, Database as ClusterDatabase } from "../Database.ts";
+import { stackDnsLabel } from "../internal/Naming.ts";
+import type { Providers } from "../Providers.ts";
+
+export interface DatabaseProps {
+  /** The cluster the database and runners run on. */
+  cluster: Kubernetes.ClusterLike | Effect.Effect<Input<Kubernetes.ClusterLike>, never, any>;
+  /**
+   * Kubernetes namespace of the database and runners.
+   * @default "default"
+   */
+  namespace?: string;
+  /**
+   * Postgres image.
+   * @default "postgres:17-alpine"
+   */
+  image?: string;
+}
+
+/**
+ * The database an Effect Cluster coordinates through, on Kubernetes, as a
+ * `Cluster.Database` Layer: Postgres as a Deployment behind a ClusterIP
+ * Service, on the cluster the runners run on. Nothing outside the cluster
+ * reaches it.
+ *
+ * Its data lives in the pod, so it is meant for development and tests; for
+ * a managed Postgres (RDS, Cloud SQL, Neon), pass its URL to
+ * `Cluster.Database.fromUrl` and give the pool its cluster.
+ *
+ * ### Running the database on Kubernetes
+ * **Example:** Postgres on a local kind cluster
+ * ```typescript
+ * export const Kind = Kubernetes.LocalCluster("Kind", { name: "cluster" });
+ * export const Database = ClusterKubernetes.Database("Cluster", { cluster: Kind });
+ * ```
+ *
+ * @primitive
+ */
+export const Database = (id: string, props: DatabaseProps) =>
+  Layer.effect(
+    ClusterDatabase,
+    Effect.gen(function* () {
+      if (globalThis.__ALCHEMY_RUNTIME__) {
+        // Runners read their database from their own environment at runtime.
+        return { url: Redacted.make(""), shardGroups: undefined as never };
+      }
+      const namespace = props.namespace ?? "default";
+      const cluster = Effect.isEffect(props.cluster) ? yield* props.cluster : props.cluster;
+      const name = yield* stackDnsLabel(`${id}-db`, 50);
+      const password = yield* Random(`${id}Password`, { bytes: 24 }) as unknown as Effect.Effect<
+        Random,
+        never,
+        Providers
+      >;
+      const db = yield* Kubernetes.Deployment(`${id}Postgres`, {
+        cluster,
+        name,
+        namespace,
+        image: props.image ?? "postgres:17-alpine",
+        port: 5432,
+        serviceType: "ClusterIP",
+        env: password.text.pipe(
+          Output.map((text) => ({
+            POSTGRES_PASSWORD: Redacted.value(text),
+            POSTGRES_DB: "cluster",
+          })),
+        ) as unknown as Record<string, string>,
+      });
+      return {
+        // Ordered after the Deployment: runners connect once it exists.
+        url: Output.all(db.deploymentName, password.text).pipe(
+          Output.map(([, text]) =>
+            Redacted.make(
+              `postgres://postgres:${encodeURIComponent(text.pipe(Redacted.value))}@${name}.${namespace}.svc.cluster.local:5432/cluster`,
+            ),
+          ),
+        ),
+        network: { kind: "kubernetes" as const, cluster, namespace },
+        shardGroups: yield* clusterShardGroups(id),
+      };
+    }),
+  );

package/src/Kubernetes/DeploymentPool.ts

@@ -0,0 +1,77 @@
+import * as Kubernetes from "@alchemy.run/kubernetes";
+import * as Output from "alchemy/Output";
+import * as Effect from "effect/Effect";
+import { GATEWAY_PORT } from "../internal/Gateway.ts";
+import { makePoolLayer, type PoolSettings } from "../internal/PoolHost.ts";
+
+export interface DeploymentPoolOptions extends PoolSettings {
+  /**
+   * Number of runners.
+   * @default 2
+   */
+  replicas?: number;
+  /**
+   * How the gateway's Service is exposed. `ClusterIP` serves callers in the
+   * cluster; `LoadBalancer` serves callers anywhere, where the cluster
+   * provisions load balancers.
+   * @default "ClusterIP"
+   */
+  serviceType?: "ClusterIP" | "NodePort" | "LoadBalancer";
+  /** Container CPU/memory requests and limits. */
+  resources?: {
+    requests?: { cpu?: string; memory?: string };
+    limits?: { cpu?: string; memory?: string };
+  };
+  /**
+   * CPU architecture of the runner image, built on the deploying machine.
+   * @default the cluster's
+   */
+  architecture?: "amd64" | "arm64";
+}
+
+/**
+ * Run a pool of Effect Cluster runners on Kubernetes: a Deployment whose pods
+ * host every class given this pool, in the database's cluster and
+ * namespace. Pods reach each other at their own addresses; the gateway is
+ * a Service of the Deployment, at
+ * `http://{name}.{namespace}.svc.cluster.local:34500` for callers in the
+ * cluster. Requires a database on a Kubernetes cluster —
+ * `ClusterKubernetes.Database`.
+ *
+ * ### Running on Kubernetes
+ * **Example:** Two runners
+ * ```typescript
+ * export const Database = ClusterKubernetes.Database("Cluster", { cluster: Kind });
+ * export const Default = ClusterKubernetes.DeploymentPool("Default", { replicas: 2 }).pipe(
+ *   Layer.provide(Database),
+ * );
+ * ```
+ *
+ * @primitive
+ */
+export const DeploymentPool = (id: string, options: DeploymentPoolOptions = {}) =>
+  makePoolLayer({
+    label: "ClusterKubernetes.DeploymentPool",
+    id,
+    settings: options,
+    expected: "a Kubernetes cluster (ClusterKubernetes.Database)",
+    network: (database) => (database.network?.kind === "kubernetes" ? database.network : undefined),
+    // The Deployment's Service is named after the pool.
+    gateway: (name, network) =>
+      Effect.succeed({
+        url: `http://${name}.${network.namespace}.svc.cluster.local:${GATEWAY_PORT}`,
+      }),
+    nodes: ({ network, name, program, environment }) =>
+      Kubernetes.Deployment(`${id}Pool`, {
+        cluster: network.cluster as Kubernetes.ClusterLike,
+        name,
+        namespace: network.namespace,
+        context: program.pipe(Output.map((p) => p.dir)) as unknown as string,
+        replicas: options.replicas ?? 2,
+        port: GATEWAY_PORT,
+        serviceType: options.serviceType ?? "ClusterIP",
+        ...(options.resources === undefined ? {} : { resources: options.resources }),
+        ...(options.architecture === undefined ? {} : { architecture: options.architecture }),
+        env: environment as unknown as Record<string, string>,
+      }).pipe(Effect.asVoid),
+  });

package/src/Kubernetes/index.ts

@@ -0,0 +1,6 @@
+/**
+ * @alchemy.run/effect-cluster/Kubernetes — run an Effect Cluster's database and
+ * runners on Kubernetes. Requires `@alchemy.run/kubernetes`.
+ */
+export * from "./Database.ts";
+export * from "./DeploymentPool.ts";

package/src/Pool.ts

@@ -0,0 +1,104 @@
+import * as Provider from "alchemy/Provider";
+import { Resource } from "alchemy/Resource";
+import * as Data from "effect/Data";
+import * as Effect from "effect/Effect";
+import type * as Layer from "effect/Layer";
+import type { PoolHost } from "./internal/PoolHostService.ts";
+import type { Providers } from "./Providers.ts";
+
+/**
+ * A pool Layer, as every host's pool returns it: provide it to an
+ * implementation to deploy it to that pool.
+ */
+export type PoolLayer<R = never> = Layer.Layer<PoolHost, never, R>;
+
+/** An entity class a pool is built with. */
+export interface PoolEntity {
+  /** The entity type: the class's logical id. */
+  name: string;
+  /** The module that exports the class. */
+  module: string;
+  /** The export of {@link module} that holds it. */
+  handler: string;
+  /**
+   * An existing Effect Cluster program that hosts the entity, run as it is:
+   * an external `Cluster.Entity`. It owns every runner in its set.
+   */
+  program?: string;
+}
+
+/** Data the entities a pool hosts bind onto it. */
+export interface PoolBindingContract {
+  entities?: PoolEntity[];
+  env?: Record<string, unknown>;
+}
+
+export interface PoolProps {
+  /** The pool's name, used in its service names. */
+  name: string;
+}
+
+export interface PoolAttributes {
+  /** The pool's name. */
+  name: string;
+  /** The entity classes the pool hosts, sorted by type. */
+  entities: PoolEntity[];
+  /** Environment values the hosted classes need, merged. */
+  env: Record<string, unknown>;
+}
+
+export interface Pool extends Resource<
+  "Cluster.Pool",
+  PoolProps,
+  PoolAttributes,
+  PoolBindingContract,
+  Providers
+> {}
+
+/**
+ * The set of entity classes one pool hosts, collected from the
+ * entities that were given it. Pool Layers (`ClusterDocker.SwarmPool`,
+ * …) declare one and build their program from it; it owns nothing in the
+ * cloud.
+ *
+ * @internal
+ */
+export const Pool = Resource<Pool>("Cluster.Pool");
+
+/**
+ * A pool was given an external `Cluster.Entity` and something
+ * else hosted another way: an external program owns every runner it runs on.
+ */
+export class PoolProgramConflict extends Data.TaggedError("Cluster.PoolProgramConflict")<{
+  readonly message: string;
+}> {}
+
+export const PoolProvider = () =>
+  Provider.succeed(Pool, {
+    stables: ["name"],
+    reconcile: ({ id, news, bindings }) =>
+      Effect.gen(function* () {
+        const entities = new Map<string, PoolEntity>();
+        const env: Record<string, unknown> = {};
+        for (const { data } of bindings) {
+          for (const entity of data.entities ?? []) entities.set(entity.name, entity);
+          Object.assign(env, data.env);
+        }
+        const all = [...entities.values()];
+        const programs = new Set(all.flatMap((entity) => (entity.program ? [entity.program] : [])));
+        if (programs.size > 1 || (programs.size === 1 && all.some((entity) => !entity.program))) {
+          return yield* new PoolProgramConflict({
+            message:
+              `Runners '${id}' were given ${all.map((entity) => `'${entity.name}'`).join(", ")}, ` +
+              `but an external program runs on every runner it is given: give each program ` +
+              `a pool of its own, and host Alchemy entities in another pool.`,
+          });
+        }
+        return {
+          name: news.name,
+          entities: [...entities.values()].sort((a, b) => a.name.localeCompare(b.name)),
+          env,
+        };
+      }),
+    delete: () => Effect.void,
+  });

package/src/Providers.ts

@@ -0,0 +1,49 @@
+import * as Provider from "alchemy/Provider";
+import { Random, RandomProvider } from "alchemy/Random";
+import * as Layer from "effect/Layer";
+import { CronProvider, CronResource } from "./Cron.ts";
+import { EntityProvider, EntityResource } from "./Entity.ts";
+import { Pool, PoolProvider } from "./Pool.ts";
+import { ShardGroups, ShardGroupsProvider } from "./ShardGroups.ts";
+import { SingletonProvider, SingletonResource } from "./Singleton.ts";
+import { WorkflowProvider, WorkflowResource } from "./Workflow.ts";
+
+/** Service tag bundling every Effect Cluster provider. */
+export class Providers extends Provider.ProviderCollection<Providers>()("Cluster") {}
+
+export type ProviderRequirements = Layer.Services<ReturnType<typeof providers>>;
+
+/**
+ * The Effect Cluster providers Layer. Add it next to the providers of the
+ * cloud your database and runners run on.
+ *
+ * @example
+ * ```ts
+ * Alchemy.Stack("App", { providers: Layer.mergeAll(Docker.providers(), Cluster.providers()) }, ...)
+ * ```
+ */
+export const providers = () =>
+  Layer.effect(
+    Providers,
+    Provider.collection([
+      EntityResource,
+      WorkflowResource,
+      SingletonResource,
+      CronResource,
+      Pool,
+      ShardGroups,
+      Random,
+    ]),
+  ).pipe(
+    Layer.provide(
+      Layer.mergeAll(
+        EntityProvider(),
+        WorkflowProvider(),
+        SingletonProvider(),
+        CronProvider(),
+        PoolProvider(),
+        ShardGroupsProvider(),
+        RandomProvider(),
+      ),
+    ),
+  );