effect 4.0.0-beta.5 → 4.0.0-beta.50

package/src/unstable/rpc/RpcServer.ts

@@ -3,21 +3,23 @@
  */
 import type { NonEmptyReadonlyArray } from "../../Array.ts"
 import * as Cause from "../../Cause.ts"
+import * as Context from "../../Context.ts"
 import * as Deferred from "../../Deferred.ts"
 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 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 ServiceMap from "../../ServiceMap.ts"
+import * as Semaphore from "../../Semaphore.ts"
 import { Stdio } from "../../Stdio.ts"
 import * as Stream from "../../Stream.ts"
 import * as Tracer from "../../Tracer.ts"
@@ -96,23 +98,24 @@ export const makeNoSerialization: <Rpcs extends Rpc.Any>(
   const spanPrefix = options.spanPrefix ?? "RpcServer"
   const concurrency = options.concurrency ?? "unbounded"
   const disableFatalDefects = options.disableFatalDefects ?? false
-  const services = yield* Effect.services<Rpc.ToHandler<Rpcs> | Scope.Scope>()
-  const scope = ServiceMap.get(services, Scope.Scope)
+  const services = yield* Effect.context<Rpc.ToHandler<Rpcs> | Scope.Scope>()
+  const scope = Context.get(services, Scope.Scope)
   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>>
+    readonly serverClient: Rpc.ServerClient
     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) => {
@@ -155,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) {
@@ -172,17 +176,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
@@ -235,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
@@ -249,32 +252,52 @@ export const makeNoSerialization: <Rpcs extends Rpc.Any>(
     // unwrap the fork data type
     const streamOrEffect = isWrapper ? result.value : result
     const handler = isStream
-      ? (streamEffect(client, request, streamOrEffect) as Effect.Effect<any>)
-      : (streamOrEffect as Effect.Effect<any>)
+      ? (streamEffect(client, request, streamOrEffect) as Effect.Effect<{} | Deferred.Deferred<any, any>>)
+      : (streamOrEffect as Effect.Effect<{} | Deferred.Deferred<any, any>>)
 
     const withMiddleware = rpc.middlewares.size > 0
       ? applyMiddleware(services, handler, metadata)
       : handler
     let responded = false
     const scope = Scope.makeUnsafe()
+    let deferred: Deferred.Deferred<unknown, unknown> | undefined = undefined
     let effect = Effect.onExit(withMiddleware, (exit) => {
       responded = true
-      const close = Scope.closeUnsafe(scope, exit)
-      const write = exit._tag === "Failure" &&
-          !disableFatalDefects &&
-          Cause.hasDies(exit.cause) &&
-          !Cause.hasInterrupts(exit.cause)
-        ? sendDefect(client, Cause.squash(exit.cause))
-        : options.onFromServer({
+      let write: Effect.Effect<void>
+      if (exit._tag === "Success") {
+        if (Deferred.isDeferred(exit.value)) {
+          deferred = exit.value
+          write = Effect.void
+        } else {
+          write = options.onFromServer({
+            _tag: "Exit",
+            clientId: client.id,
+            requestId: request.id,
+            exit: exit as any
+          })
+        }
+      } else if (
+        !disableFatalDefects &&
+        Cause.hasDies(exit.cause) &&
+        !Cause.hasInterrupts(exit.cause)
+      ) {
+        write = sendDefect(client, Cause.squash(exit.cause))
+      } else {
+        write = options.onFromServer({
           _tag: "Exit",
           clientId: client.id,
           requestId: request.id,
-          exit
+          exit: exit as any
         })
+      }
+      const close = Scope.closeUnsafe(scope, exit)
+      if (exit._tag === "Failure") {
+        reportCauseUnsafe(Fiber.getCurrent()!, exit.cause)
+      }
       return close ? Effect.ensuring(write, close) : write
     })
     if (enableTracing) {
-      const parentSpan = requestFiber.services.mapUnsafe.get(
+      const parentSpan = requestFiber.context.mapUnsafe.get(
         Tracer.ParentSpan.key
       ) as Tracer.AnySpan | undefined
       effect = Effect.withSpan(effect, `${spanPrefix}.${request.tag}`, {
@@ -298,12 +321,12 @@ export const makeNoSerialization: <Rpcs extends Rpc.Any>(
       })
     }
     if (!isFork && concurrencySemaphore) {
-      effect = concurrencySemaphore.withPermits(1)(effect)
+      effect = concurrencySemaphore.withPermit(effect)
     }
-    const serviceMap = new Map(entry.services.mapUnsafe)
-    serviceMap.forEach((value, key) => serviceMap.set(key, value))
-    serviceMap.set(Scope.Scope.key, scope)
-    const runFork = Effect.runForkWith(ServiceMap.makeUnsafe(serviceMap))
+    const context = new Map(entry.context.mapUnsafe)
+    requestFiber.context.mapUnsafe.forEach((value, key) => context.set(key, value))
+    context.set(Scope.Scope.key, scope)
+    const runFork = Effect.runForkWith(Context.makeUnsafe(context))
     const fiber = trackFiber(
       runFork(
         effect,
@@ -311,7 +334,20 @@ export const makeNoSerialization: <Rpcs extends Rpc.Any>(
       )
     )
     client.fibers.set(request.id, fiber)
-    fiber.addObserver((exit) => {
+    fiber.addObserver(function onExit(exit: Exit.Exit<any, any>): void {
+      if (deferred) {
+        const fiber = trackFiber(runFork(Effect.onExit(Deferred.await(deferred), (exit) =>
+          options.onFromServer({
+            _tag: "Exit",
+            clientId: client.id,
+            requestId: request.id,
+            exit: exit as any
+          }))))
+        client.fibers.set(request.id, fiber)
+        deferred = undefined
+        fiber.addObserver(onExit)
+        return
+      }
       if (!responded && exit._tag === "Failure") {
         trackFiber(
           runFork(
@@ -342,7 +378,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)) {
@@ -402,18 +438,18 @@ export const makeNoSerialization: <Rpcs extends Rpc.Any>(
 })
 
 const applyMiddleware = <A, E, R>(
-  services: ServiceMap.ServiceMap<never>,
+  context: Context.Context<never>,
   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
+    readonly payload: unknown
   }
 ) => {
   for (const service of options.rpc.middlewares) {
-    const middleware = ServiceMap.getUnsafe(services, service)
+    const middleware = Context.getUnsafe(context, service)
     handler = middleware(handler as any, options) as any
   }
 
@@ -461,7 +497,7 @@ export const make: <Rpcs extends Rpc.Any>(
     supportsSpanPropagation,
     supportsTransferables
   } = yield* Protocol
-  const services = yield* Effect.services<Rpc.ToHandler<Rpcs> | Rpc.Middleware<Rpcs>>()
+  const services = yield* Effect.context<Rpc.ToHandler<Rpcs> | Rpc.Middleware<Rpcs>>()
   const scope = yield* Scope.make()
 
   const server = yield* makeNoSerialization(group, {
@@ -480,7 +516,7 @@ export const make: <Rpcs extends Rpc.Any>(
             response.requestId,
             schemas.encodeDefect,
             schemas.collector,
-            Effect.provideServices(schemas.encodeChunk(response.values), schemas.services),
+            Effect.provideContext(schemas.encodeChunk(response.values), schemas.context),
             (values) => ({ _tag: "Chunk", requestId: String(response.requestId), values })
           )
         }
@@ -493,7 +529,7 @@ export const make: <Rpcs extends Rpc.Any>(
             response.requestId,
             schemas.encodeDefect,
             schemas.collector,
-            Effect.provideServices(schemas.encodeExit(response.exit), schemas.services),
+            Effect.provideContext(schemas.encodeExit(response.exit), schemas.context),
             (exit) => ({ _tag: "Exit", requestId: String(response.requestId), exit })
           )
         }
@@ -529,7 +565,7 @@ export const make: <Rpcs extends Rpc.Any>(
     ) => Effect.Effect<NonEmptyReadonlyArray<unknown>, Schema.SchemaError>
     readonly encodeExit: (u: unknown) => Effect.Effect<ResponseExitEncoded["exit"], Schema.SchemaError>
     readonly encodeDefect: (u: unknown) => Effect.Effect<unknown, Schema.SchemaError>
-    readonly services: ServiceMap.ServiceMap<never>
+    readonly context: Context.Context<never>
     readonly collector?: Transferable.Collector["Service"] | undefined
   }
 
@@ -543,12 +579,12 @@ export const make: <Rpcs extends Rpc.Any>(
         decode: Schema.decodeUnknownEffect(Schema.toCodecJson(rpc.payloadSchema)) as any,
         encodeChunk: Schema.encodeUnknownEffect(
           Schema.toCodecJson(
-            Schema.Array(streamSchemas ? streamSchemas.success : Schema.Any)
+            Schema.Array(Option.isSome(streamSchemas) ? streamSchemas.value.success : Schema.Any)
           )
         ) as any,
         encodeExit: Schema.encodeUnknownEffect(Schema.toCodecJson(Rpc.exitSchema(rpc as any))) as any,
         encodeDefect: Schema.encodeUnknownEffect(Schema.toCodecJson(rpc.defectSchema)) as any,
-        services: entry.services
+        context: entry.context
       }
       schemasCache.set(rpc, schemas)
     }
@@ -644,7 +680,7 @@ export const make: <Rpcs extends Rpc.Any>(
         }
         const schemas = getSchemas(rpc as any)
         return Effect.matchEffect(
-          Effect.provideServices(schemas.decode(request.payload), schemas.services),
+          Effect.provideContext(schemas.decode(request.payload), schemas.context),
           {
             onFailure: (error) => sendRequestDefect(client, requestId, schemas.encodeDefect, error.issue.toString()),
             onSuccess: (payload) => {
@@ -735,6 +771,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,
@@ -756,7 +793,7 @@ export const layerHttp = <Rpcs extends Rpc.Any>(options: {
  * @since 4.0.0
  * @category protocol
  */
-export class Protocol extends ServiceMap.Service<
+export class Protocol extends Context.Service<
   Protocol,
   {
     readonly run: (
@@ -915,8 +952,8 @@ export const makeProtocolWithHttpEffect: Effect.Effect<
     Scope.Scope | HttpServerRequest.HttpServerRequest
   > = Effect.gen(function*() {
     const fiber = Fiber.getCurrent()!
-    const request = ServiceMap.getUnsafe(fiber.services, HttpServerRequest.HttpServerRequest)
-    const scope = ServiceMap.getUnsafe(fiber.services, Scope.Scope)
+    const request = Context.getUnsafe(fiber.context, HttpServerRequest.HttpServerRequest)
+    const scope = Context.getUnsafe(fiber.context, Scope.Scope)
     const requestHeaders = Object.entries(request.headers)
     const data = yield* Effect.orDie<string | Uint8Array, any, never>(
       isBinary ? Effect.map(request.arrayBuffer, (buf) => new Uint8Array(buf)) : request.text
@@ -1076,6 +1113,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 +1129,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 +1151,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 +1167,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 +1213,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
     )
@@ -1236,7 +1277,7 @@ export const makeProtocolWorkerRunner: Effect.Effect<
     Effect.tapCause(Effect.logError),
     Effect.onExit(() =>
       Effect.sync(() => {
-        fiber.currentScheduler.scheduleTask(() => fiber.interruptUnsafe(fiber.id), 0)
+        fiber.currentDispatcher.scheduleTask(() => fiber.interruptUnsafe(fiber.id), 0)
       })
     ),
     Effect.forkScoped
@@ -1276,14 +1317,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 +1398,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/RpcWorker.ts

@@ -2,10 +2,10 @@
  * @since 4.0.0
  */
 import type { NoSuchElementError } from "../../Cause.ts"
+import * as Context from "../../Context.ts"
 import * as Effect from "../../Effect.ts"
 import * as Layer from "../../Layer.ts"
 import * as Schema from "../../Schema.ts"
-import * as ServiceMap from "../../ServiceMap.ts"
 import * as Transferable from "../workers/Transferable.ts"
 import type { Protocol } from "./RpcServer.ts"
 
@@ -13,7 +13,7 @@ import type { Protocol } from "./RpcServer.ts"
  * @since 4.0.0
  * @category initial message
  */
-export class InitialMessage extends ServiceMap.Service<
+export class InitialMessage extends Context.Service<
   InitialMessage,
   Effect.Effect<
     readonly [
@@ -38,7 +38,7 @@ export declare namespace InitialMessage {
   }
 }
 
-const ProtocolTag: typeof Protocol = ServiceMap.Service("@effect/rpc/RpcServer/Protocol") as any
+const ProtocolTag: typeof Protocol = Context.Service("@effect/rpc/RpcServer/Protocol") as any
 
 /**
  * @since 4.0.0
@@ -71,9 +71,9 @@ export const layerInitialMessage = <S extends Schema.Top, R2>(
   build: Effect.Effect<S["Type"], never, R2>
 ): Layer.Layer<InitialMessage, never, S["EncodingServices"] | R2> =>
   Layer.effect(InitialMessage)(
-    Effect.servicesWith((services: ServiceMap.ServiceMap<S["EncodingServices"] | R2>) =>
+    Effect.contextWith((context: Context.Context<S["EncodingServices"] | R2>) =>
       Effect.succeed(
-        Effect.provideServices(Effect.orDie(makeInitialMessage(schema, build)), services)
+        Effect.provideContext(Effect.orDie(makeInitialMessage(schema, build)), context)
       )
     )
   )

package/src/unstable/rpc/Utils.ts

@@ -1,8 +1,11 @@
 /**
  * @since 4.0.0
  */
+import type * as Context from "../../Context.ts"
 import * as Effect from "../../Effect.ts"
-import type * as ServiceMap from "../../ServiceMap.ts"
+import * as Semaphore from "../../Semaphore.ts"
+import type { Protocol } from "./RpcClient.ts"
+import type { FromServerEncoded } from "./RpcMessage.ts"
 
 /**
  * @since 4.0.0
@@ -14,10 +17,10 @@ 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)
-    let buffer: Array<[Array<any>, ServiceMap.ServiceMap<never>]> = []
+    const semaphore = Semaphore.makeUnsafe(1)
+    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
       })
@@ -29,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 = []
 
@@ -41,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.