@plitzi/sdk-shared 0.37.9 → 0.37.10

package/dist/connectors/index.mjs

@@ -1,5 +1,5 @@
 import { BODYLESS_METHODS as e, CONNECTOR_HTTP_METHODS as t, DEFAULT_READ_ENDPOINT as n, EMPTY_RESPONSE_METHODS as r, READ_ENDPOINT_NAMES as i, WRITE_ENDPOINT_NAMES as a } from "./constants.mjs";
 import { connectorTokens as o, getConnectorTokens as s } from "./manifestTokens.mjs";
 import { connectorPresets as c, emptyManifest as l } from "./presets.mjs";
-import { validateConnectorManifest as u } from "./validateManifest.mjs";
-export { e as BODYLESS_METHODS, t as CONNECTOR_HTTP_METHODS, n as DEFAULT_READ_ENDPOINT, r as EMPTY_RESPONSE_METHODS, i as READ_ENDPOINT_NAMES, a as WRITE_ENDPOINT_NAMES, c as connectorPresets, o as connectorTokens, l as emptyManifest, s as getConnectorTokens, u as validateConnectorManifest };
+import { isConnectorManifestDraft as u, validateConnectorManifest as d } from "./validateManifest.mjs";
+export { e as BODYLESS_METHODS, t as CONNECTOR_HTTP_METHODS, n as DEFAULT_READ_ENDPOINT, r as EMPTY_RESPONSE_METHODS, i as READ_ENDPOINT_NAMES, a as WRITE_ENDPOINT_NAMES, c as connectorPresets, o as connectorTokens, l as emptyManifest, s as getConnectorTokens, u as isConnectorManifestDraft, d as validateConnectorManifest };

package/dist/connectors/validateManifest.d.ts

@@ -1,3 +1,4 @@
+import { ConnectorManifestDraft } from '../types';
 /**
  * The one connector-manifest validator.
  *
@@ -26,3 +27,5 @@ export type ConnectorManifestReport = {
  * Give it whatever you have — parsed JSON, an editor's working copy, a GraphQL argument. It never throws.
  */
 export declare const validateConnectorManifest: (input: unknown) => ConnectorManifestReport;
+/** Whether a value read from outside — a deployment's store, a request — is a manifest the engine can run. */
+export declare const isConnectorManifestDraft: (input: unknown) => input is ConnectorManifestDraft;

package/dist/connectors/validateManifest.mjs

@@ -1,11 +1,12 @@
-import { BODYLESS_METHODS as e, CONNECTOR_HTTP_METHODS as t } from "./constants.mjs";
-import { connectorTokens as n } from "./manifestTokens.mjs";
+import { isRecord as e } from "../helpers/isRecord.mjs";
+import { BODYLESS_METHODS as t, CONNECTOR_HTTP_METHODS as n } from "./constants.mjs";
+import { connectorTokens as r } from "./manifestTokens.mjs";
 //#region src/connectors/validateManifest.ts
-var r = [
+var i = [
 	"offset",
 	"page",
 	"cursor"
-], i = [
+], a = [
 	"text",
 	"richText",
 	"image",
@@ -20,7 +21,7 @@ var r = [
 	"color",
 	"option",
 	"file"
-], a = /\{\{\s*([^}]+?)\s*\}\}/g, o = (e) => typeof e == "object" && !!e && !Array.isArray(e), s = (e) => typeof e == "string" && e.trim() !== "", c = (e) => typeof e == "string" ? e : JSON.stringify(e), l = (e) => [...e.matchAll(a)].map((e) => e[1]), u = (e, t) => n.some((n) => n.scopes.includes(t) ? n.value.endsWith(".") ? e.startsWith(n.value) : e === n.value : !1), d = (e, t, n, r) => {
+], o = /\{\{\s*([^}]+?)\s*\}\}/g, s = (e) => typeof e == "string" && e.trim() !== "", c = (e) => typeof e == "string" ? e : JSON.stringify(e), l = (e) => [...e.matchAll(o)].map((e) => e[1]), u = (e, t) => r.some((n) => n.scopes.includes(t) ? n.value.endsWith(".") ? e.startsWith(n.value) : e === n.value : !1), d = (e, t, n, r) => {
 	e.errors.push({
 		path: t,
 		message: n,
@@ -32,35 +33,35 @@ var r = [
 		message: n,
 		...r === void 0 ? {} : { hint: r }
 	});
-}, p = (e, t, n, r) => {
-	if (t !== void 0) {
-		if (!o(t)) {
-			d(e, n, "Must be an object of string values", "Each entry is one name and its templated value");
+}, p = (t, n, r, i) => {
+	if (n !== void 0) {
+		if (!e(n)) {
+			d(t, r, "Must be an object of string values", "Each entry is one name and its templated value");
 			return;
 		}
-		for (let [i, a] of Object.entries(t)) {
+		for (let [e, a] of Object.entries(n)) {
 			if (typeof a != "string") {
-				d(e, `${n}.${i}`, "Must be a string", "Values are Twig templates the server renders per request");
+				d(t, `${r}.${e}`, "Must be a string", "Values are Twig templates the server renders per request");
 				continue;
 			}
-			e.templates.push({
-				path: `${n}.${i}`,
+			t.templates.push({
+				path: `${r}.${e}`,
 				value: a,
-				scope: r
+				scope: i
 			});
 		}
-		return t;
+		return n;
 	}
-}, m = (e, n, r, i) => {
-	if (n === void 0) {
-		i && d(e, r, "A write endpoint must declare its method", `One of ${t.join(", ")}`);
+}, m = (e, t, r, i) => {
+	if (t === void 0) {
+		i && d(e, r, "A write endpoint must declare its method", `One of ${n.join(", ")}`);
 		return;
 	}
-	if (typeof n != "string" || !t.includes(n)) {
-		d(e, r, `"${c(n)}" is not an HTTP method`, `One of ${t.join(", ")}`);
+	if (typeof t != "string" || !n.includes(t)) {
+		d(e, r, `"${c(t)}" is not an HTTP method`, `One of ${n.join(", ")}`);
 		return;
 	}
-	return n;
+	return t;
 }, h = (e, t, n, r) => {
 	if (!s(t.path)) {
 		d(e, `${n}.path`, "An endpoint needs a path", "It is appended to baseUrl, e.g. \"/api/{{resource}}\"");
@@ -73,25 +74,25 @@ var r = [
 	});
 }, g = (e, t, n) => {
 	if (t !== void 0) {
-		if (typeof t != "string" || !r.includes(t)) {
-			d(e, n, `"${c(t)}" is not a paging style`, `One of ${r.join(", ")}`);
+		if (typeof t != "string" || !i.includes(t)) {
+			d(e, n, `"${c(t)}" is not a paging style`, `One of ${i.join(", ")}`);
 			return;
 		}
 		return t;
 	}
-}, _ = (t, n, r, i) => {
-	let a = `endpoints.read.${n}`;
-	if (!o(r)) {
-		d(t, a, "A read endpoint must be an object", "It declares at least a path");
+}, _ = (n, r, i, a) => {
+	let o = `endpoints.read.${r}`;
+	if (!e(i)) {
+		d(n, o, "A read endpoint must be an object", "It declares at least a path");
 		return;
 	}
-	h(t, r, a, "request");
-	let s = m(t, r.method, `${a}.method`, !1) ?? "GET", c = p(t, r.query, `${a}.query`, "request");
-	p(t, r.headers, `${a}.headers`, "request");
-	let l = p(t, r.body, `${a}.body`, "request"), u = g(t, r.pagination, `${a}.pagination`) ?? i;
-	if (l && e.includes(s) && f(t, `${a}.body`, `A ${s} request carries no body, so this one is never sent`, "Move these values into `query`, or read through POST if the provider expects a body"), u === void 0) return;
+	h(n, i, o, "request");
+	let s = m(n, i.method, `${o}.method`, !1) ?? "GET", c = p(n, i.query, `${o}.query`, "request");
+	p(n, i.headers, `${o}.headers`, "request");
+	let l = p(n, i.body, `${o}.body`, "request"), u = g(n, i.pagination, `${o}.pagination`) ?? a;
+	if (l && t.includes(s) && f(n, `${o}.body`, `A ${s} request carries no body, so this one is never sent`, "Move these values into `query`, or read through POST if the provider expects a body"), u === void 0) return;
 	let _ = JSON.stringify({
-		path: r.path,
+		path: i.path,
 		query: c ?? {},
 		body: l ?? {}
 	}), v = {
@@ -99,70 +100,70 @@ var r = [
 		page: "{{page}}",
 		cursor: "{{cursor}}"
 	}[u];
-	v !== void 0 && !_.includes(v) && f(t, `${a}.query`, `"${n}" pages by ${u} but never uses ${v}, so every page resolves to the first one`, `Put ${v} in the query (or the path) this endpoint sends`);
-}, v = (e, t, n) => {
-	let r = `endpoints.write.${t}`;
-	if (!o(n)) {
-		d(e, r, "A write endpoint must be an object", "It declares at least a method and a path");
+	v !== void 0 && !_.includes(v) && f(n, `${o}.query`, `"${r}" pages by ${u} but never uses ${v}, so every page resolves to the first one`, `Put ${v} in the query (or the path) this endpoint sends`);
+}, v = (t, n, r) => {
+	let i = `endpoints.write.${n}`;
+	if (!e(r)) {
+		d(t, i, "A write endpoint must be an object", "It declares at least a method and a path");
 		return;
 	}
-	h(e, n, r, "write"), m(e, n.method, `${r}.method`, !0), p(e, n.query, `${r}.query`, "write"), p(e, n.headers, `${r}.headers`, "write"), n.bodyPath !== void 0 && typeof n.bodyPath != "string" && d(e, `${r}.bodyPath`, "Must be a string", "It names where to nest the values, e.g. \"data\"");
-}, y = (e, t, n) => {
-	if (!o(t)) {
-		d(e, "endpoints", "A connector must declare its endpoints", "At least one read endpoint, usually \"list\"");
+	h(t, r, i, "write"), m(t, r.method, `${i}.method`, !0), p(t, r.query, `${i}.query`, "write"), p(t, r.headers, `${i}.headers`, "write"), r.bodyPath !== void 0 && typeof r.bodyPath != "string" && d(t, `${i}.bodyPath`, "Must be a string", "It names where to nest the values, e.g. \"data\"");
+}, y = (t, n, r) => {
+	if (!e(n)) {
+		d(t, "endpoints", "A connector must declare its endpoints", "At least one read endpoint, usually \"list\"");
 		return;
 	}
-	if (!o(t.read) || Object.keys(t.read).length === 0) d(e, "endpoints.read", "A connector needs at least one read endpoint", "Name it \"list\" — that is the one a provider element addresses when it names none");
-	else for (let [r, i] of Object.entries(t.read)) _(e, r, i, n);
-	if (t.write !== void 0) {
-		if (!o(t.write)) {
-			d(e, "endpoints.write", "Must be an object of endpoints keyed by name", "Omit it for a read-only connector");
+	if (!e(n.read) || Object.keys(n.read).length === 0) d(t, "endpoints.read", "A connector needs at least one read endpoint", "Name it \"list\" — that is the one a provider element addresses when it names none");
+	else for (let [e, i] of Object.entries(n.read)) _(t, e, i, r);
+	if (n.write !== void 0) {
+		if (!e(n.write)) {
+			d(t, "endpoints.write", "Must be an object of endpoints keyed by name", "Omit it for a read-only connector");
 			return;
 		}
-		for (let [n, r] of Object.entries(t.write)) v(e, n, r);
+		for (let [e, r] of Object.entries(n.write)) v(t, e, r);
 	}
-}, b = (e, t) => {
-	if (t !== void 0) {
-		if (!o(t)) {
-			d(e, "auth", "Must be an object", "Shape: { in, name, value }");
+}, b = (t, n) => {
+	if (n !== void 0) {
+		if (!e(n)) {
+			d(t, "auth", "Must be an object", "Shape: { in, name, value }");
 			return;
 		}
-		if (t.in !== "header" && t.in !== "query" && d(e, "auth.in", "Auth travels in a header or a query parameter", "One of header, query"), s(t.name) || d(e, "auth.name", "Auth needs the name it is sent under", "e.g. \"Authorization\" for a bearer token"), typeof t.value != "string") {
-			d(e, "auth.value", "Must be a string", "A template, e.g. \"Bearer {{credential.token}}\"");
+		if (n.in !== "header" && n.in !== "query" && d(t, "auth.in", "Auth travels in a header or a query parameter", "One of header, query"), s(n.name) || d(t, "auth.name", "Auth needs the name it is sent under", "e.g. \"Authorization\" for a bearer token"), typeof n.value != "string") {
+			d(t, "auth.value", "Must be a string", "A template, e.g. \"Bearer {{credential.token}}\"");
 			return;
 		}
-		e.templates.push({
+		t.templates.push({
 			path: "auth.value",
-			value: t.value,
+			value: n.value,
 			scope: "request"
 		});
 	}
 }, x = (e, t) => {
 	let n = p(e, t, "operators", "filter");
 	if (n) for (let [t, r] of Object.entries(n)) typeof r == "string" && !r.includes("=") && d(e, `operators.${t}`, `Operator "${t}" renders no "key=value" pair, so a filter using it is dropped`, "Write the full query entry, e.g. \"filters[{{field}}][$eq]={{value}}\"");
-}, S = (e, t) => {
-	if (t !== void 0) {
-		if (!o(t)) {
-			d(e, "fields", "Must be an object of field name → type", `Types: ${i.join(", ")}`);
+}, S = (t, n) => {
+	if (n !== void 0) {
+		if (!e(n)) {
+			d(t, "fields", "Must be an object of field name → type", `Types: ${a.join(", ")}`);
 			return;
 		}
-		for (let [n, r] of Object.entries(t)) (typeof r != "string" || !i.includes(r)) && d(e, `fields.${n}`, `"${c(r)}" is not a field type`, `One of ${i.join(", ")}`);
+		for (let [e, r] of Object.entries(n)) (typeof r != "string" || !a.includes(r)) && d(t, `fields.${e}`, `"${c(r)}" is not a field type`, `One of ${a.join(", ")}`);
 	}
 }, C = (e, t) => {
-	let r = !1;
-	for (let t of e.templates) for (let i of l(t.value)) i.startsWith("credential.") && (r = !0), u(i, t.scope) || f(e, t.path, `{{${i}}} is not a value the engine binds here, so it renders empty`, `Tokens available in this position: ${n.filter((e) => e.scopes.includes(t.scope)).map((e) => e.value).join(", ")}`);
-	if (r && !s(t)) {
+	let n = !1;
+	for (let t of e.templates) for (let i of l(t.value)) i.startsWith("credential.") && (n = !0), u(i, t.scope) || f(e, t.path, `{{${i}}} is not a value the engine binds here, so it renders empty`, `Tokens available in this position: ${r.filter((e) => e.scopes.includes(t.scope)).map((e) => e.value).join(", ")}`);
+	if (n && !s(t)) {
 		f(e, "credential", "This manifest reads {{credential.…}} but names no credential, so every request goes unauthenticated", "The connector still saves. Ask the space owner to create the credential and attach it — the secret is never part of the manifest.");
 		return;
 	}
-	!r && s(t) && f(e, "credential", "A credential is attached but no template reads {{credential.…}}, so it is never sent", "Reference it where the provider expects it, e.g. auth.value = \"Bearer {{credential.token}}\"");
-}, w = (e) => {
-	let t = {
+	!n && s(t) && f(e, "credential", "A credential is attached but no template reads {{credential.…}}, so it is never sent", "Reference it where the provider expects it, e.g. auth.value = \"Bearer {{credential.token}}\"");
+}, w = (t) => {
+	let n = {
 		errors: [],
 		warnings: [],
 		templates: []
 	};
-	if (!o(e)) return {
+	if (!e(t)) return {
 		valid: !1,
 		errors: [{
 			path: "",
@@ -171,13 +172,13 @@ var r = [
 		}],
 		warnings: []
 	};
-	s(e.baseUrl) ? /^https?:\/\//.test(e.baseUrl) || d(t, "baseUrl", "Base URL must start with http:// or https://", "The engine resolves paths against it") : d(t, "baseUrl", "A connector needs a base URL", "The origin every endpoint path is appended to"), e.credential !== void 0 && typeof e.credential != "string" && d(t, "credential", "Must be the identifier of a stored credential", "The secret itself never goes here");
-	let n = g(t, e.pagination, "pagination");
-	return b(t, e.auth), p(t, e.headers, "headers", "request"), y(t, e.endpoints, n), x(t, e.operators), S(t, e.fields), e.media !== void 0 && (o(e.media) ? e.media.baseUrl !== void 0 && !s(e.media.baseUrl) && d(t, "media.baseUrl", "Must be a non-empty string", "The origin relative media paths are rebased onto") : d(t, "media", "Must be an object", "Shape: { baseUrl }")), e.projection !== void 0 && e.projection !== "full" && d(t, "projection", "The only projection is \"full\"", "Omit it to send only the paths the page binds"), C(t, e.credential), {
-		valid: t.errors.length === 0,
-		errors: t.errors,
-		warnings: t.warnings
+	s(t.baseUrl) ? /^https?:\/\//.test(t.baseUrl) || d(n, "baseUrl", "Base URL must start with http:// or https://", "The engine resolves paths against it") : d(n, "baseUrl", "A connector needs a base URL", "The origin every endpoint path is appended to"), t.credential !== void 0 && typeof t.credential != "string" && d(n, "credential", "Must be the identifier of a stored credential", "The secret itself never goes here");
+	let r = g(n, t.pagination, "pagination");
+	return b(n, t.auth), p(n, t.headers, "headers", "request"), y(n, t.endpoints, r), x(n, t.operators), S(n, t.fields), t.media !== void 0 && (e(t.media) ? t.media.baseUrl !== void 0 && !s(t.media.baseUrl) && d(n, "media.baseUrl", "Must be a non-empty string", "The origin relative media paths are rebased onto") : d(n, "media", "Must be an object", "Shape: { baseUrl }")), t.projection !== void 0 && t.projection !== "full" && d(n, "projection", "The only projection is \"full\"", "Omit it to send only the paths the page binds"), C(n, t.credential), {
+		valid: n.errors.length === 0,
+		errors: n.errors,
+		warnings: n.warnings
 	};
-};
+}, T = (e) => w(e).valid;
 //#endregion
-export { w as validateConnectorManifest };
+export { T as isConnectorManifestDraft, w as validateConnectorManifest };

package/dist/dataSource/computed.mjs

@@ -1,45 +1,41 @@
-import { processTwigValue as e } from "../helpers/twigWrapper/processTwig/processTwig.mjs";
-import t from "@plitzi/plitzi-ui/utils/deepEqual";
+import { isRecord as e } from "../helpers/isRecord.mjs";
+import { processTwigValue as t } from "../helpers/twigWrapper/processTwig/processTwig.mjs";
+import { COMPUTED_GLOBALS as n } from "./globalSources.mjs";
+import r from "@plitzi/plitzi-ui/utils/deepEqual";
 //#region src/dataSource/computed.ts
-var n = (n, r, i) => {
-	let a = {}, o = i !== void 0 && Object.keys(i).length === Object.keys(n).length;
-	for (let [s, c] of Object.entries(n)) {
-		let n = e(c, {
-			...r,
+var i = (e, n, i) => {
+	let a = {}, o = i !== void 0 && Object.keys(i).length === Object.keys(e).length;
+	for (let [s, c] of Object.entries(e)) {
+		let e = t(c, {
+			...n,
 			computed: { ...a }
-		}), l = i?.[s], u = i !== void 0 && Object.hasOwn(i, s) && (l === n || t(l, n));
-		a[s] = u ? l : n, o &&= u;
+		}), l = i?.[s], u = i !== void 0 && Object.hasOwn(i, s) && (l === e || r(l, e));
+		a[s] = u ? l : e, o &&= u;
 	}
 	return o && i ? i : a;
-}, r = (e) => typeof e == "object" && !!e, i = (e) => r(e) && Object.values(e).every((e) => typeof e == "string"), a = [
-	"variables",
-	"navigation",
-	"auth",
-	"host",
-	"theme"
-], o = (e, t, n) => {
-	let a = r(t) ? t : {};
-	return i(n) ? {
-		...e,
-		state: a,
-		computed: c(n, e, a)
+}, a = (t) => e(t) && Object.values(t).every((e) => typeof e == "string"), o = (t, n, r) => {
+	let i = e(n) ? n : {};
+	return a(r) ? {
+		...t,
+		state: i,
+		computed: c(r, t, i)
 	} : {
-		...e,
-		state: a
+		...t,
+		state: i
 	};
 }, s, c = (e, t, r) => {
-	let i = a.map((e) => t[e]);
-	if (s?.definitions === e && s.state === r && s.globals.every((e, t) => e === i[t])) return s.computed;
-	let o = n(e, {
-		...Object.fromEntries(a.map((e, t) => [e, i[t]])),
+	let a = n.map((e) => t[e]);
+	if (s?.definitions === e && s.state === r && s.globals.every((e, t) => e === a[t])) return s.computed;
+	let o = i(e, {
+		...Object.fromEntries(n.map((e, t) => [e, a[t]])),
 		state: r
 	}, s?.definitions === e ? s.computed : void 0);
 	return s = {
 		definitions: e,
 		state: r,
-		globals: i,
+		globals: a,
 		computed: o
 	}, o;
 };
 //#endregion
-export { n as evaluateComputed, o as liveSources };
+export { i as evaluateComputed, o as liveSources };

package/dist/dataSource/globalSources.d.ts

@@ -0,0 +1,15 @@
+/**
+ * The data sources that belong to nobody: published once for the whole space by `GlobalSources`, and named as
+ * themselves rather than as `<type>_<id>` — which is what tells them apart from a source an element publishes.
+ *
+ * One list for everything that has to know them — the runtime evaluating computed values, the authoring validator
+ * refusing a binding to a name nothing answers to, an element that may not take one of these names as its id — so a
+ * new global is a global everywhere at once.
+ */
+export declare const GLOBAL_SOURCES: readonly ["variables", "navigation", "auth", "state", "host", "theme", "flags", "computed"];
+export type GlobalSource = (typeof GLOBAL_SOURCES)[number];
+/**
+ * What a computed value is evaluated over: every global but `state`, which a flow hands it live, and `computed`, which
+ * is what is being evaluated.
+ */
+export declare const COMPUTED_GLOBALS: ("auth" | "navigation" | "flags" | "variables" | "theme" | "host")[];

package/dist/dataSource/globalSources.mjs

@@ -0,0 +1,13 @@
+//#region src/dataSource/globalSources.ts
+var e = [
+	"variables",
+	"navigation",
+	"auth",
+	"state",
+	"host",
+	"theme",
+	"flags",
+	"computed"
+], t = e.filter((e) => e !== "state" && e !== "computed");
+//#endregion
+export { t as COMPUTED_GLOBALS, e as GLOBAL_SOURCES };

package/dist/dataSource/index.d.ts

@@ -1,6 +1,8 @@
 export * from './hooks';
 export * from './helpers';
 export { evaluateComputed, liveSources } from './computed';
+export { GLOBAL_SOURCES, COMPUTED_GLOBALS } from './globalSources';
+export type { GlobalSource } from './globalSources';
 export { default as getBindingsDetails } from './getBindingsDetails';
 export { default as resolveVariables } from './resolveVariables';
 export type { VariableScope } from './resolveVariables';

package/dist/dataSource/index.mjs

@@ -1,7 +1,8 @@
-import { evaluateComputed as e, liveSources as t } from "./computed.mjs";
-import n, { utilityOptions as r } from "./utility/index.mjs";
-import i from "./getBindingsDetails.mjs";
-import a from "./helpers/getSourceName.mjs";
-import o from "./hooks/useRegisterSource.mjs";
-import s from "./resolveVariables.mjs";
-export { e as evaluateComputed, i as getBindingsDetails, a as getSourceName, t as liveSources, s as resolveVariables, o as useRegisterSource, n as utility, r as utilityOptions };
+import { COMPUTED_GLOBALS as e, GLOBAL_SOURCES as t } from "./globalSources.mjs";
+import { evaluateComputed as n, liveSources as r } from "./computed.mjs";
+import i, { utilityOptions as a } from "./utility/index.mjs";
+import o from "./getBindingsDetails.mjs";
+import s from "./helpers/getSourceName.mjs";
+import c from "./hooks/useRegisterSource.mjs";
+import l from "./resolveVariables.mjs";
+export { e as COMPUTED_GLOBALS, t as GLOBAL_SOURCES, n as evaluateComputed, o as getBindingsDetails, s as getSourceName, r as liveSources, l as resolveVariables, c as useRegisterSource, i as utility, a as utilityOptions };

package/dist/devTools/utils/PlitziConsole.d.ts

@@ -17,9 +17,18 @@ declare class PlitziConsole {
     listeningParams?: {
         category: Log['category'];
     };
+    recentLimit: number;
     constructor(callback?: CallbackInternal, pendingLimit?: number);
     setCallback(callback?: CallbackInternal): void;
     processPendingLogs(): void;
+    /**
+     * Every log as it is written, beside whatever panel takes them — what a reader in text (the agent inspector) keeps
+     * for itself. Only in a browser, as everything kept here is. `replay` hands it the last ones written first: the
+     * flows a page runs as it loads end before anything mounted later could have been listening.
+     */
+    addListener(listener: (log: Log) => void, { replay }?: {
+        replay?: boolean;
+    }): () => void;
     setCallbackAddProvider(callback?: CallbackAddProvider): void;
     setCallbackRemoveProvider(callback?: CallbackRemoveProvider): void;
     flush(hard?: boolean): void;

package/dist/devTools/utils/PlitziConsole.mjs

@@ -12,6 +12,9 @@ var e = (e, t = 2) => String(e).padStart(t, "0"), t = (t) => `${e(t.getHours())}
 	listeningParams;
 	#e = [];
 	#t = !1;
+	#n = /* @__PURE__ */ new Set();
+	#r = [];
+	recentLimit = 200;
 	constructor(e, t = 100) {
 		this.callbackInternal = e, this.pendingLimit = t;
 	}
@@ -24,6 +27,12 @@ var e = (e, t = 2) => String(e).padStart(t, "0"), t = (t) => `${e(t.getHours())}
 			this.pendingLogs = [];
 		}
 	}
+	addListener(e, { replay: t = !1 } = {}) {
+		if (t) for (let t of this.#r) e(t);
+		return this.#n.add(e), () => {
+			this.#n.delete(e);
+		};
+	}
 	setCallbackAddProvider(e) {
 		this.callbackAddProvider = e;
 	}
@@ -33,9 +42,20 @@ var e = (e, t = 2) => String(e).padStart(t, "0"), t = (t) => `${e(t.getHours())}
 	flush(e = !1) {
 		this.logsListened = [], e && (this.pendingLogs = []);
 	}
-	#n(e, t, r, i) {
+	#i(e, t, r, i) {
 		if (!this.callbackInternal && !n()) return;
 		let a = this.getTime(!0);
+		if (n()) {
+			let n = {
+				logType: e,
+				category: t,
+				message: r,
+				params: i,
+				time: a
+			};
+			this.#r.push(n), this.#r.length > this.recentLimit && this.#r.shift();
+			for (let e of this.#n) e(n);
+		}
 		if (!this.callbackInternal) {
 			this.pendingLogs.push({
 				logType: e,
@@ -58,9 +78,9 @@ var e = (e, t = 2) => String(e).padStart(t, "0"), t = (t) => `${e(t.getHours())}
 			message: r,
 			params: i,
 			time: a
-		}), this.#r()), this.logsListened.length > this.logsListenedLimit && this.logsListened.shift();
+		}), this.#a()), this.logsListened.length > this.logsListenedLimit && this.logsListened.shift();
 	}
-	#r() {
+	#a() {
 		this.#t || (this.#t = !0, queueMicrotask(() => {
 			this.#t = !1;
 			let e = this.callbackInternal, t = this.#e;
@@ -78,16 +98,16 @@ var e = (e, t = 2) => String(e).padStart(t, "0"), t = (t) => `${e(t.getHours())}
 		return e ? t(n) : n;
 	}
 	info(e, t, n) {
-		this.#n("info", e, t, n);
+		this.#i("info", e, t, n);
 	}
 	warning(e, t, n) {
-		this.#n("warning", e, t, n);
+		this.#i("warning", e, t, n);
 	}
 	danger(e, t, n) {
-		this.#n("danger", e, t, n);
+		this.#i("danger", e, t, n);
 	}
 	success(e, t, n) {
-		this.#n("success", e, t, n);
+		this.#i("success", e, t, n);
 	}
 	begin(e) {
 		this.listening = !0, this.listeningParams = { category: e };

package/dist/flags/flagsCookie.d.ts

@@ -0,0 +1,26 @@
+/**
+ * The cookie a tester forces flags with — the `qa` layer, the strongest there is.
+ *
+ * A cookie and not web storage for the reason the theme is one: the server renders with it, so the page a tester
+ * forced a flag on arrives drawn that way instead of being swapped after hydration. Named with the port, like the
+ * debug preference, because a cookie's scope has none (see `debugCookieName`).
+ *
+ * It is a preference that only means something where debugging is authorized. Everywhere else both halves ignore it
+ * — a published site's visitors could otherwise turn on any feature that is still behind a flag.
+ */
+export declare const flagsCookieName: (host: string | undefined) => string;
+/**
+ * `newCheckout:1,legacyNav:0` — a flag name and its value, nothing else survives the parse. The cookie's format, and
+ * any other place flags are written as one line of text (an environment variable).
+ */
+export declare const parseFlagList: (value: string | undefined) => Record<string, boolean>;
+export declare const serializeFlagList: (forced: Record<string, boolean>) => string;
+/** What is forced once one flag is forced to `value` — or, with `undefined`, once it is no longer forced at all. */
+export declare const withForcedFlag: (forced: Record<string, boolean>, name: string, value: boolean | undefined) => Record<string, boolean>;
+/** The flags a tester forced, from a `Cookie` header or `document.cookie`. */
+export declare const forcedFlagsFromCookies: (cookies: string | undefined, host: string | undefined) => Record<string, boolean>;
+/**
+ * Keeps what a tester forced for the next page this browser asks for — every page of the site, so a forced feature is
+ * on wherever the tester goes, and the server draws it that way. Nothing forced removes the cookie.
+ */
+export declare const writeForcedFlags: (host: string, forced: Record<string, boolean>) => void;

package/dist/flags/flagsCookie.mjs

@@ -0,0 +1,20 @@
+import { cookieFromHeader as e } from "../helpers/cookies.mjs";
+import { isFlagName as t } from "./schemaFlag.mjs";
+//#region src/flags/flagsCookie.ts
+var n = (e) => {
+	let t = e?.split(":")[1];
+	return t ? `plitzi_flags_${t}` : "plitzi_flags";
+}, r = (e) => e ? Object.fromEntries(e.split(",").map((e) => e.split(":")).filter(([e, n]) => t(e) && (n === "1" || n === "0")).map(([e, t]) => [e, t === "1"])) : {}, i = (e) => Object.entries(e).filter(([e]) => t(e)).map(([e, t]) => `${e}:${t ? "1" : "0"}`).join(","), a = (e, t, n) => {
+	let { [t]: r, ...i } = e;
+	return n === void 0 ? i : {
+		...i,
+		[t]: n
+	};
+}, o = (t, i) => r(e(t, n(i))), s = (e, t) => {
+	let r = n(e), a = i(t);
+	try {
+		document.cookie = a ? `${r}=${encodeURIComponent(a)};path=/;SameSite=Lax` : `${r}=;path=/;max-age=0;SameSite=Lax`;
+	} catch {}
+};
+//#endregion
+export { n as flagsCookieName, o as forcedFlagsFromCookies, r as parseFlagList, i as serializeFlagList, a as withForcedFlag, s as writeForcedFlags };

package/dist/flags/index.d.ts

@@ -0,0 +1,3 @@
+export * from './schemaFlag';
+export * from './resolveFlags';
+export * from './flagsCookie';

package/dist/flags/index.mjs

@@ -0,0 +1,4 @@
+import { FLAG_GATE_PATTERN as e, FLAG_NAME_PATTERN as t, isFlagName as n, isSchemaFlag as r } from "./schemaFlag.mjs";
+import { flagsCookieName as i, forcedFlagsFromCookies as a, parseFlagList as o, serializeFlagList as s, withForcedFlag as c, writeForcedFlags as l } from "./flagsCookie.mjs";
+import { FLAG_LAYERS as u, flagUserFromSSR as d, flagValues as f, hasConditions as p, passesFlagGate as m, resolveFlags as h, undeclaredFlagOverrides as g } from "./resolveFlags.mjs";
+export { e as FLAG_GATE_PATTERN, u as FLAG_LAYERS, t as FLAG_NAME_PATTERN, d as flagUserFromSSR, f as flagValues, i as flagsCookieName, a as forcedFlagsFromCookies, p as hasConditions, n as isFlagName, r as isSchemaFlag, o as parseFlagList, m as passesFlagGate, h as resolveFlags, s as serializeFlagList, g as undeclaredFlagOverrides, c as withForcedFlag, l as writeForcedFlags };

package/dist/flags/resolveFlags.d.ts

@@ -0,0 +1,60 @@
+import { VariableScope } from '../dataSource/resolveVariables';
+import { RuleGroup } from '../helpers/ruleEvaluator';
+import { Schema, SSRUser } from '../types';
+/**
+ * Who decided a flag, weakest first: the space's own declaration, then the server rendering it, then the SDK
+ * embedding it, then a tester with the dev tools open. Each layer only ever answers for a flag the space declares.
+ */
+export declare const FLAG_LAYERS: readonly ["space", "server", "sdk", "qa"];
+export type FlagLayer = (typeof FLAG_LAYERS)[number];
+export type FlagOverrideLayer = Exclude<FlagLayer, 'space'>;
+/** What each layer above the space says, by flag name. A layer that says nothing about a flag leaves it alone. */
+export type FlagOverrides = Partial<Record<FlagOverrideLayer, Record<string, boolean>>>;
+/** The visitor, as a flag's rule sees them: never a token, never anything the rules have no business matching on. */
+export type FlagUser = {
+    authenticated: boolean;
+    email?: string;
+    username?: string;
+    roles?: string[];
+};
+/** The visitor a server resolved, as a flag's rule sees them — the same fields the browser's rules see. */
+export declare const flagUserFromSSR: (user: Pick<SSRUser, "email" | "username" | "roles"> | undefined) => FlagUser;
+/** What a flag's rules are matched against: everything a variable's are, and who is visiting. */
+export type FlagScope = VariableScope & {
+    user?: FlagUser;
+};
+/**
+ * One flag's answer, and where it came from: the layer that decided, and — when the space did — the index of the
+ * rule that matched, absent when it was the flag's own default. What the dev tools show beside the value.
+ */
+export type FlagResolution = {
+    value: boolean;
+    layer: FlagLayer;
+    rule?: number;
+};
+/**
+ * Whether a rule says anything at all. A rule just added in the builder has an empty group, and the evaluator reads
+ * an empty `and` as true — so an unfinished rule would turn the flag the moment it was added. It is skipped instead,
+ * and the linter says it is there.
+ */
+export declare const hasConditions: (when: unknown) => when is RuleGroup;
+/**
+ * Every flag the space declares, resolved for this render: `{ newCheckout: { value: true, layer: 'space', rule: 0 } }`.
+ *
+ * The space answers first — the first of a flag's rules that matches, or its default — and each layer above it may
+ * replace that answer, in order. An override for a flag the space does not declare is not an answer to anything and
+ * is dropped here; {@link undeclaredFlagOverrides} names those so whoever set one can be told.
+ */
+export declare const resolveFlags: (declared: Schema["flags"], scope?: FlagScope, overrides?: FlagOverrides) => Record<string, FlagResolution>;
+/** The answers alone, as the `flags` source publishes them: `{ newCheckout: true }`. */
+export declare const flagValues: (resolutions: Record<string, FlagResolution>) => Record<string, boolean>;
+/** Overrides naming a flag the space does not declare — each one a typo or a flag removed from the space. */
+export declare const undeclaredFlagOverrides: (declared: Schema["flags"], overrides: FlagOverrides) => {
+    layer: FlagOverrideLayer;
+    name: string;
+}[];
+/** Whether a flag gate lets its element exist, given the flags as they resolved. An undeclared flag resolves off. */
+export declare const passesFlagGate: (gate: {
+    name: string;
+    is: boolean;
+} | undefined, values: Record<string, boolean>) => boolean;