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

package/src/unstable/rpc/RpcGroup.ts

@@ -131,12 +131,12 @@ export interface RpcGroup<in out R extends Rpc.Any> extends Pipeable {
   /**
    * Annotate the group with a value.
    */
-  annotate<I, S>(service: ServiceMap.Service<I, S>, value: S): RpcGroup<R>
+  annotate<I, S>(service: ServiceMap.Key<I, S>, value: S): RpcGroup<R>
 
   /**
    * Annotate the Rpc's above this point with a value.
    */
-  annotateRpcs<I, S>(service: ServiceMap.Service<I, S>, value: S): RpcGroup<R>
+  annotateRpcs<I, S>(service: ServiceMap.Key<I, S>, value: S): RpcGroup<R>
 
   /**
    * Annotate the group with the provided annotations.
@@ -314,13 +314,13 @@ const RpcGroupProto = {
       })
     })
   },
-  annotate(this: RpcGroup<any>, service: ServiceMap.Service<any, any>, value: any) {
+  annotate(this: RpcGroup<any>, service: ServiceMap.Key<any, any>, value: any) {
     return makeProto({
       requests: this.requests,
       annotations: ServiceMap.add(this.annotations, service, value)
     })
   },
-  annotateRpcs(this: RpcGroup<any>, service: ServiceMap.Service<any, any>, value: any) {
+  annotateRpcs(this: RpcGroup<any>, service: ServiceMap.Key<any, any>, value: any) {
     return this.annotateRpcsMerge(ServiceMap.make(service, value))
   },
   annotateMerge(this: RpcGroup<any>, context: ServiceMap.ServiceMap<any>) {

package/src/unstable/rpc/RpcMiddleware.ts

@@ -109,7 +109,8 @@ export interface ServiceClass<
   Provides,
   E extends Schema.Top,
   ClientError,
-  Requires
+  Requires,
+  RequiredForClient extends boolean
 > extends ServiceMap.Service<Self, RpcMiddleware<Provides, E["Type"], Requires>> {
   new(_: never): ServiceMap.ServiceClass.Shape<Name, RpcMiddleware<Provides, E["Type"], Requires>> & {
     readonly [TypeId]: {
@@ -121,7 +122,7 @@ export interface ServiceClass<
   }
   readonly [TypeId]: typeof TypeId
   readonly error: E
-  readonly requiredForClient: boolean
+  readonly requiredForClient: RequiredForClient
   readonly "~ClientError": ClientError
 }
 
@@ -173,7 +174,7 @@ export type ErrorServicesDecode<A> = ErrorSchema<A>["DecodingServices"]
  * @since 4.0.0
  * @category models
  */
-export interface AnyService extends ServiceMap.Service<any, any> {
+export interface AnyService extends ServiceMap.Key<any, any> {
   readonly [TypeId]: typeof TypeId
   readonly error: Schema.Top
   readonly requiredForClient: boolean
@@ -184,7 +185,7 @@ export interface AnyService extends ServiceMap.Service<any, any> {
  * @since 4.0.0
  * @category models
  */
-export interface AnyServiceWithProps extends ServiceMap.Service<any, RpcMiddleware<any, any, any>> {
+export interface AnyServiceWithProps extends ServiceMap.Key<any, RpcMiddleware<any, any, any>> {
   readonly [TypeId]: typeof TypeId
   readonly error: Schema.Top
   readonly requiredForClient: boolean
@@ -201,16 +202,20 @@ export const Service = <
     requires?: any
     provides?: any
     clientError?: any
-  } = { requires: never; provides: never; clientError: never }
+  } = {
+    requires: never
+    provides: never
+    clientError: never
+  }
 >(): <
   const Name extends string,
   Error extends Schema.Top = Schema.Never,
-  RequiredForClient extends boolean = false
+  const RequiredForClient extends boolean = false
 >(
   id: Name,
   options?: {
     readonly error?: Error | undefined
-    readonly requiredForClient: RequiredForClient | undefined
+    readonly requiredForClient?: RequiredForClient | undefined
   } | undefined
 ) => ServiceClass<
   Self,
@@ -218,7 +223,8 @@ export const Service = <
   "provides" extends keyof Config ? Config["provides"] : never,
   Error,
   "clientError" extends keyof Config ? Config["clientError"] : never,
-  "requires" extends keyof Config ? Config["requires"] : never
+  "requires" extends keyof Config ? Config["requires"] : never,
+  RequiredForClient
 > =>
 (
   id: string,
@@ -253,7 +259,7 @@ export const Service = <
  * @category client
  */
 export const layerClient = <Id extends AnyId, S, R, EX = never, RX = never>(
-  tag: ServiceMap.Service<Id, S>,
+  tag: ServiceMap.Key<Id, S>,
   service:
     | RpcMiddlewareClient<Id[TypeId]["error"]["Type"], Id[TypeId]["clientError"], R>
     | Effect.Effect<RpcMiddlewareClient<Id[TypeId]["error"]["Type"], Id[TypeId]["clientError"], R>, EX, RX>

package/src/unstable/rpc/RpcSchema.ts

@@ -1,9 +1,12 @@
 /**
  * @since 4.0.0
  */
+import * as Cause from "../../Cause.ts"
+import { constUndefined } from "../../Function.ts"
 import * as Predicate from "../../Predicate.ts"
 import * as Schema from "../../Schema.ts"
 import type * as AST from "../../SchemaAST.ts"
+import * as ServiceMap from "../../ServiceMap.ts"
 import * as Stream_ from "../../Stream.ts"
 
 const StreamSchemaTypeId = "~effect/rpc/RpcSchema/StreamSchema"
@@ -58,3 +61,17 @@ const schema = Schema.declare(Stream_.isStream)
 export function Stream<A extends Schema.Top, E extends Schema.Top>(success: A, error: E): Stream<A, E> {
   return Schema.make(schema.ast, { [StreamSchemaTypeId]: StreamSchemaTypeId, success, error })
 }
+
+/**
+ * @since 4.0.0
+ * @category Cause annotations
+ */
+export class ClientAbort extends ServiceMap.Service<ClientAbort, true>()("effect/rpc/RpcSchema/ClientAbort") {
+  static annotation = this.serviceMap(true).pipe(
+    ServiceMap.add(Cause.StackTrace, {
+      name: "ClientAbort",
+      stack: constUndefined,
+      parent: undefined
+    })
+  )
+}

package/src/unstable/rpc/RpcSerialization.ts

@@ -107,11 +107,7 @@ export const jsonRpc = (options?: {
           return decodeJsonRpcRaw(decoded, batches)
         },
         encode: (response) => {
-          if (Array.isArray(response)) {
-            if (response.length === 0) return undefined
-            return JSON.stringify(response.map(encodeJsonRpcMessage))
-          }
-          const encoded = encodeJsonRpcRaw(response as any, batches)
+          const encoded = encodeJsonRpcResponse(response as any, batches)
           return encoded && JSON.stringify(encoded)
         }
       }
@@ -146,10 +142,7 @@ export const ndJsonRpc = (options?: {
           return messages
         },
         encode: (response) => {
-          if (Array.isArray(response)) {
-            return parser.encode(response.map(encodeJsonRpcMessage))
-          }
-          const encoded = encodeJsonRpcRaw(response as any, batches)
+          const encoded = encodeJsonRpcResponse(response as any, batches)
           return encoded && parser.encode(encoded)
         }
       })
@@ -171,6 +164,7 @@ function decodeJsonRpcRaw(
     const messages: Array<RpcMessage.FromClientEncoded | RpcMessage.FromServerEncoded> = []
     for (let i = 0; i < decoded.length; i++) {
       const message = decodeJsonRpcMessage(decoded[i])
+      messages.push(message)
       if (message._tag === "Request") {
         batch.size++
         batches.set(message.id, batch)
@@ -263,6 +257,47 @@ function encodeJsonRpcRaw(
   return encodeJsonRpcMessage(response)
 }
 
+function encodeJsonRpcResponse(
+  response:
+    | RpcMessage.FromServerEncoded
+    | RpcMessage.FromClientEncoded
+    | Array<RpcMessage.FromServerEncoded | RpcMessage.FromClientEncoded>,
+  batches: Map<string, {
+    readonly size: number
+    readonly responses: Map<string, RpcMessage.FromServerEncoded>
+  }>
+) {
+  if (Array.isArray(response) === false) {
+    return encodeJsonRpcRaw(response, batches)
+  }
+  if (response.length === 0) {
+    return undefined
+  }
+  const encoded: Array<JsonRpcMessage | Array<JsonRpcMessage>> = []
+  for (let i = 0; i < response.length; i++) {
+    const current = encodeJsonRpcRaw(response[i], batches)
+    if (current !== undefined) {
+      encoded.push(current)
+    }
+  }
+  if (encoded.length === 0) {
+    return undefined
+  }
+  if (encoded.length === 1) {
+    return encoded[0]
+  }
+  const messages: Array<JsonRpcMessage> = []
+  for (let i = 0; i < encoded.length; i++) {
+    const current = encoded[i]
+    if (Array.isArray(current)) {
+      messages.push(...current)
+    } else {
+      messages.push(current)
+    }
+  }
+  return messages
+}
+
 function encodeJsonRpcMessage(response: RpcMessage.FromServerEncoded | RpcMessage.FromClientEncoded): JsonRpcMessage {
   switch (response._tag) {
     case "Request":

package/src/unstable/rpc/RpcServer.ts

@@ -8,15 +8,17 @@ import * as Effect from "../../Effect.ts"
 import * as Exit from "../../Exit.ts"
 import * as Fiber from "../../Fiber.ts"
 import { constant, constTrue, constVoid, identity } from "../../Function.ts"
+import { reportCauseUnsafe } from "../../internal/effect.ts"
+import * as Latch from "../../Latch.ts"
 import * as Layer from "../../Layer.ts"
 import type * as Option from "../../Option.ts"
 import * as Predicate from "../../Predicate.ts"
 import * as Pull from "../../Pull.ts"
 import * as Queue from "../../Queue.ts"
-import * as Result from "../../Result.ts"
 import * as Schedule from "../../Schedule.ts"
 import * as Schema from "../../Schema.ts"
 import * as Scope from "../../Scope.ts"
+import * as Semaphore from "../../Semaphore.ts"
 import * as ServiceMap from "../../ServiceMap.ts"
 import { Stdio } from "../../Stdio.ts"
 import * as Stream from "../../Stream.ts"
@@ -101,18 +103,18 @@ export const makeNoSerialization: <Rpcs extends Rpc.Any>(
   const trackFiber = Fiber.runIn(Scope.forkUnsafe(scope, "parallel"))
   const concurrencySemaphore = concurrency === "unbounded"
     ? undefined
-    : yield* Effect.makeSemaphore(concurrency)
+    : yield* Semaphore.make(concurrency)
 
   type Client = {
     readonly id: number
-    readonly latches: Map<RequestId, Effect.Latch>
+    readonly latches: Map<RequestId, Latch.Latch>
     readonly fibers: Map<RequestId, Fiber.Fiber<unknown, any>>
     ended: boolean
   }
 
   const clients = new Map<number, Client>()
   let isShutdown = false
-  const shutdownLatch = Effect.makeLatchUnsafe(false)
+  const shutdownLatch = Latch.makeUnsafe(false)
   yield* Scope.addFinalizer(
     scope,
     Effect.withFiber((parent) => {
@@ -172,17 +174,16 @@ export const makeNoSerialization: <Rpcs extends Rpc.Any>(
           }
           case "Interrupt": {
             const fiber = client.fibers.get(message.requestId)
-            return fiber
-              ? Effect.forkDetach(
-                Fiber.interruptAs(fiber, fiberIdClientInterrupt),
-                { startImmediately: true }
-              )
-              : options.onFromServer({
-                _tag: "Exit",
-                clientId,
-                requestId: message.requestId,
-                exit: Exit.interrupt()
-              })
+            if (fiber) {
+              fiber.interruptUnsafe(requestFiber.id, RpcSchema.ClientAbort.annotation)
+              return Effect.void
+            }
+            return options.onFromServer({
+              _tag: "Exit",
+              clientId,
+              requestId: message.requestId,
+              exit: Exit.interrupt()
+            })
           }
           case "Eof": {
             client.ended = true
@@ -271,6 +272,9 @@ export const makeNoSerialization: <Rpcs extends Rpc.Any>(
           requestId: request.id,
           exit
         })
+      if (exit._tag === "Failure") {
+        reportCauseUnsafe(Fiber.getCurrent()!, exit.cause)
+      }
       return close ? Effect.ensuring(write, close) : write
     })
     if (enableTracing) {
@@ -301,7 +305,7 @@ export const makeNoSerialization: <Rpcs extends Rpc.Any>(
       effect = concurrencySemaphore.withPermits(1)(effect)
     }
     const serviceMap = new Map(entry.services.mapUnsafe)
-    serviceMap.forEach((value, key) => serviceMap.set(key, value))
+    requestFiber.services.mapUnsafe.forEach((value, key) => serviceMap.set(key, value))
     serviceMap.set(Scope.Scope.key, scope)
     const runFork = Effect.runForkWith(ServiceMap.makeUnsafe(serviceMap))
     const fiber = trackFiber(
@@ -342,7 +346,7 @@ export const makeNoSerialization: <Rpcs extends Rpc.Any>(
   ) => {
     let latch = client.latches.get(request.id)
     if (supportsAck && !latch) {
-      latch = Effect.makeLatchUnsafe(false)
+      latch = Latch.makeUnsafe(false)
       client.latches.set(request.id, latch)
     }
     if (Effect.isEffect(stream)) {
@@ -735,6 +739,7 @@ export const layerHttp = <Rpcs extends Rpc.Any>(options: {
   readonly spanPrefix?: string | undefined
   readonly spanAttributes?: Record<string, unknown> | undefined
   readonly concurrency?: number | "unbounded" | undefined
+  readonly disableFatalDefects?: boolean | undefined
 }): Layer.Layer<
   never,
   never,
@@ -1076,6 +1081,7 @@ export const toHttpEffect: <Rpcs extends Rpc.Any>(
     readonly disableTracing?: boolean | undefined
     readonly spanPrefix?: string | undefined
     readonly spanAttributes?: Record<string, unknown> | undefined
+    readonly disableFatalDefects?: boolean | undefined
   } | undefined
 ) => Effect.Effect<
   Effect.Effect<HttpServerResponse.HttpServerResponse, never, Scope.Scope | HttpServerRequest.HttpServerRequest>,
@@ -1091,6 +1097,7 @@ export const toHttpEffect: <Rpcs extends Rpc.Any>(
     readonly disableTracing?: boolean | undefined
     readonly spanPrefix?: string | undefined
     readonly spanAttributes?: Record<string, unknown> | undefined
+    readonly disableFatalDefects?: boolean | undefined
   }
 ) {
   const { httpEffect, protocol } = yield* makeProtocolWithHttpEffect
@@ -1112,6 +1119,7 @@ export const toHttpEffectWebsocket: <Rpcs extends Rpc.Any>(
     readonly disableTracing?: boolean | undefined
     readonly spanPrefix?: string | undefined
     readonly spanAttributes?: Record<string, unknown> | undefined
+    readonly disableFatalDefects?: boolean | undefined
   } | undefined
 ) => Effect.Effect<
   Effect.Effect<HttpServerResponse.HttpServerResponse, never, Scope.Scope | HttpServerRequest.HttpServerRequest>,
@@ -1127,6 +1135,7 @@ export const toHttpEffectWebsocket: <Rpcs extends Rpc.Any>(
     readonly disableTracing?: boolean | undefined
     readonly spanPrefix?: string | undefined
     readonly spanAttributes?: Record<string, unknown> | undefined
+    readonly disableFatalDefects?: boolean | undefined
   }
 ) {
   const { httpEffect, protocol } = yield* makeProtocolWithHttpEffectWebsocket
@@ -1172,7 +1181,7 @@ export const makeProtocolStdio = Effect.gen(function*() {
     )
 
     yield* Stream.fromQueue(queue).pipe(
-      Stream.run(stdio.stdout),
+      Stream.run(stdio.stdout()),
       Effect.retry(Schedule.spaced(500)),
       Effect.forkScoped
     )
@@ -1276,14 +1285,6 @@ export const layerProtocolWorkerRunner: Layer.Layer<
   WorkerRunner.WorkerRunnerPlatform
 > = Layer.effect(Protocol)(makeProtocolWorkerRunner)
 
-/**
- * Fiber id used to indicate client induced interrupts
- *
- * @since 4.0.0
- * @category Interruption
- */
-export const fiberIdClientInterrupt = -499
-
 // internal
 
 const makeSocketProtocol: Effect.Effect<
@@ -1365,12 +1366,7 @@ const makeSocketProtocol: Effect.Effect<
         return writeRaw(parser.encode(ResponseDefectEncoded(cause))!)
       }
     }).pipe(
-      Effect.catchIf(
-        ((
-          error: any
-        ) => (error.reason._tag === "SocketCloseError" ? Result.succeed(error.reason) : Result.fail(error))) as any,
-        (_: any) => Effect.void
-      ),
+      Effect.catchReason("SocketError", "SocketCloseError", (_) => Effect.void),
       Effect.orDie
     )
   }

package/src/unstable/rpc/Utils.ts

@@ -2,6 +2,7 @@
  * @since 4.0.0
  */
 import * as Effect from "../../Effect.ts"
+import * as Semaphore from "../../Semaphore.ts"
 import type * as ServiceMap from "../../ServiceMap.ts"
 
 /**
@@ -14,7 +15,7 @@ export const withRun = <
 >() =>
 <EX, RX>(f: (write: Parameters<A["run"]>[0]) => Effect.Effect<Omit<A, "run">, EX, RX>): Effect.Effect<A, EX, RX> =>
   Effect.suspend(() => {
-    const semaphore = Effect.makeSemaphoreUnsafe(1)
+    const semaphore = Semaphore.makeUnsafe(1)
     let buffer: Array<[Array<any>, ServiceMap.ServiceMap<never>]> = []
     let write = (...args: Array<any>): Effect.Effect<void> =>
       Effect.servicesWith((context) => {
@@ -29,7 +30,7 @@ export const withRun = <
           write = f
 
           for (const [args, context] of buffer) {
-            yield* Effect.provide(write(...args), context)
+            yield* Effect.provideServices(Effect.suspend(() => f(...args)), context)
           }
           buffer = []
 

package/src/unstable/schema/Model.ts

@@ -301,6 +301,37 @@ export const FieldOption: <Field extends VariantSchema.Field<any> | Schema.Top>(
     jsonUpdate: optionalOption
   }) as any
 
+/**
+ * @since 4.0.0
+ * @category booleans
+ */
+export interface BooleanSqlite extends
+  VariantSchema.Field<{
+    readonly select: Schema.BooleanFromBit
+    readonly insert: Schema.BooleanFromBit
+    readonly update: Schema.BooleanFromBit
+    readonly json: Schema.Boolean
+    readonly jsonCreate: Schema.Boolean
+    readonly jsonUpdate: Schema.Boolean
+  }>
+{}
+
+/**
+ * A schema for sqlite booleans that are represented as `0 | 1` in database
+ * variants and `boolean` in JSON variants.
+ *
+ * @since 4.0.0
+ * @category booleans
+ */
+export const BooleanSqlite: BooleanSqlite = Field({
+  select: Schema.BooleanFromBit,
+  insert: Schema.BooleanFromBit,
+  update: Schema.BooleanFromBit,
+  json: Schema.Boolean,
+  jsonCreate: Schema.Boolean,
+  jsonUpdate: Schema.Boolean
+})
+
 /**
  * @since 4.0.0
  * @category date & time

package/src/unstable/schema/VariantSchema.ts

@@ -17,7 +17,7 @@ import * as Struct_ from "../../Struct.ts"
  * @since 4.0.0
  * @category Type IDs
  */
-export const TypeId = "~effect/unstable/schema/VariantSchema"
+export const TypeId = "~effect/schema/VariantSchema"
 
 const cacheSymbol = Symbol.for(`${TypeId}/cache`)
 
@@ -71,7 +71,7 @@ export declare namespace Struct {
   }
 }
 
-const FieldTypeId = "~effect/unstable/schema/VariantSchema/Field"
+const FieldTypeId = "~effect/schema/VariantSchema/Field"
 
 /**
  * @since 4.0.0
@@ -301,12 +301,12 @@ export const make = <
     config: A & { readonly [K in Exclude<keyof A, Variants[number]>]: never }
   ) => Field<A>
   readonly FieldOnly: <const Keys extends ReadonlyArray<Variants[number]>>(
-    ...keys: Keys
+    keys: Keys
   ) => <S extends Schema.Top>(
     schema: S
   ) => Field<{ readonly [K in Keys[number]]: S }>
   readonly FieldExcept: <const Keys extends ReadonlyArray<Variants[number]>>(
-    ...keys: Keys
+    keys: Keys
   ) => <S extends Schema.Top>(
     schema: S
   ) => Field<{ readonly [K in Exclude<Variants[number], Keys[number]>]: S }>
@@ -364,7 +364,7 @@ export const make = <
         readonly [V in Variants[number]]: Extract<V, Struct<Fields>>
       }
   readonly Union: <const Members extends ReadonlyArray<Struct<any>>>(
-    ...members: Members
+    members: Members
   ) => Union<Members> & Union.Variants<Members, Variants[number]>
   readonly extract: {
     <V extends Variants[number]>(
@@ -403,7 +403,7 @@ export const make = <
       return Base
     }
   }
-  function FieldOnly<Keys extends Variants>(...keys: Keys) {
+  function FieldOnly<const Keys extends ReadonlyArray<Variants[number]>>(keys: Keys) {
     return function<S extends Schema.Top>(schema: S) {
       const obj: Record<string, S> = {}
       for (const key of keys) {
@@ -412,7 +412,7 @@ export const make = <
       return Field(obj)
     }
   }
-  function FieldExcept<Keys extends Variants>(...keys: Keys) {
+  function FieldExcept<const Keys extends ReadonlyArray<Variants[number]>>(keys: Keys) {
     return function<S extends Schema.Top>(schema: S) {
       const obj: Record<string, S> = {}
       for (const variant of options.variants) {
@@ -423,7 +423,7 @@ export const make = <
       return Field(obj)
     }
   }
-  function UnionVariants(...members: ReadonlyArray<Struct<any>>) {
+  function UnionVariants(members: ReadonlyArray<Struct<any>>) {
     return Union(members, options.variants)
   }
   const fieldEvolve = dual(
@@ -542,7 +542,7 @@ const Union = <Members extends ReadonlyArray<Struct<any>>, Variants extends Read
   members: Members,
   variants: Variants
 ) => {
-  class VariantUnion extends (Schema.Union(members.filter((member) => Schema.isSchema(member))) as any) {}
+  const VariantUnion = Schema.Union(members.filter((member) => Schema.isSchema(member))) as any
   for (const variant of variants) {
     Object.defineProperty(VariantUnion, variant, {
       value: Schema.Union(members.map((member) => extract(member, variant)))

package/src/unstable/socket/Socket.ts

@@ -5,11 +5,12 @@ import type { NonEmptyReadonlyArray } from "../../Array.ts"
 import type * as Cause from "../../Cause.ts"
 import * as Channel from "../../Channel.ts"
 import * as Deferred from "../../Deferred.ts"
-import type { DurationInput } from "../../Duration.ts"
+import type * as Duration from "../../Duration.ts"
 import * as Effect from "../../Effect.ts"
 import * as Exit from "../../Exit.ts"
 import * as FiberSet from "../../FiberSet.ts"
 import { constVoid, dual, flow } from "../../Function.ts"
+import * as Latch from "../../Latch.ts"
 import * as Layer from "../../Layer.ts"
 import * as Predicate from "../../Predicate.ts"
 import * as Pull from "../../Pull.ts"
@@ -280,7 +281,7 @@ export const toChannelMap = <IE, A>(
         return writeChunk
       }),
       Effect.forever({ disableYield: true }),
-      Effect.catchCauseIf(
+      Effect.catchCauseFilter(
         Pull.filterNoDone,
         (cause) => Queue.failCause(queue, cause)
       ),
@@ -422,7 +423,7 @@ export const layerWebSocketConstructorGlobal: Layer.Layer<WebSocketConstructor>
  */
 export const makeWebSocket = (url: string | Effect.Effect<string>, options?: {
   readonly closeCodeIsError?: ((code: number) => boolean) | undefined
-  readonly openTimeout?: DurationInput | undefined
+  readonly openTimeout?: Duration.Input | undefined
   readonly protocols?: string | Array<string> | undefined
 }): Effect.Effect<Socket, never, WebSocketConstructor> =>
   fromWebSocket(
@@ -443,12 +444,12 @@ export const fromWebSocket = <RO>(
   acquire: Effect.Effect<globalThis.WebSocket, SocketError, RO>,
   options?: {
     readonly closeCodeIsError?: ((code: number) => boolean) | undefined
-    readonly openTimeout?: DurationInput | undefined
+    readonly openTimeout?: Duration.Input | undefined
   } | undefined
 ): Effect.Effect<Socket, never, Exclude<RO, Scope.Scope>> =>
   Effect.withFiber((fiber) => {
     let currentWS: globalThis.WebSocket | undefined
-    const latch = Effect.makeLatchUnsafe(false)
+    const latch = Latch.makeUnsafe(false)
     const acquireContext = fiber.services as ServiceMap.ServiceMap<RO>
     const closeCodeIsError = options?.closeCodeIsError ?? defaultCloseCodeIsError
 
@@ -544,11 +545,10 @@ export const fromWebSocket = <RO>(
         currentWS = ws
         latch.openUnsafe()
         if (opts?.onOpen) yield* opts.onOpen
-        return yield* FiberSet.join(fiberSet).pipe(
-          Effect.catchIf(
-            SocketCloseError.filterClean((_) => !closeCodeIsError(_)) as any,
-            (_: any) => Effect.void
-          )
+        return yield* Effect.catchFilter(
+          FiberSet.join(fiberSet),
+          SocketCloseError.filterClean((_) => !closeCodeIsError(_)),
+          () => Effect.void
         )
       })).pipe(
         Effect.updateServices((input: ServiceMap.ServiceMap<R>) => ServiceMap.merge(acquireContext, input)),
@@ -618,7 +618,7 @@ export const layerWebSocket: (
   url: string | Effect.Effect<string>,
   options?: {
     readonly closeCodeIsError?: ((code: number) => boolean) | undefined
-    readonly openTimeout?: DurationInput | undefined
+    readonly openTimeout?: Duration.Input | undefined
     readonly protocols?: string | Array<string> | undefined
   } | undefined
 ) => Layer.Layer<Socket, never, WebSocketConstructor> = flow(makeWebSocket, Layer.effect(Socket))
@@ -648,7 +648,7 @@ export const fromTransformStream = <R>(acquire: Effect.Effect<InputTransformStre
   readonly closeCodeIsError?: (code: number) => boolean
 }): Effect.Effect<Socket, never, Exclude<R, Scope.Scope>> =>
   Effect.withFiber((fiber) => {
-    const latch = Effect.makeLatchUnsafe(false)
+    const latch = Latch.makeUnsafe(false)
     let currentStream: {
       readonly stream: InputTransformStream
       readonly fiberSet: FiberSet.FiberSet<any, any>
@@ -692,11 +692,10 @@ export const fromTransformStream = <R>(acquire: Effect.Effect<InputTransformStre
         yield* latch.open
         if (opts?.onOpen) yield* opts.onOpen
 
-        return yield* FiberSet.join(fiberSet).pipe(
-          Effect.catchIf(
-            SocketCloseError.filterClean((_) => !closeCodeIsError(_)) as any,
-            (_: any) => Effect.void
-          )
+        return yield* Effect.catchFilter(
+          FiberSet.join(fiberSet),
+          SocketCloseError.filterClean((_) => !closeCodeIsError(_)),
+          () => Effect.void
         )
       })).pipe(
         (_) => _,

package/src/unstable/sql/SqlClient.ts

@@ -180,7 +180,7 @@ export const make = Effect.fnUntraced(function*(options: SqlClient.MakeOptions)
  * @category transactions
  */
 export const makeWithTransaction = <I, S>(options: {
-  readonly transactionService: ServiceMap.Service<I, readonly [conn: S, counter: number]>
+  readonly transactionService: ServiceMap.Key<I, readonly [conn: S, counter: number]>
   readonly spanAttributes: ReadonlyArray<readonly [string, unknown]>
   readonly acquireConnection: Effect.Effect<readonly [Scope.Closeable | undefined, S], SqlError>
   readonly begin: (conn: NoInfer<S>) => Effect.Effect<void, SqlError>