effect 4.0.0-beta.2 → 4.0.0-beta.21

package/src/unstable/cli/internal/help.ts

@@ -0,0 +1,146 @@
+/**
+ * Help Documentation
+ * ================
+ *
+ * Internal helpers for generating help documentation.
+ * Extracted from command.ts to avoid circular dependencies.
+ */
+import * as Effect from "../../../Effect.ts"
+import type { Command } from "../Command.ts"
+import type * as GlobalFlag from "../GlobalFlag.ts"
+import type { FlagDoc, HelpDoc } from "../HelpDoc.ts"
+import * as Param from "../Param.ts"
+import * as Primitive from "../Primitive.ts"
+import { toImpl } from "./command.ts"
+
+const dedupeGlobalFlags = (
+  flags: ReadonlyArray<GlobalFlag.GlobalFlag<any>>
+): ReadonlyArray<GlobalFlag.GlobalFlag<any>> => {
+  const seen = new Set<GlobalFlag.GlobalFlag<any>>()
+  const deduped: Array<GlobalFlag.GlobalFlag<any>> = []
+  for (const flag of flags) {
+    if (seen.has(flag)) {
+      continue
+    }
+    seen.add(flag)
+    deduped.push(flag)
+  }
+  return deduped
+}
+
+/**
+ * Returns the resolved command lineage for the provided path.
+ * Includes the root command as the first element.
+ */
+export const getCommandsForCommandPath = <Name extends string, Input, E, R>(
+  command: Command<Name, Input, E, R>,
+  commandPath: ReadonlyArray<string>
+): ReadonlyArray<Command.Any> => {
+  const commands: Array<Command.Any> = [command]
+  let currentCommand: Command.Any = command
+
+  for (let i = 1; i < commandPath.length; i++) {
+    const subcommandName = commandPath[i]
+    let subcommand: Command.Any | undefined = undefined
+
+    for (const group of currentCommand.subcommands) {
+      subcommand = group.commands.find((sub) => sub.name === subcommandName)
+      if (subcommand) {
+        break
+      }
+    }
+
+    if (!subcommand) {
+      break
+    }
+
+    commands.push(subcommand)
+    currentCommand = subcommand
+  }
+
+  return commands
+}
+
+/**
+ * Returns active global flags for a command path.
+ * Built-ins are prepended and declarations are collected root -> leaf.
+ */
+export const getGlobalFlagsForCommandPath = <Name extends string, Input, E, R>(
+  command: Command<Name, Input, E, R>,
+  commandPath: ReadonlyArray<string>,
+  builtIns: ReadonlyArray<GlobalFlag.GlobalFlag<any>>
+): ReadonlyArray<GlobalFlag.GlobalFlag<any>> => {
+  const commands = getCommandsForCommandPath(command, commandPath)
+  const declared = commands.flatMap((current) => toImpl(current).globalFlags)
+  return dedupeGlobalFlags([
+    ...builtIns,
+    ...declared
+  ])
+}
+
+const collectDeclaredGlobalFlags = (command: Command.Any): ReadonlyArray<GlobalFlag.GlobalFlag<any>> => {
+  const collected: Array<GlobalFlag.GlobalFlag<any>> = []
+
+  const visit = (current: Command.Any): void => {
+    const impl = toImpl(current)
+    for (const flag of impl.globalFlags) {
+      collected.push(flag)
+    }
+    for (const group of current.subcommands) {
+      for (const subcommand of group.commands) {
+        visit(subcommand)
+      }
+    }
+  }
+
+  visit(command)
+  return dedupeGlobalFlags(collected)
+}
+
+/**
+ * Returns all global flags declared in a command tree.
+ * Built-ins are prepended and command declarations are deduplicated by identity.
+ */
+export const getGlobalFlagsForCommandTree = <Name extends string, Input, E, R>(
+  command: Command<Name, Input, E, R>,
+  builtIns: ReadonlyArray<GlobalFlag.GlobalFlag<any>>
+): ReadonlyArray<GlobalFlag.GlobalFlag<any>> =>
+  dedupeGlobalFlags([
+    ...builtIns,
+    ...collectDeclaredGlobalFlags(command)
+  ])
+
+/**
+ * Helper function to get help documentation for a specific command path.
+ * Navigates through the command hierarchy to find the right command.
+ * Reads active global flags for the path and includes them in the help doc.
+ */
+export const getHelpForCommandPath = <Name extends string, Input, E, R>(
+  command: Command<Name, Input, E, R>,
+  commandPath: ReadonlyArray<string>,
+  builtIns: ReadonlyArray<GlobalFlag.GlobalFlag<any>>
+): Effect.Effect<HelpDoc, never, never> =>
+  Effect.gen(function*() {
+    const commands = getCommandsForCommandPath(command, commandPath)
+    const currentCommand = commands.length > 0 ? commands[commands.length - 1] : command
+
+    const baseDoc = toImpl(currentCommand).buildHelpDoc(commandPath)
+
+    const flags = getGlobalFlagsForCommandPath(command, commandPath, builtIns)
+    const globalFlagDocs: Array<FlagDoc> = []
+    for (const flag of flags) {
+      const singles = Param.extractSingleParams(flag.flag)
+      for (const single of singles) {
+        const formattedAliases = single.aliases.map((alias) => alias.length === 1 ? `-${alias}` : `--${alias}`)
+        globalFlagDocs.push({
+          name: single.name,
+          aliases: formattedAliases,
+          type: single.typeName ?? Primitive.getTypeName(single.primitiveType),
+          description: single.description,
+          required: false
+        })
+      }
+    }
+
+    return { ...baseDoc, globalFlags: globalFlagDocs }
+  })

package/src/unstable/cli/internal/parser.ts

@@ -25,14 +25,11 @@
  * - Errors accumulate rather than throwing exceptions
  */
 import * as Effect from "../../../Effect.ts"
-import type { LogLevel } from "../../../LogLevel.ts"
-import * as Option from "../../../Option.ts"
 import * as CliError from "../CliError.ts"
 import type { Command, ParsedTokens } from "../Command.ts"
 import * as Param from "../Param.ts"
 import * as Primitive from "../Primitive.ts"
 import { suggest } from "./auto-suggest.ts"
-import { completionsFlag, helpFlag, logLevelFlag, versionFlag } from "./builtInFlags.ts"
 import { toImpl } from "./command.ts"
 import type { LexResult, Token } from "./lexer.ts"
 
@@ -46,36 +43,6 @@ export const getCommandPath = (parsedInput: ParsedTokens): ReadonlyArray<string>
     ? [parsedInput.subcommand.name, ...getCommandPath(parsedInput.subcommand.parsedInput)]
     : []
 
-/** @internal */
-export const extractBuiltInOptions = (
-  tokens: ReadonlyArray<Token>
-): Effect.Effect<
-  {
-    help: boolean
-    logLevel: LogLevel | undefined
-    version: boolean
-    completions: "bash" | "zsh" | "fish" | undefined
-    remainder: ReadonlyArray<Token>
-  },
-  CliError.CliError,
-  Param.Environment
-> =>
-  Effect.gen(function*() {
-    const { flagMap, remainder } = consumeKnownFlags(tokens, builtInFlagRegistry)
-    const emptyArgs: Param.ParsedArgs = { flags: flagMap, arguments: [] }
-    const [, help] = yield* helpFlag.parse(emptyArgs)
-    const [, logLevel] = yield* logLevelFlag.parse(emptyArgs)
-    const [, version] = yield* versionFlag.parse(emptyArgs)
-    const [, completions] = yield* completionsFlag.parse(emptyArgs)
-    return {
-      help,
-      logLevel: Option.getOrUndefined(logLevel),
-      version,
-      completions: Option.getOrUndefined(completions),
-      remainder
-    }
-  })
-
 /** @internal */
 export const parseArgs = (
   lexResult: LexResult,
@@ -249,8 +216,9 @@ const makeCursor = (tokens: ReadonlyArray<Token>): TokenCursor => {
 /**
  * Creates a registry for O(1) flag lookup by name or alias.
  * @throws Error if duplicate names or aliases are detected (developer error)
+ * @internal
  */
-const createFlagRegistry = (params: ReadonlyArray<FlagParam>): FlagRegistry => {
+export const createFlagRegistry = (params: ReadonlyArray<FlagParam>): FlagRegistry => {
   const index = new Map<string, FlagParam>()
 
   for (const param of params) {
@@ -273,15 +241,38 @@ const createFlagRegistry = (params: ReadonlyArray<FlagParam>): FlagRegistry => {
 }
 
 const buildSubcommandIndex = (
-  subcommands: ReadonlyArray<Command<string, unknown, unknown, unknown>>
-): Map<string, Command<string, unknown, unknown, unknown>> => new Map(subcommands.map((sub) => [sub.name, sub]))
+  subcommands: Command.Any["subcommands"]
+): Map<string, Command<string, unknown, unknown, unknown>> => {
+  const index = new Map<string, Command<string, unknown, unknown, unknown>>()
+  const setKey = (key: string, command: Command<string, unknown, unknown, unknown>) => {
+    const existing = index.get(key)
+    if (existing && existing !== command) {
+      throw new Error(
+        `Duplicate subcommand name/alias "${key}" in command definition (conflicts with "${existing.name}")`
+      )
+    }
+    index.set(key, command)
+  }
+
+  for (const group of subcommands) {
+    for (const subcommand of group.commands) {
+      setKey(subcommand.name, subcommand)
+      if (subcommand.alias && subcommand.alias !== subcommand.name) {
+        setKey(subcommand.alias, subcommand)
+      }
+    }
+  }
+  return index
+}
 
 /* ========================================================================== */
 /* Flag Accumulator                                                           */
 /* ========================================================================== */
 
-/** Creates an empty flag map with all known flag names initialized to []. */
-const createEmptyFlagMap = (params: ReadonlyArray<FlagParam>): FlagMap =>
+/** Creates an empty flag map with all known flag names initialized to [].
+ * @internal
+ */
+export const createEmptyFlagMap = (params: ReadonlyArray<FlagParam>): FlagMap =>
   Object.fromEntries(params.map((p) => [p.name, []]))
 
 /**
@@ -370,9 +361,10 @@ const consumeFlagValue = (
 /**
  * Consumes known flags from a token stream.
  * Unrecognized tokens are passed through to remainder.
- * Used for both built-in extraction and npm-style parent flag collection.
+ * Used for both global flag extraction and npm-style parent flag collection.
+ * @internal
  */
-const consumeKnownFlags = (
+export const consumeKnownFlags = (
   tokens: ReadonlyArray<Token>,
   registry: FlagRegistry
 ): { flagMap: FlagMap; remainder: ReadonlyArray<Token> } => {
@@ -401,19 +393,6 @@ const consumeKnownFlags = (
   return { flagMap, remainder }
 }
 
-/* ========================================================================== */
-/* Built-in Flags                                                             */
-/* ========================================================================== */
-
-const builtInFlagParams: ReadonlyArray<FlagParam> = [
-  ...Param.extractSingleParams(logLevelFlag),
-  ...Param.extractSingleParams(helpFlag),
-  ...Param.extractSingleParams(versionFlag),
-  ...Param.extractSingleParams(completionsFlag)
-]
-
-const builtInFlagRegistry = createFlagRegistry(builtInFlagParams)
-
 /* ========================================================================== */
 /* Error Creation                                                             */
 /* ========================================================================== */
@@ -506,7 +485,7 @@ const resolveFirstValue = (
   // Not a subcommand. Check if this looks like a typo.
   const expectsArgs = toImpl(command).config.arguments.length > 0
   if (!expectsArgs && subIndex.size > 0) {
-    const suggestions = suggest(value, command.subcommands.map((s) => s.name))
+    const suggestions = suggest(value, Array.from(subIndex.keys()))
     state.errors.push(
       new CliError.UnknownSubcommand({
         subcommand: value,

package/src/unstable/cluster/ClusterCron.ts

@@ -51,7 +51,7 @@ export const make = <E, R>(options: {
    *
    * Defaults to "1 day".
    */
-  readonly skipIfOlderThan?: Duration.DurationInput | undefined
+  readonly skipIfOlderThan?: Duration.Input | undefined
 }): Layer.Layer<never, never, Sharding | Exclude<R, Scope>> => {
   const CronEntity = Entity.make(`ClusterCron/${options.name}`, [
     Rpc.make("run", {
@@ -76,7 +76,7 @@ export const make = <E, R>(options: {
   )
 
   const skipIfOlderThan = Option.fromUndefinedOr(options.skipIfOlderThan).pipe(
-    Option.map(Duration.fromDurationInputUnsafe),
+    Option.map(Duration.fromInputUnsafe),
     Option.getOrElse(() => Duration.days(1))
   )
 

package/src/unstable/cluster/ClusterWorkflowEngine.ts

@@ -6,6 +6,7 @@ import * as Duration from "../../Duration.ts"
 import * as Effect from "../../Effect.ts"
 import * as Exit from "../../Exit.ts"
 import * as Fiber from "../../Fiber.ts"
+import * as Latch from "../../Latch.ts"
 import * as Layer from "../../Layer.ts"
 import * as PrimaryKey from "../../PrimaryKey.ts"
 import * as RcMap from "../../RcMap.ts"
@@ -15,7 +16,7 @@ import * as Schema from "../../Schema.ts"
 import type * as Scope from "../../Scope.ts"
 import * as ServiceMap from "../../ServiceMap.ts"
 import * as Rpc from "../rpc/Rpc.ts"
-import * as RpcServer from "../rpc/RpcServer.ts"
+import { ClientAbort } from "../rpc/RpcSchema.ts"
 import * as Activity from "../workflow/Activity.ts"
 import * as DurableClock from "../workflow/DurableClock.ts"
 import * as DurableDeferred from "../workflow/DurableDeferred.ts"
@@ -106,7 +107,7 @@ export const make = Effect.gen(function*() {
     readonly services: ServiceMap.ServiceMap<any>
   }>()
   const interruptedActivities = new Set<string>()
-  const activityLatches = new Map<string, Effect.Latch>()
+  const activityLatches = new Map<string, Latch.Latch>()
   const clients = yield* RcMap.make({
     lookup: Effect.fnUntraced(function*(workflowName: string) {
       const entity = entities.get(workflowName)
@@ -297,7 +298,7 @@ export const make = Effect.gen(function*() {
                 return Effect.gen(function*() {
                   let entry = activities.get(activityId)
                   while (!entry) {
-                    const latch = Effect.makeLatchUnsafe()
+                    const latch = Latch.makeUnsafe()
                     activityLatches.set(activityId, latch)
                     yield* latch.await
                     entry = activities.get(activityId)
@@ -314,7 +315,7 @@ export const make = Effect.gen(function*() {
                     // we only want to store interrupts as suspends when the
                     // client requested it
                     const suspend = cause.reasons.some((f) =>
-                      f._tag === "Interrupt" && f.fiberId === RpcServer.fiberIdClientInterrupt
+                      f._tag === "Interrupt" && f.annotations.has(ClientAbort.key)
                     )
                     if (suspend) {
                       interruptedActivities.add(activityId)

package/src/unstable/cluster/Entity.ts

@@ -4,12 +4,13 @@
 import * as Arr from "../../Array.ts"
 import type * as Cause from "../../Cause.ts"
 import * as Data from "../../Data.ts"
-import type { DurationInput } from "../../Duration.ts"
+import type * as Duration from "../../Duration.ts"
 import * as Effect from "../../Effect.ts"
 import * as Equal from "../../Equal.ts"
 import * as Exit from "../../Exit.ts"
 import { identity } from "../../Function.ts"
 import * as Hash from "../../Hash.ts"
+import type * as Latch from "../../Latch.ts"
 import * as Layer from "../../Layer.ts"
 import * as Predicate from "../../Predicate.ts"
 import * as Queue from "../../Queue.ts"
@@ -74,12 +75,12 @@ export interface Entity<
   /**
    * Annotate the entity with a value.
    */
-  annotate<I, S>(key: ServiceMap.Service<I, S>, value: S): Entity<Type, Rpcs>
+  annotate<I, S>(key: ServiceMap.Key<I, S>, value: S): Entity<Type, Rpcs>
 
   /**
    * Annotate the Rpc's above this point with a value.
    */
-  annotateRpcs<I, S>(key: ServiceMap.Service<I, S>, value: S): Entity<Type, Rpcs>
+  annotateRpcs<I, S>(key: ServiceMap.Key<I, S>, value: S): Entity<Type, Rpcs>
 
   /**
    * Annotate the entity with the given annotations.
@@ -116,7 +117,7 @@ export interface Entity<
   >(
     build: Handlers | Effect.Effect<Handlers, never, RX>,
     options?: {
-      readonly maxIdleTime?: DurationInput | undefined
+      readonly maxIdleTime?: Duration.Input | undefined
       readonly concurrency?: number | "unbounded" | undefined
       readonly mailboxCapacity?: number | "unbounded" | undefined
       readonly disableFatalDefects?: boolean | undefined
@@ -159,7 +160,7 @@ export interface Entity<
         RX
       >,
     options?: {
-      readonly maxIdleTime?: DurationInput | undefined
+      readonly maxIdleTime?: Duration.Input | undefined
       readonly mailboxCapacity?: number | "unbounded" | undefined
       readonly disableFatalDefects?: boolean | undefined
       readonly defectRetryPolicy?: Schedule.Schedule<any, unknown> | undefined
@@ -206,10 +207,10 @@ const Proto = {
   [Equal.symbol](this: Entity<string, any>, that: Equal.Equal): boolean {
     return isEntity(that) && this.type === that.type
   },
-  annotate<I, S>(this: Entity<string, any>, key: ServiceMap.Service<I, S>, value: S) {
+  annotate<I, S>(this: Entity<string, any>, key: ServiceMap.Key<I, S>, value: S) {
     return fromRpcGroup(this.type, this.protocol.annotate(key, value))
   },
-  annotateRpcs<I, S>(this: Entity<string, any>, key: ServiceMap.Service<I, S>, value: S) {
+  annotateRpcs<I, S>(this: Entity<string, any>, key: ServiceMap.Key<I, S>, value: S) {
     return fromRpcGroup(this.type, this.protocol.annotateRpcs(key, value))
   },
   annotateMerge<S>(this: Entity<string, any>, annotations: ServiceMap.ServiceMap<S>) {
@@ -234,7 +235,7 @@ const Proto = {
     this: Entity<string, Rpcs>,
     build: Handlers | Effect.Effect<Handlers, never, RX>,
     options?: {
-      readonly maxIdleTime?: DurationInput | undefined
+      readonly maxIdleTime?: Duration.Input | undefined
       readonly concurrency?: number | "unbounded" | undefined
       readonly mailboxCapacity?: number | "unbounded" | undefined
       readonly disableFatalDefects?: boolean | undefined
@@ -283,7 +284,7 @@ const Proto = {
         RX
       >,
     options?: {
-      readonly maxIdleTime?: DurationInput | undefined
+      readonly maxIdleTime?: Duration.Input | undefined
       readonly mailboxCapacity?: number | "unbounded" | undefined
       readonly disableFatalDefects?: boolean | undefined
       readonly defectRetryPolicy?: Schedule.Schedule<any, unknown> | undefined
@@ -642,6 +643,6 @@ export const KeepAliveRpc = Rpc.make("Cluster/Entity/keepAlive")
  * @since 4.0.0
  * @category Keep alive
  */
-export class KeepAliveLatch extends ServiceMap.Service<KeepAliveLatch, Effect.Latch>()(
+export class KeepAliveLatch extends ServiceMap.Service<KeepAliveLatch, Latch.Latch>()(
   "effect/cluster/Entity/KeepAliveLatch"
 ) {}

package/src/unstable/cluster/EntityResource.ts

@@ -62,14 +62,14 @@ export class CloseScope extends ServiceMap.Service<
  */
 export const make: <A, E, R>(options: {
   readonly acquire: Effect.Effect<A, E, R>
-  readonly idleTimeToLive?: Duration.DurationInput | undefined
+  readonly idleTimeToLive?: Duration.Input | undefined
 }) => Effect.Effect<
   EntityResource<A, E>,
   E,
   Scope.Scope | Exclude<R, CloseScope> | Sharding | Entity.CurrentAddress
 > = Effect.fnUntraced(function*<A, E, R>(options: {
   readonly acquire: Effect.Effect<A, E, R>
-  readonly idleTimeToLive?: Duration.DurationInput | undefined
+  readonly idleTimeToLive?: Duration.Input | undefined
 }) {
   let shuttingDown = false
 
@@ -116,14 +116,14 @@ export const make: <A, E, R>(options: {
 export const makeK8sPod: (
   spec: v1.Pod,
   options?: {
-    readonly idleTimeToLive?: Duration.DurationInput | undefined
+    readonly idleTimeToLive?: Duration.Input | undefined
   } | undefined
 ) => Effect.Effect<
   EntityResource<K8sHttpClient.PodStatus>,
   never,
   Scope.Scope | Sharding | Entity.CurrentAddress | K8sHttpClient.K8sHttpClient
 > = Effect.fnUntraced(function*(spec: v1.Pod, options?: {
-  readonly idleTimeToLive?: Duration.DurationInput | undefined
+  readonly idleTimeToLive?: Duration.Input | undefined
 }) {
   const createPod = yield* K8sHttpClient.makeCreatePod
   return yield* make({

package/src/unstable/cluster/Envelope.ts

@@ -218,7 +218,7 @@ export const PartialJson: Schema.Codec<
  * @category schemas
  */
 export const PartialArray: Schema.mutable<
-  Schema.Array$<Schema.Codec<AckChunk | Interrupt | PartialRequest, Encoded>>
+  Schema.$Array<Schema.Codec<AckChunk | Interrupt | PartialRequest, Encoded>>
 > = Schema.mutable(Schema.Array(PartialJson))
 
 /**

package/src/unstable/cluster/K8sHttpClient.ts

@@ -121,7 +121,7 @@ export const makeCreatePod = Effect.gen(function*() {
         while: (e) => e._tag === "SchemaError",
         schedule: Schedule.spaced("1 seconds")
       }),
-      Effect.catchIf(
+      Effect.catchFilter(
         (err) =>
           HttpClientError.isHttpClientError(err) && err.reason._tag === "StatusCodeError" &&
             err.reason.response.status === 404
@@ -133,7 +133,7 @@ export const makeCreatePod = Effect.gen(function*() {
     )
     const isPodFound = readPodRaw.pipe(
       Effect.as(true),
-      Effect.catchIf(
+      Effect.catchFilter(
         (err) =>
           HttpClientError.isHttpClientError(err) && err.reason._tag === "StatusCodeError" &&
             err.reason.response.status === 404
@@ -145,7 +145,7 @@ export const makeCreatePod = Effect.gen(function*() {
     const createPod = HttpClientRequest.post(`/v1/namespaces/${namespace}/pods`).pipe(
       HttpClientRequest.bodyJsonUnsafe(spec),
       client.execute,
-      Effect.catchIf(
+      Effect.catchFilter(
         (err) =>
           HttpClientError.isHttpClientError(err) && err.reason._tag === "StatusCodeError" &&
             err.reason.response.status === 409
@@ -156,10 +156,10 @@ export const makeCreatePod = Effect.gen(function*() {
       Effect.tapCause(Effect.logInfo),
       Effect.orDie
     )
-    const deletePod = HttpClientRequest.del(`/v1/namespaces/${namespace}/pods/${name}`).pipe(
+    const deletePod = HttpClientRequest.delete(`/v1/namespaces/${namespace}/pods/${name}`).pipe(
       client.execute,
       Effect.flatMap((res) => res.json),
-      Effect.catchIf(
+      Effect.catchFilter(
         (err) =>
           HttpClientError.isHttpClientError(err) && err.reason._tag === "StatusCodeError" &&
             err.reason.response.status === 404

package/src/unstable/cluster/MessageStorage.ts

@@ -6,6 +6,7 @@ import { Clock } from "../../Clock.ts"
 import * as Data from "../../Data.ts"
 import * as Effect from "../../Effect.ts"
 import * as Exit from "../../Exit.ts"
+import * as Latch from "../../Latch.ts"
 import * as Layer from "../../Layer.ts"
 import type * as Option from "../../Option.ts"
 import type { Predicate } from "../../Predicate.ts"
@@ -718,7 +719,7 @@ export class MemoryDriver extends ServiceMap.Service<MemoryDriver>()("effect/clu
       return messages
     }
 
-    const replyLatch = yield* Effect.makeLatch()
+    const replyLatch = yield* Latch.make()
 
     function repliesFor(requestIds: Array<string>) {
       const replies = Arr.empty<Reply.Encoded>()
@@ -904,10 +905,7 @@ export const layerMemory: Layer.Layer<
 
 const EnvelopeWithReply: Schema.Struct<
   {
-    readonly envelope: Schema.Codec<
-      Envelope.PartialRequest | Envelope.AckChunk | Envelope.Interrupt,
-      unknown
-    >
+    readonly envelope: Schema.Decoder<Envelope.PartialRequest | Envelope.AckChunk | Envelope.Interrupt>
     readonly lastSentReply: Schema.UndefinedOr<Schema.Codec<Reply.Encoded>>
   }
 > = Schema.Struct({

package/src/unstable/cluster/Runners.ts

@@ -3,6 +3,7 @@
  */
 import * as Effect from "../../Effect.ts"
 import * as Exit from "../../Exit.ts"
+import * as Latch from "../../Latch.ts"
 import * as Layer from "../../Layer.ts"
 import * as Queue from "../../Queue.ts"
 import * as RcMap from "../../RcMap.ts"
@@ -192,8 +193,8 @@ export const make: (options: Omit<Runners["Service"], "sendLocal" | "notifyLocal
   }
 
   type StorageRequestEntry = {
-    readonly latch: Effect.Latch
-    doneLatch: Effect.Latch | undefined
+    readonly latch: Latch.Latch
+    doneLatch: Latch.Latch | undefined
     readonly messages: Set<Message.OutgoingRequest<any>>
     replies: Array<Reply.Reply<any>>
   }
@@ -204,11 +205,11 @@ export const make: (options: Omit<Runners["Service"], "sendLocal" | "notifyLocal
       let entry = storageRequests.get(message.envelope.requestId)
       if (entry) {
         entry.messages.add(message)
-        entry.doneLatch ??= Effect.makeLatchUnsafe(false)
+        entry.doneLatch ??= Latch.makeUnsafe(false)
         return yield* entry.doneLatch.await
       } else {
         entry = {
-          latch: Effect.makeLatchUnsafe(false),
+          latch: Latch.makeUnsafe(false),
           doneLatch: undefined,
           replies: [],
           messages: new Set([message])
@@ -260,7 +261,7 @@ export const make: (options: Omit<Runners["Service"], "sendLocal" | "notifyLocal
       )
   )
 
-  const storageLatch = Effect.makeLatchUnsafe(false)
+  const storageLatch = Latch.makeUnsafe(false)
   if (storage !== MessageStorage.noop) {
     yield* Effect.gen(function*() {
       const foundRequests = new Set<StorageRequestEntry>()