effect 4.0.0-beta.6 → 4.0.0-beta.60

package/src/unstable/rpc/Utils.ts

@@ -1,9 +1,11 @@
 /**
  * @since 4.0.0
  */
+import type * as Context from "../../Context.ts"
 import * as Effect from "../../Effect.ts"
 import * as Semaphore from "../../Semaphore.ts"
-import type * as ServiceMap from "../../ServiceMap.ts"
+import type { Protocol } from "./RpcClient.ts"
+import type { FromServerEncoded } from "./RpcMessage.ts"
 
 /**
  * @since 4.0.0
@@ -16,9 +18,9 @@ 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 = Semaphore.makeUnsafe(1)
-    let buffer: Array<[Array<any>, ServiceMap.ServiceMap<never>]> = []
+    let buffer: Array<[Array<any>, Context.Context<never>]> = []
     let write = (...args: Array<any>): Effect.Effect<void> =>
-      Effect.servicesWith((context) => {
+      Effect.contextWith((context) => {
         buffer.push([args, context])
         return Effect.void
       })
@@ -30,7 +32,7 @@ export const withRun = <
           write = f
 
           for (const [args, context] of buffer) {
-            yield* Effect.provide(write(...args), context)
+            yield* Effect.provideContext(Effect.suspend(() => f(...args)), context)
           }
           buffer = []
 
@@ -42,3 +44,60 @@ export const withRun = <
       }
     } as A))
   })
+
+/**
+ * @since 4.0.0
+ */
+export const withRunClient = <EX, RX>(
+  f: (
+    write: (clientId: number, response: FromServerEncoded) => Effect.Effect<void>,
+    clientIds: ReadonlySet<number>
+  ) => Effect.Effect<Omit<Protocol["Service"], "run">, EX, RX>
+): Effect.Effect<Protocol["Service"], EX, RX> =>
+  Effect.suspend(() => {
+    const clientIds = new Set<number>()
+    const clientBuffers = new Map<number, Array<[FromServerEncoded, Context.Context<never>]>>()
+    const clientWrites = new Map<number, (data: FromServerEncoded) => Effect.Effect<void>>()
+    let write = (clientId: number, data: FromServerEncoded): Effect.Effect<void> =>
+      Effect.contextWith((context) => {
+        let buffer = clientBuffers.get(clientId)
+        if (!buffer) {
+          buffer = []
+          clientBuffers.set(clientId, buffer)
+        }
+        buffer.push([data, context])
+        return Effect.void
+      })
+    return Effect.map(
+      f((clientId, data) => {
+        const clientWrite = clientWrites.get(clientId)
+        if (clientWrite) {
+          return clientWrite(data)
+        }
+        return write(clientId, data)
+      }, clientIds),
+      (a) => ({
+        ...a,
+        run(clientId, f) {
+          return Effect.gen(function*() {
+            clientIds.add(clientId)
+            clientWrites.set(clientId, f)
+
+            const buffer = clientBuffers.get(clientId)
+            if (buffer) {
+              clientBuffers.delete(clientId)
+              for (const [args, context] of buffer) {
+                yield* Effect.provideContext(Effect.suspend(() => f(args)), context)
+              }
+            }
+
+            return yield* Effect.onExit(Effect.never, () => {
+              clientIds.delete(clientId)
+              clientWrites.delete(clientId)
+              return Effect.void
+            })
+          })
+        }
+      } satisfies Protocol["Service"])
+    )
+  })

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
@@ -550,7 +581,7 @@ export interface JsonFromString<S extends Schema.Top> extends
 export const JsonFromString = <S extends Schema.Top>(
   schema: S
 ): JsonFromString<S> => {
-  const parsed = Schema.fromJsonString(schema)
+  const parsed = Schema.fromJsonString(Schema.toCodecJson(schema)) as any
   return Field({
     select: parsed,
     insert: parsed,
@@ -568,7 +599,7 @@ export const JsonFromString = <S extends Schema.Top>(
 export interface UuidV4Insert<B extends string> extends
   VariantSchema.Field<{
     readonly select: Schema.brand<Schema.instanceOf<Uint8Array<ArrayBuffer>>, B>
-    readonly insert: VariantSchema.Overrideable<Schema.brand<Schema.instanceOf<Uint8Array<ArrayBuffer>>, B>>
+    readonly insert: Schema.withConstructorDefault<Schema.brand<Schema.instanceOf<Uint8Array<ArrayBuffer>>, B>>
     readonly update: Schema.brand<Schema.instanceOf<Uint8Array<ArrayBuffer>>, B>
     readonly json: Schema.brand<Schema.instanceOf<Uint8Array<ArrayBuffer>>, B>
   }>
@@ -588,10 +619,8 @@ export const Uint8Array: Schema.instanceOf<Uint8Array<ArrayBuffer>> = Schema.Uin
  */
 export const UuidV4WithGenerate = <B extends string>(
   schema: Schema.brand<Schema.instanceOf<Uint8Array<ArrayBuffer>>, B>
-): VariantSchema.Overrideable<Schema.brand<Schema.instanceOf<Uint8Array<ArrayBuffer>>, B>> =>
-  VariantSchema.Overrideable(schema, {
-    defaultValue: Effect.sync(() => Uuid.v4({}, new globalThis.Uint8Array(16)))
-  })
+): Schema.withConstructorDefault<Schema.brand<Schema.instanceOf<Uint8Array<ArrayBuffer>>, B>> =>
+  schema.pipe(Schema.withConstructorDefault(Effect.sync(() => Uuid.v4({}, new globalThis.Uint8Array(16)))))
 
 /**
  * A field that represents a binary UUID v4 that is generated on inserts.

package/src/unstable/schema/VariantSchema.ts

@@ -4,20 +4,17 @@
 import type { Brand } from "../../Brand.ts"
 import * as Effect from "../../Effect.ts"
 import { dual } from "../../Function.ts"
-import * as Option from "../../Option.ts"
 import { type Pipeable, pipeArguments } from "../../Pipeable.ts"
 import * as Predicate from "../../Predicate.ts"
 import * as Schema from "../../Schema.ts"
 import type * as AST from "../../SchemaAST.ts"
-import * as Getter from "../../SchemaGetter.ts"
-import * as Transformation from "../../SchemaTransformation.ts"
 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 +68,7 @@ export declare namespace Struct {
   }
 }
 
-const FieldTypeId = "~effect/unstable/schema/VariantSchema/Field"
+const FieldTypeId = "~effect/schema/VariantSchema/Field"
 
 /**
  * @since 4.0.0
@@ -238,7 +235,7 @@ export interface Class<
   new(
     props: S["~type.make.in"],
     options?: {
-      readonly disableValidation?: boolean
+      readonly disableChecks?: boolean
     } | undefined
   ): S["Type"]
 
@@ -301,12 +298,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 +361,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 +400,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 +409,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 +420,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(
@@ -470,7 +467,7 @@ export const Override = <A>(value: A): A & Brand<"Override"> => value as any
  */
 export interface Overrideable<S extends Schema.Top & Schema.WithoutConstructorDefault> extends
   Schema.Bottom<
-    (S["Type"] & Brand<"Override">) | undefined,
+    S["Type"] & Brand<"Override">,
     S["Encoded"],
     S["DecodingServices"],
     S["EncodingServices"],
@@ -481,7 +478,7 @@ export interface Overrideable<S extends Schema.Top & Schema.WithoutConstructorDe
     S["~type.parameters"],
     (S["Type"] & Brand<"Override">) | undefined,
     S["~type.mutability"],
-    "optional",
+    "required",
     "with-default",
     S["~encoded.mutability"],
     S["~encoded.optionality"]
@@ -499,18 +496,8 @@ export const Overrideable = <S extends Schema.Top & Schema.WithoutConstructorDef
   }
 ): Overrideable<S> =>
   schema.pipe(
-    Schema.decodeTo(
-      Schema.optional(Schema.brand("Override")(Schema.toType(schema))),
-      Transformation.make({
-        decode: Getter.passthrough(),
-        encode: new Getter.Getter((o) => {
-          if (Option.isSome(o) && o.value !== undefined) {
-            return Effect.succeed(o)
-          }
-          return Effect.asSome(options.defaultValue)
-        })
-      })
-    )
+    Schema.decodeTo(Schema.brand("Override")(Schema.toType(schema))),
+    Schema.withConstructorDefault(Effect.map(options.defaultValue, Override))
   ) as any
 
 const StructProto = {
@@ -542,7 +529,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

@@ -4,8 +4,9 @@
 import type { NonEmptyReadonlyArray } from "../../Array.ts"
 import type * as Cause from "../../Cause.ts"
 import * as Channel from "../../Channel.ts"
+import * as Context from "../../Context.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"
@@ -18,7 +19,6 @@ import * as Queue from "../../Queue.ts"
 import * as Result from "../../Result.ts"
 import * as Schema from "../../Schema.ts"
 import * as Scope from "../../Scope.ts"
-import * as ServiceMap from "../../ServiceMap.ts"
 
 /**
  * @since 4.0.0
@@ -36,7 +36,7 @@ export const isSocket = (u: unknown): u is Socket => Predicate.hasProperty(u, Ty
  * @since 4.0.0
  * @category tags
  */
-export const Socket: ServiceMap.Service<Socket, Socket> = ServiceMap.Service<Socket>("effect/socket/Socket")
+export const Socket: Context.Service<Socket, Socket> = Context.Service<Socket>("effect/socket/Socket")
 
 /**
  * @since 4.0.0
@@ -50,6 +50,12 @@ export interface Socket {
       readonly onOpen?: Effect.Effect<void> | undefined
     }
   ) => Effect.Effect<void, SocketError | E, R>
+  readonly runString: <_, E = never, R = never>(
+    handler: (_: string) => Effect.Effect<_, E, R> | void,
+    options?: {
+      readonly onOpen?: Effect.Effect<void> | undefined
+    }
+  ) => Effect.Effect<void, SocketError | E, R>
   readonly runRaw: <_, E = never, R = never>(
     handler: (_: string | Uint8Array) => Effect.Effect<_, E, R> | void,
     options?: {
@@ -63,6 +69,61 @@ export interface Socket {
   >
 }
 
+/**
+ * @since 4.0.0
+ * @category Constructors
+ */
+export const make = (options: {
+  readonly runRaw: <_, E, R>(
+    handler: (_: string | Uint8Array) => Effect.Effect<_, E, R> | void,
+    options?: {
+      readonly onOpen?: Effect.Effect<void> | undefined
+    }
+  ) => Effect.Effect<void, SocketError | E, R>
+  readonly run?: <_, E, R>(
+    handler: (_: Uint8Array) => Effect.Effect<_, E, R> | void,
+    options?: {
+      readonly onOpen?: Effect.Effect<void> | undefined
+    }
+  ) => Effect.Effect<void, SocketError | E, R>
+  readonly runString?: <_, E, R>(
+    handler: (_: string) => Effect.Effect<_, E, R> | void,
+    options?: {
+      readonly onOpen?: Effect.Effect<void> | undefined
+    }
+  ) => Effect.Effect<void, SocketError | E, R>
+  readonly writer: Effect.Effect<
+    (chunk: Uint8Array | string | CloseEvent) => Effect.Effect<void, SocketError>,
+    never,
+    Scope.Scope
+  >
+}): Socket =>
+  Socket.of({
+    [TypeId]: TypeId,
+    runRaw: options.runRaw,
+    run: options.run ?? ((handler, opts) =>
+      options.runRaw((data) =>
+        typeof data === "string"
+          ? handler(encoder.encode(data))
+          : data instanceof Uint8Array
+          ? handler(data)
+          : handler(new Uint8Array(data)), opts)),
+    runString: options.runString ??
+      (options.run ?
+        (handler, opts) => options.run!((data) => handler(decoder.decode(data)), opts) :
+        (handler, opts) =>
+          options.runRaw((data) =>
+            typeof data === "string"
+              ? handler(data)
+              : data instanceof Uint8Array
+              ? handler(decoder.decode(data))
+              : handler(decoder.decode(new Uint8Array(data))), opts)),
+    writer: options.writer
+  })
+
+const encoder = new TextEncoder()
+const decoder = new TextDecoder()
+
 const CloseEventTypeId = "~effect/socket/Socket/CloseEvent"
 
 /**
@@ -214,7 +275,7 @@ export type SocketErrorReason =
  * @since 4.0.0
  * @category errors
  */
-export class SocketError extends Schema.ErrorClass<SocketError>(SocketErrorTypeId)({
+export class SocketError extends Schema.TaggedErrorClass<SocketError>(SocketErrorTypeId)("SocketError", {
   _tag: Schema.tag("SocketError"),
   reason: SocketErrorReason
 }) {
@@ -243,6 +304,8 @@ export class SocketError extends Schema.ErrorClass<SocketError>(SocketErrorTypeI
   static is(u: unknown): u is SocketError {
     return isSocketError(u)
   }
+
+  override readonly message = this.reason.message
 }
 
 /**
@@ -281,7 +344,7 @@ export const toChannelMap = <IE, A>(
         return writeChunk
       }),
       Effect.forever({ disableYield: true }),
-      Effect.catchCauseIf(
+      Effect.catchCauseFilter(
         Pull.filterNoDone,
         (cause) => Queue.failCause(queue, cause)
       ),
@@ -390,13 +453,13 @@ export const makeChannel = <IE = never>(): Channel.Channel<
 /**
  * @since 4.0.0
  */
-export const defaultCloseCodeIsError = (code: number) => code !== 1000 && code !== 1006
+export const defaultCloseCodeIsError = (_code: number) => true
 
 /**
  * @since 4.0.0
  * @category tags
  */
-export class WebSocket extends ServiceMap.Service<WebSocket, globalThis.WebSocket>()(
+export class WebSocket extends Context.Service<WebSocket, globalThis.WebSocket>()(
   "~effect/socket/Socket/WebSocket"
 ) {}
 
@@ -404,7 +467,7 @@ export class WebSocket extends ServiceMap.Service<WebSocket, globalThis.WebSocke
  * @since 4.0.0
  * @category tags
  */
-export class WebSocketConstructor extends ServiceMap.Service<
+export class WebSocketConstructor extends Context.Service<
   WebSocketConstructor,
   (url: string, protocols?: string | Array<string> | undefined) => globalThis.WebSocket
 >()("@effect/platform/Socket/WebSocketConstructor") {}
@@ -423,17 +486,19 @@ 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(
-    Effect.acquireRelease(
-      (typeof url === "string" ? Effect.succeed(url) : url).pipe(
-        Effect.flatMap((url) => Effect.map(WebSocketConstructor.asEffect(), (f) => f(url, options?.protocols)))
+  WebSocketConstructor.use((makeWs) =>
+    fromWebSocket(
+      Effect.acquireRelease(
+        (typeof url === "string" ? Effect.succeed(url) : url).pipe(
+          Effect.map((url) => makeWs(url, options?.protocols))
+        ),
+        (ws) => Effect.sync(() => ws.close(1000))
       ),
-      (ws) => Effect.sync(() => ws.close(1000))
-    ),
-    options
+      options
+    )
   )
 
 /**
@@ -444,13 +509,13 @@ 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 = Latch.makeUnsafe(false)
-    const acquireContext = fiber.services as ServiceMap.ServiceMap<RO>
+    const acquireContext = fiber.context as Context.Context<RO>
     const closeCodeIsError = options?.closeCodeIsError ?? defaultCloseCodeIsError
 
     const runRaw = <_, E, R>(handler: (_: string | Uint8Array) => Effect.Effect<_, E, R> | void, opts?: {
@@ -500,6 +565,7 @@ export const fromWebSocket = <RO>(
           )
         }
         function onClose(event: globalThis.CloseEvent) {
+          const code = typeof event.code === "number" ? event.code : 1001
           ws.removeEventListener("message", onMessage)
           ws.removeEventListener("error", onError)
           Deferred.doneUnsafe(
@@ -507,7 +573,7 @@ export const fromWebSocket = <RO>(
             Effect.fail(
               new SocketError({
                 reason: new SocketCloseError({
-                  code: event.code,
+                  code,
                   closeReason: event.reason
                 })
               })
@@ -528,7 +594,7 @@ export const fromWebSocket = <RO>(
           yield* Deferred.await(openDeferred).pipe(
             Effect.timeoutOrElse({
               duration: options?.openTimeout ?? 10000,
-              onTimeout: () =>
+              orElse: () =>
                 Effect.fail(
                   new SocketError({
                     reason: new SocketOpenError({
@@ -545,45 +611,31 @@ 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)),
+        Effect.updateContext((input: Context.Context<R>) => Context.merge(acquireContext, input)),
         Effect.ensuring(Effect.sync(() => {
           latch.closeUnsafe()
           currentWS = undefined
         }))
       )
 
-    const encoder = new TextEncoder()
-    const run = <_, E, R>(handler: (_: Uint8Array) => Effect.Effect<_, E, R> | void, opts?: {
-      readonly onOpen?: Effect.Effect<void> | undefined
-    }) =>
-      runRaw((data) =>
-        typeof data === "string"
-          ? handler(encoder.encode(data))
-          : data instanceof Uint8Array
-          ? handler(data)
-          : handler(new Uint8Array(data)), opts)
-
     const write = (chunk: Uint8Array | string | CloseEvent) =>
       latch.whenOpen(Effect.sync(() => {
         const ws = currentWS!
         if (isCloseEvent(chunk)) {
           ws.close(chunk.code, chunk.reason)
         } else {
-          ws.send(chunk)
+          ws.send(chunk as string | Uint8Array<ArrayBuffer>)
         }
       }))
     const writer = Effect.succeed(write)
 
-    return Effect.succeed(Socket.of({
-      [TypeId]: TypeId,
-      run,
+    return Effect.succeed(make({
       runRaw,
       writer
     }))
@@ -619,7 +671,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))
@@ -628,7 +680,7 @@ export const layerWebSocket: (
  * @since 4.0.0
  * @category fiber refs
  */
-export const SendQueueCapacity = ServiceMap.Reference<number>("~effect/socket/Socket/SendQueueCapacity", {
+export const SendQueueCapacity = Context.Reference<number>("~effect/socket/Socket/SendQueueCapacity", {
   defaultValue: () => 16
 })
 
@@ -654,7 +706,7 @@ export const fromTransformStream = <R>(acquire: Effect.Effect<InputTransformStre
       readonly stream: InputTransformStream
       readonly fiberSet: FiberSet.FiberSet<any, any>
     } | undefined
-    const acquireServices = fiber.services as ServiceMap.ServiceMap<R>
+    const acquireServices = fiber.context as Context.Context<R>
     const closeCodeIsError = options?.closeCodeIsError ?? defaultCloseCodeIsError
     const runRaw = <_, E, R>(handler: (_: string | Uint8Array) => Effect.Effect<_, E, R> | void, opts?: {
       readonly onOpen?: Effect.Effect<void> | undefined
@@ -693,30 +745,20 @@ 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(
         (_) => _,
-        Effect.updateServices((input: ServiceMap.ServiceMap<R>) => ServiceMap.merge(acquireServices, input)),
+        Effect.updateContext((input: Context.Context<R>) => Context.merge(acquireServices, input)),
         Effect.ensuring(Effect.sync(() => {
           latch.closeUnsafe()
           currentStream = undefined
         }))
       )
 
-    const encoder = new TextEncoder()
-    const run = <_, E, R>(handler: (_: Uint8Array) => Effect.Effect<_, E, R> | void, opts?: {
-      readonly onOpen?: Effect.Effect<void> | undefined
-    }) =>
-      runRaw((data) =>
-        typeof data === "string"
-          ? handler(encoder.encode(data))
-          : handler(data), opts)
-
     const writers = new WeakMap<InputTransformStream, WritableStreamDefaultWriter<Uint8Array>>()
     const getWriter = (stream: InputTransformStream) => {
       let writer = writers.get(stream)
@@ -748,9 +790,7 @@ export const fromTransformStream = <R>(acquire: Effect.Effect<InputTransformStre
         })
     )
 
-    return Effect.succeed(Socket.of({
-      [TypeId]: TypeId,
-      run,
+    return Effect.succeed(make({
       runRaw,
       writer
     }))

package/src/unstable/socket/SocketServer.ts

@@ -1,16 +1,16 @@
 /**
  * @since 4.0.0
  */
+import * as Context from "../../Context.ts"
 import * as Data from "../../Data.ts"
 import type * as Effect from "../../Effect.ts"
-import * as ServiceMap from "../../ServiceMap.ts"
 import type * as Socket from "./Socket.ts"
 
 /**
  * @since 4.0.0
  * @category tags
  */
-export class SocketServer extends ServiceMap.Service<SocketServer, {
+export class SocketServer extends Context.Service<SocketServer, {
   readonly address: Address
   readonly run: <R, E, _>(
     handler: (socket: Socket.Socket) => Effect.Effect<_, E, R>

package/src/unstable/sql/Migrator.ts

@@ -236,11 +236,13 @@ export const make = <RD = never>({
       if (required.length > 0) {
         yield* pipe(
           insertMigrations(required.map(([id, name]) => [id, name])),
-          Effect.mapError((_) =>
-            new MigrationError({
-              kind: "Locked",
-              message: "Migrations already running"
-            })
+          Effect.mapError((error): MigrationError | SqlError =>
+            error.reason._tag === "ConstraintError"
+              ? new MigrationError({
+                kind: "Locked",
+                message: "Migrations already running"
+              })
+              : error
           )
         )
       }