@plitzi/sdk-server 0.30.19

package/dist/adapters/jsonAdapters.js

@@ -0,0 +1,46 @@
+import { readFileSync } from "node:fs";
+//#region src/adapters/jsonAdapters.ts
+var isDeploymentObject = (v) => typeof v === "object" && ("spaceId" in v || "environment" in v || "error" in v);
+var readJson = (filePath) => JSON.parse(readFileSync(filePath, "utf-8"));
+var createJsonAdapters = (config) => {
+	const getOfflineData = (spaceId, environment, revision) => {
+		try {
+			const filePath = typeof config.offlineData === "function" ? config.offlineData(spaceId, environment, revision) : config.offlineData;
+			return Promise.resolve(readJson(filePath));
+		} catch (err) {
+			console.error("[JsonAdapters] Failed to read offlineData:", err.message);
+			return Promise.resolve(void 0);
+		}
+	};
+	const getSpaceDeployment = (req) => {
+		const { deployment } = config;
+		if (!deployment) return Promise.resolve({
+			spaceId: 1,
+			environment: "main",
+			revision: 0
+		});
+		if (typeof deployment === "string") try {
+			return Promise.resolve(readJson(deployment));
+		} catch (err) {
+			console.error("[JsonAdapters] Failed to read deployment file:", err.message);
+			return Promise.resolve({ error: {
+				code: 500,
+				message: "Deployment config unreadable"
+			} });
+		}
+		if (isDeploymentObject(deployment)) return Promise.resolve(deployment);
+		const byHostname = deployment;
+		return Promise.resolve(byHostname[req.hostname] ?? byHostname["*"] ?? {
+			spaceId: 1,
+			environment: "main",
+			revision: 0
+		});
+	};
+	return {
+		getOfflineData,
+		getSpaceDeployment,
+		getUser: config.user ? (req) => Promise.resolve(typeof config.user === "function" ? config.user(req) : config.user) : void 0
+	};
+};
+//#endregion
+export { createJsonAdapters };

package/dist/core/createServer.js

@@ -0,0 +1,47 @@
+import { DEFAULT_TTL_MS } from "../helpers/cache/defaults.js";
+import { buildCacheManager } from "../helpers/cache/cacheManager.js";
+import { createServerCaches, destroyServerCaches } from "../helpers/cache/serverCaches.js";
+import { makeHandler } from "./requestHandler.js";
+import { buildTransport, protoLabel } from "./transports.js";
+import normalizePlugins, { normalizePluginSource } from "../helpers/normalizePlugins.js";
+import { compileTemplate } from "../modules/ssr/template.js";
+import { PluginManager } from "../plugins/manager.js";
+//#region src/core/createServer.ts
+var createSSRServer = (config) => {
+	const { httpVersion: version = 2, cacheTtlMs: htmlTtlMs = DEFAULT_TTL_MS.html } = config;
+	if (version >= 3 && !config.tls) throw new Error(`[SSR] httpVersion: ${version} requires a tls config with key and cert`);
+	const caches = createServerCaches(htmlTtlMs, config.rsc?.cacheTtlMs ?? DEFAULT_TTL_MS.rsc);
+	const cache = caches.html ? buildCacheManager(caches.html) : null;
+	const renderFn = config.templateFn ?? compileTemplate();
+	const pluginManager = new PluginManager(normalizePlugins(config.plugins ?? {}), config.pluginsCacheDir, config.pluginsTtlMs, config.devMode);
+	const plugins = {
+		register: (name, source) => {
+			const normalized = normalizePluginSource(source);
+			pluginManager.register(`${name}@${normalized.version}`, normalized);
+		},
+		invalidate: (name, version) => pluginManager.invalidate(name, version)
+	};
+	let primary;
+	let h3;
+	return {
+		cache,
+		plugins,
+		listen(port, host = "0.0.0.0") {
+			const handler = makeHandler(config, port, renderFn, caches, pluginManager);
+			({primary, h3} = buildTransport(config, handler, port));
+			primary.listen(port, host, () => {
+				console.log(`[SSR] ${protoLabel(version, !!config.tls)} - listening on ${host}:${port}`);
+			});
+		},
+		async close() {
+			destroyServerCaches(caches);
+			pluginManager.destroy();
+			const closeOne = (srv) => new Promise((resolve, reject) => {
+				srv.close((err) => err ? reject(err) : resolve());
+			});
+			await Promise.all([closeOne(primary), ...h3 ? [closeOne(h3)] : []]);
+		}
+	};
+};
+//#endregion
+export { createSSRServer };

package/dist/core/mimeTypes.js

@@ -0,0 +1,41 @@
+//#region src/core/mimeTypes.ts
+var MIME_TYPES = {
+	".html": "text/html; charset=utf-8",
+	".js": "application/javascript; charset=utf-8",
+	".mjs": "application/javascript; charset=utf-8",
+	".cjs": "application/javascript; charset=utf-8",
+	".css": "text/css; charset=utf-8",
+	".json": "application/json; charset=utf-8",
+	".png": "image/png",
+	".jpg": "image/jpeg",
+	".jpeg": "image/jpeg",
+	".gif": "image/gif",
+	".svg": "image/svg+xml",
+	".webp": "image/webp",
+	".ico": "image/x-icon",
+	".woff": "font/woff",
+	".woff2": "font/woff2",
+	".ttf": "font/ttf",
+	".eot": "application/vnd.ms-fontobject",
+	".txt": "text/plain; charset=utf-8",
+	".xml": "application/xml"
+};
+var IMMUTABLE_EXTS = new Set([
+	".js",
+	".mjs",
+	".cjs",
+	".css",
+	".woff",
+	".woff2",
+	".ttf",
+	".eot"
+]);
+var getMimeType = (filePath) => {
+	return MIME_TYPES[filePath.slice(filePath.lastIndexOf(".")).toLowerCase()] ?? "application/octet-stream";
+};
+var getCacheControl = (filePath) => {
+	const ext = filePath.slice(filePath.lastIndexOf(".")).toLowerCase();
+	return IMMUTABLE_EXTS.has(ext) ? "public, max-age=31536000, immutable" : "public, max-age=3600";
+};
+//#endregion
+export { getCacheControl, getMimeType };

package/dist/core/requestHandler.js

@@ -0,0 +1,108 @@
+import { parseRequest } from "./requestParser.js";
+import { serveStatic } from "./staticFiles.js";
+import { buildResponseHelpers } from "../helpers/buildResponseHelpers.js";
+import { runMiddlewares } from "../helpers/runMiddlewares.js";
+import { authMiddleware } from "../middlewares/auth.js";
+import { basicAuthMiddleware } from "../middlewares/basicAuth.js";
+import { spaceDeploymentMiddleware } from "../middlewares/spaceDeployment.js";
+import { handleMcp } from "../modules/mcp/handler.js";
+import { handleRsc } from "../modules/rsc/handler.js";
+import { renderSSR } from "../modules/ssr/handler.js";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+//#region src/core/requestHandler.ts
+var __dirname = path.dirname(fileURLToPath(import.meta.url));
+var BUILTIN_PUBLIC_DIR = path.resolve(__dirname, "../public");
+var handleRequest = async (raw, rawRes, config, port, renderFn, caches, pluginManager) => {
+	const req = parseRequest(raw);
+	const res = buildResponseHelpers(rawRes, req.headers["accept-encoding"]);
+	if (req.path === "\0") {
+		res.setStatus(400);
+		res.end();
+		return;
+	}
+	res.setHeader("X-Content-Type-Options", "nosniff");
+	res.setHeader("Referrer-Policy", "strict-origin-when-cross-origin");
+	res.setHeader("X-DNS-Prefetch-Control", "off");
+	const frameOptions = config.frameOptions === void 0 ? "DENY" : config.frameOptions;
+	if (frameOptions) if (Array.isArray(frameOptions)) res.setHeader("Content-Security-Policy", `frame-ancestors ${frameOptions.join(" ")}`);
+	else {
+		res.setHeader("X-Frame-Options", frameOptions);
+		res.setHeader("Content-Security-Policy", `frame-ancestors '${frameOptions === "DENY" ? "none" : "self"}'`);
+	}
+	if ((config.httpVersion ?? 2) >= 3) res.setHeader("Alt-Svc", `h3=":${port}"; ma=86400`);
+	if (serveStatic(req, res, BUILTIN_PUBLIC_DIR)) return;
+	if (config.publicDir && serveStatic(req, res, config.publicDir)) return;
+	if (req.path.startsWith("/.well-known/")) {
+		res.setStatus(404);
+		res.end();
+		return;
+	}
+	if (req.path.startsWith(pluginManager.urlPrefix + "/")) {
+		const relative = req.path.slice(pluginManager.urlPrefix.length);
+		const pluginName = relative.split("/")[1];
+		if (pluginName && pluginManager.hasPlugin(pluginName)) {
+			await pluginManager.prepare(pluginName);
+			if (serveStatic({
+				...req,
+				path: relative
+			}, res, pluginManager.outputDir)) return;
+		}
+		res.setStatus(404);
+		res.send("Not found");
+		return;
+	}
+	const loginPath = config.loginPath === false ? null : config.loginPath ?? "/auth/login";
+	if (loginPath && req.method === "POST" && req.path === loginPath) {
+		if (await config.adapters.onLogin?.(req)) res.setStatus(200);
+		else res.setStatus(401);
+		res.end();
+		return;
+	}
+	const logoutPath = config.logoutPath === false ? null : config.logoutPath ?? "/auth/logout";
+	if (logoutPath && req.method === "POST" && req.path === logoutPath) {
+		await config.adapters.onLogout?.(req);
+		res.setStatus(204);
+		res.end();
+		return;
+	}
+	if (config.static) for (const [prefix, rootDir] of Object.entries(config.static)) {
+		const normalizedPrefix = prefix.endsWith("/") ? prefix : `${prefix}/`;
+		if (req.path === prefix || req.path.startsWith(normalizedPrefix)) {
+			if (serveStatic({
+				...req,
+				path: req.path.slice(prefix.length) || "/"
+			}, res, rootDir)) return;
+		}
+	}
+	const mcpPath = config.mcp?.path ?? "/mcp";
+	if (config.mcp && (config.mcp.enabled ?? true) && req.path.startsWith(mcpPath)) {
+		await handleMcp(raw, rawRes, config.mcp);
+		return;
+	}
+	if (await runMiddlewares([
+		spaceDeploymentMiddleware(config.adapters),
+		basicAuthMiddleware({ cacheTtlMs: config.cacheTtlMs }),
+		authMiddleware(config.adapters),
+		...config.middlewares || []
+	], req, res) || res.status !== 200) return;
+	const rscPath = config.rsc?.path ?? "/_rsc";
+	if ((config.rsc?.enabled ?? !!config.adapters.getRscData) && req.method === "GET" && req.path === rscPath) {
+		await handleRsc(req, res, config, pluginManager, caches.rsc);
+		return;
+	}
+	await renderSSR(req, res, config, renderFn, pluginManager, caches);
+};
+var makeHandler = (config, port, renderFn, caches, pluginManager) => {
+	return (raw, rawRes) => {
+		handleRequest(raw, rawRes, config, port, renderFn, caches, pluginManager).catch((err) => {
+			console.error("[SSR] Unhandled error:", err);
+			try {
+				if (!rawRes.headersSent) rawRes.writeHead(500, { "Content-Type": "text/plain" });
+				rawRes.end("Internal Server Error");
+			} catch {}
+		});
+	};
+};
+//#endregion
+export { makeHandler };

package/dist/core/requestParser.js

@@ -0,0 +1,34 @@
+//#region src/core/requestParser.ts
+var HOSTNAME_RE = /^[a-zA-Z0-9.-]{1,253}$/u;
+var parseRequest = (raw) => {
+	const headers = raw.headers;
+	const rawHostname = (headers[":authority"] ?? headers["host"] ?? "").split(":")[0] ?? "";
+	const hostname = HOSTNAME_RE.test(rawHostname) ? rawHostname : "";
+	const scheme = headers[":scheme"];
+	const forwarded = headers["x-forwarded-proto"];
+	const encrypted = !scheme && !forwarded && "encrypted" in raw.socket && raw.socket.encrypted === true;
+	const protocol = scheme === "https" || forwarded === "https" || encrypted ? "https" : "http";
+	const rawUrl = headers[":path"] ?? raw.url ?? "/";
+	const qIndex = rawUrl.indexOf("?");
+	const rawPath = qIndex === -1 ? rawUrl : rawUrl.slice(0, qIndex);
+	const path = rawPath.includes("\0") ? "\0" : rawPath;
+	const search = qIndex === -1 ? "" : rawUrl.slice(qIndex);
+	const query = {};
+	if (search) {
+		const sp = new URLSearchParams(search.slice(1));
+		for (const [k, v] of sp.entries()) query[k] = v;
+	}
+	return {
+		method: (headers[":method"] ?? raw.method ?? "GET").toUpperCase(),
+		path,
+		search,
+		url: rawUrl,
+		hostname,
+		protocol,
+		headers,
+		query,
+		ctx: {}
+	};
+};
+//#endregion
+export { parseRequest };

package/dist/core/staticFiles.js

@@ -0,0 +1,42 @@
+import { getCacheControl, getMimeType } from "./mimeTypes.js";
+import path from "node:path";
+import fs from "node:fs";
+//#region src/core/staticFiles.ts
+var buildEtag = (stat) => `"${stat.mtimeMs.toString(36)}-${stat.size.toString(36)}"`;
+var serveFile = (req, res, filePath, stat) => {
+	const etag = buildEtag(stat);
+	const ifNoneMatch = req.headers["if-none-match"];
+	res.setHeader("ETag", etag);
+	res.setHeader("Cache-Control", getCacheControl(filePath));
+	res.setHeader("Last-Modified", stat.mtime.toUTCString());
+	if (ifNoneMatch === etag) {
+		res.setStatus(304);
+		res.end();
+		return true;
+	}
+	const content = fs.readFileSync(filePath);
+	res.setHeader("Content-Type", getMimeType(filePath));
+	res.setHeader("Content-Length", content.byteLength.toString());
+	res.send(content.toString("utf-8"));
+	return true;
+};
+var serveStatic = (req, res, rootDir) => {
+	const relative = req.path.replace(/^\/+/, "");
+	const filePath = path.resolve(rootDir, relative);
+	const resolvedRoot = path.resolve(rootDir);
+	if (filePath !== resolvedRoot && !filePath.startsWith(resolvedRoot + path.sep)) {
+		res.setStatus(403);
+		res.send("Forbidden");
+		return true;
+	}
+	if (!fs.existsSync(filePath)) return false;
+	const stat = fs.statSync(filePath);
+	if (stat.isDirectory()) {
+		const indexPath = path.join(filePath, "index.html");
+		if (!fs.existsSync(indexPath)) return false;
+		return serveFile(req, res, indexPath, fs.statSync(indexPath));
+	}
+	return serveFile(req, res, filePath, stat);
+};
+//#endregion
+export { serveStatic };

package/dist/core/transports.js

@@ -0,0 +1,51 @@
+import http from "node:http";
+import http2 from "node:http2";
+import https from "node:https";
+//#region src/core/transports.ts
+var tlsOptions = (config) => {
+	const { tls } = config;
+	if (!tls) throw new Error("[SSR] TLS config required");
+	return {
+		key: tls.key,
+		cert: tls.cert,
+		minVersion: tls.minVersion ?? "TLSv1.3"
+	};
+};
+var protoLabel = (version, hasTls) => {
+	if (version >= 3) return "HTTP/2+3 (TLS)";
+	if (version >= 2) return hasTls ? "HTTP/2 (TLS)" : "HTTP/1.1 - TLS Missing";
+	return hasTls ? "HTTPS/1.1" : "HTTP/1.1";
+};
+var buildTransport = (config, handler, port) => {
+	const version = config.httpVersion ?? 2;
+	let primary;
+	let h3;
+	if (version >= 3) {
+		primary = http2.createSecureServer({
+			...tlsOptions(config),
+			allowHTTP1: true
+		}, handler);
+		(async () => {
+			try {
+				h3 = (await import("node:http3")).createServer(tlsOptions(config), handler);
+				h3.listen(port, "0.0.0.0", () => {
+					console.log(`[SSR] HTTP/3 (QUIC) listening on port ${port}`);
+				});
+			} catch {
+				console.warn("[SSR] HTTP/3 unavailable — start Node.js with --experimental-quic (requires Node ≥ 23). Falling back to HTTP/2.");
+			}
+		})();
+	} else if (version >= 2) if (config.tls) primary = http2.createSecureServer({
+		...tlsOptions(config),
+		allowHTTP1: true
+	}, handler);
+	else primary = http.createServer(handler);
+	else if (config.tls) primary = https.createServer(tlsOptions(config), handler);
+	else primary = http.createServer(handler);
+	return {
+		primary,
+		h3
+	};
+};
+//#endregion
+export { buildTransport, protoLabel };

package/dist/helpers/buildResponseHelpers.js

@@ -0,0 +1,43 @@
+import { compressBody, selectEncoding } from "./compress.js";
+//#region src/helpers/buildResponseHelpers.ts
+var buildResponseHelpers = (raw, acceptEncoding) => {
+	let statusCode = 200;
+	const encoding = selectEncoding(acceptEncoding);
+	const writeSend = (body) => {
+		const compressed = compressBody(body, encoding);
+		if (compressed !== body) {
+			raw.setHeader("Content-Encoding", encoding);
+			raw.setHeader("Vary", "Accept-Encoding");
+		}
+		raw.setHeader("Content-Length", Buffer.byteLength(compressed).toString());
+		if (!raw.headersSent) raw.writeHead(statusCode);
+		raw.end(compressed);
+	};
+	return {
+		get status() {
+			return statusCode;
+		},
+		get headers() {
+			return raw.getHeaders();
+		},
+		setHeader(name, value) {
+			raw.setHeader(name, value);
+		},
+		setStatus(code) {
+			statusCode = code;
+		},
+		send(body) {
+			writeSend(body);
+		},
+		write(chunk) {
+			if (!raw.headersSent) raw.writeHead(statusCode);
+			raw.write(chunk);
+		},
+		end() {
+			if (!raw.headersSent) raw.writeHead(statusCode);
+			raw.end();
+		}
+	};
+};
+//#endregion
+export { buildResponseHelpers };

package/dist/helpers/buildServerInfo.js

@@ -0,0 +1,55 @@
+//#region src/helpers/buildServerInfo.ts
+var getEnvironment = (env = "production", server) => {
+	switch (env) {
+		case "production": return server;
+		case "staging": return {
+			apiServer: "https://api-stg.plitzi.com",
+			ssrServer: "https://ssr-stg.plitzi.com",
+			nodeServer: "https://server-stg.plitzi.com",
+			graphqlServer: "https://server-stg.plitzi.com/graphql",
+			websocketServer: "wss://server-stg.plitzi.com",
+			subscriptionServer: "wss://server-stg.plitzi.com/subscriptions",
+			...server
+		};
+		case "development": return {
+			apiServer: "https://api-dev.plitzi.com",
+			ssrServer: "https://ssr-dev.plitzi.com",
+			nodeServer: "https://server-dev.plitzi.com",
+			graphqlServer: "https://server-dev.plitzi.com/graphql",
+			websocketServer: "wss://server-dev.plitzi.com",
+			subscriptionServer: "wss://server-dev.plitzi.com/subscriptions",
+			...server
+		};
+		default: return {
+			apiServer: "https://api.plitzi.local",
+			ssrServer: "https://ssr.plitzi.local:4000",
+			nodeServer: "https://server.plitzi.local:8888",
+			graphqlServer: "https://server.plitzi.local:8888/graphql",
+			websocketServer: "wss://server.plitzi.local:8888",
+			subscriptionServer: "wss://server.plitzi.local:8888/subscriptions",
+			...server
+		};
+	}
+};
+var buildServerInfo = async (req, config) => {
+	const accessToken = req.query["access-token"];
+	const origin = `${req.protocol}://${req.hostname}`;
+	const user = req.ctx.user;
+	const { environment = "main", spaceId, revision = 0 } = req.ctx.spaceDeployment ?? {};
+	return getEnvironment(config.environment, {
+		basePath: "/",
+		requestUrl: req.url || "/",
+		origin,
+		location: {
+			hostname: req.hostname,
+			pathname: req.path || "/",
+			search: req.search
+		},
+		authenticated: !!user,
+		skipAuth: !!accessToken,
+		user: user ? { details: user } : void 0,
+		rscData: await config.adapters.getRscData?.(req, spaceId, environment, revision, user)
+	});
+};
+//#endregion
+export { buildServerInfo };

package/dist/helpers/cache/TtlCache.js

@@ -0,0 +1,55 @@
+import { DEFAULT_TTL_MS } from "./defaults.js";
+//#region src/helpers/cache/TtlCache.ts
+var TtlCache = class {
+	store = /* @__PURE__ */ new Map();
+	sweepTimer;
+	constructor(ttlMs = DEFAULT_TTL_MS.html, maxSize = 500, sweepIntervalMs = ttlMs) {
+		this.ttlMs = ttlMs;
+		this.maxSize = maxSize;
+		this.sweepTimer = setInterval(() => this.sweep(), sweepIntervalMs);
+		this.sweepTimer.unref?.();
+	}
+	get(key) {
+		const entry = this.store.get(key);
+		if (!entry) return;
+		if (Date.now() > entry.expiresAt) {
+			this.store.delete(key);
+			return;
+		}
+		return entry.value;
+	}
+	set(key, value) {
+		if (this.store.size >= this.maxSize) this.store.delete(this.store.keys().next().value);
+		this.store.set(key, {
+			value,
+			expiresAt: Date.now() + this.ttlMs
+		});
+	}
+	delete(key) {
+		this.store.delete(key);
+	}
+	invalidateWhere(predicate) {
+		let count = 0;
+		for (const key of this.store.keys()) if (predicate(key)) {
+			this.store.delete(key);
+			count++;
+		}
+		return count;
+	}
+	clear() {
+		this.store.clear();
+	}
+	destroy() {
+		clearInterval(this.sweepTimer);
+		this.store.clear();
+	}
+	get size() {
+		return this.store.size;
+	}
+	sweep() {
+		const now = Date.now();
+		for (const [key, entry] of this.store) if (now > entry.expiresAt) this.store.delete(key);
+	}
+};
+//#endregion
+export { TtlCache };

package/dist/helpers/cache/cacheManager.js

@@ -0,0 +1,25 @@
+//#region src/helpers/cache/cacheManager.ts
+var buildCacheManager = (store) => ({
+	invalidate(filter) {
+		if (!filter || Object.keys(filter).length === 0) {
+			const count = store.size;
+			store.clear();
+			return count;
+		}
+		return store.invalidateWhere((key) => {
+			const [keySpaceId, keyEnvironment, , keyHostname] = key.split("\0");
+			if (filter.spaceId !== void 0 && keySpaceId !== String(filter.spaceId)) return false;
+			if (filter.environment !== void 0 && keyEnvironment !== filter.environment) return false;
+			if (filter.hostname !== void 0 && keyHostname !== filter.hostname) return false;
+			return true;
+		});
+	},
+	clear() {
+		store.clear();
+	},
+	get size() {
+		return store.size;
+	}
+});
+//#endregion
+export { buildCacheManager };

package/dist/helpers/cache/defaults.js

@@ -0,0 +1,9 @@
+//#region src/helpers/cache/defaults.ts
+var DEFAULT_TTL_MS = {
+	html: 300 * 1e3,
+	rsc: 3e4,
+	auth: 300 * 1e3,
+	offlineData: 300 * 1e3
+};
+//#endregion
+export { DEFAULT_TTL_MS };

package/dist/helpers/cache/keys.js

@@ -0,0 +1,6 @@
+//#region src/helpers/cache/keys.ts
+var buildHtmlCacheKey = (accessToken = "anonymous", spaceId, environment, revision, req) => `${accessToken}\0${spaceId ?? 1}\0${environment}\0${revision}\0${req.hostname}\0${req.path}\0${req.search}`;
+var buildOfflineDataCacheKey = (spaceId, environment, revision) => `${spaceId}|${environment}|${revision}`;
+var buildRscCacheKey = (spaceId, environment, revision, userId, idsParam) => `${spaceId}|${environment}|${revision}|${userId ?? "anon"}|${idsParam ?? ""}`;
+//#endregion
+export { buildHtmlCacheKey, buildOfflineDataCacheKey, buildRscCacheKey };

package/dist/helpers/cache/serverCaches.js

@@ -0,0 +1,15 @@
+import { DEFAULT_TTL_MS } from "./defaults.js";
+import { TtlCache } from "./TtlCache.js";
+//#region src/helpers/cache/serverCaches.ts
+var createServerCaches = (htmlTtlMs = DEFAULT_TTL_MS.html, rscTtlMs = DEFAULT_TTL_MS.rsc) => ({
+	html: htmlTtlMs > 0 ? new TtlCache(htmlTtlMs) : void 0,
+	rsc: rscTtlMs > 0 ? new TtlCache(rscTtlMs) : void 0,
+	offlineData: htmlTtlMs > 0 ? new TtlCache(htmlTtlMs) : void 0
+});
+var destroyServerCaches = ({ html, rsc, offlineData }) => {
+	html?.destroy();
+	rsc?.destroy();
+	offlineData?.destroy();
+};
+//#endregion
+export { createServerCaches, destroyServerCaches };

package/dist/helpers/compress.js

@@ -0,0 +1,17 @@
+import { brotliCompressSync, constants, gzipSync } from "node:zlib";
+//#region src/helpers/compress.ts
+var MIN_SIZE = 1024;
+var selectEncoding = (acceptEncoding) => {
+	if (!acceptEncoding) return "identity";
+	if (acceptEncoding.includes("br")) return "br";
+	if (acceptEncoding.includes("gzip")) return "gzip";
+	return "identity";
+};
+var compressBody = (body, encoding) => {
+	if (encoding === "identity" || body.length < MIN_SIZE) return body;
+	const buf = Buffer.from(body, "utf-8");
+	if (encoding === "br") return brotliCompressSync(buf, { params: { [constants.BROTLI_PARAM_QUALITY]: 4 } });
+	return gzipSync(buf, { level: 6 });
+};
+//#endregion
+export { compressBody, selectEncoding };

package/dist/helpers/escapeJson.js

@@ -0,0 +1,4 @@
+//#region src/helpers/escapeJson.ts
+var escapeJson = (str) => str.replace(/</g, "\\u003c").replace(/>/g, "\\u003e").replace(/&/g, "\\u0026").replace(/\u2028/g, "\\u2028").replace(/\u2029/g, "\\u2029");
+//#endregion
+export { escapeJson };

package/dist/helpers/metrics.js

@@ -0,0 +1,36 @@
+//#region src/helpers/metrics.ts
+var RequestMetrics = class {
+	start;
+	phases = [];
+	constructor() {
+		this.start = performance.now();
+	}
+	async measure(name, fn) {
+		const t = performance.now();
+		const result = await Promise.resolve(fn());
+		this.phases.push({
+			name,
+			dur: Math.round(performance.now() - t)
+		});
+		return result;
+	}
+	/** Formats as Server-Timing header value. */
+	toServerTimingHeader() {
+		const total = Math.round(performance.now() - this.start);
+		return [...this.phases.map((p) => `${p.name};dur=${p.dur}`), `total;dur=${total}`].join(", ");
+	}
+	record(name, dur) {
+		this.phases.push({
+			name,
+			dur
+		});
+	}
+	/** Logs a one-line summary to stdout (dev mode only). */
+	log(label) {
+		const total = Math.round(performance.now() - this.start);
+		const parts = this.phases.map((p) => `${p.name}=${p.dur}ms`).join(" ");
+		console.log(`[SSR] ${label} — ${parts} | total=${total}ms`);
+	}
+};
+//#endregion
+export { RequestMetrics };

package/dist/helpers/normalizePlugins.js

@@ -0,0 +1,16 @@
+//#region src/helpers/normalizePlugins.ts
+var DEFAULT_PLUGIN_VERSION = "1.0.0";
+var normalizePluginSource = (source) => ({
+	...source,
+	version: source.version ?? DEFAULT_PLUGIN_VERSION
+});
+var normalizePlugins = (plugins) => {
+	const out = {};
+	for (const [name, source] of Object.entries(plugins)) {
+		const normalized = normalizePluginSource(source);
+		out[`${name}@${normalized.version}`] = normalized;
+	}
+	return out;
+};
+//#endregion
+export { normalizePlugins as default, normalizePluginSource };