@typokit/platform-deno 0.1.4

package/dist/index.d.ts

@@ -0,0 +1,56 @@
+import type { ServerHandle, TypoKitRequest, TypoKitResponse } from "@typokit/types";
+/** Subset of Deno's HttpServer type we rely on */
+interface DenoHttpServer {
+    shutdown(): Promise<void>;
+    finished: Promise<void>;
+    addr: {
+        port: number;
+        hostname: string;
+    };
+}
+/** Runtime platform metadata for diagnostics and inspect commands */
+export interface PlatformInfo {
+    runtime: string;
+    version: string;
+}
+/** Returns Deno platform info */
+export declare function getPlatformInfo(): PlatformInfo;
+/**
+ * Normalize a Web API Request (used by Deno.serve) into a TypoKitRequest.
+ */
+export declare function normalizeRequest(req: Request): Promise<TypoKitRequest>;
+/**
+ * Convert a TypoKitResponse into a Web API Response for Deno.serve().
+ */
+export declare function buildResponse(response: TypoKitResponse): Response;
+/** Handler function that receives a normalized request and returns a response */
+export type DenoRequestHandler = (req: TypoKitRequest) => Promise<TypoKitResponse>;
+export interface DenoServerOptions {
+    /** Optional hostname to bind to (default: "0.0.0.0") */
+    hostname?: string;
+}
+/** Result of createServer — provides listen/close and access to the underlying Deno server */
+export interface DenoServerInstance {
+    /** Start listening on the given port. Returns a handle for graceful shutdown. */
+    listen(port: number): Promise<ServerHandle>;
+    /** The underlying Deno HTTP server instance (available after listen()) */
+    server: DenoHttpServer | null;
+}
+/**
+ * Create a Deno HTTP server that dispatches to a TypoKit request handler.
+ *
+ * Usage:
+ * ```ts
+ * const srv = createServer(async (req) => ({
+ *   status: 200,
+ *   headers: {},
+ *   body: { ok: true },
+ * }));
+ * const handle = await srv.listen(3000);
+ * // ... later
+ * await handle.close();
+ * ```
+ */
+export declare function createServer(handler: DenoRequestHandler, options?: DenoServerOptions): DenoServerInstance;
+export {};
+//# 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":"AAEA,OAAO,KAAK,EAEV,YAAY,EACZ,cAAc,EACd,eAAe,EAChB,MAAM,gBAAgB,CAAC;AAMxB,kDAAkD;AAClD,UAAU,cAAc;IACtB,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IAC1B,QAAQ,EAAE,OAAO,CAAC,IAAI,CAAC,CAAC;IACxB,IAAI,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAE,CAAC;CAC1C;AAoBD,qEAAqE;AACrE,MAAM,WAAW,YAAY;IAC3B,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,iCAAiC;AACjC,wBAAgB,eAAe,IAAI,YAAY,CAM9C;AAiCD;;GAEG;AACH,wBAAsB,gBAAgB,CAAC,GAAG,EAAE,OAAO,GAAG,OAAO,CAAC,cAAc,CAAC,CA4B5E;AAED;;GAEG;AACH,wBAAgB,aAAa,CAAC,QAAQ,EAAE,eAAe,GAAG,QAAQ,CA8BjE;AAID,iFAAiF;AACjF,MAAM,MAAM,kBAAkB,GAAG,CAC/B,GAAG,EAAE,cAAc,KAChB,OAAO,CAAC,eAAe,CAAC,CAAC;AAI9B,MAAM,WAAW,iBAAiB;IAChC,wDAAwD;IACxD,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAID,8FAA8F;AAC9F,MAAM,WAAW,kBAAkB;IACjC,iFAAiF;IACjF,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC;IAC5C,0EAA0E;IAC1E,MAAM,EAAE,cAAc,GAAG,IAAI,CAAC;CAC/B;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,YAAY,CAC1B,OAAO,EAAE,kBAAkB,EAC3B,OAAO,GAAE,iBAAsB,GAC9B,kBAAkB,CAuDpB"}

package/dist/index.js

@@ -0,0 +1,167 @@
+// @typokit/platform-deno — Deno Platform Adapter
+/** Returns Deno platform info */
+export function getPlatformInfo() {
+    const deno = globalThis.Deno;
+    return {
+        runtime: "deno",
+        version: deno?.version?.deno ?? "unknown",
+    };
+}
+// ─── Request / Response Helpers ──────────────────────────────
+/** Parse query string from a URL into a Record */
+function parseQuery(searchParams) {
+    const result = {};
+    for (const [key, value] of searchParams.entries()) {
+        const existing = result[key];
+        if (existing === undefined) {
+            result[key] = value;
+        }
+        else if (Array.isArray(existing)) {
+            existing.push(value);
+        }
+        else {
+            result[key] = [existing, value];
+        }
+    }
+    return result;
+}
+/** Normalize Web API headers into a flat Record */
+function normalizeHeaders(headers) {
+    const result = {};
+    headers.forEach((value, key) => {
+        result[key] = value;
+    });
+    return result;
+}
+/**
+ * Normalize a Web API Request (used by Deno.serve) into a TypoKitRequest.
+ */
+export async function normalizeRequest(req) {
+    const url = new URL(req.url);
+    let body = undefined;
+    if (req.method !== "GET" && req.method !== "HEAD") {
+        const contentType = req.headers.get("content-type") ?? "";
+        const raw = await req.text();
+        if (raw) {
+            if (contentType.includes("application/json")) {
+                try {
+                    body = JSON.parse(raw);
+                }
+                catch {
+                    body = raw;
+                }
+            }
+            else {
+                body = raw;
+            }
+        }
+    }
+    return {
+        method: req.method.toUpperCase(),
+        path: url.pathname,
+        headers: normalizeHeaders(req.headers),
+        body,
+        query: parseQuery(url.searchParams),
+        params: {},
+    };
+}
+/**
+ * Convert a TypoKitResponse into a Web API Response for Deno.serve().
+ */
+export function buildResponse(response) {
+    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);
+            }
+        }
+    }
+    let bodyContent = null;
+    if (response.body === null || response.body === undefined) {
+        bodyContent = null;
+    }
+    else if (typeof response.body === "string") {
+        bodyContent = response.body;
+    }
+    else {
+        if (!headers.has("content-type")) {
+            headers.set("content-type", "application/json");
+        }
+        bodyContent = JSON.stringify(response.body);
+    }
+    return new Response(bodyContent, {
+        status: response.status,
+        headers,
+    });
+}
+/**
+ * Create a Deno HTTP server that dispatches to a TypoKit request handler.
+ *
+ * Usage:
+ * ```ts
+ * const srv = createServer(async (req) => ({
+ *   status: 200,
+ *   headers: {},
+ *   body: { ok: true },
+ * }));
+ * const handle = await srv.listen(3000);
+ * // ... later
+ * await handle.close();
+ * ```
+ */
+export function createServer(handler, options = {}) {
+    const hostname = options.hostname ?? "0.0.0.0";
+    let denoServer = null;
+    const instance = {
+        get server() {
+            return denoServer;
+        },
+        listen(port) {
+            return new Promise((resolve, reject) => {
+                try {
+                    const deno = globalThis.Deno;
+                    denoServer = deno.serve({
+                        port,
+                        hostname,
+                        onListen() {
+                            resolve({
+                                async close() {
+                                    if (denoServer) {
+                                        await denoServer.shutdown();
+                                        denoServer = null;
+                                    }
+                                },
+                            });
+                        },
+                    }, async (req) => {
+                        try {
+                            const normalized = await normalizeRequest(req);
+                            const response = await handler(normalized);
+                            return buildResponse(response);
+                        }
+                        catch (err) {
+                            return new Response(JSON.stringify({
+                                error: "Internal Server Error",
+                                message: err instanceof Error ? err.message : "Unknown error",
+                            }), {
+                                status: 500,
+                                headers: { "content-type": "application/json" },
+                            });
+                        }
+                    });
+                }
+                catch (err) {
+                    reject(err);
+                }
+            });
+        },
+    };
+    return instance;
+}
+//# 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,28 @@
+{
+  "name": "@typokit/platform-deno",
+  "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": {
+    "@typokit/types": "0.1.4"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/KyleBastien/typokit",
+    "directory": "packages/platform-deno"
+  },
+  "scripts": {
+    "test": "rstest run --passWithNoTests"
+  }
+}

package/src/env.d.ts

@@ -0,0 +1,50 @@
+// Minimal Web API type declarations for Deno platform adapter.
+// These types are available in Deno natively, but we declare them here
+// so the package compiles under Node16 moduleResolution without DOM lib.
+
+declare class URL {
+  constructor(url: string, base?: string);
+  readonly pathname: string;
+  readonly searchParams: URLSearchParams;
+}
+
+declare class URLSearchParams {
+  entries(): IterableIterator<[string, string]>;
+}
+
+declare class Headers {
+  constructor();
+  get(name: string): string | null;
+  has(name: string): boolean;
+  set(name: string, value: string): void;
+  append(name: string, value: string): void;
+  forEach(callback: (value: string, key: string) => void): void;
+}
+
+declare class Request {
+  constructor(input: string, init?: RequestInit);
+  readonly url: string;
+  readonly method: string;
+  readonly headers: Headers;
+  text(): Promise<string>;
+  json(): Promise<unknown>;
+}
+
+interface RequestInit {
+  method?: string;
+  headers?: Record<string, string> | Headers;
+  body?: string | null;
+}
+
+declare class Response {
+  constructor(body?: string | null, init?: ResponseInit);
+  readonly status: number;
+  readonly headers: Headers;
+  text(): Promise<string>;
+  json(): Promise<unknown>;
+}
+
+interface ResponseInit {
+  status?: number;
+  headers?: Record<string, string> | Headers;
+}

package/src/index.test.ts

@@ -0,0 +1,307 @@
+// @typokit/platform-deno — Tests
+
+import { describe, it, expect } from "@rstest/core";
+import {
+  normalizeRequest,
+  buildResponse,
+  getPlatformInfo,
+  createServer,
+} from "./index.js";
+import type { TypoKitResponse } from "@typokit/types";
+
+// ─── getPlatformInfo ─────────────────────────────────────────
+
+describe("getPlatformInfo", () => {
+  it("returns deno runtime", () => {
+    const g = globalThis as unknown as Record<string, unknown>;
+    g["Deno"] = { version: { deno: "2.0.0", v8: "12.0", typescript: "5.0" } };
+    try {
+      const info = getPlatformInfo();
+      expect(info.runtime).toBe("deno");
+      expect(info.version).toBe("2.0.0");
+    } finally {
+      delete g["Deno"];
+    }
+  });
+
+  it("returns unknown version when Deno global is missing", () => {
+    const info = getPlatformInfo();
+    expect(info.runtime).toBe("deno");
+    expect(info.version).toBe("unknown");
+  });
+});
+
+// ─── normalizeRequest ────────────────────────────────────────
+
+describe("normalizeRequest", () => {
+  it("parses method, path, headers, and query from Request", async () => {
+    const req = new Request("http://localhost:3000/hello?foo=bar", {
+      method: "GET",
+      headers: { "x-test": "yes" },
+    });
+
+    const normalized = await normalizeRequest(req);
+
+    expect(normalized.method).toBe("GET");
+    expect(normalized.path).toBe("/hello");
+    expect(normalized.query["foo"]).toBe("bar");
+    expect(normalized.headers["x-test"]).toBe("yes");
+    expect(normalized.params).toEqual({});
+  });
+
+  it("collects JSON body when content-type is application/json", async () => {
+    const req = new Request("http://localhost:3000/data", {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({ name: "test" }),
+    });
+
+    const normalized = await normalizeRequest(req);
+
+    expect(normalized.method).toBe("POST");
+    expect(normalized.body).toEqual({ name: "test" });
+  });
+
+  it("returns raw string body when content-type is not JSON", async () => {
+    const req = new Request("http://localhost:3000/text", {
+      method: "POST",
+      headers: { "content-type": "text/plain" },
+      body: "hello world",
+    });
+
+    const normalized = await normalizeRequest(req);
+    expect(normalized.body).toBe("hello world");
+  });
+
+  it("returns undefined body for GET requests", async () => {
+    const req = new Request("http://localhost:3000/empty", {
+      method: "GET",
+    });
+
+    const normalized = await normalizeRequest(req);
+    expect(normalized.body).toBeUndefined();
+  });
+
+  it("handles multiple query params with the same key", async () => {
+    const req = new Request("http://localhost:3000/multi?tag=a&tag=b", {
+      method: "GET",
+    });
+
+    const normalized = await normalizeRequest(req);
+    expect(normalized.query["tag"]).toEqual(["a", "b"]);
+  });
+});
+
+// ─── buildResponse ───────────────────────────────────────────
+
+describe("buildResponse", () => {
+  it("builds a Response with status, headers, and JSON body", () => {
+    const typoResponse: TypoKitResponse = {
+      status: 201,
+      headers: { "x-custom": "value" },
+      body: { created: true },
+    };
+
+    const response = buildResponse(typoResponse);
+
+    expect(response.status).toBe(201);
+    expect(response.headers.get("x-custom")).toBe("value");
+    expect(response.headers.get("content-type")).toBe("application/json");
+  });
+
+  it("builds a Response with string body", async () => {
+    const typoResponse: TypoKitResponse = {
+      status: 200,
+      headers: { "content-type": "text/plain" },
+      body: "hello",
+    };
+
+    const response = buildResponse(typoResponse);
+    const text = await response.text();
+
+    expect(response.status).toBe(200);
+    expect(text).toBe("hello");
+  });
+
+  it("builds a Response with null body", () => {
+    const typoResponse: TypoKitResponse = {
+      status: 204,
+      headers: {},
+      body: null,
+    };
+
+    const response = buildResponse(typoResponse);
+    expect(response.status).toBe(204);
+  });
+
+  it("handles array header values", () => {
+    const typoResponse: TypoKitResponse = {
+      status: 200,
+      headers: { "set-cookie": ["a=1", "b=2"] },
+      body: null,
+    };
+
+    const response = buildResponse(typoResponse);
+    expect(response.headers.get("set-cookie")).toContain("a=1");
+  });
+});
+
+// ─── createServer ────────────────────────────────────────────
+
+describe("createServer", () => {
+  it("creates a server instance with listen method", () => {
+    const srv = createServer(async () => ({
+      status: 200,
+      headers: {},
+      body: null,
+    }));
+
+    expect(typeof srv.listen).toBe("function");
+    expect(srv.server).toBeNull();
+  });
+
+  it("calls Deno.serve when listen is invoked", async () => {
+    const mockServer = {
+      shutdown: async () => {},
+      finished: Promise.resolve(),
+      addr: { port: 3000, hostname: "0.0.0.0" },
+    };
+
+    const g = globalThis as unknown as Record<string, unknown>;
+    g["Deno"] = {
+      version: { deno: "2.0.0", v8: "12.0", typescript: "5.0" },
+      serve: (opts: {
+        onListen?: (addr: { port: number; hostname: string }) => void;
+      }) => {
+        if (opts.onListen) {
+          opts.onListen(mockServer.addr);
+        }
+        return mockServer;
+      },
+    };
+
+    try {
+      const srv = createServer(async () => ({
+        status: 200,
+        headers: {},
+        body: { ok: true },
+      }));
+
+      const handle = await srv.listen(3000);
+      expect(srv.server).not.toBeNull();
+
+      await handle.close();
+      expect(srv.server).toBeNull();
+    } finally {
+      delete g["Deno"];
+    }
+  });
+
+  it("rejects when Deno global is not available", async () => {
+    const srv = createServer(async () => ({
+      status: 200,
+      headers: {},
+      body: null,
+    }));
+
+    let error: Error | null = null;
+    try {
+      await srv.listen(3000);
+    } catch (err) {
+      error = err as Error;
+    }
+    expect(error).not.toBeNull();
+  });
+
+  it("fetch handler converts request and returns response", async () => {
+    let capturedHandler: ((req: Request) => Promise<Response>) | null = null;
+    const mockServer = {
+      shutdown: async () => {},
+      finished: Promise.resolve(),
+      addr: { port: 3001, hostname: "0.0.0.0" },
+    };
+
+    const g = globalThis as unknown as Record<string, unknown>;
+    g["Deno"] = {
+      version: { deno: "2.0.0", v8: "12.0", typescript: "5.0" },
+      serve: (
+        opts: { onListen?: (addr: { port: number; hostname: string }) => void },
+        handler: (req: Request) => Promise<Response>,
+      ) => {
+        capturedHandler = handler;
+        if (opts.onListen) {
+          opts.onListen(mockServer.addr);
+        }
+        return mockServer;
+      },
+    };
+
+    try {
+      const srv = createServer(async (req) => ({
+        status: 200,
+        headers: { "content-type": "application/json" },
+        body: { echo: req.path },
+      }));
+
+      await srv.listen(3001);
+
+      // Simulate a request through the captured handler
+      const webReq = new Request("http://localhost:3001/test-path");
+      const webResp = await capturedHandler!(webReq);
+
+      expect(webResp.status).toBe(200);
+      const body = await webResp.json();
+      expect(body).toEqual({ echo: "/test-path" });
+
+      const handle = await srv.listen(3001);
+      await handle.close();
+    } finally {
+      delete g["Deno"];
+    }
+  });
+
+  it("fetch handler returns 500 when handler throws", async () => {
+    let capturedHandler: ((req: Request) => Promise<Response>) | null = null;
+    const mockServer = {
+      shutdown: async () => {},
+      finished: Promise.resolve(),
+      addr: { port: 3002, hostname: "0.0.0.0" },
+    };
+
+    const g = globalThis as unknown as Record<string, unknown>;
+    g["Deno"] = {
+      version: { deno: "2.0.0", v8: "12.0", typescript: "5.0" },
+      serve: (
+        opts: { onListen?: (addr: { port: number; hostname: string }) => void },
+        handler: (req: Request) => Promise<Response>,
+      ) => {
+        capturedHandler = handler;
+        if (opts.onListen) {
+          opts.onListen(mockServer.addr);
+        }
+        return mockServer;
+      },
+    };
+
+    try {
+      const srv = createServer(async () => {
+        throw new Error("boom");
+      });
+
+      await srv.listen(3002);
+
+      const webReq = new Request("http://localhost:3002/fail");
+      const webResp = await capturedHandler!(webReq);
+
+      expect(webResp.status).toBe(500);
+      const body = (await webResp.json()) as { error: string; message: string };
+      expect(body.error).toBe("Internal Server Error");
+      expect(body.message).toBe("boom");
+
+      const handle = await srv.listen(3002);
+      await handle.close();
+    } finally {
+      delete g["Deno"];
+    }
+  });
+});

package/src/index.ts

@@ -0,0 +1,250 @@
+// @typokit/platform-deno — Deno Platform Adapter
+
+import type {
+  HttpMethod,
+  ServerHandle,
+  TypoKitRequest,
+  TypoKitResponse,
+} from "@typokit/types";
+
+// ─── Deno Type Declarations ─────────────────────────────────
+// Minimal type declarations for Deno APIs so this package compiles
+// without Deno types installed (they're only available in Deno runtimes).
+
+/** Subset of Deno's HttpServer type we rely on */
+interface DenoHttpServer {
+  shutdown(): Promise<void>;
+  finished: Promise<void>;
+  addr: { port: number; hostname: string };
+}
+
+/** Options passed to Deno.serve() */
+interface DenoServeOptions {
+  port: number;
+  hostname: string;
+  onListen?: (addr: { port: number; hostname: string }) => void;
+}
+
+/** Minimal shape of the global Deno object */
+interface DenoGlobal {
+  version: { deno: string; v8: string; typescript: string };
+  serve(
+    options: DenoServeOptions,
+    handler: (req: Request) => Promise<Response> | Response,
+  ): DenoHttpServer;
+}
+
+// ─── Platform Info ───────────────────────────────────────────
+
+/** Runtime platform metadata for diagnostics and inspect commands */
+export interface PlatformInfo {
+  runtime: string;
+  version: string;
+}
+
+/** Returns Deno platform info */
+export function getPlatformInfo(): PlatformInfo {
+  const deno = (globalThis as unknown as { Deno: DenoGlobal }).Deno;
+  return {
+    runtime: "deno",
+    version: deno?.version?.deno ?? "unknown",
+  };
+}
+
+// ─── Request / Response Helpers ──────────────────────────────
+
+/** Parse query string from a URL into a Record */
+function parseQuery(
+  searchParams: URLSearchParams,
+): Record<string, string | string[] | undefined> {
+  const result: Record<string, string | string[] | undefined> = {};
+  for (const [key, value] of searchParams.entries()) {
+    const existing = result[key];
+    if (existing === undefined) {
+      result[key] = value;
+    } else if (Array.isArray(existing)) {
+      existing.push(value);
+    } else {
+      result[key] = [existing, value];
+    }
+  }
+  return result;
+}
+
+/** Normalize Web API headers into a flat Record */
+function normalizeHeaders(
+  headers: Headers,
+): Record<string, string | string[] | undefined> {
+  const result: Record<string, string | string[] | undefined> = {};
+  headers.forEach((value, key) => {
+    result[key] = value;
+  });
+  return result;
+}
+
+/**
+ * Normalize a Web API Request (used by Deno.serve) into a TypoKitRequest.
+ */
+export async function normalizeRequest(req: Request): Promise<TypoKitRequest> {
+  const url = new URL(req.url);
+
+  let body: unknown = undefined;
+  if (req.method !== "GET" && req.method !== "HEAD") {
+    const contentType = req.headers.get("content-type") ?? "";
+    const raw = await req.text();
+    if (raw) {
+      if (contentType.includes("application/json")) {
+        try {
+          body = JSON.parse(raw);
+        } catch {
+          body = raw;
+        }
+      } else {
+        body = raw;
+      }
+    }
+  }
+
+  return {
+    method: req.method.toUpperCase() as HttpMethod,
+    path: url.pathname,
+    headers: normalizeHeaders(req.headers),
+    body,
+    query: parseQuery(url.searchParams),
+    params: {},
+  };
+}
+
+/**
+ * Convert a TypoKitResponse into a Web API Response for Deno.serve().
+ */
+export function buildResponse(response: TypoKitResponse): Response {
+  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);
+      }
+    }
+  }
+
+  let bodyContent: string | null = null;
+  if (response.body === null || response.body === undefined) {
+    bodyContent = null;
+  } else if (typeof response.body === "string") {
+    bodyContent = response.body;
+  } else {
+    if (!headers.has("content-type")) {
+      headers.set("content-type", "application/json");
+    }
+    bodyContent = JSON.stringify(response.body);
+  }
+
+  return new Response(bodyContent, {
+    status: response.status,
+    headers,
+  });
+}
+
+// ─── Request Handler Type ────────────────────────────────────
+
+/** Handler function that receives a normalized request and returns a response */
+export type DenoRequestHandler = (
+  req: TypoKitRequest,
+) => Promise<TypoKitResponse>;
+
+// ─── Deno Server Options ─────────────────────────────────────
+
+export interface DenoServerOptions {
+  /** Optional hostname to bind to (default: "0.0.0.0") */
+  hostname?: string;
+}
+
+// ─── Deno Server ─────────────────────────────────────────────
+
+/** Result of createServer — provides listen/close and access to the underlying Deno server */
+export interface DenoServerInstance {
+  /** Start listening on the given port. Returns a handle for graceful shutdown. */
+  listen(port: number): Promise<ServerHandle>;
+  /** The underlying Deno HTTP server instance (available after listen()) */
+  server: DenoHttpServer | null;
+}
+
+/**
+ * Create a Deno HTTP server that dispatches to a TypoKit request handler.
+ *
+ * Usage:
+ * ```ts
+ * const srv = createServer(async (req) => ({
+ *   status: 200,
+ *   headers: {},
+ *   body: { ok: true },
+ * }));
+ * const handle = await srv.listen(3000);
+ * // ... later
+ * await handle.close();
+ * ```
+ */
+export function createServer(
+  handler: DenoRequestHandler,
+  options: DenoServerOptions = {},
+): DenoServerInstance {
+  const hostname = options.hostname ?? "0.0.0.0";
+  let denoServer: DenoHttpServer | null = null;
+
+  const instance: DenoServerInstance = {
+    get server(): DenoHttpServer | null {
+      return denoServer;
+    },
+    listen(port: number): Promise<ServerHandle> {
+      return new Promise((resolve, reject) => {
+        try {
+          const deno = (globalThis as unknown as { Deno: DenoGlobal }).Deno;
+          denoServer = deno.serve(
+            {
+              port,
+              hostname,
+              onListen() {
+                resolve({
+                  async close(): Promise<void> {
+                    if (denoServer) {
+                      await denoServer.shutdown();
+                      denoServer = null;
+                    }
+                  },
+                });
+              },
+            },
+            async (req: Request): Promise<Response> => {
+              try {
+                const normalized = await normalizeRequest(req);
+                const response = await handler(normalized);
+                return buildResponse(response);
+              } catch (err: unknown) {
+                return new Response(
+                  JSON.stringify({
+                    error: "Internal Server Error",
+                    message:
+                      err instanceof Error ? err.message : "Unknown error",
+                  }),
+                  {
+                    status: 500,
+                    headers: { "content-type": "application/json" },
+                  },
+                );
+              }
+            },
+          );
+        } catch (err) {
+          reject(err);
+        }
+      });
+    },
+  };
+
+  return instance;
+}