effect 4.0.0-beta.44 → 4.0.0-beta.46

package/src/unstable/reactivity/AtomHttpApi.ts

@@ -30,7 +30,6 @@ export interface AtomHttpApiClient<Self, Id extends string, Groups extends HttpA
 {
   new(_: never): Context.ServiceClass.Shape<Id, HttpApiClient.Client<Groups, never, never>>
 
-  readonly layer: Layer.Layer<Self>
   readonly runtime: Atom.AtomRuntime<Self>
 
   readonly mutation: <
@@ -147,10 +146,15 @@ export const Service = <Self>() =>
   id: Id,
   options: {
     readonly api: HttpApi.HttpApi<ApiId, Groups>
-    readonly httpClient: Layer.Layer<
-      | HttpApiGroup.ClientServices<Groups>
-      | HttpClient.HttpClient
-    >
+    readonly httpClient:
+      | Layer.Layer<
+        | HttpApiGroup.ClientServices<Groups>
+        | HttpClient.HttpClient
+      >
+      | ((get: Atom.AtomContext) => Layer.Layer<
+        | HttpApiGroup.ClientServices<Groups>
+        | HttpClient.HttpClient
+      >)
     readonly transformClient?: ((client: HttpClient.HttpClient) => HttpClient.HttpClient) | undefined
     readonly transformResponse?:
       | ((effect: Effect.Effect<unknown, unknown, unknown>) => Effect.Effect<unknown, unknown, unknown>)
@@ -164,12 +168,23 @@ export const Service = <Self>() =>
     HttpApiClient.Client<Groups, never, never>
   >()(id) as any
 
-  self.layer = Layer.effect(
+  const layer = Layer.effect(
     self,
     HttpApiClient.make(options.api, options)
-  ).pipe(Layer.provide(options.httpClient)) as Layer.Layer<Self>
+  )
   const runtimeFactory = options.runtime ?? Atom.runtime
-  self.runtime = runtimeFactory(self.layer)
+  self.runtime = runtimeFactory(
+    typeof options.httpClient === "function" ?
+      (get) =>
+        Layer.provide(
+          layer,
+          (options.httpClient as (get: Atom.AtomContext) => Layer.Layer<
+            | HttpApiGroup.ClientServices<Groups>
+            | HttpClient.HttpClient
+          >)(get)
+        ) as Layer.Layer<Self> :
+      Layer.provide(layer, options.httpClient) as Layer.Layer<Self>
+  )
 
   const catchErrors = Effect.catch((e: unknown) =>
     Schema.isSchemaError(e) || HttpClientError.isHttpClientError(e) ? Effect.die(e) : Effect.fail(e)

package/src/unstable/reactivity/AtomRpc.ts

@@ -37,7 +37,6 @@ export interface AtomRpcClient<Self, Id extends string, Rpcs extends Rpc.Any> ex
     RpcClient.RpcClient.Flat<Rpcs, RpcClientError>
   >
 
-  readonly layer: Layer.Layer<Self>
   readonly runtime: Atom.AtomRuntime<Self>
 
   readonly mutation: <Tag extends Rpc.Tag<Rpcs>>(
@@ -120,7 +119,9 @@ export const Service = <Self>() =>
   id: Id,
   options: {
     readonly group: RpcGroup.RpcGroup<Rpcs>
-    readonly protocol: Layer.Layer<Exclude<NoInfer<RM>, Scope>, ER>
+    readonly protocol:
+      | Layer.Layer<Exclude<NoInfer<RM>, Scope>, ER>
+      | ((get: Atom.AtomContext) => Layer.Layer<Exclude<NoInfer<RM>, Scope>, ER>)
     readonly spanPrefix?: string | undefined
     readonly spanAttributes?: Record<string, unknown> | undefined
     readonly generateRequestId?: (() => RequestId) | undefined
@@ -140,7 +141,7 @@ export const Service = <Self>() =>
     RpcClient.RpcClient.Flat<Rpcs, RpcClientError>
   >()(id) as any
 
-  self.layer = Layer.effect(
+  const layer = Layer.effect(
     self,
     options.makeEffect ??
       (RpcClient.make(options.group, {
@@ -151,9 +152,19 @@ export const Service = <Self>() =>
         never,
         RM
       >)
-  ).pipe(Layer.provide(Layer.orDie(options.protocol)))
+  )
   const runtimeFactory = options.runtime ?? Atom.runtime
-  self.runtime = runtimeFactory(self.layer)
+  self.runtime = runtimeFactory(
+    typeof options.protocol === "function" ?
+      (get) =>
+        Layer.provide(
+          layer,
+          Layer.orDie(
+            (options.protocol as ((get: Atom.AtomContext) => Layer.Layer<Exclude<NoInfer<RM>, Scope>, ER>))(get)
+          )
+        ) :
+      Layer.provide(layer, Layer.orDie(options.protocol))
+  )
 
   self.mutation = Atom.family(<Tag extends Rpc.Tag<Rpcs>>(tag: Tag) => {
     const rpc = options.group.requests.get(tag)! as any as Rpc.AnyWithProps

package/src/unstable/rpc/Rpc.ts

@@ -13,6 +13,7 @@ import type * as Queue from "../../Queue.ts"
 import * as Schema from "../../Schema.ts"
 import type { Stream } from "../../Stream.ts"
 import type * as Struct from "../../Struct.ts"
+import type { NoInfer } from "../../Types.ts"
 import type { Headers } from "../http/Headers.ts"
 import type { RequestId } from "./RpcMessage.ts"
 import type * as RpcMiddleware from "./RpcMiddleware.ts"
@@ -134,7 +135,7 @@ export interface Rpc<
    */
   annotate<I, S>(
     tag: Context.Key<I, S>,
-    value: S
+    value: NoInfer<S>
   ): Rpc<Tag, Payload, Success, Error, Middleware, Requires>
 
   /**
@@ -145,6 +146,26 @@ export interface Rpc<
   ): Rpc<Tag, Payload, Success, Error, Middleware, Requires>
 }
 
+/**
+ * @since 4.0.0
+ * @category models
+ */
+export class ServerClient {
+  readonly id: number
+  annotations: Context.Context<never>
+  constructor(id: number) {
+    this.id = id
+    this.annotations = Context.empty()
+  }
+  annotate<I, S>(
+    tag: Context.Key<I, S>,
+    value: NoInfer<S>
+  ): ServerClient {
+    this.annotations = Context.add(this.annotations, tag, value)
+    return this
+  }
+}
+
 /**
  * Represents an implemented rpc.
  *
@@ -155,7 +176,7 @@ export interface Handler<Tag extends string> {
   readonly _: unique symbol
   readonly tag: Tag
   readonly handler: (request: any, options: {
-    readonly clientId: number
+    readonly client: ServerClient
     readonly requestId: RequestId
     readonly headers: Headers
     readonly rpc: Any
@@ -475,12 +496,12 @@ export type ToHandler<R extends Any> = R extends Rpc<
 export type ToHandlerFn<Current extends Any, R = any> = (
   payload: Payload<Current>,
   options: {
-    readonly clientId: number
+    readonly client: ServerClient
     readonly requestId: RequestId
     readonly headers: Headers
     readonly rpc: Current
   }
-) => ResultFrom<Current, R> | Wrapper<ResultFrom<Current, R>>
+) => WrapperOr<ResultFrom<Current, R>>
 
 /**
  * @since 4.0.0
@@ -810,6 +831,12 @@ export interface Wrapper<A> {
   readonly uninterruptible: boolean
 }
 
+/**
+ * @since 4.0.0
+ * @category Wrapper
+ */
+export type WrapperOr<A> = A | Wrapper<A>
+
 /**
  * @since 4.0.0
  * @category Wrapper
@@ -839,6 +866,17 @@ export const wrap = (options: {
       uninterruptible: options.uninterruptible ?? false
     }
 
+/**
+ * @since 4.0.0
+ * @category Wrapper
+ */
+export const wrapMap = <A extends object, B extends object>(self: WrapperOr<A>, f: (value: A) => B): WrapperOr<B> => {
+  if (isWrapper(self)) {
+    return wrap(self)(f(self.value))
+  }
+  return f(self)
+}
+
 /**
  * You can use `fork` to wrap a response Effect or Stream, to ensure that the
  * response is executed concurrently regardless of the RpcServer concurrency

package/src/unstable/rpc/RpcClient.ts

@@ -39,7 +39,7 @@ import type * as RpcMiddleware from "./RpcMiddleware.ts"
 import * as RpcSchema from "./RpcSchema.ts"
 import * as RpcSerialization from "./RpcSerialization.ts"
 import * as RpcWorker from "./RpcWorker.ts"
-import { withRun } from "./Utils.ts"
+import { withRunClient } from "./Utils.ts"
 
 /**
  * @since 4.0.0
@@ -587,6 +587,8 @@ export const makeNoSerialization: <Rpcs extends Rpc.Any, E, const Flatten extend
   return { client, write } as const
 })
 
+let clientIdCounter = 0
+
 /**
  * @since 4.0.0
  * @category client
@@ -614,6 +616,7 @@ export const make: <Rpcs extends Rpc.Any, const Flatten extends boolean = false>
     readonly flatten?: Flatten | undefined
   } | undefined
 ) {
+  const clientId = clientIdCounter++
   const { run, send, supportsAck, supportsTransferables } = yield* Protocol
 
   type ClientEntry = {
@@ -645,7 +648,7 @@ export const make: <Rpcs extends Rpc.Any, const Flatten extends boolean = false>
             Effect.provideContext(entry.context),
             Effect.orDie,
             Effect.flatMap((payload) =>
-              send({
+              send(clientId, {
                 ...message,
                 id: String(message.id),
                 payload,
@@ -657,7 +660,7 @@ export const make: <Rpcs extends Rpc.Any, const Flatten extends boolean = false>
         case "Ack": {
           const entry = entries.get(message.requestId)
           if (!entry) return Effect.void
-          return send({
+          return send(clientId, {
             _tag: "Ack",
             requestId: String(message.requestId)
           }) as Effect.Effect<void, RpcClientError>
@@ -666,7 +669,7 @@ export const make: <Rpcs extends Rpc.Any, const Flatten extends boolean = false>
           const entry = entries.get(message.requestId)
           if (!entry) return Effect.void
           entries.delete(message.requestId)
-          return send({
+          return send(clientId, {
             _tag: "Interrupt",
             requestId: String(message.requestId)
           }) as Effect.Effect<void, RpcClientError>
@@ -678,7 +681,7 @@ export const make: <Rpcs extends Rpc.Any, const Flatten extends boolean = false>
     }
   })
 
-  yield* run((message) => {
+  yield* run(clientId, (message) => {
     switch (message._tag) {
       case "Chunk": {
         const requestId = RequestId(message.requestId)
@@ -798,9 +801,11 @@ export const withHeaders: {
  */
 export class Protocol extends Context.Service<Protocol, {
   readonly run: (
+    clientId: number,
     f: (data: FromServerEncoded) => Effect.Effect<void>
   ) => Effect.Effect<never>
   readonly send: (
+    clientId: number,
     request: FromClientEncoded,
     transferables?: ReadonlyArray<globalThis.Transferable>
   ) => Effect.Effect<void, RpcClientError>
@@ -810,7 +815,7 @@ export class Protocol extends Context.Service<Protocol, {
   /**
    * @since 4.0.0
    */
-  static make = withRun<Protocol["Service"]>()
+  static make = withRunClient
 }
 
 /**
@@ -836,7 +841,7 @@ export const makeProtocolHttp = (client: HttpClient.HttpClient): Effect.Effect<
     const emptyResponseError = (request: FromClientEncoded) =>
       protocolDefect("Received empty HTTP response from RPC server", request)
 
-    const send = Effect.fnUntraced(function*(request: FromClientEncoded) {
+    const send = Effect.fnUntraced(function*(clientId: number, request: FromClientEncoded) {
       if (request._tag !== "Request") {
         return
       }
@@ -857,15 +862,15 @@ export const makeProtocolHttp = (client: HttpClient.HttpClient): Effect.Effect<
           catch: (cause) => protocolDefect("Error decoding HTTP response", cause)
         })
         if (!Array.isArray(responses)) {
-          return yield* Effect.fail(protocolDefect("Expected an array of responses", responses))
+          return yield* protocolDefect("Expected an array of responses", responses)
         }
         if (responses.length === 0) {
-          return yield* Effect.fail(emptyResponseError(request))
+          return yield* emptyResponseError(request)
         }
         let i = 0
         return yield* Effect.whileLoop({
           while: () => i < responses.length,
-          body: () => writeResponse(responses[i++]),
+          body: () => writeResponse(clientId, responses[i++]),
           step: constVoid
         })
       }
@@ -882,7 +887,7 @@ export const makeProtocolHttp = (client: HttpClient.HttpClient): Effect.Effect<
             let i = 0
             return Effect.whileLoop({
               while: () => i < responses.length,
-              body: () => writeResponse(responses[i++]),
+              body: () => writeResponse(clientId, responses[i++]),
               step: constVoid
             })
           })
@@ -890,7 +895,7 @@ export const makeProtocolHttp = (client: HttpClient.HttpClient): Effect.Effect<
           Effect.mapError((cause) => cause instanceof RpcClientError ? cause : httpClientError(cause))
         )
       if (!hasResponse) {
-        return yield* Effect.fail(emptyResponseError(request))
+        return yield* emptyResponseError(request)
       }
     })
 
@@ -931,10 +936,11 @@ export const makeProtocolSocket = (options?: {
   never,
   Scope.Scope | RpcSerialization.RpcSerialization | Socket.Socket
 > =>
-  Protocol.make(Effect.fnUntraced(function*(writeResponse) {
+  Protocol.make(Effect.fnUntraced(function*(writeResponse, clientIds) {
     const socket = yield* Socket.Socket
     const serialization = yield* RpcSerialization.RpcSerialization
     const hooks = yield* Effect.serviceOption(ConnectionHooks)
+    const requestClientMap = new Map<string, number>()
 
     const write = yield* socket.writer
 
@@ -947,6 +953,9 @@ export const makeProtocolSocket = (options?: {
       return Option.isSome(hooks) ? hooks.value.onConnect : Effect.void
     })
 
+    const broadcast = (response: FromServerEncoded) =>
+      Effect.forEach(clientIds, (clientId) => writeResponse(clientId, response))
+
     yield* Effect.suspend(() => {
       parser = serialization.makeUnsafe()
       pinger.reset()
@@ -961,13 +970,23 @@ export const makeProtocolSocket = (options?: {
               const response = responses[i++]
               if (response._tag === "Pong") {
                 pinger.onPong()
+                return Effect.void
               }
-              return writeResponse(response)
+              if ("requestId" in response) {
+                const clientId = requestClientMap.get(response.requestId)
+                if (clientId !== undefined) {
+                  if (response._tag === "Exit") {
+                    requestClientMap.delete(response.requestId)
+                  }
+                  return writeResponse(clientId, response)
+                }
+              }
+              return broadcast(response)
             },
             step: constVoid
           })
         } catch (defect) {
-          return writeResponse({
+          return broadcast({
             _tag: "ClientProtocolError",
             error: new RpcClientError({
               reason: new RpcClientDefect({
@@ -1011,7 +1030,7 @@ export const makeProtocolSocket = (options?: {
             cause: Cause.squash(cause)
           })
         })
-        return writeResponse({
+        return broadcast({
           _tag: "ClientProtocolError",
           error: currentError
         })
@@ -1025,10 +1044,13 @@ export const makeProtocolSocket = (options?: {
     )
 
     return {
-      send(request) {
+      send(clientId, request) {
         if (currentError) {
           return Effect.fail(currentError)
         }
+        if (request._tag === "Request") {
+          requestClientMap.set(request.id, clientId)
+        }
         const encoded = parser.encode(request)
         if (encoded === undefined) return Effect.void
         return Effect.orDie(write(encoded))
@@ -1099,7 +1121,7 @@ export const makeProtocolWorker = (
   WorkerError,
   Scope.Scope | Worker.WorkerPlatform | Worker.Spawner
 > =>
-  Protocol.make(Effect.fnUntraced(function*(writeResponse) {
+  Protocol.make(Effect.fnUntraced(function*(writeResponse, clientIds) {
     const worker = yield* Worker.WorkerPlatform
     const scope = yield* Effect.scope
     let workerId = 0
@@ -1107,10 +1129,14 @@ export const makeProtocolWorker = (
     const hooks = yield* Effect.serviceOption(ConnectionHooks)
 
     const entries = new Map<string, {
+      readonly clientId: number
       readonly worker: Worker.Worker<FromServerEncoded, FromClientEncoded | RpcWorker.InitialMessage.Encoded>
       readonly latch: Latch.Latch
     }>()
 
+    const broadcast = (response: FromServerEncoded) =>
+      Effect.forEach(clientIds, (clientId) => writeResponse(clientId, response))
+
     const acquire = Effect.gen(function*() {
       const id = workerId++
       const backing = yield* worker.spawn<FromServerEncoded, FromClientEncoded | RpcWorker.InitialMessage.Encoded>(id)
@@ -1121,16 +1147,21 @@ export const makeProtocolWorker = (
           if (entry) {
             entries.delete(response.requestId)
             entry.latch.openUnsafe()
-            return writeResponse(response)
+            return writeResponse(entry.clientId, response)
           }
         } else if (response._tag === "Defect") {
           for (const [requestId, entry] of entries) {
             entries.delete(requestId)
             entry.latch.openUnsafe()
           }
-          return writeResponse(response)
+          return broadcast(response)
+        } else if ("requestId" in response) {
+          const entry = entries.get(response.requestId)
+          if (entry) {
+            return writeResponse(entry.clientId, response)
+          }
         }
-        return writeResponse(response)
+        return broadcast(response)
       }, {
         onSpawn: Option.isSome(initialMessage) ?
           Effect.flatMap(
@@ -1141,7 +1172,7 @@ export const makeProtocolWorker = (
       }).pipe(
         Effect.tapCause((cause) => {
           const error = Cause.findError(cause)
-          return writeResponse({
+          return broadcast({
             _tag: "ClientProtocolError",
             error: new RpcClientError({
               reason: Result.isSuccess(error) ? error.success.reason : new RpcClientDefect({
@@ -1189,13 +1220,17 @@ export const makeProtocolWorker = (
       })
     )
 
-    const send = (request: FromClientEncoded, transferables?: ReadonlyArray<globalThis.Transferable>) => {
+    const send = (
+      clientId: number,
+      request: FromClientEncoded,
+      transferables?: ReadonlyArray<globalThis.Transferable>
+    ) => {
       switch (request._tag) {
         case "Request": {
           return Pool.get(pool).pipe(
             Effect.flatMap((worker) => {
               const latch = Latch.makeUnsafe(false)
-              entries.set(request.id, { worker, latch })
+              entries.set(request.id, { clientId, worker, latch })
               return Effect.flatMap(worker.send(request, transferables), () => latch.await)
             }),
             Effect.scoped,

package/src/unstable/rpc/RpcGroup.ts

@@ -119,7 +119,7 @@ export interface RpcGroup<in out R extends Rpc.Any> extends Pipeable {
     (
       payload: Rpc.Payload<Extract<R, { readonly _tag: Tag }>>,
       options: {
-        readonly clientId: number
+        readonly client: Rpc.ServerClient
         readonly requestId: RequestId
         readonly headers: Headers
       }

package/src/unstable/rpc/RpcMiddleware.ts

@@ -31,7 +31,7 @@ export interface RpcMiddleware<Provides, E, Requires> {
   (
     effect: Effect.Effect<SuccessValue, E | unhandled, Provides>,
     options: {
-      readonly clientId: number
+      readonly client: Rpc.ServerClient
       readonly requestId: RequestId
       readonly rpc: Rpc.AnyWithProps
       readonly payload: unknown
@@ -77,7 +77,7 @@ export interface Any {
   (
     effect: Effect.Effect<SuccessValue, any, any>,
     options: {
-      readonly clientId: number
+      readonly client: Rpc.ServerClient
       readonly requestId: RequestId
       readonly rpc: Rpc.AnyWithProps
       readonly payload: unknown

package/src/unstable/rpc/RpcServer.ts

@@ -109,6 +109,7 @@ export const makeNoSerialization: <Rpcs extends Rpc.Any>(
     readonly id: number
     readonly latches: Map<RequestId, Latch.Latch>
     readonly fibers: Map<RequestId, Fiber.Fiber<unknown, any>>
+    readonly serverClient: Rpc.ServerClient
     ended: boolean
   }
 
@@ -157,7 +158,8 @@ export const makeNoSerialization: <Rpcs extends Rpc.Any>(
             id: clientId,
             latches: new Map(),
             fibers: new Map(),
-            ended: false
+            ended: false,
+            serverClient: new Rpc.ServerClient(clientId)
           }
           clients.set(clientId, client)
         } else if (client.ended) {
@@ -236,7 +238,7 @@ export const makeNoSerialization: <Rpcs extends Rpc.Any>(
     const isStream = RpcSchema.isStreamSchema(rpc.successSchema)
     const metadata = {
       rpc,
-      clientId: client.id,
+      client: client.serverClient,
       requestId: request.id,
       headers: request.headers,
       payload: request.payload
@@ -410,7 +412,7 @@ const applyMiddleware = <A, E, R>(
   handler: Effect.Effect<A, E, R>,
   options: {
     readonly rpc: Rpc.AnyWithProps
-    readonly clientId: number
+    readonly client: Rpc.ServerClient
     readonly requestId: RequestId
     readonly headers: Headers.Headers
     readonly payload: A

package/src/unstable/rpc/Utils.ts

@@ -4,6 +4,8 @@
 import type * as Context from "../../Context.ts"
 import * as Effect from "../../Effect.ts"
 import * as Semaphore from "../../Semaphore.ts"
+import type { Protocol } from "./RpcClient.ts"
+import type { FromServerEncoded } from "./RpcMessage.ts"
 
 /**
  * @since 4.0.0
@@ -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

@@ -581,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,
@@ -599,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>
   }>
@@ -619,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.