@effect-app/vue 4.0.0-beta.0 → 4.0.0-beta.10

package/src/mutate.ts

@@ -1,10 +1,10 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
-import * as Result from "@effect-atom/atom/Result"
 import { type InvalidateOptions, type InvalidateQueryFilters, type QueryClient, useQueryClient } from "@tanstack/vue-query"
 import { type Cause, Effect, type Exit, Option } from "effect-app"
 import { type Req } from "effect-app/client"
 import type { ClientForOptions, RequestHandler, RequestHandlerWithInput } from "effect-app/client/clientFor"
 import { tuple } from "effect-app/Function"
+import * as AsyncResult from "effect/unstable/reactivity/AsyncResult"
 import { computed, type ComputedRef, shallowRef } from "vue"
 import { makeQueryKey } from "./lib.js"
 
@@ -19,7 +19,7 @@ export const getQueryKey = (h: { id: string; options?: ClientForOptions }) => {
 }
 
 export function mutationResultToVue<A, E>(
-  mutationResult: Result.Result<A, E>
+  mutationResult: AsyncResult.AsyncResult<A, E>
 ): Res<A, E> {
   switch (mutationResult._tag) {
     case "Initial": {
@@ -49,20 +49,20 @@ export interface Res<A, E> {
 }
 
 export function make<A, E, R>(self: Effect.Effect<A, E, R>) {
-  const result = shallowRef(Result.initial() as Result.Result<A, E>)
+  const result = shallowRef(AsyncResult.initial() as AsyncResult.AsyncResult<A, E>)
 
   const execute = Effect
     .sync(() => {
-      result.value = Result.waiting(result.value)
+      result.value = AsyncResult.waiting(result.value)
     })
     .pipe(
       Effect.andThen(self),
       Effect.exit,
-      Effect.map(Result.fromExit),
+      Effect.map(AsyncResult.fromExit),
       Effect.flatMap((r) => Effect.sync(() => result.value = r))
     )
 
-  const latestSuccess = computed(() => Option.getOrUndefined(Result.value(result.value)))
+  const latestSuccess = computed(() => Option.getOrUndefined(AsyncResult.value(result.value)))
 
   return tuple(result, latestSuccess, execute)
 }
@@ -103,38 +103,38 @@ export interface MutationOptions<A, E, R, A2 = A, E2 = E, R2 = R, I = void> exte
 export const asResult: {
   <A, E, R>(
     handler: Effect.Effect<A, E, R>
-  ): readonly [ComputedRef<Result.Result<A, E>>, Effect.Effect<Exit.Exit<A, E>, never, R>]
+  ): readonly [ComputedRef<AsyncResult.AsyncResult<A, E>>, Effect.Effect<Exit.Exit<A, E>, never, R>]
   <Args extends readonly any[], A, E, R>(
     handler: (...args: Args) => Effect.Effect<A, E, R>
-  ): readonly [ComputedRef<Result.Result<A, E>>, (...args: Args) => Effect.Effect<Exit.Exit<A, E>, never, R>]
+  ): readonly [ComputedRef<AsyncResult.AsyncResult<A, E>>, (...args: Args) => Effect.Effect<Exit.Exit<A, E>, never, R>]
 } = <Args extends readonly any[], A, E, R>(
   handler: Effect.Effect<A, E, R> | ((...args: Args) => Effect.Effect<A, E, R>)
 ) => {
-  const state = shallowRef<Result.Result<A, E>>(Result.initial())
+  const state = shallowRef<AsyncResult.AsyncResult<A, E>>(AsyncResult.initial())
 
   const act = Effect.isEffect(handler)
     ? Effect
       .sync(() => {
-        state.value = Result.initial(true)
+        state.value = AsyncResult.initial(true)
       })
       .pipe(
         Effect.andThen(Effect.suspend(() =>
           handler.pipe(
             Effect.exit,
-            Effect.tap((exit) => Effect.sync(() => (state.value = Result.fromExit(exit))))
+            Effect.tap((exit) => Effect.sync(() => (state.value = AsyncResult.fromExit(exit))))
           )
         ))
       )
     : (...args: Args) =>
       Effect
         .sync(() => {
-          state.value = Result.initial(true)
+          state.value = AsyncResult.initial(true)
         })
         .pipe(
           Effect.andThen(Effect.suspend(() =>
             handler(...args).pipe(
               Effect.exit,
-              Effect.tap((exit) => Effect.sync(() => (state.value = Result.fromExit(exit))))
+              Effect.tap((exit) => Effect.sync(() => (state.value = AsyncResult.fromExit(exit))))
             )
           ))
         )

package/src/query.ts

@@ -2,7 +2,6 @@
 /* eslint-disable @typescript-eslint/no-unsafe-call */
 /* eslint-disable @typescript-eslint/no-unsafe-return */
 /* eslint-disable @typescript-eslint/no-unsafe-assignment */
-import * as Result from "@effect-atom/atom/Result"
 import { type DefaultError, type Enabled, type InitialDataFunction, type NonUndefinedGuard, type PlaceholderDataFunction, type QueryKey, type QueryObserverOptions, type QueryObserverResult, type RefetchOptions, useQuery as useTanstackQuery, useQueryClient, type UseQueryDefinedReturnType, type UseQueryReturnType } from "@tanstack/vue-query"
 import { Array, Cause, Effect, Exit, flow, Option, S, type ServiceMap } from "effect-app"
 import { type Req } from "effect-app/client"
@@ -10,6 +9,7 @@ import type { RequestHandler, RequestHandlerWithInput } from "effect-app/client/
 import { ServiceUnavailableError } from "effect-app/client/errors"
 import { type Span } from "effect/Tracer"
 import { isHttpClientError } from "effect/unstable/http/HttpClientError"
+import * as AsyncResult from "effect/unstable/reactivity/AsyncResult"
 import { computed, type ComputedRef, type MaybeRefOrGetter, ref, shallowRef, watch, type WatchSource } from "vue"
 import { makeQueryKey, reportRuntimeError } from "./lib.js"
 
@@ -93,7 +93,7 @@ export const makeQuery = <R>(getRuntime: () => ServiceMap.ServiceMap<R>) => {
         arg: I | WatchSource<I> | undefined,
         options?: CustomUndefinedInitialQueryOptions<A, E, TData>
       ): readonly [
-        ComputedRef<Result.Result<TData, E>>,
+        ComputedRef<AsyncResult.AsyncResult<TData, E>>,
         ComputedRef<TData | undefined>,
         (options?: RefetchOptions) => Effect.Effect<QueryObserverResult<TData, KnownFiberFailure<E>>, never, never>,
         UseQueryDefinedReturnType<TData, KnownFiberFailure<E>>
@@ -103,7 +103,7 @@ export const makeQuery = <R>(getRuntime: () => ServiceMap.ServiceMap<R>) => {
         arg: I | WatchSource<I> | undefined,
         options: CustomDefinedInitialQueryOptions<A, E, TData>
       ): readonly [
-        ComputedRef<Result.Result<TData, E>>,
+        ComputedRef<AsyncResult.AsyncResult<TData, E>>,
         ComputedRef<TData>,
         (options?: RefetchOptions) => Effect.Effect<QueryObserverResult<TData, KnownFiberFailure<E>>, never, never>,
         UseQueryDefinedReturnType<TData, KnownFiberFailure<E>>
@@ -113,7 +113,7 @@ export const makeQuery = <R>(getRuntime: () => ServiceMap.ServiceMap<R>) => {
         arg: I | WatchSource<I> | undefined,
         options: CustomDefinedPlaceholderQueryOptions<A, E, TData>
       ): readonly [
-        ComputedRef<Result.Result<TData, E>>,
+        ComputedRef<AsyncResult.AsyncResult<TData, E>>,
         ComputedRef<TData>,
         (options?: RefetchOptions) => Effect.Effect<QueryObserverResult<TData, KnownFiberFailure<E>>, never, never>,
         UseQueryDefinedReturnType<TData, KnownFiberFailure<E>>
@@ -202,7 +202,7 @@ export const makeQuery = <R>(getRuntime: () => ServiceMap.ServiceMap<R>) => {
     )
 
     const latestSuccess = shallowRef<TData>()
-    const result = computed((): Result.Result<TData, E> =>
+    const result = computed((): AsyncResult.AsyncResult<TData, E> =>
       swrToQuery({
         error: r.error.value ?? undefined,
         data: r.data.value === undefined ? latestSuccess.value : r.data.value, // we fall back to existing data, as tanstack query might loose it when the key changes
@@ -210,7 +210,7 @@ export const makeQuery = <R>(getRuntime: () => ServiceMap.ServiceMap<R>) => {
       })
     )
     // not using `computed` here as we have a circular dependency
-    watch(result, (value) => latestSuccess.value = Option.getOrUndefined(Result.value(value)), { immediate: true })
+    watch(result, (value) => latestSuccess.value = Option.getOrUndefined(AsyncResult.value(value)), { immediate: true })
 
     return [
       result,
@@ -231,21 +231,21 @@ export const makeQuery = <R>(getRuntime: () => ServiceMap.ServiceMap<R>) => {
     error: KnownFiberFailure<E> | undefined
     data: A | undefined
     isValidating: boolean
-  }): Result.Result<A, E> {
+  }): AsyncResult.AsyncResult<A, E> {
     if (r.error !== undefined) {
-      return Result.failureWithPrevious(
+      return AsyncResult.failureWithPrevious(
         r.error.effectCause,
         {
-          previous: r.data === undefined ? Option.none() : Option.some(Result.success(r.data)),
+          previous: r.data === undefined ? Option.none() : Option.some(AsyncResult.success(r.data)),
           waiting: r.isValidating
         }
       )
     }
     if (r.data !== undefined) {
-      return Result.success<A, E>(r.data, { waiting: r.isValidating })
+      return AsyncResult.success<A, E>(r.data, { waiting: r.isValidating })
     }
 
-    return Result.initial(r.isValidating)
+    return AsyncResult.initial(r.isValidating)
   }
 
   const useQuery: {
@@ -263,7 +263,7 @@ export const makeQuery = <R>(getRuntime: () => ServiceMap.ServiceMap<R>) => {
       <TData = A>(
         options: CustomDefinedInitialQueryOptions<A, KnownFiberFailure<E>, TData>
       ): readonly [
-        ComputedRef<Result.Result<TData, E>>,
+        ComputedRef<AsyncResult.AsyncResult<TData, E>>,
         ComputedRef<TData>,
         (options?: RefetchOptions) => Effect.Effect<QueryObserverResult<TData, KnownFiberFailure<E>>>,
         UseQueryReturnType<any, any>
@@ -271,7 +271,7 @@ export const makeQuery = <R>(getRuntime: () => ServiceMap.ServiceMap<R>) => {
       <TData = A>(
         options: CustomDefinedPlaceholderQueryOptions<A, E, TData>
       ): readonly [
-        ComputedRef<Result.Result<TData, E>>,
+        ComputedRef<AsyncResult.AsyncResult<TData, E>>,
         ComputedRef<TData>,
         (options?: RefetchOptions) => Effect.Effect<QueryObserverResult<TData, KnownFiberFailure<E>>, never, never>,
         UseQueryDefinedReturnType<TData, KnownFiberFailure<E>>
@@ -281,7 +281,7 @@ export const makeQuery = <R>(getRuntime: () => ServiceMap.ServiceMap<R>) => {
        * Effect results are passed to the caller, including errors.
        */
       <TData = A>(options?: CustomUndefinedInitialQueryOptions<A, KnownFiberFailure<E>, TData>): readonly [
-        ComputedRef<Result.Result<A, E>>,
+        ComputedRef<AsyncResult.AsyncResult<A, E>>,
         ComputedRef<A | undefined>,
         (options?: RefetchOptions) => Effect.Effect<QueryObserverResult<TData, KnownFiberFailure<E>>>,
         UseQueryReturnType<any, any>
@@ -302,7 +302,7 @@ export const makeQuery = <R>(getRuntime: () => ServiceMap.ServiceMap<R>) => {
         arg: Arg | WatchSource<Arg>,
         options: CustomDefinedInitialQueryOptions<A, KnownFiberFailure<E>, TData>
       ): readonly [
-        ComputedRef<Result.Result<TData, E>>,
+        ComputedRef<AsyncResult.AsyncResult<TData, E>>,
         ComputedRef<TData>,
         (options?: RefetchOptions) => Effect.Effect<QueryObserverResult<TData, KnownFiberFailure<E>>>,
         UseQueryReturnType<any, any>
@@ -315,7 +315,7 @@ export const makeQuery = <R>(getRuntime: () => ServiceMap.ServiceMap<R>) => {
         arg: Arg | WatchSource<Arg>,
         options: CustomDefinedPlaceholderQueryOptions<A, KnownFiberFailure<E>, TData>
       ): readonly [
-        ComputedRef<Result.Result<TData, E>>,
+        ComputedRef<AsyncResult.AsyncResult<TData, E>>,
         ComputedRef<TData>,
         (options?: RefetchOptions) => Effect.Effect<QueryObserverResult<TData, KnownFiberFailure<E>>>,
         UseQueryReturnType<any, any>
@@ -328,7 +328,7 @@ export const makeQuery = <R>(getRuntime: () => ServiceMap.ServiceMap<R>) => {
         arg: Arg | WatchSource<Arg>,
         options?: CustomUndefinedInitialQueryOptions<A, KnownFiberFailure<E>, TData>
       ): readonly [
-        ComputedRef<Result.Result<TData, E>>,
+        ComputedRef<AsyncResult.AsyncResult<TData, E>>,
         ComputedRef<TData | undefined>,
         (options?: RefetchOptions) => Effect.Effect<QueryObserverResult<TData, KnownFiberFailure<E>>>,
         UseQueryReturnType<any, any>
@@ -350,31 +350,31 @@ export const makeQuery = <R>(getRuntime: () => ServiceMap.ServiceMap<R>) => {
 // eslint-disable-next-line @typescript-eslint/no-empty-object-type
 export interface MakeQuery2<R> extends ReturnType<typeof makeQuery<R>> {}
 
-function orPrevious<E, A>(result: Result.Result<A, E>) {
-  return Result.isFailure(result) && Option.isSome(result.previousSuccess)
-    ? Result.success(result.previousSuccess.value, { waiting: result.waiting })
+function orPrevious<E, A>(result: AsyncResult.AsyncResult<A, E>) {
+  return AsyncResult.isFailure(result) && Option.isSome(result.previousSuccess)
+    ? AsyncResult.success(result.previousSuccess.value, { waiting: result.waiting })
     : result
 }
 
 export function composeQueries<
-  R extends Record<string, Result.Result<any, any>>
+  R extends Record<string, AsyncResult.AsyncResult<any, any>>
 >(
   results: R,
   renderPreviousOnFailure?: boolean
-): Result.Result<
+): AsyncResult.AsyncResult<
   {
-    [Property in keyof R]: R[Property] extends Result.Result<infer A, any> ? A
+    [Property in keyof R]: R[Property] extends AsyncResult.AsyncResult<infer A, any> ? A
       : never
   },
   {
-    [Property in keyof R]: R[Property] extends Result.Result<any, infer E> ? E
+    [Property in keyof R]: R[Property] extends AsyncResult.AsyncResult<any, infer E> ? E
       : never
   }[keyof R]
 > {
   const values = renderPreviousOnFailure
     ? Object.values(results).map(orPrevious)
     : Object.values(results)
-  const error = values.find(Result.isFailure)
+  const error = values.find(AsyncResult.isFailure)
   if (error) {
     return error
   }
@@ -382,7 +382,7 @@ export function composeQueries<
   if (initial.value !== undefined) {
     return initial.value
   }
-  const loading = Array.findFirst(values, (x) => Result.isInitial(x) && x.waiting ? Option.some(x) : Option.none())
+  const loading = Array.findFirst(values, (x) => AsyncResult.isInitial(x) && x.waiting ? Option.some(x) : Option.none())
   if (loading.value !== undefined) {
     return loading.value
   }
@@ -390,10 +390,10 @@ export function composeQueries<
   const isRefreshing = values.some((x) => x.waiting)
 
   const r = Object.entries(results).reduce((prev, [key, value]) => {
-    prev[key] = Result.value(value).value
+    prev[key] = AsyncResult.value(value).value
     return prev
   }, {} as any)
-  return Result.success(r, { waiting: isRefreshing })
+  return AsyncResult.success(r, { waiting: isRefreshing })
 }
 
 export const useUpdateQuery = () => {

package/test/Mutation.test.ts

@@ -2,7 +2,7 @@
 import { it } from "@effect/vitest"
 import { Cause, Effect, Exit, Fiber, Option } from "effect-app"
 import { CommandContext, DefaultIntl } from "../src/experimental/commander.js"
-import { Result } from "../src/lib.js"
+import { AsyncResult } from "../src/lib.js"
 import { useExperimental } from "./stubs.js"
 
 const unwrap = <A, E>(r: Fiber.Fiber<Exit.Exit<A, E>, never>) => Fiber.join(r).pipe(Effect.flatten)
@@ -88,7 +88,7 @@ describe("alt2", () => {
         expect(r).toBe("test-value") // to confirm that the initial function has ran.
         expect(executed).toBe(true) // to confirm that the combinators have ran.
 
-        expect(command.result.pipe(Result.value)).toEqual(Option.some("test-value"))
+        expect(command.result.pipe(AsyncResult.value)).toEqual(Option.some("test-value"))
 
         expect(toasts.length).toBe(0)
 
@@ -140,7 +140,7 @@ it.live("works", () =>
       expect(r).toBe("test-value") // to confirm that the initial function has ran.
       expect(executed).toBe(true) // to confirm that the combinators have ran.
 
-      expect(command.result.pipe(Result.value)).toEqual(Option.some("test-value"))
+      expect(command.result.pipe(AsyncResult.value)).toEqual(Option.some("test-value"))
 
       expect(toasts.length).toBe(0)
 
@@ -187,7 +187,7 @@ it.live("works non-gen", () =>
       expect(r).toBe("test-value") // to confirm that the initial function has ran.
       expect(executed).toBe(true) // to confirm that the combinators have ran.
 
-      expect(command.result.pipe(Result.value)).toEqual(Option.some("test-value"))
+      expect(command.result.pipe(AsyncResult.value)).toEqual(Option.some("test-value"))
 
       expect(toasts.length).toBe(0)
     }))
@@ -360,7 +360,7 @@ it.live("interrupted", () =>
       expect(Exit.hasInterrupts(r)).toBe(true) // to confirm that the initial function has interrupted
 
       expect(command.waiting).toBe(false)
-      expect(Exit.hasInterrupts(Result.toExit(command.result))).toBe(true)
+      expect(Exit.hasInterrupts(AsyncResult.toExit(command.result))).toBe(true)
       expect(toasts.length).toBe(0) // toast is removed on interruption. TODO: maybe a nicer user experience can be had?
     }))
 
@@ -386,7 +386,7 @@ it.live("fail", () =>
       expect(Exit.isFailure(r) && Cause.hasFails(r.cause)).toBe(true) // to confirm that the initial function has failed
 
       expect(command.waiting).toBe(false)
-      expect(Exit.isFailure(Result.toExit(command.result))).toBe(true)
+      expect(Exit.isFailure(AsyncResult.toExit(command.result))).toBe(true)
       expect(toasts.length).toBe(1) // toast should show error
       expect(toasts[0].message).toBe("Test Action Failed:\nBoom!")
     }))
@@ -414,7 +414,7 @@ it.live("fail and recover", () =>
       expect(r).toBe("recovered") // to confirm that the initial function has failed but we recovered
 
       expect(command.waiting).toBe(false)
-      expect(Result.toExit(command.result)).toEqual(Exit.succeed("recovered"))
+      expect(AsyncResult.toExit(command.result)).toEqual(Exit.succeed("recovered"))
       expect(toasts.length).toBe(1) // toast should show error
       expect(toasts[0].message).toBe("Test Action Success")
     }))
@@ -442,7 +442,7 @@ it.live("defect", () =>
       expect(Exit.isFailure(r) && Cause.hasDies(r.cause)).toBe(true) // to confirm that the initial function has died
 
       expect(command.waiting).toBe(false)
-      expect(Exit.isFailure(Result.toExit(command.result))).toBe(true)
+      expect(Exit.isFailure(AsyncResult.toExit(command.result))).toBe(true)
       expect(toasts.length).toBe(1) // toast should show error
       expect(toasts[0].message).toBe("Test Action unexpected error, please try again shortly.")
     }))
@@ -484,7 +484,7 @@ it.live("works with alt", () =>
       expect(r).toBe("test-value") // to confirm that the initial function has ran.
       expect(executed).toBe(true) // to confirm that the combinators have ran.
 
-      expect(command.result.pipe(Result.value)).toEqual(Option.some("test-value"))
+      expect(command.result.pipe(AsyncResult.value)).toEqual(Option.some("test-value"))
 
       expect(toasts.length).toBe(0)
     }))
@@ -666,7 +666,7 @@ it.live("interrupted with alt", () =>
       expect(Exit.hasInterrupts(r)).toBe(true) // to confirm that the initial function has interrupted
 
       expect(command.waiting).toBe(false)
-      expect(Exit.hasInterrupts(Result.toExit(command.result))).toBe(true)
+      expect(Exit.hasInterrupts(AsyncResult.toExit(command.result))).toBe(true)
       expect(toasts.length).toBe(0) // toast is removed on interruption. TODO: maybe a nicer user experience can be had?
     }))
 
@@ -694,7 +694,7 @@ it.live("fail with alt", () =>
       expect(Exit.isFailure(r) && Cause.hasFails(r.cause)).toBe(true) // to confirm that the initial function has failed
 
       expect(command.waiting).toBe(false)
-      expect(Exit.isFailure(Result.toExit(command.result))).toBe(true)
+      expect(Exit.isFailure(AsyncResult.toExit(command.result))).toBe(true)
       expect(toasts.length).toBe(1) // toast should show error
       expect(toasts[0].message).toBe("Test Action Failed:\nBoom!")
     }))
@@ -724,7 +724,7 @@ it.live("fail and recover with alt", () =>
       expect(r).toBe("recovered") // to confirm that the initial function has failed but we recovered
 
       expect(command.waiting).toBe(false)
-      expect(Result.toExit(command.result)).toEqual(Exit.succeed("recovered"))
+      expect(AsyncResult.toExit(command.result)).toEqual(Exit.succeed("recovered"))
       expect(toasts.length).toBe(1) // toast should show error
       expect(toasts[0].message).toBe("Test Action Success")
     }))
@@ -754,7 +754,7 @@ it.live("defect with alt", () =>
       expect(Exit.isFailure(r) && Cause.hasDies(r.cause)).toBe(true) // to confirm that the initial function has died
 
       expect(command.waiting).toBe(false)
-      expect(Exit.isFailure(Result.toExit(command.result))).toBe(true)
+      expect(Exit.isFailure(AsyncResult.toExit(command.result))).toBe(true)
       expect(toasts.length).toBe(1) // toast should show error
       expect(toasts[0].message).toBe("Test Action unexpected error, please try again shortly.")
     }))

package/test/dist/stubs.d.ts

@@ -36,11 +36,11 @@ export declare const Req: <_Self>() => {
         readonly success: C["success"] extends infer T ? T extends C["success"] ? T extends S.Top ? T : T extends S.Struct.Fields ? S.Struct<T> : S.Void : never : never;
         readonly error: C extends {
             error: infer E;
-        } ? E extends S.Top ? E : E extends S.Struct.Fields ? S.Struct<E> : S.Void : S.Void;
+        } ? E extends S.Top ? E : E extends S.Struct.Fields ? S.Struct<E> : S.Void : never;
         readonly config: Omit<C, "success" | "error">;
         readonly "~decodingServices": S.Codec.DecodingServices<C["success"] extends infer T_1 ? T_1 extends C["success"] ? T_1 extends S.Top ? T_1 : T_1 extends S.Struct.Fields ? S.Struct<T_1> : S.Void : never : never> | S.Codec.DecodingServices<C extends {
             error: infer E;
-        } ? E extends S.Top ? E : E extends S.Struct.Fields ? S.Struct<E> : S.Void : S.Void>;
+        } ? E extends S.Top ? E : E extends S.Struct.Fields ? S.Struct<E> : S.Void : never>;
     };
     <Tag extends string, Payload_1 extends S.Struct.Fields, C_1 extends Pick<{
         success: S.Top | S.Struct.Fields;
@@ -54,11 +54,11 @@ export declare const Req: <_Self>() => {
         readonly success: C_1["success"] extends infer T ? T extends C_1["success"] ? T extends S.Top ? T : T extends S.Struct.Fields ? S.Struct<T> : S.Void : never : never;
         readonly error: C_1 extends {
             error: infer E;
-        } ? E extends S.Top ? E : E extends S.Struct.Fields ? S.Struct<E> : S.Void : S.Void;
+        } ? E extends S.Top ? E : E extends S.Struct.Fields ? S.Struct<E> : S.Void : never;
         readonly config: Omit<C_1, "success" | "error">;
         readonly "~decodingServices": S.Codec.DecodingServices<C_1["success"] extends infer T_1 ? T_1 extends C_1["success"] ? T_1 extends S.Top ? T_1 : T_1 extends S.Struct.Fields ? S.Struct<T_1> : S.Void : never : never> | S.Codec.DecodingServices<C_1 extends {
             error: infer E;
-        } ? E extends S.Top ? E : E extends S.Struct.Fields ? S.Struct<E> : S.Void : S.Void>;
+        } ? E extends S.Top ? E : E extends S.Struct.Fields ? S.Struct<E> : S.Void : never>;
     };
     <Tag extends string, Payload_2 extends S.Struct.Fields, C_2 extends Pick<{
         success: S.Top | S.Struct.Fields;
@@ -69,12 +69,14 @@ export declare const Req: <_Self>() => {
         readonly fields: {
             readonly _tag: S.tag<Tag>;
         } & Payload_2;
-        readonly success: S.Schema<void>;
+        readonly success: S.Codec<void, void, never, never>;
         readonly error: C_2 extends {
             error: infer E;
-        } ? E extends S.Top ? E : E extends S.Struct.Fields ? S.Struct<E> : S.Void : S.Void;
+        } ? E extends S.Top ? E : E extends S.Struct.Fields ? S.Struct<E> : S.Void : never;
         readonly config: Omit<C_2, "success" | "error">;
-        readonly "~decodingServices": unknown;
+        readonly "~decodingServices": S.Codec.DecodingServices<C_2 extends {
+            error: infer E;
+        } ? E extends S.Top ? E : E extends S.Struct.Fields ? S.Struct<E> : S.Void : never>;
     };
     <Tag extends string, Payload_3 extends S.Struct.Fields, C_3 extends Record<string, any>>(tag: Tag, fields: Payload_3, config: C_3 & RpcContextMap.GetContextConfig<{}>): S.TaggedStruct<Tag, Payload_3> & {
         new (...args: any[]): any;
@@ -82,12 +84,14 @@ export declare const Req: <_Self>() => {
         readonly fields: {
             readonly _tag: S.tag<Tag>;
         } & Payload_3;
-        readonly success: S.Schema<void>;
+        readonly success: S.Codec<void, void, never, never>;
         readonly error: C_3 extends {
             error: infer E;
-        } ? E extends S.Top ? E : E extends S.Struct.Fields ? S.Struct<E> : S.Void : S.Void;
+        } ? E extends S.Top ? E : E extends S.Struct.Fields ? S.Struct<E> : S.Void : never;
         readonly config: Omit<C_3, "success" | "error">;
-        readonly "~decodingServices": unknown;
+        readonly "~decodingServices": S.Codec.DecodingServices<C_3 extends {
+            error: infer E;
+        } ? E extends S.Top ? E : E extends S.Struct.Fields ? S.Struct<E> : S.Void : never>;
     };
     <Tag extends string, Payload_4 extends S.Struct.Fields>(tag: Tag, fields: Payload_4): S.TaggedStruct<Tag, Payload_4> & {
         new (...args: any[]): any;
@@ -95,10 +99,10 @@ export declare const Req: <_Self>() => {
         readonly fields: {
             readonly _tag: S.tag<Tag>;
         } & Payload_4;
-        readonly success: S.Schema<void>;
+        readonly success: S.Codec<void, void, never, never>;
         readonly error: never;
         readonly config: Record<string, never>;
-        readonly "~decodingServices": unknown;
+        readonly "~decodingServices": never;
     };
 };
 declare const GetSomething2_base: S.TaggedStruct<"GetSomething2", {
@@ -112,7 +116,7 @@ declare const GetSomething2_base: S.TaggedStruct<"GetSomething2", {
         id: S.String;
     };
     readonly success: S.NumberFromString;
-    readonly error: S.Void;
+    readonly error: never;
     readonly config: Omit<{
         success: S.NumberFromString;
     }, "success" | "error">;

package/test/dist/stubs.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"stubs.d.ts","sourceRoot":"","sources":["../stubs.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,oBAAoB,EAAE,MAAM,oCAAoC,CAAA;AAE9E,OAAO,EAAU,KAAK,EAA0B,CAAC,EAAE,MAAM,YAAY,CAAA;AACrE,OAAO,EAAE,gBAAgB,EAAiB,MAAM,mBAAmB,CAAA;AACnE,OAAO,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAA;AAG9C,OAAO,EAAE,SAAS,EAAE,MAAM,kCAAkC,CAAA;AAC5D,OAAO,EAAE,IAAI,EAAE,MAAM,6BAA6B,CAAA;AAElD,OAAO,KAAK,KAAK,MAAM,8BAA8B,CAAA;AACrD,OAAO,EAAE,SAAS,EAAE,MAAM,kCAAkC,CAAA;AAC5D,OAAO,EAAE,cAAc,EAAc,MAAM,sBAAsB,CAAA;AACjE,OAAO,EAAE,KAAK,cAAc,EAAE,MAAM,oBAAoB,CAAA;AA8CxD,eAAO,MAAM,YAAY,GAAI,WAAU,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,oBAAoB,EAAE,CAAM,KAepG,UAAU,CAAC,cAAc,CAAC,MAAM,CAAC,CAAC,SAAS,CAAC,CAClD,CAAA;AAED,eAAO,MAAM,aAAa,GAAI,WAAU,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,oBAAoB,EAAE,CAAM,oCACpC,CAAA;AAExE,eAAO,MAAM,eAAe,GAC1B,UAAU;IAAE,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,oBAAoB,EAAE,CAAC,CAAC;IAAC,MAAM,EAAE,GAAG,EAAE,CAAA;CAAE,6GASxG,CAAA;;;;;;;;AAED,qBAAa,iBAAkB,SAAQ,sBAAyB;CAAG;AACnE,eAAO,MAAuB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAAqC,CAAA;;;;;;;;;;;;;;;;;;AACtE,qBAAa,aAAc,SAAQ,kBAEA;CAAG;;;;;;;;;;;;;;iBAML,CAAC,CAAC,KAAK,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,CAAC;;;;;AAJjE,qBAAa,6BAA8B,SAAQ,kCAMjD;CAAG;AAEL,eAAO,MAAM,SAAS;;;;;;CAA+F,CAAA;AAErH,eAAO,MAAM,SAAS,GACpB,UAAU;IAAE,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,oBAAoB,EAAE,CAAC,CAAC;IAAC,MAAM,EAAE,GAAG,EAAE,CAAA;CAAE;;;;;;;;;CAcxG,CAAA"}
+{"version":3,"file":"stubs.d.ts","sourceRoot":"","sources":["../stubs.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,oBAAoB,EAAE,MAAM,oCAAoC,CAAA;AAE9E,OAAO,EAAU,KAAK,EAA0B,CAAC,EAAE,MAAM,YAAY,CAAA;AACrE,OAAO,EAAE,gBAAgB,EAAiB,MAAM,mBAAmB,CAAA;AACnE,OAAO,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAA;AAG9C,OAAO,EAAE,SAAS,EAAE,MAAM,kCAAkC,CAAA;AAC5D,OAAO,EAAE,IAAI,EAAE,MAAM,6BAA6B,CAAA;AAElD,OAAO,KAAK,KAAK,MAAM,8BAA8B,CAAA;AACrD,OAAO,EAAE,SAAS,EAAE,MAAM,kCAAkC,CAAA;AAC5D,OAAO,EAAE,cAAc,EAAc,MAAM,sBAAsB,CAAA;AACjE,OAAO,EAAE,KAAK,cAAc,EAAE,MAAM,oBAAoB,CAAA;AA8CxD,eAAO,MAAM,YAAY,GAAI,WAAU,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,oBAAoB,EAAE,CAAM,KAepG,UAAU,CAAC,cAAc,CAAC,MAAM,CAAC,CAAC,SAAS,CAAC,CAClD,CAAA;AAED,eAAO,MAAM,aAAa,GAAI,WAAU,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,oBAAoB,EAAE,CAAM,oCACpC,CAAA;AAExE,eAAO,MAAM,eAAe,GAC1B,UAAU;IAAE,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,oBAAoB,EAAE,CAAC,CAAC;IAAC,MAAM,EAAE,GAAG,EAAE,CAAA;CAAE,6GASxG,CAAA;;;;;;;;AAED,qBAAa,iBAAkB,SAAQ,sBAAyB;CAAG;AACnE,eAAO,MAAuB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAAqC,CAAA;;;;;;;;;;;;;;;;;;AACtE,qBAAa,aAAc,SAAQ,kBAEA;CAAG;;;;;;;;;;;;;;iBAML,CAAC,CAAC,KAAK,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,CAAC;;;;;AAJjE,qBAAa,6BAA8B,SAAQ,kCAMjD;CAAG;AAEL,eAAO,MAAM,SAAS;;;;;;CAA+F,CAAA;AAErH,eAAO,MAAM,SAAS,GACpB,UAAU;IAAE,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,oBAAoB,EAAE,CAAC,CAAC;IAAC,MAAM,EAAE,GAAG,EAAE,CAAA;CAAE;;;;;;;;;CAcxG,CAAA"}