@effect-app/infra 3.10.0 → 4.0.0-beta.1

package/test/dist/fixtures.d.ts

@@ -1,85 +1,41 @@
-import { Context, Effect, Layer, S, Scope } from "effect-app";
+import { Effect, Layer, S, ServiceMap } from "effect-app";
 import { NotLoggedInError, UnauthorizedError } from "effect-app/client";
 import { RpcContextMap, RpcX } from "effect-app/rpc";
-declare const UserProfile_base: S.EnhancedClass<UserProfile, {
-    id: typeof S.String;
-    roles: S.Array$<typeof S.String> & {
-        withDefault: S.PropertySignature<":", readonly string[], never, ":", readonly string[], true, never>;
+declare const UserProfile_base: S.EnhancedClass<UserProfile, S.Struct<{
+    id: S.String;
+    roles: S.$Array<S.String> & {
+        withDefault: S.withConstructorDefault<S.$Array<S.String> & S.WithoutConstructorDefault>;
     };
-}, {
-    readonly id: string;
-    readonly roles: readonly string[];
-}, never, {
-    readonly id: string;
-    readonly roles: readonly string[];
-}, {}, {}> & Context.Tag<UserProfile, UserProfile>;
+}>, {}> & ServiceMap.Opaque<UserProfile, UserProfile>;
 export declare class UserProfile extends UserProfile_base {
 }
-declare const Some_base: (abstract new (service: {
-    a: number;
-}) => Readonly<{
-    a: number;
-}> & Context.TagClassShape<"Some", {
-    a: number;
-}>) & {
-    toLayer: {
-        (): Layer.Layer<Some, never, never>;
-        <E_1, R_1>(eff: Effect.Effect<Omit<Some, keyof Context.TagClassShape<any, any>>, E_1, R_1>): Layer.Layer<Some, E_1, R_1>;
-    };
-    toLayerScoped: {
-        (): Layer.Layer<Some, never, never>;
-        <E_1, R_2>(eff: Effect.Effect<Omit<Some, keyof Context.TagClassShape<any, any>>, E_1, R_2>): Layer.Layer<Some, E_1, Exclude<R_2, Scope.Scope>>;
-    };
-    of: (service: Context.TagClassShape<any, any>) => Some;
-    make: Effect.Effect<Some, never, never>;
-} & Context.Tag<Some, Some> & Context.ServiceUse<Some, {
+declare const Some_base: ServiceMap.OpaqueClass<Some, "Some", {
     a: number;
-}>;
+}> & {
+    readonly make: Effect.Effect<{
+        a: number;
+    }, never, never>;
+};
 export declare class Some extends Some_base {
 }
-declare const SomeElse_base: (abstract new (service: {
-    b: number;
-}) => Readonly<{
-    b: number;
-}> & Context.TagClassShape<"SomeElse", {
-    b: number;
-}>) & {
-    toLayer: {
-        (): Layer.Layer<SomeElse, never, never>;
-        <E_1, R_1>(eff: Effect.Effect<Omit<SomeElse, keyof Context.TagClassShape<any, any>>, E_1, R_1>): Layer.Layer<SomeElse, E_1, R_1>;
-    };
-    toLayerScoped: {
-        (): Layer.Layer<SomeElse, never, never>;
-        <E_1, R_2>(eff: Effect.Effect<Omit<SomeElse, keyof Context.TagClassShape<any, any>>, E_1, R_2>): Layer.Layer<SomeElse, E_1, Exclude<R_2, Scope.Scope>>;
-    };
-    of: (service: Context.TagClassShape<any, any>) => SomeElse;
-    make: Effect.Effect<SomeElse, never, never>;
-} & Context.Tag<SomeElse, SomeElse> & Context.ServiceUse<SomeElse, {
+declare const SomeElse_base: ServiceMap.OpaqueClass<SomeElse, "SomeElse", {
     b: number;
-}>;
+}> & {
+    readonly make: Effect.Effect<{
+        b: number;
+    }, never, never>;
+};
 export declare class SomeElse extends SomeElse_base {
 }
-declare const SomeService_base: (abstract new (service: {
-    a: number;
-}) => Readonly<{
-    a: number;
-}> & Context.TagClassShape<"SomeService", {
-    a: number;
-}>) & {
-    toLayer: {
-        (): Layer.Layer<SomeService, never, never>;
-        <E_1, R_1>(eff: Effect.Effect<Omit<SomeService, keyof Context.TagClassShape<any, any>>, E_1, R_1>): Layer.Layer<SomeService, E_1, R_1>;
-    };
-    toLayerScoped: {
-        (): Layer.Layer<SomeService, never, never>;
-        <E_1, R_2>(eff: Effect.Effect<Omit<SomeService, keyof Context.TagClassShape<any, any>>, E_1, R_2>): Layer.Layer<SomeService, E_1, Exclude<R_2, Scope.Scope>>;
-    };
-    of: (service: Context.TagClassShape<any, any>) => SomeService;
-    make: Effect.Effect<SomeService, never, never>;
-} & Context.Tag<SomeService, SomeService> & Context.ServiceUse<SomeService, {
+declare const SomeService_base: ServiceMap.OpaqueClass<SomeService, "SomeService", {
     a: number;
-}>;
+}> & {
+    readonly make: Effect.Effect<{
+        a: number;
+    }, never, never>;
+};
 export declare class SomeService extends SomeService_base {
+    static readonly Default: Layer.Layer<SomeService, never, never>;
 }
 declare const SomeMiddleware_base: RpcX.RpcMiddleware.TagClass<SomeMiddleware, "SomeMiddleware", {}, {
     provides: Some;
@@ -97,23 +53,23 @@ declare const RequestContextMap_base: (new () => {
     readonly config: {
         readonly allowAnonymous: RpcContextMap.RpcContextMap.Inverted<UserProfile, typeof NotLoggedInError>;
         readonly requireRoles: RpcContextMap.RpcContextMap.Custom<never, typeof UnauthorizedError, string[]>;
-        readonly test: RpcContextMap.RpcContextMap<never, typeof S.Never>;
+        readonly test: RpcContextMap.RpcContextMap<never, S.Never>;
     };
 }) & {
     config: {
         readonly allowAnonymous: RpcContextMap.RpcContextMap.Inverted<UserProfile, typeof NotLoggedInError>;
         readonly requireRoles: RpcContextMap.RpcContextMap.Custom<never, typeof UnauthorizedError, string[]>;
-        readonly test: RpcContextMap.RpcContextMap<never, typeof S.Never>;
+        readonly test: RpcContextMap.RpcContextMap<never, S.Never>;
     };
-    getConfig: (rpc: import("@effect/rpc/Rpc").AnyWithProps) => RpcContextMap.GetContextConfig<{
+    getConfig: (rpc: import("effect/unstable/rpc/Rpc").AnyWithProps) => RpcContextMap.GetContextConfig<{
         readonly allowAnonymous: RpcContextMap.RpcContextMap.Inverted<UserProfile, typeof NotLoggedInError>;
         readonly requireRoles: RpcContextMap.RpcContextMap.Custom<never, typeof UnauthorizedError, string[]>;
-        readonly test: RpcContextMap.RpcContextMap<never, typeof S.Never>;
+        readonly test: RpcContextMap.RpcContextMap<never, S.Never>;
     }>;
     get: <Key extends "allowAnonymous" | "requireRoles" | "test">(key: Key) => RpcX.RpcMiddleware.RpcDynamic<Key, {
         readonly allowAnonymous: RpcContextMap.RpcContextMap.Inverted<UserProfile, typeof NotLoggedInError>;
         readonly requireRoles: RpcContextMap.RpcContextMap.Custom<never, typeof UnauthorizedError, string[]>;
-        readonly test: RpcContextMap.RpcContextMap<never, typeof S.Never>;
+        readonly test: RpcContextMap.RpcContextMap<never, S.Never>;
     }[Key]>;
 };
 export declare class RequestContextMap extends RequestContextMap_base {
@@ -137,7 +93,7 @@ export declare class RequireRoles extends RequireRoles_base {
 }
 export declare const RequireRolesLive: Layer.Layer<RequireRoles, never, SomeService>;
 declare const Test_base: RpcX.RpcMiddleware.TagClass<Test, "Test", {
-    readonly dynamic: RpcX.RpcMiddleware.RpcDynamic<"test", RpcContextMap.RpcContextMap<never, typeof S.Never>>;
+    readonly dynamic: RpcX.RpcMiddleware.RpcDynamic<"test", RpcContextMap.RpcContextMap<never, S.Never>>;
 }, {
     requires: never;
     provides: never;
@@ -145,14 +101,10 @@ declare const Test_base: RpcX.RpcMiddleware.TagClass<Test, "Test", {
 export declare class Test extends Test_base {
 }
 export declare const TestLive: Layer.Layer<Test, never, never>;
-declare const CustomError1_base: S.TaggedErrorClass<CustomError1, "CustomError1", {
-    readonly _tag: S.tag<"CustomError1">;
-}>;
+declare const CustomError1_base: S.ErrorClass<CustomError1, S.TaggedStruct<"CustomError1", {}>, import("effect/Cause").YieldableError>;
 export declare class CustomError1 extends CustomError1_base {
 }
-declare const CustomError2_base: S.TaggedErrorClass<CustomError2, "CustomError2", {
-    readonly _tag: S.tag<"CustomError2">;
-}>;
+declare const CustomError2_base: S.ErrorClass<CustomError2, S.TaggedStruct<"CustomError2", {}>, import("effect/Cause").YieldableError>;
 export declare class CustomError2 extends CustomError2_base {
 }
 export {};

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

@@ -1 +1 @@
-{"version":3,"file":"fixtures.d.ts","sourceRoot":"","sources":["../fixtures.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,YAAY,CAAA;AAC7D,OAAO,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAA;AACvE,OAAO,EAAE,aAAa,EAAE,IAAI,EAAE,MAAM,gBAAgB,CAAA;;;;;;;;;;;;;AAGpD,qBAAa,WAAY,SAAQ,gBAKhC;CACA;;;;;;;;;;;;;;;;;;;;;AAED,qBAAa,IAAK,SAAQ,SAA2D;CAAG;;;;;;;;;;;;;;;;;;;;;AACxF,qBAAa,QAAS,SAAQ,aAAmE;CAAG;;;;;;;;;;;;;;;;;;;;;AAEpG,qBAAa,WAAY,SAAQ,gBAAgE;CAAG;;cAGb,IAAI;;AAA3F,qBAAa,cAAe,SAAQ,mBAA8E;CACjH;AAED,eAAO,MAAM,kBAAkB,2CAM9B,CAAA;;cAGgE,QAAQ;;AADzE,qBAAa,kBACX,SAAQ,uBAA0F;CAClG;AAEF,eAAO,MAAM,sBAAsB,+CAUlC,CAAA;;;;;;;;;;;;;;;;;;;;;;;;AAED,qBAAa,iBAAkB,SAAQ,sBAIrC;CAAG;;;;cAEkF,QAAQ;;AAA/F,qBAAa,cAAe,SAAQ,mBAElC;CAAG;AAEL,eAAO,MAAM,kBAAkB,2CAyB9B,CAAA;;;;;;;;AAED,qBAAa,YAAa,SAAQ,iBAKhC;CAAG;AAEL,eAAO,MAAM,gBAAgB,+CAuB5B,CAAA;;;;;;;AAED,qBAAa,IAAK,SAAQ,SAExB;CAAG;AAEL,eAAO,MAAM,QAAQ,iCAOpB,CAAA;;;;AAED,qBAAa,YAAa,SAAQ,iBAA+C;CAAG;;;;AACpF,qBAAa,YAAa,SAAQ,iBAA+C;CAAG"}
+{"version":3,"file":"fixtures.d.ts","sourceRoot":"","sources":["../fixtures.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,EAAS,UAAU,EAAE,MAAM,YAAY,CAAA;AAChE,OAAO,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAA;AACvE,OAAO,EAAE,aAAa,EAAE,IAAI,EAAE,MAAM,gBAAgB,CAAA;;;;;;;AAGpD,qBAAa,WAAY,SAAQ,gBAKhC;CACA;;;;;;;;AAED,qBAAa,IAAK,SAAQ,SAAqE;CAAG;;;;;;;;AAClG,qBAAa,QAAS,SAAQ,aAA6E;CAAG;;;;;;;;AAE9G,qBAAa,WAAY,SAAQ,gBAA0E;IACzG,MAAM,CAAC,QAAQ,CAAC,OAAO,yCAA0B;CAClD;;cAGsF,IAAI;;AAA3F,qBAAa,cAAe,SAAQ,mBAA8E;CACjH;AAED,eAAO,MAAM,kBAAkB,2CAM9B,CAAA;;cAGgE,QAAQ;;AADzE,qBAAa,kBACX,SAAQ,uBAA0F;CAClG;AAEF,eAAO,MAAM,sBAAsB,+CAUlC,CAAA;;;;;;;;;;;;;;;;;;;;;;;;AAED,qBAAa,iBAAkB,SAAQ,sBAIrC;CAAG;;;;cAEkF,QAAQ;;AAA/F,qBAAa,cAAe,SAAQ,mBAElC;CAAG;AAEL,eAAO,MAAM,kBAAkB,2CAyB9B,CAAA;;;;;;;;AAED,qBAAa,YAAa,SAAQ,iBAKhC;CAAG;AAEL,eAAO,MAAM,gBAAgB,+CAuB5B,CAAA;;;;;;;AAED,qBAAa,IAAK,SAAQ,SAExB;CAAG;AAEL,eAAO,MAAM,QAAQ,iCAOpB,CAAA;;AAED,qBAAa,YAAa,SAAQ,iBAA+C;CAAG;;AACpF,qBAAa,YAAa,SAAQ,iBAA+C;CAAG"}

package/test/dist/fixtures.js

@@ -1,25 +1,26 @@
-import { Context, Effect, Layer, S, Scope } from "effect-app";
+import { Effect, Layer, S, Scope, ServiceMap } from "effect-app";
 import { NotLoggedInError, UnauthorizedError } from "effect-app/client";
 import { RpcContextMap, RpcX } from "effect-app/rpc";
 import { TaggedError } from "effect-app/Schema";
-export class UserProfile extends Context.assignTag("UserProfile")(S.Class("UserProfile")({
+export class UserProfile extends ServiceMap.assignTag("UserProfile")(S.Class("UserProfile")({
     id: S.String,
     roles: S.Array(S.String)
 })) {
 }
-export class Some extends Context.TagMakeId("Some", Effect.succeed({ a: 1 }))() {
+export class Some extends ServiceMap.Opaque()("Some", { make: Effect.succeed({ a: 1 }) }) {
 }
-export class SomeElse extends Context.TagMakeId("SomeElse", Effect.succeed({ b: 2 }))() {
+export class SomeElse extends ServiceMap.Opaque()("SomeElse", { make: Effect.succeed({ b: 2 }) }) {
 }
 const MakeSomeService = Effect.succeed({ a: 1 });
-export class SomeService extends Context.TagMakeId("SomeService", MakeSomeService)() {
+export class SomeService extends ServiceMap.Opaque()("SomeService", { make: MakeSomeService }) {
+    static Default = this.toLayer(this.make);
 }
 // functionally equivalent to the one above
 export class SomeMiddleware extends RpcX.RpcMiddleware.Tag()("SomeMiddleware") {
 }
 export const SomeMiddlewareLive = Layer.effect(SomeMiddleware, Effect.gen(function* () {
     // yield* Effect.context<"test-dep">()
-    return (effect) => effect.pipe(Effect.provideService(Some, new Some({ a: 1 })));
+    return (effect) => effect.pipe(Effect.provideService(Some, Some.of({ a: 1 })));
 }));
 export class SomeElseMiddleware extends RpcX.RpcMiddleware.Tag()("SomeElseMiddleware") {
 }
@@ -27,7 +28,7 @@ export const SomeElseMiddlewareLive = Layer.effect(SomeElseMiddleware, Effect.ge
     // yield* Effect.context<"test-dep">()
     return (effect) => Effect.gen(function* () {
         // yield* Effect.context<"test-dep2">()
-        return yield* effect.pipe(Effect.provideService(SomeElse, new SomeElse({ b: 2 })));
+        return yield* effect.pipe(Effect.provideService(SomeElse, SomeElse.of({ b: 2 })));
     });
 }));
 export class RequestContextMap extends RpcContextMap.makeMap({
@@ -93,4 +94,4 @@ export class CustomError1 extends TaggedError()("CustomError1", {}) {
 }
 export class CustomError2 extends TaggedError()("CustomError2", {}) {
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZml4dHVyZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9maXh0dXJlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsT0FBTyxFQUFFLE1BQU0sRUFBRSxLQUFLLEVBQUUsQ0FBQyxFQUFFLEtBQUssRUFBRSxNQUFNLFlBQVksQ0FBQTtBQUM3RCxPQUFPLEVBQUUsZ0JBQWdCLEVBQUUsaUJBQWlCLEVBQUUsTUFBTSxtQkFBbUIsQ0FBQTtBQUN2RSxPQUFPLEVBQUUsYUFBYSxFQUFFLElBQUksRUFBRSxNQUFNLGdCQUFnQixDQUFBO0FBQ3BELE9BQU8sRUFBRSxXQUFXLEVBQUUsTUFBTSxtQkFBbUIsQ0FBQTtBQUUvQyxNQUFNLE9BQU8sV0FBWSxTQUFRLE9BQU8sQ0FBQyxTQUFTLENBQTJCLGFBQWEsQ0FBQyxDQUN6RixDQUFDLENBQUMsS0FBSyxDQUFjLGFBQWEsQ0FBQyxDQUFDO0lBQ2xDLEVBQUUsRUFBRSxDQUFDLENBQUMsTUFBTTtJQUNaLEtBQUssRUFBRSxDQUFDLENBQUMsS0FBSyxDQUFDLENBQUMsQ0FBQyxNQUFNLENBQUM7Q0FDekIsQ0FBQyxDQUNIO0NBQ0E7QUFFRCxNQUFNLE9BQU8sSUFBSyxTQUFRLE9BQU8sQ0FBQyxTQUFTLENBQUMsTUFBTSxFQUFFLE1BQU0sQ0FBQyxPQUFPLENBQUMsRUFBRSxDQUFDLEVBQUUsQ0FBQyxFQUFFLENBQUMsQ0FBQyxFQUFRO0NBQUc7QUFDeEYsTUFBTSxPQUFPLFFBQVMsU0FBUSxPQUFPLENBQUMsU0FBUyxDQUFDLFVBQVUsRUFBRSxNQUFNLENBQUMsT0FBTyxDQUFDLEVBQUUsQ0FBQyxFQUFFLENBQUMsRUFBRSxDQUFDLENBQUMsRUFBWTtDQUFHO0FBQ3BHLE1BQU0sZUFBZSxHQUFHLE1BQU0sQ0FBQyxPQUFPLENBQUMsRUFBRSxDQUFDLEVBQUUsQ0FBQyxFQUFFLENBQUMsQ0FBQTtBQUNoRCxNQUFNLE9BQU8sV0FBWSxTQUFRLE9BQU8sQ0FBQyxTQUFTLENBQUMsYUFBYSxFQUFFLGVBQWUsQ0FBQyxFQUFlO0NBQUc7QUFFcEcsMkNBQTJDO0FBQzNDLE1BQU0sT0FBTyxjQUFlLFNBQVEsSUFBSSxDQUFDLGFBQWEsQ0FBQyxHQUFHLEVBQXNDLENBQUMsZ0JBQWdCLENBQUM7Q0FDakg7QUFFRCxNQUFNLENBQUMsTUFBTSxrQkFBa0IsR0FBRyxLQUFLLENBQUMsTUFBTSxDQUM1QyxjQUFjLEVBQ2QsTUFBTSxDQUFDLEdBQUcsQ0FBQyxRQUFRLENBQUM7SUFDbEIsc0NBQXNDO0lBQ3RDLE9BQU8sQ0FBQyxNQUFNLEVBQUUsRUFBRSxDQUFDLE1BQU0sQ0FBQyxJQUFJLENBQUMsTUFBTSxDQUFDLGNBQWMsQ0FBQyxJQUFJLEVBQUUsSUFBSSxJQUFJLENBQUMsRUFBRSxDQUFDLEVBQUUsQ0FBQyxFQUFFLENBQUMsQ0FBQyxDQUFDLENBQUE7QUFDakYsQ0FBQyxDQUFDLENBQ0gsQ0FBQTtBQUVELE1BQU0sT0FBTyxrQkFDWCxTQUFRLElBQUksQ0FBQyxhQUFhLENBQUMsR0FBRyxFQUE4QyxDQUFDLG9CQUFvQixDQUFDO0NBQ2xHO0FBRUYsTUFBTSxDQUFDLE1BQU0sc0JBQXNCLEdBQUcsS0FBSyxDQUFDLE1BQU0sQ0FDaEQsa0JBQWtCLEVBQ2xCLE1BQU0sQ0FBQyxHQUFHLENBQUMsUUFBUSxDQUFDO0lBQ2xCLHNDQUFzQztJQUN0QyxPQUFPLENBQUMsTUFBTSxFQUFFLEVBQUUsQ0FDaEIsTUFBTSxDQUFDLEdBQUcsQ0FBQyxRQUFRLENBQUM7UUFDbEIsdUNBQXVDO1FBQ3ZDLE9BQU8sS0FBSyxDQUFDLENBQUMsTUFBTSxDQUFDLElBQUksQ0FBQyxNQUFNLENBQUMsY0FBYyxDQUFDLFFBQVEsRUFBRSxJQUFJLFFBQVEsQ0FBQyxFQUFFLENBQUMsRUFBRSxDQUFDLEVBQUUsQ0FBQyxDQUFDLENBQUMsQ0FBQTtJQUNwRixDQUFDLENBQUMsQ0FBQTtBQUNOLENBQUMsQ0FBQyxDQUNILENBQUE7QUFFRCxNQUFNLE9BQU8saUJBQWtCLFNBQVEsYUFBYSxDQUFDLE9BQU8sQ0FBQztJQUMzRCxjQUFjLEVBQUUsYUFBYSxDQUFDLFlBQVksRUFBZSxDQUFDLGdCQUFnQixDQUFDO0lBQzNFLFlBQVksRUFBRSxhQUFhLENBQUMsVUFBVSxFQUFFLENBQUMsaUJBQWlCLEVBQUUsS0FBSyxFQUFVLENBQUM7SUFDNUUsSUFBSSxFQUFFLGFBQWEsQ0FBQyxJQUFJLEVBQUUsQ0FBQyxDQUFDLENBQUMsS0FBSyxDQUFDO0NBQ3BDLENBQUM7Q0FBRztBQUVMLE1BQU0sT0FBTyxjQUFlLFNBQVEsSUFBSSxDQUFDLGFBQWEsQ0FBQyxHQUFHLEVBQTBDLENBQUMsZ0JBQWdCLEVBQUU7SUFDckgsT0FBTyxFQUFFLGlCQUFpQixDQUFDLEdBQUcsQ0FBQyxnQkFBZ0IsQ0FBQztDQUNqRCxDQUFDO0NBQUc7QUFFTCxNQUFNLENBQUMsTUFBTSxrQkFBa0IsR0FBRyxLQUFLLENBQUMsTUFBTSxDQUM1QyxjQUFjLEVBQ2QsTUFBTSxDQUFDLEdBQUcsQ0FBQyxRQUFRLENBQUM7SUFDbEIsT0FBTyxNQUFNLENBQUMsVUFBVSxDQUN0QixRQUFRLENBQUMsRUFBQyxNQUFNLEVBQUUsRUFBRSxPQUFPLEVBQUUsR0FBRyxFQUFFO1FBQ2hDLEtBQUssQ0FBQyxDQUFDLFFBQVEsQ0FBQTtRQUNmLEtBQUssQ0FBQyxDQUFDLEtBQUssQ0FBQyxLQUFLLENBQUEsQ0FBQyx1Q0FBdUM7UUFDMUQsTUFBTSxVQUFVLEdBQUcsQ0FBQyxDQUFDLE9BQU8sQ0FBQyxRQUFRLENBQUMsQ0FBQTtRQUN0QyxJQUFJLENBQUMsVUFBVSxFQUFFLENBQUM7WUFDaEIsSUFBSSxDQUFDLGlCQUFpQixDQUFDLFNBQVMsQ0FBQyxHQUFHLENBQUMsQ0FBQyxjQUFjLEVBQUUsQ0FBQztnQkFDckQsT0FBTyxLQUFLLENBQUMsQ0FBQyxJQUFJLGdCQUFnQixDQUFDLEVBQUUsT0FBTyxFQUFFLGVBQWUsRUFBRSxDQUFDLENBQUE7WUFDbEUsQ0FBQztZQUNELE9BQU8sS0FBSyxDQUFDLENBQUMsTUFBTSxDQUFBO1FBQ3RCLENBQUM7UUFDRCxPQUFPLEtBQUssQ0FBQyxDQUFDLE1BQU0sQ0FBQyxjQUFjLENBQ2pDLE1BQU0sRUFDTixXQUFXLEVBQ1gsSUFBSSxXQUFXLENBQUM7WUFDZCxFQUFFLEVBQUUsVUFBVTtZQUNkLEtBQUssRUFBRSxDQUFDLE1BQU0sRUFBRSxHQUFHLE9BQU8sQ0FBQyxjQUFjLENBQUMsS0FBSyxNQUFNLENBQUMsQ0FBQyxDQUFDLENBQUMsU0FBUyxDQUFDLENBQUMsQ0FBQyxDQUFDLEVBQUUsQ0FBQztTQUMxRSxDQUFDLENBQ0gsQ0FBQTtJQUNILENBQUMsQ0FDRixDQUFBO0FBQ0gsQ0FBQyxDQUFDLENBQ0gsQ0FBQTtBQUVELE1BQU0sT0FBTyxZQUFhLFNBQVEsSUFBSSxDQUFDLGFBQWEsQ0FBQyxHQUFHLEVBQWdCLENBQUMsY0FBYyxFQUFFO0lBQ3ZGLE9BQU8sRUFBRSxpQkFBaUIsQ0FBQyxHQUFHLENBQUMsY0FBYyxDQUFDO0lBQzlDLHlHQUF5RztJQUN6Ryw2SEFBNkg7SUFDN0gsU0FBUyxFQUFFLENBQUMsY0FBYyxDQUFDO0NBQzVCLENBQUM7Q0FBRztBQUVMLE1BQU0sQ0FBQyxNQUFNLGdCQUFnQixHQUFHLEtBQUssQ0FBQyxNQUFNLENBQzFDLFlBQVksRUFDWixNQUFNLENBQUMsR0FBRyxDQUFDLFFBQVEsQ0FBQztJQUNsQixLQUFLLENBQUMsQ0FBQyxXQUFXLENBQUE7SUFDbEIsT0FBTyxNQUFNLENBQUMsVUFBVSxDQUN0QixRQUFRLENBQUMsRUFBQyxNQUFNLEVBQUUsRUFBRSxHQUFHLEVBQUU7UUFDdkIsMkVBQTJFO1FBQzNFLE1BQU0sV0FBVyxHQUFHLEtBQUssQ0FBQyxDQUFDLE1BQU0sQ0FBQyxhQUFhLENBQUMsV0FBVyxDQUFDLENBQUE7UUFDNUQsTUFBTSxFQUFFLFlBQVksRUFBRSxHQUFHLGlCQUFpQixDQUFDLFNBQVMsQ0FBQyxHQUFHLENBQUMsQ0FBQTtRQUN6RCxPQUFPLENBQUMsR0FBRyxDQUNUO1lBQ0UsV0FBVztZQUNYLFlBQVk7U0FDYixFQUNELEVBQUUsS0FBSyxFQUFFLENBQUMsRUFBRSxDQUNiLENBQUE7UUFDRCxJQUFJLFlBQVksSUFBSSxDQUFDLFdBQVcsQ0FBQyxLQUFLLEVBQUUsS0FBSyxFQUFFLElBQUksQ0FBQyxDQUFDLElBQUksRUFBRSxFQUFFLENBQUMsWUFBWSxDQUFDLFFBQVEsQ0FBQyxJQUFJLENBQUMsQ0FBQyxFQUFFLENBQUM7WUFDM0YsT0FBTyxLQUFLLENBQUMsQ0FBQyxJQUFJLGlCQUFpQixDQUFDLEVBQUUsT0FBTyxFQUFFLDRCQUE0QixFQUFFLENBQUMsQ0FBQTtRQUNoRixDQUFDO1FBQ0QsT0FBTyxLQUFLLENBQUMsQ0FBQyxNQUFNLENBQUE7SUFDdEIsQ0FBQyxDQUNGLENBQUE7QUFDSCxDQUFDLENBQUMsQ0FDSCxDQUFBO0FBRUQsTUFBTSxPQUFPLElBQUssU0FBUSxJQUFJLENBQUMsYUFBYSxDQUFDLEdBQUcsRUFBUSxDQUFDLE1BQU0sRUFBRTtJQUMvRCxPQUFPLEVBQUUsaUJBQWlCLENBQUMsR0FBRyxDQUFDLE1BQU0sQ0FBQztDQUN2QyxDQUFDO0NBQUc7QUFFTCxNQUFNLENBQUMsTUFBTSxRQUFRLEdBQUcsS0FBSyxDQUFDLE1BQU0sQ0FDbEMsSUFBSSxFQUNKLE1BQU0sQ0FBQyxHQUFHLENBQUMsUUFBUSxDQUFDO0lBQ2xCLE9BQU8sTUFBTSxDQUFDLEVBQUUsQ0FBQyxRQUFRLENBQUMsRUFBQyxNQUFNO1FBQy9CLE9BQU8sS0FBSyxDQUFDLENBQUMsTUFBTSxDQUFBO0lBQ3RCLENBQUMsQ0FBQyxDQUFBO0FBQ0osQ0FBQyxDQUFDLENBQ0gsQ0FBQTtBQUVELE1BQU0sT0FBTyxZQUFhLFNBQVEsV0FBVyxFQUFnQixDQUFDLGNBQWMsRUFBRSxFQUFFLENBQUM7Q0FBRztBQUNwRixNQUFNLE9BQU8sWUFBYSxTQUFRLFdBQVcsRUFBZ0IsQ0FBQyxjQUFjLEVBQUUsRUFBRSxDQUFDO0NBQUcifQ==
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -1 +1 @@
-{"version":3,"file":"query.test.d.ts","sourceRoot":"","sources":["../query.test.ts"],"names":[],"mappings":"AAGA,OAAO,EAAqC,CAAC,EAAU,MAAM,YAAY,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAazE,qBAAa,SAAU,SAAQ,cAM7B;CAAG;AACL,MAAM,CAAC,OAAO,WAAW,SAAS,CAAC;IAEjC,UAAiB,OAAQ,SAAQ,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,OAAO,SAAS,CAAC;KAAG;CACvE"}
+{"version":3,"file":"query.test.d.ts","sourceRoot":"","sources":["../query.test.ts"],"names":[],"mappings":"AAGA,OAAO,EAAqC,CAAC,EAAsB,MAAM,YAAY,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAarF,qBAAa,SAAU,SAAQ,cAM7B;CAAG;AACL,MAAM,CAAC,OAAO,WAAW,SAAS,CAAC;IAEjC,UAAiB,OAAQ,SAAQ,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,OAAO,SAAS,CAAC;KAAG;CACtE"}

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

@@ -1 +1 @@
-{"version":3,"file":"rawQuery.test.d.ts","sourceRoot":"","sources":["../rawQuery.test.ts"],"names":[],"mappings":"AACA,OAAO,EAAwD,cAAc,EAAuB,MAAM,YAAY,CAAA;AACtH,OAAO,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAA;AAO5C,eAAO,MAAM,EAAE,iDAUb,CAAA"}
+{"version":3,"file":"rawQuery.test.d.ts","sourceRoot":"","sources":["../rawQuery.test.ts"],"names":[],"mappings":"AACA,OAAO,EAAsC,cAAc,EAA+C,MAAM,YAAY,CAAA;AAQ5H,eAAO,MAAM,EAAE,6CAWb,CAAA"}

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

@@ -1 +1 @@
-{"version":3,"file":"requires.test.d.ts","sourceRoot":"","sources":["../requires.test.ts"],"names":[],"mappings":"AAGA,OAAO,EAA2B,KAAK,EAAE,CAAC,EAAE,MAAM,YAAY,CAAA;AAC9D,OAAO,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAA;AAEvE,OAAO,KAAK,IAAI,MAAM,gBAAgB,CAAA;AAEtC,OAAO,EAAE,cAAc,EAAyC,YAAY,EAAoB,IAAI,EAAE,kBAAkB,EAA0B,cAAc,EAAmC,IAAI,EAAY,MAAM,eAAe,CAAA;;cAGnK,IAAI;;AADzE,qBAAa,sBACX,SAAQ,2BAA8F;IAEtG,MAAM,CAAC,OAAO,oDASZ;CACH;AAqBD,eAAO,MAAM,eAAe;;;;;;;;;;SAMK,CAAA"}
+{"version":3,"file":"requires.test.d.ts","sourceRoot":"","sources":["../requires.test.ts"],"names":[],"mappings":"AACA,OAAO,EAAU,KAAK,EAAU,CAAC,EAAc,MAAM,YAAY,CAAA;AACjE,OAAO,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAA;AAEvE,OAAO,KAAK,IAAI,MAAM,gBAAgB,CAAA;AAKtC,OAAO,EAAE,cAAc,EAAyC,YAAY,EAAoB,IAAI,EAAE,kBAAkB,EAA0B,cAAc,EAAmC,IAAI,EAAY,MAAM,eAAe,CAAA;;cAGnK,IAAI;;AADzE,qBAAa,sBACX,SAAQ,2BAA8F;IAEtG,MAAM,CAAC,OAAO,oDASZ;CACH;AAqBD,eAAO,MAAM,eAAe;;;;;;;;;;SAMK,CAAA"}

package/test/dist/rpc-multi-middleware.test.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"rpc-multi-middleware.test.d.ts","sourceRoot":"","sources":["../rpc-multi-middleware.test.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,SAAS,EAAkD,MAAM,aAAa,CAAA;AAEvF,OAAO,EAA2B,KAAK,EAAE,MAAM,QAAQ,CAAA;AACvD,OAAO,EAAE,CAAC,EAAE,MAAM,YAAY,CAAA;AAC9B,OAAO,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAA;AAGpD,OAAO,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAA;AAIhD,OAAO,EAAE,cAAc,EAAyC,YAAY,EAA0B,kBAAkB,EAA0B,cAAc,EAAmC,IAAI,EAAY,WAAW,EAAE,MAAM,eAAe,CAAA;AAErP,QAAA,MAAM,UAAU;;;;;;;;;;oCAGmB,CAAA;AAGnC,qBAAa,oBAAqB,SAAQ,UAAU;CAAG;;;;;;;;;;;;AAEvD,cAAM,UAAW,SAAQ,eAKkB;CACzC;AAsCF,eAAO,MAAM,OAAO,uFAMhB,CAAA;AAiBJ,eAAO,MAAM,YAAY,4KAItB,CAAA;AAEH,eAAO,MAAM,YAAY,0IAgByB,CAAA"}
+{"version":3,"file":"rpc-multi-middleware.test.d.ts","sourceRoot":"","sources":["../rpc-multi-middleware.test.ts"],"names":[],"mappings":"AAEA,OAAO,EAAmB,KAAK,EAAU,MAAM,QAAQ,CAAA;AACvD,OAAO,EAAE,CAAC,EAAE,MAAM,YAAY,CAAA;AAC9B,OAAO,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAA;AAGpD,OAAO,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAA;AAGhD,OAAO,EAAE,SAAS,EAAkD,MAAM,qBAAqB,CAAA;AAG/F,OAAO,EAAE,cAAc,EAAyC,YAAY,EAA0B,kBAAkB,EAA0B,cAAc,EAAmC,IAAI,EAAY,WAAW,EAAE,MAAM,eAAe,CAAA;AAErP,QAAA,MAAM,UAAU;;;;;;;;;;oCAGmB,CAAA;AAGnC,qBAAa,oBAAqB,SAAQ,UAAU;CAAG;;;;;;;;;;;;AAEvD,cAAM,UAAW,SAAQ,eAKkB;CACzC;AAsCF,eAAO,MAAM,OAAO,+FAMhB,CAAA;AAgBJ,eAAO,MAAM,YAAY,uLAItB,CAAA;AAEH,eAAO,MAAM,YAAY,yIAgByB,CAAA"}

package/test/fixtures.ts

@@ -1,9 +1,9 @@
-import { Context, Effect, Layer, S, Scope } from "effect-app"
+import { Effect, Layer, S, Scope, ServiceMap } from "effect-app"
 import { NotLoggedInError, UnauthorizedError } from "effect-app/client"
 import { RpcContextMap, RpcX } from "effect-app/rpc"
 import { TaggedError } from "effect-app/Schema"
 
-export class UserProfile extends Context.assignTag<UserProfile, UserProfile>("UserProfile")(
+export class UserProfile extends ServiceMap.assignTag<UserProfile, UserProfile>("UserProfile")(
   S.Class<UserProfile>("UserProfile")({
     id: S.String,
     roles: S.Array(S.String)
@@ -11,10 +11,12 @@ export class UserProfile extends Context.assignTag<UserProfile, UserProfile>("Us
 ) {
 }
 
-export class Some extends Context.TagMakeId("Some", Effect.succeed({ a: 1 }))<Some>() {}
-export class SomeElse extends Context.TagMakeId("SomeElse", Effect.succeed({ b: 2 }))<SomeElse>() {}
+export class Some extends ServiceMap.Opaque<Some>()("Some", { make: Effect.succeed({ a: 1 }) }) {}
+export class SomeElse extends ServiceMap.Opaque<SomeElse>()("SomeElse", { make: Effect.succeed({ b: 2 }) }) {}
 const MakeSomeService = Effect.succeed({ a: 1 })
-export class SomeService extends Context.TagMakeId("SomeService", MakeSomeService)<SomeService>() {}
+export class SomeService extends ServiceMap.Opaque<SomeService>()("SomeService", { make: MakeSomeService }) {
+  static readonly Default = this.toLayer(this.make)
+}
 
 // functionally equivalent to the one above
 export class SomeMiddleware extends RpcX.RpcMiddleware.Tag<SomeMiddleware, { provides: Some }>()("SomeMiddleware") {
@@ -24,7 +26,7 @@ export const SomeMiddlewareLive = Layer.effect(
   SomeMiddleware,
   Effect.gen(function*() {
     // yield* Effect.context<"test-dep">()
-    return (effect) => effect.pipe(Effect.provideService(Some, new Some({ a: 1 })))
+    return (effect) => effect.pipe(Effect.provideService(Some, Some.of({ a: 1 })))
   })
 )
 
@@ -39,7 +41,7 @@ export const SomeElseMiddlewareLive = Layer.effect(
     return (effect) =>
       Effect.gen(function*() {
         // yield* Effect.context<"test-dep2">()
-        return yield* effect.pipe(Effect.provideService(SomeElse, new SomeElse({ b: 2 })))
+        return yield* effect.pipe(Effect.provideService(SomeElse, SomeElse.of({ b: 2 })))
       })
   })
 )

package/test/query.test.ts

@@ -1,7 +1,7 @@
 /* eslint-disable unused-imports/no-unused-vars */
 /* eslint-disable @typescript-eslint/no-empty-object-type */
 /* eslint-disable @typescript-eslint/no-explicit-any */
-import { Effect, flow, Layer, Option, pipe, S, Struct } from "effect-app"
+import { Effect, flow, Layer, Option, pipe, S, ServiceMap, Struct } from "effect-app"
 import { inspect } from "util"
 import { expect, expectTypeOf, it } from "vitest"
 import { setupRequestContextFromCurrent } from "../src/api/setupRequest.js"
@@ -12,7 +12,7 @@ import { SomeService } from "./fixtures.js"
 
 const str = S.Struct({ _tag: S.Literal("string"), value: S.String })
 const num = S.Struct({ _tag: S.Literal("number"), value: S.Number })
-const someUnion = S.Union(str, num)
+const someUnion = S.Union([str, num])
 
 export class Something extends S.Class<Something>("Something")({
   id: S.StringId.withDefault,
@@ -23,7 +23,7 @@ export class Something extends S.Class<Something>("Something")({
 }) {}
 export declare namespace Something {
   // eslint-disable-next-line @typescript-eslint/no-empty-object-type
-  export interface Encoded extends S.Schema.Encoded<typeof Something> {}
+  export interface Encoded extends S.Codec.Encoded<typeof Something> {}
 }
 
 const q = make<Something.Encoded>()
@@ -38,9 +38,13 @@ const q = make<Something.Encoded>()
     // for projection performance benefit, this should be limited to the fields interested, and leads to SELECT fields
     project(
       S.transformToOrFail(
-        S.Struct(Struct.pick(Something.fields, "id", "displayName")),
-        S.Struct(Struct.pick(Something.fields, "id", "displayName")),
-        (_) => Effect.andThen(SomeService, _)
+        S.Struct(Struct.pick(Something.fields, ["id", "displayName"])),
+        S.Struct(Struct.pick(Something.fields, ["id", "displayName"])),
+        (_) =>
+          Effect.gen(function*() {
+            yield* SomeService
+            return _
+          })
       )
     )
   )
@@ -91,12 +95,12 @@ it("works", () => {
     }))(_)
   ))
 
-  expect(processed).toEqual(items.slice(0, 2).toReversed().map(Struct.pick("id", "displayName")))
+  expect(processed).toEqual(items.slice(0, 2).toReversed().map(Struct.pick(["id", "displayName"])))
 })
 
 // @effect-diagnostics-next-line missingEffectServiceDependency:off
-class SomethingRepo extends Effect.Service<SomethingRepo>()("SomethingRepo", {
-  effect: Effect.gen(function*() {
+class SomethingRepo extends ServiceMap.Service<SomethingRepo>()("SomethingRepo", {
+  make: Effect.gen(function*() {
     return yield* makeRepo("Something", Something, {})
   })
 }) {
@@ -104,7 +108,7 @@ class SomethingRepo extends Effect.Service<SomethingRepo>()("SomethingRepo", {
     .effect(
       SomethingRepo,
       Effect.gen(function*() {
-        return SomethingRepo.make(yield* makeRepo("Something", Something, { makeInitial: Effect.sync(() => items) }))
+        return SomethingRepo.of(yield* makeRepo("Something", Something, { makeInitial: Effect.sync(() => items) }))
       })
     )
     .pipe(
@@ -134,9 +138,13 @@ it("works with repo", () =>
           // for projection performance benefit, this should be limited to the fields interested, and leads to SELECT fields
           project(
             S.transformToOrFail(
-              S.Struct(Struct.pick(Something.fields, "displayName")),
-              S.Struct(Struct.pick(Something.fields, "displayName")),
-              (_) => Effect.andThen(SomeService, _)
+              S.Struct(Struct.pick(Something.fields, ["displayName"])),
+              S.Struct(Struct.pick(Something.fields, ["displayName"])),
+              (_) =>
+                Effect.gen(function*() {
+                  yield* SomeService
+                  return _
+                })
             )
           )
         )
@@ -148,11 +156,13 @@ it("works with repo", () =>
 
       expectTypeOf(smtArr).toEqualTypeOf<readonly Something[]>()
 
-      expect(q1).toEqual(items.slice(0, 2).toReversed().map(Struct.pick("id", "displayName")))
-      expect(q2).toEqual(items.slice(0, 2).toReversed().map(Struct.pick("displayName")))
+      console.log(" $$$$$$")
+      console.log(Struct.pick(["id", "displayName"]))
+      expect(q1).toEqual(items.slice(0, 2).toReversed().map(Struct.pick(["id", "displayName"])))
+      expect(q2).toEqual(items.slice(0, 2).toReversed().map(Struct.pick(["displayName"])))
     })
     .pipe(
-      Effect.provide(Layer.mergeAll(SomethingRepo.Test, SomeService.toLayer())),
+      Effect.provide(Layer.mergeAll(SomethingRepo.Test, SomeService.Default)),
       setupRequestContextFromCurrent(),
       Effect.runPromise
     ))
@@ -171,11 +181,11 @@ it("collect", () =>
             // for projection performance benefit, this should be limited to the fields interested, and leads to SELECT fields
             project(
               S.transformTo(
-                S.encodedSchema(S.Struct({
-                  ...Struct.pick(Something.fields, "n"),
+                S.toEncoded(S.Struct({
+                  ...Struct.pick(Something.fields, ["n"]),
                   displayName: S.String
                 })),
-                S.typeSchema(S.Option(S.String)),
+                S.toType(S.Option(S.String)),
                 (_) =>
                   _.displayName === "Riley" && _.n === "2020-01-01T00:00:00.000Z"
                     ? Option.some(`${_.displayName}-${_.n}`)
@@ -223,7 +233,7 @@ it("collect", () =>
       expect(value).toEqual("hi")
     })
     .pipe(
-      Effect.provide(Layer.mergeAll(SomethingRepo.Test, SomeService.toLayer())),
+      Effect.provide(Layer.mergeAll(SomethingRepo.Test, SomeService.Default)),
       setupRequestContextFromCurrent(),
       Effect.runPromise
     ))
@@ -250,7 +260,7 @@ namespace Test {
   export interface Encoded extends S.Struct.Encoded<typeof Test["fields"]> {}
 }
 
-const TestUnion = S.Union(Person, Animal, Test)
+const TestUnion = S.Union([Person, Animal, Test])
 type TestUnion = typeof TestUnion.Type
 namespace TestUnion {
   export type Encoded = typeof TestUnion.Encoded
@@ -487,7 +497,7 @@ it(
 
         type Union = AA | BB | CC | DD
 
-        const repo = yield* makeRepo("test", S.Union(AA, BB, CC, DD), {})
+        const repo = yield* makeRepo("test", S.Union([AA, BB, CC, DD]), {})
 
         const query1 = make<Union>().pipe(
           where("id", "AA")
@@ -510,11 +520,10 @@ it(
       .gen(function*() {
         const schema = S.Struct({
           id: S.String,
-          createdAt: S
-            .optional(S.Date)
-            .pipe(
-              S.withDefaults({ constructor: () => new Date(), decoding: () => new Date() })
-            )
+          createdAt: S.Date.pipe(
+            S.withDecodingDefault(() => new Date().toISOString()),
+            S.withConstructorDefault(() => Option.some(new Date()))
+          )
         })
         const repo = yield* makeRepo(
           "test",
@@ -524,11 +533,10 @@ it(
 
         const outputSchema = S.Struct({
           id: S.Literal("123"),
-          createdAt: S
-            .optional(S.Date)
-            .pipe(
-              S.withDefaults({ constructor: () => new Date(), decoding: () => new Date() })
-            )
+          createdAt: S.Date.pipe(
+            S.withDecodingDefault(() => new Date().toISOString()),
+            S.withConstructorDefault(() => Option.some(new Date()))
+          )
         })
 
         const result = yield* repo.query(where("id", "123"), project(outputSchema))
@@ -575,7 +583,7 @@ it(
       .gen(function*() {
         const schema = S.Struct({
           id: S.String,
-          literals: S.Union(S.Literal("a", "b", "c"), S.Null)
+          literals: S.Union([S.Literal("a", "b", "c"), S.Null])
         })
 
         type Schema = typeof schema.Type
@@ -619,7 +627,7 @@ it(
       .gen(function*() {
         const schema = S.Struct({
           id: S.String,
-          literals: S.Union(S.String, S.Null)
+          literals: S.Union([S.String, S.Null])
         })
 
         type Schema = typeof schema.Type
@@ -671,7 +679,7 @@ it("remove null from one constituent of a tagged union", () =>
 
       type Union = AA | BB
 
-      const repo = yield* makeRepo("test", S.Union(AA, BB), {})
+      const repo = yield* makeRepo("test", S.Union([AA, BB]), {})
 
       const query1 = make<Union>().pipe(
         where("id", "AA"),
@@ -729,7 +737,7 @@ it("refine 3", () =>
 
       type Union = AA | BB | CC | DD
 
-      const repo = yield* makeRepo("test", S.Union(AA, BB, CC, DD), {})
+      const repo = yield* makeRepo("test", S.Union([AA, BB, CC, DD]), {})
 
       const query1 = make<Union>().pipe(
         where("id", "AA")
@@ -773,7 +781,7 @@ it("refine inner without imposing a projection", () =>
 
       class Data extends S.Class<Data>("Data")({
         id: S.String,
-        union: S.Union(AA, BB)
+        union: S.Union([AA, BB])
       }) {}
 
       const repo = yield* makeRepo("data", Data, {})
@@ -1001,20 +1009,20 @@ it("refine union with nested union", () =>
 
       class Container1 extends S.TaggedClass<Container1>()("Container1", {
         id: S.String,
-        nested: S.Union(A, B, C)
+        nested: S.Union([A, B, C])
       }) {}
 
       class Container2 extends S.TaggedClass<Container2>()("Container2", {
         id: S.String,
-        nested: S.Union(B, C, D)
+        nested: S.Union([B, C, D])
       }) {}
 
       class Container3 extends S.TaggedClass<Container3>()("Container3", {
         id: S.String,
-        nested: S.Union(C, D, E)
+        nested: S.Union([C, D, E])
       }) {}
 
-      const Containers = S.Union(Container1, Container2, Container3)
+      const Containers = S.Union([Container1, Container2, Container3])
       type Containers = typeof Containers.Type
 
       const repo = yield* makeRepo("containers", Containers, {})