@effect-app/vue 2.94.0 → 4.0.0-beta.1

package/test/Mutation.test.ts

@@ -1,12 +1,11 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 import { it } from "@effect/vitest"
 import { Cause, Effect, Exit, Fiber, Option } from "effect-app"
-import { type RuntimeFiber } from "effect/Fiber"
 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: RuntimeFiber<Exit.Exit<A, E>, never>) => Fiber.join(r).pipe(Effect.flatten)
+const unwrap = <A, E>(r: Fiber.Fiber<Exit.Exit<A, E>, never>) => Fiber.join(r).pipe(Effect.flatten)
 
 // declare const mutation: {
 //   name: "myMutation"
@@ -72,9 +71,9 @@ describe("alt2", () => {
               expect(yield* Effect.currentSpan.pipe(Effect.map((_) => _.name))).toBe("Test Action")
             })),
             Effect.tap(() =>
-              Effect.currentSpan.pipe(Effect.map((_) => _.name), Effect.tap((_) => expect(_).toBe("Test Action")))
+              Effect.currentSpan.pipe(Effect.map((_) => _.name), Effect.tap((_) => Effect.sync(() => expect(_).toBe("Test Action"))))
             ),
-            Effect.tap(() => executed = true)
+            Effect.tap(() => Effect.sync(() => executed = true))
           )
         )
 
@@ -89,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)
 
@@ -126,9 +125,9 @@ it.live("works", () =>
           expect(yield* Effect.currentSpan.pipe(Effect.map((_) => _.name))).toBe("Test Action")
         })),
         Effect.tap(() =>
-          Effect.currentSpan.pipe(Effect.map((_) => _.name), Effect.tap((_) => expect(_).toBe("Test Action")))
+          Effect.currentSpan.pipe(Effect.map((_) => _.name), Effect.tap((_) => Effect.sync(() => expect(_).toBe("Test Action"))))
         ),
-        Effect.tap(() => executed = true)
+        Effect.tap(() => Effect.sync(() => executed = true))
       )
       expect(command.action).toBe("Test Action")
       expect(command.id).toBe("Test Action")
@@ -141,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)
 
@@ -176,9 +175,9 @@ it.live("works non-gen", () =>
           expect(yield* Effect.currentSpan.pipe(Effect.map((_) => _.name))).toBe("Test Action")
         })),
         Effect.tap(() =>
-          Effect.currentSpan.pipe(Effect.map((_) => _.name), Effect.tap((_) => expect(_).toBe("Test Action")))
+          Effect.currentSpan.pipe(Effect.map((_) => _.name), Effect.tap((_) => Effect.sync(() => expect(_).toBe("Test Action"))))
         ),
-        Effect.tap(() => executed = true)
+        Effect.tap(() => Effect.sync(() => executed = true))
       )
       expect(command.action).toBe("Test Action")
 
@@ -188,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)
     }))
@@ -211,7 +210,7 @@ it.live("has custom action name", () =>
           expect(yield* CommandContext).toMatchObject({ action: "Test Action Translated", id: "Test Action" })
           return "test-value"
         },
-        Effect.tap(() => executed = true)
+        Effect.tap(() => Effect.sync(() => executed = true))
       )
       expect(command.action).toBe("Test Action Translated")
       const r = yield* unwrap(command.handle())
@@ -235,7 +234,7 @@ it.live("can map the result", () =>
           return "test-value"
         },
         Effect.map((_) => _ + _),
-        Effect.tap(() => executed = true)
+        Effect.tap(() => Effect.sync(() => executed = true))
       )
       const r = yield* unwrap(command.handle())
 
@@ -257,7 +256,7 @@ it.live("can receive and use input", () =>
 
           return { input1, input2 }
         },
-        Effect.tap(() => executed = true)
+        Effect.tap(() => Effect.sync(() => executed = true))
       )
       const r = yield* unwrap(command.handle(1))
 
@@ -285,8 +284,8 @@ it.live("can replace the result", () =>
 
           return "test-value"
         },
-        Effect.zipRight(Effect.succeed(42)),
-        Effect.tap(() => executed = true)
+        Effect.andThen(Effect.succeed(42)),
+        Effect.tap(() => Effect.sync(() => executed = true))
       )
       const r = yield* unwrap(command.handle())
 
@@ -318,7 +317,7 @@ it.live("with toasts", () =>
           expect(yield* Effect.currentSpan.pipe(Effect.map((_) => _.name))).toBe("Test Action")
         })),
         Effect.tap(() =>
-          Effect.currentSpan.pipe(Effect.map((_) => _.name), Effect.tap((_) => expect(_).toBe("Test Action")))
+          Effect.currentSpan.pipe(Effect.map((_) => _.name), Effect.tap((_) => Effect.sync(() => expect(_).toBe("Test Action"))))
         ),
         // WithToast.handle({
         //   onFailure: "failed",
@@ -326,7 +325,7 @@ it.live("with toasts", () =>
         //   onWaiting: null
         // }),
         Command.withDefaultToast(),
-        Effect.tap(() => executed = true)
+        Effect.tap(() => Effect.sync(() => executed = true))
       )
 
       const r = yield* unwrap(command.handle())
@@ -352,16 +351,16 @@ it.live("interrupted", () =>
           return "test-value"
         },
         Command.withDefaultToast(),
-        Effect.tap(() => executed = true)
+        Effect.tap(() => Effect.sync(() => executed = true))
       )
 
       const r = yield* Fiber.join(command.handle())
 
       expect(executed).toBe(false) // we were interrupted after all :)
-      expect(Exit.isInterrupted(r)).toBe(true) // to confirm that the initial function has interrupted
+      expect(Exit.hasInterrupts(r)).toBe(true) // to confirm that the initial function has interrupted
 
       expect(command.waiting).toBe(false)
-      expect(Exit.isInterrupted(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?
     }))
 
@@ -378,16 +377,16 @@ it.live("fail", () =>
           return yield* Effect.fail({ message: "Boom!" })
         },
         Command.withDefaultToast(),
-        Effect.tap(() => executed = true)
+        Effect.tap(() => Effect.sync(() => executed = true))
       )
 
       const r = yield* Fiber.join(command.handle())
 
       expect(executed).toBe(false) // we failed after all :)
-      expect(Exit.isFailure(r) && Cause.isFailure(r.cause)).toBe(true) // to confirm that the initial function has failed
+      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!")
     }))
@@ -404,9 +403,9 @@ it.live("fail and recover", () =>
           expect(toasts.length).toBe(1)
           return yield* Effect.fail({ message: "Boom!" })
         },
-        Effect.catchAll(() => Effect.succeed("recovered")), // we recover from the error here, so the final result is success
+        Effect.orElseSucceed(() => "recovered"), // we recover from the error here, so the final result is success
         Command.withDefaultToast(),
-        Effect.tap(() => executed = true)
+        Effect.tap(() => Effect.sync(() => executed = true))
       )
 
       const r = yield* unwrap(command.handle())
@@ -415,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")
     }))
@@ -433,17 +432,17 @@ it.live("defect", () =>
           return yield* Effect.die({ message: "Boom!" })
         },
         Command.withDefaultToast(),
-        Effect.tap(() => executed = true)
+        Effect.tap(() => Effect.sync(() => executed = true))
       )
 
       const r = yield* Fiber.join(command.handle())
       // TODO: confirm we reported error
 
       expect(executed).toBe(false) // we died after all :)
-      expect(Exit.isFailure(r) && Cause.isDie(r.cause)).toBe(true) // to confirm that the initial function has died
+      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.")
     }))
@@ -472,9 +471,9 @@ it.live("works with alt", () =>
             expect(yield* Effect.currentSpan.pipe(Effect.map((_) => _.name))).toBe("Test Action")
           })),
           Effect.tap(() =>
-            Effect.currentSpan.pipe(Effect.map((_) => _.name), Effect.tap((_) => expect(_).toBe("Test Action")))
+            Effect.currentSpan.pipe(Effect.map((_) => _.name), Effect.tap((_) => Effect.sync(() => expect(_).toBe("Test Action"))))
           ),
-          Effect.tap(() => executed = true)
+          Effect.tap(() => Effect.sync(() => executed = true))
         )
       )
       expect(command.action).toBe("Test Action")
@@ -485,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)
     }))
@@ -509,7 +508,7 @@ it.live("has custom action name with alt", () =>
             expect(yield* CommandContext).toMatchObject({ action: "Test Action Translated", id: "Test Action" })
             return "test-value"
           },
-          Effect.tap(() => executed = true)
+          Effect.tap(() => Effect.sync(() => executed = true))
         )
       )
       expect(command.action).toBe("Test Action Translated")
@@ -534,7 +533,7 @@ it.live("can map the result with alt", () =>
           return "test-value"
         },
         Effect.map((_) => _ + _),
-        Effect.tap(() => executed = true)
+        Effect.tap(() => Effect.sync(() => executed = true))
       ))
       const r = yield* unwrap(command.handle())
 
@@ -560,7 +559,7 @@ it.live("can receive and use input with alt", () =>
             }
           )
           .pipe(
-            Effect.tap(() => executed = true)
+            Effect.tap(() => Effect.sync(() => executed = true))
           )
       )
       const r = yield* unwrap(command.handle(1))
@@ -590,8 +589,8 @@ it.live("can replace the result with alt", () =>
 
             return "test-value"
           },
-          Effect.zipRight(Effect.succeed(42)),
-          Effect.tap(() => executed = true)
+          Effect.andThen(Effect.succeed(42)),
+          Effect.tap(() => Effect.sync(() => executed = true))
         )
       )
       const r = yield* unwrap(command.handle())
@@ -625,10 +624,10 @@ it.live("with toasts with alt", () =>
             expect(yield* Effect.currentSpan.pipe(Effect.map((_) => _.name))).toBe("Test Action")
           })),
           Effect.tap(() =>
-            Effect.currentSpan.pipe(Effect.map((_) => _.name), Effect.tap((_) => expect(_).toBe("Test Action")))
+            Effect.currentSpan.pipe(Effect.map((_) => _.name), Effect.tap((_) => Effect.sync(() => expect(_).toBe("Test Action"))))
           ),
           Command.withDefaultToast(),
-          Effect.tap(() => executed = true)
+          Effect.tap(() => Effect.sync(() => executed = true))
         )
       )
 
@@ -657,17 +656,17 @@ it.live("interrupted with alt", () =>
             return "test-value"
           },
           Command.withDefaultToast(),
-          Effect.tap(() => executed = true)
+          Effect.tap(() => Effect.sync(() => executed = true))
         )
       )
 
       const r = yield* Fiber.join(command.handle())
 
       expect(executed).toBe(false) // we were interrupted after all :)
-      expect(Exit.isInterrupted(r)).toBe(true) // to confirm that the initial function has interrupted
+      expect(Exit.hasInterrupts(r)).toBe(true) // to confirm that the initial function has interrupted
 
       expect(command.waiting).toBe(false)
-      expect(Exit.isInterrupted(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?
     }))
 
@@ -685,17 +684,17 @@ it.live("fail with alt", () =>
             return yield* Effect.fail({ message: "Boom!" })
           },
           Command.withDefaultToast(),
-          Effect.tap(() => executed = true)
+          Effect.tap(() => Effect.sync(() => executed = true))
         )
       )
 
       const r = yield* Fiber.join(command.handle())
 
       expect(executed).toBe(false) // we failed after all :)
-      expect(Exit.isFailure(r) && Cause.isFailure(r.cause)).toBe(true) // to confirm that the initial function has failed
+      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!")
     }))
@@ -713,9 +712,9 @@ it.live("fail and recover with alt", () =>
             expect(toasts.length).toBe(1)
             return yield* Effect.fail({ message: "Boom!" })
           },
-          Effect.catchAll(() => Effect.succeed("recovered")), // we recover from the error here, so the final result is success
+          Effect.orElseSucceed(() => "recovered"), // we recover from the error here, so the final result is success
           Command.withDefaultToast(),
-          Effect.tap(() => executed = true)
+          Effect.tap(() => Effect.sync(() => executed = true))
         )
       )
 
@@ -725,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")
     }))
@@ -744,7 +743,7 @@ it.live("defect with alt", () =>
             return yield* Effect.die({ message: "Boom!" })
           },
           Command.withDefaultToast(),
-          Effect.tap(() => executed = true)
+          Effect.tap(() => Effect.sync(() => executed = true))
         )
       )
 
@@ -752,10 +751,10 @@ it.live("defect with alt", () =>
       // TODO: confirm we reported error
 
       expect(executed).toBe(false) // we died after all :)
-      expect(Exit.isFailure(r) && Cause.isDie(r.cause)).toBe(true) // to confirm that the initial function has died
+      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/form.test.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"form.test.d.ts","sourceRoot":"","sources":["../form.test.ts"],"names":[],"mappings":"AAAA,OAAO,EAAU,CAAC,EAAE,MAAM,YAAY,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAGtC,qBAAa,YAAa,SAAQ,iBAShC;CAAG;;;;;;;;;;;;;;;;;;;AAEL,qBAAa,mBAAoB,SAAQ,wBAEvC;CAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEL,qBAAa,WAAY,SAAQ,gBAK/B;CAAG;;;;;;;;;;;;;AAEL,cAAM,MAAO,SAAQ,WAEnB;CAAG;;;;;;;;;;;;;AAEL,cAAM,MAAO,SAAQ,WAEnB;CAAG;;;;;;;;;;;;;;;;;;AAEL,cAAM,QAAS,SAAQ,aAGrB;CAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqBL,qBAAa,cAAe,SAAQ,mBAGlC;CAAG"}
+{"version":3,"file":"form.test.d.ts","sourceRoot":"","sources":["../form.test.ts"],"names":[],"mappings":"AAAA,OAAO,EAAU,CAAC,EAAE,MAAM,YAAY,CAAA;;;;;;;;;;;;;;;;;AAGtC,qBAAa,YAAa,SAAQ,iBAShC;CAAG;;;;AAEL,qBAAa,mBAAoB,SAAQ,wBAEvC;CAAG;;;;;;;;;;;AAEL,qBAAa,WAAY,SAAQ,gBAK/B;CAAG;;;;;;;;AAEL,cAAM,MAAO,SAAQ,WAEnB;CAAG;;;;;;;;AAEL,cAAM,MAAO,SAAQ,WAEnB;CAAG;;;;;;;;;;;AAEL,cAAM,QAAS,SAAQ,aAGrB;CAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqBL,qBAAa,cAAe,SAAQ,mBAGlC;CAAG"}

package/test/dist/stubs.d.ts

@@ -18,67 +18,125 @@ declare const RequestContextMap_base: (new () => {
     readonly config: {};
 }) & {
     config: {};
-    getConfig: (rpc: import("@effect/rpc/Rpc").AnyWithProps) => RpcContextMap.GetContextConfig<{}>;
+    getConfig: (rpc: import("effect/unstable/rpc/Rpc").AnyWithProps) => RpcContextMap.GetContextConfig<{}>;
     get: <Key extends never>(key: Key) => import("effect-app/rpc/RpcMiddleware").RpcDynamic<Key, {}[Key]>;
 };
 export declare class RequestContextMap extends RequestContextMap_base {
 }
-export declare const Req: <Self>() => {
+export declare const Req: <_Self>() => {
     <Tag extends string, Payload extends S.Struct.Fields, C extends {
-        success: S.Schema.Any | S.Struct.Fields;
-        failure: S.Schema.Any | S.Struct.Fields;
-    }>(tag: Tag, fields: Payload, config: RpcContextMap.GetContextConfig<{}> & C): S.TaggedRequestClass<Self, Tag, {
-        readonly _tag: S.tag<Tag>;
-    } & Payload, (RpcContextMap.GetContextConfig<{}> & C)["success"] extends infer T ? T extends (RpcContextMap.GetContextConfig<{}> & C)["success"] ? T extends S.Struct.Fields ? S.TypeLiteral<T, []> : T extends S.Schema.Any ? T : never : never : never, S.Union<[(RpcContextMap.GetContextConfig<{}> & C)["failure"] extends infer T_1 ? T_1 extends (RpcContextMap.GetContextConfig<{}> & C)["failure"] ? T_1 extends S.Struct.Fields ? S.TypeLiteral<T_1, []> : T_1 extends S.Schema.Any ? T_1 : never : never : never]>> & {
-        config: Omit<C, "success" | "failure">;
+        success: S.Top | S.Struct.Fields;
+        error: S.Top | S.Struct.Fields;
+    }>(tag: Tag, fields: Payload, config: RpcContextMap.GetContextConfig<{}> & C): S.TaggedStruct<Tag, Payload> & {
+        new (...args: any[]): any;
+        readonly _tag: Tag;
+        readonly fields: {
+            readonly _tag: S.tag<Tag>;
+        } & Payload;
+        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;
+        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>;
     };
     <Tag extends string, Payload_1 extends S.Struct.Fields, C_1 extends Pick<{
-        success: S.Schema.Any | S.Struct.Fields;
-        failure: S.Schema.Any | S.Struct.Fields;
-    }, "success">>(tag: Tag, fields: Payload_1, config: RpcContextMap.GetContextConfig<{}> & C_1): S.TaggedRequestClass<Self, Tag, {
-        readonly _tag: S.tag<Tag>;
-    } & Payload_1, (RpcContextMap.GetContextConfig<{}> & C_1)["success"] extends infer T ? T extends (RpcContextMap.GetContextConfig<{}> & C_1)["success"] ? T extends S.Struct.Fields ? S.TypeLiteral<T, []> : T extends S.Schema.Any ? T : never : never : never, S.Union<[never]>> & {
-        config: Omit<C_1, "success" | "failure">;
+        success: S.Top | S.Struct.Fields;
+        error: S.Top | S.Struct.Fields;
+    }, "success">>(tag: Tag, fields: Payload_1, config: RpcContextMap.GetContextConfig<{}> & C_1): S.TaggedStruct<Tag, Payload_1> & {
+        new (...args: any[]): any;
+        readonly _tag: Tag;
+        readonly fields: {
+            readonly _tag: S.tag<Tag>;
+        } & Payload_1;
+        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;
+        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>;
     };
     <Tag extends string, Payload_2 extends S.Struct.Fields, C_2 extends Pick<{
-        success: S.Schema.Any | S.Struct.Fields;
-        failure: S.Schema.Any | S.Struct.Fields;
-    }, "failure">>(tag: Tag, fields: Payload_2, config: RpcContextMap.GetContextConfig<{}> & C_2): S.TaggedRequestClass<Self, Tag, {
-        readonly _tag: S.tag<Tag>;
-    } & Payload_2, typeof S.Void, S.Union<[(RpcContextMap.GetContextConfig<{}> & C_2)["failure"] extends infer T ? T extends (RpcContextMap.GetContextConfig<{}> & C_2)["failure"] ? T extends S.Struct.Fields ? S.TypeLiteral<T, []> : T extends S.Schema.Any ? T : never : never : never]>> & {
-        config: Omit<C_2, "success" | "failure">;
+        success: S.Top | S.Struct.Fields;
+        error: S.Top | S.Struct.Fields;
+    }, "error">>(tag: Tag, fields: Payload_2, config: RpcContextMap.GetContextConfig<{}> & C_2): S.TaggedStruct<Tag, Payload_2> & {
+        new (...args: any[]): any;
+        readonly _tag: Tag;
+        readonly fields: {
+            readonly _tag: S.tag<Tag>;
+        } & Payload_2;
+        readonly success: S.Schema<void>;
+        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;
+        readonly config: Omit<C_2, "success" | "error">;
+        readonly "~decodingServices": unknown;
     };
-    <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.TaggedRequestClass<Self, Tag, {
-        readonly _tag: S.tag<Tag>;
-    } & Payload_3, typeof S.Void, S.Union<[never]>> & {
-        config: Omit<C_3, "success" | "failure">;
+    <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;
+        readonly _tag: Tag;
+        readonly fields: {
+            readonly _tag: S.tag<Tag>;
+        } & Payload_3;
+        readonly success: S.Schema<void>;
+        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;
+        readonly config: Omit<C_3, "success" | "error">;
+        readonly "~decodingServices": unknown;
     };
-    <Tag extends string, Payload_4 extends S.Struct.Fields>(tag: Tag, fields: Payload_4): S.TaggedRequestClass<Self, Tag, {
-        readonly _tag: S.tag<Tag>;
-    } & Payload_4, typeof S.Void, never> & {
-        config: {};
+    <Tag extends string, Payload_4 extends S.Struct.Fields>(tag: Tag, fields: Payload_4): S.TaggedStruct<Tag, Payload_4> & {
+        new (...args: any[]): any;
+        readonly _tag: Tag;
+        readonly fields: {
+            readonly _tag: S.tag<Tag>;
+        } & Payload_4;
+        readonly success: S.Schema<void>;
+        readonly error: never;
+        readonly config: Record<string, never>;
+        readonly "~decodingServices": unknown;
     };
 };
-declare const GetSomething2_base: S.TaggedRequestClass<GetSomething2, "GetSomething2", {
-    readonly _tag: S.tag<"GetSomething2">;
-} & {
-    id: typeof S.String;
-}, typeof S.NumberFromString, S.Union<[never]>> & {
-    config: Omit<{
-        success: typeof S.NumberFromString;
-    }, "success" | "failure">;
+declare const GetSomething2_base: S.TaggedStruct<"GetSomething2", {
+    id: S.String;
+}> & {
+    new (...args: any[]): any;
+    readonly _tag: "GetSomething2";
+    readonly fields: {
+        readonly _tag: S.tag<"GetSomething2">;
+    } & {
+        id: S.String;
+    };
+    readonly success: S.NumberFromString;
+    readonly error: S.Void;
+    readonly config: Omit<{
+        success: S.NumberFromString;
+    }, "success" | "error">;
+    readonly "~decodingServices": never;
 };
 export declare class GetSomething2 extends GetSomething2_base {
 }
-declare const GetSomething2WithDependencies_base: S.TaggedRequestClass<GetSomething2WithDependencies, "GetSomething2", {
-    readonly _tag: S.tag<"GetSomething2">;
-} & {
-    id: typeof S.String;
-}, S.Schema<number, string, "dep-a">, S.Union<[S.Schema<string, string, "dep-b">]>> & {
-    config: Omit<{
-        success: S.Schema<number, string, "dep-a">;
-        failure: S.Schema<string, string, "dep-b">;
-    }, "success" | "failure">;
+declare const GetSomething2WithDependencies_base: S.TaggedStruct<"GetSomething2", {
+    id: S.String;
+}> & {
+    new (...args: any[]): any;
+    readonly _tag: "GetSomething2";
+    readonly fields: {
+        readonly _tag: S.tag<"GetSomething2">;
+    } & {
+        id: S.String;
+    };
+    readonly success: S.Codec<number, string, "dep-a", never>;
+    readonly error: S.String;
+    readonly config: Omit<{
+        success: S.Codec<number, string, "dep-a">;
+        error: S.String;
+    }, "success" | "error">;
+    readonly "~decodingServices": "dep-a";
 };
 export declare class GetSomething2WithDependencies extends GetSomething2WithDependencies_base {
 }

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

@@ -1 +1 @@
-{"version":3,"file":"stubs.d.ts","sourceRoot":"","sources":["../stubs.ts"],"names":[],"mappings":"AAEA,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;AAE9C,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;AA2CxD,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,oCAGzG,CAAA;AAEH,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;;;;;;;iBAKL,CAAC,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,CAAC;iBAC3C,CAAC,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,CAAC;;;AAJxD,qBAAa,6BAA8B,SAAQ,kCAKjD;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"}

package/test/dist/stubs.js

@@ -1,9 +1,8 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-import { FetchHttpClient } from "@effect/platform";
 import * as Intl from "@formatjs/intl";
 import { Effect, Layer, ManagedRuntime, Option, S } from "effect-app";
 import { ApiClientFactory, makeRpcClient } from "effect-app/client";
 import { RpcContextMap } from "effect-app/rpc";
+import * as FetchHttpClient from "effect/unstable/http/FetchHttpClient";
 import { ref } from "vue";
 import { Commander } from "../src/experimental/commander.js";
 import { I18n } from "../src/experimental/intl.js";
@@ -11,7 +10,7 @@ import { makeUseCommand } from "../src/experimental/makeUseCommand.js";
 import * as Toast from "../src/experimental/toast.js";
 import { WithToast } from "../src/experimental/withToast.js";
 import { LegacyMutation, makeClient } from "../src/makeClient.js";
-const fakeToastLayer = (toasts = []) => Toast.Toast.toLayer(Effect.sync(() => {
+const fakeToastLayer = (toasts = []) => Layer.effect(Toast.Toast, Effect.sync(() => {
     const dismiss = (id) => {
         const idx = toasts.findIndex((_) => _.id === id);
         if (idx > -1) {
@@ -42,13 +41,13 @@ const fakeToastLayer = (toasts = []) => Toast.Toast.toLayer(Effect.sync(() => {
         }
         return id;
     };
-    return Toast.wrap({
+    return Toast.Toast.of(Toast.wrap({
         error: fakeToast,
         warning: fakeToast,
         success: fakeToast,
         info: fakeToast,
         dismiss
-    });
+    }));
 }));
 export const makeFakeIntl = (messages = {}) => {
     const locale = ref("en");
@@ -66,7 +65,7 @@ export const makeFakeIntl = (messages = {}) => {
         }
     };
 };
-export const fakeIntlLayer = (messages = {}) => I18n.toLayer(Effect.sync(() => makeFakeIntl(messages)));
+export const fakeIntlLayer = (messages = {}) => Layer.effect(I18n, Effect.sync(() => I18n.of(makeFakeIntl(messages))));
 export const useExperimental = (options) => {
     const FakeIntlLayer = fakeIntlLayer(options?.messages);
     const FakeToastLayer = fakeToastLayer(options?.toasts);
@@ -85,8 +84,9 @@ export class GetSomething2 extends Req()("GetSomething2", {
 export class GetSomething2WithDependencies extends Req()("GetSomething2", {
     id: S.String
 }, {
+    // this is intentilally fake, to simulate a codec that requires a dependency
     success: S.NumberFromString,
-    failure: S.String
+    error: S.String
 }) {
 }
 export const Something = { GetSomething2, GetSomething2WithDependencies, meta: { moduleName: "Something" } };
@@ -101,4 +101,4 @@ export const useClient = (options) => {
     const clientFor_ = ApiClientFactory.makeFor(Layer.empty);
     return makeClient(() => ManagedRuntime.make(layers), clientFor_, Layer.empty);
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3R1YnMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zdHVicy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFFQSxPQUFPLEtBQUssSUFBSSxNQUFNLGdCQUFnQixDQUFBO0FBQ3RDLE9BQU8sRUFBRSxNQUFNLEVBQUUsS0FBSyxFQUFFLGNBQWMsRUFBRSxNQUFNLEVBQUUsQ0FBQyxFQUFFLE1BQU0sWUFBWSxDQUFBO0FBQ3JFLE9BQU8sRUFBRSxnQkFBZ0IsRUFBRSxhQUFhLEVBQUUsTUFBTSxtQkFBbUIsQ0FBQTtBQUNuRSxPQUFPLEVBQUUsYUFBYSxFQUFFLE1BQU0sZ0JBQWdCLENBQUE7QUFDOUMsT0FBTyxLQUFLLGVBQWUsTUFBTSxzQ0FBc0MsQ0FBQTtBQUN2RSxPQUFPLEVBQUUsR0FBRyxFQUFFLE1BQU0sS0FBSyxDQUFBO0FBQ3pCLE9BQU8sRUFBRSxTQUFTLEVBQUUsTUFBTSxrQ0FBa0MsQ0FBQTtBQUM1RCxPQUFPLEVBQUUsSUFBSSxFQUFFLE1BQU0sNkJBQTZCLENBQUE7QUFDbEQsT0FBTyxFQUFFLGNBQWMsRUFBRSxNQUFNLHVDQUF1QyxDQUFBO0FBQ3RFLE9BQU8sS0FBSyxLQUFLLE1BQU0sOEJBQThCLENBQUE7QUFDckQsT0FBTyxFQUFFLFNBQVMsRUFBRSxNQUFNLGtDQUFrQyxDQUFBO0FBQzVELE9BQU8sRUFBRSxjQUFjLEVBQUUsVUFBVSxFQUFFLE1BQU0sc0JBQXNCLENBQUE7QUFHakUsTUFBTSxjQUFjLEdBQUcsQ0FBQyxTQUFnQixFQUFFLEVBQUUsRUFBRSxDQUM1QyxLQUFLLENBQUMsTUFBTSxDQUNWLEtBQUssQ0FBQyxLQUFLLEVBQ1gsTUFBTSxDQUFDLElBQUksQ0FBQyxHQUFHLEVBQUU7SUFDZixNQUFNLE9BQU8sR0FBRyxDQUFDLEVBQWlCLEVBQUUsRUFBRTtRQUNwQyxNQUFNLEdBQUcsR0FBRyxNQUFNLENBQUMsU0FBUyxDQUFDLENBQUMsQ0FBQyxFQUFFLEVBQUUsQ0FBQyxDQUFDLENBQUMsRUFBRSxLQUFLLEVBQUUsQ0FBQyxDQUFBO1FBQ2hELElBQUksR0FBRyxHQUFHLENBQUMsQ0FBQyxFQUFFLENBQUM7WUFDYixNQUFNLEtBQUssR0FBRyxNQUFNLENBQUMsR0FBRyxDQUFDLENBQUE7WUFDekIsWUFBWSxDQUFDLEtBQUssQ0FBQyxTQUFTLENBQUMsQ0FBQTtZQUM3QixNQUFNLENBQUMsTUFBTSxDQUFDLEdBQUcsRUFBRSxDQUFDLENBQUMsQ0FBQTtRQUN2QixDQUFDO0lBQ0gsQ0FBQyxDQUFBO0lBQ0QsTUFBTSxTQUFTLEdBQUcsQ0FBQyxPQUFlLEVBQUUsT0FBeUIsRUFBRSxFQUFFO1FBQy9ELE1BQU0sRUFBRSxHQUFHLE9BQU8sRUFBRSxFQUFFLElBQUksSUFBSSxDQUFDLE1BQU0sRUFBRSxDQUFDLFFBQVEsQ0FBQyxFQUFFLENBQUMsQ0FBQyxTQUFTLENBQUMsQ0FBQyxFQUFFLEVBQUUsQ0FBQyxDQUFBO1FBQ3JFLE9BQU8sQ0FBQyxHQUFHLENBQUMsVUFBVSxFQUFFLE1BQU0sT0FBTyxFQUFFLEVBQUUsT0FBTyxDQUFDLENBQUE7UUFFakQsT0FBTyxHQUFHLEVBQUUsR0FBRyxPQUFPLEVBQUUsRUFBRSxFQUFFLENBQUE7UUFDNUIsTUFBTSxHQUFHLEdBQUcsTUFBTSxDQUFDLFNBQVMsQ0FBQyxDQUFDLENBQUMsRUFBRSxFQUFFLENBQUMsQ0FBQyxDQUFDLEVBQUUsS0FBSyxFQUFFLENBQUMsQ0FBQTtRQUNoRCxJQUFJLEdBQUcsR0FBRyxDQUFDLENBQUMsRUFBRSxDQUFDO1lBQ2IsTUFBTSxLQUFLLEdBQUcsTUFBTSxDQUFDLEdBQUcsQ0FBQyxDQUFBO1lBQ3pCLFlBQVksQ0FBQyxLQUFLLENBQUMsU0FBUyxDQUFDLENBQUE7WUFDN0IsTUFBTSxDQUFDLE1BQU0sQ0FBQyxLQUFLLEVBQUUsRUFBRSxPQUFPLEVBQUUsT0FBTyxFQUFFLENBQUMsQ0FBQTtZQUMxQyxLQUFLLENBQUMsU0FBUyxHQUFHLFVBQVUsQ0FBQyxHQUFHLEVBQUU7Z0JBQ2hDLE1BQU0sQ0FBQyxNQUFNLENBQUMsR0FBRyxFQUFFLENBQUMsQ0FBQyxDQUFBO1lBQ3ZCLENBQUMsRUFBRSxPQUFPLEVBQUUsT0FBTyxJQUFJLElBQUksQ0FBQyxDQUFBO1FBQzlCLENBQUM7YUFBTSxDQUFDO1lBQ04sTUFBTSxLQUFLLEdBQVEsRUFBRSxFQUFFLEVBQUUsT0FBTyxFQUFFLE9BQU8sRUFBRSxDQUFBO1lBQzNDLEtBQUssQ0FBQyxTQUFTLEdBQUcsVUFBVSxDQUFDLEdBQUcsRUFBRTtnQkFDaEMsTUFBTSxDQUFDLE1BQU0sQ0FBQyxHQUFHLEVBQUUsQ0FBQyxDQUFDLENBQUE7WUFDdkIsQ0FBQyxFQUFFLE9BQU8sRUFBRSxPQUFPLElBQUksSUFBSSxDQUFDLENBQUE7WUFDNUIsTUFBTSxDQUFDLElBQUksQ0FBQyxLQUFLLENBQUMsQ0FBQTtRQUNwQixDQUFDO1FBQ0QsT0FBTyxFQUFFLENBQUE7SUFDWCxDQUFDLENBQUE7SUFDRCxPQUFPLEtBQUssQ0FBQyxLQUFLLENBQUMsRUFBRSxDQUFDLEtBQUssQ0FBQyxJQUFJLENBQUM7UUFDL0IsS0FBSyxFQUFFLFNBQVM7UUFDaEIsT0FBTyxFQUFFLFNBQVM7UUFDbEIsT0FBTyxFQUFFLFNBQVM7UUFDbEIsSUFBSSxFQUFFLFNBQVM7UUFDZixPQUFPO0tBQ1IsQ0FBQyxDQUFRLENBQUE7QUFDWixDQUFDLENBQUMsQ0FDSCxDQUFBO0FBRUgsTUFBTSxDQUFDLE1BQU0sWUFBWSxHQUFHLENBQUMsV0FBNEUsRUFBRSxFQUFFLEVBQUU7SUFDN0csTUFBTSxNQUFNLEdBQUcsR0FBRyxDQUFDLElBQWEsQ0FBQyxDQUFBO0lBQ2pDLE1BQU0sU0FBUyxHQUFHLElBQUksQ0FBQyxlQUFlLEVBQUUsQ0FBQTtJQUN4QyxNQUFNLElBQUksR0FBRyxJQUFJLENBQUMsVUFBVSxDQUFzQjtRQUNoRCxNQUFNLEVBQUUsTUFBTSxDQUFDLEtBQUs7UUFDcEIsUUFBUTtLQUNULEVBQUUsU0FBUyxDQUFDLENBQUE7SUFFYixPQUFPO1FBQ0wsTUFBTTtRQUNOLElBQUk7UUFDSixLQUFLLEVBQUUsQ0FBQyxFQUFFLEVBQUUsTUFBTSxFQUFFLEVBQUUsQ0FBQyxJQUFJLENBQUMsYUFBYSxDQUFDLEVBQUUsRUFBRSxFQUFFLEVBQUUsTUFBTSxDQUFDO1FBQ3pELElBQUksYUFBYTtZQUNmLE9BQU8sSUFBSSxDQUFDLGFBQWEsQ0FBQTtRQUMzQixDQUFDO0tBQytDLENBQUE7QUFDcEQsQ0FBQyxDQUFBO0FBRUQsTUFBTSxDQUFDLE1BQU0sYUFBYSxHQUFHLENBQUMsV0FBNEUsRUFBRSxFQUFFLEVBQUUsQ0FDOUcsS0FBSyxDQUFDLE1BQU0sQ0FBQyxJQUFJLEVBQUUsTUFBTSxDQUFDLElBQUksQ0FBQyxHQUFHLEVBQUUsQ0FBQyxJQUFJLENBQUMsRUFBRSxDQUFDLFlBQVksQ0FBQyxRQUFRLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQTtBQUV4RSxNQUFNLENBQUMsTUFBTSxlQUFlLEdBQUcsQ0FDN0IsT0FBdUcsRUFDdkcsRUFBRTtJQUNGLE1BQU0sYUFBYSxHQUFHLGFBQWEsQ0FBQyxPQUFPLEVBQUUsUUFBUSxDQUFDLENBQUE7SUFDdEQsTUFBTSxjQUFjLEdBQUcsY0FBYyxDQUFDLE9BQU8sRUFBRSxNQUFNLENBQUMsQ0FBQTtJQUN0RCxNQUFNLGNBQWMsR0FBRyxTQUFTLENBQUMsT0FBTyxDQUFDLElBQUksQ0FBQyxLQUFLLENBQUMsT0FBTyxDQUFDLENBQUMsYUFBYSxFQUFFLGNBQWMsQ0FBQyxDQUFDLENBQUMsQ0FBQTtJQUM3RixNQUFNLGNBQWMsR0FBRyxTQUFTLENBQUMsT0FBTyxDQUFDLElBQUksQ0FBQyxLQUFLLENBQUMsT0FBTyxDQUFDLGNBQWMsQ0FBQyxDQUFDLENBQUE7SUFDNUUsTUFBTSxNQUFNLEdBQUcsS0FBSyxDQUFDLFFBQVEsQ0FBQyxjQUFjLEVBQUUsY0FBYyxFQUFFLGNBQWMsRUFBRSxhQUFhLENBQUMsQ0FBQTtJQUU1RixPQUFPLE1BQU0sQ0FBQyxPQUFPLENBQUMsY0FBYyxDQUFpQyxLQUFLLENBQUMsS0FBSyxDQUFDLENBQUMsSUFBSSxDQUFDLE1BQU0sQ0FBQyxPQUFPLENBQUMsTUFBTSxDQUFDLENBQUMsQ0FBQyxDQUFBO0FBQ2pILENBQUMsQ0FBQTtBQUVELE1BQU0sT0FBTyxpQkFBa0IsU0FBUSxhQUFhLENBQUMsT0FBTyxDQUFDLEVBQUUsQ0FBQztDQUFHO0FBQ25FLE1BQU0sQ0FBQyxNQUFNLEVBQUUsYUFBYSxFQUFFLEdBQUcsRUFBRSxHQUFHLGFBQWEsQ0FBQyxpQkFBaUIsQ0FBQyxDQUFBO0FBQ3RFLE1BQU0sT0FBTyxhQUFjLFNBQVEsR0FBRyxFQUFpQixDQUFDLGVBQWUsRUFBRTtJQUN2RSxFQUFFLEVBQUUsQ0FBQyxDQUFDLE1BQU07Q0FDYixFQUFFLEVBQUUsT0FBTyxFQUFFLENBQUMsQ0FBQyxnQkFBZ0IsRUFBRSxDQUFDO0NBQUc7QUFFdEMsTUFBTSxPQUFPLDZCQUE4QixTQUFRLEdBQUcsRUFBaUMsQ0FBQyxlQUFlLEVBQUU7SUFDdkcsRUFBRSxFQUFFLENBQUMsQ0FBQyxNQUFNO0NBQ2IsRUFBRTtJQUNELDRFQUE0RTtJQUM1RSxPQUFPLEVBQUUsQ0FBQyxDQUFDLGdCQUFvRDtJQUMvRCxLQUFLLEVBQUUsQ0FBQyxDQUFDLE1BQU07Q0FDaEIsQ0FBQztDQUFHO0FBRUwsTUFBTSxDQUFDLE1BQU0sU0FBUyxHQUFHLEVBQUUsYUFBYSxFQUFFLDZCQUE2QixFQUFFLElBQUksRUFBRSxFQUFFLFVBQVUsRUFBRSxXQUFvQixFQUFFLEVBQUUsQ0FBQTtBQUVySCxNQUFNLENBQUMsTUFBTSxTQUFTLEdBQUcsQ0FDdkIsT0FBdUcsRUFDdkcsRUFBRTtJQUNGLE1BQU0sYUFBYSxHQUFHLGFBQWEsQ0FBQyxPQUFPLEVBQUUsUUFBUSxDQUFDLENBQUE7SUFDdEQsTUFBTSxjQUFjLEdBQUcsY0FBYyxDQUFDLE9BQU8sRUFBRSxNQUFNLENBQUMsQ0FBQTtJQUN0RCxNQUFNLGNBQWMsR0FBRyxTQUFTLENBQUMsT0FBTyxDQUFDLElBQUksQ0FBQyxLQUFLLENBQUMsT0FBTyxDQUFDLENBQUMsYUFBYSxFQUFFLGNBQWMsQ0FBQyxDQUFDLENBQUMsQ0FBQTtJQUM3RixNQUFNLGNBQWMsR0FBRyxTQUFTLENBQUMsT0FBTyxDQUFDLElBQUksQ0FBQyxLQUFLLENBQUMsT0FBTyxDQUFDLGNBQWMsQ0FBQyxDQUFDLENBQUE7SUFDNUUsTUFBTSxHQUFHLEdBQUcsZ0JBQWdCLENBQUMsS0FBSyxDQUFDLEVBQUUsR0FBRyxFQUFFLE9BQU8sRUFBRSxPQUFPLEVBQUUsTUFBTSxDQUFDLElBQUksRUFBRSxFQUFFLENBQUMsQ0FBQyxJQUFJLENBQy9FLEtBQUssQ0FBQyxPQUFPLENBQUMsZUFBZSxDQUFDLEtBQUssQ0FBQyxDQUNyQyxDQUFBO0lBQ0QsTUFBTSxFQUFFLEdBQUcsY0FBYyxDQUFDLE9BQU8sQ0FBQyxJQUFJLENBQUMsS0FBSyxDQUFDLE9BQU8sQ0FBQyxDQUFDLGFBQWEsRUFBRSxjQUFjLENBQUMsQ0FBQyxDQUFDLENBQUE7SUFDdEYsTUFBTSxNQUFNLEdBQUcsS0FBSyxDQUFDLFFBQVEsQ0FBQyxjQUFjLEVBQUUsY0FBYyxFQUFFLGNBQWMsRUFBRSxhQUFhLEVBQUUsR0FBRyxFQUFFLEVBQUUsQ0FBQyxDQUFBO0lBRXJHLE1BQU0sVUFBVSxHQUFHLGdCQUFnQixDQUFDLE9BQU8sQ0FBQyxLQUFLLENBQUMsS0FBSyxDQUFDLENBQUE7SUFDeEQsT0FBTyxVQUFVLENBQUMsR0FBRyxFQUFFLENBQUMsY0FBYyxDQUFDLElBQUksQ0FBQyxNQUFNLENBQUMsRUFBRSxVQUFVLEVBQUUsS0FBSyxDQUFDLEtBQUssQ0FBQyxDQUFBO0FBQy9FLENBQUMsQ0FBQSJ9