effect 4.0.0-beta.31 → 4.0.0-beta.33

package/src/unstable/cluster/ClusterWorkflowEngine.ts

@@ -8,6 +8,7 @@ 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 Option from "../../Option.ts"
 import * as PrimaryKey from "../../PrimaryKey.ts"
 import * as RcMap from "../../RcMap.ts"
 import type * as Record from "../../Record.ts"
@@ -150,8 +151,9 @@ export const make = Effect.gen(function*() {
     const replies = yield* storage.repliesForUnfiltered([requestId])
     const last = replies[replies.length - 1]
     if (last && last._tag === "WithExit") {
-      return last as WithExitEncoded<Workflow.ResultEncoded<any, any>>
+      return Option.some(last as WithExitEncoded<Workflow.ResultEncoded<any, any>>)
     }
+    return Option.none<WithExitEncoded<Workflow.ResultEncoded<any, any>>>()
   })
 
   const requestReply = Effect.fnUntraced(function*(options: {
@@ -162,10 +164,10 @@ export const make = Effect.gen(function*() {
     readonly id: string
   }) {
     const requestId = yield* requestIdFor(options)
-    if (requestId === undefined) {
-      return undefined
+    if (Option.isNone(requestId)) {
+      return Option.none<WithExitEncoded<Workflow.ResultEncoded<any, any>>>()
     }
-    return yield* replyForRequestId(requestId)
+    return yield* replyForRequestId(requestId.value)
   })
 
   const resetActivityAttempt = Effect.fnUntraced(
@@ -182,8 +184,8 @@ export const make = Effect.gen(function*() {
         tag: "activity",
         id: activityPrimaryKey(options.activity.name, options.attempt)
       })
-      if (requestId === undefined) return
-      yield* sharding.reset(requestId)
+      if (Option.isNone(requestId)) return
+      yield* sharding.reset(requestId.value)
     },
     Effect.retry({
       times: 3,
@@ -218,13 +220,13 @@ export const make = Effect.gen(function*() {
       id: ""
     })
 
-    const maybeSuspended =
-      maybeReply && maybeReply.exit._tag === "Success" && maybeReply.exit.value._tag === "Suspended"
-        ? maybeReply
-        : undefined
+    const maybeSuspended = Option.filter(
+      maybeReply,
+      (reply) => reply.exit._tag === "Success" && reply.exit.value._tag === "Suspended"
+    )
 
-    if (maybeSuspended === undefined) return
-    yield* sharding.reset(Snowflake.Snowflake(maybeSuspended.requestId))
+    if (Option.isNone(maybeSuspended)) return
+    yield* sharding.reset(Snowflake.Snowflake(maybeSuspended.value.requestId))
     yield* sharding.pollStorage
   })
 
@@ -239,13 +241,13 @@ export const make = Effect.gen(function*() {
       tag: "resume",
       id: ""
     })
-    if (requestId === undefined) {
+    if (Option.isNone(requestId)) {
       const client = (yield* RcMap.get(clientsPartial, options.workflowName))(options.executionId)
       return yield* client.resume({} as any, { discard: true })
     }
-    const reply = yield* replyForRequestId(requestId)
-    if (reply === undefined) return
-    yield* sharding.reset(requestId)
+    const reply = yield* replyForRequestId(requestId.value)
+    if (Option.isNone(reply)) return
+    yield* sharding.reset(requestId.value)
   }, Effect.scoped)
 
   const engine = WorkflowEngine.makeUnsafe({
@@ -272,7 +274,7 @@ export const make = Effect.gen(function*() {
                     }
                     return engine.deferredResult(InterruptSignal).pipe(
                       Effect.flatMap((maybeExit) => {
-                        if (maybeExit === undefined) {
+                        if (Option.isNone(maybeExit)) {
                           return Effect.void
                         }
                         instance.suspended = false
@@ -373,12 +375,12 @@ export const make = Effect.gen(function*() {
         tag: "run",
         id: ""
       })
-      if (!reply) return undefined
-      const exit = yield* (Schema.decodeUnknownEffect(exitSchema)(reply.exit) as Effect.Effect<
+      if (Option.isNone(reply)) return Option.none()
+      const exit = yield* (Schema.decodeUnknownEffect(exitSchema)(reply.value.exit) as Effect.Effect<
         Exit.Exit<any, any>,
         Schema.SchemaError
       >)
-      return yield* exit
+      return Option.some(yield* exit)
     }, Effect.orDie),
 
     interrupt: Effect.fnUntraced(
@@ -392,10 +394,11 @@ export const make = Effect.gen(function*() {
           id: ""
         })
 
-        const nonSuspendedReply = reply && (reply.exit._tag !== "Success" || reply.exit.value._tag !== "Suspended")
-          ? reply
-          : undefined
-        if (nonSuspendedReply !== undefined) {
+        const nonSuspendedReply = Option.filter(
+          reply,
+          (reply) => reply.exit._tag !== "Success" || reply.exit.value._tag !== "Suspended"
+        )
+        if (Option.isSome(nonSuspendedReply)) {
           return
         }
 
@@ -463,13 +466,15 @@ export const make = Effect.gen(function*() {
           })
         ),
         Effect.map((reply) => {
-          if (reply === undefined) {
-            return undefined
+          if (Option.isNone(reply)) {
+            return Option.none<Exit.Exit<unknown, unknown>>()
           }
-          const decoded = decodeDeferredWithExit(reply as any)
-          return decoded.exit._tag === "Success"
-            ? decoded.exit.value
-            : decoded.exit
+          const decoded = decodeDeferredWithExit(reply.value as any)
+          return Option.some(
+            decoded.exit._tag === "Success"
+              ? decoded.exit.value
+              : decoded.exit
+          )
         }),
         Effect.retry({
           while: (e) => e._tag === "PersistenceError",

package/src/unstable/cluster/Entity.ts

@@ -12,13 +12,13 @@ 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 Option from "../../Option.ts"
 import * as Predicate from "../../Predicate.ts"
 import * as Queue from "../../Queue.ts"
 import type * as Schedule from "../../Schedule.ts"
 import { Scope } from "../../Scope.ts"
 import * as ServiceMap from "../../ServiceMap.ts"
 import type * as Stream from "../../Stream.ts"
-import * as UndefinedOr from "../../UndefinedOr.ts"
 import * as Headers from "../http/Headers.ts"
 import * as Rpc from "../rpc/Rpc.ts"
 import * as RpcClient from "../rpc/RpcClient.ts"
@@ -459,24 +459,24 @@ export declare namespace Replier {
  */
 export class Request<Rpc extends Rpc.Any> extends Data.Class<
   Envelope.Request<Rpc> & {
-    readonly lastSentChunk: Reply.Chunk<Rpc> | undefined
+    readonly lastSentChunk: Option.Option<Reply.Chunk<Rpc>>
   }
 > {
   /**
    * @since 4.0.0
    */
-  get lastSentChunkValue(): Rpc.SuccessChunk<Rpc> | undefined {
-    return UndefinedOr.map(this.lastSentChunk, (chunk) => Arr.lastNonEmpty(chunk.values))
+  get lastSentChunkValue(): Option.Option<Rpc.SuccessChunk<Rpc>> {
+    return Option.map(this.lastSentChunk, (chunk) => Arr.lastNonEmpty(chunk.values))
   }
 
   /**
    * @since 4.0.0
    */
   get nextSequence(): number {
-    if (this.lastSentChunk === undefined) {
+    if (Option.isNone(this.lastSentChunk)) {
       return 0
     }
-    return this.lastSentChunk.sequence + 1
+    return this.lastSentChunk.value.sequence + 1
   }
 }
 
@@ -524,10 +524,11 @@ export const makeTestClient: <Type extends string, Rpcs extends Rpc.Any, LA, LE,
           services: services as any,
           concurrency: options?.concurrency ?? 1,
           build: entity.protocol.toHandlers(handlers as any).pipe(
-            Effect.provideServices(services.pipe(
-              ServiceMap.add(CurrentRunnerAddress, runnerAddress),
-              ServiceMap.omit(Scope)
-            ))
+            Effect.provideServices(ServiceMap.mutate(services, (services) =>
+              services.pipe(
+                ServiceMap.add(CurrentRunnerAddress, runnerAddress),
+                ServiceMap.omit(Scope)
+              )))
           ) as any
         })
         return Effect.void
@@ -570,7 +571,7 @@ export const makeTestClient: <Type extends string, Rpcs extends Rpc.Any, LA, LE,
               [Envelope.TypeId]: Envelope.TypeId,
               address,
               requestId: Snowflake.Snowflake(message.id),
-              lastSentChunk: undefined
+              lastSentChunk: Option.none()
             }) as any
           })
         }
@@ -619,7 +620,7 @@ export const keepAlive: (
         spanId: span.spanId,
         sampled: span.sampled
       }),
-      lastReceivedReply: undefined,
+      lastReceivedReply: Option.none(),
       respond: () => Effect.void
     }),
     true

package/src/unstable/cluster/Message.ts

@@ -3,6 +3,7 @@
  */
 import * as Data from "../../Data.ts"
 import * as Effect from "../../Effect.ts"
+import * as Option from "../../Option.ts"
 import * as Schema from "../../Schema.ts"
 import type { ServiceMap } from "../../ServiceMap.ts"
 import * as Rpc from "../rpc/Rpc.ts"
@@ -36,7 +37,7 @@ export const incomingLocalFromOutgoing = <R extends Rpc.Any>(self: Outgoing<R>):
   return new IncomingRequestLocal({
     envelope: self.envelope,
     respond: self.respond,
-    lastSentReply: undefined
+    lastSentReply: Option.none()
   })
 }
 
@@ -46,7 +47,7 @@ export const incomingLocalFromOutgoing = <R extends Rpc.Any>(self: Outgoing<R>):
  */
 export class IncomingRequest<R extends Rpc.Any> extends Data.TaggedClass("IncomingRequest")<{
   readonly envelope: Envelope.PartialRequest
-  readonly lastSentReply: Reply.Encoded | undefined
+  readonly lastSentReply: Option.Option<Reply.Encoded>
   readonly respond: (reply: Reply.ReplyWithContext<R>) => Effect.Effect<void, MalformedMessage | PersistenceError>
 }> {}
 
@@ -56,7 +57,7 @@ export class IncomingRequest<R extends Rpc.Any> extends Data.TaggedClass("Incomi
  */
 export class IncomingRequestLocal<R extends Rpc.Any> extends Data.TaggedClass("IncomingRequestLocal")<{
   readonly envelope: Envelope.Request<R>
-  readonly lastSentReply: Reply.Reply<R> | undefined
+  readonly lastSentReply: Option.Option<Reply.Reply<R>>
   readonly respond: (reply: Reply.Reply<R>) => Effect.Effect<void, MalformedMessage | PersistenceError>
 }> {}
 
@@ -82,7 +83,7 @@ export type Outgoing<R extends Rpc.Any> = OutgoingRequest<R> | OutgoingEnvelope
 export class OutgoingRequest<R extends Rpc.Any> extends Data.TaggedClass("OutgoingRequest")<{
   readonly envelope: Envelope.Request<R>
   readonly services: ServiceMap<Rpc.Services<R>>
-  readonly lastReceivedReply: Reply.Reply<R> | undefined
+  readonly lastReceivedReply: Option.Option<Reply.Reply<R>>
   readonly rpc: R
   readonly respond: (reply: Reply.Reply<R>) => Effect.Effect<void>
 }> {
@@ -196,7 +197,7 @@ export const deserializeLocal = <Rpc extends Rpc.Any>(
           ...encoded,
           payload
         } as any),
-        lastSentReply: undefined,
+        lastSentReply: Option.none(),
         respond: self.respond
       })
     )

package/src/unstable/cluster/MessageStorage.ts

@@ -8,11 +8,10 @@ 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 * as Option from "../../Option.ts"
 import type { Predicate } from "../../Predicate.ts"
 import * as Schema from "../../Schema.ts"
 import * as ServiceMap from "../../ServiceMap.ts"
-import * as UndefinedOr from "../../UndefinedOr.ts"
 import type * as Rpc from "../rpc/Rpc.ts"
 import { EntityNotAssignedToRunner, MalformedMessage, type PersistenceError } from "./ClusterError.ts"
 import * as DeliverAt from "./DeliverAt.ts"
@@ -81,7 +80,7 @@ export class MessageStorage extends ServiceMap.Service<MessageStorage, {
       readonly tag: string
       readonly id: string
     }
-  ) => Effect.Effect<Snowflake.Snowflake | undefined, PersistenceError>
+  ) => Effect.Effect<Option.Option<Snowflake.Snowflake>, PersistenceError>
 
   /**
    * For locally sent messages, register a handler to process the replies.
@@ -187,7 +186,7 @@ export declare namespace SaveResult {
   export interface Duplicate<R extends Rpc.Any> {
     readonly _tag: "Duplicate"
     readonly originalId: Snowflake.Snowflake
-    readonly lastReceivedReply: Reply.Reply<R> | undefined
+    readonly lastReceivedReply: Option.Option<Reply.Reply<R>>
   }
 
   /**
@@ -197,7 +196,7 @@ export declare namespace SaveResult {
   export interface DuplicateEncoded {
     readonly _tag: "Duplicate"
     readonly originalId: Snowflake.Snowflake
-    readonly lastReceivedReply: Reply.Encoded | undefined
+    readonly lastReceivedReply: Option.Option<Reply.Encoded>
   }
 
   /**
@@ -240,7 +239,7 @@ export type Encoded = {
    */
   readonly requestIdForPrimaryKey: (
     primaryKey: string
-  ) => Effect.Effect<Snowflake.Snowflake | undefined, PersistenceError>
+  ) => Effect.Effect<Option.Option<Snowflake.Snowflake>, PersistenceError>
 
   /**
    * Retrieves the replies for the specified requests.
@@ -277,7 +276,7 @@ export type Encoded = {
   ) => Effect.Effect<
     Array<{
       readonly envelope: Envelope.Encoded
-      readonly lastSentReply: Reply.Encoded | undefined
+      readonly lastSentReply: Option.Option<Reply.Encoded>
     }>,
     PersistenceError
   >
@@ -291,7 +290,7 @@ export type Encoded = {
   ) => Effect.Effect<
     Array<{
       readonly envelope: Envelope.Encoded
-      readonly lastSentReply: Reply.Encoded | undefined
+      readonly lastSentReply: Option.Option<Reply.Encoded>
     }>,
     PersistenceError
   >
@@ -463,18 +462,18 @@ export const makeEncoded: (encoded: Encoded) => Effect.Effect<
           })
         ),
         Effect.flatMap((result) => {
-          if (result._tag === "Success" || result.lastReceivedReply === undefined) {
+          if (result._tag === "Success" || Option.isNone(result.lastReceivedReply)) {
             return Effect.succeed(result as SaveResult<any>)
           }
           const duplicate = result
           const schema = Reply.Reply(message.rpc)
-          return Schema.decodeEffect(schema)(result.lastReceivedReply).pipe(
+          return Schema.decodeEffect(schema)(result.lastReceivedReply.value).pipe(
             Effect.provideServices(message.services),
             MalformedMessage.refail,
             Effect.map((reply) =>
               SaveResult.Duplicate({
                 originalId: duplicate.originalId,
-                lastReceivedReply: reply
+                lastReceivedReply: Option.some(reply)
               })
             )
           )
@@ -546,7 +545,7 @@ export const makeEncoded: (encoded: Encoded) => Effect.Effect<
   const decodeMessages = (
     envelopes: Array<{
       readonly envelope: Envelope.Encoded
-      readonly lastSentReply: Reply.Encoded | undefined
+      readonly lastSentReply: Option.Option<Reply.Encoded>
     }>
   ) => {
     const messages: Array<Message.Incoming<any>> = []
@@ -655,7 +654,7 @@ export const noop: MessageStorage["Service"] = Effect.runSync(make({
   clearReplies: () => Effect.void,
   repliesFor: () => Effect.succeed([]),
   repliesForUnfiltered: () => Effect.succeed([]),
-  requestIdForPrimaryKey: () => Effect.undefined,
+  requestIdForPrimaryKey: () => Effect.succeedNone,
   unprocessedMessages: () => Effect.succeed([]),
   unprocessedMessagesById: () => Effect.succeed([]),
   resetAddress: () => Effect.void,
@@ -693,7 +692,7 @@ export class MemoryDriver extends ServiceMap.Service<MemoryDriver>()("effect/clu
     const unprocessedWith = (predicate: Predicate<Envelope.Encoded>) => {
       const messages: Array<{
         readonly envelope: Envelope.Encoded
-        readonly lastSentReply: Reply.Encoded | undefined
+        readonly lastSentReply: Option.Option<Reply.Encoded>
       }> = []
       const now = clock.currentTimeMillisUnsafe()
       for (const envelope of unprocessed) {
@@ -707,12 +706,12 @@ export class MemoryDriver extends ServiceMap.Service<MemoryDriver>()("effect/clu
           }
           messages.push({
             envelope,
-            lastSentReply: entry?.replies[entry.replies.length - 1]
+            lastSentReply: Option.fromNullishOr(entry?.replies[entry.replies.length - 1])
           })
         } else {
           messages.push({
             envelope,
-            lastSentReply: undefined
+            lastSentReply: Option.none()
           })
         }
       }
@@ -751,9 +750,11 @@ export class MemoryDriver extends ServiceMap.Service<MemoryDriver>()("effect/clu
           if (existing) {
             return SaveResultEncoded.Duplicate({
               originalId: Snowflake.Snowflake(existing.envelope.requestId),
-              lastReceivedReply: existing.replies.length === 1 && existing.replies[0]._tag === "WithExit"
-                ? existing.replies[0]
-                : existing.lastReceivedChunk
+              lastReceivedReply: Option.fromNullishOr(
+                existing.replies.length === 1 && existing.replies[0]._tag === "WithExit"
+                  ? existing.replies[0]
+                  : existing.lastReceivedChunk
+              )
             })
           }
           if (envelope._tag === "Request") {
@@ -797,7 +798,7 @@ export class MemoryDriver extends ServiceMap.Service<MemoryDriver>()("effect/clu
       requestIdForPrimaryKey: (primaryKey) =>
         Effect.sync(() => {
           const entry = requestsByPrimaryKey.get(primaryKey)
-          return UndefinedOr.map(entry?.envelope.requestId, Snowflake.Snowflake)
+          return Option.map(Option.fromNullishOr(entry?.envelope.requestId), Snowflake.Snowflake)
         }),
       repliesFor: (requestIds) => Effect.sync(() => repliesFor(requestIds)),
       repliesForUnfiltered: (requestIds) =>
@@ -808,7 +809,7 @@ export class MemoryDriver extends ServiceMap.Service<MemoryDriver>()("effect/clu
           const now = clock.currentTimeMillisUnsafe()
           const messages = Arr.empty<{
             envelope: Envelope.Encoded
-            lastSentReply: Reply.Encoded | undefined
+            lastSentReply: Option.Option<Reply.Encoded>
           }>()
           for (let index = 0; index < journal.length; index++) {
             const envelope = journal[index]
@@ -823,12 +824,12 @@ export class MemoryDriver extends ServiceMap.Service<MemoryDriver>()("effect/clu
               }
               messages.push({
                 envelope,
-                lastSentReply: entry.replies[entry.replies.length - 1]
+                lastSentReply: Option.fromNullishOr(entry.replies[entry.replies.length - 1])
               })
             } else {
               messages.push({
                 envelope,
-                lastSentReply: undefined
+                lastSentReply: Option.none()
               })
               unprocessed.delete(envelope)
             }
@@ -906,11 +907,11 @@ export const layerMemory: Layer.Layer<
 const EnvelopeWithReply: Schema.Struct<
   {
     readonly envelope: Schema.Decoder<Envelope.PartialRequest | Envelope.AckChunk | Envelope.Interrupt>
-    readonly lastSentReply: Schema.UndefinedOr<Schema.Codec<Reply.Encoded>>
+    readonly lastSentReply: Schema.Option<Schema.Codec<Reply.Encoded>>
   }
 > = Schema.Struct({
   envelope: Schema.toCodecJson(Envelope.Partial),
-  lastSentReply: Schema.UndefinedOr(Reply.Encoded)
+  lastSentReply: Schema.Option(Reply.Encoded)
 })
 
 const decodeEnvelopeWithReply = Schema.decodeEffect(EnvelopeWithReply)

package/src/unstable/cluster/Reply.ts

@@ -352,12 +352,15 @@ export const serialize = <R extends Rpc.Any>(
  */
 export const serializeLastReceived = <R extends Rpc.Any>(
   self: OutgoingRequest<R>
-): Effect.Effect<Encoded | undefined, MalformedMessage> => {
-  if (self.lastReceivedReply === undefined) {
-    return Effect.undefined
+): Effect.Effect<Option.Option<Encoded>, MalformedMessage> => {
+  const lastReceivedReply = self.lastReceivedReply
+  if (lastReceivedReply._tag === "None") {
+    return Effect.succeedNone
   }
   const schema = Reply(self.rpc)
   return MalformedMessage.refail(
-    Effect.provideServices(Schema.encodeEffect(schema)(self.lastReceivedReply), self.services)
+    Effect.provideServices(Schema.encodeEffect(schema)(lastReceivedReply.value), self.services)
+  ).pipe(
+    Effect.map(Option.some)
   )
 }

package/src/unstable/cluster/RunnerServer.ts

@@ -6,6 +6,7 @@ import type * as Exit from "../../Exit.ts"
 import * as Fiber from "../../Fiber.ts"
 import { constant } from "../../Function.ts"
 import * as Layer from "../../Layer.ts"
+import * as Option from "../../Option.ts"
 import * as Queue from "../../Queue.ts"
 import * as RpcServer from "../rpc/RpcServer.ts"
 import type * as ClusterError from "./ClusterError.ts"
@@ -36,23 +37,19 @@ export const layerHandlers = Runners.Rpcs.toLayer(Effect.gen(function*() {
           ? new Message.IncomingRequest({
             envelope,
             respond: constVoid,
-            lastSentReply: undefined
+            lastSentReply: Option.none()
           })
           : new Message.IncomingEnvelope({ envelope })
       ),
     Effect: ({ persisted, request }) => {
-      let replyEncoded:
-        | Effect.Effect<
-          Reply.Encoded,
-          ClusterError.EntityNotAssignedToRunner
-        >
-        | undefined = undefined
+      let replyEncoded: Option.Option<Effect.Effect<Reply.Encoded, ClusterError.EntityNotAssignedToRunner>> = Option
+        .none()
       let resume = (reply: Effect.Effect<Reply.Encoded, ClusterError.EntityNotAssignedToRunner>) => {
-        replyEncoded = reply
+        replyEncoded = Option.some(reply)
       }
       const message = new Message.IncomingRequest({
         envelope: request,
-        lastSentReply: undefined,
+        lastSentReply: Option.none(),
         respond(reply) {
           resume(Effect.orDie(Reply.serialize(reply)))
           return Effect.void
@@ -89,8 +86,8 @@ export const layerHandlers = Runners.Rpcs.toLayer(Effect.gen(function*() {
       return Effect.andThen(
         sharding.send(message),
         Effect.callback<Reply.Encoded, ClusterError.EntityNotAssignedToRunner>((resume_) => {
-          if (replyEncoded) {
-            resume_(replyEncoded)
+          if (Option.isSome(replyEncoded)) {
+            resume_(replyEncoded.value)
           } else {
             resume = resume_
           }
@@ -103,7 +100,7 @@ export const layerHandlers = Runners.Rpcs.toLayer(Effect.gen(function*() {
         (queue) => {
           const message = new Message.IncomingRequest({
             envelope: request,
-            lastSentReply: undefined,
+            lastSentReply: Option.none(),
             respond(reply) {
               return Effect.flatMap(Reply.serialize(reply), (reply) => {
                 Queue.offerUnsafe(queue, reply)
@@ -191,6 +188,6 @@ export const layerClientOnly: Layer.Layer<
   Layer.provide(RunnerHealth.layerNoop),
   Layer.updateService(ShardingConfig, (config) => ({
     ...config,
-    runnerAddress: undefined
+    runnerAddress: Option.none()
   }))
 )

package/src/unstable/cluster/Runners.ts

@@ -5,6 +5,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 Option from "../../Option.ts"
 import * as Queue from "../../Queue.ts"
 import * as RcMap from "../../RcMap.ts"
 import * as Schema from "../../Schema.ts"
@@ -80,7 +81,7 @@ export class Runners extends ServiceMap.Service<Runners, {
    */
   readonly notify: <R extends Rpc.Any>(
     options: {
-      readonly address: RunnerAddress | undefined
+      readonly address: Option.Option<RunnerAddress>
       readonly message: Message.Outgoing<R>
       readonly discard: boolean
     }
@@ -166,8 +167,8 @@ export const make: (options: Omit<Runners["Service"], "sendLocal" | "notifyLocal
         Duplicate: ({ lastReceivedReply, originalId }) => {
           // If the last received reply is an exit, we can just return it
           // as the response.
-          if (lastReceivedReply && lastReceivedReply._tag === "WithExit") {
-            return message.respond(lastReceivedReply.withRequestId(message.envelope.requestId))
+          if (Option.isSome(lastReceivedReply) && lastReceivedReply.value._tag === "WithExit") {
+            return message.respond(lastReceivedReply.value.withRequestId(message.envelope.requestId))
           }
           requestIdRewrites.set(message.envelope.requestId, originalId)
           return afterPersist(
@@ -341,10 +342,10 @@ export const make: (options: Omit<Runners["Service"], "sendLocal" | "notifyLocal
       return notifyWith(message, (message, duplicate) => {
         if (discard || message._tag === "OutgoingEnvelope") {
           return options.notify(options_)
-        } else if (!duplicate && options_.address) {
+        } else if (!duplicate && Option.isSome(options_.address)) {
           return Effect.catch(
             options.send({
-              address: options_.address,
+              address: options_.address.value,
               message
             }),
             (_) => replyFromStorage(message)
@@ -584,11 +585,11 @@ export const makeRpc: Effect.Effect<
       })
     },
     notify({ address, message }) {
-      if (!address) {
+      if (Option.isNone(address)) {
         return Effect.void
       }
       const envelope = message.envelope
-      return RcMap.get(clients, address).pipe(
+      return RcMap.get(clients, address.value).pipe(
         Effect.flatMap((client) => client.Notify({ envelope })),
         Effect.scoped,
         Effect.ignore