@mokup/server 0.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 ice breaker
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/index.cjs

@@ -0,0 +1,187 @@
+'use strict';
+
+const runtime = require('@mokup/runtime');
+const fetch = require('./shared/server.BdTl0qJd.cjs');
+
+function createConnectMiddleware(options) {
+  const runtime$1 = runtime.createRuntime(fetch.toRuntimeOptions(options));
+  const onNotFound = options.onNotFound ?? "next";
+  return async (req, res, next) => {
+    const runtimeRequest = await fetch.toRuntimeRequestFromNode(req);
+    const result = await runtime$1.handle(runtimeRequest);
+    if (!result) {
+      if (onNotFound === "response") {
+        res.statusCode = 404;
+        res.end();
+        return;
+      }
+      next();
+      return;
+    }
+    fetch.applyRuntimeResultToNode(res, result);
+  };
+}
+
+function createExpressMiddleware(options) {
+  return createConnectMiddleware(options);
+}
+
+function createFastifyPlugin(options) {
+  const runtime$1 = runtime.createRuntime(fetch.toRuntimeOptions(options));
+  const onNotFound = options.onNotFound ?? "next";
+  return async (instance) => {
+    instance.addHook("onRequest", async (request, reply) => {
+      const runtimeRequest = await fetch.toRuntimeRequestFromNode(
+        request.raw ?? request,
+        request.body
+      );
+      const result = await runtime$1.handle(runtimeRequest);
+      if (!result) {
+        if (onNotFound === "response") {
+          reply.status(404).send();
+        }
+        return;
+      }
+      reply.status(result.status);
+      for (const [key, value] of Object.entries(result.headers)) {
+        reply.header(key, value);
+      }
+      if (result.body === null) {
+        reply.send();
+        return;
+      }
+      if (typeof result.body === "string") {
+        reply.send(result.body);
+        return;
+      }
+      reply.send(fetch.toBinaryBody(result.body));
+    });
+  };
+}
+
+function createHonoMiddleware(options) {
+  const handler = fetch.createFetchHandler(options);
+  const middleware = async (context, next) => {
+    const response = await handler(context.req.raw);
+    if (!response) {
+      return await next();
+    }
+    return response;
+  };
+  const route = {
+    basePath: "",
+    path: "*",
+    method: "ALL",
+    handler: middleware
+  };
+  const bridge = middleware;
+  bridge.routes = [route];
+  return bridge;
+}
+
+function createKoaMiddleware(options) {
+  const runtime$1 = runtime.createRuntime(fetch.toRuntimeOptions(options));
+  const onNotFound = options.onNotFound ?? "next";
+  return async (ctx, next) => {
+    const runtimeRequest = await fetch.toRuntimeRequestFromNode(
+      ctx.req,
+      ctx.request?.body
+    );
+    const result = await runtime$1.handle(runtimeRequest);
+    if (!result) {
+      if (onNotFound === "response") {
+        ctx.status = 404;
+        ctx.body = null;
+        return;
+      }
+      await next();
+      return;
+    }
+    ctx.status = result.status;
+    ctx.set(result.headers);
+    if (result.body === null) {
+      ctx.body = null;
+      return;
+    }
+    if (typeof result.body === "string") {
+      ctx.body = result.body;
+      return;
+    }
+    ctx.body = fetch.toBinaryBody(result.body);
+  };
+}
+
+function isManifest(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) && "version" in value && "routes" in value;
+}
+function normalizeWorkerOptions(bundle) {
+  const options = {
+    manifest: bundle.manifest,
+    onNotFound: bundle.onNotFound ?? "response"
+  };
+  if (typeof bundle.moduleBase !== "undefined") {
+    options.moduleBase = bundle.moduleBase;
+  }
+  if (typeof bundle.moduleMap !== "undefined") {
+    options.moduleMap = bundle.moduleMap;
+  }
+  return options;
+}
+async function loadBundleFromDir(dir) {
+  const nodeProcess = await import('node:process');
+  const isNode = typeof nodeProcess !== "undefined" && !!nodeProcess.versions?.node;
+  if (!isNode) {
+    throw new TypeError("createMokupWorker(dir) is only supported in Node runtimes.");
+  }
+  const { readFile, access } = await import('node:fs/promises');
+  const { resolve, join } = await import('node:path');
+  const { pathToFileURL } = await import('node:url');
+  const manifestPath = resolve(dir, "mokup.manifest.json");
+  const manifestRaw = await readFile(manifestPath, "utf8");
+  const manifest = JSON.parse(manifestRaw);
+  const handlersIndexPath = resolve(dir, "mokup-handlers", "index.mjs");
+  let moduleMap;
+  try {
+    await access(handlersIndexPath);
+    const module = await import(pathToFileURL(handlersIndexPath).href);
+    moduleMap = module.mokupModuleMap;
+  } catch {
+    moduleMap = void 0;
+  }
+  const bundle = {
+    manifest,
+    moduleBase: join(dir, "/")
+  };
+  if (typeof moduleMap !== "undefined") {
+    bundle.moduleMap = moduleMap;
+  }
+  return bundle;
+}
+function createWorker(handlerOptions) {
+  const handler = fetch.createFetchHandler(handlerOptions);
+  return {
+    fetch: async (request) => {
+      return await handler(request) ?? new Response("Not Found", { status: 404 });
+    }
+  };
+}
+function createMokupWorker(input) {
+  if (typeof input === "string") {
+    return loadBundleFromDir(input).then((bundle) => createWorker(normalizeWorkerOptions(bundle)));
+  }
+  if (isManifest(input)) {
+    return createWorker({
+      manifest: input,
+      onNotFound: "response"
+    });
+  }
+  return createWorker(normalizeWorkerOptions(input));
+}
+
+exports.createFetchHandler = fetch.createFetchHandler;
+exports.createConnectMiddleware = createConnectMiddleware;
+exports.createExpressMiddleware = createExpressMiddleware;
+exports.createFastifyPlugin = createFastifyPlugin;
+exports.createHonoMiddleware = createHonoMiddleware;
+exports.createKoaMiddleware = createKoaMiddleware;
+exports.createMokupWorker = createMokupWorker;

package/dist/index.d.cts

@@ -0,0 +1,78 @@
+import { M as MokupServerOptions, F as FetchHandler, a as MokupWorkerInput } from './shared/server.C0FGI34s.cjs';
+export { b as MokupWorkerBundle } from './shared/server.C0FGI34s.cjs';
+export { Manifest, ManifestRoute, ModuleMap, RuntimeOptions } from '@mokup/runtime';
+
+interface ReadableStreamLike {
+    on: (event: string, listener: (...args: unknown[]) => void) => void;
+}
+interface NodeRequestLike extends ReadableStreamLike {
+    method?: string;
+    url?: string;
+    originalUrl?: string;
+    headers?: Record<string, string | string[] | undefined>;
+    body?: unknown;
+}
+interface NodeResponseLike {
+    statusCode?: number;
+    setHeader: (name: string, value: string) => void;
+    end: (data?: string | Uint8Array | ArrayBuffer | null) => void;
+}
+
+type NextFunction = (error?: unknown) => void;
+declare function createConnectMiddleware(options: MokupServerOptions): (req: NodeRequestLike, res: NodeResponseLike, next: NextFunction) => Promise<void>;
+
+declare function createExpressMiddleware(options: MokupServerOptions): (req: NodeRequestLike, res: NodeResponseLike, next: (error?: unknown) => void) => Promise<void>;
+
+interface FastifyRequestLike extends NodeRequestLike {
+    raw?: NodeRequestLike;
+}
+interface FastifyReplyLike {
+    status: (code: number) => FastifyReplyLike;
+    header: (name: string, value: string) => FastifyReplyLike;
+    send: (payload?: unknown) => void;
+}
+interface FastifyInstanceLike {
+    addHook: (name: 'onRequest' | 'preHandler', handler: (request: FastifyRequestLike, reply: FastifyReplyLike) => Promise<void> | void) => void;
+}
+declare function createFastifyPlugin(options: MokupServerOptions): (instance: FastifyInstanceLike) => Promise<void>;
+
+declare function createFetchHandler(options: MokupServerOptions): FetchHandler;
+
+interface HonoContextLike {
+    req: {
+        raw: Request;
+    };
+    notFound?: () => Response;
+}
+type HonoNext = () => Promise<unknown>;
+type HonoMiddleware = (context: HonoContextLike, next: HonoNext) => Promise<unknown>;
+interface HonoRouteLike {
+    basePath: string;
+    path: string;
+    method: string;
+    handler: HonoMiddleware;
+}
+declare function createHonoMiddleware(options: MokupServerOptions): HonoMiddleware & {
+    routes: HonoRouteLike[];
+};
+
+interface KoaContextLike {
+    req: NodeRequestLike;
+    request?: {
+        body?: unknown;
+        headers?: Record<string, string | string[] | undefined>;
+    };
+    status?: number;
+    body?: unknown;
+    set: (header: Record<string, string>) => void;
+}
+type KoaNext = () => Promise<unknown>;
+declare function createKoaMiddleware(options: MokupServerOptions): (ctx: KoaContextLike, next: KoaNext) => Promise<void>;
+
+interface MokupWorker {
+    fetch: (request: Request) => Promise<Response>;
+}
+declare function createMokupWorker(input: string): Promise<MokupWorker>;
+declare function createMokupWorker(input: Exclude<MokupWorkerInput, string>): MokupWorker;
+
+export { FetchHandler, MokupServerOptions, MokupWorkerInput, createConnectMiddleware, createExpressMiddleware, createFastifyPlugin, createFetchHandler, createHonoMiddleware, createKoaMiddleware, createMokupWorker };

package/dist/index.d.mts

@@ -0,0 +1,78 @@
+import { M as MokupServerOptions, F as FetchHandler, a as MokupWorkerInput } from './shared/server.C0FGI34s.mjs';
+export { b as MokupWorkerBundle } from './shared/server.C0FGI34s.mjs';
+export { Manifest, ManifestRoute, ModuleMap, RuntimeOptions } from '@mokup/runtime';
+
+interface ReadableStreamLike {
+    on: (event: string, listener: (...args: unknown[]) => void) => void;
+}
+interface NodeRequestLike extends ReadableStreamLike {
+    method?: string;
+    url?: string;
+    originalUrl?: string;
+    headers?: Record<string, string | string[] | undefined>;
+    body?: unknown;
+}
+interface NodeResponseLike {
+    statusCode?: number;
+    setHeader: (name: string, value: string) => void;
+    end: (data?: string | Uint8Array | ArrayBuffer | null) => void;
+}
+
+type NextFunction = (error?: unknown) => void;
+declare function createConnectMiddleware(options: MokupServerOptions): (req: NodeRequestLike, res: NodeResponseLike, next: NextFunction) => Promise<void>;
+
+declare function createExpressMiddleware(options: MokupServerOptions): (req: NodeRequestLike, res: NodeResponseLike, next: (error?: unknown) => void) => Promise<void>;
+
+interface FastifyRequestLike extends NodeRequestLike {
+    raw?: NodeRequestLike;
+}
+interface FastifyReplyLike {
+    status: (code: number) => FastifyReplyLike;
+    header: (name: string, value: string) => FastifyReplyLike;
+    send: (payload?: unknown) => void;
+}
+interface FastifyInstanceLike {
+    addHook: (name: 'onRequest' | 'preHandler', handler: (request: FastifyRequestLike, reply: FastifyReplyLike) => Promise<void> | void) => void;
+}
+declare function createFastifyPlugin(options: MokupServerOptions): (instance: FastifyInstanceLike) => Promise<void>;
+
+declare function createFetchHandler(options: MokupServerOptions): FetchHandler;
+
+interface HonoContextLike {
+    req: {
+        raw: Request;
+    };
+    notFound?: () => Response;
+}
+type HonoNext = () => Promise<unknown>;
+type HonoMiddleware = (context: HonoContextLike, next: HonoNext) => Promise<unknown>;
+interface HonoRouteLike {
+    basePath: string;
+    path: string;
+    method: string;
+    handler: HonoMiddleware;
+}
+declare function createHonoMiddleware(options: MokupServerOptions): HonoMiddleware & {
+    routes: HonoRouteLike[];
+};
+
+interface KoaContextLike {
+    req: NodeRequestLike;
+    request?: {
+        body?: unknown;
+        headers?: Record<string, string | string[] | undefined>;
+    };
+    status?: number;
+    body?: unknown;
+    set: (header: Record<string, string>) => void;
+}
+type KoaNext = () => Promise<unknown>;
+declare function createKoaMiddleware(options: MokupServerOptions): (ctx: KoaContextLike, next: KoaNext) => Promise<void>;
+
+interface MokupWorker {
+    fetch: (request: Request) => Promise<Response>;
+}
+declare function createMokupWorker(input: string): Promise<MokupWorker>;
+declare function createMokupWorker(input: Exclude<MokupWorkerInput, string>): MokupWorker;
+
+export { FetchHandler, MokupServerOptions, MokupWorkerInput, createConnectMiddleware, createExpressMiddleware, createFastifyPlugin, createFetchHandler, createHonoMiddleware, createKoaMiddleware, createMokupWorker };

package/dist/index.d.ts

@@ -0,0 +1,78 @@
+import { M as MokupServerOptions, F as FetchHandler, a as MokupWorkerInput } from './shared/server.C0FGI34s.js';
+export { b as MokupWorkerBundle } from './shared/server.C0FGI34s.js';
+export { Manifest, ManifestRoute, ModuleMap, RuntimeOptions } from '@mokup/runtime';
+
+interface ReadableStreamLike {
+    on: (event: string, listener: (...args: unknown[]) => void) => void;
+}
+interface NodeRequestLike extends ReadableStreamLike {
+    method?: string;
+    url?: string;
+    originalUrl?: string;
+    headers?: Record<string, string | string[] | undefined>;
+    body?: unknown;
+}
+interface NodeResponseLike {
+    statusCode?: number;
+    setHeader: (name: string, value: string) => void;
+    end: (data?: string | Uint8Array | ArrayBuffer | null) => void;
+}
+
+type NextFunction = (error?: unknown) => void;
+declare function createConnectMiddleware(options: MokupServerOptions): (req: NodeRequestLike, res: NodeResponseLike, next: NextFunction) => Promise<void>;
+
+declare function createExpressMiddleware(options: MokupServerOptions): (req: NodeRequestLike, res: NodeResponseLike, next: (error?: unknown) => void) => Promise<void>;
+
+interface FastifyRequestLike extends NodeRequestLike {
+    raw?: NodeRequestLike;
+}
+interface FastifyReplyLike {
+    status: (code: number) => FastifyReplyLike;
+    header: (name: string, value: string) => FastifyReplyLike;
+    send: (payload?: unknown) => void;
+}
+interface FastifyInstanceLike {
+    addHook: (name: 'onRequest' | 'preHandler', handler: (request: FastifyRequestLike, reply: FastifyReplyLike) => Promise<void> | void) => void;
+}
+declare function createFastifyPlugin(options: MokupServerOptions): (instance: FastifyInstanceLike) => Promise<void>;
+
+declare function createFetchHandler(options: MokupServerOptions): FetchHandler;
+
+interface HonoContextLike {
+    req: {
+        raw: Request;
+    };
+    notFound?: () => Response;
+}
+type HonoNext = () => Promise<unknown>;
+type HonoMiddleware = (context: HonoContextLike, next: HonoNext) => Promise<unknown>;
+interface HonoRouteLike {
+    basePath: string;
+    path: string;
+    method: string;
+    handler: HonoMiddleware;
+}
+declare function createHonoMiddleware(options: MokupServerOptions): HonoMiddleware & {
+    routes: HonoRouteLike[];
+};
+
+interface KoaContextLike {
+    req: NodeRequestLike;
+    request?: {
+        body?: unknown;
+        headers?: Record<string, string | string[] | undefined>;
+    };
+    status?: number;
+    body?: unknown;
+    set: (header: Record<string, string>) => void;
+}
+type KoaNext = () => Promise<unknown>;
+declare function createKoaMiddleware(options: MokupServerOptions): (ctx: KoaContextLike, next: KoaNext) => Promise<void>;
+
+interface MokupWorker {
+    fetch: (request: Request) => Promise<Response>;
+}
+declare function createMokupWorker(input: string): Promise<MokupWorker>;
+declare function createMokupWorker(input: Exclude<MokupWorkerInput, string>): MokupWorker;
+
+export { FetchHandler, MokupServerOptions, MokupWorkerInput, createConnectMiddleware, createExpressMiddleware, createFastifyPlugin, createFetchHandler, createHonoMiddleware, createKoaMiddleware, createMokupWorker };

package/dist/index.mjs

@@ -0,0 +1,179 @@
+import { createRuntime } from '@mokup/runtime';
+import { t as toRuntimeOptions, a as toRuntimeRequestFromNode, b as applyRuntimeResultToNode, c as toBinaryBody, d as createFetchHandler } from './shared/server.HVB7OYyI.mjs';
+
+function createConnectMiddleware(options) {
+  const runtime = createRuntime(toRuntimeOptions(options));
+  const onNotFound = options.onNotFound ?? "next";
+  return async (req, res, next) => {
+    const runtimeRequest = await toRuntimeRequestFromNode(req);
+    const result = await runtime.handle(runtimeRequest);
+    if (!result) {
+      if (onNotFound === "response") {
+        res.statusCode = 404;
+        res.end();
+        return;
+      }
+      next();
+      return;
+    }
+    applyRuntimeResultToNode(res, result);
+  };
+}
+
+function createExpressMiddleware(options) {
+  return createConnectMiddleware(options);
+}
+
+function createFastifyPlugin(options) {
+  const runtime = createRuntime(toRuntimeOptions(options));
+  const onNotFound = options.onNotFound ?? "next";
+  return async (instance) => {
+    instance.addHook("onRequest", async (request, reply) => {
+      const runtimeRequest = await toRuntimeRequestFromNode(
+        request.raw ?? request,
+        request.body
+      );
+      const result = await runtime.handle(runtimeRequest);
+      if (!result) {
+        if (onNotFound === "response") {
+          reply.status(404).send();
+        }
+        return;
+      }
+      reply.status(result.status);
+      for (const [key, value] of Object.entries(result.headers)) {
+        reply.header(key, value);
+      }
+      if (result.body === null) {
+        reply.send();
+        return;
+      }
+      if (typeof result.body === "string") {
+        reply.send(result.body);
+        return;
+      }
+      reply.send(toBinaryBody(result.body));
+    });
+  };
+}
+
+function createHonoMiddleware(options) {
+  const handler = createFetchHandler(options);
+  const middleware = async (context, next) => {
+    const response = await handler(context.req.raw);
+    if (!response) {
+      return await next();
+    }
+    return response;
+  };
+  const route = {
+    basePath: "",
+    path: "*",
+    method: "ALL",
+    handler: middleware
+  };
+  const bridge = middleware;
+  bridge.routes = [route];
+  return bridge;
+}
+
+function createKoaMiddleware(options) {
+  const runtime = createRuntime(toRuntimeOptions(options));
+  const onNotFound = options.onNotFound ?? "next";
+  return async (ctx, next) => {
+    const runtimeRequest = await toRuntimeRequestFromNode(
+      ctx.req,
+      ctx.request?.body
+    );
+    const result = await runtime.handle(runtimeRequest);
+    if (!result) {
+      if (onNotFound === "response") {
+        ctx.status = 404;
+        ctx.body = null;
+        return;
+      }
+      await next();
+      return;
+    }
+    ctx.status = result.status;
+    ctx.set(result.headers);
+    if (result.body === null) {
+      ctx.body = null;
+      return;
+    }
+    if (typeof result.body === "string") {
+      ctx.body = result.body;
+      return;
+    }
+    ctx.body = toBinaryBody(result.body);
+  };
+}
+
+function isManifest(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) && "version" in value && "routes" in value;
+}
+function normalizeWorkerOptions(bundle) {
+  const options = {
+    manifest: bundle.manifest,
+    onNotFound: bundle.onNotFound ?? "response"
+  };
+  if (typeof bundle.moduleBase !== "undefined") {
+    options.moduleBase = bundle.moduleBase;
+  }
+  if (typeof bundle.moduleMap !== "undefined") {
+    options.moduleMap = bundle.moduleMap;
+  }
+  return options;
+}
+async function loadBundleFromDir(dir) {
+  const nodeProcess = await import('node:process');
+  const isNode = typeof nodeProcess !== "undefined" && !!nodeProcess.versions?.node;
+  if (!isNode) {
+    throw new TypeError("createMokupWorker(dir) is only supported in Node runtimes.");
+  }
+  const { readFile, access } = await import('node:fs/promises');
+  const { resolve, join } = await import('node:path');
+  const { pathToFileURL } = await import('node:url');
+  const manifestPath = resolve(dir, "mokup.manifest.json");
+  const manifestRaw = await readFile(manifestPath, "utf8");
+  const manifest = JSON.parse(manifestRaw);
+  const handlersIndexPath = resolve(dir, "mokup-handlers", "index.mjs");
+  let moduleMap;
+  try {
+    await access(handlersIndexPath);
+    const module = await import(pathToFileURL(handlersIndexPath).href);
+    moduleMap = module.mokupModuleMap;
+  } catch {
+    moduleMap = void 0;
+  }
+  const bundle = {
+    manifest,
+    moduleBase: join(dir, "/")
+  };
+  if (typeof moduleMap !== "undefined") {
+    bundle.moduleMap = moduleMap;
+  }
+  return bundle;
+}
+function createWorker(handlerOptions) {
+  const handler = createFetchHandler(handlerOptions);
+  return {
+    fetch: async (request) => {
+      return await handler(request) ?? new Response("Not Found", { status: 404 });
+    }
+  };
+}
+function createMokupWorker(input) {
+  if (typeof input === "string") {
+    return loadBundleFromDir(input).then((bundle) => createWorker(normalizeWorkerOptions(bundle)));
+  }
+  if (isManifest(input)) {
+    return createWorker({
+      manifest: input,
+      onNotFound: "response"
+    });
+  }
+  return createWorker(normalizeWorkerOptions(input));
+}
+
+export { createConnectMiddleware, createExpressMiddleware, createFastifyPlugin, createFetchHandler, createHonoMiddleware, createKoaMiddleware, createMokupWorker };

package/dist/shared/server.BdTl0qJd.cjs

@@ -0,0 +1,264 @@
+'use strict';
+
+const runtime = require('@mokup/runtime');
+
+const textDecoder = new TextDecoder();
+const textEncoder = new TextEncoder();
+function toRuntimeOptions(options) {
+  const runtimeOptions = {
+    manifest: options.manifest
+  };
+  if (typeof options.moduleBase !== "undefined") {
+    runtimeOptions.moduleBase = options.moduleBase;
+  }
+  if (typeof options.moduleMap !== "undefined") {
+    runtimeOptions.moduleMap = options.moduleMap;
+  }
+  return runtimeOptions;
+}
+function normalizeQuery(params) {
+  const query = {};
+  for (const [key, value] of params.entries()) {
+    const current = query[key];
+    if (typeof current === "undefined") {
+      query[key] = value;
+    } else if (Array.isArray(current)) {
+      current.push(value);
+    } else {
+      query[key] = [current, value];
+    }
+  }
+  return query;
+}
+function normalizeHeaders(headers) {
+  const record = {};
+  headers.forEach((value, key) => {
+    record[key.toLowerCase()] = value;
+  });
+  return record;
+}
+function normalizeNodeHeaders(headers) {
+  if (!headers) {
+    return {};
+  }
+  const record = {};
+  for (const [key, value] of Object.entries(headers)) {
+    if (typeof value === "undefined") {
+      continue;
+    }
+    record[key.toLowerCase()] = Array.isArray(value) ? value.join(",") : String(value);
+  }
+  return record;
+}
+function parseBody(rawText, contentType) {
+  if (!rawText) {
+    return void 0;
+  }
+  if (contentType === "application/json" || contentType.endsWith("+json")) {
+    try {
+      return JSON.parse(rawText);
+    } catch {
+      return rawText;
+    }
+  }
+  if (contentType === "application/x-www-form-urlencoded") {
+    const params = new URLSearchParams(rawText);
+    return Object.fromEntries(params.entries());
+  }
+  return rawText;
+}
+function decodeText(data) {
+  return textDecoder.decode(data);
+}
+function toBinaryBody(body) {
+  return body;
+}
+function toArrayBuffer(body) {
+  const { buffer, byteOffset, byteLength } = body;
+  if (buffer instanceof ArrayBuffer && byteOffset === 0 && byteLength === buffer.byteLength) {
+    return buffer;
+  }
+  const copy = new Uint8Array(byteLength);
+  copy.set(body);
+  return copy.buffer;
+}
+function resolveUrl(input, headers) {
+  if (/^https?:\/\//.test(input)) {
+    return new URL(input);
+  }
+  const host = headers.host;
+  const base = host ? `http://${host}` : "http://localhost";
+  return new URL(input, base);
+}
+function concatChunks(chunks) {
+  if (chunks.length === 1) {
+    return chunks[0] ?? new Uint8Array();
+  }
+  let totalLength = 0;
+  for (const chunk of chunks) {
+    totalLength += chunk.length;
+  }
+  const merged = new Uint8Array(totalLength);
+  let offset = 0;
+  for (const chunk of chunks) {
+    merged.set(chunk, offset);
+    offset += chunk.length;
+  }
+  return merged;
+}
+async function readStreamBody(stream) {
+  return await new Promise((resolve, reject) => {
+    const chunks = [];
+    let hasData = false;
+    stream.on("data", (chunk) => {
+      hasData = true;
+      if (typeof chunk === "string") {
+        chunks.push(textEncoder.encode(chunk));
+        return;
+      }
+      if (chunk instanceof Uint8Array) {
+        chunks.push(chunk);
+        return;
+      }
+      if (chunk instanceof ArrayBuffer) {
+        chunks.push(new Uint8Array(chunk));
+        return;
+      }
+      chunks.push(textEncoder.encode(String(chunk)));
+    });
+    stream.on("end", () => {
+      if (!hasData) {
+        resolve(null);
+        return;
+      }
+      resolve(concatChunks(chunks));
+    });
+    stream.on("error", (error) => {
+      reject(error);
+    });
+  });
+}
+async function resolveBody(body, contentType, stream) {
+  if (typeof body !== "undefined") {
+    if (typeof body === "string") {
+      return {
+        body: parseBody(body, contentType),
+        rawBody: body
+      };
+    }
+    if (body instanceof Uint8Array) {
+      const rawText2 = decodeText(body);
+      return {
+        body: parseBody(rawText2, contentType),
+        rawBody: rawText2
+      };
+    }
+    if (body instanceof ArrayBuffer) {
+      const rawText2 = decodeText(new Uint8Array(body));
+      return {
+        body: parseBody(rawText2, contentType),
+        rawBody: rawText2
+      };
+    }
+    return {
+      body
+    };
+  }
+  if (!stream) {
+    return { body: void 0 };
+  }
+  const rawBytes = await readStreamBody(stream);
+  if (!rawBytes || rawBytes.length === 0) {
+    return { body: void 0 };
+  }
+  const rawText = decodeText(rawBytes);
+  return {
+    body: parseBody(rawText, contentType),
+    rawBody: rawText
+  };
+}
+function buildRuntimeRequest(url, method, headers, body, rawBody) {
+  const request = {
+    method,
+    path: url.pathname,
+    query: normalizeQuery(url.searchParams),
+    headers,
+    body
+  };
+  if (rawBody) {
+    request.rawBody = rawBody;
+  }
+  return request;
+}
+async function toRuntimeRequestFromFetch(request) {
+  const url = new URL(request.url);
+  const headers = normalizeHeaders(request.headers);
+  const contentType = (headers["content-type"] ?? "").split(";")[0]?.trim() ?? "";
+  const rawBody = await request.text();
+  const body = parseBody(rawBody, contentType);
+  return buildRuntimeRequest(
+    url,
+    request.method,
+    headers,
+    body,
+    rawBody || void 0
+  );
+}
+async function toRuntimeRequestFromNode(req, bodyOverride) {
+  const headers = normalizeNodeHeaders(req.headers);
+  const contentType = (headers["content-type"] ?? "").split(";")[0]?.trim() ?? "";
+  const url = resolveUrl(req.originalUrl ?? req.url ?? "/", headers);
+  const resolvedBody = await resolveBody(
+    typeof bodyOverride === "undefined" ? req.body : bodyOverride,
+    contentType,
+    req
+  );
+  return buildRuntimeRequest(
+    url,
+    req.method ?? "GET",
+    headers,
+    resolvedBody.body,
+    resolvedBody.rawBody
+  );
+}
+function applyRuntimeResultToNode(res, result) {
+  res.statusCode = result.status;
+  for (const [key, value] of Object.entries(result.headers)) {
+    res.setHeader(key, value);
+  }
+  if (result.body === null) {
+    res.end();
+    return;
+  }
+  if (typeof result.body === "string") {
+    res.end(result.body);
+    return;
+  }
+  res.end(toBinaryBody(result.body));
+}
+
+function createFetchHandler(options) {
+  const runtime$1 = runtime.createRuntime(toRuntimeOptions(options));
+  const onNotFound = options.onNotFound ?? "next";
+  return async (request) => {
+    const runtimeRequest = await toRuntimeRequestFromFetch(request);
+    const result = await runtime$1.handle(runtimeRequest);
+    if (!result) {
+      if (onNotFound === "response") {
+        return new Response(null, { status: 404 });
+      }
+      return null;
+    }
+    const responseBody = result.body === null ? null : typeof result.body === "string" ? result.body : toArrayBuffer(result.body);
+    return new Response(responseBody, {
+      status: result.status,
+      headers: result.headers
+    });
+  };
+}
+
+exports.applyRuntimeResultToNode = applyRuntimeResultToNode;
+exports.createFetchHandler = createFetchHandler;
+exports.toBinaryBody = toBinaryBody;
+exports.toRuntimeOptions = toRuntimeOptions;
+exports.toRuntimeRequestFromNode = toRuntimeRequestFromNode;

package/dist/shared/server.C0FGI34s.d.cts

@@ -0,0 +1,15 @@
+import { RuntimeOptions, Manifest, ModuleMap } from '@mokup/runtime';
+
+interface MokupServerOptions extends RuntimeOptions {
+    onNotFound?: 'next' | 'response';
+}
+type FetchHandler = (request: Request) => Promise<Response | null>;
+interface MokupWorkerBundle {
+    manifest: Manifest;
+    moduleMap?: ModuleMap;
+    moduleBase?: string | URL;
+    onNotFound?: 'next' | 'response';
+}
+type MokupWorkerInput = string | Manifest | MokupWorkerBundle;
+
+export type { FetchHandler as F, MokupServerOptions as M, MokupWorkerInput as a, MokupWorkerBundle as b };

package/dist/shared/server.C0FGI34s.d.mts

@@ -0,0 +1,15 @@
+import { RuntimeOptions, Manifest, ModuleMap } from '@mokup/runtime';
+
+interface MokupServerOptions extends RuntimeOptions {
+    onNotFound?: 'next' | 'response';
+}
+type FetchHandler = (request: Request) => Promise<Response | null>;
+interface MokupWorkerBundle {
+    manifest: Manifest;
+    moduleMap?: ModuleMap;
+    moduleBase?: string | URL;
+    onNotFound?: 'next' | 'response';
+}
+type MokupWorkerInput = string | Manifest | MokupWorkerBundle;
+
+export type { FetchHandler as F, MokupServerOptions as M, MokupWorkerInput as a, MokupWorkerBundle as b };

package/dist/shared/server.C0FGI34s.d.ts

@@ -0,0 +1,15 @@
+import { RuntimeOptions, Manifest, ModuleMap } from '@mokup/runtime';
+
+interface MokupServerOptions extends RuntimeOptions {
+    onNotFound?: 'next' | 'response';
+}
+type FetchHandler = (request: Request) => Promise<Response | null>;
+interface MokupWorkerBundle {
+    manifest: Manifest;
+    moduleMap?: ModuleMap;
+    moduleBase?: string | URL;
+    onNotFound?: 'next' | 'response';
+}
+type MokupWorkerInput = string | Manifest | MokupWorkerBundle;
+
+export type { FetchHandler as F, MokupServerOptions as M, MokupWorkerInput as a, MokupWorkerBundle as b };

package/dist/shared/server.HVB7OYyI.mjs

@@ -0,0 +1,258 @@
+import { createRuntime } from '@mokup/runtime';
+
+const textDecoder = new TextDecoder();
+const textEncoder = new TextEncoder();
+function toRuntimeOptions(options) {
+  const runtimeOptions = {
+    manifest: options.manifest
+  };
+  if (typeof options.moduleBase !== "undefined") {
+    runtimeOptions.moduleBase = options.moduleBase;
+  }
+  if (typeof options.moduleMap !== "undefined") {
+    runtimeOptions.moduleMap = options.moduleMap;
+  }
+  return runtimeOptions;
+}
+function normalizeQuery(params) {
+  const query = {};
+  for (const [key, value] of params.entries()) {
+    const current = query[key];
+    if (typeof current === "undefined") {
+      query[key] = value;
+    } else if (Array.isArray(current)) {
+      current.push(value);
+    } else {
+      query[key] = [current, value];
+    }
+  }
+  return query;
+}
+function normalizeHeaders(headers) {
+  const record = {};
+  headers.forEach((value, key) => {
+    record[key.toLowerCase()] = value;
+  });
+  return record;
+}
+function normalizeNodeHeaders(headers) {
+  if (!headers) {
+    return {};
+  }
+  const record = {};
+  for (const [key, value] of Object.entries(headers)) {
+    if (typeof value === "undefined") {
+      continue;
+    }
+    record[key.toLowerCase()] = Array.isArray(value) ? value.join(",") : String(value);
+  }
+  return record;
+}
+function parseBody(rawText, contentType) {
+  if (!rawText) {
+    return void 0;
+  }
+  if (contentType === "application/json" || contentType.endsWith("+json")) {
+    try {
+      return JSON.parse(rawText);
+    } catch {
+      return rawText;
+    }
+  }
+  if (contentType === "application/x-www-form-urlencoded") {
+    const params = new URLSearchParams(rawText);
+    return Object.fromEntries(params.entries());
+  }
+  return rawText;
+}
+function decodeText(data) {
+  return textDecoder.decode(data);
+}
+function toBinaryBody(body) {
+  return body;
+}
+function toArrayBuffer(body) {
+  const { buffer, byteOffset, byteLength } = body;
+  if (buffer instanceof ArrayBuffer && byteOffset === 0 && byteLength === buffer.byteLength) {
+    return buffer;
+  }
+  const copy = new Uint8Array(byteLength);
+  copy.set(body);
+  return copy.buffer;
+}
+function resolveUrl(input, headers) {
+  if (/^https?:\/\//.test(input)) {
+    return new URL(input);
+  }
+  const host = headers.host;
+  const base = host ? `http://${host}` : "http://localhost";
+  return new URL(input, base);
+}
+function concatChunks(chunks) {
+  if (chunks.length === 1) {
+    return chunks[0] ?? new Uint8Array();
+  }
+  let totalLength = 0;
+  for (const chunk of chunks) {
+    totalLength += chunk.length;
+  }
+  const merged = new Uint8Array(totalLength);
+  let offset = 0;
+  for (const chunk of chunks) {
+    merged.set(chunk, offset);
+    offset += chunk.length;
+  }
+  return merged;
+}
+async function readStreamBody(stream) {
+  return await new Promise((resolve, reject) => {
+    const chunks = [];
+    let hasData = false;
+    stream.on("data", (chunk) => {
+      hasData = true;
+      if (typeof chunk === "string") {
+        chunks.push(textEncoder.encode(chunk));
+        return;
+      }
+      if (chunk instanceof Uint8Array) {
+        chunks.push(chunk);
+        return;
+      }
+      if (chunk instanceof ArrayBuffer) {
+        chunks.push(new Uint8Array(chunk));
+        return;
+      }
+      chunks.push(textEncoder.encode(String(chunk)));
+    });
+    stream.on("end", () => {
+      if (!hasData) {
+        resolve(null);
+        return;
+      }
+      resolve(concatChunks(chunks));
+    });
+    stream.on("error", (error) => {
+      reject(error);
+    });
+  });
+}
+async function resolveBody(body, contentType, stream) {
+  if (typeof body !== "undefined") {
+    if (typeof body === "string") {
+      return {
+        body: parseBody(body, contentType),
+        rawBody: body
+      };
+    }
+    if (body instanceof Uint8Array) {
+      const rawText2 = decodeText(body);
+      return {
+        body: parseBody(rawText2, contentType),
+        rawBody: rawText2
+      };
+    }
+    if (body instanceof ArrayBuffer) {
+      const rawText2 = decodeText(new Uint8Array(body));
+      return {
+        body: parseBody(rawText2, contentType),
+        rawBody: rawText2
+      };
+    }
+    return {
+      body
+    };
+  }
+  if (!stream) {
+    return { body: void 0 };
+  }
+  const rawBytes = await readStreamBody(stream);
+  if (!rawBytes || rawBytes.length === 0) {
+    return { body: void 0 };
+  }
+  const rawText = decodeText(rawBytes);
+  return {
+    body: parseBody(rawText, contentType),
+    rawBody: rawText
+  };
+}
+function buildRuntimeRequest(url, method, headers, body, rawBody) {
+  const request = {
+    method,
+    path: url.pathname,
+    query: normalizeQuery(url.searchParams),
+    headers,
+    body
+  };
+  if (rawBody) {
+    request.rawBody = rawBody;
+  }
+  return request;
+}
+async function toRuntimeRequestFromFetch(request) {
+  const url = new URL(request.url);
+  const headers = normalizeHeaders(request.headers);
+  const contentType = (headers["content-type"] ?? "").split(";")[0]?.trim() ?? "";
+  const rawBody = await request.text();
+  const body = parseBody(rawBody, contentType);
+  return buildRuntimeRequest(
+    url,
+    request.method,
+    headers,
+    body,
+    rawBody || void 0
+  );
+}
+async function toRuntimeRequestFromNode(req, bodyOverride) {
+  const headers = normalizeNodeHeaders(req.headers);
+  const contentType = (headers["content-type"] ?? "").split(";")[0]?.trim() ?? "";
+  const url = resolveUrl(req.originalUrl ?? req.url ?? "/", headers);
+  const resolvedBody = await resolveBody(
+    typeof bodyOverride === "undefined" ? req.body : bodyOverride,
+    contentType,
+    req
+  );
+  return buildRuntimeRequest(
+    url,
+    req.method ?? "GET",
+    headers,
+    resolvedBody.body,
+    resolvedBody.rawBody
+  );
+}
+function applyRuntimeResultToNode(res, result) {
+  res.statusCode = result.status;
+  for (const [key, value] of Object.entries(result.headers)) {
+    res.setHeader(key, value);
+  }
+  if (result.body === null) {
+    res.end();
+    return;
+  }
+  if (typeof result.body === "string") {
+    res.end(result.body);
+    return;
+  }
+  res.end(toBinaryBody(result.body));
+}
+
+function createFetchHandler(options) {
+  const runtime = createRuntime(toRuntimeOptions(options));
+  const onNotFound = options.onNotFound ?? "next";
+  return async (request) => {
+    const runtimeRequest = await toRuntimeRequestFromFetch(request);
+    const result = await runtime.handle(runtimeRequest);
+    if (!result) {
+      if (onNotFound === "response") {
+        return new Response(null, { status: 404 });
+      }
+      return null;
+    }
+    const responseBody = result.body === null ? null : typeof result.body === "string" ? result.body : toArrayBuffer(result.body);
+    return new Response(responseBody, {
+      status: result.status,
+      headers: result.headers
+    });
+  };
+}
+
+export { toRuntimeRequestFromNode as a, applyRuntimeResultToNode as b, toBinaryBody as c, createFetchHandler as d, toRuntimeOptions as t };

package/dist/worker.cjs

@@ -0,0 +1,43 @@
+'use strict';
+
+const fetch = require('./shared/server.BdTl0qJd.cjs');
+require('@mokup/runtime');
+
+function isManifest(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) && "version" in value && "routes" in value;
+}
+function normalizeWorkerOptions(bundle) {
+  const options = {
+    manifest: bundle.manifest,
+    onNotFound: bundle.onNotFound ?? "response"
+  };
+  if (typeof bundle.moduleBase !== "undefined") {
+    options.moduleBase = bundle.moduleBase;
+  }
+  if (typeof bundle.moduleMap !== "undefined") {
+    options.moduleMap = bundle.moduleMap;
+  }
+  return options;
+}
+function createWorker(handlerOptions) {
+  const handler = fetch.createFetchHandler(handlerOptions);
+  return {
+    fetch: async (request) => {
+      return await handler(request) ?? new Response("Not Found", { status: 404 });
+    }
+  };
+}
+function createMokupWorker(input) {
+  if (typeof input === "string") {
+    throw new TypeError("createMokupWorker(dir) is only supported in Node runtimes.");
+  }
+  if (isManifest(input)) {
+    return createWorker({
+      manifest: input,
+      onNotFound: "response"
+    });
+  }
+  return createWorker(normalizeWorkerOptions(input));
+}
+
+exports.createMokupWorker = createMokupWorker;

package/dist/worker.d.cts

@@ -0,0 +1,10 @@
+import { a as MokupWorkerInput } from './shared/server.C0FGI34s.cjs';
+import '@mokup/runtime';
+
+interface MokupWorker {
+    fetch: (request: Request) => Promise<Response>;
+}
+declare function createMokupWorker(input: Exclude<MokupWorkerInput, string>): MokupWorker;
+
+export { createMokupWorker };
+export type { MokupWorker };

package/dist/worker.d.mts

@@ -0,0 +1,10 @@
+import { a as MokupWorkerInput } from './shared/server.C0FGI34s.mjs';
+import '@mokup/runtime';
+
+interface MokupWorker {
+    fetch: (request: Request) => Promise<Response>;
+}
+declare function createMokupWorker(input: Exclude<MokupWorkerInput, string>): MokupWorker;
+
+export { createMokupWorker };
+export type { MokupWorker };

package/dist/worker.d.ts

@@ -0,0 +1,10 @@
+import { a as MokupWorkerInput } from './shared/server.C0FGI34s.js';
+import '@mokup/runtime';
+
+interface MokupWorker {
+    fetch: (request: Request) => Promise<Response>;
+}
+declare function createMokupWorker(input: Exclude<MokupWorkerInput, string>): MokupWorker;
+
+export { createMokupWorker };
+export type { MokupWorker };

package/dist/worker.mjs

@@ -0,0 +1,41 @@
+import { d as createFetchHandler } from './shared/server.HVB7OYyI.mjs';
+import '@mokup/runtime';
+
+function isManifest(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) && "version" in value && "routes" in value;
+}
+function normalizeWorkerOptions(bundle) {
+  const options = {
+    manifest: bundle.manifest,
+    onNotFound: bundle.onNotFound ?? "response"
+  };
+  if (typeof bundle.moduleBase !== "undefined") {
+    options.moduleBase = bundle.moduleBase;
+  }
+  if (typeof bundle.moduleMap !== "undefined") {
+    options.moduleMap = bundle.moduleMap;
+  }
+  return options;
+}
+function createWorker(handlerOptions) {
+  const handler = createFetchHandler(handlerOptions);
+  return {
+    fetch: async (request) => {
+      return await handler(request) ?? new Response("Not Found", { status: 404 });
+    }
+  };
+}
+function createMokupWorker(input) {
+  if (typeof input === "string") {
+    throw new TypeError("createMokupWorker(dir) is only supported in Node runtimes.");
+  }
+  if (isManifest(input)) {
+    return createWorker({
+      manifest: input,
+      onNotFound: "response"
+    });
+  }
+  return createWorker(normalizeWorkerOptions(input));
+}
+
+export { createMokupWorker };

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "@mokup/server",
+  "type": "module",
+  "version": "0.0.0",
+  "description": "Server adapters for @mokup/runtime.",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/sonofmagic/mokup.git",
+    "directory": "packages/server"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.cjs"
+    },
+    "./worker": {
+      "types": "./dist/worker.d.ts",
+      "import": "./dist/worker.mjs",
+      "require": "./dist/worker.cjs"
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "@mokup/runtime": "0.0.0"
+  },
+  "devDependencies": {
+    "typescript": "^5.9.3",
+    "unbuild": "^3.6.1"
+  },
+  "scripts": {
+    "build": "unbuild",
+    "dev": "unbuild --stub",
+    "lint": "eslint .",
+    "typecheck": "tsc -p tsconfig.json --noEmit"
+  }
+}