@livestore/utils 0.4.0-dev.9 → 0.5.0-dev.0

package/src/effect/RpcClient.ts

@@ -1,11 +1,11 @@
-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'
+export * from 'effect/unstable/rpc/RpcClient'
+
+import { Cause, Deferred, Effect, Function, Latch, Layer, References, Result, Schedule, type Scope } from 'effect'
+import { RpcClient, RpcClientError, RpcSerialization } from 'effect/unstable/rpc'
+import { Protocol } from 'effect/unstable/rpc/RpcClient'
+import { constPing, type FromServerEncoded } from 'effect/unstable/rpc/RpcMessage'
+import { Socket } from 'effect/unstable/socket'
+
 import * as SubscriptionRef from './SubscriptionRef.ts'
 
 // This is based on `makeProtocolSocket` / `layerProtocolSocket` from `@effect/rpc` in order to:
@@ -19,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
@@ -28,16 +28,22 @@ 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()
+      let parser = serialization.makeUnsafe()
 
       const pinger = yield* makePinger(write(parser.encode(constPing)!), 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))
 
       yield* Effect.suspend(() => {
         // We rely on the heartbeat watchdog while streaming arbitrarily long payloads.
@@ -45,7 +51,8 @@ export const makeProtocolSocketWithIsConnected = (options: {
         // 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()
+        currentError = undefined
         pinger.reset()
         return socket
           .runRaw((message) => {
@@ -62,94 +69,107 @@ export const makeProtocolSocketWithIsConnected = (options: {
                   pinger.reset()
                   if (response._tag === 'Pong') {
                     pinger.onPong()
+                    return markConnected
                   }
-                  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)
-                        }
-                      }),
-                    ),
-                  )
+                  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: constVoid,
+                step: Function.constVoid,
               })
             } catch (defect) {
-              return writeResponse({
+              return broadcast({
                 _tag: 'ClientProtocolError',
                 error: new RpcClientError.RpcClientError({
-                  reason: 'Protocol',
-                  message: 'Error decoding message',
-                  cause: Cause.fail(defect),
+                  reason: new RpcClientError.RpcClientDefect({
+                    message: 'Error decoding message',
+                    cause: defect,
+                  }),
                 }),
               })
             }
           })
           .pipe(
             Effect.raceFirst(
-              Effect.zipRight(
-                pinger.timeout,
+              Effect.flatMap(pinger.timeout, () =>
                 Effect.fail(
-                  new Socket.SocketGenericError({
-                    reason: 'OpenTimeout',
-                    cause: new Error('ping timeout'),
+                  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 &&
-              Option.isSome(error) &&
-              (error.value.reason === 'Open' || error.value.reason === 'OpenTimeout')
+              options?.retryTransientErrors !== undefined &&
+              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 ? 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
 
@@ -164,33 +184,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, never>>()
+  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) 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),
@@ -202,9 +222,9 @@ const makePinger = Effect.fnUntraced(function* <A, E, R>(
 
   // CHANGED: add manual ping
   const ping = Effect.gen(function* () {
-    const deferred = yield* Deferred.make<void, never>()
+    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(
-      Schema.Struct({ _tag: Schema.Literal('a'), a: Schema.String }),
-      Schema.Struct({ _tag: Schema.Literal('b'), b: Schema.Number }),
-    )
+    const schema = Schema.Union([
+      Schema.TaggedStruct('a', { a: Schema.String }),
+      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,12 +19,12 @@ 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 })
 
-    if (SchemaAST.isUnion(ast)) {
-      if (isTaggedUnion(ast)) {
+    if (SchemaAST.isUnion(ast) === true) {
+      if (isTaggedUnion(ast) === true) {
         bag.push({ path, a, b, ast })
         return
       } else {
@@ -35,9 +35,8 @@ const debugDiffImpl = (ast: SchemaAST.AST, a: any, b: any, path: string, bag: Di
           } catch {}
         }
       }
-    } else if (SchemaAST.isTypeLiteral(ast)) {
-      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 {
@@ -47,12 +46,12 @@ const debugDiffImpl = (ast: SchemaAST.AST, a: any, b: any, path: string, bag: Di
   }
 }
 
-const isTaggedUnion = (ast: SchemaAST.AST) => {
-  if (SchemaAST.isUnion(ast)) {
+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 {
+  Array,
+  Effect,
+  Function,
+  Hash,
+  Option,
+  Result,
+  Schema,
+  SchemaAST,
+  SchemaGetter,
+  SchemaIssue,
+  SchemaTransformation,
+  Struct,
+} from 'effect'
+import { Transferable } from 'effect/unstable/workers'
 
-import { shouldNeverHappen } from '../../mod.ts'
+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.transformOrFail({
+          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,77 +120,44 @@ export const hash = (schema: Schema.Schema<any>) => {
   }
 }
 
-const resolveStructAst = (ast: SchemaAST.AST): SchemaAST.AST => {
-  if (SchemaAST.isTransformation(ast)) {
-    return resolveStructAst(ast.from)
-  }
-
-  return ast
-}
-
-export const getResolvedPropertySignatures = (
-  schema: Schema.Schema.AnyNoContext,
-): ReadonlyArray<SchemaAST.PropertySignature> => {
-  const resolvedAst = resolveStructAst(schema.ast)
-  return SchemaAST.getPropertySignatures(resolvedAst)
+export const getResolvedPropertySignatures = (schema: Schema.Top): ReadonlyArray<SchemaAST.PropertySignature> => {
+  const resolvedAst = SchemaAST.toType(schema.ast)
+  return SchemaAST.isObjects(resolvedAst) === true ? resolvedAst.propertySignatures : []
 }
 
 export const encodeWithTransferables =
-  <A, I, R>(schema: Schema.Schema<A, I, R>, options?: ParseOptions | undefined) =>
-  (a: A, overrideOptions?: ParseOptions | undefined): Effect.Effect<[I, Transferable[]], 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 Transferable[]]
+      return [encoded, collector.readUnsafe()] as const
     })
 
 export const decodeSyncDebug: <A, I>(
-  schema: Schema.Schema<A, I, never>,
+  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, never>,
+  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({ title: 'JsonValue' })

package/src/effect/Stream.test.ts

@@ -1,5 +1,6 @@
-import { Effect, Option, Stream } from 'effect'
+import { Effect, Option, Result, Stream } from 'effect'
 import { describe, expect, it } from 'vitest'
+
 import { concatWithLastElement, runCollectReadonlyArray } from './Stream.ts'
 
 describe('concatWithLastElement', () => {
@@ -9,7 +10,7 @@ describe('concatWithLastElement', () => {
       lastElement.pipe(
         Option.match({
           onNone: () => Stream.make('no-previous'),
-          onSome: (last) => Stream.make(`last-was-${last}`, 'continuing'),
+          onSome: (last) => Stream.make(`last-was-${String(last)}`, 'continuing'),
         }),
       ),
     )
@@ -24,7 +25,7 @@ describe('concatWithLastElement', () => {
       lastElement.pipe(
         Option.match({
           onNone: () => Stream.make('no-previous-element'),
-          onSome: (last) => Stream.make(`last-was-${last}`),
+          onSome: (last) => Stream.make(`last-was-${String(last)}`),
         }),
       ),
     )
@@ -39,7 +40,7 @@ describe('concatWithLastElement', () => {
       lastElement.pipe(
         Option.match({
           onNone: () => Stream.make('unexpected'),
-          onSome: (last) => Stream.make(`after-${last}`),
+          onSome: (last) => Stream.make(`after-${String(last)}`),
         }),
       ),
     )
@@ -60,10 +61,10 @@ describe('concatWithLastElement', () => {
     const stream1 = Stream.fail('first-error')
     const result = concatWithLastElement(stream1, () => Stream.make('should-not-reach'))
 
-    const outcome = await Effect.runPromise(Effect.either(runCollectReadonlyArray(result)))
-    expect(outcome._tag).toBe('Left')
-    if (outcome._tag === 'Left') {
-      expect(outcome.left).toBe('first-error')
+    const outcome = await Effect.runPromise(Effect.result(runCollectReadonlyArray(result)))
+    expect(outcome._tag).toBe('Failure')
+    if (Result.isFailure(outcome) === true) {
+      expect(outcome.failure).toBe('first-error')
     }
   })
 
@@ -71,10 +72,10 @@ describe('concatWithLastElement', () => {
     const stream1 = Stream.make(1, 2)
     const result = concatWithLastElement(stream1, () => Stream.fail('second-error'))
 
-    const outcome = await Effect.runPromise(Effect.either(runCollectReadonlyArray(result)))
-    expect(outcome._tag).toBe('Left')
-    if (outcome._tag === 'Left') {
-      expect(outcome.left).toBe('second-error')
+    const outcome = await Effect.runPromise(Effect.result(runCollectReadonlyArray(result)))
+    expect(outcome._tag).toBe('Failure')
+    if (Result.isFailure(outcome) === true) {
+      expect(outcome.failure).toBe('second-error')
     }
   })
 
@@ -83,7 +84,7 @@ describe('concatWithLastElement', () => {
     const result = concatWithLastElement(stream1, (lastElement) =>
       lastElement.pipe(
         Option.match({
-          onNone: () => Stream.make('no-number') as Stream.Stream<number | string, never, never>,
+          onNone: () => Stream.make('no-number') as Stream.Stream<number | string>,
           onSome: (last) => Stream.make(last * 10, last * 100),
         }),
       ),