@typokit/server-hono 0.1.4

package/dist/index.d.ts

@@ -0,0 +1,27 @@
+import type { SerializerMap, TypoKitResponse, ValidatorMap, ValidationFieldError } from "@typokit/types";
+import type { ServerAdapter } from "@typokit/core";
+declare function validationErrorResponse(message: string, fields: ValidationFieldError[]): TypoKitResponse;
+declare function runValidators(routeHandler: {
+    validators?: {
+        params?: string;
+        query?: string;
+        body?: string;
+    };
+}, validatorMap: ValidatorMap | null, params: Record<string, string>, query: Record<string, string | string[] | undefined>, body: unknown): TypoKitResponse | undefined;
+declare function serializeResponse(response: TypoKitResponse, serializerRef: string | undefined, serializerMap: SerializerMap | null): TypoKitResponse;
+/**
+ * Create a Hono server adapter for TypoKit.
+ *
+ * ```ts
+ * import { honoServer } from "@typokit/server-hono";
+ * const adapter = honoServer();
+ * adapter.registerRoutes(routeTable, handlerMap, middlewareChain, validatorMap);
+ * const handle = await adapter.listen(3000);
+ * ```
+ */
+export declare function honoServer(options?: {
+    basePath?: string;
+}): ServerAdapter;
+export { serializeResponse, runValidators, validationErrorResponse };
+export { type ServerAdapter } from "@typokit/core";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAOV,aAAa,EAGb,eAAe,EACf,YAAY,EACZ,oBAAoB,EACrB,MAAM,gBAAgB,CAAC;AACxB,OAAO,KAAK,EAAE,aAAa,EAAmB,MAAM,eAAe,CAAC;AA4DpE,iBAAS,uBAAuB,CAC9B,OAAO,EAAE,MAAM,EACf,MAAM,EAAE,oBAAoB,EAAE,GAC7B,eAAe,CAajB;AAED,iBAAS,aAAa,CACpB,YAAY,EAAE;IACZ,UAAU,CAAC,EAAE;QAAE,MAAM,CAAC,EAAE,MAAM,CAAC;QAAC,KAAK,CAAC,EAAE,MAAM,CAAC;QAAC,IAAI,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;CACjE,EACD,YAAY,EAAE,YAAY,GAAG,IAAI,EACjC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EAC9B,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,SAAS,CAAC,EACpD,IAAI,EAAE,OAAO,GACZ,eAAe,GAAG,SAAS,CA4D7B;AAID,iBAAS,iBAAiB,CACxB,QAAQ,EAAE,eAAe,EACzB,aAAa,EAAE,MAAM,GAAG,SAAS,EACjC,aAAa,EAAE,aAAa,GAAG,IAAI,GAClC,eAAe,CA8BjB;AAYD;;;;;;;;;GASG;AACH,wBAAgB,UAAU,CAAC,OAAO,CAAC,EAAE;IAAE,QAAQ,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG,aAAa,CAgPzE;AAGD,OAAO,EAAE,iBAAiB,EAAE,aAAa,EAAE,uBAAuB,EAAE,CAAC;AACrE,OAAO,EAAE,KAAK,aAAa,EAAE,MAAM,eAAe,CAAC"}

package/dist/index.js

@@ -0,0 +1,345 @@
+// @typokit/server-hono — Hono Server Adapter
+//
+// Translates TypoKit's compiled route table into Hono-native route
+// registrations. Runs on any platform Hono supports via @hono/node-server
+// for the listen() method.
+import { Hono } from "hono";
+import { serve } from "@hono/node-server";
+import { createRequestContext, executeMiddlewareChain } from "@typokit/core";
+/**
+ * Recursively walk the compiled radix tree and collect all registered routes
+ * as flat entries with their full paths reconstructed.
+ */
+function collectRoutes(node, prefix, entries) {
+    if (node.handlers) {
+        for (const [method, handler] of Object.entries(node.handlers)) {
+            if (handler) {
+                entries.push({
+                    method: method,
+                    path: prefix || "/",
+                    handlerRef: handler.ref,
+                    validators: handler.validators,
+                    serializer: handler.serializer,
+                    middleware: handler.middleware,
+                });
+            }
+        }
+    }
+    // Static children
+    if (node.children) {
+        for (const [segment, child] of Object.entries(node.children)) {
+            collectRoutes(child, `${prefix}/${segment}`, entries);
+        }
+    }
+    // Param child (:id) — Hono uses :param syntax same as TypoKit
+    if (node.paramChild) {
+        const paramNode = node.paramChild;
+        collectRoutes(paramNode, `${prefix}/:${paramNode.paramName}`, entries);
+    }
+    // Wildcard child (*path)
+    if (node.wildcardChild) {
+        const wildcardNode = node.wildcardChild;
+        collectRoutes(wildcardNode, `${prefix}/*`, entries);
+    }
+}
+// ─── Request Validation Pipeline ─────────────────────────────
+function validationErrorResponse(message, fields) {
+    const body = {
+        error: {
+            code: "VALIDATION_ERROR",
+            message,
+            details: { fields },
+        },
+    };
+    return {
+        status: 400,
+        headers: { "content-type": "application/json" },
+        body,
+    };
+}
+function runValidators(routeHandler, validatorMap, params, query, body) {
+    if (!validatorMap || !routeHandler.validators) {
+        return undefined;
+    }
+    const allErrors = [];
+    if (routeHandler.validators.params) {
+        const validator = validatorMap[routeHandler.validators.params];
+        if (validator) {
+            const result = validator(params);
+            if (!result.success && result.errors) {
+                for (const e of result.errors) {
+                    allErrors.push({
+                        path: `params.${e.path}`,
+                        expected: e.expected,
+                        actual: e.actual,
+                    });
+                }
+            }
+        }
+    }
+    if (routeHandler.validators.query) {
+        const validator = validatorMap[routeHandler.validators.query];
+        if (validator) {
+            const result = validator(query);
+            if (!result.success && result.errors) {
+                for (const e of result.errors) {
+                    allErrors.push({
+                        path: `query.${e.path}`,
+                        expected: e.expected,
+                        actual: e.actual,
+                    });
+                }
+            }
+        }
+    }
+    if (routeHandler.validators.body) {
+        const validator = validatorMap[routeHandler.validators.body];
+        if (validator) {
+            const result = validator(body);
+            if (!result.success && result.errors) {
+                for (const e of result.errors) {
+                    allErrors.push({
+                        path: `body.${e.path}`,
+                        expected: e.expected,
+                        actual: e.actual,
+                    });
+                }
+            }
+        }
+    }
+    if (allErrors.length > 0) {
+        return validationErrorResponse("Request validation failed", allErrors);
+    }
+    return undefined;
+}
+// ─── Response Serialization Pipeline ──────────────────────────
+function serializeResponse(response, serializerRef, serializerMap) {
+    if (response.body === null ||
+        response.body === undefined ||
+        typeof response.body === "string") {
+        return response;
+    }
+    const headers = { ...response.headers };
+    if (!headers["content-type"]) {
+        headers["content-type"] = "application/json";
+    }
+    if (serializerRef && serializerMap) {
+        const serializer = serializerMap[serializerRef];
+        if (serializer) {
+            return {
+                ...response,
+                headers,
+                body: serializer(response.body),
+            };
+        }
+    }
+    return {
+        ...response,
+        headers,
+        body: JSON.stringify(response.body),
+    };
+}
+/**
+ * Create a Hono server adapter for TypoKit.
+ *
+ * ```ts
+ * import { honoServer } from "@typokit/server-hono";
+ * const adapter = honoServer();
+ * adapter.registerRoutes(routeTable, handlerMap, middlewareChain, validatorMap);
+ * const handle = await adapter.listen(3000);
+ * ```
+ */
+export function honoServer(options) {
+    const app = new Hono();
+    const state = {
+        routeTable: null,
+        handlerMap: null,
+        middlewareChain: null,
+        validatorMap: null,
+        serializerMap: null,
+    };
+    const _basePath = options?.basePath;
+    /** Convert Hono context to TypoKitRequest */
+    function normalizeRequest(raw) {
+        const c = raw;
+        const req = c.req;
+        const headers = {};
+        req.raw.headers.forEach((value, key) => {
+            headers[key] = value;
+        });
+        // Parse query parameters from URL
+        const url = new URL(req.url);
+        const query = {};
+        url.searchParams.forEach((value, key) => {
+            const existing = query[key];
+            if (existing !== undefined) {
+                if (Array.isArray(existing)) {
+                    existing.push(value);
+                }
+                else {
+                    query[key] = [existing, value];
+                }
+            }
+            else {
+                query[key] = value;
+            }
+        });
+        return {
+            method: req.method.toUpperCase(),
+            path: url.pathname,
+            headers,
+            body: c._typoBody,
+            query,
+            params: c.req.param(),
+        };
+    }
+    /** Write TypoKitResponse to Hono context — returns a Response */
+    function writeResponse(raw, response) {
+        // In Hono, responses are returned, not written imperatively.
+        // We store the response on the context for the route handler to return.
+        const c = raw;
+        c._typoResponse = response;
+    }
+    function buildHonoResponse(response) {
+        const responseBody = response.body === null || response.body === undefined
+            ? ""
+            : typeof response.body === "string"
+                ? response.body
+                : JSON.stringify(response.body);
+        const headers = new Headers();
+        for (const [key, value] of Object.entries(response.headers)) {
+            if (value !== undefined) {
+                if (Array.isArray(value)) {
+                    for (const v of value) {
+                        headers.append(key, v);
+                    }
+                }
+                else {
+                    headers.set(key, value);
+                }
+            }
+        }
+        return new Response(responseBody, {
+            status: response.status,
+            headers,
+        });
+    }
+    const adapter = {
+        name: "hono",
+        registerRoutes(routeTable, handlerMap, middlewareChain, validatorMap, serializerMap) {
+            state.routeTable = routeTable;
+            state.handlerMap = handlerMap;
+            state.middlewareChain = middlewareChain;
+            state.validatorMap = validatorMap ?? null;
+            state.serializerMap = serializerMap ?? null;
+            // Collect all routes from the compiled radix tree
+            const routes = [];
+            collectRoutes(routeTable, "", routes);
+            // Register each route as a Hono-native route
+            for (const route of routes) {
+                const method = route.method.toUpperCase();
+                app.on(method, route.path, async (c) => {
+                    // Parse body for methods that have one
+                    let body = undefined;
+                    if (route.method === "POST" ||
+                        route.method === "PUT" ||
+                        route.method === "PATCH") {
+                        try {
+                            body = await c.req.json();
+                        }
+                        catch {
+                            body = undefined;
+                        }
+                    }
+                    // Stash body on context for normalizeRequest
+                    c._typoBody = body;
+                    const typoReq = normalizeRequest(c);
+                    // Run request validation pipeline
+                    const validationError = runValidators({ validators: route.validators }, state.validatorMap, typoReq.params, typoReq.query, typoReq.body);
+                    if (validationError) {
+                        return buildHonoResponse(validationError);
+                    }
+                    const handlerFn = state.handlerMap[route.handlerRef];
+                    if (!handlerFn) {
+                        const errorResp = {
+                            status: 500,
+                            headers: { "content-type": "application/json" },
+                            body: JSON.stringify({
+                                error: "Internal Server Error",
+                                message: `Handler not found: ${route.handlerRef}`,
+                            }),
+                        };
+                        return buildHonoResponse(errorResp);
+                    }
+                    // Create request context and execute middleware chain
+                    let ctx = createRequestContext();
+                    if (state.middlewareChain &&
+                        state.middlewareChain.entries.length > 0) {
+                        const entries = state.middlewareChain.entries.map((e) => ({
+                            name: e.name,
+                            middleware: {
+                                handler: async (input) => {
+                                    const mwReq = {
+                                        method: typoReq.method,
+                                        path: typoReq.path,
+                                        headers: input.headers,
+                                        body: input.body,
+                                        query: input.query,
+                                        params: input.params,
+                                    };
+                                    const response = await e.handler(mwReq, input.ctx, async () => {
+                                        return { status: 200, headers: {}, body: null };
+                                    });
+                                    return response;
+                                },
+                            },
+                        }));
+                        ctx = await executeMiddlewareChain(typoReq, ctx, entries);
+                    }
+                    // Call the handler
+                    const response = await handlerFn(typoReq, ctx);
+                    // Response serialization pipeline
+                    const serialized = serializeResponse(response, route.serializer, state.serializerMap);
+                    return buildHonoResponse(serialized);
+                });
+            }
+        },
+        async listen(port) {
+            const server = serve({
+                fetch: app.fetch,
+                port,
+                hostname: "0.0.0.0",
+            });
+            // Wait briefly for server to bind
+            await new Promise((resolve) => {
+                server.once("listening", () => resolve());
+                // If already listening, resolve immediately
+                if (server.listening)
+                    resolve();
+            });
+            return {
+                async close() {
+                    await new Promise((resolve, reject) => {
+                        server.close((err) => {
+                            if (err)
+                                reject(err);
+                            else
+                                resolve();
+                        });
+                    });
+                },
+                // Expose server for port retrieval in tests
+                _server: server,
+            };
+        },
+        normalizeRequest,
+        writeResponse,
+        getNativeServer() {
+            return app;
+        },
+    };
+    return adapter;
+}
+// Re-export for convenience
+export { serializeResponse, runValidators, validationErrorResponse };
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@typokit/server-hono",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "version": "0.1.4",
+  "type": "module",
+  "files": [
+    "dist",
+    "src"
+  ],
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "dependencies": {
+    "@hono/node-server": "^1.19.9",
+    "hono": "^4.12.3",
+    "@typokit/core": "0.1.4",
+    "@typokit/types": "0.1.4"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/KyleBastien/typokit",
+    "directory": "packages/server-hono"
+  },
+  "scripts": {
+    "test": "rstest run --passWithNoTests"
+  }
+}

package/src/index.test.ts

@@ -0,0 +1,449 @@
+// @typokit/server-hono — Integration Tests
+
+import { describe, it, expect } from "@rstest/core";
+import { honoServer } from "./index.js";
+import type {
+  CompiledRouteTable,
+  HandlerMap,
+  MiddlewareChain,
+  TypoKitRequest,
+  ValidatorMap,
+  RequestContext,
+} from "@typokit/types";
+import type { Server } from "node:http";
+
+// ─── Helpers ─────────────────────────────────────────────────
+
+function makeRouteTable(
+  overrides?: Partial<CompiledRouteTable>,
+): CompiledRouteTable {
+  return {
+    segment: "",
+    children: {
+      users: {
+        segment: "users",
+        handlers: {
+          GET: { ref: "users#list", middleware: [] },
+          POST: { ref: "users#create", middleware: [] },
+        },
+        paramChild: {
+          segment: ":id",
+          paramName: "id",
+          handlers: {
+            GET: { ref: "users#get", middleware: [] },
+          },
+        },
+      },
+      health: {
+        segment: "health",
+        handlers: {
+          GET: { ref: "health#check", middleware: [] },
+        },
+      },
+    },
+    ...overrides,
+  };
+}
+
+function makeHandlerMap(): HandlerMap {
+  return {
+    "users#list": async () => ({
+      status: 200,
+      headers: {},
+      body: [
+        { id: 1, name: "Alice" },
+        { id: 2, name: "Bob" },
+      ],
+    }),
+    "users#create": async (req: TypoKitRequest) => ({
+      status: 201,
+      headers: {},
+      body: {
+        id: 3,
+        name: (req.body as Record<string, unknown>)?.name ?? "Unknown",
+      },
+    }),
+    "users#get": async (req: TypoKitRequest) => ({
+      status: 200,
+      headers: {},
+      body: { id: req.params.id, name: "User " + req.params.id },
+    }),
+    "health#check": async () => ({
+      status: 200,
+      headers: {},
+      body: { status: "ok" },
+    }),
+  };
+}
+
+function emptyMiddlewareChain(): MiddlewareChain {
+  return { entries: [] };
+}
+
+function getPort(handle: { _server: Server }): number {
+  const addr = handle._server.address();
+  if (addr && typeof addr === "object") {
+    return addr.port;
+  }
+  throw new Error("Could not get port from server handle");
+}
+
+async function fetchJson(
+  port: number,
+  path: string,
+  options?: RequestInit,
+): Promise<{ status: number; body: unknown }> {
+  const res = await fetch(`http://127.0.0.1:${port}${path}`, {
+    ...options,
+    headers: {
+      "content-type": "application/json",
+      ...(options?.headers as Record<string, string> | undefined),
+    },
+  });
+  const text = await res.text();
+  let body: unknown;
+  try {
+    body = JSON.parse(text);
+  } catch {
+    body = text;
+  }
+  return { status: res.status, body };
+}
+
+// ─── Tests ───────────────────────────────────────────────────
+
+describe("honoServer", () => {
+  it("implements ServerAdapter interface with correct name", () => {
+    const adapter = honoServer();
+    expect(adapter.name).toBe("hono");
+    expect(typeof adapter.registerRoutes).toBe("function");
+    expect(typeof adapter.listen).toBe("function");
+    expect(typeof adapter.normalizeRequest).toBe("function");
+    expect(typeof adapter.writeResponse).toBe("function");
+    expect(typeof adapter.getNativeServer).toBe("function");
+  });
+
+  it("getNativeServer returns the Hono instance", () => {
+    const adapter = honoServer();
+    const native = adapter.getNativeServer!();
+    expect(native).toBeDefined();
+    // Hono instances have a .fetch method
+    expect(typeof (native as Record<string, unknown>).fetch).toBe("function");
+  });
+
+  it("routes GET /health correctly", async () => {
+    const adapter = honoServer();
+    adapter.registerRoutes(
+      makeRouteTable(),
+      makeHandlerMap(),
+      emptyMiddlewareChain(),
+    );
+    const handle = (await adapter.listen(0)) as unknown as {
+      close(): Promise<void>;
+      _server: Server;
+    };
+    try {
+      const port = getPort(handle);
+
+      const { status, body } = await fetchJson(port, "/health");
+      expect(status).toBe(200);
+      expect((body as Record<string, unknown>).status).toBe("ok");
+    } finally {
+      await handle.close();
+    }
+  });
+
+  it("routes GET /users and returns list", async () => {
+    const adapter = honoServer();
+    adapter.registerRoutes(
+      makeRouteTable(),
+      makeHandlerMap(),
+      emptyMiddlewareChain(),
+    );
+    const handle = (await adapter.listen(0)) as unknown as {
+      close(): Promise<void>;
+      _server: Server;
+    };
+    try {
+      const port = getPort(handle);
+
+      const { status, body } = await fetchJson(port, "/users");
+      expect(status).toBe(200);
+      expect(Array.isArray(body)).toBe(true);
+      expect((body as Array<unknown>).length).toBe(2);
+    } finally {
+      await handle.close();
+    }
+  });
+
+  it("routes POST /users with body", async () => {
+    const adapter = honoServer();
+    adapter.registerRoutes(
+      makeRouteTable(),
+      makeHandlerMap(),
+      emptyMiddlewareChain(),
+    );
+    const handle = (await adapter.listen(0)) as unknown as {
+      close(): Promise<void>;
+      _server: Server;
+    };
+    try {
+      const port = getPort(handle);
+
+      const { status, body } = await fetchJson(port, "/users", {
+        method: "POST",
+        body: JSON.stringify({ name: "Charlie" }),
+      });
+      expect(status).toBe(201);
+      expect((body as Record<string, unknown>).name).toBe("Charlie");
+    } finally {
+      await handle.close();
+    }
+  });
+
+  it("routes GET /users/:id with params", async () => {
+    const adapter = honoServer();
+    adapter.registerRoutes(
+      makeRouteTable(),
+      makeHandlerMap(),
+      emptyMiddlewareChain(),
+    );
+    const handle = (await adapter.listen(0)) as unknown as {
+      close(): Promise<void>;
+      _server: Server;
+    };
+    try {
+      const port = getPort(handle);
+
+      const { status, body } = await fetchJson(port, "/users/42");
+      expect(status).toBe(200);
+      expect((body as Record<string, unknown>).id).toBe("42");
+      expect((body as Record<string, unknown>).name).toBe("User 42");
+    } finally {
+      await handle.close();
+    }
+  });
+
+  it("returns 404 for unknown routes", async () => {
+    const adapter = honoServer();
+    adapter.registerRoutes(
+      makeRouteTable(),
+      makeHandlerMap(),
+      emptyMiddlewareChain(),
+    );
+    const handle = (await adapter.listen(0)) as unknown as {
+      close(): Promise<void>;
+      _server: Server;
+    };
+    try {
+      const port = getPort(handle);
+
+      const res = await fetch(`http://127.0.0.1:${port}/nonexistent`);
+      expect(res.status).toBe(404);
+    } finally {
+      await handle.close();
+    }
+  });
+
+  it("runs request validation and returns 400 on failure", async () => {
+    const routeTable: CompiledRouteTable = {
+      segment: "",
+      children: {
+        items: {
+          segment: "items",
+          handlers: {
+            POST: {
+              ref: "items#create",
+              middleware: [],
+              validators: { body: "items#create.body" },
+            },
+          },
+        },
+      },
+    };
+
+    const handlerMap: HandlerMap = {
+      "items#create": async (req: TypoKitRequest) => ({
+        status: 201,
+        headers: {},
+        body: req.body,
+      }),
+    };
+
+    const validatorMap: ValidatorMap = {
+      "items#create.body": (input: unknown) => {
+        const data = input as Record<string, unknown> | null;
+        if (!data || typeof data.title !== "string") {
+          return {
+            success: false,
+            errors: [
+              { path: "title", expected: "string", actual: typeof data?.title },
+            ],
+          };
+        }
+        return { success: true, data };
+      },
+    };
+
+    const adapter = honoServer();
+    adapter.registerRoutes(
+      routeTable,
+      handlerMap,
+      emptyMiddlewareChain(),
+      validatorMap,
+    );
+    const handle = (await adapter.listen(0)) as unknown as {
+      close(): Promise<void>;
+      _server: Server;
+    };
+    try {
+      const port = getPort(handle);
+
+      const { status, body } = await fetchJson(port, "/items", {
+        method: "POST",
+        body: JSON.stringify({ invalid: true }),
+      });
+      expect(status).toBe(400);
+      expect((body as Record<string, unknown>).error).toBeDefined();
+    } finally {
+      await handle.close();
+    }
+  });
+
+  it("runs response serialization with custom serializer", async () => {
+    const routeTable: CompiledRouteTable = {
+      segment: "",
+      children: {
+        data: {
+          segment: "data",
+          handlers: {
+            GET: {
+              ref: "data#get",
+              middleware: [],
+              serializer: "data#get.response",
+            },
+          },
+        },
+      },
+    };
+
+    const serializerCalls: unknown[] = [];
+    const handlerMap: HandlerMap = {
+      "data#get": async () => ({
+        status: 200,
+        headers: {},
+        body: { value: 42 },
+      }),
+    };
+
+    const adapter = honoServer();
+    adapter.registerRoutes(
+      routeTable,
+      handlerMap,
+      emptyMiddlewareChain(),
+      undefined,
+      {
+        "data#get.response": (input: unknown) => {
+          serializerCalls.push(input);
+          return JSON.stringify(input);
+        },
+      },
+    );
+    const handle = (await adapter.listen(0)) as unknown as {
+      close(): Promise<void>;
+      _server: Server;
+    };
+    try {
+      const port = getPort(handle);
+
+      const { status, body } = await fetchJson(port, "/data");
+      expect(status).toBe(200);
+      expect((body as Record<string, unknown>).value).toBe(42);
+      expect(serializerCalls.length).toBe(1);
+    } finally {
+      await handle.close();
+    }
+  });
+
+  it("middleware chain runs before handler", async () => {
+    const callOrder: string[] = [];
+
+    const routeTable: CompiledRouteTable = {
+      segment: "",
+      children: {
+        test: {
+          segment: "test",
+          handlers: {
+            GET: { ref: "test#handler", middleware: ["mw1"] },
+          },
+        },
+      },
+    };
+
+    const handlerMap: HandlerMap = {
+      "test#handler": async (_req: TypoKitRequest, ctx: RequestContext) => {
+        callOrder.push("handler");
+        return {
+          status: 200,
+          headers: {},
+          body: { requestId: ctx.requestId },
+        };
+      },
+    };
+
+    const middlewareChain: MiddlewareChain = {
+      entries: [
+        {
+          name: "mw1",
+          handler: async (_req, _ctx, next) => {
+            callOrder.push("middleware");
+            return next();
+          },
+        },
+      ],
+    };
+
+    const adapter = honoServer();
+    adapter.registerRoutes(routeTable, handlerMap, middlewareChain);
+    const handle = (await adapter.listen(0)) as unknown as {
+      close(): Promise<void>;
+      _server: Server;
+    };
+    try {
+      const port = getPort(handle);
+
+      const { status } = await fetchJson(port, "/test");
+      expect(status).toBe(200);
+      expect(callOrder[0]).toBe("middleware");
+      expect(callOrder[1]).toBe("handler");
+    } finally {
+      await handle.close();
+    }
+  });
+
+  it("listen on port 0 assigns auto port", async () => {
+    const adapter = honoServer();
+    adapter.registerRoutes(
+      makeRouteTable(),
+      makeHandlerMap(),
+      emptyMiddlewareChain(),
+    );
+    const handle = (await adapter.listen(0)) as unknown as {
+      close(): Promise<void>;
+      _server: Server;
+    };
+    try {
+      const port = getPort(handle);
+      expect(port).toBeGreaterThan(0);
+    } finally {
+      await handle.close();
+    }
+  });
+
+  it("honoServer accepts options", () => {
+    const adapter = honoServer({ basePath: "/api" });
+    const native = adapter.getNativeServer!();
+    expect(native).toBeDefined();
+    expect(typeof (native as Record<string, unknown>).fetch).toBe("function");
+  });
+});

package/src/index.ts

@@ -0,0 +1,474 @@
+// @typokit/server-hono — Hono Server Adapter
+//
+// Translates TypoKit's compiled route table into Hono-native route
+// registrations. Runs on any platform Hono supports via @hono/node-server
+// for the listen() method.
+
+import { Hono } from "hono";
+import type { Context as HonoContext } from "hono";
+import { serve } from "@hono/node-server";
+import type {
+  CompiledRoute,
+  CompiledRouteTable,
+  ErrorResponse,
+  HandlerMap,
+  HttpMethod,
+  MiddlewareChain,
+  SerializerMap,
+  ServerHandle,
+  TypoKitRequest,
+  TypoKitResponse,
+  ValidatorMap,
+  ValidationFieldError,
+} from "@typokit/types";
+import type { ServerAdapter, MiddlewareEntry } from "@typokit/core";
+import { createRequestContext, executeMiddlewareChain } from "@typokit/core";
+
+// ─── Route Traversal ─────────────────────────────────────────
+
+interface RouteEntry {
+  method: HttpMethod;
+  path: string;
+  handlerRef: string;
+  validators?: { params?: string; query?: string; body?: string };
+  serializer?: string;
+  middleware: string[];
+}
+
+/**
+ * Recursively walk the compiled radix tree and collect all registered routes
+ * as flat entries with their full paths reconstructed.
+ */
+function collectRoutes(
+  node: CompiledRoute,
+  prefix: string,
+  entries: RouteEntry[],
+): void {
+  if (node.handlers) {
+    for (const [method, handler] of Object.entries(node.handlers)) {
+      if (handler) {
+        entries.push({
+          method: method as HttpMethod,
+          path: prefix || "/",
+          handlerRef: handler.ref,
+          validators: handler.validators,
+          serializer: handler.serializer,
+          middleware: handler.middleware,
+        });
+      }
+    }
+  }
+
+  // Static children
+  if (node.children) {
+    for (const [segment, child] of Object.entries(node.children)) {
+      collectRoutes(child, `${prefix}/${segment}`, entries);
+    }
+  }
+
+  // Param child (:id) — Hono uses :param syntax same as TypoKit
+  if (node.paramChild) {
+    const paramNode = node.paramChild;
+    collectRoutes(paramNode, `${prefix}/:${paramNode.paramName}`, entries);
+  }
+
+  // Wildcard child (*path)
+  if (node.wildcardChild) {
+    const wildcardNode = node.wildcardChild;
+    collectRoutes(wildcardNode, `${prefix}/*`, entries);
+  }
+}
+
+// ─── Request Validation Pipeline ─────────────────────────────
+
+function validationErrorResponse(
+  message: string,
+  fields: ValidationFieldError[],
+): TypoKitResponse {
+  const body: ErrorResponse = {
+    error: {
+      code: "VALIDATION_ERROR",
+      message,
+      details: { fields },
+    },
+  };
+  return {
+    status: 400,
+    headers: { "content-type": "application/json" },
+    body,
+  };
+}
+
+function runValidators(
+  routeHandler: {
+    validators?: { params?: string; query?: string; body?: string };
+  },
+  validatorMap: ValidatorMap | null,
+  params: Record<string, string>,
+  query: Record<string, string | string[] | undefined>,
+  body: unknown,
+): TypoKitResponse | undefined {
+  if (!validatorMap || !routeHandler.validators) {
+    return undefined;
+  }
+
+  const allErrors: ValidationFieldError[] = [];
+
+  if (routeHandler.validators.params) {
+    const validator = validatorMap[routeHandler.validators.params];
+    if (validator) {
+      const result = validator(params);
+      if (!result.success && result.errors) {
+        for (const e of result.errors) {
+          allErrors.push({
+            path: `params.${e.path}`,
+            expected: e.expected,
+            actual: e.actual,
+          });
+        }
+      }
+    }
+  }
+
+  if (routeHandler.validators.query) {
+    const validator = validatorMap[routeHandler.validators.query];
+    if (validator) {
+      const result = validator(query);
+      if (!result.success && result.errors) {
+        for (const e of result.errors) {
+          allErrors.push({
+            path: `query.${e.path}`,
+            expected: e.expected,
+            actual: e.actual,
+          });
+        }
+      }
+    }
+  }
+
+  if (routeHandler.validators.body) {
+    const validator = validatorMap[routeHandler.validators.body];
+    if (validator) {
+      const result = validator(body);
+      if (!result.success && result.errors) {
+        for (const e of result.errors) {
+          allErrors.push({
+            path: `body.${e.path}`,
+            expected: e.expected,
+            actual: e.actual,
+          });
+        }
+      }
+    }
+  }
+
+  if (allErrors.length > 0) {
+    return validationErrorResponse("Request validation failed", allErrors);
+  }
+
+  return undefined;
+}
+
+// ─── Response Serialization Pipeline ──────────────────────────
+
+function serializeResponse(
+  response: TypoKitResponse,
+  serializerRef: string | undefined,
+  serializerMap: SerializerMap | null,
+): TypoKitResponse {
+  if (
+    response.body === null ||
+    response.body === undefined ||
+    typeof response.body === "string"
+  ) {
+    return response;
+  }
+
+  const headers = { ...response.headers };
+  if (!headers["content-type"]) {
+    headers["content-type"] = "application/json";
+  }
+
+  if (serializerRef && serializerMap) {
+    const serializer = serializerMap[serializerRef];
+    if (serializer) {
+      return {
+        ...response,
+        headers,
+        body: serializer(response.body),
+      };
+    }
+  }
+
+  return {
+    ...response,
+    headers,
+    body: JSON.stringify(response.body),
+  };
+}
+
+// ─── Hono Server Adapter ─────────────────────────────────────
+
+interface HonoServerState {
+  routeTable: CompiledRouteTable | null;
+  handlerMap: HandlerMap | null;
+  middlewareChain: MiddlewareChain | null;
+  validatorMap: ValidatorMap | null;
+  serializerMap: SerializerMap | null;
+}
+
+/**
+ * Create a Hono server adapter for TypoKit.
+ *
+ * ```ts
+ * import { honoServer } from "@typokit/server-hono";
+ * const adapter = honoServer();
+ * adapter.registerRoutes(routeTable, handlerMap, middlewareChain, validatorMap);
+ * const handle = await adapter.listen(3000);
+ * ```
+ */
+export function honoServer(options?: { basePath?: string }): ServerAdapter {
+  const app = new Hono();
+
+  const state: HonoServerState = {
+    routeTable: null,
+    handlerMap: null,
+    middlewareChain: null,
+    validatorMap: null,
+    serializerMap: null,
+  };
+
+  const _basePath = options?.basePath;
+
+  /** Convert Hono context to TypoKitRequest */
+  function normalizeRequest(raw: unknown): TypoKitRequest {
+    const c = raw as HonoContext;
+    const req = c.req;
+
+    const headers: Record<string, string | string[] | undefined> = {};
+    req.raw.headers.forEach((value: string, key: string) => {
+      headers[key] = value;
+    });
+
+    // Parse query parameters from URL
+    const url = new URL(req.url);
+    const query: Record<string, string | string[] | undefined> = {};
+    url.searchParams.forEach((value, key) => {
+      const existing = query[key];
+      if (existing !== undefined) {
+        if (Array.isArray(existing)) {
+          existing.push(value);
+        } else {
+          query[key] = [existing, value];
+        }
+      } else {
+        query[key] = value;
+      }
+    });
+
+    return {
+      method: req.method.toUpperCase() as HttpMethod,
+      path: url.pathname,
+      headers,
+      body: (c as unknown as Record<string, unknown>)._typoBody,
+      query,
+      params: c.req.param() as Record<string, string>,
+    };
+  }
+
+  /** Write TypoKitResponse to Hono context — returns a Response */
+  function writeResponse(raw: unknown, response: TypoKitResponse): void {
+    // In Hono, responses are returned, not written imperatively.
+    // We store the response on the context for the route handler to return.
+    const c = raw as HonoContext;
+    (c as unknown as Record<string, unknown>)._typoResponse = response;
+  }
+
+  function buildHonoResponse(response: TypoKitResponse): Response {
+    const responseBody =
+      response.body === null || response.body === undefined
+        ? ""
+        : typeof response.body === "string"
+          ? response.body
+          : JSON.stringify(response.body);
+
+    const headers = new Headers();
+    for (const [key, value] of Object.entries(response.headers)) {
+      if (value !== undefined) {
+        if (Array.isArray(value)) {
+          for (const v of value) {
+            headers.append(key, v);
+          }
+        } else {
+          headers.set(key, value);
+        }
+      }
+    }
+
+    return new Response(responseBody, {
+      status: response.status,
+      headers,
+    });
+  }
+
+  const adapter: ServerAdapter = {
+    name: "hono",
+
+    registerRoutes(
+      routeTable: CompiledRouteTable,
+      handlerMap: HandlerMap,
+      middlewareChain: MiddlewareChain,
+      validatorMap?: ValidatorMap,
+      serializerMap?: SerializerMap,
+    ): void {
+      state.routeTable = routeTable;
+      state.handlerMap = handlerMap;
+      state.middlewareChain = middlewareChain;
+      state.validatorMap = validatorMap ?? null;
+      state.serializerMap = serializerMap ?? null;
+
+      // Collect all routes from the compiled radix tree
+      const routes: RouteEntry[] = [];
+      collectRoutes(routeTable, "", routes);
+
+      // Register each route as a Hono-native route
+      for (const route of routes) {
+        const method = route.method.toUpperCase();
+
+        app.on(method, route.path, async (c: HonoContext) => {
+          // Parse body for methods that have one
+          let body: unknown = undefined;
+          if (
+            route.method === "POST" ||
+            route.method === "PUT" ||
+            route.method === "PATCH"
+          ) {
+            try {
+              body = await c.req.json();
+            } catch {
+              body = undefined;
+            }
+          }
+
+          // Stash body on context for normalizeRequest
+          (c as unknown as Record<string, unknown>)._typoBody = body;
+
+          const typoReq = normalizeRequest(c);
+
+          // Run request validation pipeline
+          const validationError = runValidators(
+            { validators: route.validators },
+            state.validatorMap,
+            typoReq.params,
+            typoReq.query,
+            typoReq.body,
+          );
+          if (validationError) {
+            return buildHonoResponse(validationError);
+          }
+
+          const handlerFn = state.handlerMap![route.handlerRef];
+          if (!handlerFn) {
+            const errorResp: TypoKitResponse = {
+              status: 500,
+              headers: { "content-type": "application/json" },
+              body: JSON.stringify({
+                error: "Internal Server Error",
+                message: `Handler not found: ${route.handlerRef}`,
+              }),
+            };
+            return buildHonoResponse(errorResp);
+          }
+
+          // Create request context and execute middleware chain
+          let ctx = createRequestContext();
+
+          if (
+            state.middlewareChain &&
+            state.middlewareChain.entries.length > 0
+          ) {
+            const entries: MiddlewareEntry[] =
+              state.middlewareChain.entries.map((e) => ({
+                name: e.name,
+                middleware: {
+                  handler: async (input) => {
+                    const mwReq: TypoKitRequest = {
+                      method: typoReq.method,
+                      path: typoReq.path,
+                      headers: input.headers,
+                      body: input.body,
+                      query: input.query,
+                      params: input.params,
+                    };
+                    const response = await e.handler(
+                      mwReq,
+                      input.ctx,
+                      async () => {
+                        return { status: 200, headers: {}, body: null };
+                      },
+                    );
+                    return response as unknown as Record<string, unknown>;
+                  },
+                },
+              }));
+
+            ctx = await executeMiddlewareChain(typoReq, ctx, entries);
+          }
+
+          // Call the handler
+          const response = await handlerFn(typoReq, ctx);
+
+          // Response serialization pipeline
+          const serialized = serializeResponse(
+            response,
+            route.serializer,
+            state.serializerMap,
+          );
+
+          return buildHonoResponse(serialized);
+        });
+      }
+    },
+
+    async listen(port: number): Promise<ServerHandle> {
+      const server = serve({
+        fetch: app.fetch,
+        port,
+        hostname: "0.0.0.0",
+      });
+
+      // Wait briefly for server to bind
+      await new Promise<void>((resolve) => {
+        server.once("listening", () => resolve());
+        // If already listening, resolve immediately
+        if (server.listening) resolve();
+      });
+
+      return {
+        async close(): Promise<void> {
+          await new Promise<void>((resolve, reject) => {
+            server.close((err?: Error) => {
+              if (err) reject(err);
+              else resolve();
+            });
+          });
+        },
+        // Expose server for port retrieval in tests
+        _server: server,
+      } as ServerHandle & { _server: typeof server };
+    },
+
+    normalizeRequest,
+    writeResponse,
+
+    getNativeServer(): unknown {
+      return app;
+    },
+  };
+
+  return adapter;
+}
+
+// Re-export for convenience
+export { serializeResponse, runValidators, validationErrorResponse };
+export { type ServerAdapter } from "@typokit/core";