@plitzi/sdk-server 0.30.19

package/dist/helpers/runMiddlewares.js

@@ -0,0 +1,21 @@
+//#region src/helpers/runMiddlewares.ts
+var runMiddlewares = async (middlewares, req, res) => {
+	let index = 0;
+	const state = { stopped: false };
+	const next = async () => {
+		if (state.stopped) return;
+		const mw = index < middlewares.length ? middlewares[index++] : void 0;
+		if (!mw) return;
+		const nextState = { called: false };
+		await mw(req, res, async () => {
+			nextState.called = true;
+			await next();
+		});
+		if (!nextState.called) state.stopped = true;
+	};
+	await next();
+	if (req.spaceDeployment) req.ctx.spaceDeployment = req.spaceDeployment;
+	return state.stopped;
+};
+//#endregion
+export { runMiddlewares };

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export * from './src/index'
+export {}

package/dist/index.js

@@ -0,0 +1,3 @@
+import { createSSRServer } from "./core/createServer.js";
+import { createJsonAdapters } from "./adapters/jsonAdapters.js";
+export { createJsonAdapters, createSSRServer };

package/dist/middlewares/auth.js

@@ -0,0 +1,10 @@
+//#region src/middlewares/auth.ts
+var authMiddleware = (adapters) => {
+	return async (req, _res, next) => {
+		const user = await adapters.getUser?.(req);
+		req.ctx.user = user;
+		await next();
+	};
+};
+//#endregion
+export { authMiddleware };

package/dist/middlewares/basicAuth.js

@@ -0,0 +1,67 @@
+import { DEFAULT_TTL_MS } from "../helpers/cache/defaults.js";
+import { TtlCache } from "../helpers/cache/TtlCache.js";
+import crypto from "node:crypto";
+//#region src/middlewares/basicAuth.ts
+var sendChallenge = (res, domain, realm) => {
+	res.setHeader("WWW-Authenticate", `Basic realm="${realm} - ${domain}", charset="UTF-8"`);
+	res.setHeader("Cache-Control", "no-store");
+	res.setStatus(401);
+	res.end();
+};
+var basicAuthMiddleware = (options = {}) => {
+	const { realm = "Restricted Area", cacheTtlMs = DEFAULT_TTL_MS.auth } = options;
+	const authCache = new TtlCache(cacheTtlMs, 1e4);
+	return async (req, res, next) => {
+		const credential = req.ctx.spaceDeployment?.credential;
+		if (!credential || credential.provider !== "ssr") {
+			await next();
+			return;
+		}
+		const { data: credentials } = credential;
+		if (credentials.type !== "basic") {
+			await next();
+			return;
+		}
+		const hostname = req.hostname;
+		const authHeader = req.headers["authorization"];
+		if (!authHeader || !authHeader.startsWith("Basic ")) {
+			sendChallenge(res, hostname, realm);
+			return;
+		}
+		let token;
+		let decoded;
+		try {
+			token = authHeader.slice(6);
+			decoded = Buffer.from(token, "base64").toString("utf8");
+		} catch {
+			sendChallenge(res, hostname, realm);
+			return;
+		}
+		const cacheKey = `${hostname}:${crypto.createHash("sha256").update(token).digest("hex")}`;
+		if (authCache.get(cacheKey)) {
+			await next();
+			return;
+		}
+		const colonIdx = decoded.indexOf(":");
+		if (colonIdx === -1) {
+			sendChallenge(res, hostname, realm);
+			return;
+		}
+		const user = decoded.slice(0, colonIdx);
+		const pass = decoded.slice(colonIdx + 1);
+		const expectedUser = Buffer.from(credentials.user);
+		const expectedPass = Buffer.from(credentials.pass);
+		const actualUser = Buffer.from(user);
+		const actualPass = Buffer.from(pass);
+		const userMatch = actualUser.length === expectedUser.length && crypto.timingSafeEqual(actualUser, expectedUser);
+		const passMatch = actualPass.length === expectedPass.length && crypto.timingSafeEqual(actualPass, expectedPass);
+		if (!userMatch || !passMatch) {
+			sendChallenge(res, hostname, realm);
+			return;
+		}
+		authCache.set(cacheKey, true);
+		await next();
+	};
+};
+//#endregion
+export { basicAuthMiddleware };

package/dist/middlewares/spaceDeployment.js

@@ -0,0 +1,16 @@
+//#region src/middlewares/spaceDeployment.ts
+var spaceDeploymentMiddleware = (adapters) => {
+	return async (req, res, next) => {
+		const deployment = await adapters.getSpaceDeployment(req);
+		req.ctx.spaceDeployment = deployment;
+		const { spaceId, error } = deployment;
+		if (spaceId == null || error) {
+			res.setStatus(error?.code ?? 404);
+			res.send(error?.message ?? "Space not found");
+			return;
+		}
+		await next();
+	};
+};
+//#endregion
+export { spaceDeploymentMiddleware };

package/dist/modules/mcp/handler.js

@@ -0,0 +1,34 @@
+import { createMcpServer } from "./server.js";
+import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
+//#region src/modules/mcp/handler.ts
+var readBody = (req) => new Promise((resolve, reject) => {
+	let raw = "";
+	req.on("data", (chunk) => {
+		raw += chunk.toString();
+	});
+	req.on("end", () => {
+		try {
+			resolve(raw ? JSON.parse(raw) : void 0);
+		} catch {
+			reject(/* @__PURE__ */ new Error("MCP: invalid JSON body"));
+		}
+	});
+	req.on("error", reject);
+});
+var handleMcp = async (req, res, config) => {
+	const transport = new StreamableHTTPServerTransport({ sessionIdGenerator: void 0 });
+	await createMcpServer(config.adapters).connect(transport);
+	if (req.method === "POST") {
+		let body;
+		try {
+			body = await readBody(req);
+		} catch {
+			res.writeHead(400, { "Content-Type": "application/json" });
+			res.end(JSON.stringify({ error: "Invalid JSON body" }));
+			return;
+		}
+		await transport.handleRequest(req, res, body);
+	} else await transport.handleRequest(req, res);
+};
+//#endregion
+export { handleMcp };

package/dist/modules/mcp/server.js

@@ -0,0 +1,120 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { z } from "zod";
+//#region src/modules/mcp/server.ts
+var ok = (data) => ({ content: [{
+	type: "text",
+	text: JSON.stringify(data, null, 2)
+}] });
+var err = (message) => ({
+	content: [{
+		type: "text",
+		text: message
+	}],
+	isError: true
+});
+var createMcpServer = (adapters) => {
+	const server = new McpServer({
+		name: "plitzi-schema-agent",
+		version: "1.0.0"
+	});
+	server.tool("list_spaces", "List all spaces available in the system", {}, async () => {
+		return ok(await adapters.listSpaces());
+	});
+	server.tool("get_schema", "Get the full element tree for a space and environment", {
+		spaceId: z.number().describe("Space ID"),
+		environment: z.string().describe("Environment name (e.g. main, production)")
+	}, async ({ spaceId, environment }) => {
+		const schema = await adapters.getSchema(spaceId, environment);
+		if (!schema) return err(`Schema not found for space ${spaceId} / ${environment}`);
+		return ok(schema);
+	});
+	server.tool("list_elements", "List all element IDs, types and labels for a space and environment", {
+		spaceId: z.number(),
+		environment: z.string()
+	}, async ({ spaceId, environment }) => {
+		const schema = await adapters.getSchema(spaceId, environment);
+		if (!schema) return err(`Schema not found for space ${spaceId} / ${environment}`);
+		return ok(Object.values(schema.elements).map(({ id, type, label, parentId, runtime }) => ({
+			id,
+			type,
+			label,
+			parentId,
+			runtime
+		})));
+	});
+	server.tool("get_element", "Get the full details of a single element by ID", {
+		spaceId: z.number(),
+		environment: z.string(),
+		elementId: z.string().describe("Element ID")
+	}, async ({ spaceId, environment, elementId }) => {
+		const schema = await adapters.getSchema(spaceId, environment);
+		if (!schema) return err(`Schema not found for space ${spaceId} / ${environment}`);
+		const element = schema.elements[elementId];
+		if (!element) return err(`Element ${elementId} not found`);
+		return ok(element);
+	});
+	server.tool("create_element", "Add a new element to the schema. Returns the created element with its generated ID.", {
+		spaceId: z.number(),
+		environment: z.string(),
+		type: z.string().describe("Component type (e.g. Container, Text, Button, Image)"),
+		label: z.string().describe("Human-readable name for the element"),
+		props: z.record(z.string(), z.unknown()).optional().describe("Component props/attributes"),
+		runtime: z.enum([
+			"server",
+			"client",
+			"shared"
+		]).optional().describe("Rendering runtime"),
+		parentId: z.string().optional().describe("Parent element ID; omit to place at root"),
+		position: z.number().optional().describe("Zero-based insertion index within the parent")
+	}, async ({ spaceId, environment, type, label, props, runtime, parentId, position }) => {
+		return ok(await adapters.createElement(spaceId, environment, {
+			type,
+			label,
+			props,
+			runtime
+		}, parentId, position));
+	});
+	server.tool("update_element", "Update an existing element — label, props, styles, or runtime", {
+		spaceId: z.number(),
+		environment: z.string(),
+		elementId: z.string(),
+		label: z.string().optional(),
+		props: z.record(z.string(), z.unknown()).optional(),
+		styles: z.record(z.string(), z.unknown()).optional(),
+		runtime: z.enum([
+			"server",
+			"client",
+			"shared"
+		]).optional()
+	}, async ({ spaceId, environment, elementId, label, props, styles, runtime }) => {
+		return ok(await adapters.updateElement(spaceId, environment, elementId, {
+			label,
+			props,
+			styles,
+			runtime
+		}));
+	});
+	server.tool("delete_element", "Remove an element and all its descendants from the schema", {
+		spaceId: z.number(),
+		environment: z.string(),
+		elementId: z.string()
+	}, async ({ spaceId, environment, elementId }) => {
+		await adapters.deleteElement(spaceId, environment, elementId);
+		return ok({ deleted: elementId });
+	});
+	server.tool("publish_schema", "Publish the current draft schema as a new immutable revision", {
+		spaceId: z.number(),
+		environment: z.string()
+	}, async ({ spaceId, environment }) => {
+		return ok(await adapters.publishSchema(spaceId, environment));
+	});
+	if (adapters.listPlugins) {
+		const listPlugins = adapters.listPlugins;
+		server.tool("list_plugins", "List all plugins registered in the system", {}, async () => {
+			return ok(await listPlugins());
+		});
+	}
+	return server;
+};
+//#endregion
+export { createMcpServer };

package/dist/modules/rsc/handler.js

@@ -0,0 +1,69 @@
+import { DEFAULT_TTL_MS } from "../../helpers/cache/defaults.js";
+import { buildRscCacheKey } from "../../helpers/cache/keys.js";
+//#region src/modules/rsc/handler.ts
+/**
+* Handles GET /_rsc requests.
+*
+* Calls adapters.getRscData to get server-side data for elements marked
+* runtime:'server' in the schema, then returns a JSON payload. The SDK
+* client uses this payload to update server-driven portions of the page
+* without a full navigation.
+*
+* Responses are cached server-side (TtlCache) and via Cache-Control headers:
+* - main environment: no-store (development, always fresh)
+* - Authenticated requests: Cache-Control: private, max-age=<ttl>
+* - Unauthenticated requests: Cache-Control: public, max-age=<ttl>
+*/
+var handleRsc = async (req, res, config, _pluginManager, cache) => {
+	if (!config.adapters.getRscData) {
+		res.setStatus(501);
+		res.send(JSON.stringify({ error: "getRscData adapter not configured" }));
+		return;
+	}
+	const { environment = "main", spaceId, revision = 0 } = req.ctx.spaceDeployment ?? {};
+	if (typeof spaceId !== "number") {
+		res.setStatus(400);
+		res.send(JSON.stringify({ error: "Invalid space deployment" }));
+		return;
+	}
+	const idsRaw = req.query.ids;
+	const ids = idsRaw ? idsRaw.split(",").filter(Boolean).slice(0, 50).map((id) => id.slice(0, 128)) : void 0;
+	const idsParam = ids?.join(",");
+	const ttlMs = config.rsc?.cacheTtlMs ?? DEFAULT_TTL_MS.rsc;
+	const isAuthenticated = !!req.ctx.user;
+	const cacheControl = environment === "main" ? "no-store" : isAuthenticated ? `private, max-age=${Math.floor(ttlMs / 1e3)}` : `public, max-age=${Math.floor(ttlMs / 1e3)}`;
+	const cacheKey = environment !== "main" ? buildRscCacheKey(spaceId, environment, revision, req.ctx.user?.id, idsParam) : void 0;
+	const cached = cacheKey ? cache?.get(cacheKey) : void 0;
+	if (cached) {
+		res.setHeader("Content-Type", "application/json; charset=utf-8");
+		res.setHeader("Cache-Control", cacheControl);
+		res.setHeader("X-Cache", "HIT");
+		res.send(cached);
+		return;
+	}
+	let rscData;
+	try {
+		rscData = await config.adapters.getRscData(req, spaceId, environment, revision, req.ctx.user, ids);
+	} catch (err) {
+		console.error("[RSC] getRscData error:", err);
+		res.setStatus(500);
+		res.send(JSON.stringify({ error: "RSC data fetch failed" }));
+		return;
+	}
+	const payload = {
+		version: 1,
+		transport: "json",
+		spaceId,
+		environment,
+		revision,
+		...rscData
+	};
+	const payloadStr = JSON.stringify(payload);
+	if (cacheKey) cache?.set(cacheKey, payloadStr);
+	res.setHeader("Content-Type", "application/json; charset=utf-8");
+	res.setHeader("Cache-Control", cacheControl);
+	res.setHeader("X-Cache", "MISS");
+	res.send(payloadStr);
+};
+//#endregion
+export { handleRsc };

package/dist/modules/ssr/Component.js

@@ -0,0 +1,20 @@
+import PlitziSdk from "@plitzi/plitzi-sdk";
+import { jsx } from "react/jsx-runtime";
+//#region src/modules/ssr/Component.tsx
+var Component = ({ server, renderMode = "raw", previewMode = true, offlineData, environment = "main", plugins }) => {
+	return /* @__PURE__ */ jsx(PlitziSdk, {
+		environment,
+		server,
+		previewMode,
+		renderMode,
+		offlineMode: !!offlineData && Object.keys(offlineData).length > 0,
+		offlineData,
+		children: plugins && Object.keys(plugins).map((key) => /* @__PURE__ */ jsx(PlitziSdk.Plugin, {
+			renderType: key,
+			component: plugins[key].component,
+			...plugins[key].props
+		}, key))
+	});
+};
+//#endregion
+export { Component as default };

package/dist/modules/ssr/buildBody.js

@@ -0,0 +1,20 @@
+import Component from "./Component.js";
+import { prepareRender } from "./prepareRender.js";
+import { renderToString } from "react-dom/server";
+import { jsx } from "react/jsx-runtime";
+//#region src/modules/ssr/buildBody.tsx
+var buildBody = async (req, config, spaceId, environment, revision, renderFn, pluginManager, offlineDataCache, metrics) => {
+	const prep = await prepareRender(req, config, spaceId, environment, revision, pluginManager, offlineDataCache, metrics);
+	const reactStart = metrics ? performance.now() : 0;
+	const html = renderToString(/* @__PURE__ */ jsx(Component, { ...prep.componentProps })).trim();
+	metrics?.record("react", Math.round(performance.now() - reactStart));
+	const templateStart = metrics ? performance.now() : 0;
+	const body = renderFn({
+		...prep.templateParams,
+		html
+	});
+	metrics?.record("template", Math.round(performance.now() - templateStart));
+	return body;
+};
+//#endregion
+export { buildBody };

package/dist/modules/ssr/handler.js

@@ -0,0 +1,36 @@
+import { buildHtmlCacheKey } from "../../helpers/cache/keys.js";
+import { buildBody } from "./buildBody.js";
+import { streamBody } from "./streamBody.js";
+import { RequestMetrics } from "../../helpers/metrics.js";
+//#region src/modules/ssr/handler.tsx
+var renderSSR = async (req, res, config, renderFn, pluginManager, caches) => {
+	const { environment = "main", spaceId = 1, revision = 0 } = req.ctx.spaceDeployment || {};
+	const devMode = config.devMode ?? false;
+	res.setHeader("Content-Type", "text/html; charset=utf-8");
+	const htmlCache = environment !== "main" ? caches.html : void 0;
+	const cacheKey = htmlCache ? buildHtmlCacheKey(req.ctx.user?.token, spaceId, environment, revision, req) : void 0;
+	if (htmlCache && cacheKey) {
+		const cached = htmlCache.get(cacheKey);
+		if (cached) {
+			res.setHeader("X-Cache", "HIT");
+			if (devMode) res.setHeader("Server-Timing", "html;desc=\"cache-hit\";dur=0");
+			res.send(cached);
+			return;
+		}
+	}
+	const metrics = devMode ? new RequestMetrics() : void 0;
+	if (cacheKey) res.setHeader("X-Cache", "MISS");
+	if (config.streaming) {
+		await streamBody(req, res, config, spaceId, environment, revision, renderFn, pluginManager, caches.offlineData, htmlCache, cacheKey, metrics);
+		return;
+	}
+	const body = await buildBody(req, config, spaceId, environment, revision, renderFn, pluginManager, caches.offlineData, metrics);
+	if (htmlCache && cacheKey) htmlCache.set(cacheKey, body);
+	if (metrics) {
+		res.setHeader("Server-Timing", metrics.toServerTimingHeader());
+		metrics.log(`${req.method} ${req.path}`);
+	}
+	res.send(body);
+};
+//#endregion
+export { renderSSR };

package/dist/modules/ssr/loadPluginComponents.js

@@ -0,0 +1,45 @@
+//#region src/modules/ssr/loadPluginComponents.ts
+/** Module-level cache: absolute filePath → loaded React component. */
+var componentCache = /* @__PURE__ */ new Map();
+/**
+* Plugins that failed to import (e.g. browser-only code like `document`).
+* These are permanently skipped on the server and fall through to client-side rendering.
+*/
+var failedImports = /* @__PURE__ */ new Set();
+/**
+* Dynamically imports plugin components from their compiled filesystem paths and returns
+* a Record<keyName, FC> suitable for passing to <PlitziSdk.Plugin>.
+*
+* File-source plugins are cached by filePath so subsequent requests skip the import().
+* Plugins that fail to import are added to a permanent skip-list — they are not retried
+* and will be rendered client-side instead.
+* Component-source plugins (already in memory via getComponents()) are merged in directly.
+*/
+var loadPluginComponents = async (entries, inlineComponents) => {
+	const result = {};
+	if (inlineComponents) for (const [key, component] of Object.entries(inlineComponents)) result[key] = {
+		component,
+		props: {}
+	};
+	await Promise.all(entries.filter((e) => e.filePath).map(async (e) => {
+		const filePath = e.filePath;
+		if (failedImports.has(filePath)) return;
+		let component = componentCache.get(filePath);
+		if (!component) try {
+			const mod = await import(filePath);
+			component = mod.default ?? mod;
+			componentCache.set(filePath, component);
+		} catch (err) {
+			console.warn(`[SSR] Plugin "${e.keyName}" cannot be imported server-side, falling back to client rendering:`, err.message);
+			failedImports.add(filePath);
+			return;
+		}
+		result[e.keyName] = {
+			component,
+			props: e.props
+		};
+	}));
+	return result;
+};
+//#endregion
+export { loadPluginComponents };

package/dist/modules/ssr/prepareRender.js

@@ -0,0 +1,64 @@
+import { buildOfflineDataCacheKey } from "../../helpers/cache/keys.js";
+import { loadPluginComponents } from "./loadPluginComponents.js";
+import { registerExternalPlugins } from "./registerExternalPlugins.js";
+import { buildServerInfo } from "../../helpers/buildServerInfo.js";
+import { escapeJson } from "../../helpers/escapeJson.js";
+//#region src/modules/ssr/prepareRender.tsx
+var prepareRender = async (req, config, spaceId, environment, revision, pluginManager, offlineDataCache, metrics) => {
+	const m = (name, fn) => metrics ? metrics.measure(name, fn) : Promise.resolve(fn());
+	const offlineCacheKey = environment !== "main" ? buildOfflineDataCacheKey(spaceId, environment, revision) : void 0;
+	const cachedOfflineStr = offlineCacheKey ? offlineDataCache?.get(offlineCacheKey) : void 0;
+	const [offlineData, server] = await Promise.all([cachedOfflineStr ? JSON.parse(cachedOfflineStr) : m("schema", () => config.adapters.getOfflineData(spaceId, environment, revision)), m("rsc", () => buildServerInfo(req, config))]);
+	if (!cachedOfflineStr && offlineCacheKey && offlineData !== void 0) offlineDataCache?.set(offlineCacheKey, JSON.stringify(offlineData));
+	const offlineDataStr = escapeJson(JSON.stringify({
+		offlineData,
+		offlineMode: true,
+		environment,
+		renderMode: "raw",
+		server
+	}));
+	const pluginNames = req.ctx.spaceDeployment?.pluginNames ?? [];
+	const pluginSources = req.ctx.spaceDeployment?.pluginSources;
+	const pluginBaseNames = new Set(pluginNames.map((n) => n.replace(/@[^@]*$/, "")));
+	const dynamicNames = [];
+	if (pluginSources) for (const [pluginName, pluginSource] of Object.entries(pluginSources)) {
+		const key = pluginManager.ensure(pluginName, pluginSource);
+		if (!pluginBaseNames.has(pluginName)) dynamicNames.push(key);
+	}
+	const externalNamesFiltered = (config.autoLoadSchemaPlugins !== false ? await m("extPlugins", () => registerExternalPlugins(pluginManager, offlineData)) : []).filter((k) => !pluginBaseNames.has(k.replace(/@[^@]*$/, "")));
+	const allPluginNames = [
+		...pluginNames,
+		...dynamicNames,
+		...externalNamesFiltered
+	];
+	const entries = allPluginNames.length > 0 ? await pluginManager.getEntries(allPluginNames) : [];
+	const pluginComponents = await m("plugins", () => loadPluginComponents(entries, pluginManager.getComponents()));
+	const templatePlugins = entries.length > 0 ? entries : req.ctx.spaceDeployment?.templateProps?.plugins;
+	const v = config.assetVersion ? `?v=${config.assetVersion}` : "";
+	const vendorJs = (config.devMode ? "/sdk-assets/plitzi-sdk-dev-vendor.js" : "/sdk-assets/plitzi-sdk-vendor.js") + v;
+	return {
+		componentProps: {
+			plugins: Object.keys(pluginComponents).length > 0 ? pluginComponents : void 0,
+			offlineData,
+			server,
+			environment: req.ctx.spaceDeployment?.environment ?? environment
+		},
+		entries,
+		templateParams: {
+			title: "Plitzi App",
+			jsPath: `/sdk-assets/plitzi-sdk.js${v}`,
+			cssPath: `/sdk-assets/plitzi-sdk.css${v}`,
+			react: vendorJs,
+			reactJsx: vendorJs,
+			reactDom: vendorJs,
+			reactDomClient: vendorJs,
+			...req.ctx.spaceDeployment?.templateProps,
+			plugins: templatePlugins,
+			debugMode: config.devMode,
+			ssrOnly: config.ssrOnly === true,
+			offlineData: offlineDataStr
+		}
+	};
+};
+//#endregion
+export { prepareRender };

package/dist/modules/ssr/registerExternalPlugins.js

@@ -0,0 +1,54 @@
+//#region src/modules/ssr/registerExternalPlugins.ts
+var fetchManifest = async (resource) => {
+	try {
+		const url = `${resource}/plugin-manifest.json`;
+		const res = await fetch(url);
+		if (!res.ok) {
+			console.warn(`[SSR] Failed to fetch plugin manifest from ${url}: HTTP ${res.status}`);
+			return null;
+		}
+		return await res.json();
+	} catch (err) {
+		console.warn(`[SSR] Error fetching plugin manifest from ${resource}:`, err);
+		return null;
+	}
+};
+var resolveAssetUrl = (resource, asset) => {
+	if (asset.url) return asset.url;
+	if (asset.src) return `${resource}/${asset.src}`;
+	return null;
+};
+var findAsset = (manifest, type, resource) => {
+	const assets = Object.values(manifest.assets);
+	const main = assets.find((a) => a.type === type && a.isMain) ?? assets.find((a) => a.type === type);
+	return main ? resolveAssetUrl(resource, main) ?? void 0 : void 0;
+};
+var isAbsoluteUrl = (url) => url.startsWith("http://") || url.startsWith("https://");
+var registerPlugin = async (pluginManager, plugin) => {
+	if (!plugin.resource || !isAbsoluteUrl(plugin.resource)) return null;
+	const manifest = await fetchManifest(plugin.resource);
+	if (!manifest) return null;
+	const jsUrl = findAsset(manifest, "script", plugin.resource);
+	if (!jsUrl) {
+		console.warn(`[SSR] Plugin "${plugin.type}" has no JS asset in manifest, skipping`);
+		return null;
+	}
+	const source = {
+		js: jsUrl,
+		css: findAsset(manifest, "style", plugin.resource),
+		action: "download",
+		version: manifest.version
+	};
+	return pluginManager.ensure(plugin.type, source);
+};
+/**
+* Reads plugins listed in offlineData.plugins, fetches their manifests, downloads and caches
+* JS/CSS via the PluginManager, and returns the effective plugin keys to pass to getEntries().
+*/
+var registerExternalPlugins = async (pluginManager, offlineData) => {
+	const plugins = offlineData?.plugins;
+	if (!plugins || plugins.length === 0) return [];
+	return (await Promise.all(plugins.map((p) => registerPlugin(pluginManager, p)))).filter((k) => k !== null);
+};
+//#endregion
+export { registerExternalPlugins };

package/dist/modules/ssr/streamBody.js

@@ -0,0 +1,54 @@
+import Component from "./Component.js";
+import { prepareRender } from "./prepareRender.js";
+import { renderToPipeableStream } from "react-dom/server";
+import { jsx } from "react/jsx-runtime";
+import { Writable } from "node:stream";
+//#region src/modules/ssr/streamBody.tsx
+var SSR_SENTINEL = "<!--SSR_CONTENT-->";
+var streamBody = async (req, res, config, spaceId, environment, revision, renderFn, pluginManager, offlineDataCache, htmlCache, cacheKey, metrics) => {
+	const prep = await prepareRender(req, config, spaceId, environment, revision, pluginManager, offlineDataCache, metrics);
+	const templateStart = metrics ? performance.now() : 0;
+	const fullTemplate = renderFn({
+		...prep.templateParams,
+		html: SSR_SENTINEL
+	});
+	metrics?.record("template", Math.round(performance.now() - templateStart));
+	const sentinelIdx = fullTemplate.indexOf(SSR_SENTINEL);
+	const head = sentinelIdx >= 0 ? fullTemplate.slice(0, sentinelIdx) : fullTemplate;
+	const tail = sentinelIdx >= 0 ? fullTemplate.slice(sentinelIdx + 18) : "";
+	await new Promise((resolve, reject) => {
+		const chunks = cacheKey && htmlCache ? [] : null;
+		const writable = new Writable({
+			write(chunk, _enc, cb) {
+				chunks?.push(chunk);
+				res.write(chunk);
+				cb();
+			},
+			final(cb) {
+				const tailBuf = Buffer.from(tail, "utf-8");
+				res.write(tailBuf);
+				res.end();
+				if (chunks && cacheKey && htmlCache) htmlCache.set(cacheKey, head + Buffer.concat(chunks).toString("utf-8") + tail);
+				resolve();
+				cb();
+			}
+		});
+		const reactStart = metrics ? performance.now() : 0;
+		const { pipe } = renderToPipeableStream(/* @__PURE__ */ jsx(Component, { ...prep.componentProps }), {
+			onShellReady() {
+				metrics?.record("react", Math.round(performance.now() - reactStart));
+				if (metrics) {
+					res.setHeader("Server-Timing", metrics.toServerTimingHeader());
+					metrics.log(`${req.method} ${req.path}`);
+				}
+				res.write(Buffer.from(head, "utf-8"));
+				pipe(writable);
+			},
+			onError(err) {
+				reject(err instanceof Error ? err : new Error(String(err)));
+			}
+		});
+	});
+};
+//#endregion
+export { streamBody };

package/dist/modules/ssr/template.js

@@ -0,0 +1,10 @@
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import fs from "node:fs";
+import ejs from "ejs";
+//#region src/modules/ssr/template.ts
+var __dirname = path.dirname(fileURLToPath(import.meta.url));
+var DEFAULT_TEMPLATE_PATH = path.resolve(__dirname, "views/template.ejs");
+var compileTemplate = () => ejs.compile(fs.readFileSync(DEFAULT_TEMPLATE_PATH, "utf-8"), { filename: DEFAULT_TEMPLATE_PATH });
+//#endregion
+export { compileTemplate };