effect 4.0.0-beta.3 → 4.0.0-beta.30

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

@@ -20,19 +20,16 @@
  *
  * Key Behaviors
  * -------------
- * - Parent flags may appear before OR after the subcommand name (npm-style)
+ * - Inherited parent flags may appear before OR after the subcommand name (npm-style)
  * - Only the first Value token can open a subcommand
  * - 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,
@@ -91,10 +58,17 @@ export const parseArgs = (
     const flagParams = singles.filter(Param.isFlagParam)
     const flagRegistry = createFlagRegistry(flagParams)
 
+    const inheritedSingles = commandImpl.contextConfig.flags.flatMap(Param.extractSingleParams)
+    const inheritedFlagParams = inheritedSingles.filter(Param.isFlagParam)
+    const inheritedFlagRegistry = createFlagRegistry(inheritedFlagParams)
+    const inheritedNames = new Set(inheritedFlagParams.map((param) => param.name))
+
     const context: CommandContext = {
       command,
       commandPath: newCommandPath,
-      flagRegistry
+      flagRegistry,
+      inheritedFlagRegistry,
+      localFlagNames: flagParams.filter((param) => !inheritedNames.has(param.name)).map((param) => param.name)
     }
 
     const result = scanCommandLevel(tokens, context)
@@ -166,6 +140,8 @@ type CommandContext = {
   readonly command: Command.Any
   readonly commandPath: ReadonlyArray<string>
   readonly flagRegistry: FlagRegistry
+  readonly inheritedFlagRegistry: FlagRegistry
+  readonly localFlagNames: ReadonlyArray<string>
 }
 
 /**
@@ -209,7 +185,7 @@ type LeafResult = {
 type SubcommandResult = {
   readonly _tag: "Sub"
   readonly flags: Readonly<FlagMap>
-  readonly sub: Command<string, unknown, unknown, unknown>
+  readonly sub: Command<string, unknown, unknown, unknown, unknown>
   readonly childTokens: ReadonlyArray<Token>
   readonly errors: ReadonlyArray<CliError.CliError>
 }
@@ -249,8 +225,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 +250,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, unknown>> => {
+  const index = new Map<string, Command<string, unknown, unknown, unknown, unknown>>()
+  const setKey = (key: string, command: Command<string, unknown, 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 +370,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 +402,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                                                             */
 /* ========================================================================== */
@@ -469,7 +457,7 @@ const toLeafResult = (state: ParseState): LeafResult => ({
  * Determines how to handle the first value token.
  *
  * If it matches a known subcommand:
- * - Collect any parent flags from remaining tokens (npm-style)
+ * - Collect inherited parent flags from remaining tokens (npm-style)
  * - Return SubcommandResult with child tokens
  *
  * Otherwise:
@@ -482,13 +470,30 @@ const resolveFirstValue = (
   context: CommandContext,
   state: ParseState
 ): FirstValueResult => {
-  const { command, commandPath, flagRegistry } = context
+  const { command, commandPath, inheritedFlagRegistry, localFlagNames } = context
   const subIndex = buildSubcommandIndex(command.subcommands)
   const sub = subIndex.get(value)
 
   if (sub) {
-    // npm-style: parent flags can appear after subcommand name
-    const tail = consumeKnownFlags(cursor.rest(), flagRegistry)
+    const selectedPath = [...commandPath, sub.name]
+
+    // Local flags are not inherited by subcommands.
+    const parentFlags = state.flags.snapshot()
+    for (const localFlagName of localFlagNames) {
+      const values = parentFlags[localFlagName]
+      if (values !== undefined && values.length > 0) {
+        state.errors.push(
+          new CliError.UnrecognizedOption({
+            option: `--${localFlagName}`,
+            suggestions: [],
+            command: selectedPath
+          })
+        )
+      }
+    }
+
+    // npm-style: inherited parent flags can appear after subcommand name
+    const tail = consumeKnownFlags(cursor.rest(), inheritedFlagRegistry)
     state.flags.merge(tail.flagMap)
 
     return {
@@ -506,7 +511,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>()

package/src/unstable/cluster/Sharding.ts

@@ -4,7 +4,7 @@
 import * as Arr from "../../Array.ts"
 import * as Cause from "../../Cause.ts"
 import { Clock } from "../../Clock.ts"
-import type { DurationInput } from "../../Duration.ts"
+import type { Input } from "../../Duration.ts"
 import * as Duration from "../../Duration.ts"
 import * as Effect from "../../Effect.ts"
 import * as Equal from "../../Equal.ts"
@@ -13,6 +13,7 @@ import * as Fiber from "../../Fiber.ts"
 import * as FiberMap from "../../FiberMap.ts"
 import { constant, flow } from "../../Function.ts"
 import * as HashRing from "../../HashRing.ts"
+import * as Latch from "../../Latch.ts"
 import * as Layer from "../../Layer.ts"
 import * as MutableHashMap from "../../MutableHashMap.ts"
 import * as MutableHashSet from "../../MutableHashSet.ts"
@@ -23,6 +24,7 @@ import { CurrentLogAnnotations } from "../../References.ts"
 import * as Result from "../../Result.ts"
 import * as Schedule from "../../Schedule.ts"
 import * as Scope from "../../Scope.ts"
+import * as Semaphore from "../../Semaphore.ts"
 import * as ServiceMap from "../../ServiceMap.ts"
 import * as Stream from "../../Stream.ts"
 import type * as Rpc from "../rpc/Rpc.ts"
@@ -113,7 +115,7 @@ export class Sharding extends ServiceMap.Service<Sharding, {
     entity: Entity<Type, Rpcs>,
     handlers: Effect.Effect<Handlers, never, RX>,
     options?: {
-      readonly maxIdleTime?: DurationInput | undefined
+      readonly maxIdleTime?: Input | undefined
       readonly concurrency?: number | "unbounded" | undefined
       readonly mailboxCapacity?: number | "unbounded" | undefined
       readonly disableFatalDefects?: boolean | undefined
@@ -221,7 +223,7 @@ const make = Effect.gen(function*() {
 
   // the active shards are the ones that we have acquired the lock for
   const acquiredShards = MutableHashSet.empty<ShardId>()
-  const activeShardsLatch = yield* Effect.makeLatch(false)
+  const activeShardsLatch = yield* Latch.make(false)
 
   const events = yield* PubSub.unbounded<ShardingRegistrationEvent>()
   const getRegistrationEvents: Stream.Stream<ShardingRegistrationEvent> = Stream.fromPubSub(events)
@@ -429,16 +431,16 @@ const make = Effect.gen(function*() {
   // It should also be shutdown after the entity managers, to ensure interrupt
   // & ack envelopes can still be processed.
 
-  const storageReadLatch = yield* Effect.makeLatch(true)
+  const storageReadLatch = yield* Latch.make(true)
   const openStorageReadLatch = constant(Effect.asVoid(storageReadLatch.open))
 
-  const storageReadLock = Effect.makeSemaphoreUnsafe(1)
+  const storageReadLock = Semaphore.makeUnsafe(1)
   const withStorageReadLock = storageReadLock.withPermits(1)
 
   if (storageEnabled && config.runnerAddress) {
     const selfAddress = config.runnerAddress
     const entityRegistrationTimeoutMillis = Duration.toMillis(
-      Duration.fromDurationInputUnsafe(config.entityRegistrationTimeout)
+      Duration.fromInputUnsafe(config.entityRegistrationTimeout)
     )
     const storageStartMillis = clock.currentTimeMillisUnsafe()
 
@@ -810,7 +812,7 @@ const make = Effect.gen(function*() {
     void,
     MailboxFull | AlreadyProcessingMessage | PersistenceError
   > {
-    return Effect.catchIf(
+    return Effect.catchFilter(
       Effect.suspend(() => {
         const address = message.envelope.address
         const isPersisted = ServiceMap.get(message.rpc.annotations, Persisted)
@@ -1182,7 +1184,7 @@ const make = Effect.gen(function*() {
 
   const singletons = new Map<ShardId, MutableHashMap.MutableHashMap<SingletonAddress, Effect.Effect<void>>>()
   const singletonFibers = yield* FiberMap.make<SingletonAddress>()
-  const withSingletonLock = Effect.makeSemaphoreUnsafe(1).withPermits(1)
+  const withSingletonLock = Semaphore.makeUnsafe(1).withPermits(1)
 
   const registerSingleton: Sharding["Service"]["registerSingleton"] = Effect.fnUntraced(
     function*(name, run, options) {
@@ -1253,7 +1255,7 @@ const make = Effect.gen(function*() {
   // --- Entities ---
 
   const reaper = yield* EntityReaper
-  const entityManagerLatches = new Map<string, Effect.Latch>()
+  const entityManagerLatches = new Map<string, Latch.Latch>()
 
   const registerEntity: Sharding["Service"]["registerEntity"] = Effect.fnUntraced(
     function*(entity, build, options) {
@@ -1310,7 +1312,7 @@ const make = Effect.gen(function*() {
   const waitForEntityManager = (entityType: string) => {
     let latch = entityManagerLatches.get(entityType)
     if (!latch) {
-      latch = Effect.makeLatchUnsafe()
+      latch = Latch.makeUnsafe()
       entityManagerLatches.set(entityType, latch)
     }
     return latch.await