decode error which should be caught at compile time

import * as S from "@effect/schema/Schema";
export class Test extends S.TaggedRequest<Test>()(
  "Test",
  S.Never,
  S.Void,
  {}
) {}

import { Rpc, Router } from "@effect/rpc";
import { HttpRouter as RpcHttpRouter } from "@effect/rpc-http";

import { Effect, Layer } from "effect";
import { HttpMiddleware, HttpRouter, HttpServer } from "@effect/platform";
import { BunHttpServer, BunRuntime } from "@effect/platform-bun";
import { Test } from "./schema";

const router = Router.make(
  Rpc.effect(Test, () =>
    Effect.gen(function* () {
      return 42;
    })
  )
);
export type Router = typeof router;

const HttpLive = HttpRouter.empty.pipe(
  HttpRouter.post("/rpc", RpcHttpRouter.toHttpApp(router)),
  HttpServer.serve(HttpMiddleware.logger),
  HttpServer.withLogAddress,
  Layer.provide(BunHttpServer.layer({ port: 3002 }))
);

Layer.launch(HttpLive).pipe(BunRuntime.runMain);

import { HttpClient, HttpClientRequest } from "@effect/platform";
import { Resolver } from "@effect/rpc";
import { HttpResolver } from "@effect/rpc-http";

import type { Router } from "./server";
import { Test } from "./schema";
import { Effect } from "effect";

export const rpc = HttpResolver.make<Router>(
  HttpClient.fetchOk.pipe(
    HttpClient.mapRequest(
      HttpClientRequest.prependUrl("http://localhost:3002/rpc")
    )
  )
).pipe(Resolver.toClient);

const main = Effect.gen(function* () {
  yield* rpc(new Test({}));
});

await Effect.runPromise(main);

(FiberFailure) ParseError: (ExitEncoded<void, never> <-> Exit<void, never>)
└─ Type side transformation failure
   └─ Exit<void, never>
      └─ Expected void, actual 42