@rexeus/typeweaver-types 0.7.0 → 0.9.0

package/dist/lib/ResponseValidator.d.ts

@@ -1,23 +1,37 @@
 import type {
+  HttpBodySchema,
+  HttpHeaderSchema,
   IHttpResponse,
   IResponseValidator,
+  ITypedHttpResponse,
   ResponseValidationError,
   SafeResponseValidationResult,
 } from "@rexeus/typeweaver-core";
 import { Validator } from "./Validator";
 
-export declare abstract class ResponseValidator
+export type ResponseEntry = {
+  readonly name: string;
+  readonly statusCode: number;
+  readonly headerSchema: HttpHeaderSchema | undefined;
+  readonly bodySchema: HttpBodySchema | undefined;
+};
+
+export declare abstract class ResponseValidator<
+  TResponse extends ITypedHttpResponse = ITypedHttpResponse,
+>
   extends Validator
   implements IResponseValidator
 {
-  public abstract safeValidate(
+  protected abstract readonly responseEntries: readonly ResponseEntry[];
+  protected abstract readonly expectedStatusCodes: readonly number[];
+  public safeValidate(
     response: IHttpResponse
-  ): SafeResponseValidationResult<IHttpResponse>;
-  public abstract validate(response: IHttpResponse): IHttpResponse;
-  protected validateResponseType<Response extends IHttpResponse>(
+  ): SafeResponseValidationResult<TResponse>;
+  public validate(response: IHttpResponse): TResponse;
+  protected validateResponseType<Response extends ITypedHttpResponse>(
     responseName: string,
-    headerSchema: unknown,
-    bodySchema: unknown
+    headerSchema: HttpHeaderSchema | undefined,
+    bodySchema: HttpBodySchema | undefined
   ): (
     response: IHttpResponse,
     error: ResponseValidationError

package/dist/lib/ResponseValidator.js

@@ -1,3 +1,4 @@
+import { ResponseValidationError } from "@rexeus/typeweaver-core";
 import { Validator } from "./Validator";
 /**
 * Abstract base class for HTTP response validation.
@@ -10,11 +11,47 @@ import { Validator } from "./Validator";
 *
 * Response validators are typically used in API clients to ensure
 * responses match the expected format before processing.
+*
+* Subclasses provide response metadata via `responseEntries` and
+* `expectedStatusCodes`. All validation logic lives in this base class.
 */
 export class ResponseValidator extends Validator {
 	/**
-	* Generic response validation method that validates header and body schemas.
-	* This method reduces code duplication across individual response validators.
+	* Validates a response without throwing errors.
+	*
+	* @param response - The HTTP response to validate
+	* @returns A result object containing either the validated response or error details
+	*/
+	safeValidate(response) {
+		const error = new ResponseValidationError(response.statusCode);
+		for (const entry of this.responseEntries) {
+			if (response.statusCode === entry.statusCode) {
+				const result = this.validateResponseType(entry.name, entry.headerSchema, entry.bodySchema)(response, error);
+				if (result.isValid) return result;
+			}
+		}
+		if (!error.hasResponseIssues()) {
+			error.addStatusCodeIssue([...this.expectedStatusCodes]);
+		}
+		return {
+			isValid: false,
+			error
+		};
+	}
+	/**
+	* Validates a response and throws if validation fails.
+	*
+	* @param response - The HTTP response to validate
+	* @returns The validated response with proper typing
+	* @throws {ResponseValidationError} If response structure fails validation
+	*/
+	validate(response) {
+		const result = this.safeValidate(response);
+		if (!result.isValid) throw result.error;
+		return result.data;
+	}
+	/**
+	* Validates a single response variant against its header and body schemas.
 	*
 	* @param responseName - Name of the response type for error reporting
 	* @param headerSchema - Zod schema for header validation (optional)
@@ -25,6 +62,7 @@ export class ResponseValidator extends Validator {
 		return (response, error) => {
 			let isValid = true;
 			const validatedResponse = {
+				type: responseName,
 				statusCode: response.statusCode,
 				header: undefined,
 				body: undefined

package/dist/lib/definitionLookup.d.ts

@@ -0,0 +1,29 @@
+import type {
+  ResponseDefinition,
+  SpecDefinition,
+} from "@rexeus/typeweaver-core";
+
+type MatchedOperationDefinition<
+  TSpec extends SpecDefinition,
+  TResourceName extends keyof TSpec["resources"] & string,
+> = NonNullable<TSpec["resources"][TResourceName]>["operations"][number];
+
+type MatchedResponseDefinition<
+  TResponses extends readonly ResponseDefinition[],
+> = TResponses[number];
+
+export declare const getOperationDefinition: <
+  TSpec extends SpecDefinition,
+  TResourceName extends keyof TSpec["resources"] & string,
+>(
+  spec: TSpec,
+  resourceName: TResourceName,
+  operationId: string
+) => MatchedOperationDefinition<TSpec, TResourceName>;
+
+export declare const getResponseDefinition: <
+  TResponses extends readonly ResponseDefinition[],
+>(
+  responses: TResponses,
+  responseName: string
+) => MatchedResponseDefinition<TResponses>;

package/dist/lib/definitionLookup.js

@@ -0,0 +1,14 @@
+export const getOperationDefinition = (spec, resourceName, operationId) => {
+	const operation = spec.resources[resourceName]?.operations.find((candidate) => candidate.operationId === operationId);
+	if (operation === undefined) {
+		throw new Error(`Missing operation definition '${String(resourceName)}.${String(operationId)}'.`);
+	}
+	return operation;
+};
+export const getResponseDefinition = (responses, responseName) => {
+	const response = responses.find((candidate) => candidate.name === responseName);
+	if (response === undefined) {
+		throw new Error(`Missing response definition '${String(responseName)}'.`);
+	}
+	return response;
+};

package/dist/lib/index.ts

@@ -5,7 +5,7 @@
  * @generated by @rexeus/typeweaver
  */
 
-export * from "./assert";
+export * from "./definitionLookup";
 export * from "./RequestValidator";
 export * from "./ResponseValidator";
 export * from "./Validator";

package/dist/templates/Request.ejs

@@ -7,18 +7,6 @@
  */
 
 import { HttpMethod } from "@rexeus/typeweaver-core";
-import {
-    type <%= pascalCaseOperationId %>Response,
-    <% for (const ownResponse of ownErrorResponses) { %>
-        <%= ownResponse.name %>Response,
-    <% } %>
-} from "<%= responseFile %>";
-<% for (const sharedError of sharedErrorResponses) { %>
-import { <%= sharedError.name %>Response } from "<%= sharedError.path %>";
-<% } %>
-<% for (const entityError of entityErrorResponses) { %>
-import { <%= entityError.name %>Response } from "<%= entityError.path %>";
-<% } %>
 
 <% if (headerTsType) { %>
 export type I<%= pascalCaseOperationId %>RequestHeader = <%- headerTsType %>
@@ -45,15 +33,3 @@ export type I<%= pascalCaseOperationId %>Request = {
     <%= bodyTsType ? `body: I${pascalCaseOperationId}RequestBody;` : "" %>
 };
 
-<% if (!hasSuccessResponses) { %>
-    export type Successful<%= pascalCaseOperationId %>Response = never;
-<% } else if (!hasErrorResponses) { %>
-    export type Successful<%= pascalCaseOperationId %>Response = <%= pascalCaseOperationId %>Response;
-<% } else { %>
-    export type Successful<%= pascalCaseOperationId %>Response = Exclude<<%= pascalCaseOperationId %>Response, <%= [
-        ...sharedErrorResponses,
-        ...ownErrorResponses,
-        ...entityErrorResponses,
-    ].map(({ name }) => `${name}Response`).join(" | ") %>
-    >;
-<% } %>

package/dist/templates/RequestValidator.ejs

@@ -6,15 +6,17 @@
  * @generated by @rexeus/typeweaver
  */
 
-import definition from "<%= sourcePath %>";
+import spec from "<%= specPath %>";
 import { 
   type IHttpRequest,
   type SafeRequestValidationResult,
   RequestValidationError
 } from "@rexeus/typeweaver-core";
-import { RequestValidator } from "../lib/types";
+import { getOperationDefinition, RequestValidator } from "../lib/types";
 import type { I<%= pascalCaseOperationId %>Request } from "<%= requestFile %>";
 
+const definition = getOperationDefinition(spec, "<%= resourceName %>", "<%= operationId %>");
+
 export class <%= pascalCaseOperationId %>RequestValidator extends RequestValidator {
     public safeValidate(request: IHttpRequest): SafeRequestValidationResult<I<%= pascalCaseOperationId %>Request> {
         const error = new RequestValidationError();
@@ -41,17 +43,13 @@ export class <%= pascalCaseOperationId %>RequestValidator extends RequestValidat
 
         <% if(header) { %>
             if (definition.request.header) {
-                <% if(header instanceof z.ZodObject) { %>
-                const coercedHeader = this.coerceHeaderToSchema(request.header, definition.request.header.shape);
-                <% } else { %>
-                const coercedHeader = this.coerceHeaderToSchema(request.header, definition.request.header.unwrap().shape);
-                <% } %>  
+                const coercedHeader = this.coerceHeaderToSchema(request.header, this.getSchema(definition.request.header));
                 const result = definition.request.header.safeParse(coercedHeader);
           
                 if (!result.success) {
                   error.addHeaderIssues(result.error.issues);
                 } else {
-                  validatedRequest.header = result.data;
+                  validatedRequest.header = result.data as IHttpRequest["header"];
                 }
             }
         <% } %>
@@ -70,17 +68,13 @@ export class <%= pascalCaseOperationId %>RequestValidator extends RequestValidat
 
         <% if(query) { %>
             if (definition.request.query) {
-                <% if(query instanceof z.ZodObject) { %>
-                const coercedQuery = this.coerceQueryToSchema(request.query, definition.request.query.shape);
-                <% } else { %>
-                const coercedQuery = this.coerceQueryToSchema(request.query, definition.request.query.unwrap().shape);
-                <% } %>
+                const coercedQuery = this.coerceQueryToSchema(request.query, this.getSchema(definition.request.query));
                 const result = definition.request.query.safeParse(coercedQuery);
           
                 if (!result.success) {
                   error.addQueryIssues(result.error.issues);
                 } else {
-                  validatedRequest.query = result.data;
+                  validatedRequest.query = result.data as IHttpRequest["query"];
                 }
             }
         <% } %>
@@ -107,4 +101,4 @@ export class <%= pascalCaseOperationId %>RequestValidator extends RequestValidat
     
         return result.data;
       }
-}
+}

package/dist/templates/Response.ejs

@@ -6,12 +6,15 @@
  * @generated by @rexeus/typeweaver
  */
 
-import { HttpResponse, HttpStatusCode } from "<%= coreDir %>";
+<% if (ownResponses.length > 0) { %>
+import { HttpStatusCode } from "<%= coreDir %>";
+import type { ITypedHttpResponse } from "<%= coreDir %>";
+<% } %>
 <% for (const shared of sharedResponses) { %>
-import type { I<%= shared.name %>Response, <%= shared.name %>Response } from "<%= shared.path %>";
+import type { I<%= shared.name %>Response } from "<%= shared.path %>";
 <% } %>
 <% for(const entityResponse of entityResponses) { %>
-import type { I<%= entityResponse.name %>Response, <%= entityResponse.name %>Response } from "<%= entityResponse.path %>";
+import type { I<%= entityResponse.name %>Response } from "<%= entityResponse.path %>";
 <% } %>
 
 <% for (const ownResponse of ownResponses) { %>
@@ -23,60 +26,28 @@ import type { I<%= entityResponse.name %>Response, <%= entityResponse.name %>Res
         export type I<%= ownResponse.name %>ResponseBody = <%- ownResponse.body %>;
     <% } %>
 
-
-    export type I<%= ownResponse.name %>Response =  {
-            statusCode: HttpStatusCode.<%= ownResponse.statusCodeKey %>
-            <%= ownResponse.header ? `header: I${ownResponse.name}ResponseHeader;` : "" %>
-            <%= ownResponse.body ? `body: I${ownResponse.name}ResponseBody;` : "" %>
-            };
-
-    export class <%= ownResponse.name %>Response extends HttpResponse<
+    export type I<%= ownResponse.name %>Response = ITypedHttpResponse<
+            "<%= ownResponse.name %>",
+            HttpStatusCode.<%= ownResponse.statusCodeKey %>,
             <%= ownResponse.header ? `I${ownResponse.name}ResponseHeader` : 'undefined' %>,
             <%= ownResponse.body ? `I${ownResponse.name}ResponseBody` : 'undefined' %>
-            > implements I<%= ownResponse.name %>Response {
-        public override readonly statusCode = HttpStatusCode.<%= ownResponse.statusCodeKey %>;
+            >;
 
 <% if (ownResponse.header || ownResponse.body) { %>
-        public constructor(response: Omit<I<%= ownResponse.name %>Response, "statusCode">) {
-            super(
-                HttpStatusCode.<%= ownResponse.statusCodeKey %>,
-                <%= ownResponse.header ? `response.header` : 'undefined' %>,
-                <%= ownResponse.body ? `response.body` : 'undefined' %>,
-            );
-        }
+    export const create<%= ownResponse.name %>Response = (input: Omit<I<%= ownResponse.name %>Response, "type" | "statusCode">): I<%= ownResponse.name %>Response => ({
+        ...input,
+        type: "<%= ownResponse.name %>",
+        statusCode: HttpStatusCode.<%= ownResponse.statusCodeKey %>,
+    });
 <% } else { %>
-        public constructor() {
-            super(
-                HttpStatusCode.<%= ownResponse.statusCodeKey %>,
-                undefined,
-                undefined,
-            );
-        }
-<% } %>
-    }
+    export const create<%= ownResponse.name %>Response = (): I<%= ownResponse.name %>Response => ({
+        type: "<%= ownResponse.name %>",
+        statusCode: HttpStatusCode.<%= ownResponse.statusCodeKey %>,
+    });
 <% } %>
-
-<%
-// Identify success responses (status codes 200-299)
-const successResponses = ownResponses.filter(response => response.statusCode >= 200 && response.statusCode < 300);
-const errorResponses = ownResponses.filter(response => response.statusCode < 200 || response.statusCode >= 300);
-%>
-
-<% if (successResponses.length > 0) { %>
-export type I<%= pascalCaseOperationId %>SuccessResponses =<% if (successResponses.length === 1) { %> I<%= successResponses[0].name %>Response;<% } else { %>
-<% for (const [index, successResponse] of successResponses.entries()) { %>
-<% if (index === 0) { %>    I<%= successResponse.name %>Response<% } else { %>
-    | I<%= successResponse.name %>Response<% } %>
-<% } %>;<% } %>
-
-export type <%= pascalCaseOperationId %>SuccessResponses =<% if (successResponses.length === 1) { %> <%= successResponses[0].name %>Response;<% } else { %>
-<% for (const [index, successResponse] of successResponses.entries()) { %>
-<% if (index === 0) { %>    <%= successResponse.name %>Response<% } else { %>
-    | <%= successResponse.name %>Response<% } %>
-<% } %>;<% } %>
 <% } %>
 
-export type I<%= pascalCaseOperationId %>Response =
+export type <%= pascalCaseOperationId %>Response =
 <% for (const ownResponse of ownResponses) { %>
     | I<%= ownResponse.name %>Response
 <% } %>
@@ -86,14 +57,3 @@ export type I<%= pascalCaseOperationId %>Response =
 <% for (const entityResponse of entityResponses) { %>
     | I<%= entityResponse.name %>Response
 <% } %>;
-
-export type <%= pascalCaseOperationId %>Response =
-<% for (const ownResponse of ownResponses) { %>
-    | <%= ownResponse.name %>Response
-<% } %>
-<% for (const shared of sharedResponses) { %>
-    | <%= shared.name %>Response
-<% } %>
-<% for (const entityResponse of entityResponses) { %>
-    | <%= entityResponse.name %>Response
-<% } %>;

package/dist/templates/ResponseValidator.ejs

@@ -2,98 +2,36 @@
 /**
  * This file was automatically generated by typeweaver.
  * DO NOT EDIT. Instead, modify the source definition file and generate again.
- * 
+ *
  * @generated by @rexeus/typeweaver
  */
 
-import definition from "<%= sourcePath %>";
-import {
-    type IHttpResponse,
-    type SafeResponseValidationResult,
-    ResponseValidationError
-} from "@rexeus/typeweaver-core";
+import spec from "<%= specPath %>";
 import {
+    getOperationDefinition,
+    getResponseDefinition,
+    type ResponseEntry,
     ResponseValidator,
 } from "../lib/types";
-import {
-type <%= pascalCaseOperationId %>Response,
-<% for (const ownResponse of ownResponses) { %>
-    type I<%= ownResponse.name %>Response,
-    <%= ownResponse.name %>Response,
+import type { <%= pascalCaseOperationId %>Response } from "<%= responseFile %>";
+
+const definition = getOperationDefinition(spec, "<%= resourceName %>", "<%= operationId %>");
+<% for (const response of [...ownResponses, ...sharedResponses]) { %>
+const <%= response.definitionVariableName %> = getResponseDefinition(
+    definition.responses,
+    "<%= response.name %>"
+);
 <% } %>
-} from "<%= responseFile %>";
-<% for (const sharedResponse of sharedResponses) { %>
-    import {
-        type I<%= sharedResponse.name %>Response,
-        <%= sharedResponse.name %>Response,
-    } from "<%= sharedResponse.importPath %>";
-<% } %>
-
-export class <%= pascalCaseOperationId %>ResponseValidator extends ResponseValidator {
-    public safeValidate(response: IHttpResponse): SafeResponseValidationResult<<%= pascalCaseOperationId %>Response> {
-        const result = this.validateAgainstDefinedResponses(response);
-
-        if(!result.isValid && !result.error.hasResponseIssues()) {
-            result.error.addStatusCodeIssue([
-                <% const sortedStatusCodes = allStatusCodes.map(statusCode => statusCode.statusCode).sort() %>
-                <% for (const statusCode of sortedStatusCodes) { %><%= statusCode %>,<% } %>
-            ]);
-        }
-
-        return result;
-    }
-
-    public validate(response: IHttpResponse): <%= pascalCaseOperationId %>Response {
-        const result = this.safeValidate(response);
-    
-        if (!result.isValid) {
-          throw result.error;
-        }
-    
-        return result.data;
-    }
 
-    private validateAgainstDefinedResponses(response: IHttpResponse): SafeResponseValidationResult<<%= pascalCaseOperationId %>Response> {
-        const error = new ResponseValidationError(response.statusCode);
-
-        <% for (const statusCode of allStatusCodes) { %>
-            if (response.statusCode === <%= statusCode.statusCode %>) {
-            <%
-            for (const response of [...ownResponses, ...sharedResponses]) {
-            if (response.statusCode === statusCode.statusCode) {
-            %>
-                const validate<%= response.name %>ResponseResult = this.validate<%= response.name %>Response(response, error);
-                if (validate<%= response.name %>ResponseResult.isValid) {
-                    return validate<%= response.name %>ResponseResult;
-                }
-            <% } } %>
-            }
+export class <%= pascalCaseOperationId %>ResponseValidator extends ResponseValidator<<%= pascalCaseOperationId %>Response> {
+    protected override readonly expectedStatusCodes = [
+        <% const sortedStatusCodes = allStatusCodes.map(statusCode => statusCode.statusCode).sort() %>
+        <% for (const statusCode of sortedStatusCodes) { %><%= statusCode %>,<% } %>
+    ];
 
+    protected override readonly responseEntries: readonly ResponseEntry[] = [
+        <% for (const response of [...ownResponses, ...sharedResponses]) { %>
+        { name: "<%= response.name %>", statusCode: <%= response.statusCode %>, headerSchema: <%= response.definitionVariableName %>.header, bodySchema: <%= response.definitionVariableName %>.body },
         <% } %>
-
-        return {
-            isValid: false,
-            error
-        };
-    }
-
-    <% for (const response of [...ownResponses, ...sharedResponses]) { %>
-    private validate<%= response.name %>Response(response: IHttpResponse, error: ResponseValidationError): SafeResponseValidationResult<<%= response.name %>Response> {
-        const result = this.validateResponseType<<%= response.name %>Response>(
-            "<%= response.name.replace(/Response$/, '') %>",
-            <% if(response.hasHeader) { %>definition.responses[<%= response.index %>] && "header" in definition.responses[<%= response.index %>] ? definition.responses[<%= response.index %>]!.header : undefined<% } else { %>undefined<% } %>,
-            <% if(response.hasBody) { %>definition.responses[<%= response.index %>] && "body" in definition.responses[<%= response.index %>] ? definition.responses[<%= response.index %>]!.body : undefined<% } else { %>undefined<% } %>,
-        )(response, error);
-
-        if (!result.isValid) {
-            return result;
-        }
-
-<% if (response.hasHeader || response.hasBody) { %>
-        return { isValid: true, data: new <%= response.name %>Response(result.data as I<%= response.name %>Response) };
-<% } else { %>
-        return { isValid: true, data: new <%= response.name %>Response() };
-<% } %>
-    }
-    <% } %>
-}
+    ];
+}

package/dist/templates/SharedResponse.ejs

@@ -2,11 +2,12 @@
 /**
  * This file was automatically generated by typeweaver.
  * DO NOT EDIT. Instead, modify the source definition file and generate again.
- * 
+ *
  * @generated by @rexeus/typeweaver
  */
 
-import { HttpResponse, HttpStatusCode } from "<%= coreDir %>";
+import { HttpStatusCode } from "<%= coreDir %>";
+import type { ITypedHttpResponse } from "<%= coreDir %>";
 
 <% if (headerTsType) { %>
     export type I<%= pascalCaseName %>ResponseHeader = <%- headerTsType %>;
@@ -16,35 +17,22 @@ import { HttpResponse, HttpStatusCode } from "<%= coreDir %>";
     export type I<%= pascalCaseName %>ResponseBody = <%- bodyTsType %>;
 <% } %>
 
-export type I<%= pascalCaseName %>Response = {
-statusCode: HttpStatusCode.<%= httpStatusCode[sharedResponse.statusCode] %>
-<%= sharedResponse.header ? `header: I${pascalCaseName}ResponseHeader;` : "" %>
-<%= sharedResponse.body ? `body: I${pascalCaseName}ResponseBody;` : "" %>
-};
-
-export class <%= pascalCaseName %>Response extends HttpResponse<
+export type I<%= pascalCaseName %>Response = ITypedHttpResponse<
+"<%= pascalCaseName %>",
+HttpStatusCode.<%= httpStatusCode[sharedResponse.statusCode] %>,
 <%= sharedResponse.header ? `I${pascalCaseName}ResponseHeader` : 'undefined' %>,
 <%= sharedResponse.body ? `I${pascalCaseName}ResponseBody` : 'undefined' %>
-> implements I<%= pascalCaseName %>Response {
-public override readonly statusCode = HttpStatusCode.<%= httpStatusCode[sharedResponse.statusCode] %>;
+>;
 
 <% if (sharedResponse.header || sharedResponse.body) { %>
-public constructor(response: Omit<I<%= pascalCaseName %>Response, "statusCode">) {
-    super(
-        HttpStatusCode.<%= httpStatusCode[sharedResponse.statusCode] %>,
-        <%= sharedResponse.header ? `response.header` : 'undefined' %>,
-        <%= sharedResponse.body ? `response.body` : 'undefined' %>,
-    );
-}
+export const create<%= pascalCaseName %>Response = (input: Omit<I<%= pascalCaseName %>Response, "type" | "statusCode">): I<%= pascalCaseName %>Response => ({
+    ...input,
+    type: "<%= pascalCaseName %>",
+    statusCode: HttpStatusCode.<%= httpStatusCode[sharedResponse.statusCode] %>,
+});
 <% } else { %>
-public constructor() {
-    super(
-        HttpStatusCode.<%= httpStatusCode[sharedResponse.statusCode] %>,
-        undefined,
-        undefined,
-    );
-}
+export const create<%= pascalCaseName %>Response = (): I<%= pascalCaseName %>Response => ({
+    type: "<%= pascalCaseName %>",
+    statusCode: HttpStatusCode.<%= httpStatusCode[sharedResponse.statusCode] %>,
+});
 <% } %>
-}
-
-

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rexeus/typeweaver-types",
-  "version": "0.7.0",
+  "version": "0.9.0",
   "description": "Generates request and response types plus validators aligned with your API contract. 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-core": "^0.9.0",
+    "@rexeus/typeweaver-gen": "^0.9.0"
   },
   "devDependencies": {
-    "oxc-transform": "^0.115.0",
+    "oxc-transform": "^0.121.0",
     "test-utils": "file:../test-utils",
-    "@rexeus/typeweaver-core": "^0.7.0",
-    "@rexeus/typeweaver-gen": "^0.7.0"
+    "@rexeus/typeweaver-core": "^0.9.0",
+    "@rexeus/typeweaver-gen": "^0.9.0"
   },
   "dependencies": {
     "case": "^1.6.3",
-    "@rexeus/typeweaver-zod-to-ts": "^0.7.0"
+    "@rexeus/typeweaver-zod-to-ts": "^0.9.0"
   },
   "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/ && node scripts/compile-lib.mjs && cp src/lib-declarations/*.d.ts dist/lib/ && cp src/lib/index.ts dist/lib/ && cp ../../LICENSE ../../NOTICE ./dist/",
     "test": "vitest --run",

package/dist/lib/assert.d.ts

@@ -1 +0,0 @@
-export declare function assert(value: unknown, message?: string): asserts value;

package/dist/lib/assert.js

@@ -1,11 +0,0 @@
-/**
-* This file was automatically generated by typeweaver.
-* DO NOT EDIT. Instead, modify the source definition file and generate again.
-*
-* @generated by @rexeus/typeweaver
-*/
-export function assert(value, message) {
-	if (!value) {
-		throw new Error(message || "Assertion failed");
-	}
-}