@livestore/utils 0.4.0 → 0.5.0-dev.0

package/src/effect/Effect.ts

@@ -1,22 +1,20 @@
-import * as OtelTracer from '@effect/opentelemetry/Tracer'
+import * as OtelTracer from '@effect/opentelemetry/OtelTracer'
 import {
   Cause,
+  Console,
   type Context,
   Deferred,
   Duration,
   Effect,
+  Function,
   Fiber,
   pipe,
+  Predicate,
   Scope,
   type Stream,
 } from 'effect'
-import type { UnknownException } from 'effect/Cause'
-import { log } from 'effect/Console'
-import { dual, type LazyArg } from 'effect/Function'
-import type { Predicate, Refinement } from 'effect/Predicate'
 
-import { isDevEnv, isPromise, objectToString } from '../mod.ts'
-import { UnknownError } from './Error.ts'
+import { isDevEnv, objectToString } from '../misc.ts'
 
 export * from 'effect/Effect'
 export { spanEvent } from './spanEvent.ts'
@@ -36,16 +34,14 @@ export { spanEvent } from './spanEvent.ts'
 //     console.error(message, ...rest)
 //   })
 
-/** Same as `Effect.scopeWith` but with a `CloseableScope` instead of a `Scope`. */
+/** Same as `Effect.scopeWith` but with a closeable `Scope`. */
 export const scopeWithCloseable = <R, E, A>(
-  fn: (scope: Scope.CloseableScope) => Effect.Effect<A, E, R | Scope.Scope>,
+  fn: (scope: Scope.Closeable) => Effect.Effect<A, E, R | Scope.Scope>,
 ): Effect.Effect<A, E, R | Scope.Scope> =>
   Effect.gen(function* () {
-    // const parentScope = yield* Scope.Scope
-    // const scope = yield* Scope.fork(parentScope, ExecutionStrategy.sequential)
     const scope = yield* Scope.make()
     yield* Effect.addFinalizer((exit) => Scope.close(scope, exit))
-    return yield* fn(scope).pipe(Scope.extend(scope))
+    return yield* fn(scope).pipe(Scope.provide(scope))
   })
 
 export type SyncOrPromiseOrEffect<TResult, TError = never, TContext = never> =
@@ -53,22 +49,43 @@ export type SyncOrPromiseOrEffect<TResult, TError = never, TContext = never> =
   | Promise<TResult>
   | Effect.Effect<TResult, TError, TContext>
 
-export const tryAll = <Res>(
-  fn: () => Res,
-): Res extends Effect.Effect<infer A, infer E>
-  ? Effect.Effect<A, E | UnknownException>
-  : Res extends Promise<infer A>
-    ? Effect.Effect<A, UnknownException>
-    : Effect.Effect<Res, UnknownException> =>
-  Effect.try(() => fn()).pipe(
-    Effect.andThen((fnRes) =>
-      Effect.isEffect(fnRes) === true
-        ? (fnRes as any as Effect.Effect<any>)
-        : isPromise(fnRes) === true
-          ? Effect.promise(() => fnRes)
-          : Effect.succeed(fnRes),
-    ),
-  ) as any
+/**
+ * Creates an Effect from an operation that may return a value, a Promise-like value, or another Effect.
+ *
+ * @remarks
+ * Synchronous values succeed directly, and Promise-like values are awaited. Synchronous throws and Promise rejections
+ * are mapped to `Cause.UnknownError`. When the operation returns an Effect, that Effect is executed rather than
+ * produced as a successful value; its failures and service requirements are preserved.
+ *
+ * @param operation - A callback that may return a synchronous value, a Promise-like value, or an Effect
+ * @returns An Effect representing the normalized outcome of the operation
+ */
+export function trySyncOrPromiseOrEffect<Return>(
+  operation: () => Return,
+): Effect.Effect<
+  Return extends Effect.Effect<infer A, infer _E, infer _R> ? A : Return extends PromiseLike<infer A> ? A : Return,
+  Cause.UnknownError | (Return extends Effect.Effect<infer _A, infer E, infer _R> ? E : never),
+  Return extends Effect.Effect<infer _A, infer _E, infer R> ? R : never
+>
+export function trySyncOrPromiseOrEffect(operation: () => unknown): Effect.Effect<unknown, unknown, unknown> {
+  return Effect.try({
+    try: () => {
+      const result = operation()
+
+      if (Effect.isEffect(result) === true) {
+        // @effect-diagnostics-next-line anyUnknownInErrorContext:off -- dynamic implementation boundary; the public overload preserves exact Effect error and requirement channels
+        return result
+      }
+
+      if (Predicate.isPromiseLike(result) === true) {
+        return Effect.tryPromise(() => result)
+      }
+
+      return Effect.succeed(result)
+    },
+    catch: (cause) => new Cause.UnknownError(cause),
+  }).pipe(Effect.flatten)
+}
 
 export const acquireReleaseLog = (label: string) =>
   Effect.acquireRelease(Effect.log(`${label} acquire`), (_, ex) => Effect.log(`${label} release`, ex))
@@ -85,16 +102,11 @@ export const logBefore =
 
 /** Logs both on errors and defects */
 export const tapCauseLogPretty = <R, E, A>(eff: Effect.Effect<A, E, R>): Effect.Effect<A, E, R> =>
-  Effect.tapErrorCause(eff, (cause) =>
+  Effect.tapCause(eff, (cause) =>
     Effect.gen(function* () {
-      if (Cause.isInterruptedOnly(cause) === true) {
-        // console.log('interrupted', Cause.pretty(err), err)
-        return
-      }
+      if (Cause.hasInterruptsOnly(cause) === true) return
 
-      const span = yield* OtelTracer.currentOtelSpan.pipe(
-        Effect.catchTag('NoSuchElementException', (_) => Effect.succeed(undefined)),
-      )
+      const span = yield* OtelTracer.currentOtelSpan.pipe(Effect.catchTag('NoSuchElementError', (_) => Effect.void))
 
       const firstErrLine = cause.toString().split('\n')[0]
       yield* Effect.logError(firstErrLine, cause).pipe((_) =>
@@ -121,7 +133,7 @@ export const dieDebugger = (msg: string, ...args: ReadonlyArray<unknown>): Effec
       debugger
       void args // Keeps the variable in scope so it's inspectable when the debugger pauses
     }
-    return Effect.dieMessage(msg)
+    return Effect.die(new Error(msg))
   })
 
 /**
@@ -136,27 +148,27 @@ export const orDieDebugger = <A, E, R>(self: Effect.Effect<A, E, R>): Effect.Eff
   Effect.matchEffect(self, {
     onFailure: (error) =>
       // Keep the debugger hook so that `debugger` runs only when the wrapped effect actually fails, not while building the wrapper.
-      Effect.dieSync(() => {
+      Effect.suspend(() => {
         if (isDevEnv() === true) {
           // oxlint-disable-next-line eslint(no-debugger) -- intentional breakpoint for impossible states during development
           debugger
         }
-        return error
+        return Effect.die(error)
       }),
     onSuccess: Effect.succeed,
   })
 
 export const ignoreIf: {
   <E, EB extends E>(
-    refinement: Refinement<NoInfer<E>, EB>,
+    refinement: Predicate.Refinement<NoInfer<E>, EB>,
   ): <A, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<void, Exclude<E, EB>, R>
-  <E>(predicate: Predicate<NoInfer<E>>): <A, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<void, E, R>
+  <E>(predicate: Predicate.Predicate<NoInfer<E>>): <A, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<void, E, R>
   <A, E, R, EB extends E>(
     self: Effect.Effect<A, E, R>,
-    refinement: Refinement<E, EB>,
+    refinement: Predicate.Refinement<E, EB>,
   ): Effect.Effect<void, Exclude<E, EB>, R>
-  <A, E, R>(self: Effect.Effect<A, E, R>, predicate: Predicate<E>): Effect.Effect<void, E, R>
-} = dual(2, <A, E, R>(self: Effect.Effect<A, E, R>, predicate: Predicate<E>) =>
+  <A, E, R>(self: Effect.Effect<A, E, R>, predicate: Predicate.Predicate<E>): Effect.Effect<void, E, R>
+} = Function.dual(2, <A, E, R>(self: Effect.Effect<A, E, R>, predicate: Predicate.Predicate<E>) =>
   self.pipe(Effect.catchIf(predicate, () => Effect.void)),
 )
 
@@ -167,9 +179,9 @@ export const eventListener = <TEvent = unknown>(
   options?: { once?: boolean },
 ) =>
   Effect.gen(function* () {
-    const runtime = yield* Effect.runtime()
+    const services = yield* Effect.context()
 
-    const handlerFn = (event: TEvent) => handler(event).pipe(Effect.provide(runtime), Effect.runFork)
+    const handlerFn = (event: TEvent) => handler(event).pipe(Effect.runForkWith(services))
 
     target.addEventListener(type, handlerFn, { once: options?.once ?? false })
 
@@ -177,10 +189,10 @@ export const eventListener = <TEvent = unknown>(
   })
 
 export const logWarnIfTakesLongerThan =
-  ({ label, duration }: { label: string; duration: Duration.DurationInput }) =>
+  ({ label, duration }: { label: string; duration: Duration.Input }) =>
   <R, E, A>(eff: Effect.Effect<A, E, R>): Effect.Effect<A, E, R> =>
     Effect.gen(function* () {
-      const runtime = yield* Effect.runtime()
+      const services = yield* Effect.context()
 
       let tookLongerThanTimer = false
 
@@ -190,8 +202,7 @@ export const logWarnIfTakesLongerThan =
           // TODO include span info
           return Effect.logWarning(`${label}: Took longer than ${objectToString(duration)}ms`)
         }),
-        Effect.provide(runtime),
-        Effect.runFork,
+        Effect.runForkWith(services),
       )
 
       const start = Date.now()
@@ -228,7 +239,7 @@ export const logDuration =
       const start = Date.now()
       const res = yield* eff
       const end = Date.now()
-      yield* Effect.log(`${label}: ${Duration.format(end - start)}`)
+      yield* Effect.log(`${label}: ${Duration.format(Duration.millis(end - start))}`)
       return res
     })
 
@@ -240,7 +251,7 @@ export const tapSync =
 export const debugLogEnv = (msg?: string): Effect.Effect<Context.Context<never>> =>
   pipe(
     Effect.context<never>(),
-    Effect.tap((env) => log(msg ?? 'debugLogEnv', env)),
+    Effect.tap((env) => Console.log(msg ?? 'debugLogEnv', env)),
   )
 
 /**
@@ -250,25 +261,26 @@ export const debugLogEnv = (msg?: string): Effect.Effect<Context.Context<never>>
  *
  * This function allows you to enforce a time limit on the execution of an
  * effect. If the effect does not complete within the given duration, it dies
- * with a {@link Cause.TimeoutException} as an unchecked defect. Unlike
- * {@link Effect.timeout}, which adds `TimeoutException` to the error channel,
+ * with a {@link Cause.TimeoutError} as an unchecked defect. Unlike
+ * {@link Effect.timeout}, which adds `TimeoutError` to the error channel,
  * this function keeps the error channel unchanged by treating the timeout as
  * a defect.
  *
  * The returned effect will either:
  * - Succeed with the original effect's result if it completes within the
  *   specified duration.
- * - Die with a {@link Cause.TimeoutException} defect if the time limit is exceeded.
+ * - Die with a {@link Cause.TimeoutError} defect if the time limit is exceeded.
  *
  * @see {@link timeoutOrDieMessage} for a version with a custom message.
- * @see {@link Effect.timeout} for a version that raises a `TimeoutException` as a typed error.
- * @see {@link Effect.timeoutFailCause} for a version that raises a custom defect.
+ * @see {@link Effect.timeout} for a version that raises a `TimeoutError` as a typed error.
+ * @see {@link Effect.timeoutOrElse} for a version with a custom timeout branch.
  */
-export const timeoutOrDie = (duration: Duration.DurationInput) =>
+export const timeoutOrDie =
+  (duration: Duration.Input) =>
   <A, E, R>(self: Effect.Effect<A, E, R>): Effect.Effect<A, E, R> =>
-    Effect.timeoutFailCause(self, {
+    Effect.timeoutOrElse(self, {
       duration,
-      onTimeout: () => Cause.die(new Cause.TimeoutException())
+      orElse: () => Effect.die(new Cause.TimeoutError()),
     })
 
 /**
@@ -278,25 +290,26 @@ export const timeoutOrDie = (duration: Duration.DurationInput) =>
  * @remarks
  *
  * This function behaves like {@link timeoutOrDie}, but allows you to provide
- * a custom message for the {@link Cause.TimeoutException} defect. This is useful
+ * a custom message for the {@link Cause.TimeoutError} defect. This is useful
  * for adding context about which operation timed out, making it easier to
  * diagnose issues in logs or error reports.
  *
  * The returned effect will either:
  * - Succeed with the original effect's result if it completes within the
  *   specified duration.
- * - Die with a {@link Cause.TimeoutException} defect containing the provided
+ * - Die with a {@link Cause.TimeoutError} defect containing the provided
  *   message if the time limit is exceeded.
  *
  * @see {@link timeoutOrDie} for a version without a custom message.
- * @see {@link Effect.timeout} for a version that raises a `TimeoutException` as a typed error.
- * @see {@link Effect.timeoutFailCause} for a version that raises a custom defect.
+ * @see {@link Effect.timeout} for a version that raises a `TimeoutError` as a typed error.
+ * @see {@link Effect.timeoutOrElse} for a version with a custom timeout branch.
  */
-export const timeoutOrDieMessage = (duration: Duration.DurationInput, message: string) =>
+export const timeoutOrDieMessage =
+  (duration: Duration.Input, message: string) =>
   <A, E, R>(self: Effect.Effect<A, E, R>): Effect.Effect<A, E, R> =>
-    Effect.timeoutFailCause(self, {
+    Effect.timeoutOrElse(self, {
       duration,
-      onTimeout: () => Cause.die(new Cause.TimeoutException(message))
+      orElse: () => Effect.die(new Cause.TimeoutError(message)),
     })
 
 export const toForkedDeferred = <R, E, A>(
@@ -328,16 +341,16 @@ export const withPerformanceMeasure =
     )
 
 const getSpanTrace = () => {
-  const fiberOption = Fiber.getCurrentFiber()
-  if (fiberOption._tag === 'None' || fiberOption.value.currentSpan === undefined) {
+  const fiber = Fiber.getCurrent()
+  if (fiber === undefined || fiber.currentSpan === undefined) {
     return 'No current fiber'
   }
 
   return ''
   // const msg = Effect.runSync(
   //   Effect.fail({ message: '' }).pipe(
-  //     Effect.withParentSpan(fiberOption.value.currentSpan),
-  //     Effect.catchAllCause((cause) => Effect.succeed(cause.toString())),
+  //     Effect.withParentSpan(fiber.currentSpan),
+  //     Effect.catchCause((cause) => Effect.succeed(cause.toString())),
   //   ),
   // )
 

package/src/effect/Logger.ts

@@ -1,49 +1 @@
-import { Cause, HashMap, Logger, LogLevel } from 'effect'
-
 export * from 'effect/Logger'
-
-const defaultDateFormat = (date: Date): string =>
-  `${date.getHours().toString().padStart(2, '0')}:${date.getMinutes().toString().padStart(2, '0')}:${date
-    .getSeconds()
-    .toString()
-    .padStart(2, '0')}.${date.getMilliseconds().toString().padStart(3, '0')}`
-
-export const prettyWithThread = (threadName: string, options: { mode?: 'tty' | 'browser' } = {}) =>
-  Logger.replace(
-    Logger.defaultLogger,
-    Logger.prettyLogger({
-      formatDate: (date) => `${defaultDateFormat(date)} ${threadName}`,
-      mode: options.mode,
-    }),
-  )
-
-export const consoleLogger = (threadName: string) =>
-  Logger.make(({ message, annotations, date, logLevel, cause }) => {
-    const isCloudflareWorker = typeof navigator !== 'undefined' && navigator.userAgent === 'Cloudflare-Workers'
-    const consoleFn =
-      logLevel === LogLevel.Debug
-        ? // Cloudflare Workers doesn't support console.debug 🤷
-          isCloudflareWorker === true
-          ? console.log
-          : console.debug
-        : logLevel === LogLevel.Info
-          ? console.info
-          : logLevel === LogLevel.Warning
-            ? console.warn
-            : console.error
-
-    const annotationsObj = Object.fromEntries(HashMap.entries(annotations))
-
-    const messages = Array.isArray(message) === true ? message : [message]
-    if (Cause.isEmpty(cause) === false) {
-      messages.push(Cause.pretty(cause, { renderErrorCause: true }))
-    }
-
-    if (Object.keys(annotationsObj).length > 0) {
-      messages.push(annotationsObj)
-    }
-
-    consoleFn(`[${defaultDateFormat(date)} ${threadName}]`, ...messages)
-  })
-
-export const consoleWithThread = (threadName: string) => Logger.replace(Logger.defaultLogger, consoleLogger(threadName))

package/src/effect/OtelTracer.ts

@@ -1,11 +1,10 @@
-import { makeExternalSpan } from '@effect/opentelemetry/Tracer'
+import { makeExternalSpan } from '@effect/opentelemetry/OtelTracer'
 import type { Link as OtelSpanLink } from '@opentelemetry/api'
 import type { SpanLink as EffectSpanLink } from 'effect/Tracer'
 
-export * from '@effect/opentelemetry/Tracer'
+export * from '@effect/opentelemetry/OtelTracer'
 
 export const makeSpanLink = (otelSpanLink: OtelSpanLink): EffectSpanLink => ({
-  _tag: 'SpanLink',
   span: makeExternalSpan(otelSpanLink.context),
   attributes: otelSpanLink.attributes ?? {},
 })

package/src/effect/RpcClient.ts

@@ -1,11 +1,10 @@
-export * from '@effect/rpc/RpcClient'
+export * from 'effect/unstable/rpc/RpcClient'
 
-import { Socket } from '@effect/platform'
-import { RpcClient, RpcClientError, RpcSerialization } from '@effect/rpc'
-import { Protocol } from '@effect/rpc/RpcClient'
-import { constPing, type FromServerEncoded } from '@effect/rpc/RpcMessage'
-import { Cause, Deferred, Effect, Layer, Option, Schedule, type Scope } from 'effect'
-import { constVoid, identity } from 'effect/Function'
+import { Cause, Deferred, Effect, Function, Latch, Layer, References, Result, Schedule, type Scope } from 'effect'
+import { RpcClient, RpcClientError, RpcSerialization } from 'effect/unstable/rpc'
+import { Protocol } from 'effect/unstable/rpc/RpcClient'
+import { constPing, type FromServerEncoded } from 'effect/unstable/rpc/RpcMessage'
+import { Socket } from 'effect/unstable/socket'
 
 import * as SubscriptionRef from './SubscriptionRef.ts'
 
@@ -20,7 +19,7 @@ export const layerProtocolSocketWithIsConnected = (options: {
   readonly isConnected: SubscriptionRef.SubscriptionRef<boolean>
   readonly pingSchedule?: Schedule.Schedule<unknown> | undefined
 }): Layer.Layer<Protocol, never, RpcSerialization.RpcSerialization | Socket.Socket> =>
-  Layer.scoped(Protocol, makeProtocolSocketWithIsConnected(options))
+  Layer.effect(Protocol, makeProtocolSocketWithIsConnected(options))
 
 export const makeProtocolSocketWithIsConnected = (options: {
   readonly url: string
@@ -29,16 +28,22 @@ export const makeProtocolSocketWithIsConnected = (options: {
   readonly isConnected: SubscriptionRef.SubscriptionRef<boolean>
   // CHANGED: add ping schedule
   readonly pingSchedule?: Schedule.Schedule<unknown> | undefined
-}): Effect.Effect<Protocol['Type'], never, Scope.Scope | RpcSerialization.RpcSerialization | Socket.Socket> =>
+}): Effect.Effect<Protocol['Service'], never, Scope.Scope | RpcSerialization.RpcSerialization | Socket.Socket> =>
   Protocol.make(
-    Effect.fnUntraced(function* (writeResponse) {
+    Effect.fnUntraced(function* (writeResponse, clientIds) {
       const socket = yield* Socket.Socket
       const serialization = yield* RpcSerialization.RpcSerialization
+      const requestClientMap = new Map<string | number, number>()
 
       const write = yield* socket.writer
-      const parser = serialization.unsafeMake()
+      let parser = serialization.makeUnsafe()
 
       const pinger = yield* makePinger(write(parser.encode(constPing)!), options?.pingSchedule)
+      let currentError: RpcClientError.RpcClientError | undefined
+
+      const markConnected = SubscriptionRef.set(options.isConnected, true)
+      const broadcast = (response: FromServerEncoded) =>
+        Effect.forEach(clientIds, (clientId) => writeResponse(clientId, response))
 
       yield* Effect.suspend(() => {
         // We rely on the heartbeat watchdog while streaming arbitrarily long payloads.
@@ -46,7 +51,8 @@ export const makeProtocolSocketWithIsConnected = (options: {
         // don't contain explicit `Pong` messages don't trigger the open-timeout defect.
         // (The actual pong handler still calls `onPong()` to resolve manual pings.)
         // CHANGED: don't reset parser on every message
-        // parser = serialization.unsafeMake()
+        // parser = serialization.makeUnsafe()
+        currentError = undefined
         pinger.reset()
         return socket
           .runRaw((message) => {
@@ -63,94 +69,107 @@ export const makeProtocolSocketWithIsConnected = (options: {
                   pinger.reset()
                   if (response._tag === 'Pong') {
                     pinger.onPong()
+                    return markConnected
+                  }
+                  if ('requestId' in response) {
+                    const clientId = requestClientMap.get(response.requestId)
+                    if (clientId !== undefined) {
+                      if (response._tag === 'Exit') {
+                        requestClientMap.delete(response.requestId)
+                      }
+                      return markConnected.pipe(Effect.andThen(writeResponse(clientId, response)))
+                    }
                   }
-                  return writeResponse(response).pipe(
-                    // CHANGED: set isConnected to true on pong
-                    Effect.tap(
-                      Effect.fn(function* () {
-                        if (options?.isConnected !== undefined) {
-                          yield* SubscriptionRef.set(options.isConnected, true)
-                        }
-                      }),
-                    ),
-                  )
+                  return markConnected.pipe(Effect.andThen(broadcast(response)))
                 },
-                step: constVoid,
+                step: Function.constVoid,
               })
             } catch (defect) {
-              return writeResponse({
+              return broadcast({
                 _tag: 'ClientProtocolError',
                 error: new RpcClientError.RpcClientError({
-                  reason: 'Protocol',
-                  message: 'Error decoding message',
-                  cause: Cause.fail(defect),
+                  reason: new RpcClientError.RpcClientDefect({
+                    message: 'Error decoding message',
+                    cause: defect,
+                  }),
                 }),
               })
             }
           })
           .pipe(
             Effect.raceFirst(
-              Effect.zipRight(
-                pinger.timeout,
+              Effect.flatMap(pinger.timeout, () =>
                 Effect.fail(
-                  new Socket.SocketGenericError({
-                    reason: 'OpenTimeout',
-                    cause: new Error('ping timeout'),
+                  new Socket.SocketError({
+                    reason: new Socket.SocketOpenError({
+                      kind: 'Timeout',
+                      cause: new Error('ping timeout'),
+                    }),
                   }),
                 ),
               ),
             ),
           )
       }).pipe(
-        Effect.zipRight(
+        Effect.flatMap(() =>
           Effect.fail(
-            new Socket.SocketCloseError({
-              reason: 'Close',
-              code: 1000,
-              closeReason: 'Closing connection',
+            new Socket.SocketError({
+              reason: new Socket.SocketCloseError({
+                code: 1000,
+                closeReason: 'Closing connection',
+              }),
             }),
           ),
         ),
-        Effect.tapErrorCause(
+        Effect.tapCause(
           Effect.fn(function* (cause) {
             // CHANGED: set isConnected to false on error
-            if (options?.isConnected !== undefined) {
-              yield* SubscriptionRef.set(options.isConnected, false)
-            }
+            yield* SubscriptionRef.set(options.isConnected, false)
 
-            const error = Cause.failureOption(cause)
+            const error = Cause.findError(cause)
             if (
               options?.retryTransientErrors !== undefined &&
-              Option.isSome(error) === true &&
-              (error.value.reason === 'Open' || error.value.reason === 'OpenTimeout')
+              Result.isSuccess(error) === true &&
+              error.success.reason._tag === 'SocketOpenError'
             ) {
               return
             }
             // yield* Effect.logError('Error in socket', cause)
-            return yield* writeResponse({
+            currentError = new RpcClientError.RpcClientError({
+              reason:
+                Result.isSuccess(error) === true
+                  ? error.success.reason
+                  : new RpcClientError.RpcClientDefect({
+                      message: 'Unknown socket error',
+                      cause: Cause.squash(cause),
+                    }),
+            })
+            return yield* broadcast({
               _tag: 'ClientProtocolError',
-              error: new RpcClientError.RpcClientError({
-                reason: 'Protocol',
-                message: 'Error in socket',
-                cause: Cause.squash(cause),
-              }),
+              error: currentError,
             })
           }),
         ),
         // CHANGED: make configurable via schedule
-        options?.retryTransientErrors !== undefined ? Effect.retry(options.retryTransientErrors) : identity,
+        options?.retryTransientErrors !== undefined ? Effect.retry(options.retryTransientErrors) : Function.identity,
         Effect.annotateLogs({
           module: 'RpcClient',
           method: 'makeProtocolSocket',
         }),
         Effect.interruptible,
         Effect.ignore, // Errors are already handled
-        Effect.provide(Layer.setUnhandledErrorLogLevel(Option.none())),
+        Effect.provideService(References.UnhandledLogLevel, undefined),
         Effect.forkScoped,
       )
 
       return {
-        send: (request) => {
+        send: (clientId, request) => {
+          if (currentError !== undefined) {
+            return Effect.fail(currentError)
+          }
+          if (request._tag === 'Request') {
+            requestClientMap.set(request.id, clientId)
+          }
           const encoded = parser.encode(request)
           if (encoded === undefined) return Effect.void
 
@@ -165,33 +184,33 @@ export const makeProtocolSocketWithIsConnected = (options: {
 
 export const SocketPinger = Effect.map(RpcClient.Protocol, (protocol) => (protocol as any).pinger as SocketPinger)
 
-export type SocketPinger = Effect.Effect.Success<ReturnType<typeof makePinger>>
+export type SocketPinger = Effect.Success<ReturnType<typeof makePinger>>
 
 const makePinger = Effect.fnUntraced(function* <A, E, R>(
   writePing: Effect.Effect<A, E, R>,
-  pingSchedule: Schedule.Schedule<unknown> = Schedule.spaced(10000).pipe(Schedule.addDelay(() => 5000)),
+  pingSchedule: Schedule.Schedule<unknown> = Schedule.spaced(10000).pipe(Schedule.addDelay(() => Effect.succeed(5000))),
 ) {
   // CHANGED: add manual ping deferreds
   const manualPingDeferreds = new Set<Deferred.Deferred<void>>()
 
   let recievedPong = true
-  const latch = Effect.unsafeMakeLatch()
+  const latch = Latch.makeUnsafe()
   const reset = () => {
     recievedPong = true
-    latch.unsafeClose()
+    latch.closeUnsafe()
   }
   const onPong = () => {
     recievedPong = true
     // CHANGED: mark all manual ping deferreds as done
     for (const deferred of manualPingDeferreds) {
-      Deferred.unsafeDone(deferred, Effect.void)
+      Deferred.doneUnsafe(deferred, Effect.void)
     }
   }
   yield* Effect.suspend(() => {
     // Starting new ping
-    if (recievedPong === false) return latch.open
+    if (recievedPong === false) return Effect.asVoid(latch.open)
     recievedPong = false
-    return writePing
+    return Effect.asVoid(writePing)
   }).pipe(
     // CHANGED: make configurable via schedule
     Effect.schedule(pingSchedule),
@@ -205,7 +224,7 @@ const makePinger = Effect.fnUntraced(function* <A, E, R>(
   const ping = Effect.gen(function* () {
     const deferred = yield* Deferred.make<void>()
     manualPingDeferreds.add(deferred)
-    yield* deferred
+    yield* Deferred.await(deferred)
     manualPingDeferreds.delete(deferred)
   })
 

package/src/effect/Schedule.ts

@@ -1,10 +1,9 @@
-import { Duration, pipe, Schedule } from 'effect'
+import { Duration, Effect, pipe, Schedule } from 'effect'
 
 export * from 'effect/Schedule'
 
-export const exponentialBackoff10Sec: Schedule.Schedule<Duration.DurationInput> = pipe(
+export const exponentialBackoff10Sec = pipe(
   Schedule.exponential(Duration.millis(10), 4), // 10ms, 40ms, 160ms, 640ms, 2560ms, ...
-  Schedule.andThenEither(Schedule.spaced(Duration.seconds(1))),
-  Schedule.compose(Schedule.elapsed),
-  Schedule.whileOutput(Duration.lessThanOrEqualTo(Duration.seconds(10))), // max 10 seconds
+  Schedule.modifyDelay(({ duration }) => Effect.succeed(Duration.min(duration, Duration.seconds(1)))),
+  Schedule.upTo({ duration: Duration.seconds(10) }),
 )