@plitzi/sdk-shared 0.37.8 → 0.37.10

package/dist/actions/functions.d.ts

@@ -1,8 +1,17 @@
 /**
- * Where a space's functions answer HTTP: `GET /feed/:id` declared, `GET /api/feed/42` served. The path is
- * the functions' and never a page's — the page server and the page linter both read it from here.
+ * Where a space's functions answer HTTP: `GET /feed/:id` declared, `GET /fn/feed/42` served. The path is the functions'
+ * and never a page's — the page server and the page linter both read it from here. `/fn`, not `/api`: a space's pages
+ * are its own to name, and `api` is a slug a site wants for a page about its API.
  */
-export declare const FUNCTION_ROUTES_PREFIX = "/api";
+export declare const FUNCTION_ROUTES_PREFIX = "/fn";
+/**
+ * The CPU and time an invocation gets when its task asks for none: what the server runs it with, and what the builder
+ * shows as "default". A task asks for more in its `limits`, up to what its deployment allows.
+ */
+export declare const DEFAULT_FUNCTION_TIME_LIMITS: {
+    readonly cpuMs: 100;
+    readonly wallMs: 10000;
+};
 /** Whether a page at `path` would sit where the space's functions answer. */
 export declare const isFunctionRoutePath: (path: string) => boolean;
 /**

package/dist/actions/functions.mjs

@@ -1,6 +1,9 @@
 //#region src/actions/functions.ts
-var e = "/api", t = (e) => e === "/api" || e.startsWith("/api/"), n = (e) => /^[A-Za-z0-9_][A-Za-z0-9_./-]*\.(ts|js|mjs|json)$/.test(e) && !e.split("/").some((e) => e === ".." || e === "." || e === ""), r = async (e, t) => {
-	let r = {}, i = async (a) => {
+var e = "/fn", t = {
+	cpuMs: 100,
+	wallMs: 1e4
+}, n = (e) => e === "/fn" || e.startsWith("/fn/"), r = (e) => /^[A-Za-z0-9_][A-Za-z0-9_./-]*\.(ts|js|mjs|json)$/.test(e) && !e.split("/").some((e) => e === ".." || e === "." || e === ""), i = async (e, t) => {
+	let n = {}, i = async (a) => {
 		let o;
 		try {
 			o = await t.list(a ? `${e}/${a}` : e);
@@ -9,10 +12,10 @@ var e = "/api", t = (e) => e === "/api" || e.startsWith("/api/"), n = (e) => /^[
 		}
 		for (let s of o) {
 			let o = a ? `${a}/${s.name}` : s.name;
-			s.directory ? s.name !== "node_modules" && !s.name.startsWith(".") && await i(o) : n(o) && (r[o] = await t.read(`${e}/${o}`));
+			s.directory ? s.name !== "node_modules" && !s.name.startsWith(".") && await i(o) : r(o) && (n[o] = await t.read(`${e}/${o}`));
 		}
 	};
-	return await i(""), r;
+	return await i(""), n;
 };
 //#endregion
-export { e as FUNCTION_ROUTES_PREFIX, t as isFunctionRoutePath, n as isFunctionsSourcePath, r as readFunctionsSource };
+export { t as DEFAULT_FUNCTION_TIME_LIMITS, e as FUNCTION_ROUTES_PREFIX, n as isFunctionRoutePath, r as isFunctionsSourcePath, i as readFunctionsSource };

package/dist/actions/index.d.ts

@@ -1,10 +1,10 @@
 export { accessRefusal } from './access';
 export { cronFiresBetween, cronMatches, cronNextFire, isKnownTimeZone, parseCron, zonedClock } from './cron';
 export { FAILURE_HANDLER_TASK } from './failureHandler';
-export { FUNCTION_ROUTES_PREFIX, isFunctionRoutePath, isFunctionsSourcePath, readFunctionsSource } from './functions';
+export { DEFAULT_FUNCTION_TIME_LIMITS, FUNCTION_ROUTES_PREFIX, isFunctionRoutePath, isFunctionsSourcePath, readFunctionsSource } from './functions';
 export { triggerAccess, triggerCacheMs, triggerHasStaleVerify, triggerInput, triggerVerify } from './triggerParams';
 export { actionName, actionTriggers, isActionEnabled } from './triggers';
-export { validateActionDocument } from './validateDocument';
+export { isActionDocument, validateActionDocument } from './validateDocument';
 export { isSingleEmailAddress, readSmtpCredential, SMTP_CREDENTIAL_KEYS } from './smtp';
 export type { AccessCaller } from './access';
 export type { FunctionsSourceReader } from './functions';

package/dist/actions/index.mjs

@@ -1,9 +1,9 @@
 import { accessRefusal as e } from "./access.mjs";
 import { cronFiresBetween as t, cronMatches as n, cronNextFire as r, isKnownTimeZone as i, parseCron as a, zonedClock as o } from "./cron.mjs";
 import { FAILURE_HANDLER_TASK as s } from "./failureHandler.mjs";
-import { FUNCTION_ROUTES_PREFIX as c, isFunctionRoutePath as l, isFunctionsSourcePath as u, readFunctionsSource as d } from "./functions.mjs";
-import { triggerAccess as f, triggerCacheMs as p, triggerHasStaleVerify as m, triggerInput as h, triggerVerify as g } from "./triggerParams.mjs";
-import { actionName as _, actionTriggers as v, isActionEnabled as y } from "./triggers.mjs";
-import { validateActionDocument as b } from "./validateDocument.mjs";
-import { SMTP_CREDENTIAL_KEYS as x, isSingleEmailAddress as S, readSmtpCredential as C } from "./smtp.mjs";
-export { s as FAILURE_HANDLER_TASK, c as FUNCTION_ROUTES_PREFIX, x as SMTP_CREDENTIAL_KEYS, e as accessRefusal, _ as actionName, v as actionTriggers, t as cronFiresBetween, n as cronMatches, r as cronNextFire, y as isActionEnabled, l as isFunctionRoutePath, u as isFunctionsSourcePath, i as isKnownTimeZone, S as isSingleEmailAddress, a as parseCron, d as readFunctionsSource, C as readSmtpCredential, f as triggerAccess, p as triggerCacheMs, m as triggerHasStaleVerify, h as triggerInput, g as triggerVerify, b as validateActionDocument, o as zonedClock };
+import { DEFAULT_FUNCTION_TIME_LIMITS as c, FUNCTION_ROUTES_PREFIX as l, isFunctionRoutePath as u, isFunctionsSourcePath as d, readFunctionsSource as f } from "./functions.mjs";
+import { triggerAccess as p, triggerCacheMs as m, triggerHasStaleVerify as h, triggerInput as g, triggerVerify as _ } from "./triggerParams.mjs";
+import { actionName as v, actionTriggers as y, isActionEnabled as b } from "./triggers.mjs";
+import { isActionDocument as x, validateActionDocument as S } from "./validateDocument.mjs";
+import { SMTP_CREDENTIAL_KEYS as C, isSingleEmailAddress as w, readSmtpCredential as T } from "./smtp.mjs";
+export { c as DEFAULT_FUNCTION_TIME_LIMITS, s as FAILURE_HANDLER_TASK, l as FUNCTION_ROUTES_PREFIX, C as SMTP_CREDENTIAL_KEYS, e as accessRefusal, v as actionName, y as actionTriggers, t as cronFiresBetween, n as cronMatches, r as cronNextFire, x as isActionDocument, b as isActionEnabled, u as isFunctionRoutePath, d as isFunctionsSourcePath, i as isKnownTimeZone, w as isSingleEmailAddress, a as parseCron, f as readFunctionsSource, T as readSmtpCredential, p as triggerAccess, m as triggerCacheMs, h as triggerHasStaleVerify, g as triggerInput, _ as triggerVerify, S as validateActionDocument, o as zonedClock };

package/dist/actions/triggerParams.mjs

@@ -1,11 +1,12 @@
+import { isRecord as e } from "../helpers/isRecord.mjs";
 //#region src/actions/triggerParams.ts
-var e = (e) => {
+var t = (e) => {
 	if (typeof e == "string" && e.trim() !== "") try {
 		return JSON.parse(e);
 	} catch {
 		return;
 	}
-}, t = (e) => typeof e == "object" && !!e && !Array.isArray(e), n = (e) => {
+}, n = (e) => {
 	let { access: t } = e;
 	if (t === "public" || t === "session") return { mode: t };
 	if (t === "role") return {
@@ -13,8 +14,8 @@ var e = (e) => {
 		permissions: (e.permissions ?? "").split(",").map((e) => e.trim()).filter(Boolean)
 	};
 }, r = (n) => {
-	let r = e(n.input);
-	return t(r) ? r : {};
+	let r = t(n.input);
+	return e(r) ? r : {};
 }, i = (e) => {
 	let t = e.signatureCredential?.trim();
 	if (!t) return;
@@ -30,8 +31,8 @@ var e = (e) => {
 	};
 }, a = (n) => {
 	if (n.signatureCredential?.trim()) return !1;
-	let r = e(n.verify);
-	return t(r) && typeof r.credential == "string" && r.credential.trim() !== "";
+	let r = t(n.verify);
+	return e(r) && typeof r.credential == "string" && r.credential.trim() !== "";
 }, o = (e) => {
 	let t = Number.parseFloat(e.cacheSeconds ?? "");
 	return Number.isFinite(t) && t > 0 ? Math.round(t * 1e3) : 0;

package/dist/actions/validateDocument.d.ts

@@ -1,3 +1,4 @@
+import { ActionDocument } from '../types';
 /**
  * The one server-action validator.
  *
@@ -21,3 +22,5 @@ export type ActionDocumentReport = {
     warnings: ActionDocumentIssue[];
 };
 export declare const validateActionDocument: (document: unknown) => ActionDocumentReport;
+/** Whether a value read from outside — a deployment's store, a request — is an action document a server can run. */
+export declare const isActionDocument: (document: unknown) => document is ActionDocument;

package/dist/actions/validateDocument.mjs

@@ -1,25 +1,26 @@
 import { isKnownTimeZone as e, parseCron as t } from "./cron.mjs";
 import { FAILURE_HANDLER_TASK as n } from "./failureHandler.mjs";
-import { triggerAccess as r, triggerHasStaleVerify as i, triggerVerify as a } from "./triggerParams.mjs";
+import { isRecord as r } from "../helpers/isRecord.mjs";
+import { triggerAccess as i, triggerHasStaleVerify as a, triggerVerify as o } from "./triggerParams.mjs";
 //#region src/actions/validateDocument.ts
-var o = [
+var s = [
 	"text",
 	"number",
 	"boolean",
 	"date",
 	"json",
 	"file"
-], s = [
+], c = [
 	"public",
 	"session",
 	"role"
-], c = [
+], l = [
 	"call",
 	"webhook",
 	"schedule",
 	"render",
 	"custom"
-], l = ["sha256", "sha1"], u = /* @__PURE__ */ new Set([
+], u = ["sha256", "sha1"], d = /* @__PURE__ */ new Set([
 	"input",
 	"user",
 	"spaceId",
@@ -28,208 +29,208 @@ var o = [
 	"runId",
 	"now",
 	"failure"
-]), d = /^[a-z][a-zA-Z0-9]*\.[a-z][a-zA-Z0-9]*$/, f = (e) => typeof e == "object" && !!e && !Array.isArray(e), p = (e) => typeof e == "string" && e.trim() !== "", m = (e) => {
+]), f = /^[a-z][a-zA-Z0-9]*\.[a-z][a-zA-Z0-9]*$/, p = (e) => typeof e == "string" && e.trim() !== "", m = (e) => {
 	try {
 		let t = JSON.parse(e);
-		return f(t) ? t : void 0;
+		return r(t) ? t : void 0;
 	} catch {
 		return;
 	}
 }, h = (e, t, n) => {
 	if (e !== void 0) {
-		if (!f(e)) {
+		if (!r(e)) {
 			n.push({
 				path: t,
 				message: "must be an object of field definitions"
 			});
 			return;
 		}
-		Object.entries(e).forEach(([e, r]) => {
-			if (!f(r) || !p(r.type)) {
+		Object.entries(e).forEach(([e, i]) => {
+			if (!r(i) || !p(i.type)) {
 				n.push({
 					path: `${t}.${e}`,
 					message: "must declare a type"
 				});
 				return;
 			}
-			o.includes(r.type) || n.push({
+			s.includes(i.type) || n.push({
 				path: `${t}.${e}.type`,
-				message: `unknown field type "${r.type}"`,
-				hint: `one of ${o.join(", ")}`
+				message: `unknown field type "${i.type}"`,
+				hint: `one of ${s.join(", ")}`
 			});
 		});
 	}
-}, g = (n, o, u, d) => {
-	let g = `nodes.${n}`, _ = o.action;
-	if (!p(_) || !c.includes(_)) {
-		u.push({
+}, g = (n, s, d, f) => {
+	let g = `nodes.${n}`, _ = s.action;
+	if (!p(_) || !l.includes(_)) {
+		d.push({
 			path: `${g}.action`,
 			message: `"${String(_)}" is not a way an action can be started`,
-			hint: `one of ${c.join(", ")}`
+			hint: `one of ${l.join(", ")}`
 		});
 		return;
 	}
-	let v = f(o.params) ? o.params : {};
+	let v = r(s.params) ? s.params : {};
 	if (p(v.input)) {
 		let e = m(v.input);
-		e === void 0 ? u.push({
+		e === void 0 ? d.push({
 			path: `${g}.params.input`,
 			message: "is not valid JSON"
-		}) : h(e, `${g}.params.input`, u);
+		}) : h(e, `${g}.params.input`, d);
 	}
 	if (_ !== "schedule") {
-		if (!p(v.access) || !s.includes(v.access)) u.push({
+		if (!p(v.access) || !c.includes(v.access)) d.push({
 			path: `${g}.params.access`,
 			message: "must say who may start a run this way",
-			hint: `one of ${s.join(", ")}`
+			hint: `one of ${c.join(", ")}`
 		});
 		else if (v.access === "role") {
-			let e = r(v);
-			e?.mode === "role" && e.permissions.length === 0 && u.push({
+			let e = i(v);
+			e?.mode === "role" && e.permissions.length === 0 && d.push({
 				path: `${g}.params.permissions`,
 				message: "role access must name at least one permission"
 			});
 		}
 	}
-	if (_ === "schedule" && (p(v.cron) ? t(v.cron) || u.push({
+	if (_ === "schedule" && (p(v.cron) ? t(v.cron) || d.push({
 		path: `${g}.params.cron`,
 		message: `"${v.cron}" is not an expression this server can read, so it would never fire`,
 		hint: "five fields — minute hour day-of-month month day-of-week — with *, lists, ranges and steps"
-	}) : u.push({
+	}) : d.push({
 		path: `${g}.params.cron`,
 		message: "a scheduled trigger needs a cron expression"
-	}), p(v.timezone) && !e(v.timezone) && u.push({
+	}), p(v.timezone) && !e(v.timezone) && d.push({
 		path: `${g}.params.timezone`,
 		message: `"${v.timezone}" is not a time zone this server knows, so the schedule would never fire`,
 		hint: "an IANA name like America/Santiago or Europe/Madrid — leave it empty for UTC"
 	})), p(v.cacheSeconds)) {
 		let e = Number.parseFloat(v.cacheSeconds);
-		!Number.isFinite(e) || e < 0 ? u.push({
+		!Number.isFinite(e) || e < 0 ? d.push({
 			path: `${g}.params.cacheSeconds`,
 			message: "must be a number of seconds, or left empty"
-		}) : _ !== "render" && d.push({
+		}) : _ !== "render" && f.push({
 			path: `${g}.params.cacheSeconds`,
 			message: `a "${_}" trigger is never answered from a cache`,
 			hint: "reuse only applies to a render, where the same page is built for one visitor after another"
 		});
 	}
-	_ === "custom" && !p(v.name) && u.push({
+	_ === "custom" && !p(v.name) && d.push({
 		path: `${g}.params.name`,
 		message: "a custom trigger needs a name to be mounted under"
-	}), _ === "webhook" && (i(v) && u.push({
+	}), _ === "webhook" && (a(v) && d.push({
 		path: `${g}.params.signatureCredential`,
 		message: "this signature check is in a format nothing reads any more, so the webhook is unverified",
 		hint: "name the credential holding the signing secret in \"Signing secret\", and its header beside it"
-	}), a(v) || d.push({
+	}), o(v) || f.push({
 		path: `${g}.params.signatureCredential`,
 		message: "this webhook accepts unsigned requests",
 		hint: "name the credential holding the signing secret, and only the sender you expect can start a run"
-	}), p(v.signatureAlgorithm) && !l.includes(v.signatureAlgorithm) && d.push({
+	}), p(v.signatureAlgorithm) && !u.includes(v.signatureAlgorithm) && f.push({
 		path: `${g}.params.signatureAlgorithm`,
 		message: `"${v.signatureAlgorithm}" is not an algorithm this server signs with, so sha256 is used`,
-		hint: `one of ${l.join(", ")}`
-	}), p(v.signatureToleranceSeconds) && !p(v.signatureTimestampHeader) && d.push({
+		hint: `one of ${u.join(", ")}`
+	}), p(v.signatureToleranceSeconds) && !p(v.signatureTimestampHeader) && f.push({
 		path: `${g}.params.signatureToleranceSeconds`,
 		message: "a tolerance with no timestamp header expires nothing",
 		hint: "name the header the sender puts the signing time in, or drop the tolerance"
-	})), _ === "call" && v.access === "public" && d.push({
+	})), _ === "call" && v.access === "public" && f.push({
 		path: `${g}.params.access`,
 		message: "anyone can run this action, including signed-out visitors",
 		hint: "use session access unless the page needs it before anyone signs in"
 	});
-}, _ = (e, t, r, i) => {
-	if (!f(e)) {
-		r.push({
+}, _ = (e, t, i, a) => {
+	if (!r(e)) {
+		i.push({
 			path: "nodes",
 			message: "must be an object of steps"
 		});
 		return;
 	}
-	let a = Object.entries(e), o = a.filter(([, e]) => f(e) && e.type === "trigger");
-	o.length === 0 && r.push({
+	let o = Object.entries(e), s = o.filter(([, e]) => r(e) && e.type === "trigger");
+	s.length === 0 && i.push({
 		path: "nodes",
 		message: "this action has no way in",
 		hint: "add a trigger step — call, webhook, schedule, render or custom"
 	});
-	let s = /* @__PURE__ */ new Map();
-	o.forEach(([e, t]) => {
-		p(t.action) && s.set(t.action, [...s.get(t.action) ?? [], e]);
-	}), s.forEach((e, t) => {
-		e.length > 1 && r.push({
+	let c = /* @__PURE__ */ new Map();
+	s.forEach(([e, t]) => {
+		p(t.action) && c.set(t.action, [...c.get(t.action) ?? [], e]);
+	}), c.forEach((e, t) => {
+		e.length > 1 && i.push({
 			path: `nodes.${e[1]}`,
 			message: `this action has ${e.length} "${t}" triggers`,
 			hint: "one step per way in — a second flow starts from a different kind of trigger"
 		});
-	}), a.forEach(([t, n]) => {
-		let a = `nodes.${t}`;
-		if (!f(n)) {
-			r.push({
-				path: a,
+	}), o.forEach(([t, n]) => {
+		let o = `nodes.${t}`;
+		if (!r(n)) {
+			i.push({
+				path: o,
 				message: "must be an object"
 			});
 			return;
 		}
 		if (n.type === "trigger") {
-			g(t, n, r, i);
+			g(t, n, i, a);
 			return;
 		}
 		if (n.type !== "task") {
-			r.push({
-				path: `${a}.type`,
+			i.push({
+				path: `${o}.type`,
 				message: `"${String(n.type)}" steps run in the browser and cannot run on the server`,
 				hint: "a server action is made of task steps"
 			});
 			return;
 		}
-		if (!p(n.action) || !d.test(n.action)) {
-			r.push({
-				path: `${a}.action`,
+		if (!p(n.action) || !f.test(n.action)) {
+			i.push({
+				path: `${o}.action`,
 				message: "must name a task as <namespace>.<action>",
 				hint: "for example flow.output or http.request"
 			});
 			return;
 		}
-		p(n.afterNode) && !Object.hasOwn(e, n.afterNode) && r.push({
-			path: `${a}.afterNode`,
+		p(n.afterNode) && !Object.hasOwn(e, n.afterNode) && i.push({
+			path: `${o}.afterNode`,
 			message: `points at "${n.afterNode}", which is not a step here`
 		});
-	}), a.forEach(([e]) => {
-		u.has(e) && r.push({
+	}), o.forEach(([e]) => {
+		d.has(e) && i.push({
 			path: `nodes.${e}`,
 			message: `"${e}" is what the run itself publishes in the flow scope, so a step may not take the name`,
 			hint: `rename the step — every later step reads {{ ${e} }} expecting the run's own value`
 		});
 	});
-	let c = /* @__PURE__ */ new Set(), l = /* @__PURE__ */ new Set(), m = [];
-	o.forEach(([t]) => {
+	let l = /* @__PURE__ */ new Set(), u = /* @__PURE__ */ new Set(), m = [];
+	s.forEach(([t]) => {
 		let n = /* @__PURE__ */ new Set(), r = [], i = t;
 		for (; i;) {
 			if (n.has(i)) {
-				l.add(i);
+				u.add(i);
 				break;
 			}
-			n.add(i), r.push(i), c.add(i);
+			n.add(i), r.push(i), l.add(i);
 			let t = e[i];
 			i = p(t?.afterNode) ? t.afterNode : "";
 		}
 		m.push(r);
-	}), l.forEach((e) => {
-		r.push({
+	}), u.forEach((e) => {
+		i.push({
 			path: `nodes.${e}`,
 			message: "this step is reached again by its own chain, so the flow never ends",
 			hint: "break the `afterNode` chain that comes back to it"
 		});
-	}), a.forEach(([e]) => {
-		c.has(e) || i.push({
+	}), o.forEach(([e]) => {
+		l.has(e) || a.push({
 			path: `nodes.${e}`,
 			message: "no trigger reaches this step, so it never runs",
 			hint: "chain it with `afterNode` from a trigger, or delete it"
 		});
 	});
-	let h = (t) => e[t]?.action, _ = a.filter(([, e]) => f(e) && e.action === "flow.output");
+	let h = (t) => e[t]?.action, _ = o.filter(([, e]) => r(e) && e.action === "flow.output");
 	for (let [t, n] of _) {
 		let r = p(n.afterNode) && h(n.afterNode) === "flow.onFailure";
-		p(n.afterNode) && Object.hasOwn(e, n.afterNode) && !r && i.push({
+		p(n.afterNode) && Object.hasOwn(e, n.afterNode) && !r && a.push({
 			path: `nodes.${t}.afterNode`,
 			message: "the output step is not the last one, so the steps after it run for nothing",
 			hint: "move flow.output to the end of the flow"
@@ -241,37 +242,37 @@ var o = [
 	m.forEach((e) => {
 		let t = e.findIndex((e) => h(e) === n);
 		if (t === -1) return;
-		let a = e[t];
-		t === 1 && y(i, {
-			path: `nodes.${a}`,
+		let r = e[t];
+		t === 1 && y(a, {
+			path: `nodes.${r}`,
 			message: "nothing runs before this step, so nothing can fail and the steps after it never run",
 			hint: "put On Failure after the steps whose work it undoes"
-		}), t === e.length - 1 && y(i, {
-			path: `nodes.${a}`,
+		}), t === e.length - 1 && y(a, {
+			path: `nodes.${r}`,
 			message: "nothing follows this step, so a failed run undoes nothing",
 			hint: "add the steps that give back what the flow already did"
 		}), e.slice(t + 1).forEach((e) => {
-			h(e) === "flow.onFailure" && y(r, {
+			h(e) === "flow.onFailure" && y(i, {
 				path: `nodes.${e}`,
 				message: "a flow has one place its undo begins, and this is a second one",
 				hint: "keep one On Failure step and put every undo step after it"
-			}), h(e) === "flow.output" && y(r, {
+			}), h(e) === "flow.output" && y(i, {
 				path: `nodes.${e}`,
 				message: "an output step after On Failure answers a run that has already failed",
 				hint: "move flow.output before On Failure"
 			});
 		});
-	}), _.length === 0 && f(t) && Object.keys(t).length > 0 && i.push({
+	}), _.length === 0 && r(t) && Object.keys(t).length > 0 && a.push({
 		path: "nodes",
 		message: "this action is expected to answer values but no step names any",
 		hint: "add a flow.output step at the end naming what the caller should get"
 	});
 }, v = /\{\{\s*credential\./, y = (e, t) => {
 	Object.entries(e).forEach(([e, n]) => {
-		if (!f(n) || !f(n.params)) return;
-		let r = p(n.params.credential) ? n.params.credential : "";
-		Object.entries(n.params).forEach(([n, i]) => {
-			typeof i == "string" && v.test(i) && r === "" && t.push({
+		if (!r(n) || !r(n.params)) return;
+		let i = p(n.params.credential) ? n.params.credential : "";
+		Object.entries(n.params).forEach(([n, r]) => {
+			typeof r == "string" && v.test(r) && i === "" && t.push({
 				path: `nodes.${e}.params.${n}`,
 				message: "this step reads a credential it did not ask for, so the token resolves to nothing",
 				hint: "set the step’s `credential` to the identifier it should use"
@@ -280,10 +281,10 @@ var o = [
 	});
 }, b = (e) => {
 	let t = [], n = [];
-	return f(e) ? (p(e.name) || t.push({
+	return r(e) ? (p(e.name) || t.push({
 		path: "name",
 		message: "must have a name"
-	}), h(e.output, "output", t), _(e.nodes, e.output, t, n), y(f(e.nodes) ? e.nodes : {}, n), {
+	}), h(e.output, "output", t), _(e.nodes, e.output, t, n), y(r(e.nodes) ? e.nodes : {}, n), {
 		valid: t.length === 0,
 		errors: t,
 		warnings: n
@@ -295,6 +296,6 @@ var o = [
 		}],
 		warnings: n
 	};
-};
+}, x = (e) => b(e).valid;
 //#endregion
-export { b as validateActionDocument };
+export { x as isActionDocument, b as validateActionDocument };

package/dist/auth/failureChannel.d.ts

@@ -4,13 +4,19 @@ export type AuthFailureSignal = {
     /** The request that was refused. Auth listens only to refusals from its own backend — see `sameRegistrableDomain`. */
     url?: string;
 };
-export type AuthFailureListener = (signal: AuthFailureSignal) => void;
+/** Hears a refusal, and answers whether it renewed the session because of it — or nothing, for a listener that did not. */
+export type AuthFailureListener = (signal: AuthFailureSignal) => Promise<boolean> | boolean | undefined;
 /**
  * Says that a backend refused a credential. A session can end between two checks — revoked from another device, an
  * account deactivated — and the first thing that notices is whatever request got refused, not a timer. Reporting it
  * here is how the network layers tell auth that reality moved on, without either knowing about the other.
+ *
+ * Answers whether the session was renewed because of it: a refusal that only meant "this credential expired" — a tab
+ * coming back after its token's life — is answered by a renewal, and the request that was refused can be asked again,
+ * once, instead of leaving its section in an error a reload would have cleared. A refused request never ran, so asking
+ * it again repeats nothing.
  */
-export declare const reportAuthFailure: (signal: AuthFailureSignal) => void;
+export declare const reportAuthFailure: (signal: AuthFailureSignal) => Promise<boolean>;
 export declare const onAuthFailure: (listener: AuthFailureListener) => (() => void);
 /**
  * What an HTTP refusal means for the session. Stated once, because the provider and the network layers must not

package/dist/auth/failureChannel.mjs

@@ -1,7 +1,5 @@
 //#region src/auth/failureChannel.ts
-var e = /* @__PURE__ */ new Set(), t = (t) => {
-	for (let n of e) n(t);
-}, n = (t) => (e.add(t), () => e.delete(t)), r = [
+var e = /* @__PURE__ */ new Set(), t = async (t) => (await Promise.all([...e].map(async (e) => e(t)))).some((e) => e === !0), n = (t) => (e.add(t), () => e.delete(t)), r = [
 	"missing",
 	"expired",
 	"revoked",

package/dist/authoring/elementCallbacks.d.ts

@@ -1,5 +1,70 @@
 import { BuiltinActionSpec } from './builder';
+import { BuiltinParam } from './paramSpec';
 export type BuiltinElementCallback = BuiltinActionSpec;
+/**
+ * Moving what an element shows, on the element whose box scrolls (`overflow: auto` on a row of cards, a panel) — or,
+ * with `scrollIntoView`, the page to an element. Arrows over a carousel that still swipes on a phone, a "back to the
+ * top", a jump to the answer a form just showed. Its node names the element that moves; nothing happens where there is
+ * no page to move (a server render).
+ */
+export declare const SCROLL_CALLBACKS: {
+    scrollBy: {
+        title: string;
+        type: "callback";
+        strictParams: true;
+        params: {
+            x: {
+                type: "text";
+                description: string;
+                default: string;
+            };
+            y: {
+                type: "text";
+                description: string;
+                default: string;
+            };
+            behavior: BuiltinParam;
+        };
+    };
+    scrollTo: {
+        title: string;
+        type: "callback";
+        strictParams: true;
+        params: {
+            x: {
+                type: "text";
+                description: string;
+                default: string;
+            };
+            y: {
+                type: "text";
+                description: string;
+                default: string;
+            };
+            behavior: BuiltinParam;
+        };
+    };
+    scrollIntoView: {
+        title: string;
+        type: "callback";
+        strictParams: true;
+        params: {
+            block: {
+                type: "select";
+                description: string;
+                default: string;
+                options: ("start" | "center" | "end" | "nearest")[];
+            };
+            inline: {
+                type: "select";
+                description: string;
+                default: string;
+                options: ("start" | "center" | "end" | "nearest")[];
+            };
+            behavior: BuiltinParam;
+        };
+    };
+};
 export declare const BUILTIN_ELEMENT_CALLBACKS: Record<string, BuiltinElementCallback>;
 /** The built-in element callback for an action, or undefined when the action is not a known built-in (an
  *  element-type-specific/plugin callback whose schema is not knowable here). */