@plitzi/sdk-server 0.32.25 → 0.33.0

package/dist/modules/connectors/getByPath.js

@@ -0,0 +1,21 @@
+//#region src/modules/connectors/getByPath.ts
+/**
+* Reads a dot path out of an arbitrary JSON response (`data.items`, `meta.pagination.total`). Kept local and
+* dependency-free on purpose: the equivalent helper in plitzi-ui would drag the UI bundle into the request path.
+*
+* A path of `.` or an empty path returns the value itself, which is how a manifest says "the response *is* the
+* array" or "the record *is* its own values".
+*/
+var getByPath = (source, path) => {
+	if (!path || path === ".") return source;
+	return path.split(".").reduce((current, key) => {
+		if (current === null || current === void 0) return;
+		if (Array.isArray(current)) {
+			const index = Number(key);
+			return Number.isInteger(index) ? current[index] : void 0;
+		}
+		if (typeof current === "object") return current[key];
+	}, source);
+};
+//#endregion
+export { getByPath };

package/dist/modules/connectors/index.d.ts

@@ -0,0 +1,7 @@
+export { fetchConnectorRecords, rebaseMedia, writeConnectorRecord } from './engine';
+export { createConnectorResolver } from './resolver';
+export { getByPath } from './getByPath';
+export { collectBoundPaths, projectSlice } from './projection';
+export type { FetchConnectorOptions, WriteConnectorOptions } from './engine';
+export type { ConnectorLookups, ProviderPagination } from './resolver';
+export type { ConnectorAuth, ConnectorCredential, ConnectorEndpoints, ConnectorFilter, ConnectorManifest, ConnectorManifestDraft, ConnectorPageInfo, ConnectorPagination, ConnectorQuery, ConnectorReadEndpoint, ConnectorRecord, ConnectorResponseMapping, ConnectorResult, ConnectorWriteEndpoint } from './types';

package/dist/modules/connectors/projection.d.ts

@@ -0,0 +1,18 @@
+import { Element } from '@plitzi/sdk-shared';
+/**
+ * Collects the paths a page actually reads out of one provider source.
+ *
+ * Bindings declare `<source>.<path>` directly; transformer params, `when` rules and attribute templates can carry
+ * the same reference inside a twig token, so both are scanned. Returning an empty set means nothing statically
+ * references the source — the caller must then keep the slice whole rather than serve an empty one.
+ */
+export declare const collectBoundPaths: (flat: Record<string, Element>, rootId: string, sourceName: string) => string[];
+/**
+ * Narrows a provider slice to what the page reads.
+ *
+ * A CMS entry routinely carries fields nobody bound — author emails, internal notes, unpublished translations.
+ * Those would otherwise land in the client store and in the HTML, so anything unreferenced is dropped here. With no
+ * declared paths the slice passes through untouched: an empty projection would blank the page, and shipping too
+ * much is a smaller failure than rendering nothing.
+ */
+export declare const projectSlice: (slice: unknown, paths: string[]) => unknown;

package/dist/modules/connectors/projection.js

@@ -0,0 +1,108 @@
+//#region src/modules/connectors/projection.ts
+/**
+* Structural keys a page needs regardless of what it binds, so paging and empty states never depend on static
+* analysis. A pager binds `pageInfo.*` and an empty state binds `isEmpty`; both would otherwise be projected away
+* for any page that reads neither.
+*/
+var ALWAYS_KEPT = [
+	"pageInfo",
+	"isEmpty",
+	"hasError",
+	"errorMessage"
+];
+var createNode = () => ({
+	leaf: false,
+	children: /* @__PURE__ */ new Map()
+});
+var insert = (root, segments) => {
+	let node = root;
+	for (const segment of segments) {
+		const key = /^\d+$/.test(segment) ? "*" : segment;
+		let next = node.children.get(key);
+		if (!next) {
+			next = createNode();
+			node.children.set(key, next);
+		}
+		node = next;
+	}
+	node.leaf = true;
+};
+/** Pulls `<source>.<path>` references out of any string that may carry a twig token. */
+var collectFromTemplate = (value, sourceName, found) => {
+	if (typeof value !== "string") return;
+	const pattern = new RegExp(`${sourceName}\\.([a-zA-Z0-9_\\-.]+)`, "g");
+	for (const match of value.matchAll(pattern)) found.add(match[1].replace(/\.$/, ""));
+};
+var walkUnknown = (value, sourceName, found) => {
+	if (typeof value === "string") {
+		collectFromTemplate(value, sourceName, found);
+		return;
+	}
+	if (Array.isArray(value)) {
+		value.forEach((entry) => walkUnknown(entry, sourceName, found));
+		return;
+	}
+	if (value !== null && typeof value === "object") Object.values(value).forEach((entry) => walkUnknown(entry, sourceName, found));
+};
+/**
+* Collects the paths a page actually reads out of one provider source.
+*
+* Bindings declare `<source>.<path>` directly; transformer params, `when` rules and attribute templates can carry
+* the same reference inside a twig token, so both are scanned. Returning an empty set means nothing statically
+* references the source — the caller must then keep the slice whole rather than serve an empty one.
+*/
+var collectBoundPaths = (flat, rootId, sourceName) => {
+	if (!sourceName) return [];
+	const found = /* @__PURE__ */ new Set();
+	const seen = /* @__PURE__ */ new Set();
+	const pending = [rootId];
+	const prefix = `${sourceName}.`;
+	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;
+		const { bindings, items } = element.definition;
+		Object.values(bindings ?? {}).forEach((categoryBindings) => {
+			categoryBindings.forEach((binding) => {
+				if (binding.source.startsWith(prefix)) found.add(binding.source.slice(prefix.length));
+				walkUnknown(binding.transformers, sourceName, found);
+				walkUnknown(binding.when, sourceName, found);
+			});
+		});
+		walkUnknown(element.attributes, sourceName, found);
+		if (items) pending.push(...items);
+	}
+	return [...found];
+};
+var projectNode = (value, node) => {
+	if (node.leaf || node.children.size === 0) return value;
+	if (Array.isArray(value)) {
+		const itemNode = node.children.get("*");
+		return value.map((item) => projectNode(item, itemNode ?? node));
+	}
+	if (value === null || typeof value !== "object") return value;
+	const source = value;
+	return [...node.children.entries()].reduce((acum, [key, child]) => {
+		if (key !== "*" && key in source) acum[key] = projectNode(source[key], child);
+		return acum;
+	}, {});
+};
+/**
+* Narrows a provider slice to what the page reads.
+*
+* A CMS entry routinely carries fields nobody bound — author emails, internal notes, unpublished translations.
+* Those would otherwise land in the client store and in the HTML, so anything unreferenced is dropped here. With no
+* declared paths the slice passes through untouched: an empty projection would blank the page, and shipping too
+* much is a smaller failure than rendering nothing.
+*/
+var projectSlice = (slice, paths) => {
+	if (paths.length === 0 || slice === null || typeof slice !== "object") return slice;
+	const root = createNode();
+	paths.forEach((path) => insert(root, path.split(".")));
+	ALWAYS_KEPT.forEach((key) => insert(root, [key]));
+	return projectNode(slice, root);
+};
+//#endregion
+export { collectBoundPaths, projectSlice };

package/dist/modules/connectors/resolver.d.ts

@@ -0,0 +1,18 @@
+import { ConnectorCredential, ConnectorManifest } from './types';
+import { RscElementResolver } from '../rsc/resolveRscData';
+export type ConnectorLookups = {
+    /** Reads a manifest by id. Server-side state: manifests name endpoints and must never reach the browser. */
+    getConnector: (spaceId: number, connectorId: string) => Promise<ConnectorManifest | undefined>;
+    /** Resolves the secret referenced by `manifest.credential`. */
+    getCredential?: (spaceId: number, identifier: string) => Promise<ConnectorCredential | undefined>;
+    fetchImpl?: typeof fetch;
+};
+export type ProviderPagination = 'none' | 'url' | 'append';
+/**
+ * Bridges the connector engine into the RSC pipeline: reads the provider element's own configuration, resolves its
+ * manifest and credential server-side, and returns the slice the element will publish as a binding source.
+ *
+ * An element without a connector resolves to nothing rather than failing — an unconfigured provider on a page is a
+ * draft, not an error.
+ */
+export declare const createConnectorResolver: ({ getConnector, getCredential, fetchImpl }: ConnectorLookups) => RscElementResolver;

package/dist/modules/connectors/resolver.js

@@ -0,0 +1,68 @@
+import { fetchConnectorRecords } from "./engine.js";
+import { collectBoundPaths, projectSlice } from "./projection.js";
+import getSourceName from "@plitzi/sdk-shared/dataSource/helpers/getSourceName";
+//#region src/modules/connectors/resolver.ts
+var DEFAULT_PAGE_PARAM = "page";
+var toLimit = (limit, singleRecord) => {
+	if (singleRecord) return 1;
+	const parsed = typeof limit === "string" ? parseInt(limit, 10) : limit;
+	return parsed !== void 0 && !Number.isNaN(parsed) ? parsed : void 0;
+};
+/**
+* Reads the requested page out of the request's query string.
+*
+* Both pagination modes arrive here: URL paging puts the parameter in the visitor's address bar, and append mode
+* puts the same parameter on its `/_rsc` refresh. One code path, so a "load more" window and a shared link of the
+* same page resolve to the same records.
+*/
+var toPage = (queryParams, attributes) => {
+	if (attributes.pagination === "none" || attributes.singleRecord) return 1;
+	const raw = queryParams[attributes.pageParam ?? DEFAULT_PAGE_PARAM];
+	const parsed = raw ? parseInt(raw, 10) : NaN;
+	return Number.isNaN(parsed) || parsed < 1 ? 1 : parsed;
+};
+/**
+* Bridges the connector engine into the RSC pipeline: reads the provider element's own configuration, resolves its
+* manifest and credential server-side, and returns the slice the element will publish as a binding source.
+*
+* An element without a connector resolves to nothing rather than failing — an unconfigured provider on a page is a
+* draft, not an error.
+*/
+var createConnectorResolver = ({ getConnector, getCredential, fetchImpl }) => async ({ element, flat, routeParams, queryParams, spaceId }) => {
+	const attributes = element.attributes;
+	const { connector: connectorId, endpoint, resource, limit, singleRecord = false, filters } = attributes;
+	if (!connectorId) return;
+	const manifest = await getConnector(spaceId, connectorId);
+	if (!manifest) throw new Error(`Connector "${connectorId}" is not configured for space ${spaceId}`);
+	const credential = manifest.credential && getCredential ? await getCredential(spaceId, manifest.credential) : void 0;
+	const pageSize = toLimit(limit, singleRecord);
+	const page = toPage(queryParams, attributes);
+	const pageParam = attributes.pageParam ?? DEFAULT_PAGE_PARAM;
+	const { records, pageInfo } = await fetchConnectorRecords({
+		manifest,
+		endpoint,
+		credential,
+		query: {
+			resource,
+			limit: pageSize,
+			offset: pageSize === void 0 ? void 0 : (page - 1) * pageSize,
+			page,
+			cursor: queryParams[`${pageParam}Cursor`],
+			filters,
+			routeParams,
+			queryParams
+		},
+		fetchImpl
+	});
+	const slice = {
+		...singleRecord ? { record: records[0] } : { records },
+		pageInfo,
+		isEmpty: records.length === 0,
+		hasError: false,
+		errorMessage: ""
+	};
+	if (manifest.projection === "full") return slice;
+	return projectSlice(slice, collectBoundPaths(flat, element.id, getSourceName(element.definition.type, element)));
+};
+//#endregion
+export { createConnectorResolver };

package/dist/modules/connectors/types.d.ts

@@ -0,0 +1,19 @@
+import { ConnectorRecord, PageInfo } from '@plitzi/sdk-shared';
+/**
+ * The manifest vocabulary lives in `@plitzi/sdk-shared` because the builder authors the document the engine
+ * executes. Only the result shapes below are server-side: nothing outside this process ever sees them.
+ */
+export type { ConnectorAuth, ConnectorCredential, ConnectorEndpoints, ConnectorFilter, ConnectorManifest, ConnectorManifestDraft, ConnectorPagination, ConnectorQuery, ConnectorReadEndpoint, ConnectorRecord, ConnectorResponseMapping, ConnectorWriteEndpoint } from '@plitzi/sdk-shared';
+/**
+ * `PageInfo` is the cursor-shaped connection contract shared with GraphQL. A pager cannot be rendered from cursors
+ * alone, so a connector result also carries the ordinal window it just read.
+ */
+export type ConnectorPageInfo = PageInfo & {
+    page: number;
+    /** Total pages when the provider reports a total; `0` when it does not and paging relies on page size. */
+    pageCount: number;
+};
+export type ConnectorResult = {
+    records: ConnectorRecord[];
+    pageInfo: ConnectorPageInfo;
+};

package/dist/{src/modules → modules}/rsc/handler.d.ts

@@ -1,6 +1,6 @@
 import { TtlCache } from '../../helpers/cache';
 import { PluginManager } from '../../plugins/manager';
-import { SSRRequest, SSRResponseHelpers, SSRServerConfig } from '@plitzi/sdk-shared';
+import { SSRPageServerConfig, SSRRequest, SSRResponseHelpers } from '@plitzi/sdk-shared';
 /**
  * Handles GET /_rsc requests.
  *
@@ -14,4 +14,4 @@ import { SSRRequest, SSRResponseHelpers, SSRServerConfig } from '@plitzi/sdk-sha
  * - Authenticated requests: Cache-Control: private, max-age=<ttl>
  * - Unauthenticated requests: Cache-Control: public, max-age=<ttl>
  */
-export declare const handleRsc: (req: SSRRequest, res: SSRResponseHelpers, config: SSRServerConfig, _pluginManager: PluginManager, cache?: TtlCache<string>) => Promise<void>;
+export declare const handleRsc: (req: SSRRequest, res: SSRResponseHelpers, config: SSRPageServerConfig, _pluginManager: PluginManager, cache?: TtlCache<string>) => Promise<void>;

package/dist/modules/rsc/handler.js

@@ -1,6 +1,48 @@
 import { DEFAULT_TTL_MS } from "../../helpers/cache/defaults.js";
 import { buildRscCacheKey } from "../../helpers/cache/keys.js";
+import { createOfflineDataLoader } from "../../helpers/offlineDataLoader.js";
 //#region src/modules/rsc/handler.ts
+/** Bounds the reflected location: it only ever selects one of this space's own pages, but it is still input. */
+var MAX_PAGE_LOCATION = 2048;
+var meterRsc = async (req, config, spaceId, environment, revision, cached) => {
+	if (!config.adapters.meter) return;
+	try {
+		await config.adapters.meter({
+			kind: "rsc_query",
+			cached,
+			req,
+			spaceId,
+			environment,
+			revision
+		});
+	} catch {}
+};
+/**
+* Rewrites the request to the page the browser is actually on.
+*
+* A refresh is issued against `/_rsc`, not against `/blog/my-post`, so resolving straight from `req.path` matches
+* nothing in `schema.pages` and every client-side refresh silently returns no data. The SDK sends the visitor's
+* location as `?location=`, and route params plus the page parameter are read from that instead.
+*
+* Reflecting it is safe by construction: it is matched against this space's own page list, so the worst a forged
+* value can do is resolve a page the same visitor could have loaded directly.
+*/
+var withPageLocation = (req) => {
+	const location = req.query.location;
+	if (!location || !location.startsWith("/") || location.length > MAX_PAGE_LOCATION) return req;
+	const url = new URL(location, `${req.protocol}://${req.hostname}`);
+	const query = [...url.searchParams.entries()].reduce((acum, [key, value]) => {
+		acum[key] = value;
+		return acum;
+	}, {});
+	return {
+		...req,
+		path: url.pathname,
+		search: url.search,
+		url: `${url.pathname}${url.search}`,
+		query
+	};
+};
 /**
 * Handles GET /_rsc requests.
 *
@@ -29,11 +71,13 @@ var handleRsc = async (req, res, config, _pluginManager, cache) => {
 	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 pageRequest = withPageLocation(req);
 	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 cacheKey = environment !== "main" ? buildRscCacheKey(spaceId, environment, revision, req.ctx.user?.id, idsParam, req) : void 0;
 	const cached = cacheKey ? cache?.get(cacheKey) : void 0;
+	await meterRsc(req, config, spaceId, environment, revision, !!cached);
 	if (cached) {
 		res.setHeader("Content-Type", "application/json; charset=utf-8");
 		res.setHeader("Cache-Control", cacheControl);
@@ -43,7 +87,15 @@ var handleRsc = async (req, res, config, _pluginManager, cache) => {
 	}
 	let rscData;
 	try {
-		rscData = await config.adapters.getRscData(req, spaceId, environment, revision, req.ctx.user, ids);
+		rscData = await config.adapters.getRscData({
+			req: pageRequest,
+			spaceId,
+			environment,
+			revision,
+			user: req.ctx.user,
+			ids,
+			loadOfflineData: createOfflineDataLoader(() => config.adapters.getOfflineData(spaceId, environment, revision))
+		});
 	} catch (err) {
 		console.error("[RSC] getRscData error:", err);
 		res.setStatus(500);

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

@@ -0,0 +1,35 @@
+import { Element, Environment, Schema, SSRRequest, SSRRscData, SSRUser } from '@plitzi/sdk-shared';
+/** Everything an element resolver needs to turn one `runtime: 'server'` element into its data slice. */
+export type RscResolveContext = {
+    element: Element;
+    /** The whole element map, so a resolver can inspect the subtree that consumes its data. */
+    flat: Record<string, Element>;
+    routeParams: Record<string, string | undefined>;
+    queryParams: Record<string, string>;
+    req: SSRRequest;
+    spaceId: number;
+    environment: Environment;
+    user: SSRUser | undefined;
+};
+/** 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>;
+export type ResolveRscDataOptions = {
+    schema: Schema;
+    req: SSRRequest;
+    spaceId: number;
+    environment: Environment;
+    user: SSRUser | undefined;
+    /** 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. */
+    timeoutMs?: number;
+};
+/**
+ * Resolves the server-side data slices for the page addressed by `req`.
+ *
+ * The URL is matched against the schema's pages with the same matcher the client router uses, so the element set
+ * and the route params are what the browser will see. Each `runtime: 'server'` element resolves independently:
+ * a provider that fails or hangs costs its own slice and nothing else.
+ */
+export declare const resolveRscData: ({ schema, req, spaceId, environment, user, ids, resolveElement, timeoutMs }: ResolveRscDataOptions) => Promise<SSRRscData>;

package/dist/modules/rsc/resolveRscData.js

@@ -0,0 +1,74 @@
+import { getPaths, matchRoutePath } from "@plitzi/sdk-shared/navigation";
+//#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) => {
+	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);
+		})]);
+	} finally {
+		if (timer) clearTimeout(timer);
+	}
+};
+/**
+* Resolves the server-side data slices for the page addressed by `req`.
+*
+* The URL is matched against the schema's pages with the same matcher the client router uses, so the element set
+* and the route params are what the browser will see. Each `runtime: 'server'` element resolves independently:
+* a provider that fails or hangs costs its own slice and nothing else.
+*/
+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)));
+	if (targets.length === 0) return { serverData: {} };
+	return { serverData: (await Promise.allSettled(targets.map(async (element) => ({
+		id: element.id,
+		data: await withTimeout(resolveElement({
+			element,
+			flat: schema.flat,
+			routeParams,
+			queryParams: req.query,
+			req,
+			spaceId,
+			environment,
+			user
+		}), timeoutMs, `element ${element.id}`)
+	})))).reduce((acum, result, index) => {
+		if (result.status === "rejected") {
+			console.error(`[RSC] element ${targets[index].id} failed to resolve:`, result.reason);
+			return acum;
+		}
+		if (result.value.data !== void 0) acum[result.value.id] = result.value.data;
+		return acum;
+	}, {}) };
+};
+//#endregion
+export { resolveRscData };

package/dist/{src/modules → modules}/ssr/Component.d.ts

@@ -9,6 +9,9 @@ export type ComponentProps = {
     ssrResult?: SSRRenderResult;
     sdkDevToolsStylePath?: string;
     debugMode?: boolean;
+    /** 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;
 };
-declare const Component: ({ server, renderMode, previewMode, offlineData, environment, plugins, ssrResult, sdkDevToolsStylePath, debugMode }: ComponentProps) => import("react").JSX.Element;
+declare const Component: ({ server, renderMode, previewMode, offlineData, environment, plugins, ssrResult, sdkDevToolsStylePath, debugMode, branding }: ComponentProps) => import("react").JSX.Element;
 export default Component;

package/dist/modules/ssr/Component.js

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

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

@@ -0,0 +1,9 @@
+import { TtlCache } from '../../helpers/cache';
+import { RequestMetrics } from '../../helpers/metrics';
+import { PluginManager } from '../../plugins/manager';
+import { Environment, OfflineDataRaw, SSRPageServerConfig, SSRRenderResult, SSRRequest, SSRTemplateFn } from '@plitzi/sdk-shared';
+export type BuildBodyResult = {
+    body?: string;
+    result: SSRRenderResult;
+};
+export declare const buildBody: (req: SSRRequest, config: SSRPageServerConfig, spaceId: number, environment: Environment, revision: number, renderFn: SSRTemplateFn, pluginManager: PluginManager, offlineDataCache?: TtlCache<string>, metrics?: RequestMetrics, offlineDataOverride?: OfflineDataRaw) => Promise<BuildBodyResult>;

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

@@ -0,0 +1,4 @@
+import { ServerCaches } from '../../helpers/cache';
+import { PluginManager } from '../../plugins/manager';
+import { SSRPageServerConfig, SSRRequest, SSRResponseHelpers, SSRTemplateFn } from '@plitzi/sdk-shared';
+export declare const renderSSR: (req: SSRRequest, res: SSRResponseHelpers, config: SSRPageServerConfig, renderFn: SSRTemplateFn, pluginManager: PluginManager, caches: ServerCaches) => Promise<void>;

package/dist/modules/ssr/handler.js

@@ -1,10 +1,25 @@
 import { buildHtmlCacheKey } from "../../helpers/cache/keys.js";
-import { buildBody } from "./buildBody.js";
 import { takeDraftOverride } from "./preview.js";
 import { applySSRResult } from "./applySSRResult.js";
+import { buildBody } from "./buildBody.js";
 import { streamBody } from "./streamBody.js";
 import { RequestMetrics } from "../../helpers/metrics.js";
 //#region src/modules/ssr/handler.tsx
+var meterPage = async (req, config, spaceId, environment, revision, cached) => {
+	if (!config.adapters.meter) return;
+	try {
+		return await config.adapters.meter({
+			kind: "page_view",
+			cached,
+			req,
+			spaceId,
+			environment,
+			revision
+		});
+	} catch {
+		return;
+	}
+};
 var renderSSR = async (req, res, config, renderFn, pluginManager, caches) => {
 	const { environment = "main", spaceId = 1, revision = 0 } = req.ctx.spaceDeployment || {};
 	const devMode = config.devMode ?? false;
@@ -17,10 +32,12 @@ var renderSSR = async (req, res, config, renderFn, pluginManager, caches) => {
 		if (cached) {
 			res.setHeader("X-Cache", "HIT");
 			if (devMode) res.setHeader("Server-Timing", "html;desc=\"cache-hit\";dur=0");
+			await meterPage(req, config, spaceId, environment, revision, true);
 			res.send(cached);
 			return;
 		}
 	}
+	if (!offlineDataOverride) req.ctx.meter = await meterPage(req, config, spaceId, environment, revision, false);
 	const metrics = devMode ? new RequestMetrics() : void 0;
 	if (cacheKey) res.setHeader("X-Cache", "MISS");
 	if (config.streaming) {

package/dist/{src/modules → modules}/ssr/loadPluginComponents.d.ts

@@ -9,5 +9,8 @@ import { PluginEntry, SSRPlugin } from '@plitzi/sdk-shared';
  * Component-source plugins (already in memory via getComponents()) are merged in directly.
  */
 export declare const loadPluginComponents: (entries: PluginEntry[], inlineComponents?: Record<string, unknown>) => Promise<Record<string, SSRPlugin>>;
-/** Removes one or all entries from the component and failed-import caches. Call after plugin rebuild. */
-export declare const invalidatePluginComponentCache: (filePath?: string) => void;
+/** Drop the loaded-component and failed-import caches and force the next import to re-read from disk. A plugin
+ *  rebuilt at the SAME version lands back on the same path, so without this an invalidation refreshes the build
+ *  on disk while every render keeps serving the component imported before it. The plugin manager owns its own
+ *  caches and cannot reach these, which is why invalidation has to clear both sides. */
+export declare const invalidatePluginComponentCache: () => void;

package/dist/modules/ssr/loadPluginComponents.js

@@ -1,6 +1,15 @@
+import { pathToFileURL } from "node:url";
 //#region src/modules/ssr/loadPluginComponents.ts
 /** Module-level cache: absolute filePath → loaded React component. */
 var componentCache = /* @__PURE__ */ new Map();
+/** 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.
+*  Stays at 0 until something actually invalidates, so a normal render imports the plain path and every
+*  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}`;
 /**
 * 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.
@@ -26,7 +35,7 @@ var loadPluginComponents = async (entries, inlineComponents) => {
 		if (failedImports.has(filePath)) return;
 		let component = componentCache.get(filePath);
 		if (!component) try {
-			const mod = await import(filePath);
+			const mod = await import(importUrl(filePath));
 			component = mod.default ?? mod;
 			componentCache.set(filePath, component);
 		} catch (err) {
@@ -41,5 +50,14 @@ var loadPluginComponents = async (entries, inlineComponents) => {
 	}));
 	return result;
 };
+/** Drop the loaded-component and failed-import caches and force the next import to re-read from disk. A plugin
+*  rebuilt at the SAME version lands back on the same path, so without this an invalidation refreshes the build
+*  on disk while every render keeps serving the component imported before it. The plugin manager owns its own
+*  caches and cannot reach these, which is why invalidation has to clear both sides. */
+var invalidatePluginComponentCache = () => {
+	componentCache.clear();
+	failedImports.clear();
+	generation += 1;
+};
 //#endregion
-export { loadPluginComponents };
+export { invalidatePluginComponentCache, loadPluginComponents };

package/dist/{src/modules → modules}/ssr/prepareRender.d.ts

@@ -2,7 +2,7 @@ import { ComponentProps } from './Component';
 import { TtlCache } from '../../helpers/cache';
 import { RequestMetrics } from '../../helpers/metrics';
 import { PluginManager } from '../../plugins/manager';
-import { Environment, OfflineDataRaw, PluginEntry, SSRRequest, SSRServerConfig, SSRTemplateProps } from '@plitzi/sdk-shared';
+import { Environment, OfflineDataRaw, PluginEntry, SSRPageServerConfig, SSRRequest, SSRTemplateProps } from '@plitzi/sdk-shared';
 export type RenderPrep = {
     componentProps: ComponentProps;
     entries: PluginEntry[];
@@ -10,4 +10,4 @@ export type RenderPrep = {
         offlineData: string;
     };
 };
-export declare const prepareRender: (req: SSRRequest, config: SSRServerConfig, spaceId: number, environment: Environment, revision: number, pluginManager: PluginManager, offlineDataCache?: TtlCache<string>, metrics?: RequestMetrics, offlineDataOverride?: OfflineDataRaw) => Promise<RenderPrep>;
+export declare const prepareRender: (req: SSRRequest, config: SSRPageServerConfig, spaceId: number, environment: Environment, revision: number, pluginManager: PluginManager, offlineDataCache?: TtlCache<string>, metrics?: RequestMetrics, offlineDataOverride?: OfflineDataRaw) => Promise<RenderPrep>;