@plitzi/sdk-server 0.35.8 → 0.35.9

package/CHANGELOG.md

@@ -1,5 +1,29 @@
 # @plitzi/sdk-server
 
+## 0.35.9
+
+### Patch Changes
+
+- Debug a server action's whole flow from the dev-tools, not just its answer.
+
+  A run now reports an OUTLINE of what it did: every step in order, with its task, how it ended, how long it took, and
+  the redacted error of the one that broke the flow — the compensation steps `flow.onFailure` ran included. It carries
+  nothing a step was given or returned, so it goes to any page whose debugging the deployment authorized (`devMode`, or
+  a space that switched dev tools on for its published site) and to no other. The full trace, with each step's results,
+  still reaches only an authoring request or a development server.
+
+  Runs the SERVER started while rendering a page — the ones feeding `runtime: 'server'` elements — reach the dev-tools
+  too, seeded into the page and added to by every `/_rsc` refresh, under the same authorization: a page nobody
+  authorized is not told they happened. A response carrying them is never cached. A run that died on its deadline now
+  reports the step it was on rather than nothing at all.
+
+  The Actions tab was rebuilt around it: filters and search over the log, a run list that names the step that broke,
+  and a detail panel with the flow's timeline, its compensation shown apart, and what the run carried in and out.
+
+- Updated dependencies
+  - @plitzi/plitzi-sdk@0.35.9
+  - @plitzi/sdk-shared@0.35.9
+
 ## 0.35.8
 
 ### Patch Changes

package/dist/helpers/debugAuthorization.d.ts

@@ -0,0 +1,24 @@
+import { Schema } from '@plitzi/sdk-shared';
+type DebugConfig = {
+    debugMode?: boolean;
+    devMode?: boolean;
+};
+type DebugSettings = Pick<Schema['settings'], 'devTools'> | undefined;
+/**
+ * Whether a page — and what its flows did — may be debugged. One rule for the render and for every run it reports.
+ *
+ * The server decides first, through `debugMode`: set, it speaks for every space, and `false` is a refusal no space can
+ * turn around. Left unset, a development server authorizes it, and so does a space whose own settings switched
+ * `devTools` on. The settings are what this server loaded, never anything the request carries.
+ *
+ * A page nobody authorized is told nothing: not the steps behind it, not even that a flow ran.
+ */
+export declare const authorizesDebugging: (config: DebugConfig, settings: DebugSettings) => boolean;
+/**
+ * The same rule, for a request that has not loaded the space yet.
+ *
+ * The settings are read only when the server left the answer to the space. A space that cannot be read authorizes
+ * nothing: debugging is the one thing about a page that fails closed.
+ */
+export declare const resolveDebugAuthorization: (config: DebugConfig, loadSettings: () => Promise<DebugSettings>) => Promise<boolean>;
+export {};

package/dist/helpers/debugAuthorization.js

@@ -0,0 +1,27 @@
+//#region src/helpers/debugAuthorization.ts
+/**
+* Whether a page — and what its flows did — may be debugged. One rule for the render and for every run it reports.
+*
+* The server decides first, through `debugMode`: set, it speaks for every space, and `false` is a refusal no space can
+* turn around. Left unset, a development server authorizes it, and so does a space whose own settings switched
+* `devTools` on. The settings are what this server loaded, never anything the request carries.
+*
+* A page nobody authorized is told nothing: not the steps behind it, not even that a flow ran.
+*/
+var authorizesDebugging = (config, settings) => config.debugMode ?? (config.devMode === true || settings?.devTools === true);
+/**
+* The same rule, for a request that has not loaded the space yet.
+*
+* The settings are read only when the server left the answer to the space. A space that cannot be read authorizes
+* nothing: debugging is the one thing about a page that fails closed.
+*/
+var resolveDebugAuthorization = async (config, loadSettings) => {
+	if (config.debugMode !== void 0 || config.devMode === true) return authorizesDebugging(config, void 0);
+	try {
+		return authorizesDebugging(config, await loadSettings());
+	} catch {
+		return false;
+	}
+};
+//#endregion
+export { authorizesDebugging, resolveDebugAuthorization };

package/dist/modules/actions/runtime/errors.d.ts

@@ -1,4 +1,4 @@
-import { ActionErrorReason } from '@plitzi/sdk-shared';
+import { ActionErrorReason, ActionRunStep } from '@plitzi/sdk-shared';
 /**
  * A run that stopped for a reason the caller is entitled to know, as opposed to one whose step threw.
  *
@@ -7,5 +7,10 @@ import { ActionErrorReason } from '@plitzi/sdk-shared';
  */
 export declare class ActionRunError extends Error {
     reason: ActionErrorReason;
+    /**
+     * The steps a run that STARTED took before it hit this — its deadline, a budget — set by the runner as it rethrows.
+     * A refusal before the run began has none. The same outline a completed run returns, and nothing more.
+     */
+    steps?: ActionRunStep[];
     constructor(reason: ActionErrorReason, message: string);
 }

package/dist/modules/actions/runtime/errors.js

@@ -7,6 +7,11 @@
 */
 var ActionRunError = class extends Error {
 	reason;
+	/**
+	* The steps a run that STARTED took before it hit this — its deadline, a budget — set by the runner as it rethrows.
+	* A refusal before the run began has none. The same outline a completed run returns, and nothing more.
+	*/
+	steps;
 	constructor(reason, message) {
 		super(message);
 		this.name = "ActionRunError";

package/dist/modules/actions/runtime/renderResolver.js

@@ -6,6 +6,19 @@ import { createHash, randomUUID } from "node:crypto";
 import { triggerCacheMs } from "@plitzi/sdk-shared/actions";
 //#region src/modules/actions/runtime/renderResolver.ts
 /**
+* A render run that resolved nothing, carrying what it did.
+*
+* The slice is withheld all the same — `resolveRscData` reads the rejection as the element's error state — but the
+* steps travel with the error, so a page allowed to debug is still shown where the flow broke.
+*/
+var RenderRunFailure = class extends Error {
+	summary;
+	constructor(message, summary, options) {
+		super(message, options);
+		this.summary = summary;
+	}
+};
+/**
 * What makes two renders the same question.
 *
 * Everything that can change the answer, and nothing else: the space and the version being served, the action,
@@ -84,6 +97,15 @@ var createActionResolver = (lookups, module) => {
 			* its own timeout — holding a slot and an outbound connection for a page that had already been answered.
 			*/
 			const releaseRenderStop = onAbort(signal, () => run.controller.abort());
+			const startedAt = Date.now();
+			const summaryOf = (outcome) => ({
+				actionId: entry.id,
+				runId: run.runId,
+				trigger: "render",
+				startedAt,
+				endedAt: Date.now(),
+				...outcome
+			});
 			try {
 				const result = await module.runAction({
 					entry,
@@ -106,16 +128,41 @@ var createActionResolver = (lookups, module) => {
 				* of its error one, and the bindings meant for exactly this (`hasError`, `errorMessage`) never fire: the
 				* page says "nothing here" when the truth is "this could not be fetched".
 				*/
-				if (result.status !== "completed") throw new Error(`Action "${actionId}" ended as ${result.status}`);
-				return result.output;
+				const summary = summaryOf({
+					status: result.status,
+					steps: result.steps
+				});
+				if (result.status !== "completed") throw new RenderRunFailure(`Action "${actionId}" ended as ${result.status}`, summary);
+				return {
+					output: result.output,
+					summary
+				};
 			} catch (error) {
-				if (error instanceof ActionRunError) throw new Error(`Action "${actionId}" refused this render: ${error.reason}`, { cause: error });
-				throw error;
+				if (error instanceof RenderRunFailure) throw error;
+				if (error instanceof ActionRunError) {
+					const status = error.reason === "aborted" ? "aborted" : "failed";
+					throw new RenderRunFailure(`Action "${actionId}" refused this render: ${error.reason}`, summaryOf({
+						status,
+						steps: error.steps ?? [],
+						error: error.message
+					}), { cause: error });
+				}
+				throw new RenderRunFailure(error instanceof Error ? error.message : String(error), summaryOf({
+					status: "failed",
+					steps: [],
+					error: "Action failed"
+				}), { cause: error });
 			} finally {
 				releaseRenderStop();
 				await module.guards.end(run);
 			}
 		};
+		const record = (summary) => {
+			(req.ctx.actionRuns ??= []).push({
+				...summary,
+				elementId: element.id
+			});
+		};
 		/**
 		* Everyone asking the same question at once gets one run, and its answer.
 		*
@@ -123,7 +170,14 @@ var createActionResolver = (lookups, module) => {
 		* are a thousand identical flows and a thousand identical outbound requests, arriving at whatever the action
 		* reads all in the same instant.
 		*/
-		return share.run(key, ttlMs, startRun);
+		try {
+			const { output, summary } = await share.run(key, ttlMs, startRun);
+			record(summary);
+			return output;
+		} catch (error) {
+			if (error instanceof RenderRunFailure) record(error.summary);
+			throw error;
+		}
 	};
 };
 //#endregion

package/dist/modules/actions/runtime/runAction.js

@@ -191,6 +191,17 @@ var failureHandlerOf = (nodes, trigger) => {
 		next = nodes[next.afterNode];
 	}
 };
+/** A step as a debugger may see it: what it was and how it ended, and nothing it was given or returned. */
+var stepOf = (node, { status, phase, startTime, endTime, error }) => ({
+	id: node.id,
+	title: node.title || node.action,
+	action: node.action,
+	status,
+	phase,
+	startTime,
+	endTime,
+	...error === void 0 ? {} : { error }
+});
 var withDefaults = (task, params) => Object.entries(task.params).reduce((acum, [key, param]) => {
 	if (acum[key] === void 0 || acum[key] === "") acum[key] = param.defaultValue ?? "";
 	return acum;
@@ -300,6 +311,7 @@ var createActionRunner = (config, registry, baseFetch = fetch) => {
 		});
 		const buildContext = contextFor(controller.signal, createRunFetch(baseFetch, controller.signal, limits, lineage));
 		const trace = [];
+		const steps = [];
 		const startedAt = Date.now();
 		let failure;
 		/**
@@ -338,6 +350,65 @@ var createActionRunner = (config, registry, baseFetch = fetch) => {
 		const failureHandler = failureHandlerOf(document.nodes, triggerNode);
 		/** The step the flow was running when it stopped — what `{{ failure.step }}` names to the undo. */
 		let stepInFlight = "";
+		let stepInFlightSince = 0;
+		/**
+		* Set once the run stopped awaiting its flow. A step that ignored the abort may still settle afterwards, and it
+		* must not land in the run's account after the undo that followed it — it is already recorded as where it stopped.
+		*/
+		let flowSettled = false;
+		/**
+		* Runs one step and records it twice: whole in the trace, and in `steps` as a debugger may see it.
+		*
+		* A step that throws is recorded as failed before the error travels on. Where a flow broke is the first thing
+		* anybody debugging it asks, and the error the run records afterwards says only that it did.
+		*/
+		const runStep = async (node, phase, build) => {
+			const startTime = Date.now();
+			const late = () => phase === "flow" && flowSettled;
+			try {
+				const outcome = await runNode(node, scope, registry, build);
+				if (late()) return outcome;
+				const endTime = Date.now();
+				trace.push({
+					node,
+					status: outcome.status,
+					result: redact(outcome.result),
+					postCallbacks: [],
+					startTime,
+					endTime
+				});
+				steps.push(stepOf(node, {
+					status: outcome.status,
+					phase,
+					startTime,
+					endTime
+				}));
+				request.onNode?.(node.id, outcome.status);
+				scope[node.id] = outcome.result;
+				return outcome;
+			} catch (error) {
+				if (late()) throw error;
+				const endTime = Date.now();
+				const message = redact(error instanceof Error ? error.message : String(error));
+				trace.push({
+					node,
+					status: "failed",
+					result: { error: message },
+					postCallbacks: [],
+					startTime,
+					endTime
+				});
+				steps.push(stepOf(node, {
+					status: "failed",
+					phase,
+					startTime,
+					endTime,
+					error: message
+				}));
+				request.onNode?.(node.id, "failed");
+				throw error;
+			}
+		};
 		const runFlow = async () => {
 			let current = triggerNode;
 			let executed = 0;
@@ -355,19 +426,9 @@ var createActionRunner = (config, registry, baseFetch = fetch) => {
 				}
 				executed += 1;
 				if (executed > limits.maxNodes) throw new ActionRunError("over_capacity", `Action exceeded its ${limits.maxNodes} step budget`);
-				const startTime = Date.now();
 				stepInFlight = next.id;
-				const outcome = await runNode(next, scope, registry, buildContext);
-				trace.push({
-					node: next,
-					status: outcome.status,
-					result: redact(outcome.result),
-					postCallbacks: [],
-					startTime,
-					endTime: Date.now()
-				});
-				request.onNode?.(next.id, outcome.status);
-				scope[next.id] = outcome.result;
+				stepInFlightSince = Date.now();
+				const outcome = await runStep(next, "flow", buildContext);
 				if (next.action === "flow.output" && outcome.status === "success") returned = outcome.result;
 				current = next;
 				next = document.nodes[current.afterNode];
@@ -390,31 +451,28 @@ var createActionRunner = (config, registry, baseFetch = fetch) => {
 				message: failure ?? "",
 				status
 			};
+			const handlerTime = Date.now();
 			trace.push({
 				node: handler,
 				status: "success",
 				result: redact(scope.failure),
 				postCallbacks: [],
-				startTime: Date.now(),
-				endTime: Date.now()
+				startTime: handlerTime,
+				endTime: handlerTime
 			});
+			steps.push(stepOf(handler, {
+				status: "success",
+				phase: "undo",
+				startTime: handlerTime,
+				endTime: handlerTime
+			}));
 			const runUndo = async () => {
 				let executed = 0;
 				let next = document.nodes[handler.afterNode];
 				while (next) {
 					executed += 1;
 					if (executed > limits.maxNodes) throw new ActionRunError("over_capacity", `Undoing the action exceeded its ${limits.maxNodes} step budget`);
-					const startTime = Date.now();
-					const outcome = await runNode(next, scope, registry, buildUndoContext);
-					trace.push({
-						node: next,
-						status: outcome.status,
-						result: redact(outcome.result),
-						postCallbacks: [],
-						startTime,
-						endTime: Date.now()
-					});
-					scope[next.id] = outcome.result;
+					await runStep(next, "undo", buildUndoContext);
 					next = document.nodes[next.afterNode];
 				}
 			};
@@ -475,9 +533,18 @@ var createActionRunner = (config, registry, baseFetch = fetch) => {
 				});
 			}
 		} finally {
+			flowSettled = true;
 			deadline.clear();
 			releaseOuter();
 		}
+		const stuck = document.nodes[stepInFlight];
+		if (status !== "completed" && stuck && !steps.some((step) => step.phase === "flow" && step.id === stepInFlight)) steps.push(stepOf(stuck, {
+			status: "failed",
+			phase: "flow",
+			startTime: stepInFlightSince,
+			endTime: Date.now(),
+			...failure === void 0 ? {} : { error: redact(failure) }
+		}));
 		if (status !== "completed" && failureHandler?.enabled) await undo(failureHandler);
 		const output = returned ?? {};
 		await record({
@@ -496,7 +563,10 @@ var createActionRunner = (config, registry, baseFetch = fetch) => {
 			})),
 			...failure === void 0 ? {} : { error: redact(failure) }
 		});
-		if (fatal) throw fatal;
+		if (fatal) {
+			fatal.steps = [...steps];
+			throw fatal;
+		}
 		/**
 		* The trace is COPIED out.
 		*
@@ -507,7 +577,8 @@ var createActionRunner = (config, registry, baseFetch = fetch) => {
 			runId,
 			status,
 			output: redact(output),
-			trace: [...trace]
+			trace: [...trace],
+			steps: [...steps]
 		};
 	};
 	return { runAction };

package/dist/modules/actions/transport/callHandler.js

@@ -3,6 +3,7 @@ import { triggerParams } from "../runtime/triggers.js";
 import { precheckRun } from "../runtime/precheck.js";
 import onAbort from "../../../helpers/onAbort.js";
 import { openStream, wantsStream } from "./stream.js";
+import { resolveDebugAuthorization } from "../../../helpers/debugAuthorization.js";
 import { reportReject } from "../runtime/report.js";
 import { triggerAccess } from "@plitzi/sdk-shared/actions";
 //#region src/modules/actions/transport/callHandler.ts
@@ -156,6 +157,24 @@ var handleActionCall = async (deps) => {
 	const abortRun = () => run.controller.abort();
 	const releaseAbort = onAbort(signal, abortRun);
 	const stream = wantsStream(req.headers.accept) ? openStream(raw, abortRun, run.runId) : void 0;
+	/**
+	* What a debugger may be told about this run, beside its answer.
+	*
+	* The OUTLINE — which steps ran, how each ended, where the flow broke — goes to a page whose debugging the
+	* deployment authorized: a dev server, or a space that switched dev tools on for its own site. Nothing else gets
+	* it, and it carries nothing a step was given or returned.
+	*
+	* The full TRACE, with every step's results, only to an authoring request or a development server: those results
+	* can hold another visitor's data, and sending them to an authoring request is what puts a SERVER run in the same
+	* Workflow debugger as a client one. Both are gated on the ACTION too — one behind a session tells an anonymous
+	* caller nothing about its flow.
+	*
+	* Answered once the run is over, for the answer and for the failure alike: a run that died on its deadline is
+	* exactly the one somebody is debugging.
+	*/
+	const readsRun = mayReadTrace(entryPoint, req.ctx.user);
+	const fullTrace = readsRun && (authoring === true || config.devMode === true);
+	const showsOutline = async () => readsRun && (fullTrace || await resolveDebugAuthorization(config, async () => (await config.adapters.getOfflineData(spaceId, environment, revision))?.schema.settings));
 	let outcome;
 	try {
 		const result = await module.runAction({
@@ -188,13 +207,15 @@ var handleActionCall = async (deps) => {
 			} : {}
 		});
 		outcome = result;
+		const outline = await showsOutline();
 		if (stream) {
 			stream.send({
 				event: "done",
 				data: {
 					runId: result.runId,
 					status: result.status,
-					output: result.output
+					output: result.output,
+					...outline ? { steps: result.steps } : {}
 				}
 			});
 			stream.close();
@@ -205,25 +226,32 @@ var handleActionCall = async (deps) => {
 			status: result.status,
 			output: result.output
 		};
-		if ((authoring === true || config.devMode === true) && mayReadTrace(entryPoint, req.ctx.user)) payload.trace = result.trace;
+		if (outline) payload.steps = result.steps;
+		if (fullTrace) payload.trace = result.trace;
 		send(res, 200, payload, result.runId);
 	} catch (error) {
 		const reason = error instanceof ActionRunError ? error.reason : "failed";
 		const message = error instanceof ActionRunError ? error.message : "Action failed";
 		if (!(error instanceof ActionRunError)) console.error("[Actions] run failed:", error);
+		const steps = error instanceof ActionRunError && error.steps && await showsOutline() ? error.steps : void 0;
 		if (stream) {
 			stream.send({
 				event: "error",
 				data: {
 					runId: run.runId,
 					error: message,
-					reason
+					reason,
+					...steps ? { steps } : {}
 				}
 			});
 			stream.close();
 			return;
 		}
-		fail(res, reason, message, run.runId);
+		send(res, STATUS_BY_REASON[reason], {
+			error: message,
+			reason,
+			...steps ? { steps } : {}
+		}, run.runId);
 	} finally {
 		releaseAbort();
 		await module.guards.end(run, outcome);

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

@@ -1,5 +1,5 @@
 import { ActionEmailSender } from './runtime/email';
-import { ActionEmailConfig, ActionEntry, ActionLimits, ActionRejectRecord, ActionRunRecord, ActionRunStatus, ActionTriggerType, ConnectorManifest, Environment, InteractionCallbackParam, InteractionNode, InteractionNodeStatus, SpaceRevision, SSRUser } from '@plitzi/sdk-shared';
+import { ActionEmailConfig, ActionEntry, ActionLimits, ActionRejectRecord, ActionRunRecord, ActionRunStatus, ActionRunStep, ActionTriggerType, ConnectorManifest, Environment, InteractionCallbackParam, InteractionNode, InteractionNodeStatus, SpaceRevision, SSRUser } from '@plitzi/sdk-shared';
 /** Resolved secret material, as the connector engine already models it. */
 export type ActionCredential = Record<string, string>;
 /**
@@ -236,4 +236,9 @@ export type ActionRunResult = {
     output: Record<string, unknown>;
     /** The same shape the dev-tools Interactions panel renders. Redacted before it leaves the process. */
     trace: InteractionNode[];
+    /**
+     * What the run did, step by step, without what any step was given or returned — the part a debugger may show to
+     * anybody allowed to debug the page. The trace above is for authoring and development servers alone.
+     */
+    steps: ActionRunStep[];
 };

package/dist/modules/rsc/handler.js

@@ -1,3 +1,4 @@
+import { resolveDebugAuthorization } from "../../helpers/debugAuthorization.js";
 import { DEFAULT_TTL_MS } from "../../helpers/cache/defaults.js";
 import { buildRscCacheKey } from "../../helpers/cache/keys.js";
 import { readDraftToken } from "../../core/previewToken.js";
@@ -98,6 +99,7 @@ var handleRsc = async (req, res, config, _pluginManager, cache) => {
 		res.send(cached);
 		return;
 	}
+	const loadOfflineData = createOfflineDataLoader(() => config.adapters.getOfflineData(spaceId, environment, revision));
 	let rscData;
 	try {
 		rscData = await config.adapters.getRscData({
@@ -107,7 +109,7 @@ var handleRsc = async (req, res, config, _pluginManager, cache) => {
 			revision,
 			user: req.ctx.user,
 			ids,
-			loadOfflineData: createOfflineDataLoader(() => config.adapters.getOfflineData(spaceId, environment, revision))
+			loadOfflineData
 		});
 	} catch (err) {
 		console.error("[RSC] getRscData error:", err);
@@ -115,16 +117,18 @@ var handleRsc = async (req, res, config, _pluginManager, cache) => {
 		res.send(JSON.stringify({ error: "RSC data fetch failed" }));
 		return;
 	}
+	const actionRuns = Boolean(req.ctx.actionRuns?.length) && await resolveDebugAuthorization(config, async () => (await loadOfflineData())?.schema.settings) ? req.ctx.actionRuns : void 0;
 	const payload = {
 		version: 1,
 		transport: "json",
 		spaceId,
 		environment,
 		revision,
-		...rscData
+		...rscData,
+		...actionRuns ? { actionRuns } : {}
 	};
 	const payloadStr = JSON.stringify(payload);
-	if (cacheKey) cache?.set(cacheKey, payloadStr);
+	if (cacheKey && !actionRuns?.length) cache?.set(cacheKey, payloadStr);
 	res.setHeader("Content-Type", "application/json; charset=utf-8");
 	res.setHeader("Cache-Control", cacheControl);
 	res.setHeader("X-Cache", "MISS");

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

@@ -2,8 +2,10 @@ 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';
+/** `cacheable` is false for a body that must not be served to anybody else: it carries this request's own runs. */
 export type BuildBodyResult = {
     body?: string;
     result: SSRRenderResult;
+    cacheable: boolean;
 };
 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/buildBody.js

@@ -12,7 +12,10 @@ var buildBody = async (req, config, spaceId, environment, revision, renderFn, pl
 		ssrResult: result
 	})).trim();
 	metrics?.record("react", Math.round(performance.now() - reactStart));
-	if (result.redirect !== void 0) return { result };
+	if (result.redirect !== void 0) return {
+		result,
+		cacheable: prep.cacheable
+	};
 	const templateStart = metrics ? performance.now() : 0;
 	const body = renderFn({
 		...prep.templateParams,
@@ -21,7 +24,8 @@ var buildBody = async (req, config, spaceId, environment, revision, renderFn, pl
 	metrics?.record("template", Math.round(performance.now() - templateStart));
 	return {
 		body,
-		result
+		result,
+		cacheable: prep.cacheable
 	};
 };
 //#endregion

package/dist/modules/ssr/handler.js

@@ -57,13 +57,13 @@ var renderSSR = async (req, res, config, renderFn, pluginManager, caches) => {
 		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, offlineDataOverride);
+	const { body, result, cacheable } = 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}`);
 	}
 	if (applySSRResult(res, result)) return;
-	if (htmlCache && cacheKey && body !== void 0) htmlCache.set(cacheKey, body);
+	if (htmlCache && cacheKey && body !== void 0 && cacheable) htmlCache.set(cacheKey, body);
 	res.send(body ?? "");
 };
 //#endregion

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

@@ -9,5 +9,7 @@ export type RenderPrep = {
     templateParams: SSRTemplateProps & {
         offlineData: string;
     };
+    /** False for a render that must not be served to anybody else from a cache: it carries this request's own runs. */
+    cacheable: boolean;
 };
 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>;

package/dist/modules/ssr/prepareRender.js

@@ -1,3 +1,4 @@
+import { authorizesDebugging } from "../../helpers/debugAuthorization.js";
 import { matchRscPage } from "../rsc/matchRscPage.js";
 import { readCookie } from "../../helpers/readCookie.js";
 import { buildOfflineDataCacheKey } from "../../helpers/cache/keys.js";
@@ -64,8 +65,16 @@ var prepareRender = async (req, config, spaceId, environment, revision, pluginMa
 	* so does the space itself (`settings.devTools`) — an owner inspecting their own published site. The space is read
 	* from what this server loaded, never from the request, so a visitor has no say in it.
 	*/
-	const debugAuthorized = !Boolean(req.query["__pt"]) && (config.debugMode ?? (config.devMode === true || schema?.settings.devTools === true));
+	const debugAuthorized = !Boolean(req.query["__pt"]) && authorizesDebugging(config, schema?.settings);
 	const debugRendered = resolveDebugMode(debugAuthorized, readCookie(req.headers.cookie, debugCookieName(req.headers.host)));
+	/**
+	* The runs this render's server elements started, handed to a page that may debug them — and to no other.
+	*
+	* Same authorization as the panel itself: a page nobody authorized is told nothing about the flows behind it, not
+	* even that they ran. A render carrying them is also one nobody else may be served from a cache: those runs are
+	* this request's.
+	*/
+	const actionRuns = debugAuthorized && req.ctx.actionRuns?.length ? req.ctx.actionRuns : void 0;
 	const { degrade, analytics } = req.ctx.meter ?? {};
 	const clientAnalytics = analytics ? {
 		...analytics,
@@ -98,7 +107,8 @@ var prepareRender = async (req, config, spaceId, environment, revision, pluginMa
 		...theme ? { theme } : {},
 		...clientAnalytics ? { analytics: clientAnalytics } : {},
 		...branding ? { branding } : {},
-		...overQuota ? { overQuota } : {}
+		...overQuota ? { overQuota } : {},
+		...actionRuns ? { actionRuns } : {}
 	}));
 	const pluginNames = req.ctx.spaceDeployment?.pluginNames ?? [];
 	const pluginSources = req.ctx.spaceDeployment?.pluginSources;
@@ -165,7 +175,8 @@ var prepareRender = async (req, config, spaceId, environment, revision, pluginMa
 			debugMode: debugAuthorized,
 			ssrOnly: config.ssrOnly === true,
 			offlineData: offlineDataStr
-		}
+		},
+		cacheable: actionRuns === void 0
 	};
 };
 //#endregion

package/dist/modules/ssr/streamBody.js

@@ -19,7 +19,7 @@ var streamBody = async (req, res, config, spaceId, environment, revision, render
 	const tail = sentinelIdx >= 0 ? fullTemplate.slice(sentinelIdx + 18) : "";
 	const result = {};
 	await new Promise((resolve, reject) => {
-		const chunks = cacheKey && htmlCache ? [] : null;
+		const chunks = cacheKey && htmlCache && prep.cacheable ? [] : null;
 		const writable = new Writable({
 			write(chunk, _enc, cb) {
 				chunks?.push(chunk);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@plitzi/sdk-server",
-  "version": "0.35.8",
+  "version": "0.35.9",
   "license": "AGPL-3.0",
   "files": [
     "dist",
@@ -58,8 +58,8 @@
   "type": "module",
   "sideEffects": false,
   "dependencies": {
-    "@plitzi/plitzi-sdk": "0.35.8",
-    "@plitzi/sdk-shared": "0.35.8",
+    "@plitzi/plitzi-sdk": "0.35.9",
+    "@plitzi/sdk-shared": "0.35.9",
     "ejs": "^6.0.1",
     "esbuild": "^0.28.2",
     "jsonwebtoken": "^9.0.3",