@rexeus/typeweaver-server 0.7.0 → 0.8.0

package/README.md

@@ -113,8 +113,8 @@ export const userHandlers: ServerUserApiHandler = {
 };
 ```
 
-> Generated response classes (e.g. `GetUserSuccessResponse`) are also available for when you need
-> runtime type checks or `instanceof` discrimination in error handling.
+> Generated response factory functions (e.g. `createGetUserSuccessResponse`) are also available for
+> constructing typed responses with pre-set `type` and `statusCode` discriminators.
 
 ### Create the app
 
@@ -310,48 +310,67 @@ const app = new TypeweaverApp({
 
 Each router accepts `TypeweaverRouterOptions`:
 
-| Option                     | Type                         | Default    | Description                        |
-| -------------------------- | ---------------------------- | ---------- | ---------------------------------- |
-| `requestHandlers`          | `Server<Resource>ApiHandler` | _required_ | Handler methods for each operation |
-| `validateRequests`         | `boolean`                    | `true`     | Enable/disable request validation  |
-| `handleValidationErrors`   | `boolean \| function`        | `true`     | Handle validation errors           |
-| `handleHttpResponseErrors` | `boolean \| function`        | `true`     | Handle thrown `HttpResponse`       |
-| `handleUnknownErrors`      | `boolean \| function`        | `true`     | Handle unexpected errors           |
+| Option                           | Type                         | Default    | Description                        |
+| -------------------------------- | ---------------------------- | ---------- | ---------------------------------- |
+| `requestHandlers`                | `Server<Resource>ApiHandler` | _required_ | Handler methods for each operation |
+| `validateRequests`               | `boolean`                    | `true`     | Enable/disable request validation  |
+| `validateResponses`              | `boolean`                    | `true`     | Enable/disable response validation |
+| `handleRequestValidationErrors`  | `boolean \| function`        | `true`     | Handle request validation errors   |
+| `handleResponseValidationErrors` | `boolean \| function`        | `true`     | Handle response validation errors  |
+| `handleHttpResponseErrors`       | `boolean \| function`        | `true`     | Handle thrown typed HTTP responses |
+| `handleUnknownErrors`            | `boolean \| function`        | `true`     | Handle unexpected errors           |
 
 When set to `true`, error handlers use sensible defaults (400/500 responses). When set to `false`,
-errors fall through to the next handler in the chain. When set to a function, it receives the error
-and `ServerContext` and must return an `IHttpResponse`.
+errors fall through to the next handler in the chain (except `handleResponseValidationErrors`, where
+`false` means the invalid response is returned as-is — validation still runs for field stripping,
+but invalid responses pass through unchanged). When set to a function, it receives the error and
+`ServerContext` and must return an `IHttpResponse`. If a custom error handler throws, the framework
+catches the exception and falls through gracefully to the next handler.
 
 ### 🚨 Error Handling
 
 #### Throwing errors in handlers
 
-All generated error response classes (e.g. `NotFoundErrorResponse`, `ValidationErrorResponse`)
-extend `HttpResponse`. Throw them in your handlers — the framework catches them automatically:
+Throw any object matching `ITypedHttpResponse` (i.e. `{ type: string, statusCode: number, ... }`)
+from your handlers — the framework catches it automatically and returns it as the response:
 
 ```ts
 import { HttpStatusCode } from "@rexeus/typeweaver-core";
-import { GetUserSuccessResponse, NotFoundErrorResponse } from "./generated";
 
 async handleGetUserRequest(request) {
   const user = await db.findUser(request.param.userId);
   if (!user) {
-    throw new NotFoundErrorResponse({
+    // Plain objects work — anything with `type` and `statusCode` is recognized
+    throw {
+      type: "NotFoundError",
       statusCode: HttpStatusCode.NOT_FOUND,
       header: { "Content-Type": "application/json" },
       body: { message: "Resource not found", code: "NOT_FOUND_ERROR" },
-    });
+    };
   }
-  return new GetUserSuccessResponse({
+  return {
+    type: "GetUserSuccess",
     statusCode: HttpStatusCode.OK,
     header: { "Content-Type": "application/json" },
     body: user,
-  });
+  };
 }
 ```
 
-When `handleHttpResponseErrors` is `true` (the default), thrown `HttpResponse` instances are
-returned as-is. No extra configuration needed.
+Generated factory functions (e.g. `createNotFoundErrorResponse`) are a convenient shorthand — they
+set `type` and `statusCode` for you so you only pass `header` and `body`:
+
+```ts
+import { createNotFoundErrorResponse } from "./generated";
+
+throw createNotFoundErrorResponse({
+  header: { "Content-Type": "application/json" },
+  body: { message: "Resource not found", code: "NOT_FOUND_ERROR" },
+});
+```
+
+When `handleHttpResponseErrors` is `true` (the default), thrown typed HTTP responses
+(`ITypedHttpResponse`) are returned as-is. No extra configuration needed.
 
 #### Custom error mapping
 
@@ -362,21 +381,21 @@ Use custom handler functions to transform errors into your own response shape.
 ```ts
 new UserRouter({
   requestHandlers: userHandlers,
-  handleValidationErrors: (error, ctx) =>
-    new ValidationErrorResponse({
-      statusCode: HttpStatusCode.BAD_REQUEST,
-      header: { "Content-Type": "application/json" },
-      body: {
-        code: "VALIDATION_ERROR",
-        message: "Request is invalid",
-        issues: {
-          body: error.bodyIssues,
-          query: error.queryIssues,
-          param: error.pathParamIssues,
-          header: error.headerIssues,
-        },
+  handleRequestValidationErrors: (error, ctx) => ({
+    type: "ValidationError",
+    statusCode: HttpStatusCode.BAD_REQUEST,
+    header: { "Content-Type": "application/json" },
+    body: {
+      code: "VALIDATION_ERROR",
+      message: "Request is invalid",
+      issues: {
+        body: error.bodyIssues,
+        query: error.queryIssues,
+        param: error.pathParamIssues,
+        header: error.headerIssues,
       },
-    }),
+    },
+  }),
 });
 ```
 
@@ -402,25 +421,27 @@ new UserRouter({
   requestHandlers: userHandlers,
   handleUnknownErrors: (error, ctx) => {
     logger.error("Unhandled error", { error, path: ctx.request.path });
-    return new InternalServerErrorResponse({
+    return {
+      type: "InternalServerError",
       statusCode: HttpStatusCode.INTERNAL_SERVER_ERROR,
       header: { "Content-Type": "application/json" },
       body: { code: "INTERNAL_SERVER_ERROR", message: "Something went wrong" },
-    });
+    };
   },
 });
 ```
 
 ### 📋 Error Responses
 
-| Status | Code                    | When                                                          |
-| ------ | ----------------------- | ------------------------------------------------------------- |
-| `400`  | `BAD_REQUEST`           | Malformed request body                                        |
-| `400`  | Validation issues       | `handleValidationErrors: true` and request fails validation   |
-| `404`  | `NOT_FOUND`             | No matching route                                             |
-| `405`  | `METHOD_NOT_ALLOWED`    | Route exists but method not allowed (includes `Allow` header) |
-| `413`  | `PAYLOAD_TOO_LARGE`     | Request body exceeds `maxBodySize`                            |
-| `500`  | `INTERNAL_SERVER_ERROR` | Unhandled error in handler                                    |
+| Status | Code                    | When                                                                 |
+| ------ | ----------------------- | -------------------------------------------------------------------- |
+| `400`  | `BAD_REQUEST`           | Malformed request body                                               |
+| `400`  | Validation issues       | `handleRequestValidationErrors: true` and request fails validation   |
+| `404`  | `NOT_FOUND`             | No matching route                                                    |
+| `405`  | `METHOD_NOT_ALLOWED`    | Route exists but method not allowed (includes `Allow` header)        |
+| `413`  | `PAYLOAD_TOO_LARGE`     | Request body exceeds `maxBodySize`                                   |
+| `500`  | `INTERNAL_SERVER_ERROR` | `handleResponseValidationErrors: true` and response fails validation |
+| `500`  | `INTERNAL_SERVER_ERROR` | Unhandled error in handler                                           |
 
 All error responses follow the shape: `{ code: string, message: string }`.
 

package/dist/lib/Router.ts

@@ -9,7 +9,10 @@ import type {
   HttpMethod,
   IHttpResponse,
   IRequestValidator,
+  IResponseValidator,
+  ITypedHttpResponse,
   RequestValidationError,
+  ResponseValidationError,
 } from "@rexeus/typeweaver-core";
 import type { RequestHandler } from "./RequestHandler";
 import type { ServerContext } from "./ServerContext";
@@ -30,7 +33,8 @@ export type RouteDefinition = {
   readonly operationId: string;
   readonly method: HttpMethod;
   readonly path: string;
-  readonly validator: IRequestValidator;
+  readonly requestValidator: IRequestValidator;
+  readonly responseValidator: IResponseValidator;
   readonly handler: RequestHandler<any, any, any>;
   /** Reference to the router config for error handling. */
   readonly routerConfig: RouterErrorConfig;
@@ -41,28 +45,44 @@ export type RouteDefinition = {
  */
 export type RouterErrorConfig = {
   readonly validateRequests: boolean;
+  readonly validateResponses: boolean;
   readonly handleHttpResponseErrors: HttpResponseErrorHandler | boolean;
-  readonly handleValidationErrors: ValidationErrorHandler | boolean;
+  readonly handleRequestValidationErrors:
+    | RequestValidationErrorHandler
+    | boolean;
+  readonly handleResponseValidationErrors:
+    | ResponseValidationErrorHandler
+    | boolean;
   readonly handleUnknownErrors: UnknownErrorHandler | boolean;
 };
 
 /**
  * Handles HTTP response errors thrown by request handlers.
- * The error parameter is an `HttpResponse` instance (thrown via `throw new HttpResponse(...)`).
+ * The error parameter is a typed HTTP response object (thrown via `throw { type, statusCode, ... }`).
  */
 export type HttpResponseErrorHandler = (
-  error: IHttpResponse,
+  error: ITypedHttpResponse,
   ctx: ServerContext
 ) => Promise<IHttpResponse> | IHttpResponse;
 
 /**
  * Handles request validation errors.
  */
-export type ValidationErrorHandler = (
+export type RequestValidationErrorHandler = (
   error: RequestValidationError,
   ctx: ServerContext
 ) => Promise<IHttpResponse> | IHttpResponse;
 
+/**
+ * Handles response validation errors.
+ * Called when a handler returns a response that does not match the expected schema.
+ */
+export type ResponseValidationErrorHandler = (
+  error: ResponseValidationError,
+  response: IHttpResponse,
+  ctx: ServerContext
+) => Promise<IHttpResponse> | IHttpResponse;
+
 /**
  * Handles any unknown errors not caught by other handlers.
  */

package/dist/lib/TypeweaverApp.ts

@@ -5,7 +5,10 @@
  * @generated by @rexeus/typeweaver
  */
 
-import { HttpResponse, RequestValidationError } from "@rexeus/typeweaver-core";
+import {
+  isTypedHttpResponse,
+  RequestValidationError,
+} from "@rexeus/typeweaver-core";
 import type { IHttpResponse } from "@rexeus/typeweaver-core";
 import { BodyParseError, PayloadTooLargeError } from "./Errors";
 import { FetchApiAdapter } from "./FetchApiAdapter";
@@ -16,10 +19,11 @@ import type { Middleware } from "./Middleware";
 import type { RequestHandler } from "./RequestHandler";
 import type {
   HttpResponseErrorHandler,
+  ResponseValidationErrorHandler,
   RouteDefinition,
   RouteMatch,
   UnknownErrorHandler,
-  ValidationErrorHandler,
+  RequestValidationErrorHandler,
 } from "./Router";
 import type { ServerContext } from "./ServerContext";
 import type { StateRequirementError, TypedMiddleware } from "./TypedMiddleware";
@@ -224,8 +228,15 @@ export class TypeweaverApp<TState extends Record<string, unknown> = {}> {
     if (match) {
       const routeCtx = this.withPathParams(ctx, match.params);
       try {
-        return await this.executeHandler(routeCtx, match.route);
+        const response = await this.executeHandler(routeCtx, match.route);
+        return await this.validateResponse(match.route, response, routeCtx);
       } catch (error) {
+        if (
+          isTypedHttpResponse(error) &&
+          match.route.routerConfig.validateResponses
+        ) {
+          return await this.validateResponse(match.route, error, routeCtx);
+        }
         return this.handleError(error, routeCtx, match.route);
       }
     }
@@ -261,44 +272,123 @@ export class TypeweaverApp<TState extends Record<string, unknown> = {}> {
     route: RouteDefinition
   ): Promise<IHttpResponse> {
     const validatedRequest = route.routerConfig.validateRequests
-      ? route.validator.validate(ctx.request)
+      ? route.requestValidator.validate(ctx.request)
       : ctx.request;
 
     return route.handler(validatedRequest, ctx);
   }
 
+  /**
+   * Validates a response against the operation's response validator.
+   *
+   * Behavior depends on configuration:
+   * - `validateResponses: false` → returns the original response unchanged.
+   * - `validateResponses: true` (default) → runs validation:
+   *   - Valid response → returns the stripped response (extra fields removed).
+   *   - Invalid response + handler configured → calls the handler safely.
+   *     If the handler throws, falls back to the original response.
+   *   - Invalid response + `handleResponseValidationErrors: false` → returns
+   *     the original (invalid) response as-is.
+   *
+   * @param route - The route definition containing the response validator and config
+   * @param response - The response to validate
+   * @param ctx - The server context for the current request
+   * @returns The validated (and stripped) response, the handler's response, or the original
+   */
+  private async validateResponse(
+    route: RouteDefinition,
+    response: IHttpResponse,
+    ctx: ServerContext
+  ): Promise<IHttpResponse> {
+    if (!route.routerConfig.validateResponses) return response;
+
+    const result = route.responseValidator.safeValidate(response);
+
+    if (result.isValid) return result.data;
+
+    const handler = this.resolveErrorHandler<ResponseValidationErrorHandler>(
+      route.routerConfig.handleResponseValidationErrors,
+      TypeweaverApp.defaultResponseValidationHandler
+    );
+
+    if (handler) {
+      const handlerResponse = await this.safelyExecuteErrorHandler(() =>
+        handler(result.error, response, ctx)
+      );
+      if (handlerResponse) return handlerResponse;
+    }
+
+    return response;
+  }
+
+  /**
+   * Safely executes an error handler and returns null if it fails.
+   * This allows for graceful fallback to the next handler in the chain
+   * without crashing the request pipeline.
+   *
+   * If the handler throws, the error is reported via `safeOnError`
+   * and null is returned so the caller can fall through to the next handler.
+   *
+   * @param handlerFn - Function that executes the error handler
+   * @returns The handler's response if successful, null if the handler throws
+   */
+  private async safelyExecuteErrorHandler(
+    handlerFn: () => Promise<IHttpResponse> | IHttpResponse
+  ): Promise<IHttpResponse | null> {
+    try {
+      return await handlerFn();
+    } catch (error) {
+      this.safeOnError(error);
+      return null;
+    }
+  }
+
   /**
    * Handle errors using the route's configured error handlers.
-   * Handler errors bubble up to the safety net in `fetch()`.
    */
-  private handleError(
+  private async handleError(
     error: unknown,
     ctx: ServerContext,
     route: RouteDefinition
-  ): IHttpResponse | Promise<IHttpResponse> {
+  ): Promise<IHttpResponse> {
     const config = route.routerConfig;
 
     if (error instanceof RequestValidationError) {
-      const handler = this.resolveErrorHandler<ValidationErrorHandler>(
-        config.handleValidationErrors,
-        TypeweaverApp.defaultValidationHandler
+      const handler = this.resolveErrorHandler<RequestValidationErrorHandler>(
+        config.handleRequestValidationErrors,
+        TypeweaverApp.defaultRequestValidationHandler
       );
-      if (handler) return handler(error, ctx);
+      if (handler) {
+        const response = await this.safelyExecuteErrorHandler(() =>
+          handler(error, ctx)
+        );
+        if (response) return response;
+      }
     }
 
-    if (error instanceof HttpResponse) {
+    if (isTypedHttpResponse(error)) {
       const handler = this.resolveErrorHandler<HttpResponseErrorHandler>(
         config.handleHttpResponseErrors,
         TypeweaverApp.defaultHttpResponseHandler
       );
-      if (handler) return handler(error, ctx);
+      if (handler) {
+        const response = await this.safelyExecuteErrorHandler(() =>
+          handler(error, ctx)
+        );
+        if (response) return response;
+      }
     }
 
     const handler = this.resolveErrorHandler<UnknownErrorHandler>(
       config.handleUnknownErrors,
       this.defaultUnknownHandler
     );
-    if (handler) return handler(error, ctx);
+    if (handler) {
+      const response = await this.safelyExecuteErrorHandler(() =>
+        handler(error, ctx)
+      );
+      if (response) return response;
+    }
 
     throw error;
   }
@@ -339,30 +429,35 @@ export class TypeweaverApp<TState extends Record<string, unknown> = {}> {
     return issues.map(({ message, path }) => ({ message, path }));
   }
 
-  private static defaultValidationHandler: ValidationErrorHandler = (
-    err
-  ): IHttpResponse => {
-    const issues: Record<string, unknown> = Object.create(null);
+  private static defaultRequestValidationHandler: RequestValidationErrorHandler =
+    (err): IHttpResponse => {
+      const issues: Record<string, unknown> = Object.create(null);
 
-    const header = TypeweaverApp.sanitizeIssues(err.headerIssues);
-    const body = TypeweaverApp.sanitizeIssues(err.bodyIssues);
-    const query = TypeweaverApp.sanitizeIssues(err.queryIssues);
-    const param = TypeweaverApp.sanitizeIssues(err.pathParamIssues);
+      const header = TypeweaverApp.sanitizeIssues(err.headerIssues);
+      const body = TypeweaverApp.sanitizeIssues(err.bodyIssues);
+      const query = TypeweaverApp.sanitizeIssues(err.queryIssues);
+      const param = TypeweaverApp.sanitizeIssues(err.pathParamIssues);
 
-    if (header) issues.header = header;
-    if (body) issues.body = body;
-    if (query) issues.query = query;
-    if (param) issues.param = param;
+      if (header) issues.header = header;
+      if (body) issues.body = body;
+      if (query) issues.query = query;
+      if (param) issues.param = param;
 
-    return {
-      statusCode: 400,
-      body: {
-        code: "VALIDATION_ERROR",
-        message: err.message,
-        issues,
-      },
+      return {
+        statusCode: 400,
+        body: {
+          code: "VALIDATION_ERROR",
+          message: err.message,
+          issues,
+        },
+      };
     };
-  };
+
+  private static defaultResponseValidationHandler: ResponseValidationErrorHandler =
+    (): IHttpResponse => ({
+      statusCode: 500,
+      body: TypeweaverApp.INTERNAL_SERVER_ERROR_BODY,
+    });
 
   private static defaultHttpResponseHandler: HttpResponseErrorHandler = (
     err

package/dist/lib/TypeweaverRouter.ts

@@ -7,14 +7,19 @@
  * @generated by @rexeus/typeweaver
  */
 
-import type { HttpMethod, IRequestValidator } from "@rexeus/typeweaver-core";
+import type {
+  HttpMethod,
+  IRequestValidator,
+  IResponseValidator,
+} from "@rexeus/typeweaver-core";
 import type { RequestHandler } from "./RequestHandler";
 import type {
   HttpResponseErrorHandler,
+  ResponseValidationErrorHandler,
   RouteDefinition,
   RouterErrorConfig,
   UnknownErrorHandler,
-  ValidationErrorHandler,
+  RequestValidationErrorHandler,
 } from "./Router";
 
 /**
@@ -39,22 +44,42 @@ export type TypeweaverRouterOptions<
   readonly validateRequests?: boolean;
 
   /**
-   * Configure handling of HttpResponse errors thrown by handlers.
-   * - `true`: Use default handler (returns the error as response)
-   * - `false`: Disable this handler (errors fall through to the unknown error handler)
-   * - `function`: Use custom error handler
+   * Enable response validation using generated validators.
+   * When true, responses are validated and stripped of extra fields before sending.
    * @default true
    */
-  readonly handleHttpResponseErrors?: HttpResponseErrorHandler | boolean;
+  readonly validateResponses?: boolean;
 
   /**
    * Configure handling of request validation errors.
    * - `true`: Use default handler (400 with error details)
    * - `false`: Disable this handler (errors fall through to the unknown error handler)
+   * - `function`: Use custom request validation error handler
+   * @default true
+   */
+  readonly handleRequestValidationErrors?:
+    | RequestValidationErrorHandler
+    | boolean;
+
+  /**
+   * Configure handling of response validation errors.
+   * - `true`: Use default handler (500 Internal Server Error)
+   * - `false`: Disable response validation error handling (return response as-is)
+   * - `function`: Use custom response validation error handler
+   * @default true
+   */
+  readonly handleResponseValidationErrors?:
+    | ResponseValidationErrorHandler
+    | boolean;
+
+  /**
+   * Configure handling of HttpResponse errors thrown by handlers.
+   * - `true`: Use default handler (returns the error as response)
+   * - `false`: Disable this handler (errors fall through to the unknown error handler)
    * - `function`: Use custom error handler
    * @default true
    */
-  readonly handleValidationErrors?: ValidationErrorHandler | boolean;
+  readonly handleHttpResponseErrors?: HttpResponseErrorHandler | boolean;
 
   /**
    * Configure handling of unknown errors.
@@ -91,8 +116,10 @@ export abstract class TypeweaverRouter<
     const {
       requestHandlers,
       validateRequests = true,
+      validateResponses = true,
       handleHttpResponseErrors = true,
-      handleValidationErrors = true,
+      handleRequestValidationErrors = true,
+      handleResponseValidationErrors = true,
       handleUnknownErrors = true,
     } = options;
 
@@ -100,8 +127,10 @@ export abstract class TypeweaverRouter<
 
     this.errorConfig = {
       validateRequests,
+      validateResponses,
       handleHttpResponseErrors,
-      handleValidationErrors,
+      handleRequestValidationErrors,
+      handleResponseValidationErrors,
       handleUnknownErrors,
     };
   }
@@ -113,20 +142,23 @@ export abstract class TypeweaverRouter<
    * @param method - HTTP method (GET, POST, PUT, DELETE, etc.)
    * @param path - Path pattern with `:param` placeholders
    * @param validator - Request validator for this operation
+   * @param responseValidator - Response validator for this operation
    * @param handler - Type-safe request handler
    */
   protected route(
     operationId: string,
     method: HttpMethod,
     path: string,
-    validator: IRequestValidator,
+    requestValidator: IRequestValidator,
+    responseValidator: IResponseValidator,
     handler: RequestHandler<any, any, any>
   ): void {
     this.routes.push({
       operationId,
       method,
       path,
-      validator,
+      requestValidator,
+      responseValidator,
       handler,
       routerConfig: this.errorConfig,
     });

package/dist/lib/index.ts

@@ -15,9 +15,10 @@ export {
 export { HttpMethod } from "@rexeus/typeweaver-core";
 export type {
   HttpResponseErrorHandler,
+  RequestValidationErrorHandler,
+  ResponseValidationErrorHandler,
   RouteMetadata,
   UnknownErrorHandler,
-  ValidationErrorHandler,
 } from "./Router";
 export type { ServerContext } from "./ServerContext";
 export type { RequestHandler } from "./RequestHandler";

package/dist/templates/Router.ejs

@@ -11,6 +11,7 @@ import { HttpMethod, TypeweaverRouter, type RequestHandler, type TypeweaverRoute
 import type { I<%- operation.className %>Request } from "./<%- operation.className %>Request";
 import { <%- operation.className %>RequestValidator } from "./<%- operation.className %>RequestValidator";
 import type { <%- operation.className %>Response } from "./<%- operation.className %>Response";
+import { <%- operation.className %>ResponseValidator } from "./<%- operation.className %>ResponseValidator";
 <% } %>
 
 export type Server<%- pascalCaseEntityName %>ApiHandler<
@@ -36,6 +37,7 @@ export class <%- pascalCaseEntityName %>Router<
       HttpMethod.<%- operation.method %>,
       '<%- operation.path %>',
       new <%- operation.className %>RequestValidator(),
+      new <%- operation.className %>ResponseValidator(),
       this.requestHandlers.<%- operation.handlerName %>.bind(this.requestHandlers)
     );
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rexeus/typeweaver-server",
-  "version": "0.7.0",
+  "version": "0.8.0",
   "description": "Generates a lightweight, dependency-free server with built-in routing and middleware from your API definitions. Powered by Typeweaver.",
   "type": "module",
   "sideEffects": false,
@@ -47,21 +47,21 @@
   },
   "homepage": "https://github.com/rexeus/typeweaver#readme",
   "peerDependencies": {
-    "@rexeus/typeweaver-core": "^0.7.0",
-    "@rexeus/typeweaver-gen": "^0.7.0"
+    "@rexeus/typeweaver-gen": "^0.8.0",
+    "@rexeus/typeweaver-core": "^0.8.0"
   },
   "devDependencies": {
     "get-port": "^7.1.0",
     "test-utils": "file:../test-utils",
     "tsx": "^4.21.0",
-    "@rexeus/typeweaver-core": "^0.7.0",
-    "@rexeus/typeweaver-gen": "^0.7.0"
+    "@rexeus/typeweaver-core": "^0.8.0",
+    "@rexeus/typeweaver-gen": "^0.8.0"
   },
   "dependencies": {
     "case": "^1.6.3"
   },
   "scripts": {
-    "typecheck": "tsc --noEmit",
+    "typecheck": "tsc --noEmit -p tsconfig.typecheck.json",
     "format": "oxfmt",
     "build": "tsdown && mkdir -p ./dist/templates ./dist/lib && cp -r ./src/templates/* ./dist/templates/ && cp -r ./src/lib/* ./dist/lib/ && cp ../../LICENSE ../../NOTICE ./dist/",
     "test": "vitest --run",