@typokit/server-fastify 0.1.4

package/dist/index.d.ts

@@ -0,0 +1,28 @@
+import type { FastifyServerOptions } from "fastify";
+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 Fastify server adapter for TypoKit.
+ *
+ * Options are passed directly to the Fastify constructor (logger, trustProxy, etc.).
+ *
+ * ```ts
+ * import { fastifyServer } from "@typokit/server-fastify";
+ * const adapter = fastifyServer({ logger: true, trustProxy: true });
+ * adapter.registerRoutes(routeTable, handlerMap, middlewareChain, validatorMap);
+ * const handle = await adapter.listen(3000);
+ * ```
+ */
+export declare function fastifyServer(options?: FastifyServerOptions): 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":"AAOA,OAAO,KAAK,EAIV,oBAAoB,EACrB,MAAM,SAAS,CAAC;AACjB,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;;;;;;;;;;;GAWG;AACH,wBAAgB,aAAa,CAAC,OAAO,CAAC,EAAE,oBAAoB,GAAG,aAAa,CAkL3E;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,285 @@
+// @typokit/server-fastify — Fastify Server Adapter
+//
+// Translates TypoKit's compiled route table into Fastify-native route
+// registrations. Fastify-native middleware runs before TypoKit middleware
+// per the architecture (Section 6.3).
+import Fastify from "fastify";
+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)
+    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 Fastify server adapter for TypoKit.
+ *
+ * Options are passed directly to the Fastify constructor (logger, trustProxy, etc.).
+ *
+ * ```ts
+ * import { fastifyServer } from "@typokit/server-fastify";
+ * const adapter = fastifyServer({ logger: true, trustProxy: true });
+ * adapter.registerRoutes(routeTable, handlerMap, middlewareChain, validatorMap);
+ * const handle = await adapter.listen(3000);
+ * ```
+ */
+export function fastifyServer(options) {
+    const app = Fastify(options ?? {});
+    const state = {
+        routeTable: null,
+        handlerMap: null,
+        middlewareChain: null,
+        validatorMap: null,
+        serializerMap: null,
+    };
+    /** Convert Fastify request to TypoKitRequest */
+    function normalizeRequest(raw) {
+        const req = raw;
+        const headers = {};
+        for (const [key, value] of Object.entries(req.headers)) {
+            headers[key] = value;
+        }
+        const rawQuery = req.query;
+        return {
+            method: req.method.toUpperCase(),
+            path: req.url.split("?")[0],
+            headers,
+            body: req.body,
+            query: rawQuery ?? {},
+            params: req.params ?? {},
+        };
+    }
+    /** Write TypoKitResponse to Fastify reply */
+    function writeResponse(raw, response) {
+        const reply = raw;
+        // Set headers
+        for (const [key, value] of Object.entries(response.headers)) {
+            if (value !== undefined) {
+                reply.header(key, value);
+            }
+        }
+        reply.status(response.status);
+        if (response.body === null || response.body === undefined) {
+            reply.send("");
+        }
+        else {
+            reply.send(response.body);
+        }
+    }
+    const adapter = {
+        name: "fastify",
+        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 Fastify-native route
+            for (const route of routes) {
+                app.route({
+                    method: route.method,
+                    url: route.path,
+                    handler: async (req, reply) => {
+                        const typoReq = normalizeRequest(req);
+                        // Run request validation pipeline
+                        const validationError = runValidators({ validators: route.validators }, state.validatorMap, typoReq.params, typoReq.query, typoReq.body);
+                        if (validationError) {
+                            writeResponse(reply, validationError);
+                            return;
+                        }
+                        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}`,
+                                }),
+                            };
+                            writeResponse(reply, errorResp);
+                            return;
+                        }
+                        // 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);
+                        writeResponse(reply, serialized);
+                    },
+                });
+            }
+        },
+        async listen(port) {
+            await app.listen({ port, host: "0.0.0.0" });
+            return {
+                async close() {
+                    await app.close();
+                },
+            };
+        },
+        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,33 @@
+{
+  "name": "@typokit/server-fastify",
+  "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": {
+    "fastify": "^5.3.3",
+    "@typokit/types": "0.1.4",
+    "@typokit/core": "0.1.4"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/KyleBastien/typokit",
+    "directory": "packages/server-fastify"
+  },
+  "scripts": {
+    "test": "rstest run --passWithNoTests"
+  }
+}

package/src/index.test.ts

@@ -0,0 +1,427 @@
+// @typokit/server-fastify — Integration Tests
+
+import { describe, it, expect } from "@rstest/core";
+import { fastifyServer } from "./index.js";
+import type {
+  CompiledRouteTable,
+  HandlerMap,
+  MiddlewareChain,
+  TypoKitRequest,
+  ValidatorMap,
+  RequestContext,
+} from "@typokit/types";
+import type { FastifyInstance } from "fastify";
+
+// ─── 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: [] };
+}
+
+// Helper to make HTTP requests to the Fastify-adapted server
+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("fastifyServer", () => {
+  it("implements ServerAdapter interface with correct name", () => {
+    const adapter = fastifyServer();
+    expect(adapter.name).toBe("fastify");
+    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 Fastify instance", () => {
+    const adapter = fastifyServer();
+    const native = adapter.getNativeServer!();
+    expect(native).toBeDefined();
+    // Fastify instances have a .route method
+    expect(typeof (native as Record<string, unknown>).route).toBe("function");
+  });
+
+  it("routes GET /health correctly", async () => {
+    const adapter = fastifyServer({ logger: false });
+    adapter.registerRoutes(
+      makeRouteTable(),
+      makeHandlerMap(),
+      emptyMiddlewareChain(),
+    );
+    const handle = await adapter.listen(0);
+    try {
+      const native = adapter.getNativeServer!() as FastifyInstance;
+      const addr = native.addresses()[0];
+      const port = addr.port;
+
+      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 = fastifyServer({ logger: false });
+    adapter.registerRoutes(
+      makeRouteTable(),
+      makeHandlerMap(),
+      emptyMiddlewareChain(),
+    );
+    const handle = await adapter.listen(0);
+    try {
+      const native = adapter.getNativeServer!() as FastifyInstance;
+      const port = native.addresses()[0].port;
+
+      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 = fastifyServer({ logger: false });
+    adapter.registerRoutes(
+      makeRouteTable(),
+      makeHandlerMap(),
+      emptyMiddlewareChain(),
+    );
+    const handle = await adapter.listen(0);
+    try {
+      const native = adapter.getNativeServer!() as FastifyInstance;
+      const port = native.addresses()[0].port;
+
+      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 = fastifyServer({ logger: false });
+    adapter.registerRoutes(
+      makeRouteTable(),
+      makeHandlerMap(),
+      emptyMiddlewareChain(),
+    );
+    const handle = await adapter.listen(0);
+    try {
+      const native = adapter.getNativeServer!() as FastifyInstance;
+      const port = native.addresses()[0].port;
+
+      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 = fastifyServer({ logger: false });
+    adapter.registerRoutes(
+      makeRouteTable(),
+      makeHandlerMap(),
+      emptyMiddlewareChain(),
+    );
+    const handle = await adapter.listen(0);
+    try {
+      const native = adapter.getNativeServer!() as FastifyInstance;
+      const port = native.addresses()[0].port;
+
+      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 = fastifyServer({ logger: false });
+    adapter.registerRoutes(
+      routeTable,
+      handlerMap,
+      emptyMiddlewareChain(),
+      validatorMap,
+    );
+    const handle = await adapter.listen(0);
+    try {
+      const native = adapter.getNativeServer!() as FastifyInstance;
+      const port = native.addresses()[0].port;
+
+      // Send invalid body (missing title)
+      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 = fastifyServer({ logger: false });
+    adapter.registerRoutes(
+      routeTable,
+      handlerMap,
+      emptyMiddlewareChain(),
+      undefined,
+      {
+        "data#get.response": (input: unknown) => {
+          serializerCalls.push(input);
+          return JSON.stringify(input);
+        },
+      },
+    );
+    const handle = await adapter.listen(0);
+    try {
+      const native = adapter.getNativeServer!() as FastifyInstance;
+      const port = native.addresses()[0].port;
+
+      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("options are passed to Fastify constructor", () => {
+    const adapter = fastifyServer({ logger: false, maxParamLength: 200 });
+    const native = adapter.getNativeServer!() as FastifyInstance;
+    // Verify the instance was created (basic check)
+    expect(native).toBeDefined();
+    expect(typeof native.listen).toBe("function");
+  });
+
+  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 = fastifyServer({ logger: false });
+    adapter.registerRoutes(routeTable, handlerMap, middlewareChain);
+    const handle = await adapter.listen(0);
+    try {
+      const native = adapter.getNativeServer!() as FastifyInstance;
+      const port = native.addresses()[0].port;
+
+      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 = fastifyServer({ logger: false });
+    adapter.registerRoutes(
+      makeRouteTable(),
+      makeHandlerMap(),
+      emptyMiddlewareChain(),
+    );
+    const handle = await adapter.listen(0);
+    try {
+      const native = adapter.getNativeServer!() as FastifyInstance;
+      const port = native.addresses()[0].port;
+      expect(port).toBeGreaterThan(0);
+    } finally {
+      await handle.close();
+    }
+  });
+});

package/src/index.ts

@@ -0,0 +1,418 @@
+// @typokit/server-fastify — Fastify Server Adapter
+//
+// Translates TypoKit's compiled route table into Fastify-native route
+// registrations. Fastify-native middleware runs before TypoKit middleware
+// per the architecture (Section 6.3).
+
+import Fastify from "fastify";
+import type {
+  FastifyInstance,
+  FastifyRequest,
+  FastifyReply,
+  FastifyServerOptions,
+} from "fastify";
+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)
+  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),
+  };
+}
+
+// ─── Fastify Server Adapter ──────────────────────────────────
+
+interface FastifyServerState {
+  routeTable: CompiledRouteTable | null;
+  handlerMap: HandlerMap | null;
+  middlewareChain: MiddlewareChain | null;
+  validatorMap: ValidatorMap | null;
+  serializerMap: SerializerMap | null;
+}
+
+/**
+ * Create a Fastify server adapter for TypoKit.
+ *
+ * Options are passed directly to the Fastify constructor (logger, trustProxy, etc.).
+ *
+ * ```ts
+ * import { fastifyServer } from "@typokit/server-fastify";
+ * const adapter = fastifyServer({ logger: true, trustProxy: true });
+ * adapter.registerRoutes(routeTable, handlerMap, middlewareChain, validatorMap);
+ * const handle = await adapter.listen(3000);
+ * ```
+ */
+export function fastifyServer(options?: FastifyServerOptions): ServerAdapter {
+  const app: FastifyInstance = Fastify(options ?? {});
+
+  const state: FastifyServerState = {
+    routeTable: null,
+    handlerMap: null,
+    middlewareChain: null,
+    validatorMap: null,
+    serializerMap: null,
+  };
+
+  /** Convert Fastify request to TypoKitRequest */
+  function normalizeRequest(raw: unknown): TypoKitRequest {
+    const req = raw as FastifyRequest;
+    const headers: Record<string, string | string[] | undefined> = {};
+    for (const [key, value] of Object.entries(req.headers)) {
+      headers[key] = value;
+    }
+
+    const rawQuery = req.query as
+      | Record<string, string | string[] | undefined>
+      | undefined;
+
+    return {
+      method: req.method.toUpperCase() as HttpMethod,
+      path: req.url.split("?")[0],
+      headers,
+      body: req.body,
+      query: rawQuery ?? {},
+      params: (req.params as Record<string, string>) ?? {},
+    };
+  }
+
+  /** Write TypoKitResponse to Fastify reply */
+  function writeResponse(raw: unknown, response: TypoKitResponse): void {
+    const reply = raw as FastifyReply;
+
+    // Set headers
+    for (const [key, value] of Object.entries(response.headers)) {
+      if (value !== undefined) {
+        reply.header(key, value);
+      }
+    }
+
+    reply.status(response.status);
+
+    if (response.body === null || response.body === undefined) {
+      reply.send("");
+    } else {
+      reply.send(response.body);
+    }
+  }
+
+  const adapter: ServerAdapter = {
+    name: "fastify",
+
+    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 Fastify-native route
+      for (const route of routes) {
+        app.route({
+          method: route.method,
+          url: route.path,
+          handler: async (req: FastifyRequest, reply: FastifyReply) => {
+            const typoReq = normalizeRequest(req);
+
+            // Run request validation pipeline
+            const validationError = runValidators(
+              { validators: route.validators },
+              state.validatorMap,
+              typoReq.params,
+              typoReq.query,
+              typoReq.body,
+            );
+            if (validationError) {
+              writeResponse(reply, validationError);
+              return;
+            }
+
+            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}`,
+                }),
+              };
+              writeResponse(reply, errorResp);
+              return;
+            }
+
+            // 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,
+            );
+
+            writeResponse(reply, serialized);
+          },
+        });
+      }
+    },
+
+    async listen(port: number): Promise<ServerHandle> {
+      await app.listen({ port, host: "0.0.0.0" });
+
+      return {
+        async close(): Promise<void> {
+          await app.close();
+        },
+      };
+    },
+
+    normalizeRequest,
+    writeResponse,
+
+    getNativeServer(): unknown {
+      return app;
+    },
+  };
+
+  return adapter;
+}
+
+// Re-export for convenience
+export { serializeResponse, runValidators, validationErrorResponse };
+export { type ServerAdapter } from "@typokit/core";