@effect-app/infra 2.94.0 → 3.0.0

package/src/api/routing/middleware/middleware-native.ts

@@ -0,0 +1,23 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { RpcMiddleware } from "@effect/rpc"
+import { Context } from "effect-app"
+
+export class DevMode extends Context.Reference<DevMode>()("DevMode", { defaultValue: () => false }) {}
+
+export class RequestCacheMiddleware
+  extends RpcMiddleware.Tag<RequestCacheMiddleware>()("RequestCacheMiddleware", { wrap: true })
+{}
+
+export class ConfigureInterruptibilityMiddleware
+  extends RpcMiddleware.Tag<ConfigureInterruptibilityMiddleware>()("ConfigureInterruptibilityMiddleware", {
+    wrap: true
+  })
+{}
+
+export class LoggerMiddleware extends RpcMiddleware.Tag<LoggerMiddleware>()("LoggerMiddleware", { wrap: true }) {}
+
+export const DefaultGenericMiddlewares = [
+  RequestCacheMiddleware,
+  ConfigureInterruptibilityMiddleware,
+  LoggerMiddleware
+] as const

package/src/api/routing/middleware/middleware.ts

@@ -1,14 +1,15 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-import { Cause, Context, Duration, Effect, Layer, ParseResult, Request, Schedule, type Schema } from "effect-app"
+import { Cause, Duration, Effect, Layer, ParseResult, Request, Schedule, type Schema } from "effect"
 import { pretty } from "effect-app/utils"
 import { logError, reportError } from "../../../errorReporter.js"
 import { InfraLogger } from "../../../logger.js"
 import { determineMethod, isCommand } from "../utils.js"
-import { Tag } from "./RpcMiddleware.js"
+import * as MiddlewareNative from "./middleware-native.js"
 
 const logRequestError = logError("Request")
 const reportRequestError = reportError("Request")
 
+export { DevMode } from "./middleware-native.js"
+
 export const RequestCacheLayers = Layer.mergeAll(
   Layer.setRequestCache(
     Request.makeCache({ capacity: 500, timeToLive: Duration.hours(8) })
@@ -17,46 +18,43 @@ export const RequestCacheLayers = Layer.mergeAll(
   Layer.setRequestBatching(true)
 )
 
-export class DevMode extends Context.Reference<DevMode>()("DevMode", { defaultValue: () => false }) {}
-
-export class RequestCacheMiddleware extends Tag<RequestCacheMiddleware>()("RequestCacheMiddleware", { wrap: true })({
-  effect: Effect.succeed(({ next }) => next.pipe(Effect.provide(RequestCacheLayers)))
-}) {
-}
+export const RequestCacheMiddlewareLive = Layer.succeed(
+  MiddlewareNative.RequestCacheMiddleware,
+  ({ next }) => next.pipe(Effect.provide(RequestCacheLayers))
+)
 
 // retry just once on optimistic concurrency exceptions
 const optimisticConcurrencySchedule = Schedule.once.pipe(
   Schedule.intersect(Schedule.recurWhile<any>((a) => a?._tag === "OptimisticConcurrencyException"))
 )
 
-export class ConfigureInterruptibilityMiddleware
-  extends Tag<ConfigureInterruptibilityMiddleware>()("ConfigureInterruptibilityMiddleware", { wrap: true })({
-    effect: Effect.gen(function*() {
-      const cache = new Map()
-      const getCached = (key: string, schema: Schema.Schema.Any) => {
-        const existing = cache.get(key)
-        if (existing) return existing
-        const n = determineMethod(key, schema)
-        cache.set(key, n)
-        return n
-      }
-      return ({ next, rpc }) => {
-        const method = getCached(rpc._tag, rpc.payloadSchema)
+export const ConfigureInterruptibilityMiddlewareLive = Layer.effect(
+  MiddlewareNative.ConfigureInterruptibilityMiddleware,
+  Effect.gen(function*() {
+    const cache = new Map()
+    const getCached = (key: string, schema: Schema.Schema.Any) => {
+      const existing = cache.get(key)
+      if (existing) return existing
+      const n = determineMethod(key, schema)
+      cache.set(key, n)
+      return n
+    }
+    return ({ next, rpc }) => {
+      const method = getCached(rpc._tag, rpc.payloadSchema)
 
-        next = isCommand(method)
-          ? Effect.retry(Effect.uninterruptible(next), optimisticConcurrencySchedule)
-          : Effect.interruptible(next)
+      next = isCommand(method)
+        ? Effect.retry(Effect.uninterruptible(next), optimisticConcurrencySchedule)
+        : Effect.interruptible(next)
 
-        return next
-      }
-    })
+      return next
+    }
   })
-{
-}
+)
 
-export class LoggerMiddleware extends Tag<LoggerMiddleware>()("LoggerMiddleware", { wrap: true })({
-  effect: Effect.gen(function*() {
-    const devMode = yield* DevMode
+export const LoggerMiddlewareLive = Layer.effect(
+  MiddlewareNative.LoggerMiddleware,
+  Effect.gen(function*() {
+    const devMode = yield* MiddlewareNative.DevMode
     return ({ headers, next, payload, rpc }) =>
       Effect
         .annotateCurrentSpan({
@@ -112,11 +110,10 @@ export class LoggerMiddleware extends Tag<LoggerMiddleware>()("LoggerMiddleware"
           devMode ? (_) => _ : Effect.catchAllDefect(() => Effect.die("Internal Server Error"))
         )
   })
-}) {
-}
+)
 
-export const DefaultGenericMiddlewares = [
-  RequestCacheMiddleware,
-  ConfigureInterruptibilityMiddleware,
-  LoggerMiddleware
-] as const
+export const DefaultGenericMiddlewaresLive = Layer.mergeAll(
+  RequestCacheMiddlewareLive,
+  ConfigureInterruptibilityMiddlewareLive,
+  LoggerMiddlewareLive
+)

package/src/api/routing/middleware.ts

@@ -4,6 +4,7 @@ export * from "./middleware/middleware-api.js"
 export * from "./middleware/middleware.js"
 export * from "./middleware/RouterMiddleware.js"
 export * from "./middleware/RpcMiddleware.js"
+export * from "./middleware/RpcMiddlewareX.js"
 // codegen:end
 
 export * as Middleware from "./middleware.js"

package/test/controller.test.ts

@@ -5,12 +5,13 @@ import { type RpcSerialization } from "@effect/rpc"
 import { expect, expectTypeOf, it } from "@effect/vitest"
 import { Context, Effect, Layer, S, Scope } from "effect-app"
 import { InvalidStateError, makeRpcClient, NotLoggedInError, UnauthorizedError } from "effect-app/client"
-import { DefaultGenericMiddlewares, makeMiddleware, Middleware, Tag } from "../src/api/routing/middleware.js"
+import { DefaultGenericMiddlewaresLive, makeMiddleware, Middleware, TagService } from "../src/api/routing/middleware.js"
+import { DefaultGenericMiddlewares } from "../src/api/routing/middleware/middleware-native.js"
 import { sort } from "../src/api/routing/tsort.js"
-import { AllowAnonymous, CustomError1, RequestContextMap, RequireRoles, Some, SomeElse, SomeService, Test } from "./fixtures.js"
+import { AllowAnonymous, AllowAnonymousLive, CustomError1, RequestContextMap, RequireRoles, RequireRolesLive, Some, SomeElse, SomeService, Test, TestLive } from "./fixtures.js"
 
 // @effect-diagnostics-next-line missingEffectServiceDependency:off
-class MyContextProvider extends Middleware.Tag<MyContextProvider>()("MyContextProvider", {
+class MyContextProvider extends Middleware.TagService<MyContextProvider>()("MyContextProvider", {
   provides: [Some],
   requires: [SomeElse]
 })({
@@ -39,7 +40,7 @@ class MyContextProvider extends Middleware.Tag<MyContextProvider>()("MyContextPr
 }) {}
 
 // @effect-diagnostics-next-line missingEffectServiceDependency:off
-class MyContextProvider3 extends Middleware.Tag<MyContextProvider3>()("MyContextProvider3", {
+class MyContextProvider3 extends Middleware.TagService<MyContextProvider3>()("MyContextProvider3", {
   provides: [Some],
   requires: [SomeElse]
 })({
@@ -71,23 +72,25 @@ class MyContextProvider3 extends Middleware.Tag<MyContextProvider3>()("MyContext
 expectTypeOf(MyContextProvider3.Default).toEqualTypeOf<Layer.Layer<MyContextProvider3, CustomError1, never>>()
 
 // @effect-diagnostics-next-line missingEffectServiceDependency:off
-class MyContextProvider2 extends Middleware.Tag<MyContextProvider2>()("MyContextProvider2", { provides: SomeElse })({
-  effect: Effect.gen(function*() {
-    if (Math.random() > 0.5) return yield* new CustomError1()
+class MyContextProvider2
+  extends Middleware.TagService<MyContextProvider2>()("MyContextProvider2", { provides: SomeElse })({
+    effect: Effect.gen(function*() {
+      if (Math.random() > 0.5) return yield* new CustomError1()
 
-    return Effect.fnUntraced(function*() {
-      // we test without dependencies, so that we end up with an R of never.
+      return Effect.fnUntraced(function*() {
+        // we test without dependencies, so that we end up with an R of never.
 
-      return new SomeElse({ b: 2 })
+        return new SomeElse({ b: 2 })
+      })
     })
   })
-}) {}
+{}
 
 //
 
 const Str = Context.GenericTag<"str", "str">("str")
 
-export class BogusMiddleware extends Tag<BogusMiddleware>()("BogusMiddleware", {
+export class BogusMiddleware extends TagService<BogusMiddleware>()("BogusMiddleware", {
   wrap: true
 })({
   effect: Effect.gen(function*() {
@@ -108,6 +111,12 @@ const genericMiddlewares = [
   MyContextProvider2
 ] as const
 
+const genericMiddlewaresLive = [
+  DefaultGenericMiddlewaresLive,
+  BogusMiddleware.Default,
+  MyContextProvider2.Default
+] as const
+
 const middleware = makeMiddleware<RequestContextMap>(RequestContextMap)
   .middleware(
     RequireRoles,
@@ -237,9 +246,25 @@ export class SomethingService2 extends Effect.Service<SomethingService2>()("Some
   })
 }) {}
 
-export const { Router, matchAll } = makeRouter(middleware, true)
+const MiddlewaresLive = [
+  RequireRolesLive,
+  TestLive,
+  AllowAnonymousLive,
+  MyContextProvider.Default,
+  ...genericMiddlewaresLive
+] as const
 
-export const r2 = makeRouter(middleware2, true)
+export const { Router, matchAll } = makeRouter(
+  Object.assign(middleware, {
+    Default: middleware.layer.pipe(Layer.provide(MiddlewaresLive))
+  }),
+  true
+)
+
+export const r2 = makeRouter(
+  Object.assign(middleware, { Default: middleware2.layer.pipe(Layer.provide(MiddlewaresLive)) }),
+  true
+)
 
 const router = Router(Something)({
   dependencies: [

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

@@ -1 +1 @@
-{"version":3,"file":"controller.test.d.ts","sourceRoot":"","sources":["../controller.test.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,WAAW,EAAE,KAAK,UAAU,EAA0B,MAAM,+BAA+B,CAAA;AACzG,OAAO,EAAE,KAAK,gBAAgB,EAAE,MAAM,aAAa,CAAA;AAEnD,OAAO,EAAW,MAAM,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,YAAY,CAAA;AAE7D,OAAO,EAA6C,UAAU,EAAO,MAAM,kCAAkC,CAAA;AAE7G,OAAO,EAAE,cAAc,EAAE,YAAY,EAAE,iBAAiB,EAAE,YAAY,EAAE,IAAI,EAAE,QAAQ,EAAE,WAAW,EAAE,IAAI,EAAE,MAAM,eAAe,CAAA;;;;;;AAgEhI,cAAM,kBAAmB,SAAQ,uBAU/B;CAAG;;;;;;AAML,qBAAa,eAAgB,SAAQ,oBAYnC;CACD;AA0DD,eAAO,MAAM,WAAW;;;;;;YAIM,CAAA;AAE9B,MAAM,MAAM,aAAa,GAAG;IAC1B,yCAAyC;IACzC,cAAc,CAAC,EAAE,IAAI,CAAA;IACrB,iEAAiE;IACjE,UAAU,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;CAC/B,CAAA;AACD,eAAO,MAAuB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAI/B,CAAA;;;;;;;;;;AAEF,qBAAa,GAAI,SAAQ,QAA0C;CAAG;;;;;;;;;;AACtE,qBAAa,GAAI,SAAQ,QAA0C;CAAG;;;;;;;;;;;;AAEtE,qBAAa,WAAY,SAAQ,gBAEV;CAAG;;;;;;;;;;;;AAgB1B,qBAAa,YAAa,SAAQ,iBAET;CAAG;;;;;;;;;;;;AAE5B,qBAAa,aAAc,SAAQ,kBAEA;CAAG;;;;;AAItC,qBAAa,gBAAiB,SAAQ,qBAKpC;CAAG;;;;;AASL,qBAAa,aAAc,SAAQ,kBAOjC;CAAG;;;;;AAEL,qBAAa,iBAAkB,SAAQ,sBAKrC;CAAG;AAEL,eAAO,MAAQ,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAAE,QAAQ;;;;;yHAAiC,CAAA;AAEhE,eAAO,MAAM,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAAgC,CAAA"}
+{"version":3,"file":"controller.test.d.ts","sourceRoot":"","sources":["../controller.test.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,WAAW,EAAE,KAAK,UAAU,EAA0B,MAAM,+BAA+B,CAAA;AACzG,OAAO,EAAE,KAAK,gBAAgB,EAAE,MAAM,aAAa,CAAA;AAEnD,OAAO,EAAW,MAAM,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,YAAY,CAAA;AAE7D,OAAO,EAAiD,UAAU,EAAc,MAAM,kCAAkC,CAAA;AAGxH,OAAO,EAAE,cAAc,EAAsB,YAAY,EAAE,iBAAiB,EAAE,YAAY,EAAoB,IAAI,EAAE,QAAQ,EAAE,WAAW,EAAE,IAAI,EAAY,MAAM,eAAe,CAAA;;;;;;AAgEhL,cAAM,kBACJ,SAAQ,uBAUN;CACF;;;;;;AAMF,qBAAa,eAAgB,SAAQ,oBAYnC;CACD;AAgED,eAAO,MAAM,WAAW;;;;;;YAIM,CAAA;AAE9B,MAAM,MAAM,aAAa,GAAG;IAC1B,yCAAyC;IACzC,cAAc,CAAC,EAAE,IAAI,CAAA;IACrB,iEAAiE;IACjE,UAAU,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;CAC/B,CAAA;AACD,eAAO,MAAuB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAI/B,CAAA;;;;;;;;;;AAEF,qBAAa,GAAI,SAAQ,QAA0C;CAAG;;;;;;;;;;AACtE,qBAAa,GAAI,SAAQ,QAA0C;CAAG;;;;;;;;;;;;AAEtE,qBAAa,WAAY,SAAQ,gBAEV;CAAG;;;;;;;;;;;;AAgB1B,qBAAa,YAAa,SAAQ,iBAET;CAAG;;;;;;;;;;;;AAE5B,qBAAa,aAAc,SAAQ,kBAEA;CAAG;;;;;AAItC,qBAAa,gBAAiB,SAAQ,qBAKpC;CAAG;;;;;AASL,qBAAa,aAAc,SAAQ,kBAOjC;CAAG;;;;;AAEL,qBAAa,iBAAkB,SAAQ,sBAKrC;CAAG;AAUL,eAAO,MAAQ,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAAE,QAAQ;;;;;yHAK9B,CAAA;AAED,eAAO,MAAM,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAGd,CAAA"}

package/test/dist/fixtures.d.ts

@@ -1,6 +1,5 @@
-import { Context, Effect, S, Scope } from "effect-app";
+import { Context, Effect, Layer, S, Scope } from "effect-app";
 import { NotLoggedInError, RPCContextMap, UnauthorizedError } from "effect-app/client";
-import { Middleware } from "../src/api/routing.js";
 declare const UserProfile_base: S.EnhancedClass<UserProfile, {
     id: typeof S.String;
     roles: S.Array$<typeof S.String> & {
@@ -23,12 +22,12 @@ declare const Some_base: (abstract new (service: {
     a: number;
 }>) & {
     toLayer: {
-        (): import("effect/Layer").Layer<Some, never, never>;
-        <E_1, R_1>(eff: Effect.Effect<Omit<Some, keyof Context.TagClassShape<any, any>>, E_1, R_1>): import("effect/Layer").Layer<Some, E_1, R_1>;
+        (): 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: {
-        (): import("effect/Layer").Layer<Some, never, never>;
-        <E_1, R_2>(eff: Effect.Effect<Omit<Some, keyof Context.TagClassShape<any, any>>, E_1, R_2>): import("effect/Layer").Layer<Some, E_1, Exclude<R_2, Scope.Scope>>;
+        (): 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>;
@@ -37,7 +36,7 @@ declare const Some_base: (abstract new (service: {
 } & {
     use: <X>(body: (_: {
         a: number;
-    }) => X) => X extends Effect.Effect<infer A, infer E_1, infer R_3> ? Effect.Effect<A, E_1, Some | R_3> : Effect.Effect<X, never, Some>;
+    }) => X) => X extends Effect.Effect<infer A_1, infer E_2, infer R_4> ? Effect.Effect<A_1, E_2, Some | R_4> : Effect.Effect<X, never, Some>;
 };
 export declare class Some extends Some_base {
 }
@@ -49,12 +48,12 @@ declare const SomeElse_base: (abstract new (service: {
     b: number;
 }>) & {
     toLayer: {
-        (): import("effect/Layer").Layer<SomeElse, never, never>;
-        <E_1, R_1>(eff: Effect.Effect<Omit<SomeElse, keyof Context.TagClassShape<any, any>>, E_1, R_1>): import("effect/Layer").Layer<SomeElse, E_1, R_1>;
+        (): 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: {
-        (): import("effect/Layer").Layer<SomeElse, never, never>;
-        <E_1, R_2>(eff: Effect.Effect<Omit<SomeElse, keyof Context.TagClassShape<any, any>>, E_1, R_2>): import("effect/Layer").Layer<SomeElse, E_1, Exclude<R_2, Scope.Scope>>;
+        (): 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>;
@@ -63,7 +62,7 @@ declare const SomeElse_base: (abstract new (service: {
 } & {
     use: <X>(body: (_: {
         b: number;
-    }) => X) => X extends Effect.Effect<infer A, infer E_1, infer R_3> ? Effect.Effect<A, E_1, R_3 | SomeElse> : Effect.Effect<X, never, SomeElse>;
+    }) => X) => X extends Effect.Effect<infer A_1, infer E_2, infer R_4> ? Effect.Effect<A_1, E_2, R_4 | SomeElse> : Effect.Effect<X, never, SomeElse>;
 };
 export declare class SomeElse extends SomeElse_base {
 }
@@ -75,12 +74,12 @@ declare const SomeService_base: (abstract new (service: {
     a: number;
 }>) & {
     toLayer: {
-        (): import("effect/Layer").Layer<SomeService, never, never>;
-        <E_1, R_1>(eff: Effect.Effect<Omit<SomeService, keyof Context.TagClassShape<any, any>>, E_1, R_1>): import("effect/Layer").Layer<SomeService, E_1, R_1>;
+        (): 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: {
-        (): import("effect/Layer").Layer<SomeService, never, never>;
-        <E_1, R_2>(eff: Effect.Effect<Omit<SomeService, keyof Context.TagClassShape<any, any>>, E_1, R_2>): import("effect/Layer").Layer<SomeService, E_1, Exclude<R_2, Scope.Scope>>;
+        (): 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>;
@@ -89,10 +88,30 @@ declare const SomeService_base: (abstract new (service: {
 } & {
     use: <X>(body: (_: {
         a: number;
-    }) => X) => X extends Effect.Effect<infer A, infer E_1, infer R_3> ? Effect.Effect<A, E_1, R_3 | SomeService> : Effect.Effect<X, never, SomeService>;
+    }) => X) => X extends Effect.Effect<infer A_1, infer E_2, infer R_4> ? Effect.Effect<A_1, E_2, R_4 | SomeService> : Effect.Effect<X, never, SomeService>;
 };
 export declare class SomeService extends SomeService_base {
 }
+declare const SomeMiddleware_base: import("../src/api/routing.js").TagClass<SomeMiddleware, "SomeMiddleware", {
+    readonly provides: typeof Some;
+}>;
+export declare class SomeMiddleware extends SomeMiddleware_base {
+}
+export declare const SomeMiddlewareLive: Layer.Layer<SomeMiddleware, never, never>;
+declare const SomeMiddlewareWrap_base: import("../src/api/routing.js").TagClass<SomeMiddlewareWrap, "SomeMiddlewareWrap", {
+    readonly provides: typeof Some;
+    readonly wrap: true;
+}>;
+export declare class SomeMiddlewareWrap extends SomeMiddlewareWrap_base {
+}
+export declare const SomeMiddlewareWrapLive: Layer.Layer<SomeMiddlewareWrap, never, never>;
+declare const SomeElseMiddleware_base: import("../src/api/routing.js").TagClass<SomeElseMiddleware, "SomeElseMiddleware", {
+    readonly provides: typeof SomeElse;
+    readonly wrap: true;
+}>;
+export declare class SomeElseMiddleware extends SomeElseMiddleware_base {
+}
+export declare const SomeElseMiddlewareLive: Layer.Layer<SomeElseMiddleware, never, never>;
 export declare const RequestContextMap: {
     readonly allowAnonymous: RPCContextMap.Inverted<[typeof UserProfile], typeof NotLoggedInError>;
     readonly requireRoles: RPCContextMap.Custom<never, typeof UnauthorizedError, string[]>;
@@ -101,31 +120,28 @@ export declare const RequestContextMap: {
 type _RequestContextMap = typeof RequestContextMap;
 export interface RequestContextMap extends _RequestContextMap {
 }
-declare const AllowAnonymous_base: Middleware.TagClass<AllowAnonymous, "AllowAnonymous", {
-    readonly dynamic: Middleware.RpcDynamic<"allowAnonymous", RPCContextMap.Inverted<[typeof UserProfile], typeof NotLoggedInError>>;
+declare const AllowAnonymous_base: import("../src/api/routing.js").TagClass<AllowAnonymous, "AllowAnonymous", {
+    readonly dynamic: import("../src/api/routing.js").RpcDynamic<"allowAnonymous", RPCContextMap.Inverted<[typeof UserProfile], typeof NotLoggedInError>>;
     readonly requires: typeof SomeElse;
-}> & {
-    Default: import("effect/Layer").Layer<AllowAnonymous, never, never>;
-};
+}>;
 export declare class AllowAnonymous extends AllowAnonymous_base {
 }
-declare const RequireRoles_base: Middleware.TagClass<RequireRoles, "RequireRoles", {
-    readonly dynamic: Middleware.RpcDynamic<"requireRoles", RPCContextMap.Custom<never, typeof UnauthorizedError, string[]>>;
+export declare const AllowAnonymousLive: Layer.Layer<AllowAnonymous, never, never>;
+declare const RequireRoles_base: import("../src/api/routing.js").TagClass<RequireRoles, "RequireRoles", {
+    readonly dynamic: import("../src/api/routing.js").RpcDynamic<"requireRoles", RPCContextMap.Custom<never, typeof UnauthorizedError, string[]>>;
     readonly wrap: true;
     readonly dependsOn: readonly [typeof AllowAnonymous];
-}> & {
-    Default: import("effect/Layer").Layer<RequireRoles, never, SomeService>;
-};
+}>;
 export declare class RequireRoles extends RequireRoles_base {
 }
-declare const Test_base: Middleware.TagClass<Test, "Test", {
+export declare const RequireRolesLive: Layer.Layer<RequireRoles, never, SomeService>;
+declare const Test_base: import("../src/api/routing.js").TagClass<Test, "Test", {
     readonly wrap: true;
-    readonly dynamic: Middleware.RpcDynamic<"test", RPCContextMap.RPCContextMap<never, typeof S.Never>>;
-}> & {
-    Default: import("effect/Layer").Layer<Test, never, never>;
-};
+    readonly dynamic: import("../src/api/routing.js").RpcDynamic<"test", RPCContextMap.RPCContextMap<never, typeof S.Never>>;
+}>;
 export declare class Test extends Test_base {
 }
+export declare const TestLive: Layer.Layer<Test, never, never>;
 declare const CustomError1_base: S.TaggedErrorClass<NotLoggedInError, "CustomError1", {
     readonly _tag: S.tag<"CustomError1">;
 }>;

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,EAAU,CAAC,EAAE,KAAK,EAAE,MAAM,YAAY,CAAA;AAC9D,OAAO,EAAE,gBAAgB,EAAE,aAAa,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAA;AAEtF,OAAO,EAAyB,UAAU,EAAE,MAAM,uBAAuB,CAAA;;;;;;;;;;;;;AAEzE,qBAAa,WAAY,SAAQ,gBAKhC;CACA;;;;;;;;;;;;;;;;;;;;;;;;;AAED,qBAAa,IAAK,SAAQ,SAA2D;CAAG;;;;;;;;;;;;;;;;;;;;;;;;;AACxF,qBAAa,QAAS,SAAQ,aAAmE;CAAG;;;;;;;;;;;;;;;;;;;;;;;;;AAEpG,qBAAa,WAAY,SAAQ,gBAAgE;CAAG;AASpG,eAAO,MAAM,iBAAiB;;;;CAIpB,CAAA;AAEV,KAAK,kBAAkB,GAAG,OAAO,iBAAiB,CAAA;AAClD,MAAM,WAAW,iBAAkB,SAAQ,kBAAkB;CAAG;;;;;;;AAEhE,qBAAa,cAAe,SAAQ,mBA4BlC;CACD;;;;;;;;AAID,qBAAa,YAAa,SAAQ,iBA6BhC;CACD;;;;;;;AAGD,qBAAa,IAAK,SAAQ,SASxB;CAAG;;;;AAEL,qBAAa,YAAa,SAAQ,iBAAmD;CAAG;;;;AACxF,qBAAa,YAAa,SAAQ,iBAAmD;CAAG"}
+{"version":3,"file":"fixtures.d.ts","sourceRoot":"","sources":["../fixtures.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,KAAK,EAAU,CAAC,EAAE,KAAK,EAAE,MAAM,YAAY,CAAA;AACrE,OAAO,EAAE,gBAAgB,EAAE,aAAa,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAA;;;;;;;;;;;;;AAItF,qBAAa,WAAY,SAAQ,gBAKhC;CACA;;;;;;;;;;;;;;;;;;;;;;;;;AAED,qBAAa,IAAK,SAAQ,SAA2D;CAAG;;;;;;;;;;;;;;;;;;;;;;;;;AACxF,qBAAa,QAAS,SAAQ,aAAmE;CAAG;;;;;;;;;;;;;;;;;;;;;;;;;AAEpG,qBAAa,WAAY,SAAQ,gBAAgE;CAAG;;;;AAEpG,qBAAa,cAAe,SAAQ,mBAElC;CAAG;AAEL,eAAO,MAAM,kBAAkB,2CAS9B,CAAA;;;;;AAGD,qBAAa,kBAAmB,SAAQ,uBAGtC;CACD;AAED,eAAO,MAAM,sBAAsB,+CAMlC,CAAA;;;;;AAED,qBAAa,kBAAmB,SAAQ,uBAGtC;CAAG;AAEL,eAAO,MAAM,sBAAsB,+CAUlC,CAAA;AASD,eAAO,MAAM,iBAAiB;;;;CAIpB,CAAA;AAEV,KAAK,kBAAkB,GAAG,OAAO,iBAAiB,CAAA;AAClD,MAAM,WAAW,iBAAkB,SAAQ,kBAAkB;CAAG;;;;;AAEhE,qBAAa,cAAe,SAAQ,mBAGlC;CAAG;AAEL,eAAO,MAAM,kBAAkB,2CA0B9B,CAAA;;;;;;AAID,qBAAa,YAAa,SAAQ,iBAOhC;CAAG;AAEL,eAAO,MAAM,gBAAgB,+CAuB5B,CAAA;;;;;AAGD,qBAAa,IAAK,SAAQ,SAGxB;CAAG;AAEL,eAAO,MAAM,QAAQ,iCAOpB,CAAA;;;;AAED,qBAAa,YAAa,SAAQ,iBAAmD;CAAG;;;;AACxF,qBAAa,YAAa,SAAQ,iBAAmD;CAAG"}

package/test/dist/fixtures.js

@@ -1,7 +1,7 @@
-import { Context, Effect, Option, S, Scope } from "effect-app";
+import { Context, Effect, Layer, Option, S, Scope } from "effect-app";
 import { NotLoggedInError, RPCContextMap, UnauthorizedError } from "effect-app/client";
 import { TaggedError } from "effect-app/Schema";
-import { contextMap, getConfig, Middleware } from "../src/api/routing.js";
+import { contextMap, getConfig, Tag } from "../src/api/routing.js";
 export class UserProfile extends Context.assignTag("UserProfile")(S.Class("UserProfile")({
     id: S.String,
     roles: S.Array(S.String)
@@ -14,6 +14,38 @@ export class SomeElse extends Context.TagMakeId("SomeElse", Effect.succeed({ b:
 const MakeSomeService = Effect.succeed({ a: 1 });
 export class SomeService extends Context.TagMakeId("SomeService", MakeSomeService)() {
 }
+export class SomeMiddleware extends Tag()("SomeMiddleware", {
+    provides: Some
+}) {
+}
+export const SomeMiddlewareLive = Layer.effect(SomeMiddleware, Effect.gen(function* () {
+    // yield* Effect.context<"test-dep">()
+    return () => Effect.gen(function* () {
+        return new Some({ a: 1 });
+    });
+}));
+// functionally equivalent to the one above
+export class SomeMiddlewareWrap extends Tag()("SomeMiddlewareWrap", {
+    provides: Some,
+    wrap: true
+}) {
+}
+export const SomeMiddlewareWrapLive = Layer.effect(SomeMiddlewareWrap, Effect.gen(function* () {
+    // yield* Effect.context<"test-dep">()
+    return ({ next }) => next.pipe(Effect.provideService(Some, new Some({ a: 1 })));
+}));
+export class SomeElseMiddleware extends Tag()("SomeElseMiddleware", {
+    provides: SomeElse,
+    wrap: true
+}) {
+}
+export const SomeElseMiddlewareLive = Layer.effect(SomeElseMiddleware, Effect.gen(function* () {
+    // yield* Effect.context<"test-dep">()
+    return ({ next }) => Effect.gen(function* () {
+        // yield* Effect.context<"test-dep2">()
+        return yield* next.pipe(Effect.provideService(SomeElse, new SomeElse({ b: 2 })));
+    });
+}));
 const requestConfig = getConfig();
 // TODO: null as never sucks
 // why [UserProfile] is needed? AllowAnonymous triggers an error if just UserProfile without []
@@ -25,71 +57,68 @@ export const RequestContextMap = {
     requireRoles: RPCContextMap.makeCustom(null, UnauthorizedError, Array()),
     test: RPCContextMap.make(null, S.Never)
 };
-export class AllowAnonymous extends Middleware.Tag()("AllowAnonymous", {
+export class AllowAnonymous extends Tag()("AllowAnonymous", {
     dynamic: contextMap(RequestContextMap, "allowAnonymous"),
     requires: SomeElse
-})({
-    effect: Effect.gen(function* () {
-        return Effect.fnUntraced(function* ({ headers, rpc }) {
-            yield* SomeElse;
-            yield* Scope.Scope; // provided by HttpLayerRouter.Provided
-            const isLoggedIn = !!headers["x-user"];
-            if (!isLoggedIn) {
-                if (!requestConfig(rpc).allowAnonymous) {
-                    return yield* new NotLoggedInError({ message: "Not logged in" });
-                }
-                return Option.none();
-            }
-            return Option.some(Context.make(UserProfile, new UserProfile({
-                id: "whatever",
-                roles: ["user", ...headers["x-is-manager"] === "true" ? ["manager"] : []]
-            })));
-        });
-    })
 }) {
 }
+export const AllowAnonymousLive = Layer.effect(AllowAnonymous, Effect.gen(function* () {
+    return Effect.fnUntraced(function* ({ headers, rpc }) {
+        yield* SomeElse;
+        yield* Scope.Scope; // provided by HttpLayerRouter.Provided
+        const isLoggedIn = !!headers["x-user"];
+        if (!isLoggedIn) {
+            if (!requestConfig(rpc).allowAnonymous) {
+                return yield* new NotLoggedInError({ message: "Not logged in" });
+            }
+            return Option.none();
+        }
+        return Option.some(Context.make(UserProfile, new UserProfile({
+            id: "whatever",
+            roles: ["user", ...headers["x-is-manager"] === "true" ? ["manager"] : []]
+        })));
+    });
+}));
 // TODO: don't expect service when it's wrap
 // @effect-diagnostics-next-line missingEffectServiceDependency:off
-export class RequireRoles extends Middleware.Tag()("RequireRoles", {
+export class RequireRoles extends Tag()("RequireRoles", {
     dynamic: contextMap(RequestContextMap, "requireRoles"),
     wrap: true,
     // wrap: true,
     // had to move this in here, because once you put it manually as a readonly static property on the class,
     // there's a weird issue where the fluent api stops behaving properly after adding this middleware via `addDynamicMiddleware`
     dependsOn: [AllowAnonymous]
-})({
-    effect: Effect.gen(function* () {
-        yield* SomeService;
-        return Effect.fnUntraced(function* ({ next, rpc }) {
-            // we don't know if the service will be provided or not, so we use option..
-            const userProfile = yield* Effect.serviceOption(UserProfile);
-            const { requireRoles } = requestConfig(rpc);
-            console.dir({
-                userProfile,
-                requireRoles
-            }, { depth: 5 });
-            if (requireRoles && !userProfile.value?.roles?.some((role) => requireRoles.includes(role))) {
-                return yield* new UnauthorizedError({ message: "don't have the right roles" });
-            }
-            return yield* next;
-        });
-    })
 }) {
 }
+export const RequireRolesLive = Layer.effect(RequireRoles, Effect.gen(function* () {
+    yield* SomeService;
+    return Effect.fnUntraced(function* ({ next, rpc }) {
+        // we don't know if the service will be provided or not, so we use option..
+        const userProfile = yield* Effect.serviceOption(UserProfile);
+        const { requireRoles } = requestConfig(rpc);
+        console.dir({
+            userProfile,
+            requireRoles
+        }, { depth: 5 });
+        if (requireRoles && !userProfile.value?.roles?.some((role) => requireRoles.includes(role))) {
+            return yield* new UnauthorizedError({ message: "don't have the right roles" });
+        }
+        return yield* next;
+    });
+}));
 // TODO: don't expect service when it's wrap
-export class Test extends Middleware.Tag()("Test", {
+export class Test extends Tag()("Test", {
     wrap: true,
     dynamic: contextMap(RequestContextMap, "test")
-})({
-    effect: Effect.gen(function* () {
-        return Effect.fn(function* ({ next }) {
-            return yield* next;
-        });
-    })
 }) {
 }
+export const TestLive = Layer.effect(Test, Effect.gen(function* () {
+    return Effect.fn(function* ({ next }) {
+        return yield* next;
+    });
+}));
 export class CustomError1 extends TaggedError()("CustomError1", {}) {
 }
 export class CustomError2 extends TaggedError()("CustomError1", {}) {
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZml4dHVyZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9maXh0dXJlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsT0FBTyxFQUFFLE1BQU0sRUFBRSxNQUFNLEVBQUUsQ0FBQyxFQUFFLEtBQUssRUFBRSxNQUFNLFlBQVksQ0FBQTtBQUM5RCxPQUFPLEVBQUUsZ0JBQWdCLEVBQUUsYUFBYSxFQUFFLGlCQUFpQixFQUFFLE1BQU0sbUJBQW1CLENBQUE7QUFDdEYsT0FBTyxFQUFFLFdBQVcsRUFBRSxNQUFNLG1CQUFtQixDQUFBO0FBQy9DLE9BQU8sRUFBRSxVQUFVLEVBQUUsU0FBUyxFQUFFLFVBQVUsRUFBRSxNQUFNLHVCQUF1QixDQUFBO0FBRXpFLE1BQU0sT0FBTyxXQUFZLFNBQVEsT0FBTyxDQUFDLFNBQVMsQ0FBMkIsYUFBYSxDQUFDLENBQ3pGLENBQUMsQ0FBQyxLQUFLLENBQWMsYUFBYSxDQUFDLENBQUM7SUFDbEMsRUFBRSxFQUFFLENBQUMsQ0FBQyxNQUFNO0lBQ1osS0FBSyxFQUFFLENBQUMsQ0FBQyxLQUFLLENBQUMsQ0FBQyxDQUFDLE1BQU0sQ0FBQztDQUN6QixDQUFDLENBQ0g7Q0FDQTtBQUVELE1BQU0sT0FBTyxJQUFLLFNBQVEsT0FBTyxDQUFDLFNBQVMsQ0FBQyxNQUFNLEVBQUUsTUFBTSxDQUFDLE9BQU8sQ0FBQyxFQUFFLENBQUMsRUFBRSxDQUFDLEVBQUUsQ0FBQyxDQUFDLEVBQVE7Q0FBRztBQUN4RixNQUFNLE9BQU8sUUFBUyxTQUFRLE9BQU8sQ0FBQyxTQUFTLENBQUMsVUFBVSxFQUFFLE1BQU0sQ0FBQyxPQUFPLENBQUMsRUFBRSxDQUFDLEVBQUUsQ0FBQyxFQUFFLENBQUMsQ0FBQyxFQUFZO0NBQUc7QUFDcEcsTUFBTSxlQUFlLEdBQUcsTUFBTSxDQUFDLE9BQU8sQ0FBQyxFQUFFLENBQUMsRUFBRSxDQUFDLEVBQUUsQ0FBQyxDQUFBO0FBQ2hELE1BQU0sT0FBTyxXQUFZLFNBQVEsT0FBTyxDQUFDLFNBQVMsQ0FBQyxhQUFhLEVBQUUsZUFBZSxDQUFDLEVBQWU7Q0FBRztBQUVwRyxNQUFNLGFBQWEsR0FBRyxTQUFTLEVBQXFCLENBQUE7QUFFcEQsNEJBQTRCO0FBQzVCLCtGQUErRjtBQUMvRiwwRUFBMEU7QUFDMUUsRUFBRTtBQUNGLHdEQUF3RDtBQUN4RCxNQUFNLENBQUMsTUFBTSxpQkFBaUIsR0FBRztJQUMvQixjQUFjLEVBQUUsYUFBYSxDQUFDLFlBQVksQ0FBQyxDQUFDLFdBQVcsQ0FBQyxFQUFFLGdCQUFnQixDQUFDO0lBQzNFLFlBQVksRUFBRSxhQUFhLENBQUMsVUFBVSxDQUFDLElBQWEsRUFBRSxpQkFBaUIsRUFBRSxLQUFLLEVBQVUsQ0FBQztJQUN6RixJQUFJLEVBQUUsYUFBYSxDQUFDLElBQUksQ0FBQyxJQUFhLEVBQUUsQ0FBQyxDQUFDLEtBQUssQ0FBQztDQUN4QyxDQUFBO0FBS1YsTUFBTSxPQUFPLGNBQWUsU0FBUSxVQUFVLENBQUMsR0FBRyxFQUFrQixDQUFDLGdCQUFnQixFQUFFO0lBQ3JGLE9BQU8sRUFBRSxVQUFVLENBQUMsaUJBQWlCLEVBQUUsZ0JBQWdCLENBQUM7SUFDeEQsUUFBUSxFQUFFLFFBQVE7Q0FDbkIsQ0FBQyxDQUFDO0lBQ0QsTUFBTSxFQUFFLE1BQU0sQ0FBQyxHQUFHLENBQUMsUUFBUSxDQUFDO1FBQzFCLE9BQU8sTUFBTSxDQUFDLFVBQVUsQ0FDdEIsUUFBUSxDQUFDLEVBQUMsRUFBRSxPQUFPLEVBQUUsR0FBRyxFQUFFO1lBQ3hCLEtBQUssQ0FBQyxDQUFDLFFBQVEsQ0FBQTtZQUNmLEtBQUssQ0FBQyxDQUFDLEtBQUssQ0FBQyxLQUFLLENBQUEsQ0FBQyx1Q0FBdUM7WUFDMUQsTUFBTSxVQUFVLEdBQUcsQ0FBQyxDQUFDLE9BQU8sQ0FBQyxRQUFRLENBQUMsQ0FBQTtZQUN0QyxJQUFJLENBQUMsVUFBVSxFQUFFLENBQUM7Z0JBQ2hCLElBQUksQ0FBQyxhQUFhLENBQUMsR0FBRyxDQUFDLENBQUMsY0FBYyxFQUFFLENBQUM7b0JBQ3ZDLE9BQU8sS0FBSyxDQUFDLENBQUMsSUFBSSxnQkFBZ0IsQ0FBQyxFQUFFLE9BQU8sRUFBRSxlQUFlLEVBQUUsQ0FBQyxDQUFBO2dCQUNsRSxDQUFDO2dCQUNELE9BQU8sTUFBTSxDQUFDLElBQUksRUFBRSxDQUFBO1lBQ3RCLENBQUM7WUFDRCxPQUFPLE1BQU0sQ0FBQyxJQUFJLENBQ2hCLE9BQU8sQ0FBQyxJQUFJLENBQ1YsV0FBVyxFQUNYLElBQUksV0FBVyxDQUFDO2dCQUNkLEVBQUUsRUFBRSxVQUFVO2dCQUNkLEtBQUssRUFBRSxDQUFDLE1BQU0sRUFBRSxHQUFHLE9BQU8sQ0FBQyxjQUFjLENBQUMsS0FBSyxNQUFNLENBQUMsQ0FBQyxDQUFDLENBQUMsU0FBUyxDQUFDLENBQUMsQ0FBQyxDQUFDLEVBQUUsQ0FBQzthQUMxRSxDQUFDLENBQ0gsQ0FDRixDQUFBO1FBQ0gsQ0FBQyxDQUNGLENBQUE7SUFDSCxDQUFDLENBQUM7Q0FDSCxDQUFDO0NBQ0Q7QUFFRCw0Q0FBNEM7QUFDNUMsbUVBQW1FO0FBQ25FLE1BQU0sT0FBTyxZQUFhLFNBQVEsVUFBVSxDQUFDLEdBQUcsRUFBZ0IsQ0FBQyxjQUFjLEVBQUU7SUFDL0UsT0FBTyxFQUFFLFVBQVUsQ0FBQyxpQkFBaUIsRUFBRSxjQUFjLENBQUM7SUFDdEQsSUFBSSxFQUFFLElBQUk7SUFDVixjQUFjO0lBQ2QseUdBQXlHO0lBQ3pHLDZIQUE2SDtJQUM3SCxTQUFTLEVBQUUsQ0FBQyxjQUFjLENBQUM7Q0FDNUIsQ0FBQyxDQUFDO0lBQ0QsTUFBTSxFQUFFLE1BQU0sQ0FBQyxHQUFHLENBQUMsUUFBUSxDQUFDO1FBQzFCLEtBQUssQ0FBQyxDQUFDLFdBQVcsQ0FBQTtRQUNsQixPQUFPLE1BQU0sQ0FBQyxVQUFVLENBQ3RCLFFBQVEsQ0FBQyxFQUFDLEVBQUUsSUFBSSxFQUFFLEdBQUcsRUFBRTtZQUNyQiwyRUFBMkU7WUFDM0UsTUFBTSxXQUFXLEdBQUcsS0FBSyxDQUFDLENBQUMsTUFBTSxDQUFDLGFBQWEsQ0FBQyxXQUFXLENBQUMsQ0FBQTtZQUM1RCxNQUFNLEVBQUUsWUFBWSxFQUFFLEdBQUcsYUFBYSxDQUFDLEdBQUcsQ0FBQyxDQUFBO1lBQzNDLE9BQU8sQ0FBQyxHQUFHLENBQ1Q7Z0JBQ0UsV0FBVztnQkFDWCxZQUFZO2FBQ2IsRUFDRCxFQUFFLEtBQUssRUFBRSxDQUFDLEVBQUUsQ0FDYixDQUFBO1lBQ0QsSUFBSSxZQUFZLElBQUksQ0FBQyxXQUFXLENBQUMsS0FBSyxFQUFFLEtBQUssRUFBRSxJQUFJLENBQUMsQ0FBQyxJQUFJLEVBQUUsRUFBRSxDQUFDLFlBQVksQ0FBQyxRQUFRLENBQUMsSUFBSSxDQUFDLENBQUMsRUFBRSxDQUFDO2dCQUMzRixPQUFPLEtBQUssQ0FBQyxDQUFDLElBQUksaUJBQWlCLENBQUMsRUFBRSxPQUFPLEVBQUUsNEJBQTRCLEVBQUUsQ0FBQyxDQUFBO1lBQ2hGLENBQUM7WUFDRCxPQUFPLEtBQUssQ0FBQyxDQUFDLElBQUksQ0FBQTtRQUNwQixDQUFDLENBQ0YsQ0FBQTtJQUNILENBQUMsQ0FBQztDQUNILENBQUM7Q0FDRDtBQUVELDRDQUE0QztBQUM1QyxNQUFNLE9BQU8sSUFBSyxTQUFRLFVBQVUsQ0FBQyxHQUFHLEVBQVEsQ0FBQyxNQUFNLEVBQUU7SUFDdkQsSUFBSSxFQUFFLElBQUk7SUFDVixPQUFPLEVBQUUsVUFBVSxDQUFDLGlCQUFpQixFQUFFLE1BQU0sQ0FBQztDQUMvQyxDQUFDLENBQUM7SUFDRCxNQUFNLEVBQUUsTUFBTSxDQUFDLEdBQUcsQ0FBQyxRQUFRLENBQUM7UUFDMUIsT0FBTyxNQUFNLENBQUMsRUFBRSxDQUFDLFFBQVEsQ0FBQyxFQUFDLEVBQUUsSUFBSSxFQUFFO1lBQ2pDLE9BQU8sS0FBSyxDQUFDLENBQUMsSUFBSSxDQUFBO1FBQ3BCLENBQUMsQ0FBQyxDQUFBO0lBQ0osQ0FBQyxDQUFDO0NBQ0gsQ0FBQztDQUFHO0FBRUwsTUFBTSxPQUFPLFlBQWEsU0FBUSxXQUFXLEVBQW9CLENBQUMsY0FBYyxFQUFFLEVBQUUsQ0FBQztDQUFHO0FBQ3hGLE1BQU0sT0FBTyxZQUFhLFNBQVEsV0FBVyxFQUFvQixDQUFDLGNBQWMsRUFBRSxFQUFFLENBQUM7Q0FBRyJ9
+//# sourceMappingURL=data:application/json;base64,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

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,EAAK,MAAM,YAAY,CAAA;AAG9D,OAAO,EAAkB,UAAU,EAAE,MAAM,uBAAuB,CAAA;AAClE,OAAO,EAAmD,IAAI,EAAE,QAAQ,EAAqB,MAAM,eAAe,CAAA;;;;;;AAElH,qBAAa,cAAe,SAAQ,mBAUlC;CACD;;;;;;;AAGD,qBAAa,kBAAmB,SAAQ,uBAQtC;CACD;;;;;;;AAED,qBAAa,kBAAmB,SAAQ,uBAYtC;CACD;;;;;;;AAED,qBAAa,sBAAuB,SAAQ,2BAa1C;CACD"}
+{"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,EAAkB,UAAU,EAAE,MAAM,uBAAuB,CAAA;AAClE,OAAO,EAAE,cAAc,EAAyC,YAAY,EAAoB,IAAI,EAAE,kBAAkB,EAA8D,kBAAkB,EAAe,IAAI,EAAY,MAAM,eAAe,CAAA;;;;;;;AAE5P,qBAAa,sBAAuB,SAAQ,2BAa1C;CACD;AAkBD,eAAO,MAAM,eAAe;;;;;;;;;;SAKK,CAAA"}

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

@@ -0,0 +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;AAOvD,OAAO,EAAoN,WAAW,EAAE,MAAM,eAAe,CAAA;AA8C7P,eAAO,MAAM,OAAO,uFAWO,CAAA;AAiB3B,eAAO,MAAM,YAAY,gLAItB,CAAA;AAEH,eAAO,MAAM,YAAY,+FAgByB,CAAA"}