@plitzi/sdk-shared 0.35.7 → 0.35.9

package/CHANGELOG.md

@@ -1,5 +1,42 @@
 # @plitzi/sdk-shared
 
+## 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.
+
+## 0.35.8
+
+### Patch Changes
+
+- A space can switch the dev tools on for its own published site.
+
+  - **`settings.devTools`** in the space schema, set from the builder's Settings panel ("Dev tools on the published SSR
+    site (*.plitzi.app)"). It applies to sites served with SSR — usually a space's `*.plitzi.app` address, or a custom
+    domain pointed at it. A page server that left `debugMode` unset now authorizes debugging for a space that asked for it, as it
+    already did in `devMode`. A server that sets `debugMode` still decides for every space, and `false` cannot be
+    turned around by a space. Preview renders stay undebuggable either way.
+  - The space is read from the schema the server loaded, never from the request, and the visitor's cookie can still
+    only hide the panel.
+  - **The HTML cache keys whether a visitor hid the dev tools.** A cached page on a published environment used to be
+    keyed on the theme alone, so on a page authorizing dev tools the first visitor's choice — panel or no panel — was
+    served to everybody after them.
+
 ## 0.35.7
 
 ### Patch Changes

package/dist/server/rsc/refreshRsc.mjs

@@ -1,34 +1,35 @@
 import { authFailureFromResponse as e, reportAuthFailure as t } from "../../auth/failureChannel.mjs";
 import { hasServerElements as n } from "../../schema/serverElements.mjs";
-import { getPaths as r, matchRoutePath as i } from "../../navigation/routes.mjs";
+import { recordRenderActionRuns as r } from "../../store/actionRuns/actionRunsRecorder.mjs";
+import { getPaths as i, matchRoutePath as a } from "../../navigation/routes.mjs";
 //#region src/server/rsc/refreshRsc.ts
-var a = (e, t, n) => {
+var o = (e, t, n) => {
 	if (!e) return;
-	let a = e.pages.reduce((t, n) => (n in e.flat && (t[n] = e.flat[n]), t), {});
-	return i(r(a, e.pageFolders, n), t.split("?")[0], n).pageId;
-}, o = (e) => `rsc.data.${e}`, s = () => typeof window > "u" ? "" : `${window.location.pathname}${window.location.search}`, c = async (r, i, c, l) => {
-	let { enabled: u, endpoint: d } = r.get("rsc") ?? {};
-	if (!u || !d || typeof window > "u") return;
-	let f = l ?? s(), p = r.get("schema"), m = r.get("runtime.sources.auth"), h = l ? a(p, l, !!m?.details) : r.get("navigation.currentPageId");
-	if (p && n(p, h)) try {
-		let n = new URLSearchParams({ location: f });
-		i?.length && n.set("ids", i.join(",")), Object.entries(c ?? {}).forEach(([e, t]) => n.set(e, t));
-		let a = await fetch(`${d}?${n.toString()}`, { headers: { Accept: "application/json" } });
-		if (!a.ok) {
-			let n = e(a.status, await a.json().catch(() => void 0));
+	let r = e.pages.reduce((t, n) => (n in e.flat && (t[n] = e.flat[n]), t), {});
+	return a(i(r, e.pageFolders, n), t.split("?")[0], n).pageId;
+}, s = (e) => `rsc.data.${e}`, c = () => typeof window > "u" ? "" : `${window.location.pathname}${window.location.search}`, l = async (i, a, l, u) => {
+	let { enabled: d, endpoint: f } = i.get("rsc") ?? {};
+	if (!d || !f || typeof window > "u") return;
+	let p = u ?? c(), m = i.get("schema"), h = i.get("runtime.sources.auth"), g = u ? o(m, u, !!h?.details) : i.get("navigation.currentPageId");
+	if (m && n(m, g)) try {
+		let n = new URLSearchParams({ location: p });
+		a?.length && n.set("ids", a.join(",")), Object.entries(l ?? {}).forEach(([e, t]) => n.set(e, t));
+		let o = await fetch(`${f}?${n.toString()}`, { headers: { Accept: "application/json" } });
+		if (!o.ok) {
+			let n = e(o.status, await o.json().catch(() => void 0));
 			n && t({
 				reason: n,
-				url: d
-			}), r.set("rsc.stale", !0);
+				url: f
+			}), i.set("rsc.stale", !0);
 			return;
 		}
-		let { serverData: s } = await a.json();
-		r.batch(() => {
-			i?.length ? Object.entries(s ?? {}).forEach(([e, t]) => r.set(o(e), t)) : r.set("rsc.data", s ?? {}), r.set("rsc.loaded", !0), r.set("rsc.stale", !1), r.set("rsc.location", f);
+		let { serverData: c, actionRuns: u } = await o.json();
+		u?.length && r(u), i.batch(() => {
+			a?.length ? Object.entries(c ?? {}).forEach(([e, t]) => i.set(s(e), t)) : i.set("rsc.data", c ?? {}), i.set("rsc.loaded", !0), i.set("rsc.stale", !1), i.set("rsc.location", p);
 		});
 	} catch {
-		r.set("rsc.stale", !0);
+		i.set("rsc.stale", !0);
 	}
 };
 //#endregion
-export { s as currentRscLocation, c as default, c as refreshRsc, o as rscDataPath };
+export { c as currentRscLocation, l as default, l as refreshRsc, s as rscDataPath };

package/dist/store/actionRuns/actionRunsRecorder.d.ts

@@ -1,4 +1,4 @@
-import { ActionRunEntry } from '../../types';
+import { ActionRunEntry, ActionRunSummary } from '../../types';
 /** Registered by whatever started the run, for as long as stopping it means anything. */
 export declare const registerActionCanceller: (id: string, cancel: () => void) => void;
 export declare const releaseActionCanceller: (id: string) => void;
@@ -18,6 +18,15 @@ export declare const cancelActionRun: (id: string) => void;
  * A record that only appeared on success would be missing exactly the runs somebody is looking for.
  */
 export declare const recordActionRun: (entry: Omit<ActionRunEntry, "id" | "startedAt" | "status" | "progress">) => string;
+/**
+ * Records the runs the SERVER did while building this page, or while answering a refresh of part of it.
+ *
+ * Nobody here started them, so without this they are the one kind of run a page cannot see at all — an empty
+ * section and no way to learn why. Deduped by the server's own run id, because a section refreshing itself
+ * re-reports a run that was joined or reused rather than started again: the same run twice would leave a person
+ * comparing two entries that are one.
+ */
+export declare const recordRenderActionRuns: (summaries: ActionRunSummary[]) => void;
 /** How it ended, or what it reported on the way. Unknown ids are ignored: a swept-out run is not an error. */
 export declare const updateActionRun: (id: string, patch: Partial<Omit<ActionRunEntry, "id">>) => void;
 /**

package/dist/store/actionRuns/actionRunsRecorder.mjs

@@ -17,23 +17,38 @@ var t = 0, n = (t) => e.setState("runs", t), r = /* @__PURE__ */ new Map(), i =
 		progress: [],
 		cancellable: !0
 	}, ...e.getState().runs].slice(0, 100)), i;
-}, c = (t, r) => {
+}, c = (e) => ({
+	id: `render-${e.runId}`,
+	actionId: e.actionId,
+	mode: "render",
+	runId: e.runId,
+	status: e.status,
+	steps: e.steps,
+	progress: [],
+	startedAt: e.startedAt,
+	endedAt: e.endedAt,
+	...e.error === void 0 ? {} : { error: e.error },
+	...e.elementId === void 0 ? {} : { elementId: e.elementId }
+}), l = (t) => {
+	let { runs: r } = e.getState(), i = new Set(r.map((e) => e.runId)), a = t.filter((e) => !i.has(e.runId)).map(c);
+	a.length !== 0 && n([...a.reverse(), ...r].slice(0, 100));
+}, u = (t, r) => {
 	let { runs: i } = e.getState();
 	i.some((e) => e.id === t) && n(i.map((e) => e.id === t ? {
 		...e,
 		...r
 	} : e));
-}, l = (t, r) => {
+}, d = (t, r) => {
 	let { runs: i } = e.getState();
 	n(i.map((e) => e.id === t ? {
 		...e,
 		progress: [...e.progress, r].slice(-500)
 	} : e));
-}, u = () => {
+}, f = () => {
 	let t = new Set(e.getState().runs.filter((e) => e.cancellable).map((e) => e.id));
 	[...r.keys()].forEach((e) => {
 		t.has(e) || r.delete(e);
 	}), n([]);
 };
 //#endregion
-export { o as cancelActionRun, u as clearActionRuns, l as recordActionProgress, s as recordActionRun, i as registerActionCanceller, a as releaseActionCanceller, c as updateActionRun };
+export { o as cancelActionRun, f as clearActionRuns, d as recordActionProgress, s as recordActionRun, l as recordRenderActionRuns, i as registerActionCanceller, a as releaseActionCanceller, u as updateActionRun };

package/dist/store/actionRuns/index.d.ts

@@ -1,6 +1,6 @@
 import { default as actionRunsStore } from './actionRunsStore';
 import { default as useActionRuns } from './useActionRuns';
 export { MAX_RUNS, createActionRunsState } from './actionRunsStore';
-export { cancelActionRun, clearActionRuns, recordActionProgress, recordActionRun, registerActionCanceller, releaseActionCanceller, updateActionRun } from './actionRunsRecorder';
+export { cancelActionRun, clearActionRuns, recordActionProgress, recordActionRun, recordRenderActionRuns, registerActionCanceller, releaseActionCanceller, updateActionRun } from './actionRunsRecorder';
 export type { UseActionRunsReturn } from './useActionRuns';
 export { actionRunsStore, useActionRuns };

package/dist/store/actionRuns/index.mjs

@@ -1,4 +1,4 @@
 import e, { MAX_RUNS as t, createActionRunsState as n } from "./actionRunsStore.mjs";
-import { cancelActionRun as r, clearActionRuns as i, recordActionProgress as a, recordActionRun as o, registerActionCanceller as s, releaseActionCanceller as c, updateActionRun as l } from "./actionRunsRecorder.mjs";
-import u from "./useActionRuns.mjs";
-export { t as MAX_RUNS, e as actionRunsStore, r as cancelActionRun, i as clearActionRuns, n as createActionRunsState, a as recordActionProgress, o as recordActionRun, s as registerActionCanceller, c as releaseActionCanceller, l as updateActionRun, u as useActionRuns };
+import { cancelActionRun as r, clearActionRuns as i, recordActionProgress as a, recordActionRun as o, recordRenderActionRuns as s, registerActionCanceller as c, releaseActionCanceller as l, updateActionRun as u } from "./actionRunsRecorder.mjs";
+import d from "./useActionRuns.mjs";
+export { t as MAX_RUNS, e as actionRunsStore, r as cancelActionRun, i as clearActionRuns, n as createActionRunsState, a as recordActionProgress, o as recordActionRun, s as recordRenderActionRuns, c as registerActionCanceller, l as releaseActionCanceller, u as updateActionRun, d as useActionRuns };