@plitzi/sdk-server 0.32.3 → 0.32.5

package/dist/modules/mcp/tools/shared/validator.js

@@ -0,0 +1,262 @@
+import { findFolderByRef, findPageByRef, folderAncestorIds, getPageElements, pageFoldersOf, pageRefOf, resolveRef, routeParamNames, slugRouteParams } from "../../helpers/space.js";
+import { expandShorthand, isCssProperty, suggestCssProperty } from "../operations/style/cssCatalog.js";
+import { buildTypeRegistry } from "../operations/schema/registry.js";
+//#region src/modules/mcp/tools/shared/validator.ts
+var REF_RE = /^[a-zA-Z0-9._-]+$/;
+var MAX_OPS = 100;
+var STYLE_CATEGORIES = [
+	"color",
+	"spacing",
+	"shadow",
+	"custom"
+];
+var VAR_REF = /\{\{\s*([A-Za-z_][\w.-]*)\s*\}\}/g;
+var CSS_VAR = /var\(\s*--([A-Za-z_][\w-]*)\s*\)/g;
+var RAW_CODE_TYPES = /* @__PURE__ */ new Set([
+	"blockJsx",
+	"blockHtml",
+	"custom"
+]);
+var warnOnce = (ctx, message) => {
+	if (!ctx.warned.has(message)) {
+		ctx.warned.add(message);
+		ctx.warnings.push(message);
+	}
+};
+var checkVarRefs = (text, path, ctx) => {
+	for (const match of text.matchAll(VAR_REF)) {
+		const name = match[1];
+		if (!ctx.schemaVars.has(name)) warnOnce(ctx, `Unknown variable {{${name}}} at ${path}: not a space schema variable or a page route param. Read plitzi://schema-variables, or use a route param from the page skeleton (routeParams).`);
+	}
+};
+var checkStyleVarRefs = (text, path, ctx) => {
+	for (const match of text.matchAll(CSS_VAR)) {
+		const name = match[1];
+		if (!ctx.styleVars.has(name)) {
+			const tokens = [...ctx.styleVars];
+			warnOnce(ctx, `Unknown style variable var(--${name}) at ${path}: not a design token in this space. ${tokens.length > 0 ? `Available tokens: ${tokens.slice(0, 30).join(", ")}${tokens.length > 30 ? ", …" : ""}.` : "Read plitzi://style-variables for the valid token names."}`);
+		}
+	}
+};
+var checkTypeProps = (type, props, path, ctx) => {
+	if (!props || RAW_CODE_TYPES.has(type)) return;
+	const known = ctx.typeProps.get(type);
+	if (!known || known.size === 0) return;
+	for (const key of Object.keys(props)) {
+		if (key === "subType" || known.has(key)) continue;
+		warnOnce(ctx, `Type "${type}" has no observed prop "${key}" at ${path} (observed: ${[...known].sort().join(", ")}). It may still be valid — verify against plitzi://types.`);
+	}
+};
+var checkRef = (ref, path, ctx) => {
+	if (!ref || ref.trim().length === 0) {
+		ctx.errors.push({
+			path,
+			message: "Ref must not be empty",
+			hint: "Use a semantic name like \"hero.title\""
+		});
+		return;
+	}
+	if (!REF_RE.test(ref)) ctx.errors.push({
+		path,
+		message: `Ref "${ref}" has invalid characters`,
+		hint: "Allowed characters: letters, numbers, dot, hyphen, underscore"
+	});
+};
+var checkCss = (css, path, ctx) => {
+	if (!css) return;
+	const declared = {};
+	for (const [key, value] of Object.entries(css)) if (value !== null) declared[key] = value;
+	for (const [key, value] of Object.entries(expandShorthand(declared))) {
+		if (!isCssProperty(key)) {
+			const suggestion = suggestCssProperty(key);
+			ctx.errors.push({
+				path: `${path}.${key}`,
+				message: `Unknown CSS property "${key}"`,
+				hint: suggestion ? `Use the kebab-case key "${suggestion}"` : "Read plitzi://css-properties for the valid property keys"
+			});
+		}
+		if (typeof value === "string") {
+			checkStyleVarRefs(value, `${path}.${key}`, ctx);
+			checkVarRefs(value, `${path}.${key}`, ctx);
+		}
+	}
+};
+var checkSlotCss = (slot, path, ctx) => {
+	checkCss(slot.desktop, `${path}.desktop`, ctx);
+	checkCss(slot.tablet, `${path}.tablet`, ctx);
+	checkCss(slot.mobile, `${path}.mobile`, ctx);
+	for (const [state, dm] of Object.entries(slot.states ?? {})) {
+		checkCss(dm.desktop, `${path}.states.${state}.desktop`, ctx);
+		checkCss(dm.tablet, `${path}.states.${state}.tablet`, ctx);
+		checkCss(dm.mobile, `${path}.states.${state}.mobile`, ctx);
+	}
+	for (const [name, dm] of Object.entries(slot.variants ?? {})) {
+		checkCss(dm.desktop, `${path}.variants.${name}.desktop`, ctx);
+		checkCss(dm.tablet, `${path}.variants.${name}.tablet`, ctx);
+		checkCss(dm.mobile, `${path}.variants.${name}.mobile`, ctx);
+	}
+};
+var checkElementProps = (element, path, ctx) => {
+	if (!element.props || RAW_CODE_TYPES.has(element.type)) return;
+	for (const [key, value] of Object.entries(element.props)) if (typeof value === "string") checkVarRefs(value, `${path}.props.${key}`, ctx);
+	checkTypeProps(element.type, element.props, path, ctx);
+};
+var checkElementInput = (element, path, ctx, seen) => {
+	checkRef(element.ref, `${path}.ref`, ctx);
+	if (seen.has(element.ref)) ctx.errors.push({
+		path: `${path}.ref`,
+		message: `Duplicate ref "${element.ref}" in this batch`,
+		hint: "Use a unique ref"
+	});
+	seen.add(element.ref);
+	if (!element.type) ctx.errors.push({
+		path: `${path}.type`,
+		message: "Element type is required",
+		hint: "Read plitzi://types for known types"
+	});
+	else if (!ctx.knownTypes.has(element.type)) ctx.warnings.push(`Type "${element.type}" was not seen in this space; ensure a plugin provides it (${path}.type).`);
+	checkElementProps(element, path, ctx);
+	element.children?.forEach((child, i) => checkElementInput(child, `${path}.children[${i}]`, ctx, seen));
+};
+var batchDeclaredVars = (ops) => {
+	const names = [];
+	for (const op of ops) if (op.type === "upsertVariable") names.push(op.name);
+	else if (op.type === "upsertPage" && typeof op.slug === "string") names.push(...slugRouteParams(op.slug));
+	return names;
+};
+var batchDeclaredPages = (ops) => {
+	const refs = /* @__PURE__ */ new Set();
+	for (const op of ops) if (op.type === "upsertPage") refs.add(op.ref);
+	return refs;
+};
+var batchDeclaredFolders = (ops) => {
+	const refs = /* @__PURE__ */ new Set();
+	for (const op of ops) if (op.type === "upsertFolder") refs.add(op.ref);
+	return refs;
+};
+var validateOperations = (space, ops) => {
+	const registry = buildTypeRegistry(space.schema);
+	const batchPages = batchDeclaredPages(ops);
+	const batchFolders = batchDeclaredFolders(ops);
+	const folderRefs = () => pageFoldersOf(space.schema).map((f) => f.id);
+	const ctx = {
+		errors: [],
+		warnings: [],
+		warned: /* @__PURE__ */ new Set(),
+		knownTypes: new Set(Object.keys(registry.types)),
+		typeProps: new Map(Object.entries(registry.types).map(([type, info]) => [type, new Set(Object.keys(info.props))])),
+		schemaVars: /* @__PURE__ */ new Set([
+			...space.schema.variables.map((v) => v.name),
+			...routeParamNames(space.schema),
+			...batchDeclaredVars(ops)
+		]),
+		styleVars: new Set(Object.values(space.style.variables).flatMap((group) => Object.keys(group)))
+	};
+	if (ops.length > MAX_OPS) ctx.errors.push({
+		path: "operations",
+		message: `Batch has ${ops.length} operations (max ${MAX_OPS})`,
+		hint: `Split into batches of at most ${MAX_OPS}`
+	});
+	ops.forEach((op, i) => {
+		const base = `operations[${i}]`;
+		if ((op.type === "upsertElement" || op.type === "patchElement" || op.type === "deleteElement" || op.type === "moveElement") && op.pageRef) {
+			if (!findPageByRef(space.schema, op.pageRef) && !batchPages.has(op.pageRef)) {
+				const validRefs = getPageElements(space.schema).map(pageRefOf);
+				ctx.errors.push({
+					path: `${base}.pageRef`,
+					message: `Page "${op.pageRef}" does not exist`,
+					hint: "Use an existing page ref, or create it with upsertPage earlier in the same batch",
+					validValues: validRefs
+				});
+			}
+		}
+		switch (op.type) {
+			case "upsertElement":
+				checkElementInput(op.element, `${base}.element`, ctx, /* @__PURE__ */ new Set());
+				break;
+			case "patchElement": {
+				checkRef(op.ref, `${base}.ref`, ctx);
+				const page = findPageByRef(space.schema, op.pageRef);
+				const target = page ? resolveRef(space.schema, page, op.ref) : void 0;
+				if (op.props) {
+					for (const [key, value] of Object.entries(op.props)) if (typeof value === "string") checkVarRefs(value, `${base}.props.${key}`, ctx);
+					if (target && target.id !== page?.id) checkTypeProps(target.definition.type, op.props, base, ctx);
+				}
+				break;
+			}
+			case "upsertDefinition":
+			case "patchDefinition": {
+				const { type, ref, slots, ...slot } = op;
+				checkRef(ref, `${base}.ref`, ctx);
+				checkSlotCss(slot, base, ctx);
+				for (const [slotName, slotDef] of Object.entries(slots ?? {})) checkSlotCss(slotDef, `${base}.slots.${slotName}`, ctx);
+				break;
+			}
+			case "upsertGlobalStyle":
+			case "patchGlobalStyle": {
+				const { type, componentType, slots, ...slot } = op;
+				checkRef(componentType, `${base}.componentType`, ctx);
+				checkSlotCss(slot, base, ctx);
+				for (const [slotName, slotDef] of Object.entries(slots ?? {})) checkSlotCss(slotDef, `${base}.slots.${slotName}`, ctx);
+				break;
+			}
+			case "deleteGlobalStyle":
+				checkRef(op.componentType, `${base}.componentType`, ctx);
+				break;
+			case "upsertPage":
+				checkRef(op.ref, `${base}.ref`, ctx);
+				if (typeof op.folder === "string" && op.folder !== "") {
+					if (!findFolderByRef(space.schema, op.folder) && !batchFolders.has(op.folder)) ctx.errors.push({
+						path: `${base}.folder`,
+						message: `Folder "${op.folder}" does not exist`,
+						hint: "Create it with upsertFolder earlier in the same batch, or read plitzi://folders for valid refs",
+						validValues: folderRefs()
+					});
+				}
+				break;
+			case "upsertFolder":
+				checkRef(op.ref, `${base}.ref`, ctx);
+				if (typeof op.parentId === "string") {
+					checkRef(op.parentId, `${base}.parentId`, ctx);
+					const parent = findFolderByRef(space.schema, op.parentId);
+					if (!parent && !batchFolders.has(op.parentId)) ctx.errors.push({
+						path: `${base}.parentId`,
+						message: `Parent folder "${op.parentId}" does not exist`,
+						hint: "Create the parent with upsertFolder first, or read plitzi://folders for valid refs",
+						validValues: folderRefs()
+					});
+					const selfId = findFolderByRef(space.schema, op.ref)?.id ?? op.ref;
+					if ((parent?.id ?? op.parentId) === selfId || parent && folderAncestorIds(pageFoldersOf(space.schema), parent.id).includes(selfId)) ctx.errors.push({
+						path: `${base}.parentId`,
+						message: `Folder "${op.ref}" cannot be nested under itself or one of its descendants`,
+						hint: "Choose a parent that is not this folder or below it"
+					});
+				}
+				break;
+			case "deleteDefinition":
+			case "deleteFolder":
+			case "deletePage":
+			case "upsertVariable":
+			case "deleteVariable":
+				checkRef("ref" in op ? op.ref : op.name, `${base}.${"ref" in op ? "ref" : "name"}`, ctx);
+				break;
+			case "upsertStyleVariable":
+			case "deleteStyleVariable":
+				if (!STYLE_CATEGORIES.includes(op.category)) ctx.errors.push({
+					path: `${base}.category`,
+					message: `Unknown style-variable category "${op.category}"`,
+					hint: "Use one of the valid categories",
+					validValues: STYLE_CATEGORIES
+				});
+				break;
+			default: break;
+		}
+	});
+	return {
+		valid: ctx.errors.length === 0,
+		errors: ctx.errors,
+		warnings: ctx.warnings
+	};
+};
+//#endregion
+export { validateOperations };

package/dist/modules/mcp/tools/validate.js

@@ -0,0 +1,19 @@
+import { environment, operations } from "./operations/index.js";
+import { defineTool } from "./shared/tool.js";
+import { validateOperations } from "./shared/validator.js";
+//#region src/modules/mcp/tools/validate.ts
+var validateShape = {
+	environment,
+	operations
+};
+var validate = (input, space) => validateOperations(space, input.operations);
+var validateTool = defineTool({
+	name: "plitzi_validate",
+	title: "Validate",
+	description: "Check a batch of operations without executing them. Returns teachable errors and warnings.",
+	inputShape: validateShape,
+	access: "read",
+	run: (input, ctx) => validate(input, ctx.space)
+});
+//#endregion
+export { validate, validateShape, validateTool };

package/dist/modules/ssr/buildBody.js

@@ -3,8 +3,8 @@ 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);
+var buildBody = async (req, config, spaceId, environment, revision, renderFn, pluginManager, offlineDataCache, metrics, offlineDataOverride) => {
+	const prep = await prepareRender(req, config, spaceId, environment, revision, pluginManager, offlineDataCache, metrics, offlineDataOverride);
 	const result = {};
 	const reactStart = metrics ? performance.now() : 0;
 	const html = renderToString(/* @__PURE__ */ jsx(Component, {

package/dist/modules/ssr/handler.js

@@ -1,6 +1,7 @@
 import { buildHtmlCacheKey } from "../../helpers/cache/keys.js";
-import { applySSRResult } from "./applySSRResult.js";
 import { buildBody } from "./buildBody.js";
+import { takeDraftOverride } from "./preview.js";
+import { applySSRResult } from "./applySSRResult.js";
 import { streamBody } from "./streamBody.js";
 import { RequestMetrics } from "../../helpers/metrics.js";
 //#region src/modules/ssr/handler.tsx
@@ -8,7 +9,8 @@ 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 offlineDataOverride = await takeDraftOverride(req, config);
+	const htmlCache = environment !== "main" && !offlineDataOverride ? 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);
@@ -22,10 +24,10 @@ var renderSSR = async (req, res, config, renderFn, pluginManager, caches) => {
 	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);
+		await streamBody(req, res, config, spaceId, environment, revision, renderFn, pluginManager, caches.offlineData, htmlCache, cacheKey, metrics, offlineDataOverride);
 		return;
 	}
-	const { body, result } = await buildBody(req, config, spaceId, environment, revision, renderFn, pluginManager, caches.offlineData, metrics);
+	const { body, result } = await buildBody(req, config, spaceId, environment, revision, renderFn, pluginManager, caches.offlineData, metrics, offlineDataOverride);
 	if (metrics) {
 		res.setHeader("Server-Timing", metrics.toServerTimingHeader());
 		metrics.log(`${req.method} ${req.path}`);

package/dist/modules/ssr/prepareRender.js

@@ -1,16 +1,16 @@
-import { buildOfflineDataCacheKey } from "../../helpers/cache/keys.js";
 import { loadPluginComponents } from "./loadPluginComponents.js";
 import { registerExternalPlugins } from "./registerExternalPlugins.js";
 import { buildServerInfo } from "../../helpers/buildServerInfo.js";
+import { buildOfflineDataCacheKey } from "../../helpers/cache/keys.js";
 import { escapeJson } from "../../helpers/escapeJson.js";
 import { readCookie } from "../../helpers/readCookie.js";
 //#region src/modules/ssr/prepareRender.tsx
-var prepareRender = async (req, config, spaceId, environment, revision, pluginManager, offlineDataCache, metrics) => {
+var prepareRender = async (req, config, spaceId, environment, revision, pluginManager, offlineDataCache, metrics, offlineDataOverride) => {
 	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 cachedOfflineStr = offlineDataOverride === void 0 && offlineCacheKey ? offlineDataCache?.get(offlineCacheKey) : void 0;
+	const [offlineData, server] = await Promise.all([offlineDataOverride !== void 0 ? Promise.resolve(offlineDataOverride) : cachedOfflineStr ? JSON.parse(cachedOfflineStr) : m("schema", () => config.adapters.getOfflineData(spaceId, environment, revision)), m("rsc", () => buildServerInfo(req, config))]);
+	if (offlineDataOverride === void 0 && !cachedOfflineStr && offlineCacheKey && offlineData !== void 0) offlineDataCache?.set(offlineCacheKey, JSON.stringify(offlineData));
 	const v = config.assetVersion ? `?v=${config.assetVersion}` : "";
 	const sdkDevToolsStylePath = `/sdk-assets/plitzi-sdk-devtools.css${v}`;
 	const debugCookie = readCookie(req.headers.cookie, "plitzi_debug");

package/dist/modules/ssr/preview.js

@@ -0,0 +1,106 @@
+import { computeVersion } from "../mcp/helpers/computeVersion.js";
+import { cloneSpace, findPageByRef, getPageElements } from "../mcp/helpers/space.js";
+import { applyOperations } from "../mcp/tools/apply/dispatch.js";
+import { validateOperations } from "../mcp/tools/shared/validator.js";
+import { PREVIEW_TOKEN_PARAM } from "../mcp/constants.js";
+import { buildBody } from "./buildBody.js";
+import { randomUUID } from "node:crypto";
+//#region src/modules/ssr/preview.ts
+/** In-memory one-shot draft store — the default when the consumer injects none. Fine for a single replica;
+*  a multi-replica deployment must inject a shared store so a preview URL resolves on any replica. */
+var createMemoryDraftStore = () => {
+	const store = /* @__PURE__ */ new Map();
+	return {
+		put(token, data, ttlMs) {
+			store.set(token, {
+				data,
+				expiresAt: Date.now() + ttlMs
+			});
+		},
+		take(token) {
+			const hit = store.get(token);
+			if (!hit) return;
+			store.delete(token);
+			return hit.expiresAt > Date.now() ? hit.data : void 0;
+		}
+	};
+};
+/** Consume the draft override for a render, if the request carries a valid preview token. Returns undefined on
+*  a normal request (renders persisted state) or when the token is unknown/expired (one-shot / TTL). */
+var takeDraftOverride = async (req, config) => {
+	const token = req.query[PREVIEW_TOKEN_PARAM];
+	if (!token || !config.draftStore) return;
+	return config.draftStore.take(token);
+};
+var resolvePagePath = (schema, pageRef) => {
+	const pages = getPageElements(schema);
+	const page = pageRef ? findPageByRef(schema, pageRef) : pages.find((p) => p.attributes.default) ?? pages[0];
+	const slug = page && typeof page.attributes.slug === "string" ? page.attributes.slug : "";
+	return slug.startsWith("/") ? slug : `/${slug}`;
+};
+var syntheticRequest = (pagePath) => ({
+	method: "GET",
+	path: pagePath,
+	search: "",
+	url: pagePath,
+	hostname: "localhost",
+	protocol: "https",
+	headers: {},
+	query: {},
+	ctx: {}
+});
+/** Build a preview of a page: apply any unsaved `operations` to a clone (never persisted), render the resulting
+*  draft to full HTML via the SSR pipeline, and stash the draft under a one-shot token so a browser can fetch
+*  the exact same render at `?__pt=<token>` (for screenshots). With no operations it previews persisted state. */
+var createPreview = async (body, config, renderFn, pluginManager, caches) => {
+	const env = body.env ?? "main";
+	const revision = 0;
+	const offlineData = await config.adapters.getOfflineData(body.spaceId, env, revision);
+	if (!offlineData) return {
+		ok: false,
+		error: "NO_DATA",
+		message: `No offline data for space ${body.spaceId} (${env}).`
+	};
+	let draftOffline = offlineData;
+	if (body.operations && body.operations.length > 0) {
+		const draft = cloneSpace({
+			schema: offlineData.schema,
+			style: offlineData.style
+		});
+		const validation = validateOperations(draft, body.operations);
+		if (!validation.valid) return {
+			ok: false,
+			error: "INVALID_OPERATIONS",
+			message: "The operations did not validate.",
+			errors: validation.errors
+		};
+		const outcome = applyOperations(draft, env, body.operations);
+		if (outcome.errors.length > 0) return {
+			ok: false,
+			error: "APPLY_FAILED",
+			message: "The operations could not be applied.",
+			errors: outcome.errors
+		};
+		draftOffline = {
+			...offlineData,
+			schema: draft.schema,
+			style: draft.style
+		};
+	}
+	const pagePath = resolvePagePath(draftOffline.schema, body.pageRef);
+	const { body: html } = await buildBody(syntheticRequest(pagePath), config, body.spaceId, env, revision, renderFn, pluginManager, caches.offlineData, void 0, draftOffline);
+	let token;
+	if (config.draftStore) {
+		token = randomUUID();
+		await config.draftStore.put(token, draftOffline, config.preview?.ttlMs ?? 6e4);
+	}
+	return {
+		ok: true,
+		token,
+		pagePath,
+		html: html ?? "",
+		stateVersion: computeVersion(draftOffline)
+	};
+};
+//#endregion
+export { PREVIEW_TOKEN_PARAM, createMemoryDraftStore, createPreview, takeDraftOverride };

package/dist/modules/ssr/registerExternalPlugins.js

@@ -1,6 +1,6 @@
-import path from "node:path";
 import crypto from "node:crypto";
 import fs from "node:fs/promises";
+import path from "node:path";
 //#region src/modules/ssr/registerExternalPlugins.ts
 var MANIFEST_TTL_MS = 600 * 1e3;
 var manifestCache = /* @__PURE__ */ new Map();

package/dist/modules/ssr/streamBody.js

@@ -1,13 +1,13 @@
-import { applySSRResult } from "./applySSRResult.js";
 import Component from "./Component.js";
 import { prepareRender } from "./prepareRender.js";
+import { applySSRResult } from "./applySSRResult.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);
+var streamBody = async (req, res, config, spaceId, environment, revision, renderFn, pluginManager, offlineDataCache, htmlCache, cacheKey, metrics, offlineDataOverride) => {
+	const prep = await prepareRender(req, config, spaceId, environment, revision, pluginManager, offlineDataCache, metrics, offlineDataOverride);
 	const templateStart = metrics ? performance.now() : 0;
 	const fullTemplate = renderFn({
 		...prep.templateParams,

package/dist/modules/ssr/template.js

@@ -1,6 +1,6 @@
 import path from "node:path";
-import { fileURLToPath } from "node:url";
 import fs from "node:fs";
+import { fileURLToPath } from "node:url";
 import ejs from "ejs";
 //#region src/modules/ssr/template.ts
 var __dirname = path.dirname(fileURLToPath(import.meta.url));

package/dist/plugins/compile.js

@@ -1,5 +1,5 @@
-import path from "node:path";
 import fs from "node:fs/promises";
+import path from "node:path";
 import esbuild from "esbuild";
 //#region src/plugins/compile.ts
 var EXTERNAL = [

package/dist/plugins/copy.js

@@ -1,5 +1,5 @@
-import path from "node:path";
 import fs from "node:fs/promises";
+import path from "node:path";
 //#region src/plugins/copy.ts
 var copyPlugin = async (src, destDir, filename) => {
 	const dest = path.join(destDir, filename);

package/dist/plugins/manager.js

@@ -1,8 +1,8 @@
 import { compilePlugin } from "./compile.js";
 import { copyPlugin } from "./copy.js";
 import { detectAction, isComponentSource } from "./detect.js";
-import path from "node:path";
 import fs from "node:fs/promises";
+import path from "node:path";
 //#region src/plugins/manager.ts
 var META_FILE = "meta.json";
 var DEFAULT_TTL_MS = 10080 * 60 * 1e3;

package/dist/server.js

@@ -1,20 +1,33 @@
-import { createSSRServer } from "./core/createServer.js";
+import { createSSRServer } from "./core/server/ssrServer.js";
 import path from "node:path";
+import { readFileSync, writeFileSync } from "node:fs";
 import { fileURLToPath } from "node:url";
-import { readFileSync } from "node:fs";
 //#region src/standalone/server.ts
 var PORT = parseInt(process.env.SSR_PORT ?? "3002", 10);
 var HOST = process.env.SSR_HOST ?? "0.0.0.0";
+var spacePath = () => path.resolve(__dirname, "schemas/basic", "space.json");
+var stylePath = () => path.resolve(__dirname, "schemas/basic", "style.json");
+var readSchema = () => JSON.parse(readFileSync(spacePath(), "utf-8")).schema;
+var readStyle = () => JSON.parse(readFileSync(stylePath(), "utf-8"));
 var getOfflineData = () => {
-	const fileSchema = JSON.parse(readFileSync(path.resolve(__dirname, "schemas/basic", "space.json"), "utf-8"));
-	const style = JSON.parse(readFileSync(path.resolve(__dirname, "schemas/basic", "style.json"), "utf-8"));
 	const offlineData = {
-		schema: fileSchema.schema,
-		style
+		schema: readSchema(),
+		style: readStyle()
 	};
 	console.warn("[SSR] getOfflineData: using stub adapter — returning spaceId=1");
 	return Promise.resolve(offlineData);
 };
+var getSpaceId = () => Promise.resolve(1);
+var getSchema = () => Promise.resolve(readSchema());
+var getStyle = () => Promise.resolve(readStyle());
+var saveSchema = (_spaceId, _environment, schema) => {
+	writeFileSync(spacePath(), JSON.stringify({ schema }, null, 2));
+	return Promise.resolve();
+};
+var saveStyle = (_spaceId, _environment, style) => {
+	writeFileSync(stylePath(), JSON.stringify(style, null, 2));
+	return Promise.resolve();
+};
 var getSpaceDeployment = () => {
 	console.warn("[SSR] getSpaceDeployment: using stub adapter — returning spaceId=1");
 	return Promise.resolve({
@@ -45,13 +58,24 @@ var getRscData = async (_req, _spaceId, _environment, _revision, user, ids) => {
 	};
 	return { serverData: ids?.length ? Object.fromEntries(ids.filter((id) => id in all).map((id) => [id, all[id]])) : all };
 };
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = path.dirname(__filename);
+var saveOfflineData = (_spaceId, _environment, data) => {
+	writeFileSync(spacePath(), JSON.stringify({ schema: data.schema }, null, 2));
+	writeFileSync(stylePath(), JSON.stringify(data.style, null, 2));
+	return Promise.resolve();
+};
 var adapters = {
 	getOfflineData,
 	getSpaceDeployment,
-	getRscData
+	getRscData,
+	saveOfflineData,
+	getSpaceId,
+	getSchema,
+	getStyle,
+	saveSchema,
+	saveStyle
 };
-var __filename = fileURLToPath(import.meta.url);
-var __dirname = path.dirname(__filename);
 createSSRServer({
 	port: PORT,
 	host: HOST,
@@ -59,6 +83,7 @@ createSSRServer({
 	devMode: false,
 	static: { "/sdk-assets": path.resolve(process.cwd(), "../sdk/dist") },
 	httpVersion: 1,
+	mcpAi: { enabled: true },
 	plugins: {
 		serverInfo: {
 			js: path.resolve(__dirname, "plugins/ServerInfo.tsx"),

package/dist/src/core/createServer.d.ts

@@ -1,2 +1,6 @@
 import { SSRServer, SSRServerConfig } from '@plitzi/sdk-shared';
-export declare const createSSRServer: (config: SSRServerConfig) => SSRServer;
+export { createSSRServer } from './server/ssrServer';
+export { createMCPServer } from './server/mcpServer';
+export { resolveServices } from './services/resolve';
+export type { ResolvedServices } from './services/resolve';
+export declare const createServer: (config: SSRServerConfig) => SSRServer;

package/dist/src/core/health.d.ts

@@ -0,0 +1,10 @@
+export type HealthCheckApp = {
+    get: (path: string, handler: (...args: any[]) => void) => void;
+};
+export interface HealthIdentity {
+    role: string;
+    name?: string;
+    version?: string;
+}
+export declare const buildHealthPayload: (identity?: Partial<HealthIdentity>) => Record<string, unknown>;
+export declare const registerHealthCheck: (app: HealthCheckApp, identity: HealthIdentity) => void;

package/dist/src/core/http/dispatcher.d.ts

@@ -0,0 +1,7 @@
+import { BaseContext, Stage } from './types';
+import { RawResponse } from '../../helpers/buildResponseHelpers';
+import { Handler } from '../transports';
+import { SSRRequest, SSRResponseHelpers } from '@plitzi/sdk-shared';
+import { IncomingMessage } from 'node:http';
+export type BuildContext<C extends BaseContext> = (raw: IncomingMessage, rawRes: RawResponse, req: SSRRequest, res: SSRResponseHelpers) => C;
+export declare const makeHandler: <C extends BaseContext>(label: string, buildContext: BuildContext<C>, stages: Stage<C>[]) => Handler;

package/dist/src/core/http/securityHeaders.d.ts

@@ -0,0 +1,2 @@
+import { SSRResponseHelpers, SSRServerConfig } from '@plitzi/sdk-shared';
+export declare const applySecurityHeaders: (res: SSRResponseHelpers, config: SSRServerConfig, port: number) => void;

package/dist/src/core/http/stages/authRoutes.d.ts

@@ -0,0 +1,4 @@
+import { Stage } from '../types';
+export declare const loginStage: Stage;
+export declare const logoutStage: Stage;
+export declare const authRoutesStages: Stage[];

package/dist/src/core/http/stages/health.d.ts

@@ -0,0 +1,2 @@
+import { Stage } from '../types';
+export declare const healthStage: Stage;

package/dist/src/core/http/stages/middlewares.d.ts

@@ -0,0 +1,2 @@
+import { Stage } from '../types';
+export declare const middlewaresStage: Stage;

package/dist/src/core/http/stages/pluginAssets.d.ts

@@ -0,0 +1,2 @@
+import { SSRContext, Stage } from '../types';
+export declare const pluginAssetsStage: Stage<SSRContext>;

package/dist/src/core/http/stages/static.d.ts

@@ -0,0 +1,5 @@
+import { Stage } from '../types';
+export declare const builtinPublicStage: Stage;
+export declare const publicDirStage: Stage;
+export declare const wellKnownStage: Stage;
+export declare const configStaticStage: Stage;