litzjs 0.0.0

package/dist/server.js

@@ -0,0 +1,316 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_internal_transport = require("./internal-transport-DR0r68ff.js");
+const require_request_headers = require("./request-headers-ZPR3TQs3.js");
+//#region src/server/index.ts
+let rscRendererPromise;
+function createServer(options = {}) {
+	const manifest = options.manifest ?? {};
+	async function handle(request) {
+		const url = new URL(request.url);
+		let contextLoaded = false;
+		let contextValue;
+		async function getContext() {
+			if (contextLoaded) return contextValue;
+			contextLoaded = true;
+			contextValue = options.createContext ? await options.createContext(request) : void 0;
+			return contextValue;
+		}
+		try {
+			if (url.pathname === "/_litzjs/resource") return handleResourceRequest(request, manifest.resources ?? [], getContext);
+			if (url.pathname === "/_litzjs/route" || url.pathname === "/_litzjs/action") return handleRouteRequest(request, manifest.routes ?? [], getContext);
+			const apiResponse = await handleApiRequest(request, manifest.apiRoutes ?? [], getContext);
+			if (apiResponse) return apiResponse;
+			if (request.method === "GET" || request.method === "HEAD") {
+				const assetResponse = await options.assets?.(request);
+				if (assetResponse) return toHeadResponseIfNeeded(request, assetResponse);
+				if (shouldServeDocument(request, url.pathname)) {
+					const documentResponse = await createDocumentResponse(options.document, request);
+					if (documentResponse) return toHeadResponseIfNeeded(request, documentResponse);
+				}
+			}
+			return new Response("Not Found", { status: 404 });
+		} catch (error) {
+			const context = contextLoaded ? contextValue : void 0;
+			options.onError?.(error, context);
+			return new Response("Litz server error.", {
+				status: 500,
+				headers: { "content-type": "text/plain; charset=utf-8" }
+			});
+		}
+	}
+	return { fetch: handle };
+}
+async function createDocumentResponse(document, request) {
+	if (!document) return null;
+	if (typeof document === "string") return new Response(request.method === "HEAD" ? null : document, {
+		status: 200,
+		headers: { "content-type": "text/html; charset=utf-8" }
+	});
+	return document(request);
+}
+function toHeadResponseIfNeeded(request, response) {
+	if (request.method !== "HEAD") return response;
+	return new Response(null, {
+		status: response.status,
+		statusText: response.statusText,
+		headers: response.headers
+	});
+}
+async function handleResourceRequest(request, resources, getContext) {
+	if (request.method !== "POST") return new Response("Method Not Allowed", { status: 405 });
+	const body = await require_request_headers.parseInternalRequestBody(request);
+	const resourcePath = body.path;
+	const operation = body.operation ?? "loader";
+	const entry = resources.find((resource) => resource.path === resourcePath);
+	if (!resourcePath || !entry?.resource) return createLitzJsonResponse(404, {
+		kind: "error",
+		message: "Resource not found."
+	});
+	const handler = operation === "action" ? entry.resource.action : entry.resource.loader;
+	const middleware = entry.resource.middleware ?? [];
+	if (!handler) return createLitzJsonResponse(405, {
+		kind: "error",
+		message: `Resource does not define a ${operation}.`
+	});
+	const normalizedRequest = normalizeInternalRequest(request, resourcePath, body.request, body.payload);
+	const signal = request.signal;
+	const context = await getContext();
+	return createServerResultResponse(await runMiddlewareChain({
+		middleware,
+		request: normalizedRequest.request,
+		params: normalizedRequest.params,
+		signal,
+		context,
+		execute(nextContext) {
+			return handler({
+				request: normalizedRequest.request,
+				params: normalizedRequest.params,
+				signal,
+				context: nextContext
+			});
+		}
+	}), `${entry.path}#${operation}`);
+}
+async function handleRouteRequest(request, routes, getContext) {
+	if (request.method !== "POST") return new Response("Method Not Allowed", { status: 405 });
+	const body = await require_request_headers.parseInternalRequestBody(request);
+	const routePath = body.path;
+	const targetId = body.target;
+	const operation = body.operation ?? (new URL(request.url).pathname === "/_litzjs/action" ? "action" : "loader");
+	const entry = routes.find((route) => route.path === routePath);
+	if (!routePath || !entry?.route) return createLitzJsonResponse(404, {
+		kind: "error",
+		message: "Route not found."
+	});
+	const chain = getRouteMatchChain(entry);
+	const target = operation === "action" ? chain[chain.length - 1] : findTargetRouteMatch(chain, targetId ?? routePath);
+	if (!target) return createLitzJsonResponse(404, {
+		kind: "error",
+		message: "Route target not found."
+	});
+	const targetIndex = chain.findIndex((candidate) => candidate.id === target.id);
+	const handler = operation === "action" ? entry.route.action ?? entry.route.options?.action : target.loader;
+	const middleware = chain.slice(0, targetIndex + 1).flatMap((candidate) => candidate.middleware);
+	if (!handler) return createLitzJsonResponse(405, {
+		kind: "error",
+		message: `Route does not define a ${operation}.`
+	});
+	const normalizedRequest = normalizeInternalRequest(request, routePath, body.request, body.payload);
+	const signal = request.signal;
+	const context = await getContext();
+	return createServerResultResponse(await runMiddlewareChain({
+		middleware,
+		request: normalizedRequest.request,
+		params: operation === "action" ? normalizedRequest.params : require_internal_transport.extractRouteLikeParams(target.path, new URL(normalizedRequest.request.url).pathname) ?? normalizedRequest.params,
+		signal,
+		context,
+		execute(nextContext) {
+			const params = operation === "action" ? normalizedRequest.params : require_internal_transport.extractRouteLikeParams(target.path, new URL(normalizedRequest.request.url).pathname) ?? normalizedRequest.params;
+			return handler({
+				request: normalizedRequest.request,
+				params,
+				signal,
+				context: nextContext
+			});
+		}
+	}), `${target.id}#${operation}`);
+}
+async function handleApiRequest(request, apiRoutes, getContext) {
+	const url = new URL(request.url);
+	const matched = apiRoutes.map((candidate) => ({
+		entry: candidate,
+		params: require_internal_transport.matchPathname(candidate.path, url.pathname)
+	})).find((candidate) => candidate.params !== null);
+	if (!matched?.entry.api?.methods) return null;
+	const params = matched.params;
+	if (!params) return null;
+	const method = request.method.toUpperCase();
+	const handler = matched.entry.api.methods[method] ?? matched.entry.api.methods.ALL;
+	const middleware = matched.entry.api.middleware ?? [];
+	if (!handler) return new Response("Method Not Allowed", { status: 405 });
+	const signal = request.signal;
+	return runMiddlewareChain({
+		middleware,
+		request,
+		params,
+		signal,
+		context: await getContext(),
+		execute(nextContext) {
+			return handler({
+				request,
+				params,
+				signal,
+				context: nextContext
+			});
+		}
+	});
+}
+async function runMiddlewareChain(options) {
+	const dispatch = async (index, context) => {
+		const middleware = options.middleware[index];
+		if (!middleware) return options.execute(context);
+		let called = false;
+		return middleware({
+			request: options.request,
+			params: options.params,
+			signal: options.signal,
+			context
+		}, async (overrides) => {
+			if (called) throw new Error("Litz middleware next() called multiple times.");
+			called = true;
+			const nextContext = overrides && Object.prototype.hasOwnProperty.call(overrides, "context") ? overrides.context : context;
+			return dispatch(index + 1, nextContext);
+		});
+	};
+	return dispatch(0, options.context);
+}
+function getRouteMatchChain(entry) {
+	return [...collectLayouts(entry.route?.options?.layout).map((layout) => ({
+		id: layout.id,
+		path: layout.path,
+		loader: layout.options?.loader,
+		middleware: layout.options?.middleware ?? []
+	})), {
+		id: entry.id,
+		path: entry.path,
+		loader: entry.route?.loader ?? entry.route?.options?.loader,
+		middleware: entry.route?.options?.middleware ?? []
+	}];
+}
+function collectLayouts(layout) {
+	if (!layout) return [];
+	return [...collectLayouts(layout.options?.layout), layout];
+}
+function findTargetRouteMatch(chain, targetId) {
+	return chain.find((entry) => entry.id === targetId);
+}
+async function createServerResultResponse(result, viewId = "litzjs#view") {
+	if (!result || typeof result !== "object" || !("kind" in result)) return createLitzJsonResponse(500, {
+		kind: "fault",
+		message: "Handler returned an unknown result."
+	});
+	const serverResult = result;
+	const headers = new Headers(serverResult.headers);
+	applyRevalidateHeader(headers, serverResult.revalidate);
+	switch (serverResult.kind) {
+		case "data": return createLitzJsonResponse(serverResult.status ?? 200, {
+			kind: "data",
+			data: serverResult.data,
+			revalidate: serverResult.revalidate ?? []
+		}, headers);
+		case "invalid": return createLitzJsonResponse(serverResult.status ?? 422, {
+			kind: "invalid",
+			fields: serverResult.fields,
+			formError: serverResult.formError,
+			data: serverResult.data
+		}, headers);
+		case "redirect": return createLitzJsonResponse(serverResult.status ?? 303, {
+			kind: "redirect",
+			location: serverResult.location,
+			replace: serverResult.replace ?? false,
+			revalidate: serverResult.revalidate ?? []
+		}, headers);
+		case "error": return createLitzJsonResponse(serverResult.status ?? 500, {
+			kind: "error",
+			message: serverResult.message ?? "Error",
+			code: serverResult.code,
+			data: serverResult.data
+		}, headers);
+		case "fault": return createLitzJsonResponse(serverResult.status ?? 500, {
+			kind: "fault",
+			message: serverResult.message ?? "Fault",
+			digest: serverResult.digest
+		}, headers);
+		case "view": {
+			headers.set("content-type", "text/x-component");
+			headers.set("x-litzjs-kind", "view");
+			headers.set("x-litzjs-status", String(serverResult.status ?? 200));
+			headers.set("x-litzjs-view-id", viewId);
+			const stream = (await loadRscRenderer()).renderToReadableStream(serverResult.node);
+			return new Response(stream, {
+				status: serverResult.status ?? 200,
+				headers
+			});
+		}
+		default: return createLitzJsonResponse(500, {
+			kind: "fault",
+			message: `Unsupported result kind "${serverResult.kind}".`
+		});
+	}
+}
+async function loadRscRenderer() {
+	rscRendererPromise ??= import("@vitejs/plugin-rsc/rsc");
+	return rscRendererPromise;
+}
+function createLitzJsonResponse(status, body, headers) {
+	const responseHeaders = new Headers(headers);
+	responseHeaders.set("content-type", "application/vnd.litzjs.result+json");
+	return new Response(JSON.stringify(body), {
+		status,
+		headers: responseHeaders
+	});
+}
+function applyRevalidateHeader(headers, revalidate) {
+	if (!revalidate?.length) return;
+	headers.set("x-litzjs-revalidate", revalidate.join(","));
+}
+function normalizeInternalRequest(originalRequest, pathPattern, requestData, payload) {
+	const params = requestData?.params ?? {};
+	const search = new URLSearchParams(requestData?.search ?? {});
+	const url = new URL(originalRequest.url);
+	url.pathname = interpolatePath(pathPattern, params);
+	url.search = search.toString();
+	url.hash = "";
+	let body;
+	if (payload) {
+		body = new FormData();
+		for (const [key, value] of payload.entries) body.append(key, value);
+	}
+	return {
+		request: new Request(url, {
+			method: body ? "POST" : "GET",
+			headers: require_request_headers.createInternalHandlerHeaders(originalRequest.headers),
+			signal: originalRequest.signal,
+			body
+		}),
+		params
+	};
+}
+function interpolatePath(pathPattern, params) {
+	return pathPattern.replace(/:([A-Za-z0-9_]+)/g, (_, key) => {
+		const value = params[key];
+		if (value === void 0) throw new Error(`Missing required path param "${key}" for path "${pathPattern}".`);
+		return encodeURIComponent(value);
+	});
+}
+function shouldServeDocument(request, pathname) {
+	if (pathname.startsWith("/_litzjs/") || pathname.startsWith("/api/")) return false;
+	if (lastPathSegment(pathname).includes(".")) return false;
+	const accept = request.headers.get("accept") ?? "";
+	return accept.includes("text/html") || accept.includes("*/*");
+}
+function lastPathSegment(pathname) {
+	return require_internal_transport.trimPathSegments(pathname).at(-1) ?? "";
+}
+//#endregion
+exports.createServer = createServer;

package/dist/server.mjs

@@ -0,0 +1,315 @@
+import { a as matchPathname, i as extractRouteLikeParams, s as trimPathSegments } from "./internal-transport-dsMykcNK.mjs";
+import { n as parseInternalRequestBody, t as createInternalHandlerHeaders } from "./request-headers-DepZ5tjg.mjs";
+//#region src/server/index.ts
+let rscRendererPromise;
+function createServer(options = {}) {
+	const manifest = options.manifest ?? {};
+	async function handle(request) {
+		const url = new URL(request.url);
+		let contextLoaded = false;
+		let contextValue;
+		async function getContext() {
+			if (contextLoaded) return contextValue;
+			contextLoaded = true;
+			contextValue = options.createContext ? await options.createContext(request) : void 0;
+			return contextValue;
+		}
+		try {
+			if (url.pathname === "/_litzjs/resource") return handleResourceRequest(request, manifest.resources ?? [], getContext);
+			if (url.pathname === "/_litzjs/route" || url.pathname === "/_litzjs/action") return handleRouteRequest(request, manifest.routes ?? [], getContext);
+			const apiResponse = await handleApiRequest(request, manifest.apiRoutes ?? [], getContext);
+			if (apiResponse) return apiResponse;
+			if (request.method === "GET" || request.method === "HEAD") {
+				const assetResponse = await options.assets?.(request);
+				if (assetResponse) return toHeadResponseIfNeeded(request, assetResponse);
+				if (shouldServeDocument(request, url.pathname)) {
+					const documentResponse = await createDocumentResponse(options.document, request);
+					if (documentResponse) return toHeadResponseIfNeeded(request, documentResponse);
+				}
+			}
+			return new Response("Not Found", { status: 404 });
+		} catch (error) {
+			const context = contextLoaded ? contextValue : void 0;
+			options.onError?.(error, context);
+			return new Response("Litz server error.", {
+				status: 500,
+				headers: { "content-type": "text/plain; charset=utf-8" }
+			});
+		}
+	}
+	return { fetch: handle };
+}
+async function createDocumentResponse(document, request) {
+	if (!document) return null;
+	if (typeof document === "string") return new Response(request.method === "HEAD" ? null : document, {
+		status: 200,
+		headers: { "content-type": "text/html; charset=utf-8" }
+	});
+	return document(request);
+}
+function toHeadResponseIfNeeded(request, response) {
+	if (request.method !== "HEAD") return response;
+	return new Response(null, {
+		status: response.status,
+		statusText: response.statusText,
+		headers: response.headers
+	});
+}
+async function handleResourceRequest(request, resources, getContext) {
+	if (request.method !== "POST") return new Response("Method Not Allowed", { status: 405 });
+	const body = await parseInternalRequestBody(request);
+	const resourcePath = body.path;
+	const operation = body.operation ?? "loader";
+	const entry = resources.find((resource) => resource.path === resourcePath);
+	if (!resourcePath || !entry?.resource) return createLitzJsonResponse(404, {
+		kind: "error",
+		message: "Resource not found."
+	});
+	const handler = operation === "action" ? entry.resource.action : entry.resource.loader;
+	const middleware = entry.resource.middleware ?? [];
+	if (!handler) return createLitzJsonResponse(405, {
+		kind: "error",
+		message: `Resource does not define a ${operation}.`
+	});
+	const normalizedRequest = normalizeInternalRequest(request, resourcePath, body.request, body.payload);
+	const signal = request.signal;
+	const context = await getContext();
+	return createServerResultResponse(await runMiddlewareChain({
+		middleware,
+		request: normalizedRequest.request,
+		params: normalizedRequest.params,
+		signal,
+		context,
+		execute(nextContext) {
+			return handler({
+				request: normalizedRequest.request,
+				params: normalizedRequest.params,
+				signal,
+				context: nextContext
+			});
+		}
+	}), `${entry.path}#${operation}`);
+}
+async function handleRouteRequest(request, routes, getContext) {
+	if (request.method !== "POST") return new Response("Method Not Allowed", { status: 405 });
+	const body = await parseInternalRequestBody(request);
+	const routePath = body.path;
+	const targetId = body.target;
+	const operation = body.operation ?? (new URL(request.url).pathname === "/_litzjs/action" ? "action" : "loader");
+	const entry = routes.find((route) => route.path === routePath);
+	if (!routePath || !entry?.route) return createLitzJsonResponse(404, {
+		kind: "error",
+		message: "Route not found."
+	});
+	const chain = getRouteMatchChain(entry);
+	const target = operation === "action" ? chain[chain.length - 1] : findTargetRouteMatch(chain, targetId ?? routePath);
+	if (!target) return createLitzJsonResponse(404, {
+		kind: "error",
+		message: "Route target not found."
+	});
+	const targetIndex = chain.findIndex((candidate) => candidate.id === target.id);
+	const handler = operation === "action" ? entry.route.action ?? entry.route.options?.action : target.loader;
+	const middleware = chain.slice(0, targetIndex + 1).flatMap((candidate) => candidate.middleware);
+	if (!handler) return createLitzJsonResponse(405, {
+		kind: "error",
+		message: `Route does not define a ${operation}.`
+	});
+	const normalizedRequest = normalizeInternalRequest(request, routePath, body.request, body.payload);
+	const signal = request.signal;
+	const context = await getContext();
+	return createServerResultResponse(await runMiddlewareChain({
+		middleware,
+		request: normalizedRequest.request,
+		params: operation === "action" ? normalizedRequest.params : extractRouteLikeParams(target.path, new URL(normalizedRequest.request.url).pathname) ?? normalizedRequest.params,
+		signal,
+		context,
+		execute(nextContext) {
+			const params = operation === "action" ? normalizedRequest.params : extractRouteLikeParams(target.path, new URL(normalizedRequest.request.url).pathname) ?? normalizedRequest.params;
+			return handler({
+				request: normalizedRequest.request,
+				params,
+				signal,
+				context: nextContext
+			});
+		}
+	}), `${target.id}#${operation}`);
+}
+async function handleApiRequest(request, apiRoutes, getContext) {
+	const url = new URL(request.url);
+	const matched = apiRoutes.map((candidate) => ({
+		entry: candidate,
+		params: matchPathname(candidate.path, url.pathname)
+	})).find((candidate) => candidate.params !== null);
+	if (!matched?.entry.api?.methods) return null;
+	const params = matched.params;
+	if (!params) return null;
+	const method = request.method.toUpperCase();
+	const handler = matched.entry.api.methods[method] ?? matched.entry.api.methods.ALL;
+	const middleware = matched.entry.api.middleware ?? [];
+	if (!handler) return new Response("Method Not Allowed", { status: 405 });
+	const signal = request.signal;
+	return runMiddlewareChain({
+		middleware,
+		request,
+		params,
+		signal,
+		context: await getContext(),
+		execute(nextContext) {
+			return handler({
+				request,
+				params,
+				signal,
+				context: nextContext
+			});
+		}
+	});
+}
+async function runMiddlewareChain(options) {
+	const dispatch = async (index, context) => {
+		const middleware = options.middleware[index];
+		if (!middleware) return options.execute(context);
+		let called = false;
+		return middleware({
+			request: options.request,
+			params: options.params,
+			signal: options.signal,
+			context
+		}, async (overrides) => {
+			if (called) throw new Error("Litz middleware next() called multiple times.");
+			called = true;
+			const nextContext = overrides && Object.prototype.hasOwnProperty.call(overrides, "context") ? overrides.context : context;
+			return dispatch(index + 1, nextContext);
+		});
+	};
+	return dispatch(0, options.context);
+}
+function getRouteMatchChain(entry) {
+	return [...collectLayouts(entry.route?.options?.layout).map((layout) => ({
+		id: layout.id,
+		path: layout.path,
+		loader: layout.options?.loader,
+		middleware: layout.options?.middleware ?? []
+	})), {
+		id: entry.id,
+		path: entry.path,
+		loader: entry.route?.loader ?? entry.route?.options?.loader,
+		middleware: entry.route?.options?.middleware ?? []
+	}];
+}
+function collectLayouts(layout) {
+	if (!layout) return [];
+	return [...collectLayouts(layout.options?.layout), layout];
+}
+function findTargetRouteMatch(chain, targetId) {
+	return chain.find((entry) => entry.id === targetId);
+}
+async function createServerResultResponse(result, viewId = "litzjs#view") {
+	if (!result || typeof result !== "object" || !("kind" in result)) return createLitzJsonResponse(500, {
+		kind: "fault",
+		message: "Handler returned an unknown result."
+	});
+	const serverResult = result;
+	const headers = new Headers(serverResult.headers);
+	applyRevalidateHeader(headers, serverResult.revalidate);
+	switch (serverResult.kind) {
+		case "data": return createLitzJsonResponse(serverResult.status ?? 200, {
+			kind: "data",
+			data: serverResult.data,
+			revalidate: serverResult.revalidate ?? []
+		}, headers);
+		case "invalid": return createLitzJsonResponse(serverResult.status ?? 422, {
+			kind: "invalid",
+			fields: serverResult.fields,
+			formError: serverResult.formError,
+			data: serverResult.data
+		}, headers);
+		case "redirect": return createLitzJsonResponse(serverResult.status ?? 303, {
+			kind: "redirect",
+			location: serverResult.location,
+			replace: serverResult.replace ?? false,
+			revalidate: serverResult.revalidate ?? []
+		}, headers);
+		case "error": return createLitzJsonResponse(serverResult.status ?? 500, {
+			kind: "error",
+			message: serverResult.message ?? "Error",
+			code: serverResult.code,
+			data: serverResult.data
+		}, headers);
+		case "fault": return createLitzJsonResponse(serverResult.status ?? 500, {
+			kind: "fault",
+			message: serverResult.message ?? "Fault",
+			digest: serverResult.digest
+		}, headers);
+		case "view": {
+			headers.set("content-type", "text/x-component");
+			headers.set("x-litzjs-kind", "view");
+			headers.set("x-litzjs-status", String(serverResult.status ?? 200));
+			headers.set("x-litzjs-view-id", viewId);
+			const stream = (await loadRscRenderer()).renderToReadableStream(serverResult.node);
+			return new Response(stream, {
+				status: serverResult.status ?? 200,
+				headers
+			});
+		}
+		default: return createLitzJsonResponse(500, {
+			kind: "fault",
+			message: `Unsupported result kind "${serverResult.kind}".`
+		});
+	}
+}
+async function loadRscRenderer() {
+	rscRendererPromise ??= import("@vitejs/plugin-rsc/rsc");
+	return rscRendererPromise;
+}
+function createLitzJsonResponse(status, body, headers) {
+	const responseHeaders = new Headers(headers);
+	responseHeaders.set("content-type", "application/vnd.litzjs.result+json");
+	return new Response(JSON.stringify(body), {
+		status,
+		headers: responseHeaders
+	});
+}
+function applyRevalidateHeader(headers, revalidate) {
+	if (!revalidate?.length) return;
+	headers.set("x-litzjs-revalidate", revalidate.join(","));
+}
+function normalizeInternalRequest(originalRequest, pathPattern, requestData, payload) {
+	const params = requestData?.params ?? {};
+	const search = new URLSearchParams(requestData?.search ?? {});
+	const url = new URL(originalRequest.url);
+	url.pathname = interpolatePath(pathPattern, params);
+	url.search = search.toString();
+	url.hash = "";
+	let body;
+	if (payload) {
+		body = new FormData();
+		for (const [key, value] of payload.entries) body.append(key, value);
+	}
+	return {
+		request: new Request(url, {
+			method: body ? "POST" : "GET",
+			headers: createInternalHandlerHeaders(originalRequest.headers),
+			signal: originalRequest.signal,
+			body
+		}),
+		params
+	};
+}
+function interpolatePath(pathPattern, params) {
+	return pathPattern.replace(/:([A-Za-z0-9_]+)/g, (_, key) => {
+		const value = params[key];
+		if (value === void 0) throw new Error(`Missing required path param "${key}" for path "${pathPattern}".`);
+		return encodeURIComponent(value);
+	});
+}
+function shouldServeDocument(request, pathname) {
+	if (pathname.startsWith("/_litzjs/") || pathname.startsWith("/api/")) return false;
+	if (lastPathSegment(pathname).includes(".")) return false;
+	const accept = request.headers.get("accept") ?? "";
+	return accept.includes("text/html") || accept.includes("*/*");
+}
+function lastPathSegment(pathname) {
+	return trimPathSegments(pathname).at(-1) ?? "";
+}
+//#endregion
+export { createServer };