@effect/cluster 0.28.4 → 0.29.0

package/src/internal/atLeastOnceStorage.ts

@@ -1,218 +0,0 @@
-import * as SqlClient from "@effect/sql/SqlClient"
-import type * as SqlError from "@effect/sql/SqlError"
-import * as SqlResolver from "@effect/sql/SqlResolver"
-import * as Context from "effect/Context"
-import * as Effect from "effect/Effect"
-import * as Layer from "effect/Layer"
-import * as PrimaryKey from "effect/PrimaryKey"
-import * as Schema from "effect/Schema"
-import * as Stream from "effect/Stream"
-import type * as AtLeastOnceStorage from "../AtLeastOnceStorage.js"
-import * as RecipientAddress from "../RecipientAddress.js"
-import type * as Serialization from "../Serialization.js"
-import * as SerializedEnvelope from "../SerializedEnvelope.js"
-import * as SerializedMessage from "../SerializedMessage.js"
-import * as InternalSerialization from "./serialization.js"
-
-/** @internal */
-const SymbolKey = "@effect/cluster/AtLeastOnceStorage"
-
-/** @internal */
-export const TypeId: AtLeastOnceStorage.TypeId = Symbol.for(
-  SymbolKey
-) as AtLeastOnceStorage.TypeId
-
-/** @internal */
-export const atLeastOnceStorageTag: Context.Tag<
-  AtLeastOnceStorage.AtLeastOnceStorage,
-  AtLeastOnceStorage.AtLeastOnceStorage
-> = Context.GenericTag<AtLeastOnceStorage.AtLeastOnceStorage>(SymbolKey)
-
-const make = ({ table }: AtLeastOnceStorage.AtLeastOnceStorage.MakeOptions): Effect.Effect<
-  AtLeastOnceStorage.AtLeastOnceStorage,
-  SqlError.SqlError,
-  SqlClient.SqlClient | Serialization.Serialization
-> =>
-  Effect.gen(function*() {
-    const sql = yield* SqlClient.SqlClient
-    const serialization = yield* InternalSerialization.serializationTag
-
-    yield* sql.onDialectOrElse({
-      mssql: () =>
-        sql`
-          IF OBJECT_ID(N'${sql.literal(table)}', N'U') IS NULL
-          CREATE TABLE ${sql(table)} (
-            recipient_name VARCHAR(255) NOT NULL,
-            shard_id INT NOT NULL DEFAULT 0,
-            entity_id VARCHAR(255) NOT NULL,
-            message_id VARCHAR(255) NOT NULL,
-            message_body TEXT NOT NULL,
-            processed BIT NOT NULL DEFAULT 0,
-            CONSTRAINT ${sql(table)}_pkey PRIMARY KEY (recipient_name, entity_id, message_id)
-              WITH (IGNORE_DUP_KEY = ON)
-          )
-        `,
-      mysql: () =>
-        sql`
-          CREATE TABLE IF NOT EXISTS ${sql(table)} (
-            recipient_name VARCHAR(255) NOT NULL,
-            shard_id INT NOT NULL DEFAULT 0,
-            entity_id VARCHAR(255) NOT NULL,
-            message_id VARCHAR(255) NOT NULL,
-            message_body TEXT NOT NULL,
-            processed BOOLEAN NOT NULL DEFAULT FALSE,
-            CONSTRAINT ${sql(table)}_pkey PRIMARY KEY (recipient_name, entity_id, message_id)
-          )
-        `,
-      pg: () =>
-        Effect.catchAll(sql`SELECT ${table}::regclass`, () =>
-          sql`
-            CREATE TABLE IF NOT EXISTS ${sql(table)} (
-              recipient_name VARCHAR(255) NOT NULL,
-              shard_id INT NOT NULL DEFAULT 0,
-              entity_id VARCHAR(255) NOT NULL,
-              message_id VARCHAR(255) NOT NULL,
-              message_body TEXT NOT NULL,
-              processed BOOLEAN NOT NULL DEFAULT FALSE,
-              CONSTRAINT ${sql(table)}_pkey PRIMARY KEY (recipient_name, entity_id, message_id)
-            )
-          `),
-      orElse: () =>
-        sql`
-          CREATE TABLE IF NOT EXISTS ${sql.literal(table)} (
-            recipient_name VARCHAR(255) NOT NULL,
-            shard_id INT NOT NULL DEFAULT (0),
-            entity_id VARCHAR(255) NOT NULL,
-            message_id VARCHAR(255) NOT NULL,
-            message_body CLOB NOT NULL,
-            processed BOOLEAN NOT NULL DEFAULT (0),
-            CONSTRAINT ${sql.literal(table)}_pkey PRIMARY KEY (recipient_name, entity_id, message_id)
-          )
-        `
-    })
-
-    const UpsertEntryResolver = yield* SqlResolver.void("UpsertEntry", {
-      Request: Schema.Struct({
-        recipient_name: Schema.String,
-        shard_id: Schema.Number,
-        entity_id: Schema.String,
-        message_id: Schema.String,
-        message_body: Schema.String
-      }),
-      execute: (requests) =>
-        sql.onDialectOrElse({
-          mssql: () =>
-            sql`
-              INSERT INTO ${sql(table)}
-              ${sql.insert(requests)}
-            `,
-          mysql: () =>
-            sql`
-              INSERT INTO ${sql(table)}
-              ${sql.insert(requests)}
-              ON DUPLICATE KEY UPDATE
-                recipient_name = recipient_name,
-                entity_id = entity_id,
-                message_id = message_id
-            `,
-          pg: () =>
-            sql`
-              INSERT INTO ${sql(table)}
-              ${sql.insert(requests)}
-              ON CONFLICT ON CONSTRAINT ${sql(table)}_pkey DO NOTHING
-            `,
-          orElse: () =>
-            sql`
-              INSERT INTO ${sql(table)}
-              ${sql.insert(requests)}
-              ON CONFLICT (recipient_name, entity_id, message_id) DO NOTHING
-            `
-        })
-    })
-
-    const SweepPendingResolver = yield* SqlResolver.ordered("SweepPending", {
-      Request: Schema.Number,
-      Result: Schema.Struct({
-        shard_id: Schema.Number,
-        entity_id: Schema.String,
-        message_id: Schema.String,
-        recipient_name: Schema.String,
-        message_body: Schema.String
-      }),
-      execute: (shard_ids) =>
-        sql`
-          SELECT
-            shard_id,
-            entity_id,
-            message_id,
-            recipient_name,
-            message_body
-          FROM ${sql(table)}
-          WHERE ${
-          sql.and([
-            sql`processed = ${false}`,
-            sql.in("shard_id", shard_ids)
-          ])
-        }
-        `
-    })
-
-    return {
-      [TypeId]: TypeId,
-      upsert: (recipientType, shardId, entityId, message) =>
-        serialization.encode(recipientType.schema, message).pipe(
-          Effect.flatMap(
-            (message_body) =>
-              UpsertEntryResolver.execute({
-                recipient_name: recipientType.name,
-                shard_id: shardId.value,
-                entity_id: entityId,
-                message_id: PrimaryKey.value(message),
-                message_body: message_body.value
-              })
-          ),
-          Effect.catchAllCause(Effect.logError)
-        ),
-      markAsProcessed: (recipientType, _shardId, entityId, message) => {
-        return sql`
-          UPDATE ${sql(table)}
-          SET ${
-          sql.onDialectOrElse({
-            pg: () => sql.update({ processed: "TRUE" }),
-            orElse: () => sql.update({ processed: 1 })
-          })
-        }
-          WHERE ${
-          sql.and([
-            sql`recipient_name = ${recipientType.name}`,
-            sql`entity_id = ${entityId}`,
-            sql`message_id = ${PrimaryKey.value(message)}`
-          ])
-        }`.pipe(Effect.catchAllCause(Effect.logError))
-      },
-      sweepPending: (shardIds) =>
-        Effect.forEach(shardIds, (id) =>
-          Effect.withRequestCaching(true)(
-            SweepPendingResolver.execute(id.value)
-          ), {
-          batching: true
-        }).pipe(
-          Effect.orDie,
-          Stream.fromIterableEffect,
-          Stream.map((entry) =>
-            SerializedEnvelope.make(
-              RecipientAddress.makeRecipientAddress(entry.recipient_name, entry.entity_id),
-              entry.message_id,
-              SerializedMessage.make(entry.message_body)
-            )
-          )
-        )
-    }
-  })
-
-/** @internal */
-export const layer = (options: AtLeastOnceStorage.AtLeastOnceStorage.MakeOptions): Layer.Layer<
-  AtLeastOnceStorage.AtLeastOnceStorage,
-  SqlError.SqlError,
-  SqlClient.SqlClient | Serialization.Serialization
-> => Layer.effect(atLeastOnceStorageTag, make(options))

package/src/internal/entityState.ts

@@ -1,64 +0,0 @@
-import * as Data from "effect/Data"
-import type * as Effect from "effect/Effect"
-import type * as Fiber from "effect/Fiber"
-import * as Option from "effect/Option"
-import type * as Scope from "effect/Scope"
-import type * as MessageState from "../MessageState.js"
-import type * as SerializedEnvelope from "../SerializedEnvelope.js"
-import type * as SerializedMessage from "../SerializedMessage.js"
-import type * as ShardingException from "../ShardingException.js"
-
-/** @internal */
-const EntityStateSymbolKey = "@effect/cluster/EntityState"
-
-/** @internal */
-export const EntityStateTypeId = Symbol.for(EntityStateSymbolKey)
-
-/** @internal */
-export type EntityStateTypeId = typeof EntityStateTypeId
-
-/**
- * @since 1.0.0
- * @category models
- */
-export interface EntityState {
-  readonly [EntityStateTypeId]: EntityStateTypeId
-  readonly sendAndGetState: (
-    envelope: SerializedEnvelope.SerializedEnvelope
-  ) => Effect.Effect<
-    MessageState.MessageState<SerializedMessage.SerializedMessage>,
-    ShardingException.ExceptionWhileOfferingMessageException | ShardingException.SerializationException
-  >
-  readonly expirationFiber: Fiber.RuntimeFiber<void, never>
-  readonly executionScope: Scope.CloseableScope
-  readonly terminationFiber: Option.Option<Fiber.RuntimeFiber<void, never>>
-  readonly lastReceivedAt: number
-}
-
-/** @internal */
-export function make(
-  data: Omit<EntityState, EntityStateTypeId>
-): EntityState {
-  return Data.struct({ [EntityStateTypeId]: EntityStateTypeId, ...data })
-}
-
-/** @internal */
-export function withTerminationFiber(
-  terminationFiber: Fiber.RuntimeFiber<void, never>
-): (entityState: EntityState) => EntityState {
-  return (entityState) => ({ ...entityState, terminationFiber: Option.some(terminationFiber) })
-}
-
-/** @internal */
-export function withExpirationFiber(
-  expirationFiber: Fiber.RuntimeFiber<void, never>
-): (entityState: EntityState) => EntityState {
-  return (entityState) => ({ ...entityState, expirationFiber })
-}
-
-/** @internal */
-export function withLastReceivedAd(
-  lastReceivedAt: number
-): (entityState: EntityState) => EntityState {
-  return (entityState) => ({ ...entityState, lastReceivedAt })
-}

package/src/internal/managerConfig.ts

@@ -1,84 +0,0 @@
-import * as Config from "effect/Config"
-import type * as ConfigError from "effect/ConfigError"
-import * as Context from "effect/Context"
-import * as Duration from "effect/Duration"
-import { pipe } from "effect/Function"
-import * as Layer from "effect/Layer"
-import type * as ManagerConfig from "../ManagerConfig.js"
-
-/** @internal */
-const ManagerConfigSymbolKey = "@effect/cluster/ManagerConfig"
-
-/** @internal */
-export const ManagerConfigTypeId: ManagerConfig.ManagerConfigTypeId = Symbol.for(
-  ManagerConfigSymbolKey
-) as ManagerConfig.ManagerConfigTypeId
-
-/** @internal */
-export const managerConfigTag: Context.Tag<ManagerConfig.ManagerConfig, ManagerConfig.ManagerConfig> = Context
-  .GenericTag(ManagerConfigSymbolKey)
-
-/** @internal */
-const defaultValues: ManagerConfig.ManagerConfig = {
-  numberOfShards: 300,
-  apiPort: 8080,
-  rebalanceInterval: Duration.seconds(20),
-  rebalanceRetryInterval: Duration.seconds(10),
-  pingTimeout: Duration.seconds(3),
-  persistRetryInterval: Duration.seconds(3),
-  persistRetryCount: 100,
-  rebalanceRate: 2 / 100
-}
-
-/** @internal */
-export const defaults: Layer.Layer<ManagerConfig.ManagerConfig> = Layer.succeed(managerConfigTag, defaultValues)
-
-/** @internal */
-const config: Config.Config<ManagerConfig.ManagerConfig> = Config.all({
-  numberOfShards: pipe(
-    Config.number("NUMBER_OF_SHARDS"),
-    Config.withDefault(defaultValues.numberOfShards),
-    Config.withDescription("Number of shards")
-  ),
-  apiPort: pipe(
-    Config.integer("API_PORT"),
-    Config.withDefault(defaultValues.apiPort),
-    Config.withDescription("API port")
-  ),
-  rebalanceInterval: pipe(
-    Config.map(Config.number("REBALANCE_INTERVAL"), Duration.millis),
-    Config.withDefault(defaultValues.rebalanceInterval),
-    Config.withDescription("Interval of rebalance")
-  ),
-  rebalanceRetryInterval: pipe(
-    Config.map(Config.number("REBALANCE_RETRY_INTERVAL"), Duration.millis),
-    Config.withDefault(defaultValues.rebalanceRetryInterval),
-    Config.withDescription("Retry interval of rebalance")
-  ),
-  pingTimeout: pipe(
-    Config.map(Config.number("PING_TIMEOUT"), Duration.millis),
-    Config.withDefault(defaultValues.pingTimeout),
-    Config.withDescription("Ping timeout")
-  ),
-  persistRetryInterval: pipe(
-    Config.map(Config.number("PERSIST_RETRY_INTERVAL"), Duration.millis),
-    Config.withDefault(defaultValues.persistRetryInterval),
-    Config.withDescription("Persist retry interval")
-  ),
-  persistRetryCount: pipe(
-    Config.number("PERSIST_RETRY_COUNT"),
-    Config.withDefault(defaultValues.persistRetryCount),
-    Config.withDescription("Persist retry count")
-  ),
-  rebalanceRate: pipe(
-    Config.number("REBALANCE_RATE"),
-    Config.withDefault(defaultValues.rebalanceRate),
-    Config.withDescription("Rebalance rate")
-  )
-})
-
-/** @internal */
-export const fromConfig: Layer.Layer<ManagerConfig.ManagerConfig, ConfigError.ConfigError> = Layer.effect(
-  managerConfigTag,
-  config
-)

package/src/internal/message.ts

@@ -1,63 +0,0 @@
-import * as PrimaryKey from "effect/PrimaryKey"
-import * as Schema from "effect/Schema"
-import type * as Types from "effect/Types"
-import type * as Message from "../Message.js"
-
-/** @internal */
-export function isMessageWithResult(value: unknown): value is Message.Message<unknown, unknown, unknown, unknown> {
-  return (
-    typeof value === "object" && value !== null &&
-    Schema.symbolWithResult in value
-  )
-}
-
-/** @internal */
-export function exitSchema<A extends Message.Message.Any>(
-  message: A
-): Schema.Schema<Message.Message.Exit<A>, unknown> {
-  return Schema.exitSchema(message as any) as any
-}
-
-/** @internal */
-export function successSchema<A extends Message.Message.Any>(
-  message: A
-): Schema.Schema<Message.Message.Success<A>, unknown> {
-  return Schema.successSchema(message as any) as any
-}
-
-/** @internal */
-export function failureSchema<A extends Message.Message.Any>(
-  message: A
-): Schema.Schema<Message.Message.Error<A>, unknown> {
-  return Schema.failureSchema(message as any) as any
-}
-
-/**
- * @since 1.0.0
- * @category schemas
- */
-export const TaggedMessage_ = <Self>() =>
-<Tag extends string, E, IE, A, IA, Fields extends Schema.Struct.Fields>(
-  tag: Tag,
-  failure: Schema.Schema<E, IE, never>,
-  success: Schema.Schema<A, IA, never>,
-  fields: Fields,
-  messageToId: (message: Schema.Struct.Encoded<Fields>) => string
-): Message.TaggedMessageConstructor<
-  Tag,
-  Self,
-  Schema.Schema.Context<Fields[keyof Fields]>,
-  Types.Simplify<Schema.Struct.Encoded<Fields>>,
-  Types.Simplify<Schema.Struct.Type<Fields>>,
-  IE,
-  E,
-  IA,
-  A
-> => {
-  return class extends (Schema.TaggedRequest<{}>()(tag, { failure, success, payload: fields }) as any) {
-    constructor(props: any, disableValidation?: boolean) {
-      super(props, disableValidation)
-      ;(this as any)[PrimaryKey.symbol] = () => messageToId(this as any)
-    }
-  } as any
-}

package/src/internal/messageState.ts

@@ -1,98 +0,0 @@
-import * as Effect from "effect/Effect"
-import { pipe } from "effect/Function"
-import * as Schema from "effect/Schema"
-import type * as MessageState from "../MessageState.js"
-
-/** @internal */
-const MessageStateSymbolKey = "@effect/cluster/MessageState"
-
-/** @internal */
-export const MessageStateTypeId: MessageState.MessageStateTypeId = Symbol.for(
-  MessageStateSymbolKey
-) as MessageState.MessageStateTypeId
-
-/** @internal */
-export function isMessageState(value: unknown): value is MessageState.MessageState<unknown> {
-  return typeof value === "object" && value !== null && MessageStateTypeId in value
-}
-
-/** @internal */
-export const Acknowledged: MessageState.MessageStateAcknowledged = {
-  [MessageStateTypeId]: MessageStateTypeId,
-  _tag: "@effect/cluster/MessageState/Acknowledged"
-}
-
-/** @internal */
-export function Processed<A>(result: A): MessageState.MessageStateProcessed<A> {
-  return ({
-    [MessageStateTypeId]: MessageStateTypeId,
-    _tag: "@effect/cluster/MessageState/Processed",
-    result
-  })
-}
-
-/** @internal */
-export function match<A, B, C = B>(
-  cases: {
-    onAcknowledged: (value: MessageState.MessageStateAcknowledged) => B
-    onProcessed: (exit: MessageState.MessageStateProcessed<A>) => C
-  }
-) {
-  return (value: MessageState.MessageState<A>) => {
-    switch (value._tag) {
-      case "@effect/cluster/MessageState/Acknowledged":
-        return cases.onAcknowledged(value)
-      case "@effect/cluster/MessageState/Processed":
-        return cases.onProcessed(value)
-    }
-  }
-}
-
-/** @internal */
-export function mapEffect<A, B, R, E>(
-  value: MessageState.MessageState<A>,
-  fn: (value: A) => Effect.Effect<B, E, R>
-): Effect.Effect<MessageState.MessageState<B>, E, R> {
-  return pipe(
-    value,
-    match({
-      onAcknowledged: Effect.succeed,
-      onProcessed: (_) =>
-        Effect.map(fn(_.result), (_) => Processed(_)) as Effect.Effect<MessageState.MessageState<B>, E, R>
-    })
-  )
-}
-
-/** @internal */
-export function schema<A, I>(
-  result: Schema.Schema<A, I>
-): Schema.Schema<
-  MessageState.MessageState<A>,
-  MessageState.MessageState.Encoded<I>
-> {
-  return Schema.Union(
-    Schema.rename(
-      Schema.Struct({
-        [MessageStateSymbolKey]: Schema.compose(
-          Schema.compose(Schema.Literal(MessageStateSymbolKey), Schema.Symbol, { strict: false }),
-          Schema.UniqueSymbolFromSelf(MessageStateTypeId),
-          { strict: false }
-        ),
-        _tag: Schema.Literal("@effect/cluster/MessageState/Acknowledged")
-      }),
-      { [MessageStateSymbolKey]: MessageStateTypeId }
-    ),
-    Schema.rename(
-      Schema.Struct({
-        [MessageStateSymbolKey]: Schema.compose(
-          Schema.compose(Schema.Literal(MessageStateSymbolKey), Schema.Symbol, { strict: false }),
-          Schema.UniqueSymbolFromSelf(MessageStateTypeId),
-          { strict: false }
-        ),
-        _tag: Schema.Literal("@effect/cluster/MessageState/Processed"),
-        result
-      }),
-      { [MessageStateSymbolKey]: MessageStateTypeId }
-    )
-  )
-}

package/src/internal/podWithMetadata.ts

@@ -1,72 +0,0 @@
-import * as Data from "effect/Data"
-import { pipe } from "effect/Function"
-import * as List from "effect/List"
-import * as Option from "effect/Option"
-import type * as Pod from "../Pod.js"
-
-/** @internal */
-const PodWithMetadataSymbolKey = "@effect/cluster/PodWithMetadata"
-
-/** @internal */
-export const PodWithMetadataTypeId = Symbol.for(PodWithMetadataSymbolKey)
-
-/** @internal */
-export type PodWithMetadataTypeId = typeof PodWithMetadataTypeId
-
-/** @internal */
-export class PodWithMetadata extends Data.Class<{
-  [PodWithMetadataTypeId]: PodWithMetadataTypeId
-  pod: Pod.Pod
-  registered: number
-}> {}
-
-/** @internal */
-export function make(pod: Pod.Pod, registered: number): PodWithMetadata {
-  return new PodWithMetadata({ [PodWithMetadataTypeId]: PodWithMetadataTypeId, pod, registered })
-}
-
-/** @internal */
-export function isPodWithMetadata(value: unknown): value is PodWithMetadata {
-  return (
-    typeof value === "object" &&
-    value !== null &&
-    PodWithMetadataTypeId in value &&
-    value[PodWithMetadataTypeId] === PodWithMetadataTypeId
-  )
-}
-
-/** @internal */
-export function extractVersion(pod: PodWithMetadata): List.List<number> {
-  return pipe(
-    List.fromIterable(pod.pod.version.split(".")),
-    List.map((_) => parseInt(_, 10))
-  )
-}
-
-/** @internal */
-export function compareVersion(a: List.List<number>, b: List.List<number>): 0 | 1 | -1 {
-  let restA = a
-  let restB = b
-  while (List.size(restA) > 0 || List.size(restB) > 0) {
-    const numA = pipe(
-      List.head(restA),
-      Option.getOrElse(() => 0)
-    )
-    const numB = pipe(
-      List.head(restB),
-      Option.getOrElse(() => 0)
-    )
-
-    if (numA < numB) return -1
-    if (numB > numA) return 1
-    restA = pipe(
-      List.tail(restA),
-      Option.getOrElse(() => List.empty())
-    )
-    restB = pipe(
-      List.tail(restB),
-      Option.getOrElse(() => List.empty())
-    )
-  }
-  return 0
-}

package/src/internal/pods.ts

@@ -1,29 +0,0 @@
-import * as Context from "effect/Context"
-import * as Effect from "effect/Effect"
-import * as Layer from "effect/Layer"
-import type * as Pods from "../Pods.js"
-
-/** @internal */
-const PodsSymbolKey = "@effect/cluster/Pods"
-
-/** @internal */
-export const PodsTypeId: Pods.PodsTypeId = Symbol.for(PodsSymbolKey) as Pods.PodsTypeId
-
-/** @internal */
-export const podsTag = Context.GenericTag<Pods.Pods>(PodsSymbolKey)
-
-/** @internal */
-export function make(
-  args: Omit<Pods.Pods, Pods.PodsTypeId>
-): Pods.Pods {
-  return { [PodsTypeId]: PodsTypeId, ...args }
-}
-
-/** @internal */
-export const noop = Layer.succeed(podsTag, {
-  [PodsTypeId]: PodsTypeId,
-  assignShards: () => Effect.void,
-  unassignShards: () => Effect.void,
-  ping: () => Effect.void,
-  sendAndGetState: () => Effect.never
-})

package/src/internal/podsHealth.ts

@@ -1,39 +0,0 @@
-import * as Context from "effect/Context"
-import * as Data from "effect/Data"
-import * as Effect from "effect/Effect"
-import { pipe } from "effect/Function"
-import * as Layer from "effect/Layer"
-import * as Option from "effect/Option"
-import * as Pods from "../Pods.js"
-import type * as PodsHealth from "../PodsHealth.js"
-
-/** @internal */
-const PodsHealthSymbolKey = "@effect/cluster/PodsHealth"
-
-/** @internal */
-export const PodsHealthTypeId: PodsHealth.PodsHealthTypeId = Symbol.for(
-  PodsHealthSymbolKey
-) as PodsHealth.PodsHealthTypeId
-
-/** @internal */
-export const podsHealthTag = Context.GenericTag<PodsHealth.PodsHealth>(PodsHealthSymbolKey)
-
-/** @internal */
-export function make(args: Omit<PodsHealth.PodsHealth, PodsHealth.PodsHealthTypeId>): PodsHealth.PodsHealth {
-  return Data.struct({ [PodsHealthTypeId]: PodsHealthTypeId, ...args })
-}
-
-/** @internal */
-export const noop = Layer.succeed(podsHealthTag, {
-  [PodsHealthTypeId]: PodsHealthTypeId,
-  isAlive: () => Effect.succeed(true)
-})
-
-/** @internal */
-export const local = Layer.effect(
-  podsHealthTag,
-  Effect.map(Pods.Pods, (podApi) =>
-    make({
-      isAlive: (address) => pipe(podApi.ping(address), Effect.option, Effect.map(Option.isSome))
-    }))
-)