effect 4.0.0-beta.93 → 4.0.0-beta.97

package/src/unstable/cluster/Sharding.ts

@@ -38,7 +38,7 @@ import * as Semaphore from "../../Semaphore.ts"
 import * as Stream from "../../Stream.ts"
 import type * as Rpc from "../rpc/Rpc.ts"
 import * as RpcClient from "../rpc/RpcClient.ts"
-import { type FromServer, RequestId } from "../rpc/RpcMessage.ts"
+import type { FromServer } from "../rpc/RpcMessage.ts"
 import type { MailboxFull, PersistenceError } from "./ClusterError.ts"
 import { AlreadyProcessingMessage, EntityNotAssignedToRunner } from "./ClusterError.ts"
 import * as ClusterMetrics from "./ClusterMetrics.ts"
@@ -1034,148 +1034,151 @@ const make = Effect.gen(function*() {
       MailboxFull | AlreadyProcessingMessage
     >,
     never
-  > = yield* ResourceMap.make(Effect.fnUntraced(function*(entity: Entity<string, any>) {
-    const client = yield* RpcClient.makeNoSerialization(entity.protocol, {
-      spanPrefix: `${entity.type}.client`,
-      disableTracing: !Context.get(entity.protocol.annotations, ClusterSchema.ClientTracingEnabled),
-      supportsAck: true,
-      generateRequestId: () => RequestId(snowflakeGen.nextUnsafe()),
-      flatten: true,
-      onFromClient(options): Effect.Effect<
-        void,
-        MailboxFull | AlreadyProcessingMessage | PersistenceError
-      > {
-        const address = Context.getUnsafe(options.context, ClientAddressTag)
-        switch (options.message._tag) {
-          case "Request": {
-            const fiber = Fiber.getCurrent()!
-            const id = Snowflake.Snowflake(options.message.id)
-            const rpc = entity.protocol.requests.get(options.message.tag)!
-            let respond: (reply: Reply.Reply<any>) => Effect.Effect<void>
-            const envelope = Envelope.makeRequest<any>({
-              requestId: id,
-              address,
-              tag: options.message.tag,
-              payload: options.message.payload,
-              headers: options.message.headers,
-              traceId: options.message.traceId,
-              spanId: options.message.spanId,
-              sampled: options.message.sampled
-            })
-            const message = new Message.OutgoingRequest({
-              envelope,
-              lastReceivedReply: Option.none(),
-              rpc,
-              context: fiber.context as Context.Context<any>,
-              respond: (reply) => respond(reply),
-              annotations: Context.get(rpc.annotations, ClusterSchema.Dynamic)(
-                rpc.annotations,
-                envelope as any
-              )
-            })
-            if (!options.discard) {
-              const entry: ClientRequestEntry = {
-                rpc: rpc as any,
-                context: fiber.currentContext,
-                message
+  > = yield* ResourceMap.make(
+    Effect.fnUntraced(function*(entity: Entity<string, any>) {
+      const client = yield* RpcClient.makeNoSerialization(entity.protocol, {
+        spanPrefix: `${entity.type}.client`,
+        disableTracing: !Context.get(entity.protocol.annotations, ClusterSchema.ClientTracingEnabled),
+        supportsAck: true,
+        generateRequestId: () => snowflakeGen.nextUnsafe() as any,
+        flatten: true,
+        onFromClient(options): Effect.Effect<
+          void,
+          MailboxFull | AlreadyProcessingMessage | PersistenceError
+        > {
+          const address = Context.getUnsafe(options.context, ClientAddressTag)
+          switch (options.message._tag) {
+            case "Request": {
+              const fiber = Fiber.getCurrent()!
+              const id = Snowflake.Snowflake(options.message.id)
+              const rpc = entity.protocol.requests.get(options.message.tag)!
+              let respond: (reply: Reply.Reply<any>) => Effect.Effect<void>
+              const envelope = Envelope.makeRequest<any>({
+                requestId: id,
+                address,
+                tag: options.message.tag,
+                payload: options.message.payload,
+                headers: options.message.headers,
+                traceId: options.message.traceId,
+                spanId: options.message.spanId,
+                sampled: options.message.sampled
+              })
+              const message = new Message.OutgoingRequest({
+                envelope,
+                lastReceivedReply: Option.none(),
+                rpc,
+                context: fiber.context as Context.Context<any>,
+                respond: (reply) => respond(reply),
+                annotations: Context.get(rpc.annotations, ClusterSchema.Dynamic)(
+                  rpc.annotations,
+                  envelope as any
+                )
+              })
+              if (!options.discard) {
+                const entry: ClientRequestEntry = {
+                  rpc: rpc as any,
+                  context: fiber.currentContext,
+                  message
+                }
+                clientRequests.set(id, entry)
+                respond = makeClientRespond(entry, client.write)
+              } else {
+                respond = clientRespondDiscard
               }
-              clientRequests.set(id, entry)
-              respond = makeClientRespond(entry, client.write)
-            } else {
-              respond = clientRespondDiscard
+              return sendOutgoing(message, options.discard)
             }
-            return sendOutgoing(message, options.discard)
-          }
-          case "Ack": {
-            const requestId = Snowflake.Snowflake(options.message.requestId)
-            const entry = clientRequests.get(requestId)
-            if (!entry) return Effect.void
-            return sendOutgoing(
-              new Message.OutgoingEnvelope({
-                envelope: new Envelope.AckChunk({
-                  id: snowflakeGen.nextUnsafe(),
-                  address,
-                  requestId,
-                  replyId: entry.lastChunkId!
+            case "Ack": {
+              const requestId = Snowflake.Snowflake(options.message.requestId)
+              const entry = clientRequests.get(requestId)
+              if (!entry) return Effect.void
+              return sendOutgoing(
+                new Message.OutgoingEnvelope({
+                  envelope: new Envelope.AckChunk({
+                    id: snowflakeGen.nextUnsafe(),
+                    address,
+                    requestId,
+                    replyId: entry.lastChunkId!
+                  }),
+                  rpc: entry.rpc
                 }),
-                rpc: entry.rpc
-              }),
-              false
-            )
-          }
-          case "Interrupt": {
-            const requestId = Snowflake.Snowflake(options.message.requestId)
-            const entry = clientRequests.get(requestId)!
-            if (!entry) return Effect.void
-            clientRequests.delete(requestId)
-            if (ClusterSchema.isUninterruptibleForClient(entry.message.annotations)) {
-              return Effect.void
-            }
-            // for durable messages, we ignore interrupts on shutdown or as a
-            // result of a shard being resassigned
-            const isTransientInterrupt = MutableRef.get(isShutdown) ||
-              options.message.interruptors.some((id) => internalInterruptors.has(id))
-            if (isTransientInterrupt && Context.get(entry.message.annotations, Persisted)) {
-              return Effect.void
+                false
+              )
             }
-            return Effect.ignore(sendOutgoing(
-              new Message.OutgoingEnvelope({
-                envelope: new Envelope.Interrupt({
-                  id: snowflakeGen.nextUnsafe(),
-                  address,
-                  requestId
+            case "Interrupt": {
+              const requestId = Snowflake.Snowflake(options.message.requestId)
+              const entry = clientRequests.get(requestId)!
+              if (!entry) return Effect.void
+              clientRequests.delete(requestId)
+              if (ClusterSchema.isUninterruptibleForClient(entry.message.annotations)) {
+                return Effect.void
+              }
+              // for durable messages, we ignore interrupts on shutdown or as a
+              // result of a shard being resassigned
+              const isTransientInterrupt = MutableRef.get(isShutdown) ||
+                options.message.interruptors.some((id) => internalInterruptors.has(id))
+              if (isTransientInterrupt && Context.get(entry.message.annotations, Persisted)) {
+                return Effect.void
+              }
+              return Effect.ignore(sendOutgoing(
+                new Message.OutgoingEnvelope({
+                  envelope: new Envelope.Interrupt({
+                    id: snowflakeGen.nextUnsafe(),
+                    address,
+                    requestId
+                  }),
+                  rpc: entry.rpc
                 }),
-                rpc: entry.rpc
-              }),
-              false,
-              3
-            ))
+                false,
+                3
+              ))
+            }
           }
+          return Effect.void
         }
-        return Effect.void
-      }
-    })
-
-    yield* Scope.addFinalizer(
-      yield* Effect.scope,
-      Effect.withFiber((fiber) => {
-        internalInterruptors.add(fiber.id)
-        return Effect.void
       })
-    )
 
-    return (entityId: string) => {
-      const id = makeEntityId(entityId)
-      const address = ClientAddressTag.context(makeEntityAddress({
-        shardId: getShardId(id, entity.getShardGroup(entityId as EntityId)),
-        entityId: id,
-        entityType: entity.type
-      }))
-      const clientFn = function(tag: string, payload: any, options?: {
-        readonly context?: Context.Context<never>
-      }) {
-        const context = options?.context ? Context.merge(options.context, address) : address
-        return client.client(tag, payload, {
-          ...options,
-          context
+      yield* Scope.addFinalizer(
+        yield* Effect.scope,
+        Effect.withFiber((fiber) => {
+          internalInterruptors.add(fiber.id)
+          return Effect.void
         })
-      }
-      const proxyClient: any = {}
-      return new Proxy(proxyClient, {
-        has(_, p) {
-          return entity.protocol.requests.has(p as string)
-        },
-        get(target, p) {
-          if (p in target) {
-            return target[p]
-          } else if (!entity.protocol.requests.has(p as string)) {
-            return undefined
-          }
-          return target[p] = (payload: any, options?: {}) => clientFn(p as string, payload, options)
+      )
+
+      return (entityId: string) => {
+        const id = makeEntityId(entityId)
+        const address = ClientAddressTag.context(makeEntityAddress({
+          shardId: getShardId(id, entity.getShardGroup(entityId as EntityId)),
+          entityId: id,
+          entityType: entity.type
+        }))
+        const clientFn = function(tag: string, payload: any, options?: {
+          readonly context?: Context.Context<never>
+        }) {
+          const context = options?.context ? Context.merge(options.context, address) : address
+          return client.client(tag, payload, {
+            ...options,
+            context
+          })
         }
-      })
-    }
-  }))
+        const proxyClient: any = {}
+        return new Proxy(proxyClient, {
+          has(_, p) {
+            return entity.protocol.requests.has(p as string)
+          },
+          get(target, p) {
+            if (p in target) {
+              return target[p]
+            } else if (!entity.protocol.requests.has(p as string)) {
+              return undefined
+            }
+            return target[p] = (payload: any, options?: {}) => clientFn(p as string, payload, options)
+          }
+        })
+      }
+    }),
+    { referential: true }
+  )
 
   const makeClient = <Type extends string, Rpcs extends Rpc.Any>(entity: Entity<Type, Rpcs>): Effect.Effect<
     (
@@ -1196,7 +1199,7 @@ const make = Effect.gen(function*() {
         return write({
           _tag: "Chunk",
           clientId: 0,
-          requestId: RequestId(reply.requestId),
+          requestId: reply.requestId as any,
           values: reply.values
         })
       }
@@ -1205,7 +1208,7 @@ const make = Effect.gen(function*() {
         return write({
           _tag: "Exit",
           clientId: 0,
-          requestId: RequestId(reply.requestId),
+          requestId: reply.requestId as any,
           exit: reply.exit
         })
       }

package/src/unstable/cluster/Snowflake.ts

@@ -53,8 +53,8 @@ export type Snowflake = Brand.Branded<bigint, TypeId>
  * @category constructors
  * @since 4.0.0
  */
-export const Snowflake = (input: string | bigint): Snowflake =>
-  typeof input === "string" ? BigInt(input) as Snowflake : input as Snowflake
+export const Snowflake = (input: string | number | bigint): Snowflake =>
+  typeof input === "bigint" ? input as Snowflake : BigInt(input) as Snowflake
 
 /**
  * Namespace containing support types for snowflake parts and generators.

package/src/unstable/cluster/internal/entityManager.ts

@@ -18,7 +18,6 @@ import * as Schema from "../../../Schema.ts"
 import * as SchemaIssue from "../../../SchemaIssue.ts"
 import * as Scope from "../../../Scope.ts"
 import type * as Rpc from "../../rpc/Rpc.ts"
-import { RequestId } from "../../rpc/RpcMessage.ts"
 import * as RpcServer from "../../rpc/RpcServer.ts"
 import { AlreadyProcessingMessage, EntityNotAssignedToRunner, MailboxFull, MalformedMessage } from "../ClusterError.ts"
 import * as ClusterMetrics from "../ClusterMetrics.ts"
@@ -67,7 +66,7 @@ export interface EntityManager {
 export type EntityState = {
   readonly address: EntityAddress
   readonly scope: Scope.Scope
-  readonly activeRequests: Map<bigint, {
+  readonly activeRequests: Map<Snowflake.Snowflake, {
     readonly rpc: Rpc.AnyWithProps
     readonly message: Message.IncomingRequestLocal<any>
     sentReply: boolean
@@ -145,7 +144,7 @@ export const make = Effect.fnUntraced(function*<
     )
 
     const activeRequests: EntityState["activeRequests"] = new Map()
-    let defectRequestIds = new Set<bigint>()
+    let defectRequestIds = new Set<Snowflake.Snowflake>()
     let isRestartingDueToDefect = false
 
     // the server is stored in a ref, so if there is a defect, we can
@@ -155,16 +154,18 @@ export const make = Effect.fnUntraced(function*<
       Effect.fnUntraced(function*(scope) {
         let isShuttingDown = false
 
+        const handlerContext = Context.mutate(context, (context) =>
+          context.pipe(
+            Context.add(CurrentAddress, address),
+            Context.add(CurrentRunnerAddress, options.runnerAddress),
+            Context.add(KeepAliveLatch, keepAliveLatch),
+            Context.add(Scope.Scope, scope),
+            Context.add(CurrentLogAnnotations, {})
+          ))
+
         // Initiate the behavior for the entity
         const handlers = yield* (entity.protocol.toHandlers(buildHandlers as any).pipe(
-          Effect.provideService(CurrentLogAnnotations, {}),
-          Effect.provideContext(Context.mutate(context, (context) =>
-            context.pipe(
-              Context.add(CurrentAddress, address),
-              Context.add(CurrentRunnerAddress, options.runnerAddress),
-              Context.add(KeepAliveLatch, keepAliveLatch),
-              Context.add(Scope.Scope, scope)
-            ))),
+          Effect.setContext(handlerContext as Context.Context<any>),
           Effect.sandbox,
           Effect.tapError((cause) => Effect.logError("Defect building entity handlers", cause)),
           Effect.retry(defectRetryPolicy)
@@ -182,7 +183,7 @@ export const make = Effect.fnUntraced(function*<
           onFromServer(response): Effect.Effect<void> {
             switch (response._tag) {
               case "Exit": {
-                const request = activeRequests.get(response.requestId)
+                const request = activeRequests.get(Snowflake.Snowflake(response.requestId))
                 if (!request) return Effect.void
 
                 request.sentReply = true
@@ -190,7 +191,7 @@ export const make = Effect.fnUntraced(function*<
                 if (
                   isShuttingDown &&
                   Exit.hasInterrupts(response.exit) &&
-                  defectRequestIds.has(response.requestId)
+                  defectRequestIds.has(Snowflake.Snowflake(response.requestId))
                 ) {
                   return Effect.void
                 }
@@ -208,7 +209,7 @@ export const make = Effect.fnUntraced(function*<
                   if (!isShuttingDown) {
                     return server.write(0, {
                       ...request.message.envelope,
-                      id: RequestId(request.message.envelope.requestId),
+                      id: request.message.envelope.requestId as any,
                       tag: request.message.envelope.tag as any,
                       payload: new Request({
                         ...request.message.envelope,
@@ -218,7 +219,7 @@ export const make = Effect.fnUntraced(function*<
                       Effect.forkIn(scope)
                     )
                   }
-                  activeRequests.delete(response.requestId)
+                  activeRequests.delete(Snowflake.Snowflake(response.requestId))
                   return options.storage.unregisterReplyHandler(request.message.envelope.requestId)
                 }
                 return retryRespond(
@@ -235,7 +236,7 @@ export const make = Effect.fnUntraced(function*<
                 ).pipe(
                   Effect.flatMap(() => {
                     processedRequestIds.add(request.message.envelope.requestId)
-                    activeRequests.delete(response.requestId)
+                    activeRequests.delete(Snowflake.Snowflake(response.requestId))
 
                     // ensure that the reaper does not remove the entity as we haven't
                     // been "idle" yet
@@ -249,7 +250,7 @@ export const make = Effect.fnUntraced(function*<
                 )
               }
               case "Chunk": {
-                const request = activeRequests.get(response.requestId)
+                const request = activeRequests.get(Snowflake.Snowflake(response.requestId))
                 if (!request) return Effect.void
                 const sequence = request.sequence
                 request.sequence++
@@ -280,7 +281,7 @@ export const make = Effect.fnUntraced(function*<
           }
         }).pipe(
           Scope.provide(scope),
-          Effect.provideContext(handlers)
+          Effect.setContext(Context.merge(handlerContext, handlers))
         )
 
         yield* Scope.addFinalizer(
@@ -297,7 +298,7 @@ export const make = Effect.fnUntraced(function*<
             const { lastSentChunk, message } = request
             yield* server.write(0, {
               ...message.envelope,
-              id: RequestId(message.envelope.requestId),
+              id: message.envelope.requestId as any,
               tag: message.envelope.tag as any,
               payload: new Request({
                 ...message.envelope,
@@ -473,7 +474,7 @@ export const make = Effect.fnUntraced(function*<
               server.activeRequests.set(message.envelope.requestId, entry)
               let write = server.write(0, {
                 ...message.envelope,
-                id: RequestId(message.envelope.requestId),
+                id: message.envelope.requestId as any,
                 payload: new Request({
                   ...message.envelope,
                   lastSentChunk: Option.filter(
@@ -501,10 +502,10 @@ export const make = Effect.fnUntraced(function*<
               return server.write(
                 0,
                 message.envelope._tag === "AckChunk"
-                  ? { _tag: "Ack", requestId: RequestId(message.envelope.requestId) }
+                  ? { _tag: "Ack", requestId: message.envelope.requestId as any }
                   : {
                     _tag: "Interrupt",
-                    requestId: RequestId(message.envelope.requestId),
+                    requestId: message.envelope.requestId as any,
                     interruptors: []
                   }
               )
@@ -609,9 +610,10 @@ export const make = Effect.fnUntraced(function*<
   })
 })
 
-const defaultRetryPolicy = Schedule.exponential(500, 1.5).pipe(
-  Schedule.either(Schedule.spaced("10 seconds"))
-)
+const defaultRetryPolicy = Schedule.min([
+  Schedule.exponential(500, 1.5),
+  Schedule.spaced("10 seconds")
+])
 
 const makeMessageDecode = <Type extends string, Rpcs extends Rpc.Any>(
   entity: Entity<Type, Rpcs>,

package/src/unstable/cluster/internal/resourceMap.ts

@@ -4,23 +4,16 @@ import * as Effect from "../../../Effect.ts"
 import * as Exit from "../../../Exit.ts"
 import * as MutableHashMap from "../../../MutableHashMap.ts"
 import * as MutableRef from "../../../MutableRef.ts"
-import * as Option from "../../../Option.ts"
 import * as Scope from "../../../Scope.ts"
 
 /** @internal */
 export class ResourceMap<K, A, E> {
   readonly lookup: (key: K, scope: Scope.Scope) => Effect.Effect<A, E>
-  readonly entries: MutableHashMap.MutableHashMap<K, {
-    readonly scope: Scope.Closeable
-    readonly deferred: Deferred.Deferred<A, E>
-  }>
+  readonly entries: BackingMap<K, A, E>
   readonly isClosed: MutableRef.MutableRef<boolean>
   constructor(
     lookup: (key: K, scope: Scope.Scope) => Effect.Effect<A, E>,
-    entries: MutableHashMap.MutableHashMap<K, {
-      readonly scope: Scope.Closeable
-      readonly deferred: Deferred.Deferred<A, E>
-    }>,
+    entries: BackingMap<K, A, E>,
     isClosed: MutableRef.MutableRef<boolean>
   ) {
     this.lookup = lookup
@@ -28,22 +21,29 @@ export class ResourceMap<K, A, E> {
     this.isClosed = isClosed
   }
 
-  static make = Effect.fnUntraced(function*<K, A, E, R>(lookup: (key: K) => Effect.Effect<A, E, R>) {
+  static make = Effect.fnUntraced(function*<K, A, E, R>(lookup: (key: K) => Effect.Effect<A, E, R>, options?: {
+    readonly referential?: boolean | undefined
+  }) {
     const scope = yield* Effect.scope
     const services = yield* Effect.context<R>()
     const isClosed = MutableRef.make(false)
 
-    const entries = MutableHashMap.empty<K, {
-      scope: Scope.Closeable
-      deferred: Deferred.Deferred<A, E>
-    }>()
+    const entries: BackingMap<K, A, E> = options?.referential ?
+      {
+        _tag: "Referential",
+        map: new Map()
+      } :
+      {
+        _tag: "Equal",
+        map: MutableHashMap.empty()
+      }
 
     yield* Scope.addFinalizerExit(
       scope,
       (exit) => {
         MutableRef.set(isClosed, true)
-        return Effect.forEach(entries, ([key, { scope }]) => {
-          MutableHashMap.remove(entries, key)
+        return Effect.forEach(entries.map, ([key, { scope }]) => {
+          backingDelete(entries, key)
           return Effect.exit(Scope.close(scope, exit))
         }, { concurrency: "unbounded", discard: true })
       }
@@ -61,18 +61,18 @@ export class ResourceMap<K, A, E> {
       if (MutableRef.get(this.isClosed)) {
         return Effect.interrupt
       }
-      const existing = MutableHashMap.get(this.entries, key)
-      if (Option.isSome(existing)) {
-        return Deferred.await(existing.value.deferred)
+      const existing = backingGet(this.entries, key)
+      if (existing) {
+        return Deferred.await(existing.deferred)
       }
       const scope = Effect.runSync(Scope.make())
       const deferred = Deferred.makeUnsafe<A, E>()
-      MutableHashMap.set(this.entries, key, { scope, deferred })
+      backingSet(this.entries, key, { scope, deferred })
       return Effect.onExit(this.lookup(key, scope), (exit) => {
         if (exit._tag === "Success") {
           return Deferred.done(deferred, exit)
         }
-        MutableHashMap.remove(this.entries, key)
+        backingDelete(this.entries, key)
         return Deferred.done(deferred, exit)
       })
     })
@@ -80,12 +80,12 @@ export class ResourceMap<K, A, E> {
 
   remove(key: K): Effect.Effect<void> {
     return Effect.suspend(() => {
-      const entry = MutableHashMap.get(this.entries, key)
-      if (Option.isNone(entry)) {
+      const entry = backingGet(this.entries, key)
+      if (!entry) {
         return Effect.void
       }
-      MutableHashMap.remove(this.entries, key)
-      return Scope.close(entry.value.scope, Exit.void)
+      backingDelete(this.entries, key)
+      return Scope.close(entry.scope, Exit.void)
     })
   }
 
@@ -98,3 +98,37 @@ export class ResourceMap<K, A, E> {
       }))
   }
 }
+
+type BackingMap<K, A, E> = {
+  readonly _tag: "Equal"
+  readonly map: MutableHashMap.MutableHashMap<K, Entry<A, E>>
+} | {
+  readonly _tag: "Referential"
+  readonly map: Map<K, Entry<A, E>>
+}
+
+type Entry<A, E> = {
+  readonly scope: Scope.Closeable
+  readonly deferred: Deferred.Deferred<A, E>
+}
+
+const backingGet = <K, A, E>(map: BackingMap<K, A, E>, key: K): Entry<A, E> | undefined => {
+  if (map._tag === "Equal") {
+    return MutableHashMap.get(map.map, key).valueOrUndefined
+  }
+  return map.map.get(key)
+}
+const backingSet = <K, A, E>(map: BackingMap<K, A, E>, key: K, entry: Entry<A, E>): void => {
+  if (map._tag === "Equal") {
+    MutableHashMap.set(map.map, key, entry)
+  } else {
+    map.map.set(key, entry)
+  }
+}
+const backingDelete = <K, A, E>(map: BackingMap<K, A, E>, key: K): void => {
+  if (map._tag === "Equal") {
+    MutableHashMap.remove(map.map, key)
+  } else {
+    map.map.delete(key)
+  }
+}

package/src/unstable/encoding/Sse.ts

@@ -80,15 +80,15 @@ export const decode = <IE, Done>(): Channel.Channel<
  * @since 4.0.0
  */
 export interface EventCodec extends
-  Schema.Codec<
+  Schema.ConstraintCodec<
     any,
     {
       readonly id?: string | undefined
       readonly event?: string | undefined
       readonly data: string
     },
-    any,
-    any
+    unknown,
+    unknown
   >
 {}
 

package/src/unstable/eventlog/EventLog.ts

@@ -854,9 +854,10 @@ const make = Effect.gen(function*() {
         Effect.scoped,
         Effect.catchCause(Effect.logError),
         Effect.repeat(
-          Schedule.exponential(200, 1.5).pipe(
-            Schedule.either(Schedule.spaced({ seconds: 10 }))
-          )
+          Schedule.min([
+            Schedule.exponential(200, 1.5),
+            Schedule.spaced({ seconds: 10 })
+          ])
         ),
         Effect.annotateLogs({
           service: "EventLog",