refactor: Phoenix-style three-layer plug architecture (v0.2.0)

Implement three-layer request flow: Endpoint → Router (scopes) → Route

New features:
- Pipeline module for reusable plug collections
- Router.scope for grouping routes with shared plugs
- Route.plug for per-route middleware
- Endpoint.to_handler replaces Endpoint.start (separation of concerns)

API changes:
- Endpoint no longer manages server config (port/bind/tls)
- Server.run now accepts config directly
- Router.compile_scopes for scope-based routing

Includes documentation updates for new API patterns.

README.md

···
 |--------|-------------|
 | [Client](lib/client.ml) | HTTP client with auto-protocol selection and connection pooling |
 | [Server](lib/server.ml) | HTTP server with multi-domain parallelism |
-| [Router](lib/router.ml) | Radix trie router with path parameters |
+| [Router](lib/router.ml) | Radix trie router with path parameters, scopes, and per-route plugs |
 | [Plug](lib/plug.ml) | Phoenix-style middleware composition |
-| [Endpoint](lib/endpoint.ml) | Application bootstrap tying router, plugs, and server |
+| [Pipeline](lib/pipeline.ml) | Reusable plug collections for route scopes |
+| [Endpoint](lib/endpoint.ml) | Global plug entry point, builds handler from plugs + router |
 | [Websocket](lib/websocket.ml) | WebSocket client and server (RFC 6455) |
 | [Sse](lib/sse.ml) | Server-Sent Events |
 | [Pubsub](lib/pubsub.ml) | Lock-free topic-based pub/sub messaging |

bin/las/README.md

···
 let () =
   Eio_main.run @@ fun env ->
   let clock = Eio.Stdenv.clock env in
+  let net = Eio.Stdenv.net env in
   let store = Plug.Session.Memory_store.create () in
   
   (* Build the plug pipeline *)
   let endpoint =
     Endpoint.create
-      { Endpoint.default_config with
-        port = 8080;
-        secret_key_base = Sys.getenv_opt "SECRET_KEY" |> Option.value ~default:"dev-secret-32-chars-minimum!!!";
+      { secret_key_base = Sys.getenv_opt "SECRET_KEY" 
+          |> Option.value ~default:"dev-secret-32-chars-minimum!!!";
+        health_check = true;
       }
     |> Endpoint.plug (Plug.Logger.create ~clock (fun _ _ -> ()))
     |> Endpoint.plug (Plug.Compress.create ())
···
         ~requests:100 
         ~per:60.0)
     |> Endpoint.router Routes.router
-    |> Endpoint.websocket Realtime.ws_handler
   in
   
-  Endpoint.start endpoint ~env
+  (* Build handler and run server *)
+  let handler = Endpoint.to_handler endpoint in
+  Eio.Switch.run @@ fun sw ->
+  Server.run ~sw ~net 
+    ~config:{ Server.default_config with port = 8080 } 
+    handler
 ```
 
 ### 1.2 Data Models

bin/las/las.ml

···
 
   Eio_main.run @@ fun env ->
   let clock = Eio.Stdenv.clock env in
+  let net = Eio.Stdenv.net env in
   (match Db.init db_path with
   | Ok () -> ()
   | Error e -> failwith ("Database init failed: " ^ e));
···
   Printf.printf "Database: %s\n%!" db_path;
   if verbose then Printf.printf "Verbose logging: enabled\n%!";
 
+  let secret_key =
+    Sys.getenv_opt "SECRET_KEY"
+    |> Option.value ~default:"dev-secret-32-chars-minimum!!!"
+  in
+
   let endpoint =
     let e =
       Hcs.Endpoint.create
-        {
-          Hcs.Endpoint.default_config with
-          port;
-          secret_key_base =
-            Sys.getenv_opt "SECRET_KEY"
-            |> Option.value ~default:"dev-secret-32-chars-minimum!!!";
-        }
+        { Hcs.Endpoint.default_config with secret_key_base = secret_key }
     in
     let e = Hcs.Endpoint.plug e (Hcs.Plug.Logger.create ~clock logger) in
     let e = Hcs.Endpoint.plug e (Hcs.Plug.Compress.create ()) in
···
     in
     Hcs.Endpoint.router e (Routes.router clock)
   in
-  Hcs.Endpoint.start endpoint ~env
+
+  let handler = Hcs.Endpoint.to_handler endpoint in
+  let config = { Hcs.Server.default_config with port } in
+
+  Eio.Switch.run @@ fun sw -> Hcs.Server.run ~sw ~net ~config handler
 
 let () = Climate.Command.run command

docs/guides/plug-system.md

···
 
   Eio.Switch.run @@ fun sw ->
   let net = Eio.Stdenv.net env in
-  Server.run ~sw ~net handler
+  Server.run ~sw ~net ~config:Server.default_config handler
 ```
 
 ## Next Steps

docs/guides/routing.md

···
 
 let () =
   Eio_main.run @@ fun env ->
+  let net = Eio.Stdenv.net env in
   let endpoint =
     Endpoint.create Endpoint.default_config
     |> Endpoint.router routes
   in
-  Endpoint.start endpoint ~env
+  let handler = Endpoint.to_handler endpoint in
+  Eio.Switch.run @@ fun sw ->
+  Server.run ~sw ~net ~config:{ Server.default_config with port = 8080 } handler
 ```
 
 ## Route Organization
···
 
 let () =
   Eio_main.run @@ fun env ->
+  let net = Eio.Stdenv.net env in
   let endpoint =
-    Endpoint.create { Endpoint.default_config with port = 8080 }
+    Endpoint.create Endpoint.default_config
     |> Endpoint.router routes
   in
-  Endpoint.start endpoint ~env
+  let handler = Endpoint.to_handler endpoint in
+  Eio.Switch.run @@ fun sw ->
+  Server.run ~sw ~net ~config:{ Server.default_config with port = 8080 } handler
 ```
 
 Test it:

dune-project

···
 
 (name hcs)
 
-(version 0.1.1)
+(version 0.2.0)
 
 (generate_opam_files true)
 

hcs.opam

···
 # This file is generated by dune, edit dune-project instead
 opam-version: "2.0"
-version: "0.1.1"
+version: "0.2.0"
 synopsis: "Eio based HTTP client/server library for OCaml 5+"
 description:
   "HCS is a HTTP client/server library for OCaml 5+ supporting HTTP/1.1, HTTP/2, and WebSocket. Built on Eio."

lib/endpoint.ml

···
-type config = {
-  port : int;
-  bind : string;
-  domains : int;
-  secret_key_base : string;
-  protocol : Server.protocol;
-  tls : Tls_config.Server.t option;
-  health_check : bool;
-}
+type config = { secret_key_base : string; health_check : bool }
 
-let default_config =
-  {
-    port = 8080;
-    bind = "0.0.0.0";
-    domains = 1;
-    secret_key_base = "";
-    protocol = Server.Http1_only;
-    tls = None;
-    health_check = true;
-  }
+let default_config = { secret_key_base = ""; health_check = true }
 
 type params_handler = Router.params -> Server.request -> Server.response
 
 type t = {
   config : config;
-  plugs : Plug.t list;
+  plugs : Pipeline.t;
   router : params_handler Router.t option;
   ws_handler : Server.ws_handler option;
 }
 
-let create config = { config; plugs = []; router = None; ws_handler = None }
-let plug t p = { t with plugs = p :: t.plugs }
+let create config =
+  { config; plugs = Pipeline.empty; router = None; ws_handler = None }
+
+let plug t p = { t with plugs = Pipeline.plug t.plugs p }
 let router t r = { t with router = Some r }
 let websocket t handler = { t with ws_handler = Some handler }
+let ws_handler t = t.ws_handler
 let not_found_handler _req = Server.respond ~status:`Not_found "Not Found"
 
 let health_handler _req =
   Server.respond ~status:`OK ~headers:[ ("Content-Type", "text/plain") ] "ok"
 
-let build_handler t =
-  let base_handler =
+let to_handler t =
+  let route_handler =
     match t.router with
     | None -> not_found_handler
     | Some r -> (
···
             | None -> req.target
           in
           match Router.lookup r ~method_:req.meth ~path with
-          | Some (handler, params) -> handler params req
+          | Some { handler; params; plugs } ->
+              let base_handler req = handler params req in
+              let wrapped = Pipeline.apply plugs base_handler in
+              wrapped req
           | None -> not_found_handler req)
   in
   let with_health =
     if t.config.health_check then fun req ->
       if req.Server.target = "/_health" || req.Server.target = "/health" then
         health_handler req
-      else base_handler req
-    else base_handler
+      else route_handler req
+    else route_handler
   in
-  let pipeline = Plug.compose_all (List.rev t.plugs) in
-  Plug.apply pipeline with_health
-
-let start t ~env =
-  let handler = build_handler t in
-  let server_config =
-    {
-      Server.default_config with
-      port = t.config.port;
-      host = t.config.bind;
-      domain_count = t.config.domains;
-      protocol = t.config.protocol;
-      tls = t.config.tls;
-    }
-  in
-  Eio.Switch.run @@ fun sw ->
-  let net = Eio.Stdenv.net env in
-  if t.config.domains > 1 then
-    let domain_mgr = Eio.Stdenv.domain_mgr env in
-    Server.run_parallel ~sw ~net ~domain_mgr ~config:server_config
-      ?ws_handler:t.ws_handler handler
-  else
-    Server.run ~sw ~net ~config:server_config ?ws_handler:t.ws_handler handler
+  Pipeline.apply t.plugs with_health

lib/hcs.ml

···
 module Plug = Plug
 (** Plug-based middleware system (Phoenix-style) *)
 
+module Pipeline = Pipeline
+(** Reusable plug collections for route scopes *)
+
 module Endpoint = Endpoint
-(** Application bootstrap tying router, plugs, and server *)
+(** Global plug entry point before routing *)
 
 module Pool = Pool
 (** Connection pool *)

lib/pipeline.ml

···
+(** Reusable plug collections for route groups (Phoenix-style pipelines). *)
+
+type t = Core.t list
+
+let empty : t = []
+let create (plugs : Core.t list) : t = plugs
+let plug (t : t) (p : Core.t) : t = t @ [ p ]
+let plug_first (t : t) (p : Core.t) : t = p :: t
+let compose (t1 : t) (t2 : t) : t = t1 @ t2
+let to_plug (t : t) : Core.t = Core.compose_all t
+
+let apply (t : t) (handler : Core.handler) : Core.handler =
+  Core.apply (to_plug t) handler
+
+let is_empty (t : t) : bool = t = []
+let length (t : t) : int = List.length t

lib/router.ml

···
-(** Type-safe router with radix trie for efficient path matching.
-
-    This module provides:
-    - Type-safe path patterns with parameter extraction
-    - Radix trie for O(path_length) route lookup
-    - Hashtbl for O(1) literal segment matching
-    - Middleware support
-    - Route scoping/grouping *)
-
-(** Path segment types *)
-type segment =
-  | Literal of string  (** Exact match *)
-  | Param of string  (** Named parameter capture *)
-  | Wildcard  (** Match rest of path *)
+(** Type-safe router with radix trie, scopes, and per-route plugs. *)
 
+type segment = Literal of string | Param of string | Wildcard
 type params = (string * string) list
-(** Parsed path parameters *)
-
-type 'a route = {
-  method_ : H1.Method.t option;  (** None = match any method *)
-  segments : segment list;
-  handler : 'a;
-}
-(** A route definition *)
+type 'a handler_entry = { handler : 'a; plugs : Pipeline.t }
 
 type 'a trie_node = {
-  mutable handlers : (H1.Method.t option * 'a) list;
-      (** Handlers at this node *)
+  mutable handlers : (H1.Method.t option * 'a handler_entry) list;
   literal_children : (string, 'a trie_node) Hashtbl.t;
-      (** O(1) lookup for literal segments *)
   mutable param_child : (string * 'a trie_node) option;
-      (** Single param child (with param name) *)
-  mutable wildcard_child : 'a trie_node option;  (** Single wildcard child *)
+  mutable wildcard_child : 'a trie_node option;
 }
-(** Radix trie node with optimized child storage *)
 
 type 'a t = { root : 'a trie_node }
-(** Compiled router *)
+type 'a match_result = { handler : 'a; params : params; plugs : Pipeline.t }
 
-(** Create empty trie node *)
 let empty_node () =
   {
     handlers = [];
···
     wildcard_child = None;
   }
 
-(** Create empty router *)
 let empty () = { root = empty_node () }
 
-(** Parse path string into segments *)
 let parse_path path =
   let path =
     if String.length path > 0 && path.[0] = '/' then
···
         else if s = "*" then Wildcard
         else Literal s)
 
-(** Find or create child node for segment *)
 let find_or_create_child node seg =
   match seg with
   | Literal s -> (
···
           node.wildcard_child <- Some child;
           child)
 
-(** Add a route to the trie *)
-let add_route router ~method_ ~path ~handler =
+let add_route router ~method_ ~path ~handler ~plugs =
   let segments = parse_path path in
+  let entry = { handler; plugs } in
   let rec insert node = function
-    | [] -> node.handlers <- (method_, handler) :: node.handlers
+    | [] -> node.handlers <- (method_, entry) :: node.handlers
     | seg :: rest ->
         let child = find_or_create_child node seg in
         insert child rest
   in
   insert router.root segments
 
-(** Lookup a path in the trie - optimized with index-based parsing *)
 let lookup router ~method_ ~path =
   let len = String.length path in
   let start = if len > 0 && path.[0] = '/' then 1 else 0 in
 
   let rec search node pos params =
     if pos >= len then
-      List.find_opt
-        (fun (m, _) -> match m with None -> true | Some m' -> m' = method_)
-        node.handlers
-      |> Option.map (fun (_, handler) -> (handler, params))
+      match
+        List.find_opt
+          (fun (m, _) -> match m with None -> true | Some m' -> m' = method_)
+          node.handlers
+      with
+      | Some (_, entry) ->
+          Some { handler = entry.handler; params; plugs = entry.plugs }
+      | None -> None
     else
       let seg_end =
         try String.index_from path pos '/' with Not_found -> len
···
   in
   search router.root start []
 
-(** Route builder DSL *)
 module Route = struct
-  type 'a t = { method_ : H1.Method.t option; path : string; handler : 'a }
+  type 'a t = {
+    method_ : H1.Method.t option;
+    path : string;
+    handler : 'a;
+    plugs : Pipeline.t;
+  }
 
-  let get path handler = { method_ = Some `GET; path; handler }
-  let post path handler = { method_ = Some `POST; path; handler }
-  let put path handler = { method_ = Some `PUT; path; handler }
-  let delete path handler = { method_ = Some `DELETE; path; handler }
-  let patch path handler = { method_ = Some (`Other "PATCH"); path; handler }
-  let head path handler = { method_ = Some `HEAD; path; handler }
-  let options path handler = { method_ = Some `OPTIONS; path; handler }
-  let any path handler = { method_ = None; path; handler }
+  let make ?method_ path handler = { method_; path; handler; plugs = [] }
+  let get path handler = { method_ = Some `GET; path; handler; plugs = [] }
+  let post path handler = { method_ = Some `POST; path; handler; plugs = [] }
+  let put path handler = { method_ = Some `PUT; path; handler; plugs = [] }
+
+  let delete path handler =
+    { method_ = Some `DELETE; path; handler; plugs = [] }
+
+  let patch path handler =
+    { method_ = Some (`Other "PATCH"); path; handler; plugs = [] }
+
+  let head path handler = { method_ = Some `HEAD; path; handler; plugs = [] }
+
+  let options path handler =
+    { method_ = Some `OPTIONS; path; handler; plugs = [] }
+
+  let any path handler = { method_ = None; path; handler; plugs = [] }
+  let plug route p = { route with plugs = Pipeline.plug route.plugs p }
 end
 
-(** Compile routes into a router *)
+let normalize_path path =
+  if String.length path = 0 then "/"
+  else if path.[0] <> '/' then "/" ^ path
+  else path
+
+let join_paths prefix path =
+  let prefix = normalize_path prefix in
+  let path = normalize_path path in
+  if prefix = "/" then path else if path = "/" then prefix else prefix ^ path
+
+let scope ?(through = Pipeline.empty) prefix routes =
+  List.map
+    (fun (r : 'a Route.t) ->
+      {
+        r with
+        path = join_paths prefix r.path;
+        plugs = Pipeline.compose through r.plugs;
+      })
+    routes
+
 let compile routes =
   let router = empty () in
   List.iter
     (fun r ->
-      add_route router ~method_:r.Route.method_ ~path:r.path ~handler:r.handler)
+      add_route router ~method_:r.Route.method_ ~path:r.Route.path
+        ~handler:r.Route.handler ~plugs:r.Route.plugs)
     routes;
   router
 
-(** Get parameter from params list *)
+let compile_scopes scopes =
+  let all_routes = List.concat scopes in
+  compile all_routes
+
 let param name params = List.assoc_opt name params
 
-(** Get parameter with default *)
 let param_or name ~default params =
   match List.assoc_opt name params with Some v -> v | None -> default
 
-(** Get parameter as int *)
 let param_int name params =
   match List.assoc_opt name params with
   | Some v -> int_of_string_opt v
   | None -> None
 
-(** Get parameter as int with default *)
 let param_int_or name ~default params =
   match param_int name params with Some v -> v | None -> default

test/test_hcs.ml

···
     ]
 end
 
-(* ================================================================== *)
-(* Router Tests *)
-(* ================================================================== *)
+module Test_pipeline = struct
+  open Hcs.Pipeline
+
+  let test_empty () = check int "empty length" 0 (length empty)
+
+  let test_create () =
+    let p = create [ Fun.id; Fun.id ] in
+    check int "create length" 2 (length p)
+
+  let test_plug () =
+    let p = empty |> fun t -> plug t Fun.id in
+    check int "plug length" 1 (length p)
+
+  let test_plug_first () =
+    let p = empty |> fun t -> plug_first t Fun.id in
+    check int "plug_first length" 1 (length p)
+
+  let test_compose () =
+    let p1 = create [ Fun.id ] in
+    let p2 = create [ Fun.id; Fun.id ] in
+    let combined = compose p1 p2 in
+    check int "compose length" 3 (length combined)
+
+  let test_is_empty () =
+    check bool "empty is empty" true (is_empty empty);
+    check bool "non-empty not empty" false (is_empty (create [ Fun.id ]))
+
+  let test_apply () =
+    let called = ref false in
+    let mark_plug : Hcs.Plug.t =
+     fun handler req ->
+      called := true;
+      handler req
+    in
+    let p = create [ mark_plug ] in
+    let dummy_req : Hcs.Server.request =
+      { meth = `GET; target = "/"; headers = []; body = ""; version = HTTP_1_1 }
+    in
+    let handler _req = Hcs.Server.respond "ok" in
+    let wrapped = apply p handler in
+    let _ = wrapped dummy_req in
+    check bool "plug was called" true !called
+
+  let tests =
+    [
+      test_case "empty" `Quick test_empty;
+      test_case "create" `Quick test_create;
+      test_case "plug" `Quick test_plug;
+      test_case "plug_first" `Quick test_plug_first;
+      test_case "compose" `Quick test_compose;
+      test_case "is_empty" `Quick test_is_empty;
+      test_case "apply" `Quick test_apply;
+    ]
+end
 
 module Test_router = struct
   open Hcs.Router
···
   let test_router_literal_match () =
     let router = empty () in
     add_route router ~method_:(Some `GET) ~path:"/users"
-      ~handler:"users_handler";
+      ~handler:"users_handler" ~plugs:[];
     match lookup router ~method_:`GET ~path:"/users" with
-    | Some (handler, _) -> check string "handler" "users_handler" handler
+    | Some { handler; _ } -> check string "handler" "users_handler" handler
     | None -> fail "no match"
 
   let test_router_param_match () =
     let router = empty () in
     add_route router ~method_:(Some `GET) ~path:"/users/:id"
-      ~handler:"user_handler";
+      ~handler:"user_handler" ~plugs:[];
     match lookup router ~method_:`GET ~path:"/users/123" with
-    | Some (handler, params) ->
+    | Some { handler; params; _ } ->
         check string "handler" "user_handler" handler;
         check (option string) "id param" (Some "123") (param "id" params)
     | None -> fail "no match"
···
   let test_router_multiple_params () =
     let router = empty () in
     add_route router ~method_:(Some `GET) ~path:"/users/:user_id/posts/:post_id"
-      ~handler:"post_handler";
+      ~handler:"post_handler" ~plugs:[];
     match lookup router ~method_:`GET ~path:"/users/42/posts/100" with
-    | Some (handler, params) ->
+    | Some { handler; params; _ } ->
         check string "handler" "post_handler" handler;
         check (option string) "user_id" (Some "42") (param "user_id" params);
         check (option string) "post_id" (Some "100") (param "post_id" params)
···
   let test_router_wildcard_match () =
     let router = empty () in
     add_route router ~method_:(Some `GET) ~path:"/files/*"
-      ~handler:"files_handler";
+      ~handler:"files_handler" ~plugs:[];
     match lookup router ~method_:`GET ~path:"/files/path/to/file.txt" with
-    | Some (handler, params) ->
+    | Some { handler; params; _ } ->
         check string "handler" "files_handler" handler;
         check (option string) "wildcard" (Some "path/to/file.txt")
           (param "*" params)
···
 
   let test_router_method_match () =
     let router = empty () in
-    add_route router ~method_:(Some `GET) ~path:"/users" ~handler:"get_handler";
+    add_route router ~method_:(Some `GET) ~path:"/users" ~handler:"get_handler"
+      ~plugs:[];
     add_route router ~method_:(Some `POST) ~path:"/users"
-      ~handler:"post_handler";
+      ~handler:"post_handler" ~plugs:[];
     (match lookup router ~method_:`GET ~path:"/users" with
-    | Some (handler, _) -> check string "GET handler" "get_handler" handler
+    | Some { handler; _ } -> check string "GET handler" "get_handler" handler
     | None -> fail "no GET match");
     match lookup router ~method_:`POST ~path:"/users" with
-    | Some (handler, _) -> check string "POST handler" "post_handler" handler
+    | Some { handler; _ } -> check string "POST handler" "post_handler" handler
     | None -> fail "no POST match"
 
   let test_router_any_method () =
     let router = empty () in
-    add_route router ~method_:None ~path:"/health" ~handler:"health_handler";
+    add_route router ~method_:None ~path:"/health" ~handler:"health_handler"
+      ~plugs:[];
     (match lookup router ~method_:`GET ~path:"/health" with
-    | Some (handler, _) -> check string "GET" "health_handler" handler
+    | Some { handler; _ } -> check string "GET" "health_handler" handler
     | None -> fail "no GET match");
     match lookup router ~method_:`POST ~path:"/health" with
-    | Some (handler, _) -> check string "POST" "health_handler" handler
+    | Some { handler; _ } -> check string "POST" "health_handler" handler
     | None -> fail "no POST match"
 
   let test_router_no_match () =
     let router = empty () in
-    add_route router ~method_:(Some `GET) ~path:"/users" ~handler:"handler";
+    add_route router ~method_:(Some `GET) ~path:"/users" ~handler:"handler"
+      ~plugs:[];
     match lookup router ~method_:`GET ~path:"/posts" with
     | Some _ -> fail "unexpected match"
     | None -> ()
···
     in
     let router = compile routes in
     (match lookup router ~method_:`GET ~path:"/users" with
-    | Some (h, _) -> check string "list" "list_users" h
+    | Some { handler; _ } -> check string "list" "list_users" handler
     | None -> fail "no list match");
     match lookup router ~method_:`GET ~path:"/users/42" with
-    | Some (h, params) ->
-        check string "get" "get_user" h;
+    | Some { handler; params; _ } ->
+        check string "get" "get_user" handler;
         check (option string) "id" (Some "42") (param "id" params)
     | None -> fail "no get match"
 
···
     check (option int) "param_int" (Some 42) (param_int "id" params);
     check int "param_int_or" 0 (param_int_or "foo" ~default:0 params)
 
+  let test_scope_prefix () =
+    let routes = scope "/api" [ Route.get "/users" "list_users" ] in
+    let router = compile routes in
+    match lookup router ~method_:`GET ~path:"/api/users" with
+    | Some { handler; _ } -> check string "scoped handler" "list_users" handler
+    | None -> fail "no match for scoped route"
+
+  let test_scope_root_prefix () =
+    let routes = scope "/" [ Route.get "/users" "list_users" ] in
+    let router = compile routes in
+    match lookup router ~method_:`GET ~path:"/users" with
+    | Some { handler; _ } -> check string "root scope" "list_users" handler
+    | None -> fail "no match"
+
+  let test_scope_nested_path () =
+    let routes = scope "/api/v1" [ Route.get "/users/:id" "get_user" ] in
+    let router = compile routes in
+    match lookup router ~method_:`GET ~path:"/api/v1/users/42" with
+    | Some { handler; params; _ } ->
+        check string "nested scope" "get_user" handler;
+        check (option string) "id param" (Some "42") (param "id" params)
+    | None -> fail "no match"
+
+  let test_compile_scopes () =
+    let api_routes = scope "/api" [ Route.get "/posts" "list_posts" ] in
+    let web_routes = scope "/" [ Route.get "/" "home" ] in
+    let router = compile_scopes [ api_routes; web_routes ] in
+    (match lookup router ~method_:`GET ~path:"/api/posts" with
+    | Some { handler; _ } -> check string "api route" "list_posts" handler
+    | None -> fail "no api match");
+    match lookup router ~method_:`GET ~path:"/" with
+    | Some { handler; _ } -> check string "web route" "home" handler
+    | None -> fail "no web match"
+
+  let test_route_with_plug () =
+    let dummy_plug : Hcs.Plug.t = fun handler -> handler in
+    let base_route = Route.get "/admin" "admin_handler" in
+    let route = Route.plug base_route dummy_plug in
+    let router = compile [ route ] in
+    match lookup router ~method_:`GET ~path:"/admin" with
+    | Some { handler; plugs; _ } ->
+        check string "handler" "admin_handler" handler;
+        check int "has plugs" 1 (List.length plugs)
+    | None -> fail "no match"
+
   let tests =
     [
       test_case "parse_path empty" `Quick test_parse_path_empty;
···
       test_case "router no match" `Quick test_router_no_match;
       test_case "router compile" `Quick test_router_compile;
       test_case "param helpers" `Quick test_param_helpers;
+      test_case "scope prefix" `Quick test_scope_prefix;
+      test_case "scope root prefix" `Quick test_scope_root_prefix;
+      test_case "scope nested path" `Quick test_scope_nested_path;
+      test_case "compile scopes" `Quick test_compile_scopes;
+      test_case "route with plug" `Quick test_route_with_plug;
     ]
 end
 
···
           let open Hcs.Router in
           let router = empty () in
           add_route router ~method_:(Some `GET) ~path:"/users/:id/items/:name"
-            ~handler:"handler";
+            ~handler:"handler" ~plugs:[];
           match
             lookup router ~method_:`GET
               ~path:(Printf.sprintf "/users/%s/items/%s" id name)
           with
-          | Some (_, params) ->
+          | Some { params; _ } ->
               param "id" params = Some id && param "name" params = Some name
           | None -> false)
 
···
       ("Codec", Test_codec.tests);
       ("Stream", Test_stream.tests);
       ("Http", Test_http.tests);
+      ("Pipeline", Test_pipeline.tests);
       ("Router", Test_router.tests);
       ("Log", Test_log.tests);
       ("Tls_config", Test_tls_config.tests);