@rexeus/typeweaver-hono 0.0.1

package/README.md

@@ -0,0 +1,61 @@
+# @rexeus/typeweaver-hono
+
+TypeWeaver plugin for generating type-safe Hono routers from HTTP operation definitions.
+
+## Overview
+
+This plugin generates Hono router classes that automatically handle request validation, type-safe
+routing, and error responses. Each entity gets its own router class extending `TypeweaverHono` with
+full TypeScript type inference.
+
+## Installation
+
+```bash
+npm install @rexeus/typeweaver-hono
+```
+
+## Usage
+
+```bash
+# Via CLI
+npx typeweaver generate --plugins hono --input ./definitions --output ./generated
+
+# Via config file
+npx typeweaver generate --config ./typeweaver.config.js
+```
+
+```javascript
+// typeweaver.config.js
+export default {
+  input: "./api/definitions",
+  output: "./api/generated",
+  plugins: ["hono"],
+};
+```
+
+## Example
+
+## Features
+
+- **Type-safe route handlers** - Full TypeScript inference for requests and responses
+- **Automatic request validation** - Built-in validation using generated validators
+- **Configurable error handling** - Customize validation and error responses
+- **Pure Hono compatibility** - Works with all Hono middleware and features
+
+## Configuration Options
+
+```typescript
+new ProjectHono({
+  requestHandlers: handlers,
+
+  // Optional configurations, for example:
+  validateRequests: false, // Disable automatic validation
+  handleValidationErrors: false, // Let validation errors bubble up
+  handleHttpResponseErrors: true, // Handle thrown HttpResponse errors
+  handleUnknownErrors: customHandler, // Custom error handler function
+});
+```
+
+## License
+
+ISC © Dennis Wentzien 2025

package/dist/index.d.ts

@@ -0,0 +1,8 @@
+import { BasePlugin, GeneratorContext } from '@rexeus/typeweaver-gen';
+
+declare class HonoPlugin extends BasePlugin {
+    name: string;
+    generate(context: GeneratorContext): void;
+}
+
+export { HonoPlugin as default };

package/dist/index.js

@@ -0,0 +1,55 @@
+import { BasePlugin } from '@rexeus/typeweaver-gen';
+import Case from 'case';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { fileURLToPath as fileURLToPath$1 } from 'url';
+import path$1 from 'path';
+
+class HonoRouterGenerator {
+  static generate(context) {
+    const __dirname = path.dirname(fileURLToPath(import.meta.url));
+    const templateFile = path.join(__dirname, "templates", "HonoRouter.ejs");
+    for (const [entityName, operationResources] of Object.entries(
+      context.resources.entityResources
+    )) {
+      this.writeHonoRouter(entityName, templateFile, operationResources, context);
+    }
+  }
+  static writeHonoRouter(entityName, templateFile, operationResources, context) {
+    const pascalCaseEntityName = Case.pascal(entityName);
+    const outputDir = path.join(context.outputDir, entityName);
+    const outputPath = path.join(outputDir, `${pascalCaseEntityName}Hono.ts`);
+    const operations = operationResources.map((resource) => this.createOperationData(resource));
+    const content = context.renderTemplate(templateFile, {
+      coreDir: path.relative(outputDir, context.outputDir),
+      entityName,
+      pascalCaseEntityName,
+      operations
+    });
+    const relativePath = path.relative(context.outputDir, outputPath);
+    context.writeFile(relativePath, content);
+  }
+  static createOperationData(resource) {
+    const operationId = resource.definition.operationId;
+    const className = Case.pascal(operationId);
+    const handlerName = `handle${className}Request`;
+    return {
+      className,
+      handlerName,
+      method: resource.definition.method,
+      path: resource.definition.path
+    };
+  }
+}
+
+const __dirname = path$1.dirname(fileURLToPath$1(import.meta.url));
+class HonoPlugin extends BasePlugin {
+  name = "hono";
+  generate(context) {
+    const libSourceDir = path$1.join(__dirname, "lib");
+    this.copyLibFiles(context, libSourceDir, this.name);
+    HonoRouterGenerator.generate(context);
+  }
+}
+
+export { HonoPlugin as default };

package/dist/lib/FetchApiAdapter.ts

@@ -0,0 +1,161 @@
+import type {
+  HttpMethod,
+  IHttpRequest,
+  IHttpResponse,
+  IHttpHeader,
+  IHttpQuery,
+  IHttpBody,
+} from "@rexeus/typeweaver-core";
+import { HttpAdapter } from "./HttpAdapter";
+import { normalizeHeaders } from "./normalizeHeaders";
+
+/**
+ * Adapter for converting between Fetch API Request/Response objects
+ * and the framework-agnostic HTTP types.
+ *
+ * This adapter works with the Request and Response objects from the Fetch API
+ * specification, which are available in modern JavaScript runtimes (browsers,
+ * Node.js 18+, Deno, Bun, Cloudflare Workers, etc.).
+ */
+export class FetchApiAdapter extends HttpAdapter<Request, Response> {
+  /**
+   * Converts a Fetch API Request to an IHttpRequest.
+   * Extracts headers, query parameters, and body from the Request object.
+   *
+   * @param request - The Fetch API Request object
+   * @param pathParams - Optional path parameters (not available in Fetch API Request)
+   * @returns Promise resolving to an IHttpRequest
+   */
+  public async toRequest(
+    request: Request,
+    pathParams?: Record<string, string>
+  ): Promise<IHttpRequest> {
+    const url = new URL(request.url);
+
+    return {
+      method: request.method.toUpperCase() as HttpMethod,
+      path: url.pathname,
+      header: this.extractHeaders(request.headers),
+      query: this.extractQueryParams(url),
+      param:
+        pathParams && Object.keys(pathParams).length > 0
+          ? pathParams
+          : undefined,
+      body: await this.parseRequestBody(request),
+    };
+  }
+
+  /**
+   * Converts an IHttpResponse to a Fetch API Response.
+   * Creates a Response object with the appropriate status, headers, and body.
+   *
+   * @param response - The IHttpResponse to convert
+   * @returns A Fetch API Response object
+   */
+  public toResponse(response: IHttpResponse): Response {
+    const { statusCode, body, header } = response;
+
+    return new Response(this.buildResponseBody(body), {
+      status: statusCode,
+      headers: this.buildResponseHeaders(header),
+    });
+  }
+
+  private addMultiValue(
+    record: Record<string, string | string[]>,
+    key: string,
+    value: string
+  ): void {
+    const existing = record[key];
+    if (existing) {
+      if (Array.isArray(existing)) {
+        existing.push(value);
+      } else {
+        record[key] = [existing, value];
+      }
+    } else {
+      record[key] = value;
+    }
+  }
+
+  private extractHeaders(headers: Headers): IHttpHeader {
+    const result: Record<string, string | string[]> = {};
+    headers.forEach((value, key) => {
+      this.addMultiValue(result, key, value);
+    });
+    return normalizeHeaders(result);
+  }
+
+  private extractQueryParams(url: URL): IHttpQuery {
+    const result: Record<string, string | string[]> = {};
+    url.searchParams.forEach((value, key) => {
+      this.addMultiValue(result, key, value);
+    });
+    return Object.keys(result).length > 0 ? result : undefined;
+  }
+
+  private async parseRequestBody(request: Request): Promise<IHttpBody> {
+    if (!request.body) return undefined;
+
+    const contentType = request.headers.get("content-type");
+
+    if (contentType?.includes("application/json")) {
+      try {
+        return await request.json();
+      } catch {
+        return undefined;
+      }
+    }
+
+    if (contentType?.includes("text/")) {
+      return await request.text();
+    }
+
+    if (contentType?.includes("application/x-www-form-urlencoded")) {
+      const text = await request.text();
+      const formData = new URLSearchParams(text);
+      const formObject: Record<string, string | string[]> = {};
+      formData.forEach((value, key) => {
+        this.addMultiValue(formObject, key, value);
+      });
+      return formObject;
+    }
+
+    const rawBody = await request.text();
+    return rawBody || undefined;
+  }
+
+  private buildResponseBody(body: any): string | ArrayBuffer | Blob | null {
+    if (body === undefined) {
+      return null;
+    }
+
+    if (
+      typeof body === "string" ||
+      body instanceof Blob ||
+      body instanceof ArrayBuffer
+    ) {
+      return body;
+    }
+
+    return JSON.stringify(body);
+  }
+
+  private buildResponseHeaders(header?: IHttpHeader): Headers {
+    const headers = new Headers();
+
+    if (header) {
+      Object.entries(header).forEach(([key, value]) => {
+        if (value !== undefined) {
+          if (Array.isArray(value)) {
+            value.forEach(v => headers.append(key, v));
+          } else {
+            headers.set(key, String(value));
+          }
+        }
+      });
+    }
+
+    return headers;
+  }
+}

package/dist/lib/HonoAdapter.ts

@@ -0,0 +1,44 @@
+import type { Context } from "hono";
+import type { IHttpRequest, IHttpResponse } from "@rexeus/typeweaver-core";
+import { FetchApiAdapter } from "./FetchApiAdapter";
+import { HttpAdapter } from "./HttpAdapter";
+
+/**
+ * Adapter for converting between Hono's Context and the core HTTP types.
+ *
+ * This adapter extends the FetchApiAdapter functionality by adding
+ * Hono-specific features like path parameter extraction.
+ */
+export class HonoAdapter extends HttpAdapter<Context, Response> {
+  private fetchAdapter = new FetchApiAdapter();
+
+  /**
+   * Converts a Hono Context to an IHttpRequest.
+   *
+   * Leverages the FetchApiAdapter for standard Request processing
+   * and adds Hono-specific path parameter extraction.
+   *
+   * @param c - The Hono context
+   * @returns Promise resolving to an IHttpRequest
+   */
+  public async toRequest(c: Context): Promise<IHttpRequest> {
+    const pathParams = c.req.param();
+    const request = await this.fetchAdapter.toRequest(c.req.raw, pathParams);
+
+    // Override the path with Hono's path (which may differ from raw URL path)
+    request.path = c.req.path;
+
+    return request;
+  }
+
+  /**
+   * Converts an IHttpResponse to a Hono Response.
+   * Delegates to FetchApiAdapter since Hono uses standard Fetch API Response objects.
+   *
+   * @param response - The IHttpResponse to convert
+   * @returns A Hono-compatible Response object
+   */
+  public toResponse(response: IHttpResponse): Response {
+    return this.fetchAdapter.toResponse(response);
+  }
+}

package/dist/lib/HonoRequestHandler.ts

@@ -0,0 +1,7 @@
+import type { IHttpRequest, IHttpResponse } from "@rexeus/typeweaver-core";
+import type { Context } from "hono";
+
+export type HonoRequestHandler<
+  Request extends IHttpRequest,
+  Response extends IHttpResponse,
+> = (request: Request, context: Context) => Promise<Response>;

package/dist/lib/HttpAdapter.ts

@@ -0,0 +1,29 @@
+import type { IHttpRequest, IHttpResponse } from "@rexeus/typeweaver-core";
+
+/**
+ * Abstract base class for HTTP adapters.
+ *
+ * Provides a common interface for converting between different HTTP request/response
+ * formats and the framework-agnostic IHttpRequest/IHttpResponse types.
+ */
+export abstract class HttpAdapter<TRequest = any, TResponse = any> {
+  /**
+   * Converts a framework-specific request to an IHttpRequest.
+   *
+   * @param request - The framework-specific request object
+   * @param context - Optional additional context needed for conversion
+   * @returns Promise resolving to an IHttpRequest
+   */
+  public abstract toRequest(
+    request: TRequest,
+    context?: any
+  ): Promise<IHttpRequest>;
+
+  /**
+   * Converts an IHttpResponse to a framework-specific response.
+   *
+   * @param response - The IHttpResponse to convert
+   * @returns The framework-specific response object
+   */
+  public abstract toResponse(response: IHttpResponse): TResponse;
+}

package/dist/lib/TypeweaverHono.ts

@@ -0,0 +1,295 @@
+import { Hono, type Context } from "hono";
+import {
+  HttpResponse,
+  RequestValidationError,
+  type IHttpRequest,
+  type IHttpResponse,
+  type IRequestValidator,
+} from "@rexeus/typeweaver-core";
+import { HonoAdapter } from "./HonoAdapter";
+import type { HonoRequestHandler } from "./HonoRequestHandler";
+import type { HonoOptions } from "hono/hono-base";
+import type { BlankEnv, BlankSchema, Env, Schema } from "hono/types";
+
+/**
+ * Handles HTTP response errors thrown by request handlers.
+ * @param error - The HTTP response error that was thrown
+ * @param context - The Hono context for the current request
+ * @returns The HTTP response to send to the client
+ */
+export type HttpResponseErrorHandler = (
+  error: HttpResponse,
+  context: Context
+) => Promise<IHttpResponse> | IHttpResponse;
+
+/**
+ * Handles request validation errors.
+ * @param error - The validation error containing field-specific issues
+ * @param context - The Hono context for the current request
+ * @returns The HTTP response to send to the client
+ */
+export type ValidationErrorHandler = (
+  error: RequestValidationError,
+  context: Context
+) => Promise<IHttpResponse> | IHttpResponse;
+
+/**
+ * Handles any unknown errors not caught by other handlers.
+ * @param error - The unknown error (could be anything)
+ * @param context - The Hono context for the current request
+ * @returns The HTTP response to send to the client
+ */
+export type UnknownErrorHandler = (
+  error: unknown,
+  context: Context
+) => Promise<IHttpResponse> | IHttpResponse;
+
+/**
+ * Configuration options for TypeweaverHono routers.
+ * @template RequestHandlers - Type containing all request handler methods
+ * @template HonoEnv - Hono environment type for middleware context
+ */
+export type TypeweaverHonoOptions<
+  RequestHandlers,
+  HonoEnv extends Env = BlankEnv,
+> = HonoOptions<HonoEnv> & {
+  /**
+   * Request handler methods for each operation.
+   * Each handler receives a request (validated if `validateRequests` is true) and Hono context.
+   */
+  requestHandlers: RequestHandlers;
+
+  /**
+   * Enable request validation using generated validators.
+   * When false, requests are passed through without validation.
+   * @default true
+   */
+  validateRequests?: boolean;
+
+  /**
+   * Configure handling of HttpResponse errors thrown by handlers.
+   * - `true`: Use default handler (returns the error as-is)
+   * - `false`: Let errors bubble up to Hono
+   * - `function`: Use custom error handler
+   * @default true
+   */
+  handleHttpResponseErrors?: HttpResponseErrorHandler | boolean;
+
+  /**
+   * Configure handling of request validation errors.
+   * - `true`: Use default handler (400 with error details)
+   * - `false`: Let errors bubble up to Hono
+   * - `function`: Use custom error handler
+   * @default true
+   */
+  handleValidationErrors?: ValidationErrorHandler | boolean;
+
+  /**
+   * Configure handling of unknown errors.
+   * - `true`: Use default handler (500 Internal Server Error)
+   * - `false`: Let errors bubble up to Hono
+   * - `function`: Use custom error handler
+   * @default true
+   */
+  handleUnknownErrors?: UnknownErrorHandler | boolean;
+};
+
+/**
+ * Abstract base class for TypeWeaver-generated Hono routers.
+ *
+ * Extends Hono with TypeWeaver-specific features:
+ * - Automatic request validation using generated validators
+ * - Configurable error handling for validation, HTTP, and unknown errors
+ * - Type-safe request/response handling with adapters
+ *
+ * @template RequestHandlers - Object containing typed request handler methods
+ * @template HonoEnv - Hono environment type (default: BlankEnv)
+ * @template HonoSchema - Hono schema type (default: BlankSchema)
+ * @template HonoBasePath - Base path for routes (default: "/")
+ */
+export abstract class TypeweaverHono<
+  RequestHandlers,
+  HonoEnv extends Env = BlankEnv,
+  HonoSchema extends Schema = BlankSchema,
+  HonoBasePath extends string = "/",
+> extends Hono<HonoEnv, HonoSchema, HonoBasePath> {
+  /**
+   * Adapter for converting between Hono and TypeWeaver request/response formats.
+   */
+  protected readonly adapter = new HonoAdapter();
+
+  /**
+   * Request handlers provided during construction.
+   */
+  protected readonly requestHandlers: RequestHandlers;
+
+  /**
+   * Resolved configuration for validation and error handling.
+   */
+  private readonly config: {
+    validateRequests: boolean;
+    errorHandlers: {
+      validation: ValidationErrorHandler | undefined;
+      httpResponse: HttpResponseErrorHandler | undefined;
+      unknown: UnknownErrorHandler | undefined;
+    };
+  };
+
+  /**
+   * Default error handlers used when custom handlers are not provided.
+   */
+  private readonly defaultHandlers = {
+    validation: (error: RequestValidationError): IHttpResponse => ({
+      statusCode: 400,
+      body: {
+        error: {
+          code: "VALIDATION_ERROR",
+          message: error.message,
+          details: {
+            headers: error.headerIssues,
+            body: error.bodyIssues,
+            query: error.queryIssues,
+            params: error.pathParamIssues,
+          },
+        },
+      },
+    }),
+
+    httpResponse: (error: HttpResponse): IHttpResponse => error,
+
+    unknown: (): IHttpResponse => ({
+      statusCode: 500,
+      body: {
+        error: {
+          code: "INTERNAL_SERVER_ERROR",
+          message: "An unexpected error occurred.",
+        },
+      },
+    }),
+  };
+
+  /**
+   * Creates a new TypeweaverHono router instance.
+   *
+   * @param options - Configuration options including request handlers and error handling
+   * @param options.requestHandlers - Object containing all request handler methods
+   * @param options.validateRequests - Whether to validate requests (default: true)
+   * @param options.handleHttpResponseErrors - Handler or boolean for HTTP errors (default: true)
+   * @param options.handleValidationErrors - Handler or boolean for validation errors (default: true)
+   * @param options.handleUnknownErrors - Handler or boolean for unknown errors (default: true)
+   */
+  public constructor(options: TypeweaverHonoOptions<RequestHandlers, HonoEnv>) {
+    const {
+      requestHandlers,
+      validateRequests = true,
+      handleHttpResponseErrors,
+      handleValidationErrors,
+      handleUnknownErrors,
+      ...honoOptions
+    } = options;
+
+    super(honoOptions);
+
+    this.requestHandlers = requestHandlers;
+
+    // Resolve configuration
+    this.config = {
+      validateRequests,
+      errorHandlers: {
+        validation: this.resolveErrorHandler(handleValidationErrors, error =>
+          this.defaultHandlers.validation(error)
+        ),
+        httpResponse: this.resolveErrorHandler(
+          handleHttpResponseErrors,
+          error => this.defaultHandlers.httpResponse(error)
+        ),
+        unknown: this.resolveErrorHandler(handleUnknownErrors, () =>
+          this.defaultHandlers.unknown()
+        ),
+      },
+    };
+
+    this.registerErrorHandler();
+  }
+
+  /**
+   * Resolves error handler configuration to a handler function or undefined.
+   *
+   * @param option - Boolean to enable/disable or custom handler function
+   * @param defaultHandler - Default handler to use when option is true
+   * @returns Resolved handler function or undefined if disabled
+   */
+  private resolveErrorHandler<T extends Function>(
+    option: T | boolean | undefined,
+    defaultHandler: T
+  ): T | undefined {
+    if (option === false) return undefined;
+    if (option === true || option === undefined) return defaultHandler;
+    return option;
+  }
+
+  /**
+   * Registers the global error handler with Hono.
+   * Processes errors in order: validation, HTTP response, unknown.
+   */
+  protected registerErrorHandler(): void {
+    this.onError(async (error, context) => {
+      // Handle validation errors
+      if (
+        error instanceof RequestValidationError &&
+        this.config.errorHandlers.validation
+      ) {
+        return this.adapter.toResponse(
+          await this.config.errorHandlers.validation(error, context)
+        );
+      }
+
+      // Handle HTTP response errors
+      if (
+        error instanceof HttpResponse &&
+        this.config.errorHandlers.httpResponse
+      ) {
+        return this.adapter.toResponse(
+          await this.config.errorHandlers.httpResponse(error, context)
+        );
+      }
+
+      // Handle unknown errors
+      if (this.config.errorHandlers.unknown) {
+        return this.adapter.toResponse(
+          await this.config.errorHandlers.unknown(error, context)
+        );
+      }
+
+      // Default: re-throw
+      throw error;
+    });
+  }
+
+  /**
+   * Handles a request with validation and type-safe response conversion.
+   *
+   * @param context - Hono context for the current request
+   * @param validator - Request validator for the specific operation
+   * @param handler - Type-safe request handler function
+   * @returns Hono-compatible Response object
+   */
+  protected async handleRequest<
+    TRequest extends IHttpRequest,
+    TResponse extends IHttpResponse,
+  >(
+    context: Context,
+    validator: IRequestValidator,
+    handler: HonoRequestHandler<TRequest, TResponse>
+  ): Promise<Response> {
+    const httpRequest = await this.adapter.toRequest(context);
+
+    // Conditionally validate
+    const validatedRequest = this.config.validateRequests
+      ? (validator.validate(httpRequest) as TRequest)
+      : (httpRequest as TRequest);
+
+    const httpResponse = await handler(validatedRequest, context);
+    return this.adapter.toResponse(httpResponse);
+  }
+}

package/dist/lib/index.ts

@@ -0,0 +1,3 @@
+export * from "./TypeweaverHono";
+export * from "./HonoRequestHandler";
+export * from "./HonoAdapter";

package/dist/lib/normalizeHeaders.ts

@@ -0,0 +1,36 @@
+import Case from "case";
+import type { IHttpHeader } from "@rexeus/typeweaver-core";
+
+export interface NormalizedHeaders {
+  [key: string]: string | string[];
+}
+
+export const normalizeHeaders = (
+  headers: Record<string, string | string[] | undefined> | null
+): IHttpHeader => {
+  if (!headers) return undefined;
+
+  const result: NormalizedHeaders = {};
+
+  for (const [key, value] of Object.entries(headers)) {
+    if (value === undefined) continue;
+
+    const processedValue =
+      typeof value === "string" ? value.split(",").map(v => v.trim()) : value;
+
+    const filteredValue = processedValue.filter(v => v !== "");
+    if (filteredValue.length === 0) continue;
+
+    const lowerKey = key.toLowerCase();
+    const headerKey = Case.header(key);
+
+    const finalValue: string | string[] =
+      filteredValue.length === 1 ? filteredValue[0]! : filteredValue;
+
+    result[lowerKey] = finalValue;
+    result[headerKey] = finalValue;
+    result[key] = finalValue;
+  }
+
+  return Object.keys(result).length > 0 ? result : undefined;
+};

package/dist/templates/HonoRouter.ejs

@@ -0,0 +1,32 @@
+import type { Context } from "hono";
+import { TypeweaverHono, type HonoRequestHandler } from "<%- coreDir %>/lib/hono";
+<% for (const operation of operations) { %>
+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";
+<% } %>
+
+export type <%- pascalCaseEntityName %>ApiHandler = {
+<% for (const operation of operations) { %>
+  <%- operation.handlerName %>: HonoRequestHandler<I<%- operation.className %>Request, <%- operation.className %>Response>;
+<% } %>
+};
+
+export class <%- pascalCaseEntityName %>Hono extends TypeweaverHono<<%- pascalCaseEntityName %>ApiHandler> {
+  public constructor(handlers: <%- pascalCaseEntityName %>ApiHandler) {
+    super({ requestHandlers: handlers });
+    this.setupRoutes();
+  }
+
+  protected setupRoutes(): void {
+<% for (const operation of operations) { %>
+    this.<%- operation.method.toLowerCase() %>('<%- operation.path %>', async (context: Context) =>
+      this.handleRequest(
+        context,
+        new <%- operation.className %>RequestValidator(),
+        this.requestHandlers.<%- operation.handlerName %>
+      ));
+
+<% } %>
+  }
+}

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "@rexeus/typeweaver-hono",
+  "version": "0.0.1",
+  "description": "Hono router generator plugin for TypeWeaver",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist",
+    "package.json",
+    "README.md"
+  ],
+  "keywords": [
+    "typeweaver",
+    "plugin",
+    "hono",
+    "router",
+    "api",
+    "http"
+  ],
+  "author": "Dennis Wentzien <dennis@rexeus.com>",
+  "license": "ISC",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/rexeus/typeweaver.git",
+    "directory": "packages/hono"
+  },
+  "bugs": {
+    "url": "https://github.com/rexeus/typeweaver/issues"
+  },
+  "homepage": "https://github.com/rexeus/typeweaver#readme",
+  "peerDependencies": {
+    "@rexeus/typeweaver-core": "*",
+    "@rexeus/typeweaver-gen": "*"
+  },
+  "devDependencies": {
+    "@rexeus/typeweaver-core": "0.0.1",
+    "@rexeus/typeweaver-gen": "0.0.1"
+  },
+  "dependencies": {
+    "case": "^1.6.3",
+    "hono": "^4.0.0"
+  },
+  "scripts": {
+    "typecheck": "tsc --noEmit",
+    "format": "prettier --write .",
+    "build": "pkgroll --clean-dist && cp -r ./src/templates ./dist/templates && cp -r ./src/lib ./dist/lib",
+    "preversion": "npm run build"
+  }
+}