@rexeus/typeweaver-core 0.0.1

package/README.md

@@ -0,0 +1,162 @@
+# @rexeus/typeweaver-core
+
+A TypeScript library for defining type-safe HTTP APIs with runtime validation and code generation
+support.
+
+## Features
+
+- **Type-Safe API Definitions** - Define HTTP operations with complete TypeScript type inference
+- **Runtime Validation** - Zod schema integration for request/response validation
+- **Framework Adapters** - Support for AWS Lambda, Hono, and other execution contexts
+- **Client Generation Ready** - Abstract base classes designed for code generation
+- **Route Matching** - Optimized route resolution with parameter support
+- **Error Handling** - Structured validation errors with detailed issue reporting
+
+## Installation
+
+```bash
+npm install @rexeus/typeweaver-core
+```
+
+**Peer Dependencies:**
+
+```bash
+npm install zod@^3.25.0 axios@^1.9.0 hono@^4.8.0
+```
+
+> **Important:** This library requires Zod v4 features and imports from `"zod/v4"`. Make sure you
+> have a compatible Zod version installed.
+
+## Quick Start
+
+### Define API Operations
+
+```typescript
+import { z } from "zod/v4";
+import { HttpOperationDefinition, HttpStatusCode, HttpMethod } from "@rexeus/typeweaver-core";
+import { accountSchema } from "./accountSchema";
+import { sharedResponses } from "../shared/sharedResponses";
+import { defaultResponseHeader } from "../shared/defaultResponseHeader";
+import { defaultRequestHeadersWithPayload } from "../shared/defaultRequestHeader";
+
+export default new HttpOperationDefinition({
+  operationId: "RegisterAccount",
+  path: "/accounts",
+  summary: "Register new account",
+  method: HttpMethod.POST,
+  request: {
+    body: z.object({
+      email: z.email().max(256),
+      password: z.string().max(256),
+    }),
+    header: defaultRequestHeadersWithPayload.omit({
+      Authorization: true,
+    }),
+  },
+  responses: [
+    {
+      statusCode: HttpStatusCode.OK,
+      description: "Account created successfully",
+      body: accountSchema,
+      name: "RegisterAccountSuccess",
+      header: defaultResponseHeader,
+    },
+    ...sharedResponses,
+  ],
+});
+```
+
+### Framework Integration
+
+```typescript
+// AWS Lambda
+import { AwsLambdaHandler, AwsLambdaRoute } from "@rexeus/typeweaver-core";
+
+// Hono
+import { HonoHttpRequestHandler, HonoHttpRoute } from "@rexeus/typeweaver-core";
+```
+
+## Architecture
+
+This library provides a foundation for building type-safe APIs with:
+
+- **Definition Layer** - OpenAPI-style operation definitions with Zod schemas
+- **Validation Layer** - Request/response validation with detailed error reporting
+- **Router Layer** - Efficient route matching with framework adapters
+- **Client Layer** - Abstract base for generating type-safe API clients
+
+## Key Benefits
+
+### Type Safety
+
+Complete end-to-end type safety from API definition to runtime execution.
+
+### Runtime Validation
+
+Zod schemas provide both TypeScript types and runtime validation.
+
+### Code Generation Ready
+
+Abstract patterns designed for generating API clients and servers.
+
+### Performance Optimized
+
+Route matching uses preprocessing and caching for O(n) performance.
+
+### Framework Agnostic
+
+Core definitions work with any execution context via adapter pattern.
+
+## Framework Adapters
+
+TypeWeaver Core includes adapters for various runtime environments:
+
+### AWS Lambda Adapters
+
+```typescript
+import { 
+  createAwsLambdaHandler,
+  createAwsApiGatewayV1Handler,
+  createAwsApiGatewayV2Handler,
+  createAwsLambdaFunctionUrlHandler,
+  createAwsAlbHandler
+} from "@rexeus/typeweaver-core";
+```
+
+### Hono Integration
+
+```typescript
+import { 
+  createHonoHttpApiHandler,
+  HonoHttpRouter 
+} from "@rexeus/typeweaver-core";
+```
+
+### Generic HTTP Adapters
+
+```typescript
+import { 
+  HttpAdapter,
+  FetchApiAdapter 
+} from "@rexeus/typeweaver-core";
+```
+
+## Validation System
+
+Comprehensive request and response validation with structured error handling:
+
+```typescript
+import { 
+  RequestValidator,
+  ResponseValidator,
+  RequestValidationError,
+  ResponseValidationError 
+} from "@rexeus/typeweaver-core";
+
+const validator = new RequestValidator(operationDefinition);
+const result = validator.safeValidate(request);
+
+if (!result.isValid) {
+  console.error(result.error.issues);
+}
+```

package/dist/index.d.ts

@@ -0,0 +1,326 @@
+import { ZodObject, ZodString, ZodStringFormat, ZodLiteral, ZodEnum, ZodOptional, ZodArray, ZodType, z } from 'zod/v4';
+
+type IHttpHeader = Record<string, string | string[]> | undefined;
+type HttpHeaderValue = ZodString | ZodStringFormat | ZodLiteral<string> | ZodEnum<Record<string, string>>;
+type HttpHeaderSchema = ZodObject<Record<string, HttpHeaderValue | ZodOptional<HttpHeaderValue> | ZodArray<HttpHeaderValue> | ZodOptional<ZodArray<HttpHeaderValue>>>>;
+
+type IHttpParam = Record<string, string> | undefined;
+type HttpParamValue = ZodString | ZodStringFormat | ZodLiteral<string> | ZodEnum<Record<string, string>>;
+type HttpParamSchema = ZodObject<Record<string, HttpParamValue | ZodOptional<HttpParamValue>>>;
+
+type IHttpBody = any | undefined;
+type HttpBodySchema = ZodType;
+
+type IHttpQuery = Record<string, string | string[]> | undefined;
+type HttpQueryValue = ZodString | ZodStringFormat | ZodLiteral<string> | ZodEnum<Record<string, string>>;
+type HttpQuerySchema = ZodObject<Record<string, HttpQueryValue | ZodOptional<HttpQueryValue> | ZodArray<HttpQueryValue> | ZodOptional<ZodArray<HttpQueryValue>>>>;
+
+declare enum HttpMethod {
+    GET = "GET",
+    POST = "POST",
+    PUT = "PUT",
+    DELETE = "DELETE",
+    PATCH = "PATCH",
+    OPTIONS = "OPTIONS",
+    HEAD = "HEAD",
+    TRACE = "TRACE",
+    CONNECT = "CONNECT"
+}
+
+type IHttpRequest<Header extends IHttpHeader = IHttpHeader, Param extends IHttpParam = IHttpParam, Query extends IHttpQuery = IHttpQuery, Body extends IHttpBody = IHttpBody> = {
+    body?: Body;
+    query?: Query;
+    param?: Param;
+    header?: Header;
+    path: string;
+    method: HttpMethod;
+};
+
+declare enum HttpStatusCode {
+    OK = 200,
+    CREATED = 201,
+    ACCEPTED = 202,
+    NO_CONTENT = 204,
+    RESET_CONTENT = 205,
+    PARTIAL_CONTENT = 206,
+    MULTI_STATUS = 207,
+    ALREADY_REPORTED = 208,
+    IM_USED = 226,
+    BAD_REQUEST = 400,
+    UNAUTHORIZED = 401,
+    PAYMENT_REQUIRED = 402,
+    FORBIDDEN = 403,
+    NOT_FOUND = 404,
+    METHOD_NOT_ALLOWED = 405,
+    NOT_ACCEPTABLE = 406,
+    PROXY_AUTHENTICATION_REQUIRED = 407,
+    REQUEST_TIMEOUT = 408,
+    CONFLICT = 409,
+    GONE = 410,
+    LENGTH_REQUIRED = 411,
+    PRECONDITION_FAILED = 412,
+    PAYLOAD_TOO_LARGE = 413,
+    URI_TOO_LONG = 414,
+    UNSUPPORTED_MEDIA_TYPE = 415,
+    RANGE_NOT_SATISFIABLE = 416,
+    EXPECTATION_FAILED = 417,
+    IM_A_TEAPOT = 418,
+    MISDIRECTED_REQUEST = 421,
+    UNPROCESSABLE_ENTITY = 422,
+    LOCKED = 423,
+    FAILED_DEPENDENCY = 424,
+    UPGRADE_REQUIRED = 426,
+    PRECONDITION_REQUIRED = 428,
+    TOO_MANY_REQUESTS = 429,
+    REQUEST_HEADER_FIELDS_TOO_LARGE = 431,
+    UNAVAILABLE_FOR_LEGAL_REASONS = 451,
+    INTERNAL_SERVER_ERROR = 500,
+    NOT_IMPLEMENTED = 501,
+    BAD_GATEWAY = 502,
+    SERVICE_UNAVAILABLE = 503,
+    GATEWAY_TIMEOUT = 504,
+    HTTP_VERSION_NOT_SUPPORTED = 505,
+    VARIANT_ALSO_NEGOTIATES = 506,
+    INSUFFICIENT_STORAGE = 507,
+    LOOP_DETECTED = 508,
+    NOT_EXTENDED = 510,
+    NETWORK_AUTHENTICATION_REQUIRED = 511
+}
+type HttpStatusCodeNameMapKey = (typeof HttpStatusCode)[keyof typeof HttpStatusCode];
+declare const HttpStatusCodeNameMap: Record<HttpStatusCodeNameMapKey, string>;
+
+type IHttpResponse<Header extends IHttpHeader = IHttpHeader, Body extends IHttpBody = IHttpBody> = {
+    statusCode: HttpStatusCode;
+    header?: Header;
+    body?: Body;
+};
+declare class HttpResponse<Header extends IHttpHeader = IHttpHeader, Body extends IHttpBody = IHttpBody> implements IHttpResponse<Header, Body> {
+    readonly statusCode: HttpStatusCode;
+    readonly header: Header;
+    readonly body: Body;
+    constructor(statusCode: HttpStatusCode, header: Header, body: Body);
+}
+
+type IHttpRequestDefinition<THeader extends HttpHeaderSchema | undefined = HttpHeaderSchema | undefined, TParam extends HttpParamSchema | undefined = HttpParamSchema | undefined, TQuery extends HttpQuerySchema | undefined = HttpQuerySchema | undefined, TBody extends HttpBodySchema | undefined = HttpBodySchema | undefined> = {
+    header?: THeader;
+    param?: TParam;
+    query?: TQuery;
+    body?: TBody;
+};
+declare class HttpRequestDefinition<THeader extends HttpHeaderSchema | undefined, TParam extends HttpParamSchema | undefined, TQuery extends HttpQuerySchema | undefined, TBody extends HttpBodySchema | undefined> implements IHttpRequestDefinition<THeader, TParam, TQuery, TBody> {
+    readonly header?: THeader;
+    readonly param?: TParam;
+    readonly query?: TQuery;
+    readonly body?: TBody;
+    constructor(definition: IHttpRequestDefinition<THeader, TParam, TQuery, TBody>);
+}
+
+type IHttpResponseDefinition<TName extends string = string, TStatusCode extends HttpStatusCode = HttpStatusCode, TDescription extends string = string, THeader extends HttpHeaderSchema | undefined = HttpHeaderSchema | undefined, TBody extends HttpBodySchema | undefined = HttpBodySchema | undefined, TIsShared extends boolean = boolean> = {
+    name: TName;
+    statusCode: TStatusCode;
+    description: TDescription;
+    header?: THeader;
+    body?: TBody;
+    isShared?: TIsShared;
+};
+type IExtendHttpResponseDefinition<TName extends string, TStatusCode extends HttpStatusCode, TDescription extends string, THeader extends HttpHeaderSchema | undefined, TBody extends HttpBodySchema | undefined, TIsShared extends boolean> = Partial<IHttpResponseDefinition<TName, TStatusCode, TDescription, THeader, TBody, TIsShared>> & Pick<IHttpResponseDefinition<TName, TStatusCode, TDescription, THeader, TBody, TIsShared>, "name">;
+declare class HttpResponseDefinition<TName extends string, TStatusCode extends HttpStatusCode, TDescription extends string, THeader extends HttpHeaderSchema | undefined, TBody extends HttpBodySchema | undefined, TIsShared extends boolean> {
+    private definition;
+    name: TName;
+    statusCode: TStatusCode;
+    description: TDescription;
+    header?: THeader;
+    body?: TBody;
+    isShared?: TIsShared;
+    constructor(definition: IHttpResponseDefinition<TName, TStatusCode, TDescription, THeader, TBody, TIsShared>);
+    extend<EName extends string, EStatusCode extends HttpStatusCode = TStatusCode, EDescription extends string = TDescription, EHeader extends HttpHeaderSchema | undefined = THeader, EBody extends HttpBodySchema | undefined = TBody, EIsShared extends boolean = TIsShared>(definition: IExtendHttpResponseDefinition<EName, EStatusCode, EDescription, EHeader, EBody, EIsShared>): HttpResponseDefinition<EName, EStatusCode, EDescription, THeader extends undefined ? EHeader : EHeader extends undefined ? THeader : THeader & EHeader, TBody extends undefined ? EBody : EBody extends undefined ? TBody : TBody & EBody, EIsShared>;
+}
+
+/**
+ * Interface for HTTP operation definitions.
+ *
+ * Represents a complete HTTP API operation with:
+ * - Unique operation identifier
+ * - HTTP method and path
+ * - Request definition (headers, params, query, body)
+ * - Response definitions for different status codes
+ *
+ * @template TOperationId - The operation identifier literal type
+ * @template TPath - The URL path literal type
+ * @template TMethod - The HTTP method type
+ * @template TSummary - The operation summary literal type
+ * @template THeader - The header schema type
+ * @template TParam - The path parameter schema type
+ * @template TQuery - The query parameter schema type
+ * @template TBody - The request body schema type
+ * @template TRequest - The complete request definition type
+ * @template TResponses - The array of response definitions
+ */
+type IHttpOperationDefinition<TOperationId extends string = string, TPath extends string = string, TMethod extends HttpMethod = HttpMethod, TSummary extends string = string, THeader extends HttpHeaderSchema | undefined = HttpHeaderSchema | undefined, TParam extends HttpParamSchema | undefined = HttpParamSchema | undefined, TQuery extends HttpQuerySchema | undefined = HttpQuerySchema | undefined, TBody extends HttpBodySchema | undefined = HttpBodySchema | undefined, TRequest extends IHttpRequestDefinition<THeader, TParam, TQuery, TBody> = IHttpRequestDefinition<THeader, TParam, TQuery, TBody>, TResponses extends IHttpResponseDefinition[] = IHttpResponseDefinition[]> = {
+    operationId: TOperationId;
+    path: TPath;
+    method: TMethod;
+    summary: TSummary;
+    request: TRequest;
+    responses: TResponses;
+};
+/**
+ * Concrete implementation of HTTP operation definition.
+ *
+ * This class provides a type-safe way to define HTTP API operations with:
+ * - Full TypeScript type inference for all components
+ * - Integration with Zod schemas for runtime validation
+ * - Support for multiple response definitions per operation
+ * - OpenAPI-compatible structure
+ *
+ * The extensive generic parameters enable complete type safety from
+ * definition through to runtime execution and code generation.
+ *
+ * @template TOperationId - The operation identifier literal type
+ * @template TPath - The URL path literal type
+ * @template TMethod - The HTTP method type
+ * @template TSummary - The operation summary literal type
+ * @template THeader - The header schema type
+ * @template TParam - The path parameter schema type
+ * @template TQuery - The query parameter schema type
+ * @template TBody - The request body schema type
+ * @template TRequest - The complete request definition type
+ * @template TResponses - The array of response definitions
+ */
+declare class HttpOperationDefinition<TOperationId extends string, TPath extends string, TMethod extends HttpMethod, TSummary extends string, THeader extends HttpHeaderSchema | undefined, TParam extends HttpParamSchema | undefined, TQuery extends HttpQuerySchema | undefined, TBody extends HttpBodySchema | undefined, TRequest extends IHttpRequestDefinition<THeader, TParam, TQuery, TBody>, TResponses extends IHttpResponseDefinition[]> implements IHttpOperationDefinition<TOperationId, TPath, TMethod, TSummary, THeader, TParam, TQuery, TBody, TRequest, TResponses> {
+    readonly operationId: TOperationId;
+    readonly path: TPath;
+    readonly method: TMethod;
+    readonly summary: TSummary;
+    readonly request: TRequest;
+    readonly responses: TResponses;
+    constructor(definition: IHttpOperationDefinition<TOperationId, TPath, TMethod, TSummary, THeader, TParam, TQuery, TBody, TRequest, TResponses>);
+}
+
+/**
+ * Input configuration for RequestValidationError.
+ */
+type RequestValidationErrorInput = {
+    /** Validation issues found in HTTP headers */
+    headerIssues?: z.core.$ZodRawIssue[];
+    /** Validation issues found in request body */
+    bodyIssues?: z.core.$ZodRawIssue[];
+    /** Validation issues found in query parameters */
+    queryIssues?: z.core.$ZodRawIssue[];
+    /** Validation issues found in path parameters */
+    pathParamIssues?: z.core.$ZodRawIssue[];
+};
+/**
+ * Error thrown when HTTP request validation fails.
+ *
+ * This error provides detailed information about validation failures across
+ * different parts of an HTTP request. Each category of issues is stored
+ * separately for precise error reporting and debugging.
+ *
+ * The error integrates with Zod's issue format, making it compatible with
+ * Zod schema validation while maintaining flexibility for custom validators.
+ */
+declare class RequestValidationError extends Error {
+    readonly message: string;
+    /** Validation issues found in HTTP headers */
+    readonly headerIssues: z.core.$ZodRawIssue[];
+    /** Validation issues found in request body */
+    readonly bodyIssues: z.core.$ZodRawIssue[];
+    /** Validation issues found in query parameters */
+    readonly queryIssues: z.core.$ZodRawIssue[];
+    /** Validation issues found in path parameters */
+    readonly pathParamIssues: z.core.$ZodRawIssue[];
+    constructor(input?: RequestValidationErrorInput);
+    /**
+     * Adds header validation issues to the error.
+     * @param issues - Array of Zod validation issues
+     */
+    addHeaderIssues(issues: z.core.$ZodRawIssue[]): void;
+    /**
+     * Adds body validation issues to the error.
+     * @param issues - Array of Zod validation issues
+     */
+    addBodyIssues(issues: z.core.$ZodRawIssue[]): void;
+    /**
+     * Adds query parameter validation issues to the error.
+     * @param issues - Array of Zod validation issues
+     */
+    addQueryIssues(issues: z.core.$ZodRawIssue[]): void;
+    /**
+     * Adds path parameter validation issues to the error.
+     * @param issues - Array of Zod validation issues
+     */
+    addPathParamIssues(issues: z.core.$ZodRawIssue[]): void;
+    /**
+     * Checks if this error contains any validation issues.
+     * @returns true if any category has issues, false otherwise
+     */
+    hasIssues(): boolean;
+}
+
+type ValidationSuccessResult$1<T> = {
+    isValid: true;
+    data: T;
+};
+type ValidationFailureResult$1 = {
+    isValid: false;
+    error: RequestValidationError;
+};
+type SafeRequestValidationResult<T> = ValidationSuccessResult$1<T> | ValidationFailureResult$1;
+/**
+ * Interface for HTTP request validators.
+ */
+type IRequestValidator = {
+    /**
+     * Validates a request and returns a result object.
+     * Does not throw errors.
+     */
+    safeValidate(request: IHttpRequest): SafeRequestValidationResult<IHttpRequest>;
+    /**
+     * Validates a request and returns the validated request.
+     * @throws {RequestValidationError} If validation fails
+     */
+    validate(request: IHttpRequest): IHttpRequest;
+};
+
+type ResponseValidationErrorInput = {
+    headerIssues?: z.core.$ZodRawIssue[];
+    bodyIssues?: z.core.$ZodRawIssue[];
+};
+declare class ResponseValidationError extends Error {
+    readonly statusCode: HttpStatusCode;
+    readonly message: string;
+    readonly headerIssues: z.core.$ZodRawIssue[];
+    readonly bodyIssues: z.core.$ZodRawIssue[];
+    constructor(statusCode: HttpStatusCode, input?: ResponseValidationErrorInput);
+    addHeaderIssues(issues: z.core.$ZodRawIssue[]): void;
+    addBodyIssues(issues: z.core.$ZodRawIssue[]): void;
+    hasIssues(): boolean;
+}
+
+type ValidationSuccessResult<T> = {
+    isValid: true;
+    data: T;
+};
+type ValidationFailureResult = {
+    isValid: false;
+    error: ResponseValidationError;
+};
+type SafeResponseValidationResult<T> = ValidationSuccessResult<T> | ValidationFailureResult;
+/**
+ * Interface for HTTP response validators.
+ */
+type IResponseValidator = {
+    /**
+     * Validates a response and returns a result object.
+     * Does not throw errors.
+     */
+    safeValidate(response: IHttpResponse): SafeResponseValidationResult<IHttpResponse>;
+    /**
+     * Validates a response and returns the validated response.
+     * @throws {ResponseValidationError} If validation fails
+     */
+    validate(response: IHttpResponse): IHttpResponse;
+};
+
+export { type HttpBodySchema, type HttpHeaderSchema, HttpMethod, HttpOperationDefinition, type HttpParamSchema, type HttpQuerySchema, HttpRequestDefinition, HttpResponse, HttpResponseDefinition, HttpStatusCode, HttpStatusCodeNameMap, type IExtendHttpResponseDefinition, type IHttpBody, type IHttpHeader, type IHttpOperationDefinition, type IHttpParam, type IHttpQuery, type IHttpRequest, type IHttpRequestDefinition, type IHttpResponse, type IHttpResponseDefinition, type IRequestValidator, type IResponseValidator, RequestValidationError, type RequestValidationErrorInput, ResponseValidationError, type ResponseValidationErrorInput, type SafeRequestValidationResult, type SafeResponseValidationResult };

package/dist/index.js

@@ -0,0 +1,298 @@
+import z from 'zod/v4';
+
+var HttpStatusCode = /* @__PURE__ */ ((HttpStatusCode2) => {
+  HttpStatusCode2[HttpStatusCode2["OK"] = 200] = "OK";
+  HttpStatusCode2[HttpStatusCode2["CREATED"] = 201] = "CREATED";
+  HttpStatusCode2[HttpStatusCode2["ACCEPTED"] = 202] = "ACCEPTED";
+  HttpStatusCode2[HttpStatusCode2["NO_CONTENT"] = 204] = "NO_CONTENT";
+  HttpStatusCode2[HttpStatusCode2["RESET_CONTENT"] = 205] = "RESET_CONTENT";
+  HttpStatusCode2[HttpStatusCode2["PARTIAL_CONTENT"] = 206] = "PARTIAL_CONTENT";
+  HttpStatusCode2[HttpStatusCode2["MULTI_STATUS"] = 207] = "MULTI_STATUS";
+  HttpStatusCode2[HttpStatusCode2["ALREADY_REPORTED"] = 208] = "ALREADY_REPORTED";
+  HttpStatusCode2[HttpStatusCode2["IM_USED"] = 226] = "IM_USED";
+  HttpStatusCode2[HttpStatusCode2["BAD_REQUEST"] = 400] = "BAD_REQUEST";
+  HttpStatusCode2[HttpStatusCode2["UNAUTHORIZED"] = 401] = "UNAUTHORIZED";
+  HttpStatusCode2[HttpStatusCode2["PAYMENT_REQUIRED"] = 402] = "PAYMENT_REQUIRED";
+  HttpStatusCode2[HttpStatusCode2["FORBIDDEN"] = 403] = "FORBIDDEN";
+  HttpStatusCode2[HttpStatusCode2["NOT_FOUND"] = 404] = "NOT_FOUND";
+  HttpStatusCode2[HttpStatusCode2["METHOD_NOT_ALLOWED"] = 405] = "METHOD_NOT_ALLOWED";
+  HttpStatusCode2[HttpStatusCode2["NOT_ACCEPTABLE"] = 406] = "NOT_ACCEPTABLE";
+  HttpStatusCode2[HttpStatusCode2["PROXY_AUTHENTICATION_REQUIRED"] = 407] = "PROXY_AUTHENTICATION_REQUIRED";
+  HttpStatusCode2[HttpStatusCode2["REQUEST_TIMEOUT"] = 408] = "REQUEST_TIMEOUT";
+  HttpStatusCode2[HttpStatusCode2["CONFLICT"] = 409] = "CONFLICT";
+  HttpStatusCode2[HttpStatusCode2["GONE"] = 410] = "GONE";
+  HttpStatusCode2[HttpStatusCode2["LENGTH_REQUIRED"] = 411] = "LENGTH_REQUIRED";
+  HttpStatusCode2[HttpStatusCode2["PRECONDITION_FAILED"] = 412] = "PRECONDITION_FAILED";
+  HttpStatusCode2[HttpStatusCode2["PAYLOAD_TOO_LARGE"] = 413] = "PAYLOAD_TOO_LARGE";
+  HttpStatusCode2[HttpStatusCode2["URI_TOO_LONG"] = 414] = "URI_TOO_LONG";
+  HttpStatusCode2[HttpStatusCode2["UNSUPPORTED_MEDIA_TYPE"] = 415] = "UNSUPPORTED_MEDIA_TYPE";
+  HttpStatusCode2[HttpStatusCode2["RANGE_NOT_SATISFIABLE"] = 416] = "RANGE_NOT_SATISFIABLE";
+  HttpStatusCode2[HttpStatusCode2["EXPECTATION_FAILED"] = 417] = "EXPECTATION_FAILED";
+  HttpStatusCode2[HttpStatusCode2["IM_A_TEAPOT"] = 418] = "IM_A_TEAPOT";
+  HttpStatusCode2[HttpStatusCode2["MISDIRECTED_REQUEST"] = 421] = "MISDIRECTED_REQUEST";
+  HttpStatusCode2[HttpStatusCode2["UNPROCESSABLE_ENTITY"] = 422] = "UNPROCESSABLE_ENTITY";
+  HttpStatusCode2[HttpStatusCode2["LOCKED"] = 423] = "LOCKED";
+  HttpStatusCode2[HttpStatusCode2["FAILED_DEPENDENCY"] = 424] = "FAILED_DEPENDENCY";
+  HttpStatusCode2[HttpStatusCode2["UPGRADE_REQUIRED"] = 426] = "UPGRADE_REQUIRED";
+  HttpStatusCode2[HttpStatusCode2["PRECONDITION_REQUIRED"] = 428] = "PRECONDITION_REQUIRED";
+  HttpStatusCode2[HttpStatusCode2["TOO_MANY_REQUESTS"] = 429] = "TOO_MANY_REQUESTS";
+  HttpStatusCode2[HttpStatusCode2["REQUEST_HEADER_FIELDS_TOO_LARGE"] = 431] = "REQUEST_HEADER_FIELDS_TOO_LARGE";
+  HttpStatusCode2[HttpStatusCode2["UNAVAILABLE_FOR_LEGAL_REASONS"] = 451] = "UNAVAILABLE_FOR_LEGAL_REASONS";
+  HttpStatusCode2[HttpStatusCode2["INTERNAL_SERVER_ERROR"] = 500] = "INTERNAL_SERVER_ERROR";
+  HttpStatusCode2[HttpStatusCode2["NOT_IMPLEMENTED"] = 501] = "NOT_IMPLEMENTED";
+  HttpStatusCode2[HttpStatusCode2["BAD_GATEWAY"] = 502] = "BAD_GATEWAY";
+  HttpStatusCode2[HttpStatusCode2["SERVICE_UNAVAILABLE"] = 503] = "SERVICE_UNAVAILABLE";
+  HttpStatusCode2[HttpStatusCode2["GATEWAY_TIMEOUT"] = 504] = "GATEWAY_TIMEOUT";
+  HttpStatusCode2[HttpStatusCode2["HTTP_VERSION_NOT_SUPPORTED"] = 505] = "HTTP_VERSION_NOT_SUPPORTED";
+  HttpStatusCode2[HttpStatusCode2["VARIANT_ALSO_NEGOTIATES"] = 506] = "VARIANT_ALSO_NEGOTIATES";
+  HttpStatusCode2[HttpStatusCode2["INSUFFICIENT_STORAGE"] = 507] = "INSUFFICIENT_STORAGE";
+  HttpStatusCode2[HttpStatusCode2["LOOP_DETECTED"] = 508] = "LOOP_DETECTED";
+  HttpStatusCode2[HttpStatusCode2["NOT_EXTENDED"] = 510] = "NOT_EXTENDED";
+  HttpStatusCode2[HttpStatusCode2["NETWORK_AUTHENTICATION_REQUIRED"] = 511] = "NETWORK_AUTHENTICATION_REQUIRED";
+  return HttpStatusCode2;
+})(HttpStatusCode || {});
+const HttpStatusCodeNameMap = {
+  [200 /* OK */]: "Ok",
+  [201 /* CREATED */]: "Created",
+  [202 /* ACCEPTED */]: "Accepted",
+  [204 /* NO_CONTENT */]: "NoContent",
+  [205 /* RESET_CONTENT */]: "ResetContent",
+  [206 /* PARTIAL_CONTENT */]: "PartialContent",
+  [207 /* MULTI_STATUS */]: "MultiStatus",
+  [208 /* ALREADY_REPORTED */]: "AlreadyReported",
+  [226 /* IM_USED */]: "ImUsed",
+  [400 /* BAD_REQUEST */]: "BadRequest",
+  [401 /* UNAUTHORIZED */]: "Unauthorized",
+  [402 /* PAYMENT_REQUIRED */]: "PaymentRequired",
+  [403 /* FORBIDDEN */]: "Forbidden",
+  [404 /* NOT_FOUND */]: "NotFound",
+  [405 /* METHOD_NOT_ALLOWED */]: "MethodNotAllowed",
+  [406 /* NOT_ACCEPTABLE */]: "NotAcceptable",
+  [407 /* PROXY_AUTHENTICATION_REQUIRED */]: "ProxyAuthenticationRequired",
+  [408 /* REQUEST_TIMEOUT */]: "RequestTimeout",
+  [409 /* CONFLICT */]: "Conflict",
+  [410 /* GONE */]: "Gone",
+  [411 /* LENGTH_REQUIRED */]: "LengthRequired",
+  [412 /* PRECONDITION_FAILED */]: "PreconditionFailed",
+  [413 /* PAYLOAD_TOO_LARGE */]: "PayloadTooLarge",
+  [414 /* URI_TOO_LONG */]: "UriTooLong",
+  [415 /* UNSUPPORTED_MEDIA_TYPE */]: "UnsupportedMediaType",
+  [416 /* RANGE_NOT_SATISFIABLE */]: "RangeNotSatisfiable",
+  [417 /* EXPECTATION_FAILED */]: "ExpectationFailed",
+  [418 /* IM_A_TEAPOT */]: "ImATeapot",
+  [421 /* MISDIRECTED_REQUEST */]: "MisdirectedRequest",
+  [422 /* UNPROCESSABLE_ENTITY */]: "UnprocessableEntity",
+  [423 /* LOCKED */]: "Locked",
+  [424 /* FAILED_DEPENDENCY */]: "FailedDependency",
+  [426 /* UPGRADE_REQUIRED */]: "UpgradeRequired",
+  [428 /* PRECONDITION_REQUIRED */]: "PreconditionRequired",
+  [429 /* TOO_MANY_REQUESTS */]: "TooManyRequests",
+  [431 /* REQUEST_HEADER_FIELDS_TOO_LARGE */]: "RequestHeaderFieldsTooLarge",
+  [451 /* UNAVAILABLE_FOR_LEGAL_REASONS */]: "UnavailableForLegalReasons",
+  [500 /* INTERNAL_SERVER_ERROR */]: "InternalServerError",
+  [501 /* NOT_IMPLEMENTED */]: "NotImplemented",
+  [502 /* BAD_GATEWAY */]: "BadGateway",
+  [503 /* SERVICE_UNAVAILABLE */]: "ServiceUnavailable",
+  [504 /* GATEWAY_TIMEOUT */]: "GatewayTimeout",
+  [505 /* HTTP_VERSION_NOT_SUPPORTED */]: "HttpVersionNotSupported",
+  [506 /* VARIANT_ALSO_NEGOTIATES */]: "VariantAlsoNegotiates",
+  [507 /* INSUFFICIENT_STORAGE */]: "InsufficientStorage",
+  [508 /* LOOP_DETECTED */]: "LoopDetected",
+  [510 /* NOT_EXTENDED */]: "NotExtended",
+  [511 /* NETWORK_AUTHENTICATION_REQUIRED */]: "NetworkAuthenticationRequired"
+};
+
+class HttpResponse {
+  constructor(statusCode, header, body) {
+    this.statusCode = statusCode;
+    this.header = header;
+    this.body = body;
+  }
+}
+
+var HttpMethod = /* @__PURE__ */ ((HttpMethod2) => {
+  HttpMethod2["GET"] = "GET";
+  HttpMethod2["POST"] = "POST";
+  HttpMethod2["PUT"] = "PUT";
+  HttpMethod2["DELETE"] = "DELETE";
+  HttpMethod2["PATCH"] = "PATCH";
+  HttpMethod2["OPTIONS"] = "OPTIONS";
+  HttpMethod2["HEAD"] = "HEAD";
+  HttpMethod2["TRACE"] = "TRACE";
+  HttpMethod2["CONNECT"] = "CONNECT";
+  return HttpMethod2;
+})(HttpMethod || {});
+
+class HttpOperationDefinition {
+  operationId;
+  path;
+  method;
+  summary;
+  request;
+  responses;
+  constructor(definition) {
+    this.operationId = definition.operationId;
+    this.path = definition.path;
+    this.method = definition.method;
+    this.summary = definition.summary;
+    this.request = definition.request;
+    this.responses = definition.responses;
+  }
+}
+
+class HttpRequestDefinition {
+  header;
+  param;
+  query;
+  body;
+  constructor(definition) {
+    this.header = definition.header;
+    this.param = definition.param;
+    this.query = definition.query;
+    this.body = definition.body;
+  }
+}
+
+class HttpResponseDefinition {
+  constructor(definition) {
+    this.definition = definition;
+    this.name = definition.name;
+    this.statusCode = definition.statusCode;
+    this.description = definition.description;
+    this.header = definition.header;
+    this.body = definition.body;
+    this.isShared = definition.isShared;
+  }
+  name;
+  statusCode;
+  description;
+  header;
+  body;
+  isShared;
+  extend(definition) {
+    const mergedHeader = (() => {
+      if (!this.header && !definition.header) return void 0;
+      if (!this.header) return definition.header;
+      if (!definition.header) return this.header;
+      return z.object({
+        ...this.header.shape,
+        ...definition.header.shape
+      });
+    })();
+    const mergedBody = (() => {
+      if (!this.body && !definition.body) return void 0;
+      if (!this.body) return definition.body;
+      if (!definition.body) return this.body;
+      if (this.body instanceof z.ZodObject && definition.body instanceof z.ZodObject) {
+        return z.object({
+          ...this.body.shape,
+          ...definition.body.shape
+        });
+      }
+      return definition.body;
+    })();
+    const baseDefinition = {
+      ...this.definition,
+      name: definition.name,
+      statusCode: definition.statusCode ?? this.statusCode,
+      description: definition.description ?? this.description,
+      isShared: definition.isShared ?? this.isShared,
+      header: mergedHeader,
+      body: mergedBody
+    };
+    return new HttpResponseDefinition(baseDefinition);
+  }
+}
+
+class RequestValidationError extends Error {
+  message;
+  /** Validation issues found in HTTP headers */
+  headerIssues = [];
+  /** Validation issues found in request body */
+  bodyIssues = [];
+  /** Validation issues found in query parameters */
+  queryIssues = [];
+  /** Validation issues found in path parameters */
+  pathParamIssues = [];
+  constructor(input) {
+    const message = "Invalid request";
+    super(message);
+    this.message = message;
+    if (input?.headerIssues) {
+      this.headerIssues = input.headerIssues;
+    }
+    if (input?.bodyIssues) {
+      this.bodyIssues = input.bodyIssues;
+    }
+    if (input?.queryIssues) {
+      this.queryIssues = input.queryIssues;
+    }
+    if (input?.pathParamIssues) {
+      this.pathParamIssues = input.pathParamIssues;
+    }
+  }
+  /**
+   * Adds header validation issues to the error.
+   * @param issues - Array of Zod validation issues
+   */
+  addHeaderIssues(issues) {
+    this.headerIssues.push(...issues);
+  }
+  /**
+   * Adds body validation issues to the error.
+   * @param issues - Array of Zod validation issues
+   */
+  addBodyIssues(issues) {
+    this.bodyIssues.push(...issues);
+  }
+  /**
+   * Adds query parameter validation issues to the error.
+   * @param issues - Array of Zod validation issues
+   */
+  addQueryIssues(issues) {
+    this.queryIssues.push(...issues);
+  }
+  /**
+   * Adds path parameter validation issues to the error.
+   * @param issues - Array of Zod validation issues
+   */
+  addPathParamIssues(issues) {
+    this.pathParamIssues.push(...issues);
+  }
+  /**
+   * Checks if this error contains any validation issues.
+   * @returns true if any category has issues, false otherwise
+   */
+  hasIssues() {
+    return this.headerIssues.length > 0 || this.bodyIssues.length > 0 || this.queryIssues.length > 0 || this.pathParamIssues.length > 0;
+  }
+}
+
+class ResponseValidationError extends Error {
+  constructor(statusCode, input) {
+    const message = `Invalid response for status code '${statusCode}'`;
+    super(message);
+    this.statusCode = statusCode;
+    this.message = message;
+    if (input?.headerIssues) {
+      this.headerIssues = input.headerIssues;
+    }
+    if (input?.bodyIssues) {
+      this.bodyIssues = input.bodyIssues;
+    }
+  }
+  message;
+  headerIssues = [];
+  bodyIssues = [];
+  addHeaderIssues(issues) {
+    this.headerIssues.push(...issues);
+  }
+  addBodyIssues(issues) {
+    this.bodyIssues.push(...issues);
+  }
+  hasIssues() {
+    return this.headerIssues.length > 0 || this.bodyIssues.length > 0;
+  }
+}
+
+export { HttpMethod, HttpOperationDefinition, HttpRequestDefinition, HttpResponse, HttpResponseDefinition, HttpStatusCode, HttpStatusCodeNameMap, RequestValidationError, ResponseValidationError };

package/package.json

@@ -0,0 +1,59 @@
+{
+  "name": "@rexeus/typeweaver-core",
+  "version": "0.0.1",
+  "description": "Core TypeScript and Zod utilities for TypeWeaver API framework",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "files": [
+    "dist",
+    "package.json",
+    "README.md"
+  ],
+  "keywords": [
+    "api",
+    "spec",
+    "definition",
+    "typescript",
+    "zod",
+    "generator",
+    "typeweaver"
+  ],
+  "author": "Dennis Wentzien <dw@rexeus.com>",
+  "license": "ISC",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/rexeus/typeweaver.git",
+    "directory": "packages/core"
+  },
+  "bugs": {
+    "url": "https://github.com/rexeus/typeweaver/issues"
+  },
+  "homepage": "https://github.com/rexeus/typeweaver#readme",
+  "devDependencies": {
+    "axios": "^1.9.0",
+    "hono": "^4.8.0",
+    "zod": "^3.25.28"
+  },
+  "peerDependencies": {
+    "axios": "^1.9.0",
+    "hono": "^4.8.0",
+    "zod": "^3.25.0"
+  },
+  "dependencies": {
+    "@types/aws-lambda": "^8.10.149",
+    "case": "^1.6.3"
+  },
+  "scripts": {
+    "typecheck": "tsc --noEmit",
+    "format": "prettier --write .",
+    "build": "pkgroll --clean-dist",
+    "preversion": "npm run build"
+  }
+}