diff --git a/.changeset/ten-laws-join.md b/.changeset/ten-laws-join.md
new file mode 100644
index 0000000000..8a95cb483a
--- /dev/null
+++ b/.changeset/ten-laws-join.md
@@ -0,0 +1,5 @@
+---
+"@effect-app/infra": minor
+---
+
+support middleware `requires` and simplified api
diff --git a/.vscode/settings.json b/.vscode/settings.json
index fdc73f3d26..14cf11524a 100644
--- a/.vscode/settings.json
+++ b/.vscode/settings.json
@@ -7,7 +7,7 @@
   // would prefer on in frontend, so might want to use a specialised frontend config..
   "volar.updateImportsOnFileMove.enabled": false,
   "typescript.preferences.includePackageJsonAutoImports": "on",
-  "typescript.preferences.autoImportFileExcludePatterns": [w
+  "typescript.preferences.autoImportFileExcludePatterns": [
     "node_modules/@sentry/node",
     "node_modules/vitest/dist",
     "node_modules/@azure/cosmos",
diff --git a/packages/infra/src/api/layerUtils.ts b/packages/infra/src/api/layerUtils.ts
index 7973e38f6f..12d1e0ca64 100644
--- a/packages/infra/src/api/layerUtils.ts
+++ b/packages/infra/src/api/layerUtils.ts
@@ -7,19 +7,19 @@ export namespace LayerUtils {
     NonEmptyReadonlyArray<Layer.Layer.Any> ? {
       [k in keyof Layers]: Layer.Layer.Success<Layers[k]>
     }[number]
-    : never
+    : Layer.Layer.Success<Layers[number]>
 
   export type GetLayersContext<Layers extends ReadonlyArray<Layer.Layer.Any>> = Layers extends
     NonEmptyReadonlyArray<Layer.Layer.Any> ? {
       [k in keyof Layers]: Layer.Layer.Context<Layers[k]>
     }[number]
-    : never
+    : Layer.Layer.Context<Layers[number]>
 
   export type GetLayersError<Layers extends ReadonlyArray<Layer.Layer.Any>> = Layers extends
     NonEmptyReadonlyArray<Layer.Layer.Any> ? {
       [k in keyof Layers]: Layer.Layer.Error<Layers[k]>
     }[number]
-    : never
+    : Layer.Layer.Error<Layers[number]>
 }
 
 export type ContextTagWithDefault<Id, A, LayerE, LayerR> =
diff --git a/packages/infra/src/api/routing.ts b/packages/infra/src/api/routing.ts
index d54bcb563d..587f08f952 100644
--- a/packages/infra/src/api/routing.ts
+++ b/packages/infra/src/api/routing.ts
@@ -4,7 +4,7 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 import { determineMethod, isCommand } from "@effect-app/infra/api/routing/utils"
 import { Rpc, RpcGroup, RpcServer } from "@effect/rpc"
-import { type Array, Duration, Effect, Layer, type NonEmptyReadonlyArray, Predicate, Request, S, Schedule, Schema, type Scope } from "effect-app"
+import { type Array, Effect, Layer, type NonEmptyReadonlyArray, Predicate, S, Schedule, Schema, type Scope } from "effect-app"
 import type { GetEffectContext, GetEffectError, RPCContextMap } from "effect-app/client/req"
 import { type HttpHeaders, HttpRouter } from "effect-app/http"
 import { typedKeysOf, typedValuesOf } from "effect-app/utils"
@@ -819,11 +819,3 @@ export type MakeHandlers<Make, Handlers extends Record<string, any>> = Make exte
  * @since 3.9.0
  */
 export type MakeDepsOut<Make> = Contravariant.Type<MakeDeps<Make>[Layer.LayerTypeId]["_ROut"]>
-
-export const RequestCacheLayers = Layer.mergeAll(
-  Layer.setRequestCache(
-    Request.makeCache({ capacity: 500, timeToLive: Duration.hours(8) })
-  ),
-  Layer.setRequestCaching(true),
-  Layer.setRequestBatching(true)
-)
diff --git a/packages/infra/src/api/routing/middleware/ContextProvider.ts b/packages/infra/src/api/routing/middleware/ContextProvider.ts
index 06d801a07a..b9078a21f4 100644
--- a/packages/infra/src/api/routing/middleware/ContextProvider.ts
+++ b/packages/infra/src/api/routing/middleware/ContextProvider.ts
@@ -87,9 +87,9 @@ export const mergeContextProviders = <
   effect: Effect.Effect<
     Effect.Effect<
       // we need to merge all contexts into one
-      Context.Context<GetContext<EffectGenUtils.Success<Tag.Service<TDeps[number]>>>>,
+      Context.Context<GetContext<EffectGenUtils.Success<Tag.Identifier<TDeps[number]>>>>,
       never,
-      EffectGenUtils.Context<Tag.Service<TDeps[number]>>
+      EffectGenUtils.Context<Tag.Identifier<TDeps[number]>>
     >,
     LayerUtils.GetLayersError<{ [K in keyof TDeps]: TDeps[K]["Default"] }>,
     LayerUtils.GetLayersSuccess<{ [K in keyof TDeps]: TDeps[K]["Default"] }>
@@ -174,13 +174,13 @@ export const MergedContextProvider = <
     ContextProviderId,
     Effect.Effect<
       // we need to merge all contexts into one
-      Context.Context<GetContext<EffectGenUtils.Success<Tag.Service<TDeps[number]>>>>,
+      Context.Context<GetContext<EffectGenUtils.Success<Tag.Identifier<TDeps[number]>>>>,
       never,
-      EffectGenUtils.Context<Tag.Service<TDeps[number]>>
+      EffectGenUtils.Context<Tag.Identifier<TDeps[number]>>
     >,
     LayerUtils.GetLayersError<{ [K in keyof TDeps]: TDeps[K]["Default"] }>,
     | Exclude<
-      Tag.Service<TDeps[number]>,
+      Tag.Identifier<TDeps[number]>,
       LayerUtils.GetLayersSuccess<{ [K in keyof TDeps]: TDeps[K]["Default"] }>
     >
     | LayerUtils.GetLayersContext<{ [K in keyof TDeps]: TDeps[K]["Default"] }>
diff --git a/packages/infra/src/api/routing/middleware/DynamicMiddleware.ts b/packages/infra/src/api/routing/middleware/DynamicMiddleware.ts
index 134d909e0e..dee051625c 100644
--- a/packages/infra/src/api/routing/middleware/DynamicMiddleware.ts
+++ b/packages/infra/src/api/routing/middleware/DynamicMiddleware.ts
@@ -94,10 +94,10 @@ export type RequestContextMapProvider<RequestContextMap extends Record<string, R
 export interface MiddlewareMake<
   RequestContextMap extends Record<string, RPCContextMap.Any>, // what services will the middleware provide dynamically to the next, or raise errors.
   DynamicMiddlewareProviders extends RequestContextMapProvider<RequestContextMap>, // how to resolve the dynamic middleware
-  GenericMiddlewareProviders extends NonEmptyReadonlyArray<GenericMiddlewareMaker>,
+  GenericMiddlewareProviders extends ReadonlyArray<GenericMiddlewareMaker>,
   MakeMiddlewareE, // what the middleware construction can fail with
   MakeMiddlewareR, // what the middleware requires to be constructed
-  MiddlewareDependencies extends NonEmptyReadonlyArray<Layer.Layer.Any> // layers provided for the middleware to be constructed
+  MiddlewareDependencies extends ReadonlyArray<Layer.Layer.Any> // layers provided for the middleware to be constructed
 > {
   /* dynamic middlewares to be applied based on Request Configuration */
   dynamicMiddlewares: DynamicMiddlewareProviders
@@ -170,8 +170,8 @@ export const makeMiddleware =
   >() =>
   <
     RequestContextProviders extends RequestContextMapProvider<RequestContextMap>, // how to resolve the dynamic middleware
-    GenericMiddlewareProviders extends NonEmptyReadonlyArray<GenericMiddlewareMaker>,
-    MiddlewareDependencies extends NonEmptyReadonlyArray<Layer.Layer.Any>, // layers provided for the middlware to be constructed
+    GenericMiddlewareProviders extends ReadonlyArray<GenericMiddlewareMaker>,
+    MiddlewareDependencies extends ReadonlyArray<Layer.Layer.Any>, // layers provided for the middlware to be constructed
     MakeMiddlewareE = never, // what the middleware construction can fail with
     MakeMiddlewareR = never // what the middlware requires to be constructed
   >(
@@ -295,7 +295,7 @@ export const makeMiddlewareBasic =
   <
     RequestContextMap extends Record<string, RPCContextMap.Any>,
     RequestContextProviders extends RequestContextMapProvider<RequestContextMap>, // how to resolve the dynamic middleware
-    GenericMiddlewareProviders extends NonEmptyReadonlyArray<GenericMiddlewareMaker>
+    GenericMiddlewareProviders extends ReadonlyArray<GenericMiddlewareMaker>
   >(
     make: MiddlewareMake<
       RequestContextMap,
@@ -446,22 +446,22 @@ function makeRpcEffect<
 }
 
 // updated to support Scope.Scope
-export interface RpcMiddleware<Provides, E> {
+export interface RpcMiddleware<Provides, E, Requires> {
   (options: {
     readonly clientId: number
     readonly rpc: Rpc.AnyWithProps
     readonly payload: unknown
     readonly headers: HttpHeaders.Headers
-  }): Effect.Effect<Provides, E, Scope.Scope>
+  }): Effect.Effect<Provides, E, Scope.Scope | Requires>
 }
-export interface RpcMiddlewareWrap<Provides, E> {
+export interface RpcMiddlewareWrap<Provides, E, Requires> {
   (options: {
     readonly clientId: number
     readonly rpc: Rpc.AnyWithProps
     readonly payload: unknown
     readonly headers: HttpHeaders.Headers
-    readonly next: Effect.Effect<SuccessValue, E, Provides | Scope.Scope>
-  }): Effect.Effect<SuccessValue, E, Scope.Scope>
+    readonly next: Effect.Effect<SuccessValue, E, Provides | Scope.Scope | Requires>
+  }): Effect.Effect<SuccessValue, E, Scope.Scope | Requires>
 }
 
 type RpcOptionsOriginal = {
@@ -484,22 +484,23 @@ type RpcOptionsDynamic<Key extends string, A extends RPCContextMap.Any> = RpcOpt
 
 export type Dynamic<Options> = Options extends RpcOptionsDynamic<any, any> ? true : false
 
-export interface RpcMiddlewareDynamic<A, E, Config> {
+export interface RpcMiddlewareDynamic<A, E, R, Config> {
   (options: {
     readonly config: Config // todo
     readonly clientId: number
     readonly rpc: Rpc.AnyWithProps
     readonly payload: unknown
     readonly headers: HttpHeaders.Headers
-  }): Effect.Effect<Option.Option<Context.Context<A>>, E, Scope.Scope>
+  }): Effect.Effect<Option.Option<Context.Context<A>>, E, Scope.Scope | R>
 }
 
 export interface TagClassDynamicAny<RequestContext extends Record<string, RPCContextMap.Any>>
   extends Context.Tag<any, any>
 {
   readonly [RpcMiddleware.TypeId]: RpcMiddleware.TypeId
-  readonly optional: boolean
-  readonly provides?: Context.Tag<any, any> | undefined
+  readonly optional: boolean // TODO: support optional vs required.. with required, we can eliminate the context..
+  //  readonly provides?: Context.Tag<any, any> | undefined
+  readonly requires?: Context.Tag<any, any> | ContextRepr | undefined
   readonly failure: Schema.Schema.All
   readonly requiredForClient: boolean
   readonly dynamic: RpcDynamic<any, RequestContext[keyof RequestContext]>
@@ -522,6 +523,18 @@ export declare namespace TagClass {
     } ? ContextRepr.Identifier<Options["provides"]>
     : never
 
+  /**
+   * @since 1.0.0
+   * @category models
+   */
+  export type Requires<Options> = Options extends {
+    readonly requires: Context.Tag<any, any>
+  } ? Context.Tag.Identifier<Options["requires"]>
+    : Options extends {
+      readonly requires: ContextRepr
+    } ? ContextRepr.Identifier<Options["requires"]>
+    : never
+
   /**
    * @since 1.0.0
    * @category models
@@ -592,6 +605,9 @@ export declare namespace TagClass {
     readonly provides: Options extends { readonly provides: Context.Tag<any, any> } ? Options["provides"]
       : Options extends { readonly provides: ContextRepr } ? Options["provides"]
       : undefined
+    readonly requires: Options extends { readonly requires: Context.Tag<any, any> } ? Options["requires"]
+      : Options extends { readonly requires: ContextRepr } ? Options["requires"]
+      : undefined
     readonly dynamic: Options extends RpcOptionsDynamic<any, any> ? Options["dynamic"]
       : undefined
     readonly requiredForClient: RequiredForClient<Options>
@@ -610,16 +626,19 @@ export interface TagClass<
     Options,
     TagClass.Wrap<Options> extends true ? RpcMiddlewareWrap<
         TagClass.Provides<Options>,
+        TagClass.Requires<Options>,
         TagClass.Failure<Options>
       >
       : Options extends RpcOptionsDynamic<any, any> ? RpcMiddlewareDynamic<
           TagClass.Service<Options>,
           TagClass.FailureService<Options>,
+          TagClass.Requires<Options>,
           { [K in Options["dynamic"]["key"]]?: Options["dynamic"]["settings"]["contextActivation"] }
         >
       : RpcMiddleware<
         TagClass.Service<Options>,
-        TagClass.FailureService<Options>
+        TagClass.FailureService<Options>,
+        TagClass.Requires<Options>
       >
   >
 {}
@@ -636,16 +655,19 @@ export const Tag = <Self>() =>
   effect: Effect.Effect<
     TagClass.Wrap<Options> extends true ? RpcMiddlewareWrap<
         TagClass.Provides<Options>,
-        TagClass.Failure<Options>
+        TagClass.Failure<Options>,
+        TagClass.Requires<Options>
       >
       : Options extends RpcOptionsDynamic<any, any> ? RpcMiddlewareDynamic<
           TagClass.Service<Options>,
           TagClass.FailureService<Options>,
+          TagClass.Requires<Options>,
           { [K in Options["dynamic"]["key"]]?: Options["dynamic"]["settings"]["contextActivation"] }
         >
       : RpcMiddleware<
         TagClass.Service<Options>,
-        TagClass.FailureService<Options>
+        TagClass.FailureService<Options>,
+        TagClass.Requires<Options>
       >,
     E,
     R
diff --git a/packages/infra/src/api/routing/middleware/dynamic-middleware.ts b/packages/infra/src/api/routing/middleware/dynamic-middleware.ts
index 480b2640fc..b791ac78ef 100644
--- a/packages/infra/src/api/routing/middleware/dynamic-middleware.ts
+++ b/packages/infra/src/api/routing/middleware/dynamic-middleware.ts
@@ -20,13 +20,15 @@ export type ContextWithLayer<
   & (
     | ContextTagWithDefault<
       Id,
-      RpcMiddlewareDynamic<Service, Error, Config>,
+      // todo
+      RpcMiddlewareDynamic<Service, Error, any, Config>,
       LayerE,
       LayerR
     >
     | ContextTagWithDefault<
       Id,
-      RpcMiddlewareDynamic<Service, Error, Config>,
+      // todo
+      RpcMiddlewareDynamic<Service, Error, never, Config>,
       LayerE,
       LayerR
     >
@@ -84,7 +86,7 @@ export const implementMiddleware = <T extends Record<string, RPCContextMap.Any>>
     ) => Effect.Effect<
       Context.Context<GetEffectContext<T, typeof options["config"]>>,
       Effect.Error<ReturnType<Tag.Service<TI[keyof TI]>>>,
-      Effect.Context<ReturnType<Tag.Identifier<TI[keyof TI]>>>
+      Effect.Context<ReturnType<Tag.Service<TI[keyof TI]>>>
     >,
     never,
     Tag.Identifier<{ [K in keyof TI]: TI[K] }[keyof TI]>
diff --git a/packages/infra/src/api/routing/middleware/generic-middleware.ts b/packages/infra/src/api/routing/middleware/generic-middleware.ts
index 7ba09a2385..b9e3d7fb1f 100644
--- a/packages/infra/src/api/routing/middleware/generic-middleware.ts
+++ b/packages/infra/src/api/routing/middleware/generic-middleware.ts
@@ -18,6 +18,7 @@ export interface TagClassAny extends Context.Tag<any, any> {
   readonly [TypeId]: TypeId
   readonly optional: boolean
   readonly provides?: Context.Tag<any, any> | ContextRepr | undefined
+  readonly requires?: Context.Tag<any, any> | ContextRepr | undefined
   readonly failure: Schema.Schema.All
   readonly requiredForClient: boolean
   readonly wrap: boolean
@@ -38,11 +39,21 @@ export type DynamicMiddlewareMaker<RequestContext extends Record<string, RPCCont
   & { Default: Layer.Layer.Any } // todo; and Layer..
 
 export namespace GenericMiddlewareMaker {
+  export type ApplyServices<A extends TagClassAny, R> = Exclude<R, Provided<A>> | Required<A>
+  export type ApplyManyServices<A extends NonEmptyReadonlyArray<TagClassAny>, R> =
+    | Exclude<R, { [K in keyof A]: Provided<A[K]> }[number]>
+    | { [K in keyof A]: Required<A[K]> }[number]
   export type Provided<T> = T extends TagClassAny
     ? T extends { provides: Context.Tag<any, any> } ? Context.Tag.Identifier<T["provides"]>
     : T extends { provides: ContextRepr } ? ContextRepr.Identifier<T["provides"]>
     : never
     : never
+
+  export type Required<T> = T extends TagClassAny
+    ? T extends { requires: Context.Tag<any, any> } ? Context.Tag.Identifier<T["requires"]>
+    : T extends { requires: ContextRepr } ? ContextRepr.Identifier<T["requires"]>
+    : never
+    : never
 }
 
 export const genericMiddleware = (i: GenericMiddlewareMaker) => i
diff --git a/packages/infra/src/api/routing/middleware/middleware-api.ts b/packages/infra/src/api/routing/middleware/middleware-api.ts
index 676ea0d050..7b66a7fdc7 100644
--- a/packages/infra/src/api/routing/middleware/middleware-api.ts
+++ b/packages/infra/src/api/routing/middleware/middleware-api.ts
@@ -1,4 +1,4 @@
-import { type NonEmptyReadonlyArray } from "effect-app"
+import { Array, Either, type NonEmptyArray } from "effect-app"
 import { type RPCContextMap } from "effect-app/client"
 import { type DynamicMiddlewareMaker, type GenericMiddlewareMaker, makeMiddleware, type makeMiddlewareBasic, type RequestContextMapProvider } from "../../routing.js"
 
@@ -9,41 +9,128 @@ export const contextMap = <RequestContextMap>() => <K extends keyof RequestConte
   settings: null as any as RequestContextMap[typeof a]
 })
 
-type DynamicMiddlewareMakerrsss<
+export interface MiddlewareM<
   RequestContext extends Record<string, RPCContextMap.Any>,
   Provided extends keyof RequestContext,
-  Middlewares extends NonEmptyReadonlyArray<GenericMiddlewareMaker>,
-  DynamicMiddlewareProviders extends RequestContextMapProvider<RequestContext>
-> = keyof Omit<RequestContext, Provided> extends never
-  ? ReturnType<typeof makeMiddlewareBasic<RequestContext, DynamicMiddlewareProviders, Middlewares>>
-  : {
-    addDynamicMiddleware: <MW extends NonEmptyReadonlyArray<DynamicMiddlewareMaker<RequestContext>>>(
-      ...middlewares: MW
-    ) => DynamicMiddlewareMakerrsss<
+  Middlewares extends ReadonlyArray<GenericMiddlewareMaker>,
+  DynamicMiddlewareProviders,
+  // out MiddlewareR = never
+  MiddlewareR = never
+> {
+  middleware<MW extends NonEmptyArray<GenericMiddlewareMaker>>(
+    ...mw: MW
+  ): DynamicMiddlewareMakerrsss<
+    RequestContext,
+    Provided,
+    [...Middlewares, ...MW],
+    DynamicMiddlewareProviders,
+    GenericMiddlewareMaker.ApplyManyServices<MW, MiddlewareR>
+  >
+}
+
+export interface MiddlewareDynamic<
+  RequestContext extends Record<string, RPCContextMap.Any>,
+  Provided extends keyof RequestContext,
+  Middlewares extends ReadonlyArray<GenericMiddlewareMaker>,
+  DynamicMiddlewareProviders,
+  out MiddlewareR
+> {
+  // TODO: this still allows to mix both types of middleware but with bad typing result
+  // either have to block it, or implement the support properly.
+  middleware<MW extends NonEmptyArray<DynamicMiddlewareMaker<RequestContext>> | NonEmptyArray<GenericMiddlewareMaker>>(
+    ...mw: MW
+  ): [MW] extends [NonEmptyArray<DynamicMiddlewareMaker<RequestContext>>] ? DynamicMiddlewareMakerrsss<
       RequestContext,
       Provided | MW[number]["dynamic"]["key"],
       Middlewares,
       & DynamicMiddlewareProviders
       & {
-        [K in keyof MW as MW[K] extends DynamicMiddlewareMaker<RequestContext> ? MW[K]["dynamic"]["key"] : never]: MW[K]
-      }
+        [U in MW[number] as U["dynamic"]["key"]]: U
+      },
+      GenericMiddlewareMaker.ApplyManyServices<MW, MiddlewareR>
     >
-  }
+    : DynamicMiddlewareMakerrsss<
+      RequestContext,
+      Provided,
+      [...Middlewares, ...MW],
+      DynamicMiddlewareProviders,
+      GenericMiddlewareMaker.ApplyManyServices<MW, MiddlewareR>
+    >
+}
+
+type GetDynamicMiddleware<T, RequestContext extends Record<string, RPCContextMap.Any>> = T extends
+  RequestContextMapProvider<RequestContext> ? T : never
+
+type DynamicMiddlewareMakerrsss<
+  RequestContext extends Record<string, RPCContextMap.Any>,
+  Provided extends keyof RequestContext = never,
+  Middlewares extends ReadonlyArray<GenericMiddlewareMaker> = [],
+  DynamicMiddlewareProviders = unknown,
+  MiddlewareR = never
+> = keyof Omit<RequestContext, Provided> extends never ? [MiddlewareR] extends [never] ?
+      & ReturnType<
+        typeof makeMiddlewareBasic<
+          RequestContext,
+          GetDynamicMiddleware<DynamicMiddlewareProviders, RequestContext>,
+          Middlewares
+        >
+      >
+      // & {
+      //   MiddlewareR: MiddlewareR
+      //   Provided: Provided
+      //   Middlewares: Middlewares
+      //   DynamicMiddlewareProviders: Simplify<DynamicMiddlewareProviders>
+      // }
+      & MiddlewareM<
+        RequestContext,
+        Provided,
+        Middlewares,
+        DynamicMiddlewareProviders,
+        MiddlewareR
+      >
+  : MiddlewareM<
+    RequestContext,
+    Provided,
+    Middlewares,
+    DynamicMiddlewareProviders,
+    MiddlewareR
+  >
+  : MiddlewareDynamic<
+    RequestContext,
+    Provided,
+    Middlewares,
+    DynamicMiddlewareProviders,
+    MiddlewareR
+  >
 
 export const makeNewMiddleware: <
   RequestContextMap extends Record<string, RPCContextMap.Any>
->() => <Middlewares extends NonEmptyReadonlyArray<GenericMiddlewareMaker>>(
-  ...genericMiddlewares: Middlewares
-) => DynamicMiddlewareMakerrsss<RequestContextMap, never, Middlewares, never> = () => (...genericMiddlewares) => {
-  const dynamicMiddlewares: Record<string, any> = {} as any
+>() => DynamicMiddlewareMakerrsss<RequestContextMap> = () => {
   const make = makeMiddleware<any>()
+  let capturedMiddlewares: (DynamicMiddlewareMaker<any> | GenericMiddlewareMaker)[] = []
   const it = {
-    addDynamicMiddleware: (...middlewares: any[]) => {
-      for (const a of middlewares) {
-        console.log("Adding dynamic middleware", a, a.dynamic, Object.keys(a))
-        dynamicMiddlewares[a.dynamic.key] = a
+    middleware: (...middlewares: any[]) => {
+      for (const mw of middlewares) {
+        capturedMiddlewares = [mw, ...capturedMiddlewares]
+        if (mw.dynamic) {
+          console.log("Adding dynamic middleware", mw.key, mw.dynamic.key)
+        } else {
+          console.log("Adding generic middleware", mw.key)
+        }
       }
-      return Object.assign(make({ genericMiddlewares: genericMiddlewares as any, dynamicMiddlewares }), it)
+      const [genericMiddlewares, dyn] = Array.partitionMap(
+        capturedMiddlewares,
+        (mw) =>
+          "dynamic" in mw && mw.dynamic
+            ? Either.right(mw as DynamicMiddlewareMaker<any>)
+            : Either.left(mw as GenericMiddlewareMaker)
+      )
+      const dynamicMiddlewares = dyn.reduce(
+        (prev, cur) => ({ ...prev, [cur.dynamic.key]: cur }),
+        {} as Record<string, any>
+      )
+      // TODO: support dynamic and generic intertwined. treat them as one
+      return Object.assign(make({ genericMiddlewares, dynamicMiddlewares }), it)
     }
   }
   return it as any
diff --git a/packages/infra/src/api/routing/middleware/middleware.ts b/packages/infra/src/api/routing/middleware/middleware.ts
index 4d2d0cd862..93716ba37b 100644
--- a/packages/infra/src/api/routing/middleware/middleware.ts
+++ b/packages/infra/src/api/routing/middleware/middleware.ts
@@ -1,13 +1,21 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
-import { Cause, Context, Effect, ParseResult } from "effect-app"
+import { Cause, Context, Duration, Effect, Layer, ParseResult, Request } from "effect-app"
 import { pretty } from "effect-app/utils"
 import { logError, reportError } from "../../../errorReporter.js"
 import { InfraLogger } from "../../../logger.js"
-import { RequestCacheLayers, Tag } from "../../routing.js"
+import { Tag } from "../middleware.js"
 
 const logRequestError = logError("Request")
 const reportRequestError = reportError("Request")
 
+export const RequestCacheLayers = Layer.mergeAll(
+  Layer.setRequestCache(
+    Request.makeCache({ capacity: 500, timeToLive: Duration.hours(8) })
+  ),
+  Layer.setRequestCaching(true),
+  Layer.setRequestBatching(true)
+)
+
 export class DevMode extends Context.Reference<DevMode>()("DevMode", { defaultValue: () => false }) {}
 
 export class RequestCacheMiddleware extends Tag<RequestCacheMiddleware>()("RequestCacheMiddleware", { wrap: true })({
diff --git a/packages/infra/test/contextProvider.test.ts b/packages/infra/test/contextProvider.test.ts
index 7391d77a19..8ef34f012f 100644
--- a/packages/infra/test/contextProvider.test.ts
+++ b/packages/infra/test/contextProvider.test.ts
@@ -3,8 +3,7 @@
 import { expectTypeOf } from "@effect/vitest"
 import { Context, Effect, Scope } from "effect-app"
 import { ContextProvider, mergeContextProviders, MergedContextProvider } from "../src/api/routing.js"
-import { CustomError1, Some, SomeElse } from "./controller.test.js"
-import { SomeService } from "./query.test.js"
+import { CustomError1, Some, SomeElse, SomeService } from "./fixtures.js"
 
 // @effect-diagnostics-next-line missingEffectServiceDependency:off
 class MyContextProvider extends Effect.Service<MyContextProvider>()("MyContextProvider", {
diff --git a/packages/infra/test/controller.test.ts b/packages/infra/test/controller.test.ts
index 9386c43a3c..5cd3b3f0f1 100644
--- a/packages/infra/test/controller.test.ts
+++ b/packages/infra/test/controller.test.ts
@@ -1,46 +1,24 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 /* eslint-disable @typescript-eslint/no-unsafe-member-access */
 import { type MakeContext, type MakeErrors, makeRouter } from "@effect-app/infra/api/routing"
-import type { RequestContext } from "@effect-app/infra/RequestContext"
 import { expect, expectTypeOf, it } from "@effect/vitest"
-import { type Array, Context, Effect, Layer, Option, S, Scope } from "effect-app"
-import { InvalidStateError, makeRpcClient, type RPCContextMap, UnauthorizedError } from "effect-app/client"
-import { Class, TaggedError } from "effect-app/Schema"
-import { contextMap, DefaultGenericMiddlewares, implementMiddleware, makeMiddleware, makeNewMiddleware, Middleware, Tag } from "../src/api/routing/middleware.js"
+import { Context, Effect, Layer, S, Scope } from "effect-app"
+import { InvalidStateError, makeRpcClient, NotLoggedInError, UnauthorizedError } from "effect-app/client"
+import { DefaultGenericMiddlewares, implementMiddleware, makeMiddleware, makeNewMiddleware, Middleware, Tag } from "../src/api/routing/middleware.js"
 import { sort } from "../src/api/routing/tsort.js"
-import { SomeService } from "./query.test.js"
-
-export class UserProfile extends Context.assignTag<UserProfile, UserProfile>("UserProfile")(
-  Class<UserProfile>("UserProfile")({
-    id: S.String,
-    roles: S.Array(S.String)
-  })
-) {
-}
-
-export class NotLoggedInError extends TaggedError<NotLoggedInError>()("NotLoggedInError", {
-  message: S.String
-}) {}
-
-export class CustomError1 extends TaggedError<NotLoggedInError>()("CustomError1", {}) {}
-export class CustomError2 extends TaggedError<NotLoggedInError>()("CustomError1", {}) {}
-
-export interface CTX {
-  context: RequestContext
-}
-
-export class Some extends Context.TagMakeId("Some", Effect.succeed({ a: 1 }))<Some>() {}
-export class SomeElse extends Context.TagMakeId("SomeElse", Effect.succeed({ b: 2 }))<SomeElse>() {}
+import { AllowAnonymous, CustomError1, type RequestContextMap, RequireRoles, Some, SomeElse, SomeService, Test } from "./fixtures.js"
 
 // @effect-diagnostics-next-line missingEffectServiceDependency:off
 class MyContextProvider extends Middleware.Tag<MyContextProvider>()("MyContextProvider", {
-  provides: [Some]
+  provides: [Some],
+  requires: [SomeElse]
 })({
   effect: Effect.gen(function*() {
     yield* SomeService
     if (Math.random() > 0.5) return yield* new CustomError1()
 
     return Effect.fnUntraced(function*() {
+      yield* SomeElse
       // the only requirements you can have are the one provided by HttpRouter.HttpRouter.Provided
       yield* Scope.Scope
 
@@ -74,71 +52,9 @@ class MyContextProvider2 extends Middleware.Tag<MyContextProvider2>()("MyContext
 
 //
 
-export type RequestContextMap = {
-  allowAnonymous: RPCContextMap.Inverted<UserProfile, typeof NotLoggedInError>
-  requireRoles: RPCContextMap.Custom<never, typeof UnauthorizedError, Array<string>>
-  test: RPCContextMap<never, typeof S.Never>
-}
-
 const Str = Context.GenericTag<"str", "str">("str")
 const Str2 = Context.GenericTag<"str2", "str">("str2")
 
-class AllowAnonymous extends Middleware.Tag<AllowAnonymous>()("AllowAnonymous", {
-  dynamic: contextMap<RequestContextMap>()("allowAnonymous")
-})({
-  effect: Effect.gen(function*() {
-    return Effect.fnUntraced(
-      function*({ config, headers }) {
-        yield* Scope.Scope // provided by HttpRouter.HttpRouter.Provided
-        const isLoggedIn = !!headers["x-user"]
-        if (!isLoggedIn) {
-          if (!config.allowAnonymous) {
-            return yield* new NotLoggedInError({ message: "Not logged in" })
-          }
-          return Option.none()
-        }
-        return Option.some(Context.make(
-          UserProfile,
-          { id: "whatever", roles: ["user", "manager"] }
-        ))
-      }
-    )
-  })
-}) {
-}
-
-// @effect-diagnostics-next-line missingEffectServiceDependency:off
-class RequireRoles extends Middleware.Tag<RequireRoles>()("RequireRoles", {
-  dynamic: contextMap<RequestContextMap>()("requireRoles"),
-  // 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* Some
-    return Effect.fnUntraced(
-      function*({ config }) {
-        // we don't know if the service will be provided or not, so we use option..
-        const userProfile = yield* Effect.serviceOption(UserProfile)
-        const { requireRoles } = config
-        if (requireRoles && !userProfile.value?.roles?.some((role) => requireRoles.includes(role))) {
-          return yield* new UnauthorizedError({ message: "don't have the right roles" })
-        }
-        return Option.none<Context<never>>()
-      }
-    )
-  })
-}) {
-}
-
-class Test extends Middleware.Tag<Test>()("Test", { dynamic: contextMap<RequestContextMap>()("test") })({
-  effect: Effect.gen(function*() {
-    return Effect.fn(function*() {
-      return Option.none<Context<never>>()
-    })
-  })
-}) {}
-
 export class BogusMiddleware extends Tag<BogusMiddleware>()("BogusMiddleware", {
   provides: SomeService,
   wrap: true
@@ -204,13 +120,13 @@ const middleware2 = makeMiddleware<RequestContextMap>()({
   }
 })
 
-export const middleware3 = makeNewMiddleware<RequestContextMap>()(
-  ...genericMiddlewares
-)
-  .addDynamicMiddleware(AllowAnonymous, RequireRoles)
-  .addDynamicMiddleware(Test)
+export const middleware3 = makeNewMiddleware<RequestContextMap>()
+  .middleware(...genericMiddlewares)
+  .middleware(AllowAnonymous, RequireRoles)
+  .middleware(Test)
+// .middleware(BogusMiddleware)
 
-expectTypeOf(middleware3).toEqualTypeOf<typeof middleware2>()
+// expectTypeOf(middleware3).toExtend<typeof middleware2>()
 
 export type RequestConfig = {
   /** Disable authentication requirement */
@@ -360,7 +276,7 @@ it("sorts based on requirements", () => {
 
 // eslint-disable-next-line unused-imports/no-unused-vars
 const matched = matchAll({ router })
-expectTypeOf({} as Layer.Context<typeof matched>).toEqualTypeOf<SomeService | "str">()
+expectTypeOf({} as Layer.Context<typeof matched>).toEqualTypeOf<SomeService | Some | "str">()
 
 type makeContext = MakeContext<typeof router.make>
 expectTypeOf({} as MakeErrors<typeof router.make>).toEqualTypeOf<InvalidStateError>()
@@ -432,7 +348,7 @@ const router2 = r2.Router(Something)({
 
 // eslint-disable-next-line unused-imports/no-unused-vars
 const matched2 = matchAll({ router: router2 })
-expectTypeOf({} as Layer.Context<typeof matched2>).toEqualTypeOf<SomeService>()
+expectTypeOf({} as Layer.Context<typeof matched2>).toEqualTypeOf<Some | SomeService>()
 
 type makeContext2 = MakeContext<typeof router2.make>
 expectTypeOf({} as MakeErrors<typeof router2.make>).toEqualTypeOf<InvalidStateError>()
diff --git a/packages/infra/test/fixtures.ts b/packages/infra/test/fixtures.ts
new file mode 100644
index 0000000000..32ceb78133
--- /dev/null
+++ b/packages/infra/test/fixtures.ts
@@ -0,0 +1,85 @@
+import { Context, Effect, Option, S, Scope } from "effect-app"
+import { NotLoggedInError, type RPCContextMap, UnauthorizedError } from "effect-app/client"
+import { TaggedError } from "effect-app/Schema"
+import { contextMap, Middleware } from "../src/api/routing.js"
+
+export class UserProfile extends Context.assignTag<UserProfile, UserProfile>("UserProfile")(
+  S.Class<UserProfile>("UserProfile")({
+    id: S.String,
+    roles: S.Array(S.String)
+  })
+) {
+}
+
+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 type RequestContextMap = {
+  allowAnonymous: RPCContextMap.Inverted<UserProfile, typeof NotLoggedInError>
+  requireRoles: RPCContextMap.Custom<never, typeof UnauthorizedError, Array<string>>
+  test: RPCContextMap<never, typeof S.Never>
+}
+
+export class AllowAnonymous extends Middleware.Tag<AllowAnonymous>()("AllowAnonymous", {
+  dynamic: contextMap<RequestContextMap>()("allowAnonymous"),
+  requires: SomeElse
+})({
+  effect: Effect.gen(function*() {
+    return Effect.fnUntraced(
+      function*({ config, headers }) {
+        yield* SomeElse
+        yield* Scope.Scope // provided by HttpRouter.HttpRouter.Provided
+        const isLoggedIn = !!headers["x-user"]
+        if (!isLoggedIn) {
+          if (!config.allowAnonymous) {
+            return yield* new NotLoggedInError({ message: "Not logged in" })
+          }
+          return Option.none()
+        }
+        return Option.some(Context.make(
+          UserProfile,
+          { id: "whatever", roles: ["user", "manager"] }
+        ))
+      }
+    )
+  })
+}) {
+}
+
+// @effect-diagnostics-next-line missingEffectServiceDependency:off
+export class RequireRoles extends Middleware.Tag<RequireRoles>()("RequireRoles", {
+  dynamic: contextMap<RequestContextMap>()("requireRoles"),
+  // 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* Some
+    return Effect.fnUntraced(
+      function*({ config }) {
+        // we don't know if the service will be provided or not, so we use option..
+        const userProfile = yield* Effect.serviceOption(UserProfile)
+        const { requireRoles } = config
+        if (requireRoles && !userProfile.value?.roles?.some((role) => requireRoles.includes(role))) {
+          return yield* new UnauthorizedError({ message: "don't have the right roles" })
+        }
+        return Option.none<Context<never>>()
+      }
+    )
+  })
+}) {
+}
+
+export class Test extends Middleware.Tag<Test>()("Test", { dynamic: contextMap<RequestContextMap>()("test") })({
+  effect: Effect.gen(function*() {
+    return Effect.fn(function*() {
+      return Option.none<Context<never>>()
+    })
+  })
+}) {}
+
+export class CustomError1 extends TaggedError<NotLoggedInError>()("CustomError1", {}) {}
+export class CustomError2 extends TaggedError<NotLoggedInError>()("CustomError1", {}) {}
+
+const MakeSomeService = Effect.succeed({ a: 1 })
+export class SomeService extends Context.TagMakeId("SomeService", MakeSomeService)<SomeService>() {}
diff --git a/packages/infra/test/layerUtils.test.ts b/packages/infra/test/layerUtils.test.ts
new file mode 100644
index 0000000000..32bb01d7fc
--- /dev/null
+++ b/packages/infra/test/layerUtils.test.ts
@@ -0,0 +1,19 @@
+import { it } from "@effect/vitest"
+import { type Layer } from "effect"
+import { expectTypeOf } from "vitest/index.cjs"
+import { type LayerUtils } from "../src/api/layerUtils.js"
+
+it("works", () => {
+  type B = (Layer.Layer<void, "error-a", "a"> | Layer.Layer<void, "error-b", "b">)[]
+  type C = LayerUtils.GetLayersContext<B>
+  type CE = LayerUtils.GetLayersError<B>
+
+  expectTypeOf({} as C).toEqualTypeOf<"a" | "b">()
+  expectTypeOf({} as CE).toEqualTypeOf<"error-a" | "error-b">()
+
+  type B2 = [Layer.Layer<void, "error-a", "a">, Layer.Layer<void, "error-b", "b"> | Layer.Layer<void, "error-c", "c">]
+  type C2 = LayerUtils.GetLayersContext<B2>
+  type CE2 = LayerUtils.GetLayersError<B2>
+  expectTypeOf({} as C2).toEqualTypeOf<"a" | "b" | "c">()
+  expectTypeOf({} as CE2).toEqualTypeOf<"error-a" | "error-b" | "error-c">()
+})
diff --git a/packages/infra/test/query.test.ts b/packages/infra/test/query.test.ts
index 245fbc094d..233839b5d9 100644
--- a/packages/infra/test/query.test.ts
+++ b/packages/infra/test/query.test.ts
@@ -1,13 +1,14 @@
 /* eslint-disable unused-imports/no-unused-vars */
 /* eslint-disable @typescript-eslint/no-empty-object-type */
 /* eslint-disable @typescript-eslint/no-explicit-any */
-import { Context, Effect, flow, Layer, Option, pipe, S, Struct } from "effect-app"
+import { Effect, flow, Layer, Option, pipe, S, Struct } from "effect-app"
 import { inspect } from "util"
 import { expect, expectTypeOf, it } from "vitest"
 import { setupRequestContextFromCurrent } from "../src/api/setupRequest.js"
 import { and, count, make, one, or, order, page, project, type QueryEnd, type QueryProjection, type QueryWhere, toFilter, where } from "../src/Model/query.js"
 import { makeRepo } from "../src/Model/Repository.js"
 import { memFilter, MemoryStoreLive } from "../src/Store/Memory.js"
+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 })
@@ -25,9 +26,6 @@ export declare namespace Something {
   export interface Encoded extends S.Schema.Encoded<typeof Something> {}
 }
 
-const MakeSomeService = Effect.succeed({ a: 1 })
-export class SomeService extends Context.TagMakeId("SomeService", MakeSomeService)<SomeService>() {}
-
 const q = make<Something.Encoded>()
   .pipe( // provided automatically inside Repo.q2()
     where("displayName", "Verona"),
diff --git a/packages/infra/test/requires.test.ts b/packages/infra/test/requires.test.ts
new file mode 100644
index 0000000000..74b0fcea91
--- /dev/null
+++ b/packages/infra/test/requires.test.ts
@@ -0,0 +1,75 @@
+import { expectTypeOf, it } from "@effect/vitest"
+import { Effect, Layer, S } from "effect-app"
+import { makeNewMiddleware, Middleware } from "../src/api/routing.js"
+import { AllowAnonymous, type RequestContextMap, RequireRoles, Some, SomeElse, Test } from "./fixtures.js"
+
+export class SomeMiddleware extends Middleware.Tag<SomeMiddleware>()("SomeMiddleware", {
+  provides: Some,
+  wrap: true
+})({
+  effect: Effect.gen(function*() {
+    // yield* Effect.context<"test-dep">()
+    return ({ next }) =>
+      Effect.gen(function*() {
+        // yield* Effect.context<"test-dep2">()
+        return yield* next.pipe(Effect.provideService(Some, new Some({ a: 1 })))
+      })
+  })
+}) {
+}
+
+export class SomeElseMiddleware extends Middleware.Tag<SomeElseMiddleware>()("SomeElseMiddleware", {
+  provides: SomeElse,
+  wrap: true
+})({
+  effect: 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 })))
+      })
+  })
+}) {
+}
+
+export class RequiresSomeMiddleware extends Middleware.Tag<RequiresSomeMiddleware>()("RequiresSomeMiddleware", {
+  requires: Some,
+  wrap: true
+})({
+  effect: Effect.gen(function*() {
+    // yield* Effect.context<"test-dep">()
+    return ({ next }) =>
+      Effect.gen(function*() {
+        yield* Some
+        // yield* Effect.context<"test-dep2">()
+        return yield* next
+      })
+  })
+}) {
+}
+
+it("requires gets enforced", async () => {
+  const middleware3 = makeNewMiddleware<RequestContextMap>()
+    .middleware(RequiresSomeMiddleware)
+    .middleware(SomeMiddleware)
+    .middleware(AllowAnonymous, RequireRoles)
+    .middleware(SomeElseMiddleware)
+    .middleware(Test)
+
+  type LayerContext = Layer.Layer.Context<typeof middleware3["Default"]>
+  expectTypeOf({} as LayerContext).toEqualTypeOf<Some>()
+
+  await Effect
+    .gen(function*() {
+      const mw = yield* middleware3
+      const mwM = mw.effect(Object.assign({}, S.Any, { config: {} }), (_req) => Effect.void, "some-module")
+      yield* mwM({}, { "x-user": "test-user" })
+      // console.log({ v })
+    })
+    .pipe(
+      Effect.scoped,
+      Effect.provide(middleware3.Default.pipe(Layer.provide(Layer.succeed(Some, new Some({ a: 1 }))))),
+      Effect.runPromise
+    )
+})