diff --git a/packages/server/src/rpc/RPCRouter.ts b/packages/server/src/rpc/RPCRouter.ts
index 057b687..bd1f673 100644
--- a/packages/server/src/rpc/RPCRouter.ts
+++ b/packages/server/src/rpc/RPCRouter.ts
@@ -1,64 +1,12 @@
-import { Schema as S } from "@effect/schema"
-import { ServerTime } from "@todo-tests/common/data"
-import { TRPCError } from "@trpc/server"
-import { observable } from "@trpc/server/observable"
-import { Context, Data, Effect, Fiber, Layer, Schedule } from "effect"
-import { TRPCBuilder } from "../trpc/TRPCBuilder"
-import { RPCProcedureBuilder } from "./procedures/RPCProcedureBuilder"
-import { todoRouter } from "./routers/todo"
-
-
-const encodeServerTime = S.encode(ServerTime)
-
-
-export const router = Effect.gen(function*() {
-    const t         = yield* TRPCBuilder
-    const procedure = yield* RPCProcedureBuilder
-
-    return t.router({
-        ping: procedure.query(({ ctx }) => ctx.run(
-            Effect.succeed("pong")
-        )),
-
-        serverTime: procedure
-            .subscription(({ ctx }) =>
-                observable<typeof ServerTime.Encoded>(emit => {
-                    const emitter = ctx.fork(
-                        Effect.sync(() => new Date()).pipe(
-                            Effect.flatMap(encodeServerTime),
-                            Effect.map(emit.next),
-                            Effect.repeat(Schedule.fixed("1 second")),
-                        )
-                    )
-
-                    return () => ctx.fork(
-                        Fiber.interrupt(emitter)
-                    )
-                })
-            ),
-
-
-        fail1: procedure.query(({ ctx }) => ctx.run(
-            Effect.fail(new AnError({ aValue: "A value" }))
-        )),
-        fail2: procedure.query(({ ctx }) => ctx.run(
-            Effect.fail(new TRPCError({ code: "NOT_IMPLEMENTED" }))
-        )),
-
-        todo: yield* todoRouter,
-    })
-})
-
-class AnError extends Data.TaggedError("AnError")<{
-    aValue: string
-}> {}
+import { Context, Effect, Layer } from "effect"
+import { indexRouter } from "./routers"
 
 
 export class RPCRouter extends Context.Tag("RPCRouter")<RPCRouter,
-    Effect.Effect.Success<typeof router>
+    Effect.Effect.Success<typeof indexRouter>
 >() {}
 
 export module RPCRouter {
     export type Router = Context.Tag.Service<RPCRouter>
-    export const Live = Layer.effect(RPCRouter, router)
+    export const Live = Layer.effect(RPCRouter, indexRouter)
 }
diff --git a/packages/server/src/rpc/routers/index.ts b/packages/server/src/rpc/routers/index.ts
new file mode 100644
index 0000000..da1a997
--- /dev/null
+++ b/packages/server/src/rpc/routers/index.ts
@@ -0,0 +1,54 @@
+import { Schema as S } from "@effect/schema"
+import { ServerTime } from "@todo-tests/common/data"
+import { TRPCError } from "@trpc/server"
+import { observable } from "@trpc/server/observable"
+import { Data, Effect, Fiber, Schedule } from "effect"
+import { TRPCBuilder } from "../../trpc/TRPCBuilder"
+import { RPCProcedureBuilder } from "../procedures/RPCProcedureBuilder"
+import { todoRouter } from "./todo"
+
+
+const encodeServerTime = S.encode(ServerTime)
+
+
+export const indexRouter = Effect.gen(function*() {
+    const t         = yield* TRPCBuilder
+    const procedure = yield* RPCProcedureBuilder
+
+    return t.router({
+        ping: procedure.query(({ ctx }) => ctx.run(
+            Effect.succeed("pong")
+        )),
+
+        serverTime: procedure
+            .subscription(({ ctx }) =>
+                observable<typeof ServerTime.Encoded>(emit => {
+                    const emitter = ctx.fork(
+                        Effect.sync(() => new Date()).pipe(
+                            Effect.flatMap(encodeServerTime),
+                            Effect.map(emit.next),
+                            Effect.repeat(Schedule.fixed("1 second")),
+                        )
+                    )
+
+                    return () => ctx.fork(
+                        Fiber.interrupt(emitter)
+                    )
+                })
+            ),
+
+
+        fail1: procedure.query(({ ctx }) => ctx.run(
+            Effect.fail(new AnError({ aValue: "A value" }))
+        )),
+        fail2: procedure.query(({ ctx }) => ctx.run(
+            Effect.fail(new TRPCError({ code: "NOT_IMPLEMENTED" }))
+        )),
+
+        todo: yield* todoRouter,
+    })
+})
+
+class AnError extends Data.TaggedError("AnError")<{
+    aValue: string
+}> {}