@plitzi/sdk-server 0.33.1 → 0.34.0

package/dist/modules/rsc/resolveRscData.d.ts

@@ -10,6 +10,14 @@ export type RscResolveContext = {
     spaceId: number;
     environment: Environment;
     user: SSRUser | undefined;
+    /**
+     * Aborted when this element's budget runs out, so a resolver can stop the work nobody is waiting for.
+     *
+     * The timeout below only ever decided when to STOP WAITING — the losing side of a race keeps running — so a
+     * provider that took longer than its budget went on holding a run slot and an outbound connection for a page
+     * that had already been sent. What is being cancelled is not the request, it is the work behind it.
+     */
+    signal: AbortSignal;
 };
 /** Produces the data slice for a single server element. Returning undefined leaves the element out of the payload. */
 export type RscElementResolver = (context: RscResolveContext) => Promise<unknown>;
@@ -22,7 +30,12 @@ export type ResolveRscDataOptions = {
     /** Restricts resolution to these element ids (partial refresh). Undefined resolves every server element. */
     ids?: string[];
     resolveElement: RscElementResolver;
-    /** Per-element budget. One slow provider must not hold the whole payload. */
+    /**
+     * Per-element budget: one slow provider must not hold the whole payload, and must not go on working once it
+     * has. It is the PAGE's ceiling and it wins over the producer's own — an action allowed ten seconds of its own
+     * is still cut off here, because a section is worth waiting for only as long as the visitor is. Configurable
+     * per deployment as `rsc.elementTimeoutMs`.
+     */
     timeoutMs?: number;
 };
 /**

package/dist/modules/rsc/resolveRscData.js

@@ -1,28 +1,23 @@
-import { getPaths, matchRoutePath } from "@plitzi/sdk-shared/navigation";
+import { matchRscPage } from "./matchRscPage.js";
+import { collectServerElements } from "@plitzi/sdk-shared/schema/serverElements";
 //#region src/modules/rsc/resolveRscData.ts
 var DEFAULT_ELEMENT_TIMEOUT_MS = 5e3;
-/** Depth-first walk of a page subtree. Iterative to stay safe on deeply nested schemas. */
-var collectSubtree = (flat, rootId) => {
-	const collected = [];
-	const seen = /* @__PURE__ */ new Set();
-	const pending = [rootId];
-	while (pending.length > 0) {
-		const id = pending.pop();
-		if (id === void 0 || seen.has(id)) continue;
-		seen.add(id);
-		const element = flat[id];
-		if (!element) continue;
-		collected.push(element);
-		const { items } = element.definition;
-		if (items) pending.push(...items);
-	}
-	return collected;
-};
-var withTimeout = async (promise, timeoutMs, label) => {
+/**
+* Runs one element's resolution against its budget, and CANCELS it when the budget is gone.
+*
+* The race decides what the payload waits for; the abort decides what the server keeps doing. Racing alone left
+* the loser running to its own timeout — for actions, five more seconds of a held slot and an in-flight request
+* per element, for a page that was answered without it.
+*/
+var withBudget = async (run, timeoutMs, label) => {
+	const controller = new AbortController();
 	let timer;
 	try {
-		return await Promise.race([promise, new Promise((_resolve, reject) => {
-			timer = setTimeout(() => reject(/* @__PURE__ */ new Error(`RSC resolution timed out after ${timeoutMs}ms for ${label}`)), timeoutMs);
+		return await Promise.race([run(controller.signal), new Promise((_resolve, reject) => {
+			timer = setTimeout(() => {
+				controller.abort();
+				reject(/* @__PURE__ */ new Error(`RSC resolution timed out after ${timeoutMs}ms for ${label}`));
+			}, timeoutMs);
 		})]);
 	} finally {
 		if (timer) clearTimeout(timer);
@@ -37,21 +32,14 @@ var withTimeout = async (promise, timeoutMs, label) => {
 */
 var resolveRscData = async ({ schema, req, spaceId, environment, user, ids, resolveElement, timeoutMs = DEFAULT_ELEMENT_TIMEOUT_MS }) => {
 	if (schema.rsc?.enabled === false) return {};
-	const pages = schema.pages.reduce((acum, pageId) => {
-		const page = schema.flat[pageId];
-		if (page) acum[pageId] = page;
-		return acum;
-	}, {});
-	const paths = getPaths(pages, schema.pageFolders, !!user);
-	const { pageId, pathMatch } = matchRoutePath(paths, req.path, !!user);
-	if (!pageId) return { serverData: {} };
-	const routeParams = pathMatch?.params ?? {};
-	const requested = ids ? new Set(ids) : void 0;
-	const targets = collectSubtree(schema.flat, pageId).filter((element) => element.definition.runtime === "server" && (!requested || requested.has(element.id)));
+	const match = matchRscPage(schema, req.path, user);
+	if (!match) return { serverData: {} };
+	const { pageId, routeParams } = match;
+	const targets = collectServerElements(schema, pageId, ids);
 	if (targets.length === 0) return { serverData: {} };
 	return { serverData: (await Promise.allSettled(targets.map(async (element) => ({
 		id: element.id,
-		data: await withTimeout(resolveElement({
+		data: await withBudget((signal) => resolveElement({
 			element,
 			flat: schema.flat,
 			routeParams,
@@ -59,7 +47,8 @@ var resolveRscData = async ({ schema, req, spaceId, environment, user, ids, reso
 			req,
 			spaceId,
 			environment,
-			user
+			user,
+			signal
 		}), timeoutMs, `element ${element.id}`)
 	})))).reduce((acum, result, index) => {
 		if (result.status === "rejected") {

package/dist/modules/ssr/Component.d.ts

@@ -1,4 +1,4 @@
-import { OfflineDataRaw, Environment, RenderMode, Server, SSRPlugin, SSRRenderResult } from '@plitzi/sdk-shared';
+import { OfflineDataRaw, Environment, RenderMode, Server, SSRPlugin, SSRRenderResult, Theme } from '@plitzi/sdk-shared';
 export type ComponentProps = {
     server: Partial<Server>;
     renderMode?: Extract<RenderMode, 'raw'>;
@@ -12,6 +12,10 @@ export type ComponentProps = {
     /** Forced on when the metering adapter degrades this render; otherwise left to the SDK's own default so the
      *  markup here matches what the browser hydrates with. */
     branding?: boolean;
+    /** The same degraded render, as the reason: the account behind this space is over its quota. */
+    overQuota?: boolean;
+    /** The theme this document was rendered with, from the visitor's cookie. See `prepareRender`. */
+    theme?: Theme;
 };
-declare const Component: ({ server, renderMode, previewMode, offlineData, environment, plugins, ssrResult, sdkDevToolsStylePath, debugMode, branding }: ComponentProps) => import("react").JSX.Element;
+declare const Component: ({ server, renderMode, previewMode, offlineData, environment, plugins, ssrResult, sdkDevToolsStylePath, debugMode, branding, overQuota, theme }: ComponentProps) => import("react").JSX.Element;
 export default Component;

package/dist/modules/ssr/Component.js

@@ -1,7 +1,7 @@
 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, ssrResult, sdkDevToolsStylePath, debugMode = false, branding }) => {
+var Component = ({ server, renderMode = "raw", previewMode = true, offlineData, environment = "main", plugins, ssrResult, sdkDevToolsStylePath, debugMode = false, branding, overQuota, theme }) => {
 	const serverWithResult = {
 		...server,
 		ssr: {
@@ -19,6 +19,8 @@ var Component = ({ server, renderMode = "raw", previewMode = true, offlineData,
 		sdkDevToolsStylePath,
 		debugMode,
 		...branding === void 0 ? {} : { branding },
+		...overQuota === void 0 ? {} : { overQuota },
+		...theme === void 0 ? {} : { theme },
 		children: plugins && Object.keys(plugins).map((key) => /* @__PURE__ */ jsx(PlitziSdk.Plugin, {
 			renderType: key,
 			component: plugins[key].component,

package/dist/modules/ssr/draftSession.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/modules/ssr/handler.js

@@ -1,5 +1,5 @@
 import { buildHtmlCacheKey } from "../../helpers/cache/keys.js";
-import { takeDraftOverride } from "./preview.js";
+import { draftSessionCookie, takeDraftOverride } from "./preview.js";
 import { applySSRResult } from "./applySSRResult.js";
 import { buildBody } from "./buildBody.js";
 import { streamBody } from "./streamBody.js";
@@ -24,7 +24,20 @@ 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 offlineDataOverride = await takeDraftOverride(req, config);
+	const draft = await takeDraftOverride(req, config);
+	const offlineDataOverride = draft?.data;
+	if (draft) {
+		/**
+		* Unsaved work, told not to travel.
+		*
+		* `no-store` because every layer between here and the browser would otherwise be free to hand this render to
+		* somebody else, and `noindex` because a draft URL that reaches a crawler puts unpublished copy in a search
+		* result. Neither is a nicety: the whole point of a draft is that it is not the site yet.
+		*/
+		res.setHeader("Cache-Control", "no-store, no-cache, must-revalidate");
+		res.setHeader("X-Robots-Tag", "noindex, nofollow");
+		if (draft.reusable) res.setHeader("Set-Cookie", draftSessionCookie(req, draft.token, config.preview?.sessionTtlMs ?? 9e5));
+	}
 	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) {

package/dist/modules/ssr/loadPluginComponents.js

@@ -1,7 +1,23 @@
 import { pathToFileURL } from "node:url";
 //#region src/modules/ssr/loadPluginComponents.ts
-/** Module-level cache: absolute filePath → loaded React component. */
+/** Module-level cache: the bundle's stamped identity → loaded React component. */
 var componentCache = /* @__PURE__ */ new Map();
+/**
+* When the bundle behind an entry was built, taken from the URL the page is told to load.
+*
+* The manager stamps that URL for the browser's benefit — the assets are served `immutable`, so a rebuilt plugin
+* needs a new URL to reach anyone — and the server needs exactly the same fact for exactly the same reason: Node's
+* ESM registry caches a module by URL for the life of the process, and a rebuild lands back on the same path. Reading
+* the stamp the manager already publishes keeps the two sides on one answer instead of inventing a second one.
+*
+* Without it a dev server renders the component it imported when it started while the browser loads the rebuilt one,
+* and the two disagree about the markup — which React reports as a hydration mismatch and answers by throwing away
+* the whole tree, taking the panels beside it with it.
+*/
+var stampOf = (entry) => {
+	const at = entry.js?.indexOf("?v=") ?? -1;
+	return at === -1 ? "" : entry.js.slice(at + 3);
+};
 /** Bumped on invalidation and appended to the import URL. Node's ESM registry caches a module by URL for the
 *  life of the process — clearing the Map above is not enough, since a rebuilt plugin lands back on the same
 *  path and `import()` would hand back the module loaded before it. A changed URL is the only way to re-read.
@@ -9,7 +25,7 @@ var componentCache = /* @__PURE__ */ new Map();
 *  subsequent one hits Node's cache. Superseded generations stay resident: the registry has no eviction, which
 *  is the price of reloading at all and why this is driven by explicit invalidation rather than per-request. */
 var generation = 0;
-var importUrl = (filePath) => generation === 0 ? filePath : `${pathToFileURL(filePath).href}?g=${generation}`;
+var importUrl = (filePath, stamp) => generation === 0 && !stamp ? filePath : `${pathToFileURL(filePath).href}?v=${stamp}&g=${generation}`;
 /**
 * 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.
@@ -33,11 +49,12 @@ var loadPluginComponents = async (entries, inlineComponents) => {
 	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);
+		const cacheKey = importUrl(filePath, stampOf(e));
+		let component = componentCache.get(cacheKey);
 		if (!component) try {
-			const mod = await import(importUrl(filePath));
+			const mod = await import(cacheKey);
 			component = mod.default ?? mod;
-			componentCache.set(filePath, component);
+			componentCache.set(cacheKey, component);
 		} catch (err) {
 			console.warn(`[SSR] Plugin "${e.keyName}" cannot be imported server-side, falling back to client rendering:`, err.message);
 			failedImports.add(filePath);

package/dist/modules/ssr/prepareRender.js

@@ -1,13 +1,23 @@
+import { matchRscPage } from "../rsc/matchRscPage.js";
 import { buildOfflineDataCacheKey } from "../../helpers/cache/keys.js";
 import { loadPluginComponents } from "./loadPluginComponents.js";
+import "../../core/previewToken.js";
+import { resolveActionEndpoint, resolveRscEndpoint } from "../../core/services/resolve.js";
 import { createOfflineDataLoader } from "../../helpers/offlineDataLoader.js";
 import { registerExternalPlugins } from "./registerExternalPlugins.js";
+import { resolvePageSeo } from "./resolvePageSeo.js";
 import { sdkAssetVersion } from "../../core/sdkAssets.js";
 import { buildServerInfo } from "../../helpers/buildServerInfo.js";
 import { escapeJson } from "../../helpers/escapeJson.js";
 import { readCookie } from "../../helpers/readCookie.js";
 import { resolveDebugMode } from "../../helpers/resolveDebugMode.js";
+import { hasServerElements } from "@plitzi/sdk-shared/schema/serverElements";
+import { themeFromCookies } from "@plitzi/sdk-shared/theme";
+import { debugCookieName } from "@plitzi/sdk-shared/devTools";
+import { fontUrlResolver, fontsToHead } from "@plitzi/sdk-shared/style";
 //#region src/modules/ssr/prepareRender.tsx
+/** Last resort only: used for a page that declares no SEO title and a deployment that supplies none either. */
+var DEFAULT_TITLE = "Plitzi App";
 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;
@@ -17,18 +27,63 @@ var prepareRender = async (req, config, spaceId, environment, revision, pluginMa
 		if (cachedOfflineStr) return Promise.resolve(JSON.parse(cachedOfflineStr));
 		return m("schema", () => config.adapters.getOfflineData(spaceId, environment, revision));
 	});
-	const [offlineData, server] = await Promise.all([loadOfflineData(), m("rsc", () => buildServerInfo(req, config, loadOfflineData))]);
+	const offlineData = await loadOfflineData();
+	const rscPath = resolveRscEndpoint(config);
+	const schema = offlineData?.schema;
+	const pageMatch = schema !== void 0 ? matchRscPage(schema, req.path, req.ctx.user) : void 0;
+	const rscData = rscPath !== void 0 && schema !== void 0 && schema.rsc?.enabled !== false && pageMatch !== void 0 && hasServerElements(schema, pageMatch.pageId) && config.adapters.getRscData ? await m("rsc", () => config.adapters.getRscData?.({
+		req,
+		spaceId: req.ctx.spaceDeployment?.spaceId ?? spaceId,
+		environment: req.ctx.spaceDeployment?.environment ?? environment,
+		revision: req.ctx.spaceDeployment?.revision ?? revision,
+		user: req.ctx.user,
+		loadOfflineData
+	})) : rscPath ? { serverData: {} } : void 0;
+	const pageSeo = resolvePageSeo(schema, pageMatch?.pageId);
+	const server = buildServerInfo(req, config, {
+		rscPath,
+		rscData,
+		actionPath: resolveActionEndpoint(config)
+	});
 	if (offlineDataOverride === void 0 && !cachedOfflineStr && offlineCacheKey && offlineData !== void 0) offlineDataCache?.set(offlineCacheKey, JSON.stringify(offlineData));
 	const version = config.assetVersion ?? sdkAssetVersion();
 	const v = version ? `?v=${version}` : "";
 	const sdkDevToolsStylePath = `/sdk-assets/plitzi-sdk-devtools.css${v}`;
-	const debugMode = resolveDebugMode(config.debugMode ?? config.devMode, readCookie(req.headers.cookie, "plitzi_debug"));
+	/**
+	* Two facts, and they have to leave this server separately.
+	*
+	* `debugAuthorized` is the deployment's decision and is what the client bootstrap is handed, because on the
+	* client that argument is what arms the shortcut and the "currently hidden" console hint. Collapsing the
+	* cookie into it — which is what this used to send — made hiding the panel on an SSR page permanent: the page
+	* came back authorizing nothing, so the shortcut was dead and nothing on screen or in the console said why.
+	*
+	* `debugRendered` is what this particular render draws, preference included. The client derives the same
+	* product from the same cookie on its first pass, so the markup it hydrates matches.
+	*/
+	const debugAuthorized = !Boolean(req.query["__pt"]) && Boolean(config.debugMode ?? config.devMode);
+	const debugRendered = resolveDebugMode(debugAuthorized, readCookie(req.headers.cookie, debugCookieName(req.headers.host)));
 	const { degrade, analytics } = req.ctx.meter ?? {};
 	const clientAnalytics = analytics ? {
 		...analytics,
 		firstViewCounted: true
 	} : void 0;
 	const branding = degrade ? true : void 0;
+	const overQuota = degrade ? true : void 0;
+	/**
+	* The visitor's theme, from the cookie the SDK writes it to.
+	*
+	* This is the whole reason it is a cookie and not web storage: read here, the class goes on `<html>` in the
+	* document the server sends, so the page arrives already painted in the right theme — no blocking script in the
+	* head, and no first paint in the other theme for the SDK to correct four hundred milliseconds later.
+	*
+	* It travels to the browser too. The class alone would settle what the page LOOKS like, but a space can bind to
+	* `{{ theme.resolved }}` or gate a rule on the scheme, and a client that started at `system` while the server
+	* rendered `dark` would hydrate different markup and throw away the tree.
+	*
+	* Absent — a first visit — is not a problem to solve: nothing is stamped, `system` is what the provider starts
+	* at, and the stylesheet's media queries answer, which is exactly right.
+	*/
+	const theme = themeFromCookies(req.headers.cookie);
 	const offlineDataStr = escapeJson(JSON.stringify({
 		offlineData,
 		offlineMode: true,
@@ -36,8 +91,10 @@ var prepareRender = async (req, config, spaceId, environment, revision, pluginMa
 		renderMode: "raw",
 		server,
 		sdkDevToolsStylePath,
+		...theme ? { theme } : {},
 		...clientAnalytics ? { analytics: clientAnalytics } : {},
-		...branding ? { branding } : {}
+		...branding ? { branding } : {},
+		...overQuota ? { overQuota } : {}
 	}));
 	const pluginNames = req.ctx.spaceDeployment?.pluginNames ?? [];
 	const pluginSources = req.ctx.spaceDeployment?.pluginSources;
@@ -55,7 +112,10 @@ var prepareRender = async (req, config, spaceId, environment, revision, pluginMa
 	];
 	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 templatePlugins = (entries.length > 0 ? entries : req.ctx.spaceDeployment?.templateProps?.plugins)?.map((entry) => ({
+		...entry,
+		ssr: entry.keyName in pluginComponents
+	}));
 	const vendorJs = (config.devMode ? "/sdk-assets/plitzi-sdk-dev-vendor.js" : "/sdk-assets/plitzi-sdk-vendor.js") + v;
 	return {
 		componentProps: {
@@ -63,13 +123,15 @@ var prepareRender = async (req, config, spaceId, environment, revision, pluginMa
 			offlineData,
 			server,
 			environment: req.ctx.spaceDeployment?.environment ?? environment,
-			debugMode,
+			debugMode: debugRendered,
 			sdkDevToolsStylePath,
-			branding
+			branding,
+			overQuota,
+			theme
 		},
 		entries,
 		templateParams: {
-			title: "Plitzi App",
+			title: DEFAULT_TITLE,
 			jsPath: `/sdk-assets/plitzi-sdk.js${v}`,
 			cssPath: `/sdk-assets/plitzi-sdk.css${v}`,
 			react: vendorJs,
@@ -77,9 +139,26 @@ var prepareRender = async (req, config, spaceId, environment, revision, pluginMa
 			reactDom: vendorJs,
 			reactDomClient: vendorJs,
 			reactCompilerRuntime: vendorJs,
+			/**
+			* The class this document wears, straight onto `<html>` — see `theme` above.
+			*
+			* `system` and "never chose" both write nothing, and the silence is the mechanism: the stylesheet's
+			* `prefers-color-scheme` queries are guarded on the absence of these classes, so stamping one would freeze the
+			* page against the machine it is running on.
+			*/
+			themeClass: theme && theme !== "system" ? theme : void 0,
+			/**
+			* The space's own families, requested by the document itself.
+			*
+			* Ahead of the deployment's `templateProps` because a deployment cannot know them: they are a fact about the
+			* space's style document, and a page whose text is laid out in a face the browser has not been asked for is
+			* a page that renders in a fallback and then reflows.
+			*/
+			fonts: fontsToHead(offlineData?.style.fonts ?? [], fontUrlResolver(config.fonts?.baseUrl)),
 			...req.ctx.spaceDeployment?.templateProps,
+			...pageSeo,
 			plugins: templatePlugins,
-			debugMode,
+			debugMode: debugAuthorized,
 			ssrOnly: config.ssrOnly === true,
 			offlineData: offlineDataStr
 		}

package/dist/modules/ssr/prepareRender.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/modules/ssr/preview.d.ts

@@ -1,10 +1,23 @@
 import { DraftStore, OfflineDataRaw, SSRRequest, SSRServerConfig } from '@plitzi/sdk-shared';
-/** The READ side of draft-preview: a render resolving a stashed draft from its one-shot token. The write side —
- *  applying unsaved operations and rendering the result — lives in `@plitzi/sdk-mcp`, which is what knows how to
- *  interpret an operation; a page-only deployment keeps this much and never loads that. */
-/** 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. */
+/** The READ side of draft-preview: a render resolving a stashed draft from its token. The write side — applying
+ *  unsaved operations and rendering the result — lives in `@plitzi/sdk-mcp`, which is what knows how to interpret an
+ *  operation; a page-only deployment keeps this much and never loads that. */
+/** In-memory 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. */
 export declare const createMemoryDraftStore: () => DraftStore;
-/** 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). */
-export declare const takeDraftOverride: (req: SSRRequest, config: SSRServerConfig) => Promise<OfflineDataRaw | undefined>;
+/** What a draft render has to say about itself, so nothing downstream has to ask the store a second time. */
+export type DraftOverride = {
+    data: OfflineDataRaw;
+    token: string;
+    /** Whether the token survived the read — which is what decides if the visit is worth remembering in a cookie. */
+    reusable: boolean;
+};
+/**
+ * Resolve the draft this request is looking at, if any.
+ *
+ * Returns undefined on a normal request (renders persisted state) and on a token the store no longer has — expired,
+ * dropped, or a one-shot that has already been rendered once.
+ */
+export declare const takeDraftOverride: (req: SSRRequest, config: SSRServerConfig) => Promise<DraftOverride | undefined>;
+/** The `Set-Cookie` that carries a draft session through the rest of the visit. */
+export declare const draftSessionCookie: (req: SSRRequest, token: string, ttlMs: number) => string;

package/dist/modules/ssr/preview.js

@@ -1,33 +1,57 @@
-import { PREVIEW_TOKEN_PARAM } from "../../core/previewToken.js";
+import { PREVIEW_COOKIE, readDraftToken } from "../../core/previewToken.js";
 //#region src/modules/ssr/preview.ts
-/** The READ side of draft-preview: a render resolving a stashed draft from its one-shot token. The write side —
-*  applying unsaved operations and rendering the result — lives in `@plitzi/sdk-mcp`, which is what knows how to
-*  interpret an operation; a page-only deployment keeps this much and never loads that. */
-/** 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. */
+/** The READ side of draft-preview: a render resolving a stashed draft from its token. The write side — applying
+*  unsaved operations and rendering the result — lives in `@plitzi/sdk-mcp`, which is what knows how to interpret an
+*  operation; a page-only deployment keeps this much and never loads that. */
+/** In-memory 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) {
+		put(token, data, { ttlMs, reusable = false }) {
 			store.set(token, {
 				data,
-				expiresAt: Date.now() + ttlMs
+				expiresAt: Date.now() + ttlMs,
+				reusable
 			});
 		},
 		take(token) {
 			const hit = store.get(token);
 			if (!hit) return;
+			if (!hit.reusable || hit.expiresAt <= Date.now()) store.delete(token);
+			return hit.expiresAt > Date.now() ? {
+				data: hit.data,
+				reusable: hit.reusable
+			} : void 0;
+		},
+		drop(token) {
 			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). */
+/**
+* Resolve the draft this request is looking at, if any.
+*
+* Returns undefined on a normal request (renders persisted state) and on a token the store no longer has — expired,
+* dropped, or a one-shot that has already been rendered once.
+*/
 var takeDraftOverride = async (req, config) => {
-	const token = req.query[PREVIEW_TOKEN_PARAM];
+	const token = readDraftToken(req);
 	if (!token || !config.draftStore) return;
-	return config.draftStore.take(token);
+	const entry = await config.draftStore.take(token);
+	return entry ? {
+		...entry,
+		token
+	} : void 0;
 };
+/** The `Set-Cookie` that carries a draft session through the rest of the visit. */
+var draftSessionCookie = (req, token, ttlMs) => [
+	`${PREVIEW_COOKIE}=${encodeURIComponent(token)}`,
+	"Path=/",
+	"HttpOnly",
+	"SameSite=Lax",
+	`Max-Age=${Math.max(0, Math.floor(ttlMs / 1e3))}`,
+	...req.protocol === "https" ? ["Secure"] : []
+].join("; ");
 //#endregion
-export { createMemoryDraftStore, takeDraftOverride };
+export { createMemoryDraftStore, draftSessionCookie, takeDraftOverride };

package/dist/modules/ssr/registerExternalPlugins.js

@@ -1,6 +1,6 @@
+import crypto from "node:crypto";
 import path from "node:path";
 import fs from "node:fs/promises";
-import crypto from "node:crypto";
 //#region src/modules/ssr/registerExternalPlugins.ts
 var MANIFEST_TTL_MS = 6e5;
 var manifestCache = /* @__PURE__ */ new Map();
@@ -86,7 +86,7 @@ var registerPlugin = async (pluginManager, plugin) => {
 	const source = {
 		js: jsUrl,
 		css: findAsset(manifest, "style", plugin.resource),
-		action: "download",
+		action: "cdn",
 		version: manifest.version
 	};
 	return pluginManager.ensure(plugin.type, source);

package/dist/modules/ssr/resolvePageSeo.d.ts

@@ -0,0 +1,18 @@
+import { Schema } from '@plitzi/sdk-shared';
+export type PageSeo = {
+    title?: string;
+    description?: string;
+};
+/**
+ * The title and description the addressed page declares for itself.
+ *
+ * The page element has carried `seoEnabled` / `seoPageTitle` / `seoPageDescription` all along — the builder edits
+ * them and the client renders them into the head through Helmet — but the SSR document was built from a constant,
+ * so every server-rendered page arrived titled the same. That is the half a crawler and a link preview see, which
+ * is the half that matters: they read the document as delivered and never run the client.
+ *
+ * `seoEnabled: false` returns nothing rather than a default, so the deployment's own title stays in charge of a
+ * page that opted out. Blank strings are treated as absent for the same reason — the builder writes one for a
+ * field the author cleared, and an empty <title> is worse than a generic one.
+ */
+export declare const resolvePageSeo: (schema: Schema | undefined, pageId: string | undefined) => PageSeo;

package/dist/modules/ssr/resolvePageSeo.js

@@ -0,0 +1,26 @@
+//#region src/modules/ssr/resolvePageSeo.ts
+/**
+* The title and description the addressed page declares for itself.
+*
+* The page element has carried `seoEnabled` / `seoPageTitle` / `seoPageDescription` all along — the builder edits
+* them and the client renders them into the head through Helmet — but the SSR document was built from a constant,
+* so every server-rendered page arrived titled the same. That is the half a crawler and a link preview see, which
+* is the half that matters: they read the document as delivered and never run the client.
+*
+* `seoEnabled: false` returns nothing rather than a default, so the deployment's own title stays in charge of a
+* page that opted out. Blank strings are treated as absent for the same reason — the builder writes one for a
+* field the author cleared, and an empty <title> is worse than a generic one.
+*/
+var resolvePageSeo = (schema, pageId) => {
+	if (!schema || !pageId) return {};
+	const page = schema.flat[pageId];
+	if (!page?.attributes.seoEnabled) return {};
+	const title = page.attributes.seoPageTitle?.trim();
+	const description = page.attributes.seoPageDescription?.trim();
+	return {
+		...title ? { title } : {},
+		...description ? { description } : {}
+	};
+};
+//#endregion
+export { resolvePageSeo };

package/dist/modules/ssr/resolvePageSeo.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/modules/ssr/template.test.d.ts

@@ -0,0 +1 @@
+export {};