@rexeus/typeweaver-types 0.10.0 → 0.10.1

package/dist/lib/RequestValidator.js

@@ -1,19 +1,25 @@
+/**
+ * This file was automatically generated by typeweaver.
+ * DO NOT EDIT. Instead, modify the source definition file and generate again.
+ *
+ * @generated by @rexeus/typeweaver
+ */
 import { Validator } from "./Validator";
 /**
-* Abstract base class for HTTP request validation.
-*
-* This class provides the foundation for request validators that:
-* - Validate headers, body, query parameters, and path parameters
-* - Support both safe (non-throwing) and unsafe (throwing) validation
-* - Integrate with Zod schemas for runtime validation
-* - Provide detailed error information for debugging
-*
-* Implementations should validate all request components and either:
-* - Return validated data (for `validate`)
-* - Return success/error result (for `safeValidate`)
-*/
+ * Abstract base class for HTTP request validation.
+ *
+ * This class provides the foundation for request validators that:
+ * - Validate headers, body, query parameters, and path parameters
+ * - Support both safe (non-throwing) and unsafe (throwing) validation
+ * - Integrate with Zod schemas for runtime validation
+ * - Provide detailed error information for debugging
+ *
+ * Implementations should validate all request components and either:
+ * - Return validated data (for `validate`)
+ * - Return success/error result (for `safeValidate`)
+ */
 export class RequestValidator extends Validator {
-	constructor() {
-		super();
-	}
+    constructor() {
+        super();
+    }
 }

package/dist/lib/ResponseValidator.js

@@ -1,101 +1,102 @@
+/**
+ * This file was automatically generated by typeweaver.
+ * DO NOT EDIT. Instead, modify the source definition file and generate again.
+ *
+ * @generated by @rexeus/typeweaver
+ */
 import { ResponseValidationError } from "@rexeus/typeweaver-core";
 import { Validator } from "./Validator";
 /**
-* Abstract base class for HTTP response validation.
-*
-* This class provides the foundation for response validators that:
-* - Validate response status codes match expected values
-* - Validate response headers and body against schemas
-* - Support both safe (non-throwing) and unsafe (throwing) validation
-* - Integrate with Zod schemas for runtime validation
-*
-* 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.
-*/
+ * Abstract base class for HTTP response validation.
+ *
+ * This class provides the foundation for response validators that:
+ * - Validate response status codes match expected values
+ * - Validate response headers and body against schemas
+ * - Support both safe (non-throwing) and unsafe (throwing) validation
+ * - Integrate with Zod schemas for runtime validation
+ *
+ * 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 {
-	/**
-	* 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)
-	* @param bodySchema - Zod schema for body validation (optional)
-	* @returns Function that validates response and returns result
-	*/
-	validateResponseType(responseName, headerSchema, bodySchema) {
-		return (response, error) => {
-			let isValid = true;
-			const validatedResponse = {
-				type: responseName,
-				statusCode: response.statusCode,
-				header: undefined,
-				body: undefined
-			};
-			if (bodySchema) {
-				const validateBodyResult = bodySchema.safeParse(response.body);
-				if (!validateBodyResult.success) {
-					error.addBodyIssues(responseName, validateBodyResult.error.issues);
-					isValid = false;
-				} else {
-					validatedResponse.body = validateBodyResult.data;
-				}
-			}
-			if (headerSchema) {
-				const coercedHeader = this.coerceHeaderToSchema(response.header, this.getSchema(headerSchema));
-				const validateHeaderResult = headerSchema.safeParse(coercedHeader);
-				if (!validateHeaderResult.success) {
-					error.addHeaderIssues(responseName, validateHeaderResult.error.issues);
-					isValid = false;
-				} else {
-					validatedResponse.header = validateHeaderResult.data;
-				}
-			}
-			if (!isValid) {
-				return {
-					isValid: false,
-					error
-				};
-			}
-			return {
-				isValid: true,
-				data: validatedResponse
-			};
-		};
-	}
+    /**
+     * 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)
+     * @param bodySchema - Zod schema for body validation (optional)
+     * @returns Function that validates response and returns result
+     */
+    validateResponseType(responseName, headerSchema, bodySchema) {
+        return (response, error) => {
+            let isValid = true;
+            const validatedResponse = {
+                type: responseName,
+                statusCode: response.statusCode,
+                header: undefined,
+                body: undefined,
+            };
+            if (bodySchema) {
+                const validateBodyResult = bodySchema.safeParse(response.body);
+                if (!validateBodyResult.success) {
+                    error.addBodyIssues(responseName, validateBodyResult.error.issues);
+                    isValid = false;
+                }
+                else {
+                    validatedResponse.body = validateBodyResult.data;
+                }
+            }
+            if (headerSchema) {
+                const coercedHeader = this.coerceHeaderToSchema(response.header, this.getSchema(headerSchema));
+                const validateHeaderResult = headerSchema.safeParse(coercedHeader);
+                if (!validateHeaderResult.success) {
+                    error.addHeaderIssues(responseName, validateHeaderResult.error.issues);
+                    isValid = false;
+                }
+                else {
+                    validatedResponse.header = validateHeaderResult.data;
+                }
+            }
+            if (!isValid) {
+                return { isValid: false, error };
+            }
+            return { isValid: true, data: validatedResponse };
+        };
+    }
 }

package/dist/lib/Validator.js

@@ -1,185 +1,198 @@
+/**
+ * This file was automatically generated by typeweaver.
+ * DO NOT EDIT. Instead, modify the source definition file and generate again.
+ *
+ * @generated by @rexeus/typeweaver
+ */
 import z from "zod";
 import { $ZodArray, $ZodOptional } from "zod/v4/core";
 /**
-* Abstract base class for HTTP validation.
-*
-* This class provides the foundation for request and response validators that:
-* - Analyze Zod schemas for correct single/multi value handling of headers and query parameters
-* - Coerce objects to match schema expectations
-*/
+ * Abstract base class for HTTP validation.
+ *
+ * This class provides the foundation for request and response validators that:
+ * - Analyze Zod schemas for correct single/multi value handling of headers and query parameters
+ * - Coerce objects to match schema expectations
+ */
 export class Validator {
-	static schemaCacheCaseSensitive = new WeakMap();
-	static schemaCacheCaseInsensitive = new WeakMap();
-	/**
-	* Analyzes a Zod schema shape to create an efficient lookup map.
-	* Results are cached using WeakMap for optimal performance.
-	*
-	* @param shape - The Zod schema shape to analyze
-	* @param caseSensitive - Whether to preserve key casing (true) or normalize to lowercase (false)
-	* @returns Map with lookup keys pointing to original key and array type information
-	*/
-	analyzeSchema(shape, caseSensitive) {
-		const cache = caseSensitive ? Validator.schemaCacheCaseSensitive : Validator.schemaCacheCaseInsensitive;
-		const cached = cache.get(shape);
-		if (cached) {
-			return cached;
-		}
-		const schemaMap = this.buildSchemaMap(shape, caseSensitive);
-		cache.set(shape, schemaMap);
-		return schemaMap;
-	}
-	/**
-	*
-	* Extracts a Zod schema shape from header or query schemas.
-	* This is used to support schema coercion and analysis.
-	*
-	* @param headerSchema
-	* @returns
-	*/
-	getSchema(headerSchema) {
-		if (headerSchema instanceof z.ZodObject) {
-			return headerSchema.shape;
-		}
-		if (headerSchema instanceof z.ZodOptional) {
-			const unwrapped = headerSchema.unwrap();
-			if (unwrapped instanceof z.ZodObject) {
-				return unwrapped.shape;
-			}
-		}
-		return {};
-	}
-	/**
-	* Builds a schema map by analyzing the Zod shape structure.
-	* Extracts type information for each field to support proper coercion.
-	*/
-	buildSchemaMap(shape, caseSensitive) {
-		const schemaMap = new Map();
-		for (const [key, zodType] of Object.entries(shape)) {
-			if (!zodType) continue;
-			const isArray = zodType instanceof $ZodArray || zodType instanceof $ZodOptional && zodType._zod.def.innerType instanceof $ZodArray;
-			const lookupKey = caseSensitive ? key : key.toLowerCase();
-			schemaMap.set(lookupKey, {
-				originalKey: key,
-				isArray
-			});
-		}
-		return schemaMap;
-	}
-	/**
-	* Coerces objects to match schema expectations with configurable case sensitivity.
-	* Values not in the schema are ignored.
-	*
-	* @param data - The data object to coerce
-	* @param shape - The Zod schema shape to match against
-	* @param caseSensitive - Whether keys should match exactly (true) or case-insensitively (false)
-	* @returns Coerced data object with proper key casing and array coercion
-	*/
-	coerceToSchema(data, shape, caseSensitive) {
-		if (typeof data !== "object" || data === null) {
-			return data;
-		}
-		const schemaMap = this.analyzeSchema(shape, caseSensitive);
-		const coerced = {};
-		for (const [key, value] of Object.entries(data)) {
-			const normalizedKey = caseSensitive ? key : key.toLowerCase();
-			const schemaInfo = schemaMap.get(normalizedKey);
-			if (schemaInfo) {
-				this.addValueToCoerced(coerced, normalizedKey, value, schemaInfo.isArray);
-			}
-		}
-		// If case-sensitive, return coerced object as is
-		if (caseSensitive) {
-			return coerced;
-		}
-		// If case-insensitive, map back to original keys from schema
-		return this.mapToOriginalKeys(coerced, schemaMap);
-	}
-	/**
-	* Adds a value to the coerced object, handling collisions when multiple
-	* values exist for the same key (e.g., duplicate headers with different casing).
-	* Preserves all values as arrays when collisions occur to prevent data loss.
-	*/
-	addValueToCoerced(coerced, key, value, expectsArray) {
-		const existing = coerced[key];
-		const newValue = this.coerceValueStructure(value, expectsArray);
-		if (existing === undefined) {
-			coerced[key] = newValue;
-			return;
-		}
-		// Merge existing and new values
-		const existingArray = Array.isArray(existing) ? existing : [existing];
-		const newArray = Array.isArray(newValue) ? newValue : [newValue];
-		const merged = [...existingArray, ...newArray];
-		// If schema expects a single value but we have multiple, preserve as array
-		// to avoid data loss (validation will catch this later)
-		coerced[key] = expectsArray || merged.length > 1 ? merged : merged[0];
-	}
-	/**
-	* Coerces a value's structure to match schema expectations.
-	* Wraps single values in arrays when schema expects array type,
-	* unwraps single-element arrays when schema expects single value.
-	*/
-	coerceValueStructure(value, expectsArray) {
-		if (expectsArray && !Array.isArray(value)) {
-			return [value];
-		}
-		if (!expectsArray && Array.isArray(value) && value.length === 1) {
-			return value[0];
-		}
-		return value;
-	}
-	/**
-	* Maps normalized (lowercase) keys back to their original casing as defined in the schema.
-	* Used for case-insensitive matching where the output should preserve schema-defined casing.
-	*/
-	mapToOriginalKeys(coerced, schemaMap) {
-		const withOriginalKeys = {};
-		for (const [key, value] of Object.entries(coerced)) {
-			const originalKey = schemaMap.get(key)?.originalKey ?? key;
-			withOriginalKeys[originalKey] = value;
-		}
-		return withOriginalKeys;
-	}
-	/**
-	* Coerces header data to match schema expectations with case-insensitive matching.
-	*
-	* @param header - The header object to coerce
-	* @param shape - The Zod schema shape for headers
-	* @returns Coerced header object
-	*/
-	coerceHeaderToSchema(header, shape) {
-		if (typeof header !== "object" || header === null) {
-			return this.coerceToSchema(header ?? {}, shape, false);
-		}
-		const preprocessed = this.splitCommaDelimitedValues(header, shape);
-		return this.coerceToSchema(preprocessed, shape, false);
-	}
-	/**
-	* Splits comma-separated header strings into arrays per RFC 7230.
-	* Only applies to fields where the schema expects an array type.
-	* Values that are already arrays pass through unchanged.
-	*/
-	splitCommaDelimitedValues(header, shape) {
-		const schemaMap = this.analyzeSchema(shape, false);
-		const result = {};
-		for (const [key, value] of Object.entries(header)) {
-			const schemaInfo = schemaMap.get(key.toLowerCase());
-			if (schemaInfo?.isArray && typeof value === "string") {
-				result[key] = value.split(",").map((v) => v.trim()).filter((v) => v !== "");
-			} else {
-				result[key] = value;
-			}
-		}
-		return result;
-	}
-	/**
-	* Coerces query data to match schema expectations with case-sensitive matching.
-	*
-	* @param query - The query object to coerce
-	* @param shape - The Zod schema shape for query parameters
-	* @returns Coerced query object
-	*/
-	coerceQueryToSchema(query, shape) {
-		return this.coerceToSchema(query ?? {}, shape, true);
-	}
+    static schemaCacheCaseSensitive = new WeakMap();
+    static schemaCacheCaseInsensitive = new WeakMap();
+    /**
+     * Analyzes a Zod schema shape to create an efficient lookup map.
+     * Results are cached using WeakMap for optimal performance.
+     *
+     * @param shape - The Zod schema shape to analyze
+     * @param caseSensitive - Whether to preserve key casing (true) or normalize to lowercase (false)
+     * @returns Map with lookup keys pointing to original key and array type information
+     */
+    analyzeSchema(shape, caseSensitive) {
+        const cache = caseSensitive
+            ? Validator.schemaCacheCaseSensitive
+            : Validator.schemaCacheCaseInsensitive;
+        const cached = cache.get(shape);
+        if (cached) {
+            return cached;
+        }
+        const schemaMap = this.buildSchemaMap(shape, caseSensitive);
+        cache.set(shape, schemaMap);
+        return schemaMap;
+    }
+    /**
+     *
+     * Extracts a Zod schema shape from header or query schemas.
+     * This is used to support schema coercion and analysis.
+     *
+     * @param headerSchema
+     * @returns
+     */
+    getSchema(headerSchema) {
+        if (headerSchema instanceof z.ZodObject) {
+            return headerSchema.shape;
+        }
+        if (headerSchema instanceof z.ZodOptional) {
+            const unwrapped = headerSchema.unwrap();
+            if (unwrapped instanceof z.ZodObject) {
+                return unwrapped.shape;
+            }
+        }
+        return {};
+    }
+    /**
+     * Builds a schema map by analyzing the Zod shape structure.
+     * Extracts type information for each field to support proper coercion.
+     */
+    buildSchemaMap(shape, caseSensitive) {
+        const schemaMap = new Map();
+        for (const [key, zodType] of Object.entries(shape)) {
+            if (!zodType)
+                continue;
+            const isArray = zodType instanceof $ZodArray ||
+                (zodType instanceof $ZodOptional &&
+                    zodType._zod.def.innerType instanceof $ZodArray);
+            const lookupKey = caseSensitive ? key : key.toLowerCase();
+            schemaMap.set(lookupKey, { originalKey: key, isArray });
+        }
+        return schemaMap;
+    }
+    /**
+     * Coerces objects to match schema expectations with configurable case sensitivity.
+     * Values not in the schema are ignored.
+     *
+     * @param data - The data object to coerce
+     * @param shape - The Zod schema shape to match against
+     * @param caseSensitive - Whether keys should match exactly (true) or case-insensitively (false)
+     * @returns Coerced data object with proper key casing and array coercion
+     */
+    coerceToSchema(data, shape, caseSensitive) {
+        if (typeof data !== "object" || data === null) {
+            return data;
+        }
+        const schemaMap = this.analyzeSchema(shape, caseSensitive);
+        const coerced = {};
+        for (const [key, value] of Object.entries(data)) {
+            const normalizedKey = caseSensitive ? key : key.toLowerCase();
+            const schemaInfo = schemaMap.get(normalizedKey);
+            if (schemaInfo) {
+                this.addValueToCoerced(coerced, normalizedKey, value, schemaInfo.isArray);
+            }
+            // Headers/params not in schema are ignored (strict validation)
+        }
+        // If case-sensitive, return coerced object as is
+        if (caseSensitive) {
+            return coerced;
+        }
+        // If case-insensitive, map back to original keys from schema
+        return this.mapToOriginalKeys(coerced, schemaMap);
+    }
+    /**
+     * Adds a value to the coerced object, handling collisions when multiple
+     * values exist for the same key (e.g., duplicate headers with different casing).
+     * Preserves all values as arrays when collisions occur to prevent data loss.
+     */
+    addValueToCoerced(coerced, key, value, expectsArray) {
+        const existing = coerced[key];
+        const newValue = this.coerceValueStructure(value, expectsArray);
+        if (existing === undefined) {
+            coerced[key] = newValue;
+            return;
+        }
+        // Merge existing and new values
+        const existingArray = Array.isArray(existing) ? existing : [existing];
+        const newArray = Array.isArray(newValue) ? newValue : [newValue];
+        const merged = [...existingArray, ...newArray];
+        // If schema expects a single value but we have multiple, preserve as array
+        // to avoid data loss (validation will catch this later)
+        coerced[key] = expectsArray || merged.length > 1 ? merged : merged[0];
+    }
+    /**
+     * Coerces a value's structure to match schema expectations.
+     * Wraps single values in arrays when schema expects array type,
+     * unwraps single-element arrays when schema expects single value.
+     */
+    coerceValueStructure(value, expectsArray) {
+        if (expectsArray && !Array.isArray(value)) {
+            return [value];
+        }
+        if (!expectsArray && Array.isArray(value) && value.length === 1) {
+            return value[0];
+        }
+        return value;
+    }
+    /**
+     * Maps normalized (lowercase) keys back to their original casing as defined in the schema.
+     * Used for case-insensitive matching where the output should preserve schema-defined casing.
+     */
+    mapToOriginalKeys(coerced, schemaMap) {
+        const withOriginalKeys = {};
+        for (const [key, value] of Object.entries(coerced)) {
+            const originalKey = schemaMap.get(key)?.originalKey ?? key;
+            withOriginalKeys[originalKey] = value;
+        }
+        return withOriginalKeys;
+    }
+    /**
+     * Coerces header data to match schema expectations with case-insensitive matching.
+     *
+     * @param header - The header object to coerce
+     * @param shape - The Zod schema shape for headers
+     * @returns Coerced header object
+     */
+    coerceHeaderToSchema(header, shape) {
+        if (typeof header !== "object" || header === null) {
+            return this.coerceToSchema(header ?? {}, shape, false);
+        }
+        const preprocessed = this.splitCommaDelimitedValues(header, shape);
+        return this.coerceToSchema(preprocessed, shape, false);
+    }
+    /**
+     * Splits comma-separated header strings into arrays per RFC 7230.
+     * Only applies to fields where the schema expects an array type.
+     * Values that are already arrays pass through unchanged.
+     */
+    splitCommaDelimitedValues(header, shape) {
+        const schemaMap = this.analyzeSchema(shape, false);
+        const result = {};
+        for (const [key, value] of Object.entries(header)) {
+            const schemaInfo = schemaMap.get(key.toLowerCase());
+            if (schemaInfo?.isArray && typeof value === "string") {
+                result[key] = value
+                    .split(",")
+                    .map(v => v.trim())
+                    .filter(v => v !== "");
+            }
+            else {
+                result[key] = value;
+            }
+        }
+        return result;
+    }
+    /**
+     * Coerces query data to match schema expectations with case-sensitive matching.
+     *
+     * @param query - The query object to coerce
+     * @param shape - The Zod schema shape for query parameters
+     * @returns Coerced query object
+     */
+    coerceQueryToSchema(query, shape) {
+        return this.coerceToSchema(query ?? {}, shape, true); // case-sensitive
+    }
 }

package/dist/lib/definitionLookup.js

@@ -1,14 +1,20 @@
+/**
+ * This file was automatically generated by typeweaver.
+ * DO NOT EDIT. Instead, modify the source definition file and generate again.
+ *
+ * @generated by @rexeus/typeweaver
+ */
 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;
+    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;
+    const response = responses.find(candidate => candidate.name === responseName);
+    if (response === undefined) {
+        throw new Error(`Missing response definition '${String(responseName)}'.`);
+    }
+    return response;
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rexeus/typeweaver-types",
-  "version": "0.10.0",
+  "version": "0.10.1",
   "description": "Generates request and response types plus validators aligned with your API contract. Powered by Typeweaver 🧵✨",
   "type": "module",
   "sideEffects": false,
@@ -47,22 +47,21 @@
   },
   "homepage": "https://github.com/rexeus/typeweaver#readme",
   "peerDependencies": {
-    "@rexeus/typeweaver-core": "^0.10.0",
-    "@rexeus/typeweaver-gen": "^0.10.0"
+    "@rexeus/typeweaver-core": "^0.10.1",
+    "@rexeus/typeweaver-gen": "^0.10.1"
   },
   "devDependencies": {
-    "oxc-transform": "^0.121.0",
     "test-utils": "file:../test-utils",
-    "@rexeus/typeweaver-core": "^0.10.0",
-    "@rexeus/typeweaver-gen": "^0.10.0"
+    "@rexeus/typeweaver-gen": "^0.10.1",
+    "@rexeus/typeweaver-core": "^0.10.1"
   },
   "dependencies": {
-    "@rexeus/typeweaver-zod-to-ts": "^0.10.0"
+    "@rexeus/typeweaver-zod-to-ts": "^0.10.1"
   },
   "scripts": {
     "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/",
+    "build": "tsdown",
     "test": "vitest --run",
     "preversion": "npm run build"
   }