@livestore/utils 0.4.0 → 0.5.0-dev.1

package/src/effect/RpcClient.ts

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

package/src/effect/Schedule.ts

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

package/src/effect/Schema/debug-diff.test.ts

@@ -8,7 +8,7 @@ describe('debug-diff', () => {
   test('simple object', () => {
     const schema = Schema.Struct({
       a: Schema.String,
-      b: Schema.Number,
+      b: Schema.Finite,
     })
 
     const a = { a: 'hello', b: 1 }
@@ -35,7 +35,7 @@ describe('debug-diff', () => {
     const schema = Schema.Struct({
       a: Schema.String,
       b: Schema.Struct({
-        c: Schema.Number,
+        c: Schema.Finite,
       }),
     })
     const a = { a: 'hello', b: { c: 1 } }
@@ -58,7 +58,7 @@ describe('debug-diff', () => {
   })
 
   test('union', () => {
-    const schema = Schema.Union(Schema.String, Schema.Number)
+    const schema = Schema.Union([Schema.String, Schema.Finite])
     const a = 'hello'
     const b = 1
     const diff = debugDiff(schema)(a, b)
@@ -74,10 +74,10 @@ describe('debug-diff', () => {
   })
 
   test('tagged union', () => {
-    const schema = Schema.Union(
+    const schema = Schema.Union([
       Schema.TaggedStruct('a', { a: Schema.String }),
-      Schema.TaggedStruct('b', { b: Schema.Number }),
-    )
+      Schema.TaggedStruct('b', { b: Schema.Finite }),
+    ])
     const a = { _tag: 'a', a: 'hello' } as const
     const b = { _tag: 'b', b: 1 } as const
     const diff = debugDiff(schema)(a, b)

package/src/effect/Schema/debug-diff.ts

@@ -11,7 +11,7 @@ export type DiffItem = {
  * Diffs two values for a given schema and traverses downwards and returns a list of differences.
  */
 export const debugDiff =
-  <A, I, R>(base: Schema.Schema<A, I, R>) =>
+  <A, I, R>(base: Schema.Top) =>
   (a: A, b: A): DiffItem[] => {
     const bag = [] as DiffItem[]
     debugDiffImpl(base.ast, a, b, '', bag)
@@ -19,7 +19,7 @@ export const debugDiff =
   }
 
 const debugDiffImpl = (ast: SchemaAST.AST, a: any, b: any, path: string, bag: DiffItem[]) => {
-  const eq = Schema.equivalence({ ast } as any)
+  const eq = Schema.toEquivalence({ ast } as any)
   if (eq(a, b) === false) {
     // bag.push({ path, a, b, ast })
 
@@ -35,9 +35,8 @@ const debugDiffImpl = (ast: SchemaAST.AST, a: any, b: any, path: string, bag: Di
           } catch {}
         }
       }
-    } else if (SchemaAST.isTypeLiteral(ast) === true) {
-      const props = SchemaAST.getPropertySignatures(ast)
-      for (const prop of props) {
+    } else if (SchemaAST.isObjects(ast) === true) {
+      for (const prop of ast.propertySignatures) {
         debugDiffImpl(prop.type, a[prop.name], b[prop.name], `${path}.${prop.name.toString()}`, bag)
       }
     } else {
@@ -50,9 +49,8 @@ const debugDiffImpl = (ast: SchemaAST.AST, a: any, b: any, path: string, bag: Di
 const isTaggedUnion = (ast: SchemaAST.AST): boolean => {
   if (SchemaAST.isUnion(ast) === true) {
     return ast.types.every((type) => {
-      if (SchemaAST.isTypeLiteral(type) === false) return false
-      const props = SchemaAST.getPropertySignatures(type)
-      return props.some((prop) => prop.name.toString() === '_tag')
+      if (SchemaAST.isObjects(type) === false) return false
+      return type.propertySignatures.some((prop) => prop.name.toString() === '_tag')
     })
   }
   return false

package/src/effect/Schema/index.ts

@@ -1,18 +1,115 @@
-import { Transferable } from '@effect/platform'
-import { Effect, Hash, ParseResult, Schema } from 'effect'
-import type { ParseError } from 'effect/ParseResult'
-import type { ParseOptions } from 'effect/SchemaAST'
-import * as SchemaAST from 'effect/SchemaAST'
-
-import { shouldNeverHappen } from '../../mod.ts'
+import {
+  Array,
+  Effect,
+  Function,
+  Hash,
+  Option,
+  Result,
+  Schema,
+  SchemaAST,
+  SchemaGetter,
+  SchemaIssue,
+  SchemaTransformation,
+  Struct,
+} from 'effect'
+import { Transferable } from 'effect/workers'
+
+import { shouldNeverHappen } from '../../misc.ts'
 
 export * from 'effect/Schema'
 export * from './debug-diff.ts'
 
+type PluckSchema<Fields extends Schema.Struct.Fields, K extends keyof Fields> = Schema.Codec<
+  Fields[K]['Type'],
+  Schema.Struct<Pick<Fields, K>>['Encoded'],
+  Schema.Struct<Pick<Fields, K>>['DecodingServices'],
+  Schema.Struct<Pick<Fields, K>>['EncodingServices']
+>
+
+export const pluck =
+  <const K extends PropertyKey>(key: K) =>
+  <Fields extends { readonly [P in K]: Schema.Top }>(
+    schema: Schema.Struct<Fields>,
+  ): PluckSchema<Fields, K & keyof Fields> => {
+    const field = schema.fields[key] as Fields[K & keyof Fields]
+
+    return schema.mapFields(Struct.pick([key])).pipe(
+      Schema.decodeTo(Schema.toType(field), {
+        decode: SchemaGetter.transform((whole: any) => whole[key]),
+        encode: SchemaGetter.transform((value) => ({ [key]: value }) as any),
+      }),
+    ) as unknown as PluckSchema<Fields, K & keyof Fields>
+  }
+
+/**
+ * Like {@link fromJsonString}, but the ENCODED form is an *indented* JSON string
+ * (default 2-space) instead of compact — for committed/human-read JSON files
+ * (package.json, release plans, CI previews) that must stay diff-friendly while
+ * still round-tripping through the schema.
+ *
+ * Use a concrete schema for known shapes (adds validation) or `Schema.Unknown`
+ * for open-ended ones (the indented analogue of `fromJsonString(Schema.Unknown)`).
+ *
+ * TODO collapse into `fromJsonString(schema, { space })` now that Effect 4 accepts a
+ * `space` option; kept separate here to keep the Effect upgrade free of release-tooling changes.
+ */
+export const jsonStringIndented = <S extends Schema.Top>(schema: S, space: number | string = 2) =>
+  schema.pipe(
+    Schema.encodeTo(Schema.String, {
+      decode: SchemaGetter.parseJson(),
+      encode: SchemaGetter.stringifyJson({ space }),
+    }),
+  )
+
+export const head = <S extends Schema.Top>(
+  array: Schema.$Array<S>,
+): Schema.decodeTo<Schema.Option<Schema.toType<S>>, Schema.$Array<S>> =>
+  array.pipe(
+    Schema.decodeTo(
+      Schema.Option(Schema.toType(array.value)),
+      SchemaTransformation.transform({
+        decode: Array.head,
+        encode: Option.match({
+          onNone: () => [],
+          onSome: Array.of,
+        }),
+      }),
+    ),
+  )
+
+type HeadOrElse<S extends Schema.Top> = Schema.decodeTo<Schema.toType<S>, Schema.$Array<S>>
+
+export const headOrElse: {
+  <S extends Schema.Top>(array: Schema.$Array<S>, orElse?: () => S['Type']): HeadOrElse<S>
+  (): <S extends Schema.Top>(array: Schema.$Array<S>) => HeadOrElse<S>
+  <S extends Schema.Top>(orElse: () => S['Type']): (array: Schema.$Array<S>) => HeadOrElse<S>
+} = Function.dual(
+  (args) => Schema.isSchema(args[0]),
+  <S extends Schema.Top>(array: Schema.$Array<S>, orElse?: () => S['Type']): HeadOrElse<S> =>
+    array.pipe(
+      Schema.decodeTo(
+        Schema.toType(array.value),
+        SchemaTransformation.transformEffect({
+          decode: (array) =>
+            Array.isReadonlyArrayNonEmpty(array) === true
+              ? Effect.succeed(Array.headNonEmpty(array))
+              : orElse === undefined
+                ? Effect.fail(
+                    new SchemaIssue.InvalidValue({
+                      message: 'Unable to retrieve the first element of an empty array',
+                    }),
+                  )
+                : Effect.succeed(orElse()),
+          encode: (value) => Effect.succeed(Array.of(value)),
+        }),
+      ),
+    ),
+)
+
 // NOTE this is a temporary workaround until Effect schema has a better way to hash schemas
 // https://github.com/Effect-TS/effect/issues/2719
 // TODO remove this once the issue is resolved
-export const hash = (schema: Schema.Schema<any>) => {
+export const hash = (schema: Schema.Top) => {
   try {
     return Hash.string(JSON.stringify(schema.ast, null, 2))
   } catch {
@@ -23,80 +120,44 @@ export const hash = (schema: Schema.Schema<any>) => {
   }
 }
 
-const resolveStructAst = (ast: SchemaAST.AST): SchemaAST.AST => {
-  if (SchemaAST.isTransformation(ast) === true) {
-    return resolveStructAst(ast.from)
-  }
-
-  return ast
+export const getResolvedPropertySignatures = (schema: Schema.Top): ReadonlyArray<SchemaAST.PropertySignature> => {
+  const resolvedAst = SchemaAST.toType(schema.ast)
+  return SchemaAST.isObjects(resolvedAst) === true ? resolvedAst.propertySignatures : []
 }
 
-export const getResolvedPropertySignatures = (
-  schema: Schema.Schema.AnyNoContext,
-): ReadonlyArray<SchemaAST.PropertySignature> => {
-  const resolvedAst = resolveStructAst(schema.ast)
-  return SchemaAST.getPropertySignatures(resolvedAst)
-}
-
-/** Objects that can be transferred between contexts (workers, etc.) */
-type TransferableObject = ArrayBuffer | MessagePort
-
 export const encodeWithTransferables =
-  <A, I, R>(schema: Schema.Schema<A, I, R>, options?: ParseOptions) =>
-  (a: A, overrideOptions?: ParseOptions): Effect.Effect<[I, TransferableObject[]], ParseError, R> =>
+  <A, I>(schema: Schema.Codec<A, I>, options?: SchemaAST.ParseOptions) =>
+  (a: A, overrideOptions?: SchemaAST.ParseOptions) =>
     Effect.gen(function* () {
       const collector = yield* Transferable.makeCollector
 
-      const encoded: I = yield* Schema.encode(schema, options)(a, overrideOptions).pipe(
+      const encoded = yield* Schema.encodeEffect(schema, options)(a, overrideOptions).pipe(
         Effect.provideService(Transferable.Collector, collector),
       )
 
-      return [encoded, collector.unsafeRead() as TransferableObject[]]
+      return [encoded, collector.readUnsafe()] as const
     })
 
 export const decodeSyncDebug: <A, I>(
-  schema: Schema.Schema<A, I>,
+  schema: Schema.Codec<A, I>,
   options?: SchemaAST.ParseOptions,
 ) => (i: I, overrideOptions?: SchemaAST.ParseOptions) => A = (schema, options) => (input, overrideOptions) => {
-  const res = Schema.decodeEither(schema, options)(input, overrideOptions)
-  if (res._tag === 'Left') {
-    return shouldNeverHappen(`decodeSyncDebug failed:`, res.left)
+  const res = Schema.decodeResult(schema, options)(input, overrideOptions)
+  if (Result.isFailure(res) === true) {
+    return shouldNeverHappen(`decodeSyncDebug failed:`, res.failure)
   } else {
-    return res.right
+    return res.success
   }
 }
 
 export const encodeSyncDebug: <A, I>(
-  schema: Schema.Schema<A, I>,
+  schema: Schema.Codec<A, I>,
   options?: SchemaAST.ParseOptions,
 ) => (a: A, overrideOptions?: SchemaAST.ParseOptions) => I = (schema, options) => (input, overrideOptions) => {
-  const res = Schema.encodeEither(schema, options)(input, overrideOptions)
-  if (res._tag === 'Left') {
-    return shouldNeverHappen(`encodeSyncDebug failed:`, res.left)
+  const res = Schema.encodeResult(schema, options)(input, overrideOptions)
+  if (Result.isFailure(res) === true) {
+    return shouldNeverHappen(`encodeSyncDebug failed:`, res.failure)
   } else {
-    return res.right
+    return res.success
   }
 }
-
-export const swap = <A, I, R>(schema: Schema.Schema<A, I, R>): Schema.Schema<I, A, R> =>
-  Schema.transformOrFail(Schema.typeSchema(schema), Schema.encodedSchema(schema), {
-    decode: ParseResult.encode(schema),
-    encode: ParseResult.decode(schema),
-  })
-
-export const Base64FromUint8Array: Schema.Schema<string, Uint8Array> = swap(Schema.Uint8ArrayFromBase64)
-
-export interface JsonArray extends ReadonlyArray<JsonValue> {}
-export interface JsonObject {
-  [key: string]: JsonValue
-}
-export type JsonValue = string | number | boolean | null | JsonObject | JsonArray
-
-export const JsonValue: Schema.Schema<JsonValue> = Schema.Union(
-  Schema.String,
-  Schema.Number,
-  Schema.Boolean,
-  Schema.Null,
-  Schema.Array(Schema.suspend(() => JsonValue)),
-  Schema.Record({ key: Schema.String, value: Schema.suspend(() => JsonValue) }),
-).annotations({ identifier: 'JsonValue' })